Spotlight › REDLINE

REDLINE, a benchmark measured against a 4.77 MHz PC

REDLINE gives the processor, the memory and the drawing the same 25 jobs on every machine and times each one. Every score is a multiple of the first IBM PC, so the machine in the picture -- that PC, emulated cycle by cycle -- scores about 1x.

jobs timed
25
the IBM PC scores
1.00x
size
one 13.5KB file
How to run it Get the disk
REDLINE
The REDLINE Summary view on VGA. A large 1.02x headline under CPU + RAM Performance, relative to the 4.77 MHz PC. A system snapshot lists an 8088-compatible processor, an estimated 4.68 MHz, 640KB of memory and a 640 by 480 VGA screen. Below, 25 bars in blue, green and red each read between 1.00x and 1.10x.
The reference machine, measuring itself. An IBM PC with a 4.77 MHz 8088 and a VGA card, emulated by MartyPC. Every bar lands between 1.00x and 1.10x, because the reference is the middle of three measured trials and a single run falls a few percent either side of it.

What a benchmark is

A fixed amount of work, a stopwatch, and a machine to compare against.

A benchmark is a program that gives a computer a fixed job and measures how long it takes. One timing on its own says little. What makes it useful is a second machine that did the same job, so the answer can be "three times as fast as that one" rather than a number of milliseconds nobody can picture.

DOS had several well-known ones. Norton's System Information, Landmark and CheckIt each put a hardware summary, a score and a row of comparison bars on one screen, scored against some reference PC. Under Windows 3.1, WinTach and WinBench timed the graphics system itself: lines, fills, text and copies of rectangles of pixels. REDLINE takes its layout from those programs and its reference from the machine os8088 is written for.

That reference is the IBM PC of 1981, with an Intel 8088 at 4.77 MHz. Every score is a multiple of it: 2.00x means a job ran in half the time it took that PC, and 1.00x is that PC exactly.

The 25 jobs

The same work on every machine, in three passes, averaged.

Processor and memory

Six jobs: chains of additions, rotations of a register, 16-bit multiplies, 32-by-16-bit divides, and copying and filling 2KB of memory. The large number at the top of Summary is the average of these six.

Basic drawing

Six more: a filled rectangle, a 256-pixel line, a rectangle's outline, a line of 31 characters, and two kinds of picture copied onto the screen. All of it goes through os8088's own drawing calls, the same ones every program uses.

Larger drawing

The same six again on a field up to 256 by 128 pixels: a full fill, a field of lines, nested frames, a grid of text and two larger pictures.

The hard ones

Seven: a wireframe cube and a shaded one, each turned through four full revolutions; a Mandelbrot set of 64 by 32 points; a patterned picture; a scroll; windows inside windows sliding about; and the window itself resized and repainted.

The drawing happens in a second window, the Graphics Lab, which opens for the run and closes when it ends, so you can watch each job while it is timed. A run goes through all 25 jobs three times and each score comes from the average of the three. The bars are drawn after the last job, outside the timing, so they cost the result nothing.

The timer is the PC's own clock chip, read directly, so each job is timed to under a millionth of a second. A job too long for that falls back to the system's tick of 18.2 a second, and the report marks every timing with which of the two it used.

See it running

The Graphics Lab at 4.77 MHz, and the same program on a modern computer.

