Some Scheme Benchmarks

# About the Benchmarks

The benchmark results page shows some benchmark results on a collection of fairly standard (mostly Gabriel) Scheme benchmarks.

Tables show relative performance, with the actual time for the fastest run shown on the left. So, by default, 1 is the fastest, but select any implementation to normalize the table with respect to that implementation’s speed. A `-` appears when a benchmark didn’t run in an implementation for some reason (possibly not a good one).

The compilers-only page shows just the compilers among the tested implementations. For those results, the small gray numbers are (relative) compile times, where the compile time for the `nothing` benchmark is subtracted from every other benchmark’s compile time.

Run times are averaged over three runs for compilers or one run for interpreters. All reported times are CPU time (system plus user). The times are based on the output of the implementation’s `time` syntactic form or similar functions.

Machine:

- MacBook Pro, 2.53 GHz, Mac OS X 10.6.2, compiling to 32-bit programs

Compiler configurations:

- Bigloo (3.3a): `-06 -call/cc -copt -O3 -copt -fomit-frame-pointer`
- Chicken (4.3.0): `-no-trace -no-lambda-info -optimize-level 3 -block -lambda-lift`
- Gambit (4.6.0): `(declare (block) (standard-bindings) (extended-bindings) (safe) (interrupts-enabled))`, compiled and run with `-:m10000`
- Guile (1.9.7): `load`
- Ikarus (0.0.4-rc1+ rev 1870): in R6RS library
- Larceny (0.97): in R6RS library
- MIT (7.7.90+): `(declare (usual-integrations))`; run with `--heap 12000`
- Petite Chez (7.4d): `load`
- PLT (4.2.4): in `module`; for benchmarks that use `set-car!` and `set-cdr!`, PLT’s R5RS support is used
- Scheme48 (1.8): `load` after `,bench on`

These configurations are all “safe mode,” but they allow a compiler to assume that built-in Scheme functions are not redefined and that no top-level defintion is ever changed. Such assumptions correspond to putting the benchmark in an R6RS library. We attempt to use the various implementations in a compentent way, but not in a sophisticated way. For example, we do not tweak inlining parameters or specify fixnum arithmetic (where appropriate), which could produce significant improvements from some compilers.

For more benchmarks and a more sophisticated use of a few compilers, including fixnum- and flonum-specific arithmetic as well as unsafe modes, see Gambit benchmark results.

For further details on the benchmarks here, see the benchmark source and infrastructure, which is available form the PLT git repository:

http://git.racket-lang.org/plt/tree/HEAD:/collects/tests/racket/benchmarks/common/