🚀 go-pugleaf

I sure can't say anything about those Sun-3 times, and I am 
curious about it also.  Could it be explained by simply a better
compiler?  

For example, the following table is part of one
circulated in USENET a while back, with times I've added
for various Apollo's.  Note that the Pascal versions run
much faster than the C versions (and likely do things
differently, so one shouldn't draw too many conclusions):

 * MACHINE	PROCESSOR	OPERATING	COMPILER	DHRYSTONES/SEC.
 * TYPE				SYSTEM				NO REG	REGS
 * --------------------------	------------	-----------	---------------
** Apollo DN300 68010-?Mhz      Aegis SR8       cc   r2.39       686      -
** Apollo DN320 68010-?Mhz      Aegis SR9       cc   r3.12       808      -
 * VAX 11/750	-		Unix 4.2bsd	cc		 862	 877
 * VAX 11/750	-		VMS		VAX-11 C 2.0	 958	1091
 * Sun2/120	68010-10Mhz	Sun 4.2BSD	cc		1136	1219
** Apollo DN300 68010-?Mhz      Aegis SR8       pas  r5.65      1332      -
** Apollo DN320 68010-?Mhz      Aegis SR9       pas  r6.59      1349      -
 * VAX 11/780	-		UNIX 5.2	cc		1515	1562
** Apollo DN660                 Aegis SR9       cc   r3.12      2030      -
** Apollo DN660                 Aegis SR9       pas  r6.59      2790      -
 * IRIS 2400T	68020-16.67MHz	Sys5 #14	cc		3105	3401
 * SUN 3/75	68020-16.67Mhz	SUN 4.2 V3	cc		3333	3571
 *

** Apollo times added by N. Holtz, Nov. 29, 1985, from results
   of March 84 version C/2 of Dhrystone (no register variables).

By the way, that figure reported of 1700 looks pretty low for a
DN330 -- I thought they were supposed to be slightly faster
than a DN660.  Were all the 'fast' options turned on? 

I suspect this is not the case (I haven't looked at the dhrystone
benchmark very carefully), but are there some funny optimizations
possible?  For example, when I first tried the following naive
benchmark (out of BYTE + many other places, I believe), I got
incredible (orders of magnitude) speed ups over other machines.

The Apollo compiler quite rightly did all the arithmetic at compile
time, and replaced the 14 statements with 14 MOVE's (but why didn't
it remove the the first 13 moves, at least, plus the loop as well?).
So obviously, this is pretty useless as a benchmark.

#define CONST1  3.1415926
#define CONST2  1.7839032
#define COUNT   10000

main()
{
        double a, b, c;
        int i;

        a = CONST1;
        b = CONST2;
        for (i = 0; i < COUNT; ++i) {
                c = a * b;
                c = c / a;
                c = a * b;
                c = c / a;
                c = a * b;
                c = c / a;
                c = a * b;
                c = c / a;
                c = a * b;
                c = c / a;
                c = a * b;
                c = c / a;
                c = a * b;
                c = c / a;
        }
        printf("Done\n");
}