Performance Comparison Intel 386DX, Intel RapidCAD, C&T 38600DX, Cyrix 486DLC

This document, containing descriptions and a benchmark comparison of the
Intel 386DX, Intel RapidCAD, C&T 38600DX, and the Cyrix 486DLC has been
put together for the benefit of the net.community. I believe, but cannot
guarantee, that all data given herein is correct. If you would like to
report errors in this document, or have suggestions for its enhancement,
feel free to contact me at the following email address:

     JUFFA@IRA.UKA.DE

You can also write to me at my snail mail address:

     Norbert Juffa
     Wielandtstr. 14
     7500 Karlsruhe 1
     Germany

Corrections pertaining to spelling or grammatical errors are also encouraged,
especially from those net.users that are native speakers of (American) English.


This is the third version of this document. Thanks to the people that helped
improve it by their comments on the previous versions:

    Alex Martelli (martelli@cadlab.sublink.org),
    Fred Dunlap (fred@cyrix.com),
    Antony Suter (antony@werple.apana.org.au)

A special thanks for editing this article goes to:

    David Ruggiero (osiris@halcyon.halcyon.com)


The previous version of this article has also appeared in print. Check out:

    Juffa, N.: "Performance Comparison Intel 386DX, Intel RapidCAD, C&T 38600DX,
    Cyrix 486DLC". In: Association Francaise des Utilisateurs d'Unix et des
    Systemes Ouverts (ed.): "Dossier special No 4 - Benchmarks", March 1993,
    pp. 109-117


This document released 14-June-1993

---------------------------------------------------------------------------

In 1992, three new CPUs were introduced into the PC marketplace. Each has the
capability to replace the standard Intel 386DX CPU and provide higher
performance for existing 386 systems. These new chips are the Intel RapidCAD,
the Chips&Technologies (C&T) Super386 38600DX, and the Cyrix 486DLC. All chips
had initially been released in 33 MHz versions, but at least the Cyrix 486DLC
is available in a 40 MHz version now. While the Intel RapidCAD is marketed
only as an end-user product (which means PC manufacturers will not ship systems
with the RapidCAD already installed), C&T sells their products directly to the
end user as well as to PC motherboard manufacturers. Cyrix currently sells
only to OEMs (Original Equipment Manufacturers), that is motherboard
manufacturers. Cyrix also manufactures the 486SLC, which is a replacement for
the Intel/AMD 386SX CPUs. C&T has announced a 38600SX chip, but it will not
ship before sometime in 1993, if at all.

The Intel RapidCAD
------------------

The Intel RapidCAD is, in rough terms, an Intel 486DX with the 8 KB on-chip
cache removed and a 386 pinout. To software, it appears to be a 386DX with a
math coprocessor, as the 486-specific instructions have been removed from its
instruction set. It is marketed by Intel as "the ultimate coprocessor" and, as
the name implies, its main purpose is to replace the 386DX in existing systems
and thereby boost the performance of floating-point intensive applications such
as CAD software, spreadsheets, and math packages (e.g. SPSS, Mathematica).

RapidCAD is delivered as a set of two chips. RapidCAD-1 is a 132-pin PGA (pin
grid array) chip that goes into the CPU socket and replaces the 386DX. It
contains the CPU and the FPU (floating-point unit). RapidCAD-2 is a 68-pin PGA
chip that goes into the 387 coprocessor (or EMC) socket; it contains a simple
PLA whose only purpose it to generate the FERR signal for the motherboard
logic: this provides full PC-compatible handling of floating-point exceptions.
Many CPU instructions execute in one clock cycle in the RapidCAD, just as on
the Intel 486. The RapidCAD is constrained, however, by use of the standard
386DX bus interface, since every bus cycle takes two CPU clock cycles. This
means that instructions may be executed by the RapidCAD faster than they can be
fetched from memory. But as most FPU instructions take longer to execute than
CPU instructions, they are not greatly slowed down by this slow bus interface,
and most of them execute in the same time as in the Intel 486DX. Therefore, the
Intel RapidCAD provides higher overall floating-point performance than any
386/387 combination. Results from the SPEC benchmarks, a common workstation
UNIX benchmark suite, show that the RapidCAD provides 85% more floating-point
and 15% more integer performance than an Intel 386DX/387DX combination at the
same clock frequency.

