| 2011-02-04 20:46:19 |
Robert Smith |
bug |
|
|
added bug |
| 2011-02-04 20:46:19 |
Robert Smith |
attachment added |
|
copy-paste "patch", take out the IN-PACKAGE form https://bugs.launchpad.net/bugs/713343/+attachment/1830186/+files/isqrt.lisp |
|
| 2011-02-04 20:50:41 |
Robert Smith |
description |
1. A description of what you do, what happens, and what you expected to happen.
a. Compute ISQRT for small and large integers (between 0 and 10e7.
b. ISQRT successfully computes it. See these benchmarks.
http://paste.lisp.org/display/119381,1/raw
http://paste.lisp.org/display/119381,2/raw
c. ISQRT should compute it even faster!
2. A complete repeatable test-case.
A faster version provided here (also attached):
https://bitbucket.org/tarballs_are_good/numericl/src/d6284092b3ec/src/integer/isqrt.lisp
The benchmark used was [modulo the value in DOTIMES and argument to ITEST:
(declaim (optimize (speed 3) (debug 0) (safety 0)))
(defparameter dum-dum-pop 0)
(defun itest (n ts &aux m1 m2)
(progn
(print 'isqrt) (terpri)
(time (dotimes (i ts)
(setq m1 (isqrt n))))
(print 'my-isqrt) (terpri)
(time (dotimes (i ts)
(setq m2 (isqrt-fast n))))
(print (list (integer-length m1) (integer-length m2)))))
(dotimes (i 3)
(setf dum-dum-pop (+ 7 (expt 11 (expt 10 i))))
(format t "===================================================~%")
(format t "x = 7 + 11^(10^~D); computed 10000000 times" i)
(itest dum-dum-pop 1000000)
(format t "~%===================================================~%"))
3. SBCL version as reported by "sbcl --version".
SBCL 1.0.44
Installed from source.
4. Output from uname -a.
Linux TheAmbiguousCase 2.6.35-25-generic #44-Ubuntu SMP Fri Jan 21 17:40:44 UTC 2011 x86_64 GNU/Linux
5. *FEATURES*.
(:QUICKLISP :SB-BSD-SOCKETS-ADDRINFO :ASDF2 :ASDF :ANSI-CL :COMMON-LISP :SBCL
:SB-DOC :SB-TEST :SB-LDB :SB-PACKAGE-LOCKS :SB-UNICODE :SB-EVAL
:SB-SOURCE-LOCATIONS :IEEE-FLOATING-POINT :X86-64 :UNIX :ELF :LINUX :SB-THREAD
:LARGEFILE :GENCGC :STACK-GROWS-DOWNWARD-NOT-UPWARD :C-STACK-IS-CONTROL-STACK
:LINKAGE-TABLE :COMPARE-AND-SWAP-VOPS :UNWIND-TO-FRAME-AND-CALL-VOP
:RAW-INSTANCE-INIT-VOPS :STACK-ALLOCATABLE-CLOSURES :STACK-ALLOCATABLE-VECTORS
:STACK-ALLOCATABLE-LISTS :STACK-ALLOCATABLE-FIXED-OBJECTS :ALIEN-CALLBACKS
:CYCLE-COUNTER :COMPLEX-FLOAT-VOPS :FLOAT-EQL-VOPS :INLINE-CONSTANTS
:MEMORY-BARRIER-VOPS :OS-PROVIDES-DLOPEN :OS-PROVIDES-DLADDR
:OS-PROVIDES-PUTWC :OS-PROVIDES-SUSECONDS-T :OS-PROVIDES-GETPROTOBY-R
:OS-PROVIDES-POLL) |
1. A description of what you do, what happens, and what you expected to happen.
a. Compute ISQRT for small and large integers (between 0 and 10e7.
b. ISQRT successfully computes it. See these benchmarks.
http://paste.lisp.org/display/119381,1/raw
http://paste.lisp.org/display/119381,2/raw
c. ISQRT should compute it even faster!
2. A complete repeatable test-case.
A faster version provided here (also attached):
https://bitbucket.org/tarballs_are_good/numericl/src/d6284092b3ec/src/integer/isqrt.lisp
The benchmark used was [modulo the value in DOTIMES and argument to ITEST:
(declaim (optimize (speed 3) (debug 0) (safety 0)))
(defparameter dum-dum-pop 0)
(defun itest (n ts &aux m1 m2)
(progn
(print 'isqrt) (terpri)
(time (dotimes (i ts)
(setq m1 (isqrt n))))
(print 'my-isqrt) (terpri)
(time (dotimes (i ts)
(setq m2 (isqrt-fast n))))
(print (list (integer-length m1) (integer-length m2)))))
(dotimes (i 3)
(setf dum-dum-pop (+ 7 (expt 11 (expt 10 i))))
(format t "===================================================~%")
(format t "x = 7 + 11^(10^~D); computed 10000000 times" i)
(itest dum-dum-pop 1000000)
(format t "~%===================================================~%"))
3. SBCL version as reported by "sbcl --version".
SBCL 1.0.44
(Installed from source.)
4. Output from uname -a.
Linux TheAmbiguousCase 2.6.35-25-generic #44-Ubuntu SMP Fri Jan 21 17:40:44 UTC 2011 x86_64 GNU/Linux
5. *FEATURES*.
(:QUICKLISP :SB-BSD-SOCKETS-ADDRINFO :ASDF2 :ASDF :ANSI-CL :COMMON-LISP :SBCL
:SB-DOC :SB-TEST :SB-LDB :SB-PACKAGE-LOCKS :SB-UNICODE :SB-EVAL
:SB-SOURCE-LOCATIONS :IEEE-FLOATING-POINT :X86-64 :UNIX :ELF :LINUX :SB-THREAD
:LARGEFILE :GENCGC :STACK-GROWS-DOWNWARD-NOT-UPWARD :C-STACK-IS-CONTROL-STACK
:LINKAGE-TABLE :COMPARE-AND-SWAP-VOPS :UNWIND-TO-FRAME-AND-CALL-VOP
:RAW-INSTANCE-INIT-VOPS :STACK-ALLOCATABLE-CLOSURES :STACK-ALLOCATABLE-VECTORS
:STACK-ALLOCATABLE-LISTS :STACK-ALLOCATABLE-FIXED-OBJECTS :ALIEN-CALLBACKS
:CYCLE-COUNTER :COMPLEX-FLOAT-VOPS :FLOAT-EQL-VOPS :INLINE-CONSTANTS
:MEMORY-BARRIER-VOPS :OS-PROVIDES-DLOPEN :OS-PROVIDES-DLADDR
:OS-PROVIDES-PUTWC :OS-PROVIDES-SUSECONDS-T :OS-PROVIDES-GETPROTOBY-R
:OS-PROVIDES-POLL)
|
|
| 2011-02-04 20:50:41 |
Robert Smith |
tags |
enhancement |
enhancement integers numerics optimization speed |
|
| 2011-02-04 20:58:59 |
Robert Smith |
description |
1. A description of what you do, what happens, and what you expected to happen.
a. Compute ISQRT for small and large integers (between 0 and 10e7.
b. ISQRT successfully computes it. See these benchmarks.
http://paste.lisp.org/display/119381,1/raw
http://paste.lisp.org/display/119381,2/raw
c. ISQRT should compute it even faster!
2. A complete repeatable test-case.
A faster version provided here (also attached):
https://bitbucket.org/tarballs_are_good/numericl/src/d6284092b3ec/src/integer/isqrt.lisp
The benchmark used was [modulo the value in DOTIMES and argument to ITEST:
(declaim (optimize (speed 3) (debug 0) (safety 0)))
(defparameter dum-dum-pop 0)
(defun itest (n ts &aux m1 m2)
(progn
(print 'isqrt) (terpri)
(time (dotimes (i ts)
(setq m1 (isqrt n))))
(print 'my-isqrt) (terpri)
(time (dotimes (i ts)
(setq m2 (isqrt-fast n))))
(print (list (integer-length m1) (integer-length m2)))))
(dotimes (i 3)
(setf dum-dum-pop (+ 7 (expt 11 (expt 10 i))))
(format t "===================================================~%")
(format t "x = 7 + 11^(10^~D); computed 10000000 times" i)
(itest dum-dum-pop 1000000)
(format t "~%===================================================~%"))
3. SBCL version as reported by "sbcl --version".
SBCL 1.0.44
(Installed from source.)
4. Output from uname -a.
Linux TheAmbiguousCase 2.6.35-25-generic #44-Ubuntu SMP Fri Jan 21 17:40:44 UTC 2011 x86_64 GNU/Linux
5. *FEATURES*.
(:QUICKLISP :SB-BSD-SOCKETS-ADDRINFO :ASDF2 :ASDF :ANSI-CL :COMMON-LISP :SBCL
:SB-DOC :SB-TEST :SB-LDB :SB-PACKAGE-LOCKS :SB-UNICODE :SB-EVAL
:SB-SOURCE-LOCATIONS :IEEE-FLOATING-POINT :X86-64 :UNIX :ELF :LINUX :SB-THREAD
:LARGEFILE :GENCGC :STACK-GROWS-DOWNWARD-NOT-UPWARD :C-STACK-IS-CONTROL-STACK
:LINKAGE-TABLE :COMPARE-AND-SWAP-VOPS :UNWIND-TO-FRAME-AND-CALL-VOP
:RAW-INSTANCE-INIT-VOPS :STACK-ALLOCATABLE-CLOSURES :STACK-ALLOCATABLE-VECTORS
:STACK-ALLOCATABLE-LISTS :STACK-ALLOCATABLE-FIXED-OBJECTS :ALIEN-CALLBACKS
:CYCLE-COUNTER :COMPLEX-FLOAT-VOPS :FLOAT-EQL-VOPS :INLINE-CONSTANTS
:MEMORY-BARRIER-VOPS :OS-PROVIDES-DLOPEN :OS-PROVIDES-DLADDR
:OS-PROVIDES-PUTWC :OS-PROVIDES-SUSECONDS-T :OS-PROVIDES-GETPROTOBY-R
:OS-PROVIDES-POLL)
|
1. A description of what you do, what happens, and what you expected to happen.
===============================================================================
a. Compute ISQRT for small and large integers (between 0 and 10e7.
b. ISQRT successfully computes it. See these benchmarks.
http://paste.lisp.org/display/119381,1/raw
http://paste.lisp.org/display/119381,2/raw
c. ISQRT should compute it even faster!
2. A complete repeatable test-case.
===================================
A faster version provided here (also attached):
https://bitbucket.org/tarballs_are_good/numericl/src/d6284092b3ec/src/integer/isqrt.lisp
The benchmark used was [modulo the value in DOTIMES and argument to ITEST:
(declaim (optimize (speed 3) (debug 0) (safety 0)))
(defparameter dum-dum-pop 0)
(defun itest (n ts &aux m1 m2)
(progn
(print 'isqrt) (terpri)
(time (dotimes (i ts)
(setq m1 (isqrt n))))
(print 'my-isqrt) (terpri)
(time (dotimes (i ts)
(setq m2 (isqrt-fast n))))
(print (list (integer-length m1) (integer-length m2)))))
(dotimes (i 3)
(setf dum-dum-pop (+ 7 (expt 11 (expt 10 i))))
(format t "===================================================~%")
(format t "x = 7 + 11^(10^~D); computed 10000000 times" i)
(itest dum-dum-pop 1000000)
(format t "~%===================================================~%"))
3. SBCL version as reported by "sbcl --version".
================================================
SBCL 1.0.44
(Installed from source.)
4. Output from uname -a.
========================
Linux TheAmbiguousCase 2.6.35-25-generic #44-Ubuntu SMP Fri Jan 21 17:40:44 UTC 2011 x86_64 GNU/Linux
5. *FEATURES*.
==============
(:QUICKLISP :SB-BSD-SOCKETS-ADDRINFO :ASDF2 :ASDF :ANSI-CL :COMMON-LISP :SBCL
:SB-DOC :SB-TEST :SB-LDB :SB-PACKAGE-LOCKS :SB-UNICODE :SB-EVAL
:SB-SOURCE-LOCATIONS :IEEE-FLOATING-POINT :X86-64 :UNIX :ELF :LINUX :SB-THREAD
:LARGEFILE :GENCGC :STACK-GROWS-DOWNWARD-NOT-UPWARD :C-STACK-IS-CONTROL-STACK
:LINKAGE-TABLE :COMPARE-AND-SWAP-VOPS :UNWIND-TO-FRAME-AND-CALL-VOP
:RAW-INSTANCE-INIT-VOPS :STACK-ALLOCATABLE-CLOSURES :STACK-ALLOCATABLE-VECTORS
:STACK-ALLOCATABLE-LISTS :STACK-ALLOCATABLE-FIXED-OBJECTS :ALIEN-CALLBACKS
:CYCLE-COUNTER :COMPLEX-FLOAT-VOPS :FLOAT-EQL-VOPS :INLINE-CONSTANTS
:MEMORY-BARRIER-VOPS :OS-PROVIDES-DLOPEN :OS-PROVIDES-DLADDR
:OS-PROVIDES-PUTWC :OS-PROVIDES-SUSECONDS-T :OS-PROVIDES-GETPROTOBY-R
:OS-PROVIDES-POLL)
|
|
| 2011-02-04 21:00:24 |
Robert Smith |
description |
1. A description of what you do, what happens, and what you expected to happen.
===============================================================================
a. Compute ISQRT for small and large integers (between 0 and 10e7.
b. ISQRT successfully computes it. See these benchmarks.
http://paste.lisp.org/display/119381,1/raw
http://paste.lisp.org/display/119381,2/raw
c. ISQRT should compute it even faster!
2. A complete repeatable test-case.
===================================
A faster version provided here (also attached):
https://bitbucket.org/tarballs_are_good/numericl/src/d6284092b3ec/src/integer/isqrt.lisp
The benchmark used was [modulo the value in DOTIMES and argument to ITEST:
(declaim (optimize (speed 3) (debug 0) (safety 0)))
(defparameter dum-dum-pop 0)
(defun itest (n ts &aux m1 m2)
(progn
(print 'isqrt) (terpri)
(time (dotimes (i ts)
(setq m1 (isqrt n))))
(print 'my-isqrt) (terpri)
(time (dotimes (i ts)
(setq m2 (isqrt-fast n))))
(print (list (integer-length m1) (integer-length m2)))))
(dotimes (i 3)
(setf dum-dum-pop (+ 7 (expt 11 (expt 10 i))))
(format t "===================================================~%")
(format t "x = 7 + 11^(10^~D); computed 10000000 times" i)
(itest dum-dum-pop 1000000)
(format t "~%===================================================~%"))
3. SBCL version as reported by "sbcl --version".
================================================
SBCL 1.0.44
(Installed from source.)
4. Output from uname -a.
========================
Linux TheAmbiguousCase 2.6.35-25-generic #44-Ubuntu SMP Fri Jan 21 17:40:44 UTC 2011 x86_64 GNU/Linux
5. *FEATURES*.
==============
(:QUICKLISP :SB-BSD-SOCKETS-ADDRINFO :ASDF2 :ASDF :ANSI-CL :COMMON-LISP :SBCL
:SB-DOC :SB-TEST :SB-LDB :SB-PACKAGE-LOCKS :SB-UNICODE :SB-EVAL
:SB-SOURCE-LOCATIONS :IEEE-FLOATING-POINT :X86-64 :UNIX :ELF :LINUX :SB-THREAD
:LARGEFILE :GENCGC :STACK-GROWS-DOWNWARD-NOT-UPWARD :C-STACK-IS-CONTROL-STACK
:LINKAGE-TABLE :COMPARE-AND-SWAP-VOPS :UNWIND-TO-FRAME-AND-CALL-VOP
:RAW-INSTANCE-INIT-VOPS :STACK-ALLOCATABLE-CLOSURES :STACK-ALLOCATABLE-VECTORS
:STACK-ALLOCATABLE-LISTS :STACK-ALLOCATABLE-FIXED-OBJECTS :ALIEN-CALLBACKS
:CYCLE-COUNTER :COMPLEX-FLOAT-VOPS :FLOAT-EQL-VOPS :INLINE-CONSTANTS
:MEMORY-BARRIER-VOPS :OS-PROVIDES-DLOPEN :OS-PROVIDES-DLADDR
:OS-PROVIDES-PUTWC :OS-PROVIDES-SUSECONDS-T :OS-PROVIDES-GETPROTOBY-R
:OS-PROVIDES-POLL)
|
1. Describe what you do, what happens, and what you expected
============================================================
a. Compute ISQRT for small and large integers (between 0 and 10e7.
b. ISQRT successfully computes it. See these benchmarks.
http://paste.lisp.org/display/119381,1/raw
http://paste.lisp.org/display/119381,2/raw
c. ISQRT should compute it even faster!
2. A complete repeatable test-case
==================================
A faster version provided here (also attached):
https://bitbucket.org/tarballs_are_good/numericl/src/d6284092b3ec/src/integer/isqrt.lisp
The benchmark used was [modulo the value in DOTIMES and argument to ITEST:
(declaim (optimize (speed 3) (debug 0) (safety 0)))
(defparameter dum-dum-pop 0)
(defun itest (n ts &aux m1 m2)
(progn
(print 'isqrt) (terpri)
(time (dotimes (i ts)
(setq m1 (isqrt n))))
(print 'my-isqrt) (terpri)
(time (dotimes (i ts)
(setq m2 (isqrt-fast n))))
(print (list (integer-length m1) (integer-length m2)))))
(dotimes (i 3)
(setf dum-dum-pop (+ 7 (expt 11 (expt 10 i))))
(format t "===================================================~%")
(format t "x = 7 + 11^(10^~D); computed 10000000 times" i)
(itest dum-dum-pop 1000000)
(format t "~%===================================================~%"))
3. SBCL version as reported by "sbcl --version"
===============================================
SBCL 1.0.44
(Installed from source.)
4. Output from uname -a
=======================
Linux TheAmbiguousCase 2.6.35-25-generic #44-Ubuntu SMP Fri Jan 21 17:40:44 UTC 2011 x86_64 GNU/Linux
5. *FEATURES*.
==============
(:QUICKLISP :SB-BSD-SOCKETS-ADDRINFO :ASDF2 :ASDF :ANSI-CL :COMMON-LISP :SBCL
:SB-DOC :SB-TEST :SB-LDB :SB-PACKAGE-LOCKS :SB-UNICODE :SB-EVAL
:SB-SOURCE-LOCATIONS :IEEE-FLOATING-POINT :X86-64 :UNIX :ELF :LINUX :SB-THREAD
:LARGEFILE :GENCGC :STACK-GROWS-DOWNWARD-NOT-UPWARD :C-STACK-IS-CONTROL-STACK
:LINKAGE-TABLE :COMPARE-AND-SWAP-VOPS :UNWIND-TO-FRAME-AND-CALL-VOP
:RAW-INSTANCE-INIT-VOPS :STACK-ALLOCATABLE-CLOSURES :STACK-ALLOCATABLE-VECTORS
:STACK-ALLOCATABLE-LISTS :STACK-ALLOCATABLE-FIXED-OBJECTS :ALIEN-CALLBACKS
:CYCLE-COUNTER :COMPLEX-FLOAT-VOPS :FLOAT-EQL-VOPS :INLINE-CONSTANTS
:MEMORY-BARRIER-VOPS :OS-PROVIDES-DLOPEN :OS-PROVIDES-DLADDR
:OS-PROVIDES-PUTWC :OS-PROVIDES-SUSECONDS-T :OS-PROVIDES-GETPROTOBY-R
:OS-PROVIDES-POLL)
|
|
| 2011-02-04 21:01:46 |
Robert Smith |
description |
1. Describe what you do, what happens, and what you expected
============================================================
a. Compute ISQRT for small and large integers (between 0 and 10e7.
b. ISQRT successfully computes it. See these benchmarks.
http://paste.lisp.org/display/119381,1/raw
http://paste.lisp.org/display/119381,2/raw
c. ISQRT should compute it even faster!
2. A complete repeatable test-case
==================================
A faster version provided here (also attached):
https://bitbucket.org/tarballs_are_good/numericl/src/d6284092b3ec/src/integer/isqrt.lisp
The benchmark used was [modulo the value in DOTIMES and argument to ITEST:
(declaim (optimize (speed 3) (debug 0) (safety 0)))
(defparameter dum-dum-pop 0)
(defun itest (n ts &aux m1 m2)
(progn
(print 'isqrt) (terpri)
(time (dotimes (i ts)
(setq m1 (isqrt n))))
(print 'my-isqrt) (terpri)
(time (dotimes (i ts)
(setq m2 (isqrt-fast n))))
(print (list (integer-length m1) (integer-length m2)))))
(dotimes (i 3)
(setf dum-dum-pop (+ 7 (expt 11 (expt 10 i))))
(format t "===================================================~%")
(format t "x = 7 + 11^(10^~D); computed 10000000 times" i)
(itest dum-dum-pop 1000000)
(format t "~%===================================================~%"))
3. SBCL version as reported by "sbcl --version"
===============================================
SBCL 1.0.44
(Installed from source.)
4. Output from uname -a
=======================
Linux TheAmbiguousCase 2.6.35-25-generic #44-Ubuntu SMP Fri Jan 21 17:40:44 UTC 2011 x86_64 GNU/Linux
5. *FEATURES*.
==============
(:QUICKLISP :SB-BSD-SOCKETS-ADDRINFO :ASDF2 :ASDF :ANSI-CL :COMMON-LISP :SBCL
:SB-DOC :SB-TEST :SB-LDB :SB-PACKAGE-LOCKS :SB-UNICODE :SB-EVAL
:SB-SOURCE-LOCATIONS :IEEE-FLOATING-POINT :X86-64 :UNIX :ELF :LINUX :SB-THREAD
:LARGEFILE :GENCGC :STACK-GROWS-DOWNWARD-NOT-UPWARD :C-STACK-IS-CONTROL-STACK
:LINKAGE-TABLE :COMPARE-AND-SWAP-VOPS :UNWIND-TO-FRAME-AND-CALL-VOP
:RAW-INSTANCE-INIT-VOPS :STACK-ALLOCATABLE-CLOSURES :STACK-ALLOCATABLE-VECTORS
:STACK-ALLOCATABLE-LISTS :STACK-ALLOCATABLE-FIXED-OBJECTS :ALIEN-CALLBACKS
:CYCLE-COUNTER :COMPLEX-FLOAT-VOPS :FLOAT-EQL-VOPS :INLINE-CONSTANTS
:MEMORY-BARRIER-VOPS :OS-PROVIDES-DLOPEN :OS-PROVIDES-DLADDR
:OS-PROVIDES-PUTWC :OS-PROVIDES-SUSECONDS-T :OS-PROVIDES-GETPROTOBY-R
:OS-PROVIDES-POLL)
|
1. Describe what you do, what happens, and what you expected
============================================================
a. Compute ISQRT for small and large integers (between 0 and 10e7.
b. ISQRT successfully computes it. See these benchmarks.
http://paste.lisp.org/display/119381,1/raw
http://paste.lisp.org/display/119381,2/raw
c. ISQRT should compute it even faster!
2. A complete repeatable test-case
==================================
A faster version provided here (also attached):
https://bitbucket.org/tarballs_are_good/numericl/src/d6284092b3ec/src/integer/isqrt.lisp
The benchmark used was [modulo the value in DOTIMES and argument to ITEST:
(declaim (optimize (speed 3) (debug 0) (safety 0)))
(defparameter dum-dum-pop 0)
(defun itest (n ts &aux m1 m2)
(progn
(print 'isqrt) (terpri)
(time (dotimes (i ts)
(setq m1 (isqrt n))))
(print 'my-isqrt) (terpri)
(time (dotimes (i ts)
(setq m2 (isqrt-fast n))))
(print (list (integer-length m1) (integer-length m2)))))
(dotimes (i 3)
(setf dum-dum-pop (+ 7 (expt 11 (expt 10 i))))
(format t "===================================================~%")
(format t "x = 7 + 11^(10^~D); computed 10000000 times" i)
(itest dum-dum-pop 1000000)
(format t "~%===================================================~%"))
3. SBCL version as reported by "sbcl --version"
===============================================
SBCL 1.0.44
(Installed from source.)
4. Output from uname -a
=======================
Linux TheAmbiguousCase 2.6.35-25-generic #44-Ubuntu SMP Fri Jan 21 17:40:44 UTC 2011 x86_64 GNU/Linux
5. *FEATURES*.
==============
(:QUICKLISP :SB-BSD-SOCKETS-ADDRINFO :ASDF2 :ASDF :ANSI-CL :COMMON-LISP
:SBCL :SB-DOC :SB-TEST :SB-LDB :SB-PACKAGE-LOCKS :SB-UNICODE :SB-EVAL
:SB-SOURCE-LOCATIONS :IEEE-FLOATING-POINT :X86-64 :UNIX :ELF :LINUX
:SB-THREAD :LARGEFILE :GENCGC :STACK-GROWS-DOWNWARD-NOT-UPWARD
:C-STACK-IS-CONTROL-STACK :LINKAGE-TABLE :COMPARE-AND-SWAP-VOPS
:UNWIND-TO-FRAME-AND-CALL-VOP :RAW-INSTANCE-INIT-VOPS
:STACK-ALLOCATABLE-CLOSURES :STACK-ALLOCATABLE-VECTORS
:STACK-ALLOCATABLE-LISTS :STACK-ALLOCATABLE-FIXED-OBJECTS
:ALIEN-CALLBACKS :CYCLE-COUNTER :COMPLEX-FLOAT-VOPS :FLOAT-EQL-VOPS
:INLINE-CONSTANTS :MEMORY-BARRIER-VOPS :OS-PROVIDES-DLOPEN
:OS-PROVIDES-DLADDR :OS-PROVIDES-PUTWC :OS-PROVIDES-SUSECONDS-T
:OS-PROVIDES-GETPROTOBY-R :OS-PROVIDES-POLL)
|
|
| 2011-02-12 11:27:23 |
Nikodemus Siivola |
tags |
enhancement integers numerics optimization speed |
optimization review |
|
| 2011-02-12 11:27:42 |
Nikodemus Siivola |
sbcl: assignee |
|
Nikodemus Siivola (nikodemus) |
|
| 2011-02-16 12:31:24 |
Nikodemus Siivola |
sbcl: importance |
Undecided |
Low |
|
| 2011-02-16 12:31:24 |
Nikodemus Siivola |
sbcl: status |
New |
Triaged |
|
| 2011-03-30 18:06:19 |
Nikodemus Siivola |
sbcl: status |
Triaged |
Fix Committed |
|
| 2011-03-30 18:06:19 |
Nikodemus Siivola |
sbcl: assignee |
Nikodemus Siivola (nikodemus) |
|
|
| 2011-05-09 17:02:37 |
Stas Boukarev |
sbcl: status |
Fix Committed |
Fix Released |
|
