SLALOM: The First Scalable Supercomputer Benchmark

By John Gustafson, Diane Rover,
Stephen Elbert, and Michael Carter

SLALOM stands for Scalable, Language-independent, Ames Laboratory, One-minute Measurement. We didn't force-fit that acronym. It was pure luck that it turned out to mean "a timed race through obstacles."

"How long will my computer take to run SLALOM?" One minute. That's the wrong question. It always takes one minute! The right question is, "How big a SLALOM problem will my computer solve?"

For years, we've said that the right way to measure computers is to fix time, not problem size. The trouble is, all the popular benchmarks are of fixed size, which is one reason they have a way of going out-of-date as computing power increases. By using the principle of fixed-time benchmarking, it's possible to compare a very wide range of computers, from the smallest personal computer to the most powerful supercomputer, on a single scale. SLALOM is designed to remain useful for many computer generations. SLALOM will be able to benchmark the first 100 TFLOPS computer.

Suppose you wanted to compare a tricycle to a jet. The worst way to do it would be to pick a distance and clock them. If you make the distance 100 miles, the poor tricyclist probably won't even make it. If you make the distance 100 feet, the tricyclist will probably win! Instead, why not ask, "How far can each go in one hour?" The ratio of the distances traveled is a fair measure of their relative performance.

Over a year ago, we set out to create a benchmark for "grand challenge" supercomputing, one that would span the wide spectrum of computing approaches in use today, and one that shouldn't go out-of-date for several decades. Most "benchmarks" are simply excerpts from programs that have been run on multiple machines, or "synthetic" combinations of sample operations that correlate poorly with entire problems. Building a good benchmark is a challenge, since it has to be unprejudiced toward any machine or programming environment, free from undiscovered "shortcuts," and capable of self-verification. Most challenging of all is to create a single program that captures salient features of scientific computing generally.

SLALOM corrects several deficiencies in various existing benchmarks:

The benchmark has been given shouts of approval from vendors spanning the supercomputing industry. The rules of the benchmark are patently fair, and both vector and parallel approaches get shown in their best light.

Fortran, C, and Pascal definitions of the revised benchmark are available, with variants for SIMD, shared-memory MIMD, distributed-memory MIMD, and vector computers, through "anonymous ftp" to a workstation at Ames,, and we encourage submission of the results of any experiments run using this benchmark. Mail results to

Building on the Experience of Past Benchmarks

It's natural in measuring computer performance that the problem being solved be fixed as the computing power varies. Unfortunately, this natural assumption is highly questionable since it doesn't reflect the way people actually use computers. Generally, problems scale to use the available resources, both memory and speed, so that the execution time remains roughly constant. The need for problem scaling has been mentioned in [4], and the more specific goal of scaling the problem to keep execution time constant described in [1].

This is certainly true for the problem of solving systems of linear equations. The popular LINPACK benchmark [2] has undergone at least three size changes in an attempt to keep up with performance increases, but already the latest version is looking too small for the most powerful computers. When the LINPACK software was first introduced, timings for solving a 100 by 100 system were gathered from a number of institutions and published.

As computers have increased in size and speed, the 100 by 100 problem is increasingly inappropriate for measuring high-speed computers. The fastest CRAY does that problem in less than 1/200 of a second, faster than almost any display can refresh to inform the user that the job is done. Even in 64-bit precision, the CRAY uses only 1/400 of its main memory for that problem. As a result, a new version of the benchmark was introduced for a 300 by 300 problem. When this also began to look small, a 1000 by 1000 version was added. To add to the confusion, variations exist for 32-bit versus 64-bit precision, "rolled BLAS" versus "unrolled BLAS," pure Fortran versus various degrees of hand-coded tuning and compiler directives. This proliferation results from the erosion of restrictions on how to achieve the answer.

