# Floating point performance of classic minicomputers

Are there any numbers available for the floating point performance of classic minicomputers of the seventies and eighties? For example, the VAX 11/780 for integer calculations was generally rated in the ballpark of one MIPS, similar to the 68000 and 286, but I can't find any corresponding figures for floating point.

I do have a figure of 50 kflops for the 8087, so a comparison to that would be useful, as would raw flops numbers.

The Whetstone table may be useful. The ratio of Whetstones/s to FLOPS varies, but not too much.

A whetstone test outputs a table, like

``````Loop content                 Result            MFLOPS     MOPS   Seconds

N1 floating point    -1.12475025653839100      19.971              0.274
N2 floating point    -1.12274754047393800      11.822              3.240
N3 if then else       1.00000000000000000               11.659     2.530
N4 fixed point       12.00000000000000000               13.962     6.430
N5 sin,cos etc.       0.49904659390449520                2.097    11.310
N6 floating point     0.99999988079071040       3.360             45.750
N7 assignments        3.00000000000000000                2.415    21.810
N8 exp,sqrt etc.      0.75110864639282230                1.206     8.790

MWIPS                                          28.462            100.134
``````

(from the C language variant of Whetstone, for a 100 MHz Pentium.) The overall MFLOPS result can be computed as the geometric mean of the three MFLOPS values in lines 1, 2, and 6, as suggested in the Whetstone table explanation. In this case it will be cube_root(19.971*11.822*3.36)=9.257 MFLOPS. Why they didn't add a few lines of code to compute and print it automatically, is beyond me.

Not all rows in the table have the MFLOPS value because on most machines an older version of Whetstone was run that did not report MFLOPS per loop.

For VAX 11/780, luckily, we have the MFLOPS value (0.25 - with FPU, which would be a fair comparison with 8087, that is 5x).

For most DEC systems, when both MWIPS and MFLOPS figures are given, the ratio between Whetstones/s and FLOPS varies between 3.5x and 4x, so a reasonable comparison can be made with other systems for which the MFLOPS value is not provided. For example, a PDP 11/34 with hardware FP, reported as 0.204 MWIPS, would likely have performed approximately at 50 KFLOPS.

There are nearly endless benchmarks (see a short list of relevance at Benchmark Programs and Reports on the Top500 site) and it may need a bit of work to understand each benchmark's implications (see Benchmark Tutorial, in IEEE Micro 1989, or An Overview of Common Benchmarks in Computer 12/1990). Benchmarking will always give only a rough estimation, so all numbers should be taken with a serious amount of salt.

Having said that, one of the longest running measurements, the Whetstone Benchmark, is quite useful for us, as it's been around since 1972. Its details were described in an article in 1976 Computer Journal. Its result is given in so called Whetstone Instructions Per Second, usually noted as KiloWIPS or MegaWIPS.

Originally developed in ALGOL60 it has been ported to next to all languages available and many computers. This was possible as the benchmark isn't defined as a specific source code (like with SPEC), but a series of (FP) operations. So, to some extent, it also relies on programming skills as well as the compiler used. Alas due to its simple nature, programmers' skills will only show up as long as the compiler is rather bad in supporting a (new) machine.

As with every benchmark, it also measures memory access, control structures, etc., not only FP instructions. But translation is rather well defined, so with detailed numbers, WIPS can be translated into FLOPS. Or just used as they are for the sake of simplicity.

Some examples for common machines are:

``````MWIPS  Machine    Environment
0.0027 Apple II   Applesoft
0.0188 PDP 11/20  Fortran
0.0852 80286/87   Fortran
0.74   VAX 11/780 Fortran, No FPU
1.02   VAX 11/780 Fortran
2.4    SUN 3/160  Fortran 68020/881@16 MHz
``````

All values are taken from the Whetstone Benchmark History and Results, written by Roy Longbottom who was involved with application of Whetstone almost since the beginning. It provides not only much information about the development, but also quite extensive lists of machines, focusing on scientific usage. His site includes quite a lot more information about benchmarks than just Whetstone.

But there are many other sites/lists around the web, so a search may help to find values for the machines you are searching for. Or just go ahead and implement it yourself - it's really just a few (hundred) lines of code (some FORTRAN required).

This is not so much quantitative data as qualitative annecdote.

Many years ago, I interfaced an NSC MM-57109 "math" chip to the Z-80 system I was building at the time. It gave me access to much better calculating abilities than I would otherwise have had access to. A professor at York University, Keith Aldridge, approached me to see if this chip could be fitted to the Interdata 5/16 minicomputer he was using.

To get to the point, the first step was to benchmark the performance of the 5/16 computer's software based floating point. It was pretty good. On the order of 50 microseconds for most operations (sorry, that data is long lost). Much faster than the MM-57109 which needed several milliseconds for most tasks. We investigated using the then brand new 8087 chip, but were forced to conclude that the overhead of interprocessor communication and format translation made this a losing proposition.

As Dr Aldridge said when I presented my findings: "Engineers look for answers; Sometimes the answer is NO!"

I ended up working with his grad students improving their FORTRAN code. I could usually improve throughput by applying a few simple transformations.

In the end, another colleague donated a 32 bit Interdata (by then Perkin Elmer) machine that had floating point in hardware.