Power consumption of the RapidCAD is typically 3500 mW at 33 MHz. The current
street price of the 33 MHz version is ~300 US$.

The C&T 38600DX
---------------

The Chips&Technologies 38600DX is designed to be 100% compatible to the Intel
386DX CPU. Unlike AMD's Am386 CPUs (which use microcode that is identical to
the Intel 386DX's microcode), the C&T 38600DX uses new microcode developed
within C&T using "clean-room" techniques. C&T even included the 386DX's
"undocumented" LOADALL386 instruction in the instruction set to provide full
compatibility with the Intel chip.

Some instructions execute faster on the 38600DX than on the 386DX. C&T also
produces a 38605DX CPU that includes a 512-byte instruction cache and provides
further performance increases over the Intel part. The 38605DX needs a bigger
socket (144-pin PGA) and is therefore *not* pin-compatible with the 386DX.

In my tests, I found that the 38600DX has severe problems with the CPU-
coprocessor communication, which causes its floating-point performance to drop
below the level provided by the Intel 386DX/Intel 387DX for most programs. This
problem exists with all available 387 compatible coprocessors (ULSI 83C87, IIT
3C87, Cyrix EMC87, Cyrix 83D87, Cyrix 387+, C&T 38700, and the Intel 387DX).
(A net.acquaintance also did tests with the 38600DX and arrived at similar
results. He contacted C&T and they said they were aware of the problem.)

Typical power consumption of the 40 MHz 38600DX is 1650 mW, which is less than
the typical power consumption of the Intel 386DX at 33 MHz (2000 mW). The
38600DX currently sells for ~US$ 80 for the 33 MHz version.

The Cyrix 486DLC
----------------

The Cyrix 486DLC is the latest entry into the market of 386DX replacements. It
features a 486SX compatible instruction set, a 1 KB on-chip cache, and a 16x16-
bit hardware multiplier. The RISC-like execution unit of the 486DLC executes
many instructions in a single clock cycle. The hardware multiplier multiplies
16-bit quantities in 3 clock cycles, as compared to 12-25 cycles on a standard
Intel 386DX. This is especially useful in address calculations (code from non-
optimizing compilers may contain many MUL instructions for array accesses) and
for software floating-point arithmetic (e.g., a coprocessor emulator). The 1 KB
cache helps the 486DLC to overcome the limitations of the 386 bus interface,
although its hit rate averages only about 65% under normal program conditions.

In existing 386 systems, DMA transfers (such as those performed by a SCSI
controller or a sound board) may force the internal cache of the 486DLC to be
flushed as the only means available in a 386 system to enforce consistency
between the contents of the on-chip cache and external memory. This stems from
the fact that the 386 bus interface was designed without provisions for an
on-chip cache. This problem can reduce the performance of the 486DLC in systems
that do a sizeable amount of (bus master) DMA. Cyrix has, however, defined some
additional cache control signals for some of the 486DLC lines; they can be used
to improve communications between the on-chip cache and a larger external cache
or main memory and prevent this problem. Current 386 systems ignore these
signals since they are not defined for the Intel 386DX. However, motherboards
designed for use with the Cyrix chip should be able to take advantage of them
and thereby gain increased performance.

The Cyrix cache is a unified data/instruction write-through type and can be
configured as either a direct-mapped or 2-way set associative cache. It permits
definition of up to four non-cacheable regions, which are particularly useful
if a system has memory mapped peripherals (e.g., the Weitek math coprocessor).
For compatibility reasons, the cache is disabled after a processor reset
and must be enabled with the help of a small program provided by Cyrix. This
prevents problems with BIOSes that are not "486DLC aware". Motherboards that
come with the 486DLC installed usually feature a BIOS that supports the cache
and switch it on after the machine self-test. On these machines, no additional
software is required to take advantage of the cache. The cache control program
from Cyrix is a DOS program. Antony Suter (antony@werple.apana.org.au) informs
me that public domain drivers for OS/2, 386BSD, and Linux that enable the
cache are available from various ftp servers.