There's clearly a need for a "gold standard" in benchmarking scientific computers. Increasingly, however, the LINPACK currency has become a bit inflated. The figure below shows an example of what the LINPACK report itself warns [2]: it "should in no way be used to judge the overall performance of a computer system." The horizontal axis shows performance on a chemistry program called GAMESS [6], and the vertical axis shows performance on the 100 by 100 LINPACK benchmark.

The PERFECT Club makes the improvement of starting with real applications, but has had limited success (7%) in putting parallel versions in its suite. It also lacks input and output, and is aimed at "dusty deck Fortran" environments.

We hope that the SLALOM benchmark will last several decades without fundamental change. It may be the first benchmark with such longevity, and will permit the tracking of technology trends over a wide baseline.

A Complete, Real Problem: Radiosity

We started with a scientific paper from 1984 describing the use of radiation transfer to generate realistic images with diffuse surfaces [3]. The buzzword for this method of rendering is "radiosity," and it has passed ray-tracing as a computational challenge for computer-generated scenes. Stated simply the problem is to find the equilibrium radiation inside a box made of diffuse colored surfaces. The faces are divided into regions called "patches," the equations that determine their coupling are set up, and the equations are solved for red, green, and blue spectral components.

The reason we picked this problem is that it's scalable, involves solving a nearly-dense system of equations, has I/O and set up costs, and appears to lack hidden "shortcuts" that might be unevenly exploited. If you want an answer that's correct to 8 digits, the only way to do the job in general is to set up and solve the equations directly. If there's an unanticipated algorithmic breakthrough, we will simply make it available and watch the performance figures improve.

Instead of obtaining a program from the authors of the radiosity paper, we built one from their description. The only changes made were to calculate the matrix entries from an exact expression for the integrals, instead of approximating the entries by quadrature. We even use the same radiative properties as their example. We also made the problem decomposable into an arbitrary number of patches, from 6 on up, so that the scaling would be as smooth as possible.

What to Time

The LINPACK benchmark times only the solution of the set of equations [2]. The PERFECT Club benchmarks [5] have had all the input and output operations carefully deleted. For a fixed-size problem, these omissions are understandable. For fixed time, one can fairly time everything from when the RETURN key is pressed to when the answer becomes viewable.

Given that the problem is a real one, we can now time the setup of the matrix as well as its solution. Constructing an N by N dense matrix takes order N2 time, whereas solving that matrix requires order N3 time (or N2.? for clever block methods with Strassen-type multiplications). For large N, the solving will dominate the benchmark. Yet, the operations needed to set up each element is in the hundreds, so the operation counts are roughly in balance when N = 200. The slower machines in our list are spending much of the time setting up the problem instead of solving it.

We go further than this, however. We also time input and output. The input is in the form of reading a geometry file from mass storage. The output consists of writing the answer (position, size, and color of every patch) to mass storage. While this should pose no burden to most computers now in use, including input and output time will screen out those machines so immature as to lack usable mass storage. These regions are easily projected onto a two-dimensional plane and drawn on a graphics display, and we provide software to do that for anyone interested.

Also, the performance is fed back to the user for each problem size, in a form that summarizes and profiles the run. A typical iteration (this is from the single processor Silicon Graphics 4D/380S) produces something like this:

531 patches:
TaskSecondsOperationsMFLOPS% of Time
Reader0.001258.0.0258000.0 %
Region0.0011148.1.1480000.0 %
SetUp110.52020532123.1.95172317.8 %
SetUp223.13039372520.1.70222739.1 %
SetUp30.130236856.1.8219690.2 %
Solver 24.890135282624.5.43522042.1 %
Storer0.48025440.0.0530000.8 %
TOTAL59.160195425529.3.303339100.0 %
residual is 2.2566160051696E-12
Approximate data memory use: 2311600 bytes


We have three ways of verifying answers. The setup of the matrix is cross-checked by seeing that the rows sum to unity. The residual of the matrix solution is found after the job is done. Lastly, answer files can be compared for small and large problem sizes, against examples we maintain with the program versions. Also, displaying the result graphically can quickly show errors.

