Gambit-list Novembre 2012

gambit-list@iro.umontreal.ca

12 participants
15 discussions

R7RS 7th draft available
by Alex Shinn 10 Nov '12

10 Nov '12

[Sent to multiple lists via bcc.] The seventh and semi-final draft is available at: http://trac.sacrideo.us/wg/raw-attachment/wiki/WikiStart/r7rs-draft-7.pdf This includes many changes from the 6th draft, including those resulting from the many formal (and informal) comments we received. Thanks to everyone who helped! The Steering Committee will form an electorate and call for ratification based on this draft, after which we will fix any errors in the eighth and final draft. Any issues arising after that point will be tracked separately in an errata list. A release of chibi-scheme with all changes up to this point will be made shortly, along with a full R7RS test suite. -- Alex

1 0

Re: [gambit-list] [racket] translate from Racket to Common Lisp
by Marc Feeley 07 Nov '12

07 Nov '12

Le 2012-11-06 à 3:50 AM, Hugh Aguilar <hughaguilar96(a)yahoo.com> a écrit : > I am very impressed that Racket is as fast as it is. I had expected the compilers such as Gambit to be much faster than the VM-JIT system. If Racket had a 64-bit x86 assembler available, I might even consider using it instead of Gambit. > > > Message: 1 > Date: Mon, 5 Nov 2012 08:09:19 -0500 > From: Sam Tobin-Hochstadt <samth(a)ccs.neu.edu> > To: Matthew Flatt <mflatt(a)cs.utah.edu> > Cc: "users(a)racket-lang.org" <users(a)racket-lang.org> > Subject: Re: [racket] translate from Racket to Common Lisp > Message-ID: > <CAK=HD+Yyr1R4K6emrgSXqie2c_AmT1BzhLpP1X=1NDXRgzsjGg(a)mail.gmail.com> > Content-Type: text/plain; charset=UTF-8 > > It's impressive to note the change in relative performance for Racket > over past 3 years since you published the benchmarks on the blog -- > Racket has gone from slower than Gambit on the majority of benchmarks, > sometimes by a significant margin, to faster on most of them, and > never more than 2x slower (except ctak). For your information, it seems that the change in relative performance has more to do with the change in C compiler over the past 3 years than anything else. The benchmarks were run on Mac OS X with the C compiler available with Xcode. Recently Apple dropped distributing the GNU gcc compiler with Xcode, and the "gcc" program that is installed is actually a version which uses the gcc compiler parser but LLVM as a back-end (i.e. llvm-gcc). That C compiler has bugs which prevent using gcc's computed gotos which are critical for the best performance. This is what Gambit's "configure" script has to say when using llvm-gcc: configure: ************************************************************************** *** *** *** The LLVM GCC compiler that is being used may have a bug in the *** *** compilation of label values (i.e. &&label). This bug was *** *** discovered when compiling Gambit with Xcode on Mac OS X (see bug *** *** ID# 9956714). For this reason the use of computed gotos in the *** *** generated code has been disabled. This greatly reduces the run *** *** time performance. The system runs 5 times slower than when it is *** *** compiled with GNU GCC. It is highly recommended that you use *** *** another C compiler if possible. *** *** *** ************************************************************************** I have suggested to Matthew that he rerun the benchmarks on a linux machine where GNU gcc is the default C compiler. It will be interesting to see how that affects performance. Marc

5 11

Slow Bit Hacking with c-lambda
by tcl super dude 07 Nov '12

07 Nov '12