Not all 486DLCs will work correctly with all math coprocessors in all
circumstances, with protected mode multitasked environments (e.g. MS-Windows
386-enhanced mode) being especially critical. Using the 486DLC with the Cyrix
EMC87, Cyrix 83D87 (chips produced prior to November 1991), and IIT 3C87, I
have been able to completely lock up the machine due to synchronization
problems between the CPU and the coprocessor while executing the FSAVE or
FRSTOR instructions (which are used to save and restore the coprocessor status
during task switches). According to Cyrix, this problem only occurred with the
first revision of the 486DLC (like the sample chip I have) and is fixed on
newer ones. To be on the safe side, the 486DLC should best be used with the
Cyrix 387+ (its "Europe-only" name) or with the identical Cyrix 83D87
(US-bound chips manufactured after October 1991): these are not only the
highest performing 387 coprocessors on the market, but they also work properly
even with the first generation 486DLC.

If you already have a Cyrix 83D87 coprocessor and want to know whether it is
the old or new type, I recommend you use my COMPTEST program, available as
CTEST259.ZIP via anonymous ftp from garbo.uwasa.fi and other fine ftp servers.
If COMPTEST reports a 387+, you either have the 387+ or the identical newer
version of the 83D87 installed and can use any version of the Cyrix 486DLC
without problems. If you believe that you may have problems with a 486DLC/387
combination, I suggest you contact Cyrix technical support (1-800-FAS-MATH in
the US).

Power consumption of a 40 MHz 486DLC is typically 2800 mW. As Cyrix can't fill
demand for their 486DLC/SLC chips, they currently sell these chips only to
OEMs. About two million 486SLC/DLC CPUs have been sold so far. The 486SLC is
especially popular with notebook manufacturers. Chips sold by retailers seem
to be "surplus" chips sold off by OEMs at a premium price. While the price for
a 486DLC-40 is about US$ 100 when bought by an OEM, it sells for about US$
200-250 on the open market.

Tests and benchmarks
--------------------

HW configuration: 33.3/40 MHz motherboard with Forex chip set and AMI BIOS. 128
KB zero- wait-state, direct mapped, write-through CPU cache with one write
buffer, 4 bytes per cache line, and 4 clock cycles penalty for a cache line
miss. 8 MB of main memory with an average access time of 1.6 wait states. Cyrix
EMC87 in 387 compatibility mode as math coprocessor. (This and the Cyrix 83D87
/ 387+ are the fastest coprocessors available for use with the
386DX/486DLC/38600DX). Conner 3204F hard disk, 203 MB capacity, IDE interface
(CORETEST throughput 1100 KB/s, seek time 16 ms). Diamond SpeedSTAR HiColor,
ISA bus SVGA card using Tseng's ET4000 chip, 1 MB DRAM as frame buffer, *no*
accelerator. The switches on the card were set for fastest reliable operation,
with a VIDSPEED throughput of 6500 bytes/ms at 40 MHz and 5400 bytes/ms at
33.3 MHz.

SW configuration: MS-DOS 5.0, MS Windows 3.1, HyperDisk 4.32 disk cache program
in write-back mode, using 2 MB of extended memory, 386MAX 6.01 used as memory
manager and DPMI provider in some benchmarks. Latest Tseng (Colorview) driver
for Windows 3.1 at 1024x768x256, using the 8514 fonts.


For the Whetstone, Dhrystone, WINTACH, DODUC, LINPACK, LLL, and Savage
benchmarks, *higher* numbers indicate *faster* performance.

For the MAKE RTL, MAKE TRANCK, and String-Test benchmarks, *lower* numbers
indicate *faster* performance.


                         Intel        C&T      Intel      Cyrix      Cyrix
33.3 MHz                 386DX    38600DX   RapidCAD      486DLC     486DLC
                                                        cache off    cache on
integer

Whetstone [kWhets/s]       447        585        563        695        803
Dhrystone (C) [Dhry./s]  11688      11819      12357      14150      15488
Dhrystone (Pas) [Dhry./s]10455      10877      10751      12154      13858
String-Test [ms]           459        453        441        347        327
MAKE RTL [s]                51.32      47.10      46.34      43.45      39.13
MAKE TRANCK [s]             62.42      55.47      55.37      53.64      46.12
WINTACH [overall RPM]        4.85       4.90       5.49       5.53       6.14

