2. The Compilers
3. The Programs
4. The Systems
5. Other notes
1. BW1D (C)
2. BW1D (FOR)
Willus.com's 2002 Win32 Compiler Benchmarks:
3. The Programs
The simulation codes that I compiled with each compiler are dominated
by floating point intensive codes, with one integer benchmark (an
MP3 conversion program called LAME) thrown in to try and satisfy
the integer fans out there. The floating point codes themselves
have a common theme--electron beam/rf wave interactions, since this area
is quite familiar to me and I have access to a number of codes of this type.
Nota bene: Click on a column heading to sort the rows based on the data in that column.
||BW1D = Beam-Wave one-dimensional.
This simulation, like two of the others, models the interaction of an
electron beam with an electrodynamic wave. It is computationally
intensive and mostly emphasizes double precision floating point. The
beam is only modeled in one dimension, and a grid is not necessary for
mapping the fields or the beam, so it has a reasonably small memory
footprint. It has the most lines of code of any of the benchmarks.
[Note: See 10/02 update on summary page for MinGW 2.0
(based on gcc 3.2) run time on this code.]
||This simulation is similar to the BW1D C version, but it is an older,
much simpler FORTRAN version. It unfortunately uses implicit
typing, so I believe it depends on the compiler whether the real
variables will be single or double precision. I didn't check what
type each compiler defaults to.
||This simulation is similar to BW1D FORTRAN version, but models the
electron beam in two-dimensions. It therefore has more complex
algorithms and a much bigger memory footprint. All floating point variables
are explicitly double precision, and floating point calculations
dominate the performance. The memory footprint is difficult to
precisely determine because the arrays are sized for a maximum
case (there is no dynamic memory allocation in FORTRAN 77).
||This code tracks charged particles through an electrostatic field which
is mapped on a finite-element grid. Because it uses a large grid and
many electron macro-particles, it has a big memory footprint.
It's also the lone C++ entry. Again, it is dominated by double
precision arithmetic. This code was also the most difficult to compile,
as C++ is not as mature in the standardization department as C and
FORTRAN 77. Notes: The Borland compiled version
would not run correctly.
||This is my concession to the integer performance fans out there! I
grabbed the source for the LAME MP3 conversion algorithm, which converts
uncompressed Windows wave (.wav) files to MPEG-1 Layer 3 files (.mp3).
The benchmark in this case is how long it takes to convert a 2-minute
song ripped directly from a CD. Notes: The lcc version
would not run correctly with the -O option, so it was compiled
with no optimization.
Also, my original benchmark script did not work
quite right in Windows 98 for LAME (because it writes screen info to stderr!)