The Rules

In this first SLALOM benchmark, we fix problem execution time at 60 seconds. The benchmark has logic to time itself and adjust automatically to find that problem size, or the user can do the trial-and-error manually. We can supply versions in C, Fortran 77, Pascal, and eventually other languages. We can also supply variations with compiler directives for shared-memory parallel machines, message-passing versions for distributed memory MIMD, and a MasPar version for massively-parallel SIMD computers.

These are just starting points. You may optimize the program for a given machine so long as you don't specialize your program to the input data. These are "grand challenge" rules: if you would undertake an optimization to push a scientific frontier, then you can do it to SLALOM.

If we can't verify the reported performance ourselves, the list will so indicate. The usual system of scientific accountability holds for our list: you are responsible for the numbers you report. You must disclose any special technique that you use.

You Must Be This Tall To Go On This Ride

The smallest SLALOM run possible is one with only 6 patches: one for each face of the box. We weight that job as 8812 floating-point operations, so a computer must be capable of at least 148 FLOPS (not MFLOPS, but FLOPS) to run SLALOM in under a minute. The Radio Shack Model 100, a 6-year old lap computer running interpretive BASIC, was too slow to make it. We haven't found any current machines unable to run the benchmark, but if you can't compete for the largest problem, we'd love to have a new record smallest problem to show SLALOM's scalability! Even running BASIC, our Macintosh IIcx was well above the entry threshold.

Right now, the list has a dynamic range of about a million to one between the fastest and slowest machines, in terms of MFLOPS. Using "patches" or "kilopatches" compresses the range nicely, and gives a better feel than MFLOPS for the size of a physical problem that can reasonably be solved using that machine.

The Report

Remember, this is the first installment of a rapidly changing list. We don't have Connection Machine or IBM 390 times yet. The NCUBE times only go up to 64 processors. The Intel iPSC/860 and Cogent figures are for only one processor. Our run on the world's only CRAY-2/8 was not tuned nearly as much as was the CRAY Y-MP, so that gap will soon close. But with the publication of this article, the race is now on!

Incidentally, you won't find older machines cluttering up our list. We will keep, and occasionally publish, data interesting from the historical viewpoint, but what we mainly intend to publish are figures for machines that are actively marketed.

Machine, environmentProcessorsPatchesOperationsSecondsMFLOPSMeasurerDate
Cray Y-MP/8, 167 MHz
Fortran+tuned LAPACK solver
85120126 G59.032130.J. Brooks (v)
Cray Y-MP/8, 167 MHz
Fortran+tuned LAPACK solver
4409665.2 G54.811190.J. Brooks (v)
Cray Y-MP/8, 167 MHz
Fortran+tuned LAPACK solver
2320031.6 G56.7556.J. Brooks (v)
Cray Y-MP/8, 167 MHz
Fortran+tuned LAPACK solver
1256016.5 G58.27293.J. Brooks (v)
Cray 2S/8-128, 244 MHz
Fortran+directives, FPP 3.00Z25
8244314.4 G59.83240.S. Elbert
Ames Lab
NCUBE 6400, 20 MHz
6414382.83 G59.9547.2J. Gustafson
Ames Lab
MasPar MP-1, 12.5 MHz
C with plural variables (mpl)
819214072.93 G57.6550.8M. Carter
Ames Lab
Silicon Graphics 4D/380S, 33 MHz
Fortran (-O2 -mp -lparalin)
810101.15 G59.8519.2S. Elbert
Ames Lab
Silicon Graphics 4D/380S, 33 MHz
Fortran (-O2 -mp -lparalin)
4853716. M59.8711.96S. Elbert
Ames Lab
Silicon Graphics 4D/380S, 33 MHz
Fortran (-O2 -mp -lparalin)
2676378. M59.156.39S. Elbert
Ames Lab
IBM RS/6000 POWERstation 320
Fortran (xlf -O -Q)
1642328. M59.+5.6S. Elbert
Ames Lab
Silicon Graphics 4D/380S, 33 MHz
Fortran (-O2 -mp -lparalin)
1531195. M59.163.30S. Elbert
Ames Lab
iPSC/860, 40 MHz
Fortran (-OLM -i860)
1419105. M59.911.75J. Gustafson
Ames Lab
Myrias SPS2 (mc68020, 16.7 MHz)
Fortran (mpfc -Ofr)
6439992.2. M59.261.56J. Roche (v)
SUN 4/370, 25 MHz,
C (ucc -O4 -dalign etc.)
138081.1 M59.851.35M. Carter
Ames Lab
NCUBE 2, 20 MHz
Fortran + assembler subroutines (-O2)
135467.5 M59.731.13J. Gustafson
Ames Lab
Silicon Graphics 4D/20, 12.5 MHz,
Fortran (f77 -O2)
1 29040.5 M59.700.679S. Elbert
Ames Lab
DECStation 2100, 12.5 MHz,
Fortran (f77 -O2)
128538.8 M59.720.649J. Gustafson
Ames Lab
Cogent XTM (T800 Transputer)
Fortran 77 (-O -u)
11497.89 M59.370.133C. Vollum (v)
Mac IIcx, 68030,
Interpreted QuickBASIC
1240.142 M59.+0.00239J. Gustafson
Ames Lab