float

DODUC [Rapidity index]      79.0       76.4      150.3       89.4       90.7
LINPACK [MFLOPS]             0.2808     0.2707     0.4578     0.3158     0.3438
LLL [MFLOPS]                 0.3352     0.3537     0.6083     0.3816     0.4139
Whetstone [kWhets/s]      2540       2340       3990       2908       3061
Savage [function eval/s] 71685      53191      72464      88757      93897


                         Intel        C&T      Intel      Cyrix      Cyrix
40.0 MHz                 386DX    38600DX   RapidCAD      486DLC     486DLC
                                                         cache off   cache on
integer

Whetstone [kWhets/s]       536        702        676        835        963
Dhrystone (C) [Dhry./s]  14128      14116      14836      16987      18750
Dhrystone (Pas) [Dhry./s]12490      13067      12890      14573      16624
String-Test [ms]           384        377        368        289        273
MAKE RTL [s]                43.46      40.11      39.84      37.25      33.54
MAKE TRANCK [s]             53.00      47.59      47.07      45.36      39.00
WINTACH [overall RPM]        5.65       5.73       6.41       6.46       7.23

float

DODUC [Rapidity index]      94.9       77.5      180.3      105.1      106.6
LINPACK [MFLOPS]             0.3324     0.3260     0.5418     0.3789     0.4131
LLL [MFLOPS]                 0.4025     0.4204     0.7263     0.4562     0.4956
Whetstone [kWhets/s]      3061       2632       4798       3505       3677
Savage [function eval/s] 86083      49587      86957     106762     112360


To complete the picture, I ran the CPU/FPU standard benchmarks on an Intel
486DX running at 33.3/40 MHz. Since the 486 machine was configured with a
different hard disk than the 386 system, and the compilers and tools installed
on the 386 machine were not present, the MAKE benchmarks could unfortunately
not be included in the tests.

486DX, 256 KBytes CPU cache (write-through), 8 MB of RAM, AMI-BIOS, Diamond
SpeedSTAR HiColor (VIDSPEED throughput: 6500 bytes/ms at 40 MHz and 5400
bytes/ms at 33.3 MHz), MS-DOS 5.0, MS-Windows 3.1:

integer                       33.3 MHz             40 MHz

Whetstone [kWhets/s]          707                 848
Dhrystone (C) [Dhry./s]     19394               23265
Dhrystone (Pas) [Dhry./s]   16978               20368
String-Test [ms]              333                 279
WINTACH                         8.59               10.14

float

DODUC [Rapidity index]        184.0              220.7
LINPACK [MFLOPS]                0.6682              0.8204
LLL [MFLOPS]                    0.9387              1.1110
Whetstone [kWhets/s]         5143                6195
Savage [function eval/s]    82192               98522


Conclusions
-----------

The Cyrix 486DLC is the 386DX replacement with the highest integer performance.
With the internal cache enabled, integer performance of the 486DLC can be up to
80% higher compared with a Intel 386DX at the same clock frequency, with the
average speed gain for integer applications being 35%. Enabling the internal
cache provides about 5-15% more performance than with the cache disabled for
both integer and floating-point applications. Floating-point applications are
accelerated by about 15%-30% if the Cyrix 486DLC (with cache enabled) is used
instead of the Intel 386DX. Compared with the Intel 486DX, the Cyrix 486DLC
provides about 70% of the integer performance and about 50% of the floating-
point performance at the same clock frequency.

The Intel RapidCAD is the 386DX replacement that provides the highest floating-
point performance. It can speed up most floating-point intensive programs by
60%-90% compared with the fastest Intel 386DX/math coprocessor combination; it
provides nearly 75% of the floating-point performance of a Intel 486DX at the
same clock frequency. Integer performance increases by an average 15% by using
the RapidCAD instead of the standard Intel 386DX, with the maximum performance
gain being 35%.

The Chips&Technologies 38600DX has a slightly higher integer performance than
the Intel 386DX, with the speedup ranging from 0%-30% and an average speedup on
the order of 10%.


