[comp.sys.ibm.pc] Benchmarks

kalra@cit-vax.UUCP (06/14/87)

Could someone please point to a reference to various benchmarks, specifically
the Dhrystones. Also what does the Norton Index mean.

Thanks

paul@cgh.UUCP (06/15/87)

In article <3019@cit-vax.Caltech.Edu> kalra@cit-vax.UUCP (Devendra Kalra) writes:
>
>... Also what does the Norton Index mean.

One of the programs distributed with the Norton Utilities is SI, or
Speed Index.  When run, it produces a number which is supposed to be an
Index relative to the original IBM PC.  That is, a Norton SI of 2.0 is
supposed to mean that the current machine is 2 times faster than a
standard PC. 

However, beware: the test uses a small subset of machine instructions
and the values it gives can vary wildly when used on different families
of processors.  It gives entirely misleading results when comparing say,
an 8088 and an 80286, or an 8086 and a V20. 

To summarize: the Norton Index means nothing.  You would be well advised
to ignore all claims based on it unless you are comparing like
processors, in which case it can show you the relative clock speeds.

NPASMITH@TUCCVM.BITNET (Philip A. Smith) (11/13/87)

Machine     |    CPU   |N=30 |N=30 |N=50 |N=50 | N=70 ||     |     |
            |          |FORT | C   |FORT | C   | FORT ||FORT |  C  |
IBM XT      | 8088/7   |-----|60.57|-----|-----|------||-----|62.93|
Zenith Z158 | V20/8087 |50.55|39.31|-----|-----|------||-----|42.96|
Everex 1800 | 80286    |-----|299.0|-----|-----|------||-----|17.18|
IBM AT 6MHz | 80286/7  |76.89|60.26|-----|-----|------||-----|23.05|
IBM AT 16MHz| 80386/7  |15.73|13.60|-----|61.60|------||-----| 7.48|
Zenith Z386 | 80386    |-----|132.2|-----|-----|------||-----| 6.85|
            | Sun 3/60 | 6.43|-----|35.95|-----|100.21||-----| 9.76|
        *   | Microvax |12.37|-----|42.05|-----|108.35||15.35|-----|
        *   | Vax11/785| 6.66|-----|20.13|-----| 48.88||11.18|-----|
        *   | IBM 4341 | 4.16| 7.26|19.03|33.54| 52.09|| 8.45| 6.65|
        *   | IBM 4381 | 1.65| 2.90| 7.10|13.34| 19.55|| 4.23| 3.73|
        *   | IBM 3081 | 0.56| 1.01| 2.53| 4.71|  6.93|| 1.06| 1.28|
        *   | IBM 3090 | 0.18| 0.39| 0.80| 1.80|  2.19|| 0.51| 0.69|
            +----------+-----+-----+-----+-----+------++-----+-----+