Hi everyone, I have been working on an image processing library that I want to use on android. I know that performance is a bit of a problem on image processing, so I started to study some bit hacking to improve the performance on my integer operations. My problem now is that I don't know why my c-lambdas take so much time to execute. All operations take constant time and there is no branching. Probably is some sort of conversion time between C types and GAMBIT types. I expected min-integer and abs-integer to be a lot faster than min and abs, respectively. Any help is appreciated. URL REFERENCE: http://graphics.stanford.edu/~seander/bithacks.html#IntegerAbs http://graphics.stanford.edu/~seander/bithacks.html#IntegerMinOrMax MY ENVIRONMENT: Linux casa 3.6.4-1-ARCH #1 SMP PREEMPT Mon Oct 29 15:13:56 CET 2012 i686 GNU/Linux gcc -v Using built-in specs. COLLECT_GCC=gcc COLLECT_LTO_WRAPPER=/usr/lib/gcc/i686-pc-linux-gnu/4.7.2/lto-wrapper Target: i686-pc-linux-gnu Configured with: /build/src/gcc-4.7.2/configure --prefix=/usr --libdir=/usr/lib --libexecdir=/usr/lib --mandir=/usr/share/man --infodir=/usr/share/info --with-bugurl=https://bugs.archlinux.org/--enable-languages=c,c++,ada,fortran,go,lto,objc,obj-c++ --enable-shared --enable-threads=posix --with-system-zlib --enable-__cxa_atexit --disable-libunwind-exceptions --enable-clocale=gnu --disable-libstdcxx-pch --enable-libstdcxx-time --enable-gnu-unique-object --enable-linker-build-id --with-ppl --enable-cloog-backend=isl --disable-ppl-version-check --disable-cloog-version-check --enable-lto --enable-gold --enable-ld=default --enable-plugin --with-plugin-ld=ld.gold --with-linker-hash-style=gnu --disable-multilib --disable-libssp --disable-build-with-cxx --disable-build-poststage1-with-cxx --enable-checking=release Thread model: posix gcc version 4.7.2 (GCC) Gambit v4.6.6 (SINGLE HOST and GCC extensions enabled) SCHEME CODE: compiled with ---> gambitc -exe bithacks.scm ;; bithacks.scm (declare (not safe) (fixnum) (inline) (inline-primitives)) ;; INTEGER ABSOLUTE (define abs-integer (c-lambda (int) int "// we want to find the absolute value of arg1 int const mask = ___arg1 >> sizeof(int) * CHAR_BIT - 1; ___result = (___arg1 + mask) ^ mask;")) (define min-integer (c-lambda (int int) int "// find the smaller of arg1 arg2 ___result = ___arg2 ^ ((___arg1 ^ ___arg2) & -(___arg1 < ___arg2));")) (define (test-abs) (let ((result 0)) (begin (display "abs:\n") (time (let loop-i ((i 0)) (cond ((fx< i 100000) (set! result (abs i)) (loop-i (fx+ 1 i)))))) (display "abs-integer:\n") (time (let loop-j ((j 0)) (cond ((fx< j 100000) (set! result (abs-integer j)) (loop-j (fx+ 1 j))))))))) (define (test-min) (let ((result 0)) (begin (display "min:\n") (time (let loop-i ((i 0)) (cond ((fx< i 100000) (set! result (min i result)) (loop-i (fx+ 1 i)))))) (display "min-integer:\n") (time (let loop-j ((j 0)) (cond ((fx< j 100000) (set! result (min-integer j result)) (loop-j (fx+ 1 j))))))))) ;; run tests (test-abs) (test-min) ;;;;;;;;;;;;;;;;;;;;;; RESULTS;;;;;;;;;;;;;;;;;;;;; abs: (time (let loop-i ((i 0)) (cond ((fx< i 100000) (set! result (abs i)) (loop-i (fx+ 1 i)))))) 2 ms real time 3 ms cpu time (3 user, 0 system) no collections no bytes allocated no minor faults no major faults abs-integer: (time (let loop-j ((j 0)) (cond ((fx< j 100000) (set! result (abs-integer j)) (loop-j (fx+ 1 j)))))) 22 ms real time 23 ms cpu time (23 user, 0 system) no collections no bytes allocated 2 minor faults no major faults min: (time (let loop-i ((i 0)) (cond ((fx< i 100000) (set! result (min i result)) (loop-i (fx+ 1 i)))))) 2 ms real time 3 ms cpu time (0 user, 3 system) no collections no bytes allocated no minor faults no major faults min-integer: (time (let loop-j ((j 0)) (cond ((fx< j 100000) (set! result (min-integer j result)) (loop-j (fx+ 1 j)))))) 28 ms real time 30 ms cpu time (27 user, 3 system) no collections no bytes allocated no minor faults no major faults

3 3