Description of benchmarks
-------------------------
DHRYSTONE [9] is a synthetic benchmark developed by R. Weicker from Siemens in
1984. The frequency of operations and data types used by Dhrystone are modeled
after statistics collected for 'typical' programs that are written in a HLL
(high level language) such as C or Pascal that do not use floating-point
arithmetic. Thus there is a certain distribution of global and local variables
being used in procedures, there is a certain percentage of use of records
(structs) or strings out of the total number of variables accessed and there is
a certain percentage of procedure calls and if-statements out of the total
lines of codes executed. All these percentages match the statistics used in the
development of Dhrystone quite closely. To preserve the typical distributions,
the measurement rules for Dhrystone forbid function inlining (a frequently used
optimization technique optionally performed by most optimizing compilers). The
current version of Dhrystone is 2.1, and this is the version used for my tests.
Version 2.1 [10] differs from previous versions in that it contains additional
code that prevents optimizing compilers from throwing out most of the code by
dead code elimination (since Dhrystone has no input file, many expressions can
be computed at compile time), thus artificially inflating performance numbers.
The Dhrystone benchmark exists in equivalent Ada, Pascal and C versions, which
are all available from netlib@ornl.gov. Dhrystone measures the time to execute
its main loop and sets this time into relation with a fixed reference time, the
result being a performance index given in "Dhrystones per second". I used two
Dhrystone executables. One was compiled using the non-optimizing Turbo Pascal
6.0 compiler, the other one was compiled with the MS-C 7.0 compiler using the
large memory model and maximum optimization but without the use of function
inlining. Because the Turbo Pascal executable uses more memory operands and the
MS-C executable uses more register-to-register operations, the speedup for the
executables on different CPUs can be noticeably different.

WINTACH is a public domain benchmark program by Texas Instruments that measures
the speed of graphics output for four typical MS-Windows applications: a word
processor, a spreadsheet, a CAD program, and a paint program. TI has collected
profiles for each class of applications under 'typical' user loads. The four
parts of the WINTACH benchmark were then modeled after these profiles, so that
the percentage of certain GDI (graphics device interface) calls found in the
profiles is also present in the benchmark. WINTACH determines the performance
of each program part relative to the performance of a standard VGA card in a 20
MHz 386DX machine. It also combines the four values into an overall relative
performance index, which is reported in my tables. Using this single number to
represent graphics performance is justified in this case since the four partial
results do *not* deviate much from the average for the SVGA tested (a Diamond
SpeedSTAR HiColor). I used a frame buffer card for the test because for these
graphics card type, graphics performance depends solely on the performance of
the CPU, which handles all accesses to the display memory. On an accelerated
card, some of the low-level operations are delegated to the accelerator chip
and the influence of the CPU speed on the graphics performance is not seen so
clearly. For this test, I used the latest Tseng Windows 3.1 driver (Colorview)
at a resolution of 1024x768x256 with the large 8514 fonts (WINTACH code C8).

MAKE RTL is not a single program. Rather it is a build of a complete project,
my own run-time library for Turbo Pascal 6.0. The project consists of about 200
source files with a total size of ~650 KByte. Most of the source files are
assembly language (.ASM) files, while there are also some Pascal (.PAS) files.
Building the complete project using MAKE, about 200 binary files (.OBJ and
.TPU) are produced with a combined size of ~300 KB. The programs used during
the build are MAKE 3.5, TPC 6.01, and TASM 2.01, all by Borland, Inc. All files
are read from and written to the hard disk, using a 2 MB write back disk cache
provided by the HyperDisk 4.32 program. This eliminates most of the I/O
overhead. No memory manager was installed during the test. The time reported is
the time from starting the MAKE utility to the reappearance of the DOS prompt.
MAKE RTL can be thought of being typical of applications that operate on a lot
of small files, and use only integer instructions.

MAKE TRANCK is a project build for a project consisting of two assembly
language modules, two C modules and one FORTRAN module. The combined size of
the source files is approximately 120 KBytes. All modules are compiled
(assembled) and combined into a single program linking with both, the C and the
FORTRAN libraries. Programs used are MAKE 3.5 by Borland and MASM 6.0, MS-C
7.0, MS-FORTRAN 5.0, and LINK 5.3, all by Microsoft, Inc. The C compiler and
the linker run in protected mode and require a DPMI host to be present. 386MAX
6.01 by Qualitas was installed for this purpose. To minimize I/O overhead, the
HyperDisk 4.32 disk caching program was installed, with 2 MByte of extended
memory allocated to the cache. The modules are compiled with compiler switches
set for maximum optimization, and most of the time for the project build is
spent in the optimizing stages of the compilers.

