INTRODUCTION
------------

Bubble is a program to provide a general measure of raw
CPU/integer/memory performance by measuring how long it
takes to complete a bubble sort of a large list of
psuedo-random numbers. The numbers are interspersed at
irregular intervals within a 9 megabyte data structure.

Minimum requirements: 486 (or 386 with a 387), 16
megabytes memory to run in DOS, 32 megabytes memory to
run in Windows, Win95 or DOS (will NOT work in Win31).
Bubble can be recompiled to run in UNIX.

USAGE
-----

Bubble is not intended to be a precise measure of
performance (such a program would have to be platform
specific). And, Bubble is not necessarily a good measure
of overall system performance because there's so many
other variables that affect how fast a particular
application runs on a particular computer.

Since most common operating systems are multitasking, a
program like Bubble can only measure the CPU time that's
granted to it. For best results, shutdown all other
programs before running Bubble. You can give Bubble full
control of the CPU by running Bubble using a version of
DOS prior to Win95, or by booting Windows in DOS mode.
Also make sure to run Bubble a few times -- the first
run is frequently slower (and less representive) than
subsequent runs. A bit of disk disk activity is normal
when running the first time (as the operating system
swaps stuff to disk to free up memory), but if you get
continuous disk activity, your system probably doesn't
have enough memory for Bubble to return meaningful
results.

When Bubble finishes running, it displays the elapsed
time, a performance index, and the bit size of the C
integer type (which is usually the word size of the
machine -- an important distinction between different
hardware systems). The performance index is the run time
on a 100 MHz Pentium divided by the measured run time.

Some results I got on various computers: a PII/266
returned 2.0 in Windows and returned a 2.4 in DOS; a
486DX/50 returned a 0.5 under Linux; and my ISP's
computer (whatever it is) returned a 0.9 under BSD
UNIX.

NOTES
-----

The run fails if the the data structure could not be
created (not enough memory), or if the psuedo-random
number sequence is different than expected (shouldn't
happen).

Bubble requires a 486 or 386+387. That's because
there's a smidgen of floating point code, which is
only used to display the performance index. The timed
run does not use any floating point code (i.e. Bubble
does not measure floating point performance).

Bubble might crash if the run time is less than 1 second
or the integer/pointer size is larger than 64-bits.

SOURCE CODE
-----------

bubble.cpp is the Windows/DOS/UNIX front end and run.cpp
is code to perform the bubble sort. The files bubble.rc
and bubble.ico are Windows resource files, and are only
necessary when compiling for Windows. The only C++ code
in the .cpp files is the Win95 interface, so if you're
compiling for DOS or UNIX you should be able to use a C
compiler (rather than a C++ compiler). The Win95 code is
compiled if _WINDOWS is defined, otherwise the DOS/UNIX
code (using standard input/output) is compiled. If
compiling as a DOS program, you must use some sort of
DOS-extender, since the code expects a "flat" memory
model. BUBBLE.EXE (for Windows/DOS) is created by first
compiling for DOS, then compiling for Windows using the
DOS program as the Windows stub.

AUTHOR
------

Eric Tauck
warp@earthling.net
31 May 1998


