Willus.com Home   |   Archive   |   About  


    1. Overview
    2. The Compilers
    3. The Programs
    4. The Systems
    5. Other notes

    1. BW1D (C)
    2. BW1D (FOR)
    3. BW2D
    4. FEM2D
    5. LAME

    (User Comments)

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.
Name Type Lines Memory Footprint Description
BW1D (C) C 150,000 2 MB 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.]
BW1D (FOR) FORTRAN 1,800 1 MB 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.
BW2D FORTRAN 19,000 32 MB 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).
FEM2D C++ 63,000 16 MB 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.
LAME C 33,000 1.5 MB 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!)

<<  Previous: The Compilers

Next: The Systems   >>

This page last modified
Thursday, 29-Dec-2011 09:25:00 MST