STRING-TEST is a simple benchmark that tests the string handling functions
built into the Turbo Pascal language. Nearly all of the execution time is spent
in repeated execution of the STOS, CMPS, SCAS, and MOVS instructions. The data
and code fit into about five KBytes of memory. In cached systems, almost all
memory accesses will be cache hits. The program was written and compiled with
Turbo Pascal 6.0 and linked with my own run-time library, which provides much
faster string functions than the run-time library delivered by Borland.
Compiler switches were set for fastest execution. The time reported is the time
to complete the whole benchmark in milliseconds, with an accuracy of +/-1
millisecond.

LLL is short for Lawrence Livermore Loops [8], a set of kernels taken from real
floating-point extensive programs. Some of these loops are vectorizable, but
since we don't deal with vector processors here, this doesn't matter. For this
test, LLL was adapted from the FORTRAN original in [7] to Turbo Pascal. By
variable overlaying (similar to FORTRAN's EQUIVALENCE statement) memory
allocation for data was reduced to 64 KB, so all data fits into a single 64 KB
segment. The older version of LLL is used here which contains 14 loops. There
also exists a newer, more elaborate version consisting of 24 kernels. The
kernels in LLL exercise only multiplication and addition. The MFLOPS rate
reported is the average of the MFLOPS rate of all 14 kernels as reported by the
LLL program. All floating-point variables in the program are of type double.
LLL and Whetstone results (see below) are reported as returned by my COMPTEST
test program in which they have been included as a measure of coprocessor/FPU
performance. COMPTEST has been compiled under Turbo Pascal 6.0 with all
'optimizations' on and using my own run-time library, which gives higher
performance than the one included with TP 6.0. My library is available as
TPL60N19.ZIP from garbo.uwasa.fi and ftp-sites that mirror this site.

LINPACK [4] is a well known floating-point benchmark that also heavily
exercises the memory system. Linpack operates on large matrices and takes up
about 570 KB in the version used for this test. This is about the largest
program size a pure DOS system can accommodate. Linpack was originally designed
to estimate performance of BLAS, a library of FORTRAN subroutines that handles
various vector and matrix operations. Note that vendors are free to supply
optimized (e.g. assembly language versions) of BLAS. Linpack uses two routines
from BLAS which are thought to be typical of the matrix operations used by
BLAS. Both routines only use addition/subtraction and multiplication. The
FORTRAN source code for Linpack can be obtained from the automated mail server
netlib@ornl.gov. Linpack was compiled using MS FORTRAN 5.0 in the HUGE memory
model (which can handle data structures larger than 64 KB) and with compiler
switches set for maximum optimization. All floating-point variables in the
program are of the DOUBLE type. Linpack performs the same test repeatedly. The
number reported is the maximum MFLOPS rate returned by Linpack. Linpack MFLOPS
ratings for a great number of machines are contained in [5]. This PostScript
document is also available from netlib@ornl.gov.

WHETSTONE [1,2,3] is a synthetic benchmark based on statistics collected about
the use of certain control and data structures in programs written in high
level languages. Based on these statistics, Whetstone tries to mirror a
'typical' HLL program. Whetstone performance is expressed by how many
hypothetical 'whetstone' instructions are executed per second. It was originally
implemented in ALGOL. Unlike LLL and Linpack, Whetstone not only uses addition
and multiplication but exercises all basic arithmetic operations as well as
some transcendental functions. Whetstone performance depends on the speed of
the coprocessor as well as on the speed of the CPU, while LLL and Linpack place
a heavier burden on the coprocessor/FPU. There exist an old and a new version
of Whetstone. Note that results from the two versions can differ by as much as
20% for the same test configuration. For this test, the new version in Pascal
from [2] was used. It was compiled with Turbo Pascal 6.0 and my own library
(see above) with all 'optimizations' on. For the integer test, software
floating-point arithmetic using the REAL type was utilized. Using the software
arithmetic exercises only the CPU, in particular the execution of MOV, SHL, SHR,
RCR, ADD, SUB, MUL, and DIV instructions. For the floating-point test, the
hardware floating-point arithmetic of the coprocessor was used and computations
were performed using the DOUBLE type.

SAVAGE tests the performance of transcendental function evaluation. It is
basically a small loop in which the sin, cos, arctan, ln, exp, and sqrt
functions are combined in a single expression. While sin, cos, arctan, and sqrt
can be evaluated directly with a single 387 coprocessor instruction each, ln
and exp need additional preprocessing for argument reduction and result
conversion. According to [11], the Savage benchmark was devised by Bill Savage,
and is distributed by: The Wohl Engine Company, Ltd., 8200 Shore Front Parkway,
Rockaway Beach, NY 11693, USA. Usually, Savage is programmed to make 250,000
passes though the loop. Here only 10,000 loops are executed for a total of
60,000 transcendental function evaluations. The result is expressed in function
evaluations per second. SAVAGE source code was taken from [6] and compiled with
Turbo Pascal 6.0 and my own run-time library (see above).

DODUC [12] is a modified application program by Nhuan Doduc that is also part
of the SPEC benchmark suite. It is a nuclear safety analysis code that
simulates the time evolution of a thermohydraulic modelization for a nuclear
reactor's component and the benchmark is created from the computational kernel
of the original application. The benchmark consists of 5323 FORTRAN statement
lines and the executable size is about 350 KBytes. Almost all processing is
done using double precision floating-point values. There is not much array
processing. Instead the program has an iterative structure with an abundance of
short branches and small loops. The version used for this test was compiled
with the highly optimizing NDP FORTRAN V3.0 compiler from Microway, which
generates a 32-bit mode executable that runs in protected mode using a
protected mode loader provided by Microway. The execution time of the DODUC
program is set into relation with fixed reference times and the result is
scaled to give a "Rapidity index".


References
----------

[1]  Curnow, H.J.; Wichmann, B.A.: A synthetic benchmark.
     Computer Journal, Vol. 19, No. 1, 1976, pp. 43-49
[2]  Wichmann, B.A.: Validation code for the Whetstone benchmark.
     NPL Report DITC 107/88, National Physics Laboratory, UK, March 1988
[3]  Curnow, H.J.: Wither Whetstone? The Synthetic Benchmark after 15 Years.
     In: Aad van der Steen (ed.): Evaluating Supercomputers.
     London: Chapman and Hall 1990
[4]  Dongarra, J.J.: The Linpack Benchmark: An Explanation.
     In: Aad van der Steen (ed.): Evaluating Supercomputers.
     London: Chapman and Hall 1990
[5]  Dongarra, J.J.: Performance of Various Computers Using Standard Linear
     Equations Software.
     Report CS-89-85, Computer Science Department, University of Tennessee,
     March 11, 1992
[6]  Huth, N.: Dichtung und Wahrheit oder Datenblatt und Test.
     Design & Elektronik 1990, Heft 13, Seiten 105-110
[7]  Esser, R.; Kremer, F.; Schmidt, W.G.: Testrechnungen auf der IBM 3090E mit
     Vektoreinrichtung.
     Arbeitsbericht RRZK-8803, Regionales Rechenzentrum an der Universit"at zu
     K"oln, Februar 1988
[8]  McMahon, H.H.: The Livermore Fortran Kernels: A test of the numerical
     performance range.
     Technical Report UCRL-53745, Lawrence Livermore National
     Laboratory, USA, December 1986
[9]  Weicker, R.P.: Dhrystone: A Synthetic Systems Programming Benchmark.
     Communications of the ACM, Vol. 27, No. 10, October 1984, pp. 1013-1030
[10] Weicker, R.P.: Dhrystone Benchmark: Rationale for Version 2 and
     Measurement Rules.
     SIGPLAN Notices, Vol. 23, No. 8, August 1988, pp. 49-62
[11] FasMath 83D87 Benchmark Report. Cyrix Corporation, June 1990
     Order No. B2004
[12] Doduc, Nhuan: Fortran Execution Time Benchmark.
     Unpublished manuscript, version 45, available from ndoduc@framentec.fr