NOTE: a "(v)" after a name means the benchmark was run by the vendor. Vendors often have access to special tools, early compiler releases, and proprietary libraries, so remember the source. We quote MFLOPS for continuity with earlier benchmarks, but it's patches that determines rank. See the MasPar versus the NCUBE 6400 ranking, for example.

In one minute, a Macintosh IIcx can compute
a 24-patch decomposition using interpretive
BASIC. With the exact same benchmark,
we've measured machines a million times faster.
This is a 512-patch run, a one minute job for an
Iris workstation. Computing these colors takes
about 200 million floating point operations.


We thank everyone who has participated in this effort. This work was supported by the U. S. Department of Energy Applied Mathematical Sciences subprogram of the Office of Energy Research, under contract W-7405-ENG-82.


We view SLALOM as a significant step toward providing a level playing field for advanced architectures. Right now, Cray Research is the clear winner, but the highly parallel computers have yet to compete in the same price range. The largest NCUBE, Intel, and Thinking Machines systems should be worthy opponents for Cray on SLALOM. We're committed to maintaining the scientific integrity of this benchmark, and, with your help, we look forward to measuring and publishing even more wide-ranging SLALOM numbers in the future.


[1] R. E. Benner, G. R. Montry, and J. L. Gustafson, "A Structural Analysis Algorithm for Massively Parallel Computers," Parallel Supercomputing: Methods, Algorithms, and Applications, edited by G. F. Carey, Wiley series in parallel computing, 1989.

[2] J. J. Dongarra, "Performance of Various Computers Using Standard Linear Equations Software in a Fortran Environment," Argonne National Laboratory, Technical Memorandum No. 23, Feb. 2, 1988.

[3] C. M. Goral, K. E. Torrance, D. P. Greenberg, and B. Battaile, "Modeling the Interaction of Light Between Diffuse Surfaces," Computer Graphics, Volume 18, Number 3, July 1984.

[4] J. L. Gustafson, "Reevaluating Amdahl's Law," Communications of the ACM, Volume 31, Number 5, May 1988.

[5] L. Pointer, "PERFECT: Performance Evaluation for Cost-Effective Transformations, Report 2," CSRD Report No. 964, March, 1990.

[6] M.W. Schmidt, J.A. Boatz, K.K. Baldridge, S. Koseki, M.S. Gordon, S.T. Elbert, and B. Lam, "General Atomic and Molecular Electronic Structure System (GAMESS)," Quantum Chemistry Program Exchange Bulletin, Vol. 7, No. 115, 1987.

Contact: John Gustafson