Re: [gambit-list] Slow Bit Hacking with c-lambda
by tcl super dude 04 Nov '12

04 Nov '12

Now scheme min is even faster.. that is ok. But what I don't understand is how that simple C implementation get so low performance. abs: (time (let loop-i ((i 0)) (cond ((fx< i 100000) (set! result (abs i)) (loop-i (fx+ 1 i)))))) 1 ms real time 0 ms cpu time (0 user, 0 system) no collections no bytes allocated no minor faults no major faults abs-integer: (time (let loop-j ((j 0)) (cond ((fx< j 100000) (set! result (abs-integer j)) (loop-j (fx+ 1 j)))))) 18 ms real time 17 ms cpu time (17 user, 0 system) no collections no bytes allocated 1 minor fault no major faults min: (time (let loop-i ((i 0)) (cond ((fx< i 100000) (set! result (min i result)) (loop-i (fx+ 1 i)))))) 0 ms real time 0 ms cpu time (0 user, 0 system) no collections no bytes allocated no minor faults no major faults min-integer: (time (let loop-j ((j 0)) (cond ((fx< j 100000) (set! result (min-integer j result)) (loop-j (fx+ 1 j)))))) 26 ms real time 26 ms cpu time (23 user, 3 system) no collections no bytes allocated no minor faults no major faults On Sun, Nov 4, 2012 at 7:31 PM, Mikael More <mikael.more(a)gmail.com> wrote: > Ah, also throw in the following: > * (declare (not interrupts-enabled)) > > This might be a big deal - when it's off, Gambit doesn't produce any > hooks for stack overflow or thread system interrupts but executes your code > according to a typical C model > > * (declare (standard-bindings) (extended-bindings)) too? > > > What is the performance you get from Gambit now, and what kind of > performance is it you want to get? > > > 2012/11/4 tcl super dude <tcleval(a)gmail.com> > >> I assumed I could get a bit of performance improvement over min procedure >> because I don't do any branch. I' thought min-integer to be at least close >> to gambit-c time. The problem is that those operations and a few more are >> performed thousands of times. Gambit loops are usually 2x slower than C, so >> I hoped I could improve some basic operations as I only perform them on >> integers. I don't Understand how a simple shift to extract the lower bits >> could make so much difference. Maybe if someone point me to the >> implementation of min and abs on gambit, I can understand the difference. I >> ve looked for these procedures on gambit's source but could not point it >> out. >> >> I'll try to implement them using vectors and see what happens. >> >> now compiled with (block): >> >> >> abs: >> >> (time (let loop-i ((i 0)) (cond ((fx> (loop-i (fx+ 1 i)))))) >> 2 ms real time >> >> 3 ms cpu time (3 user, 0 system) >> >> no collections >> >> no bytes allocated >> >> no minor faults >> >> no major faults >> >> abs-integer: >> >> (time (let loop-j ((j 0)) (cond ((fx< j 100000) (set! result (abs-integer >> j)) (loop-j (fx+ 1 j)))))) >> 19 ms real time >> >> 20 ms cpu time (17 user, 3 system) >> >> no collections >> >> no bytes allocated >> >> 2 minor faults >> >> no major faults >> >> min: >> >> (time (let loop-i ((i 0)) (cond ((fx> result)) (loop-i (fx+ 1 i)))))) >> 2 ms real time >> >> 3 ms cpu time (0 user, 3 system) >> >> no collections >> >> no bytes allocated >> >> no minor faults >> no major faults >> min-integer: >> (time (let loop-j ((j 0)) (cond ((fx< j 100000) (set! result (min-integer >> j result)) (loop-j (fx+ 1 j)))))) >> 27 ms real time >> 27 ms cpu time (27 user, 0 system) >> no collections >> no bytes allocated >> no minor faults >> no major faults >> >> >> On Sun, Nov 4, 2012 at 5:15 PM, Mikael <mikael.rcv(a)gmail.com> wrote: >> >>> First, please add (declare (block)) and re-compile, this way Gambit >>> won't need to re-look up the procedures in the global namespace that you >>> call, on each invocation. Please report what kind of improvement you got >>> with this. >>> >>> >>> Now just to make this round of emails complete: >>> >>> What would be good/very good performance in your view? >>> >>> Could you send jobs in some kind of batch format to C? >>> >>> Note that Gambit-internal fxnum variables have a special encoding (the >>> lowermost two(?) bits are object type identifier, which are shifted out >>> when converting them to C int), this takes a little bit of time. >>> >>> If for instance you make u32vectors/s32vectors/etc. [and send batch ops >>> made on those to C to be performed etc.] then you can just read out the >>> content of those vectors 'raw' in C, there's no interconversion there. >>> >>> Brgds >>> >>> 2012/11/4 tcl super dude <tcleval(a)gmail.com> >>> >>>> Hi everyone, >>>> >>>> I have been working on an image processing library that I want to use >>>> on android. I know that performance is a bit of a problem on image >>>> processing, so I started to study some bit hacking to improve the >>>> performance on my integer operations. My problem now is that I don't know >>>> why my c-lambdas take so much time to execute. All operations take constant >>>> time and there is no branching. Probably is some sort of conversion time >>>> between C types and GAMBIT types. I expected min-integer and abs-integer to >>>> be a lot faster than min and abs, respectively. Any help is appreciated. >>>> >>>> URL REFERENCE: >>>> http://graphics.stanford.edu/~seander/bithacks.html#IntegerAbs >>>> http://graphics.stanford.edu/~seander/bithacks.html#IntegerMinOrMax >>>> >>>> >>>> MY ENVIRONMENT: >>>> Linux casa 3.6.4-1-ARCH #1 SMP PREEMPT Mon Oct 29 15:13:56 CET 2012 >>>> i686 GNU/Linux >>>> >>>> gcc -v >>>> Using built-in specs. >>>> COLLECT_GCC=gcc >>>> COLLECT_LTO_WRAPPER=/usr/lib/gcc/i686-pc-linux-gnu/4.7.2/lto-wrapper >>>> Target: i686-pc-linux-gnu >>>> Configured with: /build/src/gcc-4.7.2/configure --prefix=/usr >>>> --libdir=/usr/lib --libexecdir=/usr/lib --mandir=/usr/share/man >>>> --infodir=/usr/share/info --with-bugurl=https://bugs.archlinux.org/--enable-languages=c,c++,ada,fortran,go,lto,objc,obj-c++ --enable-shared >>>> --enable-threads=posix --with-system-zlib --enable-__cxa_atexit >>>> --disable-libunwind-exceptions --enable-clocale=gnu --disable-libstdcxx-pch >>>> --enable-libstdcxx-time --enable-gnu-unique-object --enable-linker-build-id >>>> --with-ppl --enable-cloog-backend=isl --disable-ppl-version-check >>>> --disable-cloog-version-check --enable-lto --enable-gold >>>> --enable-ld=default --enable-plugin --with-plugin-ld=ld.gold >>>> --with-linker-hash-style=gnu --disable-multilib --disable-libssp >>>> --disable-build-with-cxx --disable-build-poststage1-with-cxx >>>> --enable-checking=release >>>> Thread model: posix >>>> gcc version 4.7.2 (GCC) >>>> >>>> Gambit v4.6.6 (SINGLE HOST and GCC extensions enabled) >>>> >>>> >>>> SCHEME CODE: compiled with ---> gambitc -exe bithacks.scm >>>> >>>> ;; bithacks.scm >>>> >>>> >>>> (declare >>>> (not safe) >>>> (fixnum) >>>> (inline) >>>> (inline-primitives)) >>>> >>>> ;; INTEGER ABSOLUTE >>>> (define abs-integer >>>> (c-lambda (int) int >>>> "// we want to find the absolute value of arg1 >>>> int const mask = ___arg1 >> sizeof(int) * CHAR_BIT - 1; >>>> ___result = (___arg1 + mask) ^ mask;")) >>>> >>>> >>>> (define min-integer >>>> (c-lambda (int int) int >>>> "// find the smaller of arg1 arg2 >>>> ___result = ___arg2 ^ ((___arg1 ^ ___arg2) & -(___arg1 < >>>> ___arg2));")) >>>> >>>> (define (test-abs) >>>> (let ((result 0)) >>>> (begin >>>> (display "abs:\n") >>>> (time >>>> (let loop-i ((i 0)) >>>> (cond ((fx>>> (set! result (abs i)) >>>> (loop-i (fx+ 1 i)))))) >>>> (display "abs-integer:\n") >>>> (time >>>> (let loop-j ((j 0)) >>>> (cond ((fx< j 100000) >>>> (set! result (abs-integer j)) >>>> (loop-j (fx+ 1 j))))))))) >>>> >>>> (define (test-min) >>>> (let ((result 0)) >>>> (begin >>>> (display "min:\n") >>>> (time >>>> (let loop-i ((i 0)) >>>> (cond ((fx>>> (set! result (min i result)) >>>> (loop-i (fx+ 1 i)))))) >>>> (display "min-integer:\n") >>>> (time >>>> (let loop-j ((j 0)) >>>> (cond ((fx< j 100000) >>>> (set! result (min-integer j result)) >>>> (loop-j (fx+ 1 j))))))))) >>>> >>>> ;; run tests >>>> >>>> (test-abs) >>>> (test-min) >>>> >>>> ;;;;;;;;;;;;;;;;;;;;;; RESULTS;;;;;;;;;;;;;;;;;;;;; >>>> >>>> abs: >>>> (time (let loop-i ((i 0)) (cond ((fx>>> (loop-i (fx+ 1 i)))))) >>>> 2 ms real time >>>> 3 ms cpu time (3 user, 0 system) >>>> no collections >>>> no bytes allocated >>>> no minor faults >>>> no major faults >>>> abs-integer: >>>> (time (let loop-j ((j 0)) (cond ((fx< j 100000) (set! result >>>> (abs-integer j)) (loop-j (fx+ 1 j)))))) >>>> 22 ms real time >>>> 23 ms cpu time (23 user, 0 system) >>>> no collections >>>> no bytes allocated >>>> 2 minor faults >>>> no major faults >>>> min: >>>> (time (let loop-i ((i 0)) (cond ((fx>>> result)) (loop-i (fx+ 1 i)))))) >>>> 2 ms real time >>>> 3 ms cpu time (0 user, 3 system) >>>> no collections >>>> no bytes allocated >>>> no minor faults >>>> no major faults >>>> min-integer: >>>> (time (let loop-j ((j 0)) (cond ((fx< j 100000) (set! result >>>> (min-integer j result)) (loop-j (fx+ 1 j)))))) >>>> 28 ms real time >>>> 30 ms cpu time (27 user, 3 system) >>>> no collections >>>> no bytes allocated >>>> no minor faults >>>> no major faults >>>> >>>> >>>> _______________________________________________ >>>> Gambit-list mailing list >>>> Gambit-list(a)iro.umontreal.ca >>>> https://webmail.iro.umontreal.ca/mailman/listinfo/gambit-list >>>> >>>> >>> >> >> _______________________________________________ >> Gambit-list mailing list >> Gambit-list(a)iro.umontreal.ca >> https://webmail.iro.umontreal.ca/mailman/listinfo/gambit-list >> >> >

