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.

Calculates (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.

Simplex algorithm, one million iterations.
A test of floating point arithmetic, and a real program.

Kernighan and Van Wyk Benchmarks

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.

Earley's parsing algorithm, parsing a 15-symbol input according to one
of the simplest ambiguous grammars, 1 iteration.
A real program, applied to toy data whose exponential behavior
leads to a peak heap size of half a gigabyte or more.

This program was provided by Andrew Wright, but we don't know much
about it, and would appreciate more information.
This higher order program creates closures almost as often as it
performs non-tail procedure calls.
Three iterations on a problem of size 7.

This is a quicksort benchmark.
(That isn't as obvious as it sounds. The 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.

Garbage Collection Benchmarks

An updated and exponentially scalable version of the
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.

A version of nboyer that has been tuned (by Henry
Baker) to reduce storage allocation, making it less of a garbage collection
benchmark and more of a compiler benchmark. Only 4 lines of code were
changed, and another 7 lines of code were added.
These timings are for 1 iteration on a problem of size 5.

This program was written to mimic the phase structure that has been
conjectured for a class of application programs for which garbage
collection may represent a significant fraction of the execution time.
This benchmark warms up by allocating and then dropping a large
binary tree.
Then it allocates a large permanent tree and a permanent array
of floating point numbers.
Then it allocates considerable tree storage in seven phases,
increasing the tree size in each phase but keeping the total
storage allocation approximately the same for each phase.
Each phase is divided into two subphases. The first subphase allocates
trees top-down using side effects, while the second subphase allocates
trees bottom-up without using side effects.
This benchmark was written in Java by John Ellis and Pete Kovac,
modified by Hans Boehm, and translated into Scheme, Standard ML,
C++, and C by William Clinger;
it has had too much influence on implementors of production
garbage collectors.
The timings shown are for 1 iteration on problem size 20.

The 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.

Synthetic Benchmarks for R7RS

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.