Relay-Version: version B 2.10 5/3/83; site utzoo.UUCP
Path: utzoo!mnetor!uunet!husc6!cmcl2!nrl-cmf!ukma!psuvm.bitnet!tuccvm.bitnet!npasmith
From: NPASMITH@TUCCVM.BITNET (Philip A. Smith)
Newsgroups: comp.sys.ibm.pc
Subject: Benchmarks
Message-ID: <19NPASMITH@TUCCVM>
Date: Thu, 12-Nov-87 20:55:13 EST
Article-I.D.: TUCCVM.19NPASMITH
Posted: Thu Nov 12 20:55:13 1987
Date-Received: Mon, 16-Nov-87 07:11:56 EST
Organization: Triangle Universities Computation Center 
           I just spent a week benchmarking all the machines I could gain access to.  The benc
Lines: The benc
Keywords: arks are included at the end of this file (C and FORTRAN).  The objective was to figure out which

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 ******