* CPU time reported by operating system, all others elapsed time.
     
     
           Interesting Observations:  The Everex 1800 and Zenith Z386
      did not have math coprocessors (I would expect them to do very
      well if they did) !  The "16MHz IBM AT" was a 6MHz AT with an
      Intel Inboard/386 card and 80387 math coprocessor.
                 Look at the integer time for the Z386!  This was a base
      model without the 64k memory cache, so this time could be
      improved.  Something weird is happening with the Sun 3/60 -- for
      longer runs it is "asymptotically" approaching Microvax
      performance.  The Vaxes integer performance was
      disappointing.
     
           This ought to make owners of XT/AT/386's feel better.  I was
      going to have a "cost" column for each machine but I don't have
      the slightest idea what a 3090  , etc.  costs (10**7 $ ?), plus
      university pricing is vastly different from retail.  If someone
      wants to enlighten us, please do.
     
           When you consider that many of the big machines run with an
      "overload factor" (elapsed time/CPU time) of 5-20, you might get
      your work done faster on a micro.  If you've used TSO on an
      overloaded big IBM, you won't get too enthused about "multiuser"
      PCs.
     
                           ************************************
     
        Floating-point benchmark - triple integration by the mid-point rule.
        Note that the exp(x/y) can be pulled out of the inner loop by a smart
        optimizing compiler -- if a machine has such a compiler then it
        deserves the better benchmark time.  (Not efficient but easy to
        type into machines that aren't networked to anything.)
     
                                       *** bench.c ***
        #include <stdio.h>
        #include <math.h>
     
        main()
        {
        double d,start,x,y,z,v=0;
        int i,j,k,n;
        puts("enter n:"); scanf("%d",&n);
        d=1.0/n; start=1.0+0.5*d;
        for( x=start,i=0; i<n; x+=d, ++i)
        for( y=start,j=0; j<n; y+=d, ++j)
        for( z=start,k=0; k<n; z+=d, ++k)
          v += sin(x*y*z)*exp(x/y)*log(y/z);
        v *= d*d*d;
        printf("\nn=%d, v=%25.16le",n,v);
        }
     
                                       *** bench.for ***
     
              IMPLICIT REAL*8(A-H,O-Z)
              WRITE(*,*) 'ENTER N:'
              READ(*,*) N
              D=1.0/N
              START = 1.0D0 - 0.5*D
              X=START
              DO 10 I=1,N
              X=X+D
              Y=START
              DO 10 J=1,N
              Y=Y+D
              Z=START
              DO 10 K=1,N
              Z=Z+D
        10    V=V+ DSIN(X*Y*Z)*DEXP(X/Y)*DLOG(Y/Z)
              V=V*(D**3)
              WRITE(*,*) 'N=',N,' V=',V
              STOP
              END
     
                       ************************************
     
        Integer benchmark -- Calculate 1899 prime numbers 100 times.
        (One should check that an optimizing compiler does not move
        the body of the program outside the "100 loop" [change the 100
        to 50 and see if execution time is halved.])
        (Adaptations of sieve of Eratosthenes benchmark (Byte magazine orig.)).
     
                               *** sieve.c ***
        #define S 8190
        char f[S+1];
        main()
        {
          register int i,p,k,c,n;
          for (n = 1; n <= 100; n++)
            {
            c = 0;
            for (i = 0; i <= S; i++) f[i] = 1;
            for (i = 0; i <= S; i++)
              {
              if (f[i])
                {
                p = i + i + 3; k = i + p;
                while (k <= S) { f[k] = 0; k += p; }
                c++;
                }
              }
            }
          printf("\n%d primes.\n", c);
        }
     
                               *** sieve.for ***
              INTEGER I,P,K,C,N,F(0:8190)
              DO 10 N=1,100
                C = 0
                DO 20 I=0,8190
        20        F(I) = 1
                DO 30 I=0,8190
                  IF (F(I).NE.0) THEN
                    P = I + I + 3
                    K = I + P
        50          IF (K.GT.8190) GOTO 40
                    F(K) = 0
                    K = K + P
                    GOTO 50
        40          CONTINUE
                    C = C + 1
                  END IF
        30      CONTINUE
        10    CONTINUE
              WRITE(*,*) C, 'PRIMES'
              STOP
              END
     
*****  End of file ******
     

promac@iisat.UUCP (Promac Systems) (05/30/89)

After scanning through all the latest "CLONE" mags looking at all of the
benchmarks(I know that they are not the end of all comparsions), I thought
that I would like to see for myself how the Motorola based systems
standup. Does anyone have the C source code for the LinPack, matrix, and
other assorted benchmarks that they could E-mail to me.
later
Barry Comer

promac@iisat.UUCP

conan@vax1.acs.udel.EDU (Robert B Carroll) (05/31/89)

In article <14@iisat.UUCP> promac@iisat.UUCP (Promac Systems) writes:
>Does anyone have the C source code for the LinPack, matrix, and
>other assorted benchmarks that they could E-mail to me.
>Barry Comer
>promac@iisat.UUCP

look in uunet.
i remember getting some dhrystone and whetstone stuff.

-- 
conan@vax1.acs.udel.edu OR conan@192.5.57.1
CONAN THE BARBARIAN of Cimmeria

ecf_udwo@jhunix.HCF.JHU.EDU (Douglas W O'Neal) (05/31/89)

>Does anyone have the C source code for the LinPack, matrix, and
>other assorted benchmarks that they could E-mail to me.
>Barry Comer
>promac@iisat.UUCP

You can get these from from the netlib.  Send a mail message
consisting of the line
	send index
to netlib@anl-mcs.arpa to get the full list of software available.

Doug O'Neal