The benchmarks described below are portable R7RS programs. None define any libraries. Each description of a benchmark begins with a link to its source code, omitting the part that is shared by all of these benchmarks.
All of these benchmarks, their inputs, and the Unix
script used to run them, are
online
and can be downloaded using git or svn.
The timings report execution time only, as calculated using
current-jiffy.
This pseudo-benchmark is an aggregate statistic that shows the geometric mean for all benchmarks. Where other benchmarks display timings in seconds, the numerical scores for the geometric mean show the (geometric) average ratio of the system's time to the fastest system's time. An average ratio of 1.0 is the lowest possible, and can be achieved only by a system that is fastest on every benchmark.
The R7RS (small) standard does not require implementations to provide all of the R7RS standard libraries, and some implementations are unable to run some of the benchmarks for other reasons as well; furthermore, our benchmarking script gives up on any benchmark that takes more than an hour to run. The geometric means for each system were calculated using only the benchmarks that returned correct results in less than an hour. When implementations of the R7RS are more mature, the geometric means will be recalculated to impose a penalty for each benchmark an implementation is unable to run.
string->symbol and/or
symbol->string.]
null?, cons, car,
cdr, and little else.
diviter
except it uses deep recursion instead of iteration.
puzzle,
a Gabriel benchmark,
50 iterations.
(tak 40 20 11).
A test of non-tail calls and arithmetic.
[Historical note:
The Symbolics 3600 performed 1 iteration of (tak 18 12 6)
in 0.43 seconds using generic arithmetic.
On our test machine, Larceny runs that benchmark in 0.00016 seconds.
That's 2500 times as fast.]
(tak 40 20 12), which is faster than
calculating (tak 40 20 11), using the same recursive
algorithm as for the tak:32:16:8
benchmark but using lists to represent integers. This too was a
Gabriel benchmark (with different arguments). 1 iteration.
takl benchmark contains a
peculiar boolean expression. Rewriting that expression into a
more readable idiom allows some compilers to generate better
code for it.
tak:40:20:11 benchmark
in continuation-passing style, 1 iteration.
A test of closure creation.
tak:32:16:8 benchmark
in continuation-capturing style, 1 iteration.
A test of call-with-current-continuation.
(< n 2) to terminate the
recursion; 5 iterations.
fib that uses first class continuations;
written by Kent Dybvig. Calculates the 30th Fibonacci number
(832040) 10 times.
fib
benchmark.
sum
benchmark.
mbrot benchmark,
but using complex instead of real arithmetic.
Brian W Kernighan and Christopher J Van Wyk wrote a set of small benchmarks to compare the performance of several scripting languages, including C and Scheme. Marc Feeley and I modified some of these benchmarks to correct bugs and to increase the number of iterations. When I translated them into R6RS Scheme, I rewrote most of them into slightly more idiomatic Scheme.
string-append and substring,
and very little else. 25 iterations on a problem size of 500000.
nboyer.scm 2500 times.
nboyer benchmark 2500 times
using a scanner and parser generated using Will Clinger's
LexGen and ParseGen.
quicksort
benchmark distributed with Gambit is a bignum benchmark,
not a quicksort benchmark. See the comments in
the code.)
Sorts a vector of 10000 random integers 2500 times.
Written by Lars Hansen, and restored to its original glory
by Will Clinger.
boyer benchmark.
The nboyer benchmark's data structures are
considerably more appropriate than the data structures used in the
original boyer benchmarks.
These timings are for 1 iteration on
a problem of size 5.
A test of lists, vectors, and garbage collection.
mperm20:10:2:1 benchmark
is a severe test of storage allocation and garbage collection.
At the end of each of the 20 iterations, the oldest half of the
live storage becomes garbage.
This benchmark is particularly difficult for generational garbage
collectors, since it violates their assumption that young objects
have a shorter future life expectancy than older objects.
The perm9 benchmark distributed with Gambit
does not have that property.
The R6RS and R7RS added several new features that had not been tested by older benchmarks because they were not a standard part of Scheme. Most of the following synthetic benchmarks were derived from Larceny's test suites for these features.