REDLINE Graphics Lab
The Graphics Lab window, enlarged, showing a solid cube in perspective with a red face, a darker red face and a yellow face.
The shaded cube, on the 4.77 MHz PC. Eight corners turned and projected with whole-number arithmetic, the faces turned away from you thrown out, and the rest filled in. The lab window is shown at twice its size.
REDLINE Graphics Lab
The Graphics Lab window, enlarged, holding a blue-titled Scene container with a Window inside it, a Nested window inside that with an Object button, and a red wireframe cube beside them.
Windows inside windows. A container, a window in it, a window in that and a button, with a cube beside them. Each one is placed relative to the one holding it, and the job times moving them. Also at twice size, on the 4.77 MHz PC.
REDLINE
A benchmark in progress. The REDLINE window reads Run 1/3, L3 Mandelbrot 64x32, with a progress bar a quarter full. The Graphics Lab in front of it shows a Mandelbrot set in green, cyan, red, magenta and brown around a black centre.
A run in progress. The first of three passes, on the Mandelbrot job: 64 by 32 points, each tried up to 24 times, filling the lab. This is QEMU on a modern Mac, where a whole run takes under ten seconds.
REDLINE
The REDLINE Summary view in QEMU. The headline reads 2820.85x. The processor and memory bars read between 396x and 9029x; the drawing bars read between 26x and 190x and are barely visible on the shared scale.
The same program in QEMU. The processor and memory jobs average 2,820 times the IBM PC. The drawing jobs score only 26x to 190x, so on a scale shared with a 9,029x multiply they hardly show.
REDLINE
The Compare view: the 25 workload names down the left and one long bar for each, blue for the four processor jobs, green for the two memory jobs and red for the nineteen drawing jobs, with each score at the right.
Compare. The bars get the whole window. Every bar shares one scale: the highest score rounded up, plus 5x. Blue is the processor, green the memory and red the drawing.
REDLINE
The REDLINE Summary view on a CGA screen, 640 by 200: a large 1.02x headline, a short system snapshot, and the first two results with grey dithered bars.
On CGA. The 4.77 MHz PC with a CGA card, whose screen is 200 lines tall. Summary shrinks to fit and pages through the results, and the bars are dithered because the screen has no grey.

The reference PC

Measured on an emulator that keeps the original's timing, and committed with every number.

The 1.00x machine is an IBM PC model 5150: an Intel 8088 at 4.772727 MHz, 640KB of memory, two 360KB floppy drives and no turbo. It runs on MartyPC, an emulator that models the 8088 down to the cycle -- the queue it fetches instructions into, the bus, the time each instruction takes -- and is checked against tests taken on real 8088 chips.

The reference is three trials, each the average of three complete runs, and each job's figure is the middle of the three trials. The drawing has its own reference for each kind of screen: CGA at 640 by 200, Hercules at 720 by 348 and VGA at 640 by 480, all on the same PC. A screen that matches none of the three still gets its timings, but no drawing score, because comparing it with a different screen's figure would not mean anything.

Every sample, every trial and the exact versions of the program, the operating system and the emulator that produced them are saved in the source tree, along with the script that measures them again.

What it does not claim

The numbers it can stand behind, and the ones it leaves blank.

There is no single score for the whole machine. The large number is the processor and memory alone, and it says so. The drawing scores sit beside it, each against the reference for that screen.

It does not time the disk or a maths coprocessor. It reports whether a coprocessor is present and nothing more.

A processor's clock speed is reported in three different ways, and each is labelled with where it came from: the speed a modern processor states for itself, a speed measured from its own cycle counter, or an estimate for an old processor worked out from how long a multiply and a divide take. For a processor it cannot identify it shows no clock speed at all rather than guess. Memory is reported as the BIOS describes it, which is not always how much is fitted.

The reference comes from an emulator, and an emulator that keeps exact time is still not the same as the real machine. REDLINE has not yet been run against a real 4.77 MHz PC.

Running it

One file, one key, and a still mouse.

  1. Take redline.img from the release, in the size your machine uses: 1.44MB, 1.2MB, 720KB or 360KB. It is also on the everything disks, on the live USB image and CD, and on The Wire under Utilities.

  2. Boot os8088 with it in the second drive, double-click Disk B, and double-click REDLINE.O88.

  3. Close any other programs, press R or click Run, and leave the mouse alone until it finishes. Anything else the machine does during a run counts against it.

  4. U, D and C switch between Summary, Detailed and Compare, and Tab cycles them. S saves the whole report as REDLINE.TXT beside the program, with every sample and how it was timed.

Download os8088 How it measures The other programs