2 3

Re: [gambit-list] Slow Bit Hacking with c-lambda
by Mikael 04 Nov '12

04 Nov '12

Ah, also throw in the following: * (declare (not interrupts-enabled)) This might be a big deal - when it's off, Gambit doesn't produce any hooks for stack overflow or thread system interrupts but executes your code according to a typical C model * (declare (standard-bindings) (extended-bindings)) too? What is the performance you get from Gambit now, and what kind of performance is it you want to get? 2012/11/4 tcl super dude <tcleval(a)gmail.com> > I assumed I could get a bit of performance improvement over min procedure > because I don't do any branch. I' thought min-integer to be at least close > to gambit-c time. The problem is that those operations and a few more are > performed thousands of times. Gambit loops are usually 2x slower than C, so > I hoped I could improve some basic operations as I only perform them on > integers. I don't Understand how a simple shift to extract the lower bits > could make so much difference. Maybe if someone point me to the > implementation of min and abs on gambit, I can understand the difference. I > ve looked for these procedures on gambit's source but could not point it > out. > > I'll try to implement them using vectors and see what happens. > > now compiled with (block): > > > abs: > > (time (let loop-i ((i 0)) (cond ((fx (loop-i (fx+ 1 i)))))) > 2 ms real time > > 3 ms cpu time (3 user, 0 system) > > no collections > > no bytes allocated > > no minor faults > > no major faults > > abs-integer: > > (time (let loop-j ((j 0)) (cond ((fx< j 100000) (set! result (abs-integer > j)) (loop-j (fx+ 1 j)))))) > 19 ms real time > > 20 ms cpu time (17 user, 3 system) > > no collections > > no bytes allocated > > 2 minor faults > > no major faults > > min: > > (time (let loop-i ((i 0)) (cond ((fx result)) (loop-i (fx+ 1 i)))))) > 2 ms real time > > 3 ms cpu time (0 user, 3 system) > > no collections > > no bytes allocated > > no minor faults > no major faults > min-integer: > (time (let loop-j ((j 0)) (cond ((fx< j 100000) (set! result (min-integer > j result)) (loop-j (fx+ 1 j)))))) > 27 ms real time > 27 ms cpu time (27 user, 0 system) > no collections > no bytes allocated > no minor faults > no major faults > > > On Sun, Nov 4, 2012 at 5:15 PM, Mikael <mikael.rcv(a)gmail.com> wrote: > >> First, please add (declare (block)) and re-compile, this way Gambit won't >> need to re-look up the procedures in the global namespace that you call, on >> each invocation. Please report what kind of improvement you got with this. >> >> >> Now just to make this round of emails complete: >> >> What would be good/very good performance in your view? >> >> Could you send jobs in some kind of batch format to C? >> >> Note that Gambit-internal fxnum variables have a special encoding (the >> lowermost two(?) bits are object type identifier, which are shifted out >> when converting them to C int), this takes a little bit of time. >> >> If for instance you make u32vectors/s32vectors/etc. [and send batch ops >> made on those to C to be performed etc.] then you can just read out the >> content of those vectors 'raw' in C, there's no interconversion there. >> >> Brgds >> >> 2012/11/4 tcl super dude <tcleval(a)gmail.com> >> >>> Hi everyone, >>> >>> I have been working on an image processing library that I want to use on >>> android. I know that performance is a bit of a problem on image processing, >>> so I started to study some bit hacking to improve the performance on my >>> integer operations. My problem now is that I don't know why my c-lambdas >>> take so much time to execute. All operations take constant time and there >>> is no branching. Probably is some sort of conversion time between C types >>> and GAMBIT types. I expected min-integer and abs-integer to be a lot faster >>> than min and abs, respectively. Any help is appreciated. >>> >>> URL REFERENCE: >>> http://graphics.stanford.edu/~seander/bithacks.html#IntegerAbs >>> http://graphics.stanford.edu/~seander/bithacks.html#IntegerMinOrMax >>> >>> >>> MY ENVIRONMENT: >>> Linux casa 3.6.4-1-ARCH #1 SMP PREEMPT Mon Oct 29 15:13:56 CET 2012 i686 >>> GNU/Linux >>> >>> gcc -v >>> Using built-in specs. >>> COLLECT_GCC=gcc >>> COLLECT_LTO_WRAPPER=/usr/lib/gcc/i686-pc-linux-gnu/4.7.2/lto-wrapper >>> Target: i686-pc-linux-gnu >>> Configured with: /build/src/gcc-4.7.2/configure --prefix=/usr >>> --libdir=/usr/lib --libexecdir=/usr/lib --mandir=/usr/share/man >>> --infodir=/usr/share/info --with-bugurl=https://bugs.archlinux.org/--enable-languages=c,c++,ada,fortran,go,lto,objc,obj-c++ --enable-shared >>> --enable-threads=posix --with-system-zlib --enable-__cxa_atexit >>> --disable-libunwind-exceptions --enable-clocale=gnu --disable-libstdcxx-pch >>> --enable-libstdcxx-time --enable-gnu-unique-object --enable-linker-build-id >>> --with-ppl --enable-cloog-backend=isl --disable-ppl-version-check >>> --disable-cloog-version-check --enable-lto --enable-gold >>> --enable-ld=default --enable-plugin --with-plugin-ld=ld.gold >>> --with-linker-hash-style=gnu --disable-multilib --disable-libssp >>> --disable-build-with-cxx --disable-build-poststage1-with-cxx >>> --enable-checking=release >>> Thread model: posix >>> gcc version 4.7.2 (GCC) >>> >>> Gambit v4.6.6 (SINGLE HOST and GCC extensions enabled) >>> >>> >>> SCHEME CODE: compiled with ---> gambitc -exe bithacks.scm >>> >>> ;; bithacks.scm >>> >>> >>> (declare >>> (not safe) >>> (fixnum) >>> (inline) >>> (inline-primitives)) >>> >>> ;; INTEGER ABSOLUTE >>> (define abs-integer >>> (c-lambda (int) int >>> "// we want to find the absolute value of arg1 >>> int const mask = ___arg1 >> sizeof(int) * CHAR_BIT - 1; >>> ___result = (___arg1 + mask) ^ mask;")) >>> >>> >>> (define min-integer >>> (c-lambda (int int) int >>> "// find the smaller of arg1 arg2 >>> ___result = ___arg2 ^ ((___arg1 ^ ___arg2) & -(___arg1 < >>> ___arg2));")) >>> >>> (define (test-abs) >>> (let ((result 0)) >>> (begin >>> (display "abs:\n") >>> (time >>> (let loop-i ((i 0)) >>> (cond ((fx>> (set! result (abs i)) >>> (loop-i (fx+ 1 i)))))) >>> (display "abs-integer:\n") >>> (time >>> (let loop-j ((j 0)) >>> (cond ((fx< j 100000) >>> (set! result (abs-integer j)) >>> (loop-j (fx+ 1 j))))))))) >>> >>> (define (test-min) >>> (let ((result 0)) >>> (begin >>> (display "min:\n") >>> (time >>> (let loop-i ((i 0)) >>> (cond ((fx>> (set! result (min i result)) >>> (loop-i (fx+ 1 i)))))) >>> (display "min-integer:\n") >>> (time >>> (let loop-j ((j 0)) >>> (cond ((fx< j 100000) >>> (set! result (min-integer j result)) >>> (loop-j (fx+ 1 j))))))))) >>> >>> ;; run tests >>> >>> (test-abs) >>> (test-min) >>> >>> ;;;;;;;;;;;;;;;;;;;;;; RESULTS;;;;;;;;;;;;;;;;;;;;; >>> >>> abs: >>> (time (let loop-i ((i 0)) (cond ((fx>> (loop-i (fx+ 1 i)))))) >>> 2 ms real time >>> 3 ms cpu time (3 user, 0 system) >>> no collections >>> no bytes allocated >>> no minor faults >>> no major faults >>> abs-integer: >>> (time (let loop-j ((j 0)) (cond ((fx< j 100000) (set! result >>> (abs-integer j)) (loop-j (fx+ 1 j)))))) >>> 22 ms real time >>> 23 ms cpu time (23 user, 0 system) >>> no collections >>> no bytes allocated >>> 2 minor faults >>> no major faults >>> min: >>> (time (let loop-i ((i 0)) (cond ((fx>> result)) (loop-i (fx+ 1 i)))))) >>> 2 ms real time >>> 3 ms cpu time (0 user, 3 system) >>> no collections >>> no bytes allocated >>> no minor faults >>> no major faults >>> min-integer: >>> (time (let loop-j ((j 0)) (cond ((fx< j 100000) (set! result >>> (min-integer j result)) (loop-j (fx+ 1 j)))))) >>> 28 ms real time >>> 30 ms cpu time (27 user, 3 system) >>> no collections >>> no bytes allocated >>> no minor faults >>> no major faults >>> >>> >>> _______________________________________________ >>> Gambit-list mailing list >>> Gambit-list(a)iro.umontreal.ca >>> https://webmail.iro.umontreal.ca/mailman/listinfo/gambit-list >>> >>> >> > > _______________________________________________ > Gambit-list mailing list > Gambit-list(a)iro.umontreal.ca > https://webmail.iro.umontreal.ca/mailman/listinfo/gambit-list > >

1 0

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

Gambit-list Novembre 2012