sdcc-extra/historygraphs/whetstone-mcs51/whetstone.c

   1 /*
   2  * C Converted Whetstone Double Precision Benchmark
   3  *              Version 1.2     22 March 1998
   4  *
   5  *      (c) Copyright 1998 Painter Engineering, Inc.
   6  *              All Rights Reserved.
   7  *
   8  *              Permission is granted to use, duplicate, and
   9  *              publish this text and program as long as it
  10  *              includes this entire comment block and limited
  11  *              rights reference.
  12  *
  13  * Converted by Rich Painter, Painter Engineering, Inc. based on the
  14  * www.netlib.org benchmark/whetstoned version obtained 16 March 1998.
  15  *
  16  * A novel approach was used here to keep the look and feel of the
  17  * FORTRAN version.  Altering the FORTRAN-based array indices,
  18  * starting at element 1, to start at element 0 for C, would require
  19  * numerous changes, including decrementing the variable indices by 1.
  20  * Instead, the array E1[] was declared 1 element larger in C.  This
  21  * allows the FORTRAN index range to function without any literal or
  22  * variable indices changes.  The array element E1[0] is simply never
  23  * used and does not alter the benchmark results.
  24  *
  25  * The major FORTRAN comment blocks were retained to minimize
  26  * differences between versions.  Modules N5 and N12, like in the
  27  * FORTRAN version, have been eliminated here.
  28  *
  29  * An optional command-line argument has been provided [-c] to
  30  * offer continuous repetition of the entire benchmark.
  31  * An optional argument for setting an alternate LOOP count is also
  32  * provided.  Define PRINTOUT to cause the POUT() function to print
  33  * outputs at various stages.  Final timing measurements should be
  34  * made with the PRINTOUT undefined.
  35  *
  36  * Questions and comments may be directed to the author at
  37  *                      r.painter@ieee.org
  38  */
  39 /*
  40 C**********************************************************************
  41 C     Benchmark #2 -- Double  Precision Whetstone (A001)
  42 C
  43 C     o This is a REAL*8 version of
  44 C       the Whetstone benchmark program.
  45 C
  46 C     o DO-loop semantics are ANSI-66 compatible.
  47 C
  48 C     o Final measurements are to be made with all
  49 C       WRITE statements and FORMAT sttements removed.
  50 C
  51 C**********************************************************************
  52 */
  53
  54 /* standard C library headers required */
  55 #include <stdlib.h>
  56 #include <stdio.h>
  57 #include <string.h>
  58 #include <math.h>
  59
  60 /* the following is optional depending on the timing function used */
  61 void init(void);
  62 unsigned long int clock(void);
  63 void clockinc(void) __interrupt(1);
  64
  65 /* map the FORTRAN math functions, etc. to the C versions */
  66 #define DSIN    sinf
  67 #define DCOS    cosf
  68 #define DATAN   atanf
  69 #define DLOG    logf
  70 #define DEXP    expf
  71 #define DSQRT   sqrtf
  72 #define IF              if
  73
  74 /* function prototypes */
  75 void POUT(long N, long J, long K, double X1, double X2, double X3, double X4);
  76 void PA(double E[]);
  77 void P0(void);
  78 void P3(double X, double Y, double *Z);
  79 #define USAGE   "usage: whetdc [-c] [loops]\n"
  80
  81 /*
  82         COMMON T,T1,T2,E1(4),J,K,L
  83 */
  84 double T,T1,T2,E1[5];
  85 int J,K,L;
  86
  87 int
  88 main(int argc, char *argv[])
  89 {
  90         /* used in the FORTRAN version */
  91         long I;
  92         long N1, N2, N3, N4, N6, N7, N8, N9, N10, N11;
  93         double X1,X2,X3,X4,X,Y,Z;
  94         long LOOP;
  95         int II, JJ;
  96
  97         /* added for this version */
  98         long startmsec, finimsec;
  99         float KIPS;
 100         int continuous;
 101
 102         continuous = 0;
 103
 104     init();
 105 LCONT:
 106 /*
 107 C
 108 C       Start benchmark timing at this point.
 109 C
 110 */
 111         startmsec = clock();
 112
 113 /*
 114 C
 115 C       The actual benchmark starts here.
 116 C
 117 */
 118         T  = .499975;
 119         T1 = 0.50025;
 120         T2 = 2.0;
 121 /*
 122 C
 123 C       With loopcount LOOP=10, one million Whetstone instructions
 124 C       will be executed in EACH MAJOR LOOP..A MAJOR LOOP IS EXECUTED
 125 C       'II' TIMES TO INCREASE WALL-CLOCK TIMING ACCURACY.
 126 C
 127         LOOP = 1000;
 128 */
 129         LOOP = 10;
 130         II   = 1;
 131
 132         JJ = 1;
 133
 134 IILOOP:
 135         N1  = 0;
 136         N2  = 12 * LOOP;
 137         N3  = 14 * LOOP;
 138         N4  = 345 * LOOP;
 139         N6  = 210 * LOOP;
 140         N7  = 32 * LOOP;
 141         N8  = 899 * LOOP;
 142         N9  = 616 * LOOP;
 143         N10 = 0;
 144         N11 = 93 * LOOP;
 145 /*
 146 C
 147 C       Module 1: Simple identifiers
 148 C
 149 */
 150         X1  =  1.0;
 151         X2  = -1.0;
 152         X3  = -1.0;
 153         X4  = -1.0;
 154
 155         for (I = 1; I <= N1; I++) {
 156             X1 = (X1 + X2 + X3 - X4) * T;
 157             X2 = (X1 + X2 - X3 + X4) * T;
 158             X3 = (X1 - X2 + X3 + X4) * T;
 159             X4 = (-X1+ X2 + X3 + X4) * T;
 160         }
 161 #ifdef PRINTOUT
 162         IF (JJ==II)POUT(N1,N1,N1,X1,X2,X3,X4);
 163 #endif
 164
 165 /*
 166 C
 167 C       Module 2: Array elements
 168 C
 169 */
 170         E1[1] =  1.0;
 171         E1[2] = -1.0;
 172         E1[3] = -1.0;
 173         E1[4] = -1.0;
 174
 175         for (I = 1; I <= N2; I++) {
 176             E1[1] = ( E1[1] + E1[2] + E1[3] - E1[4]) * T;
 177             E1[2] = ( E1[1] + E1[2] - E1[3] + E1[4]) * T;
 178             E1[3] = ( E1[1] - E1[2] + E1[3] + E1[4]) * T;
 179             E1[4] = (-E1[1] + E1[2] + E1[3] + E1[4]) * T;
 180         }
 181
 182 #ifdef PRINTOUT
 183         IF (JJ==II)POUT(N2,N3,N2,E1[1],E1[2],E1[3],E1[4]);
 184 #endif
 185
 186 /*
 187 C
 188 C       Module 3: Array as parameter
 189 C
 190 */
 191         for (I = 1; I <= N3; I++)
 192                 PA(E1);
 193
 194 #ifdef PRINTOUT
 195         IF (JJ==II)POUT(N3,N2,N2,E1[1],E1[2],E1[3],E1[4]);
 196 #endif
 197
 198 /*
 199 C
 200 C       Module 4: Conditional jumps
 201 C
 202 */
 203         J = 1;
 204         for (I = 1; I <= N4; I++) {
 205                 if (J == 1)
 206                         J = 2;
 207                 else
 208                         J = 3;
 209
 210                 if (J > 2)
 211                         J = 0;
 212                 else
 213                         J = 1;
 214
 215                 if (J < 1)
 216                         J = 1;
 217                 else
 218                         J = 0;
 219         }
 220
 221 #ifdef PRINTOUT
 222         IF (JJ==II)POUT(N4,J,J,X1,X2,X3,X4);
 223 #endif
 224
 225 /*
 226 C
 227 C       Module 5: Omitted
 228 C       Module 6: Integer arithmetic
 229 C
 230 */
 231
 232         J = 1;
 233         K = 2;
 234         L = 3;
 235
 236         for (I = 1; I <= N6; I++) {
 237             J = J * (K-J) * (L-K);
 238             K = L * K - (L-J) * K;
 239             L = (L-K) * (K+J);
 240             E1[L-1] = J + K + L;
 241             E1[K-1] = J * K * L;
 242         }
 243
 244 #ifdef PRINTOUT
 245         IF (JJ==II)POUT(N6,J,K,E1[1],E1[2],E1[3],E1[4]);
 246 #endif
 247
 248 /*
 249 C
 250 C       Module 7: Trigonometric functions
 251 C
 252 */
 253         X = 0.5;
 254         Y = 0.5;
 255
 256         for (I = 1; I <= N7; I++) {
 257                 X = T * DATAN(T2*DSIN(X)*DCOS(X)/(DCOS(X+Y)+DCOS(X-Y)-1.0));
 258                 Y = T * DATAN(T2*DSIN(Y)*DCOS(Y)/(DCOS(X+Y)+DCOS(X-Y)-1.0));
 259         }
 260
 261 #ifdef PRINTOUT
 262         IF (JJ==II)POUT(N7,J,K,X,X,Y,Y);
 263 #endif
 264
 265 /*
 266 C
 267 C       Module 8: Procedure calls
 268 C
 269 */
 270         X = 1.0;
 271         Y = 1.0;
 272         Z = 1.0;
 273
 274         for (I = 1; I <= N8; I++)
 275                 P3(X,Y,&Z);
 276
 277 #ifdef PRINTOUT
 278         IF (JJ==II)POUT(N8,J,K,X,Y,Z,Z);
 279 #endif
 280
 281 /*
 282 C
 283 C       Module 9: Array references
 284 C
 285 */
 286         J = 1;
 287         K = 2;
 288         L = 3;
 289         E1[1] = 1.0;
 290         E1[2] = 2.0;
 291         E1[3] = 3.0;
 292
 293         for (I = 1; I <= N9; I++)
 294                 P0();
 295
 296 #ifdef PRINTOUT
 297         IF (JJ==II)POUT(N9,J,K,E1[1],E1[2],E1[3],E1[4]);
 298 #endif
 299
 300 /*
 301 C
 302 C       Module 10: Integer arithmetic
 303 C
 304 */
 305         J = 2;
 306         K = 3;
 307
 308         for (I = 1; I <= N10; I++) {
 309             J = J + K;
 310             K = J + K;
 311             J = K - J;
 312             K = K - J - J;
 313         }
 314
 315 #ifdef PRINTOUT
 316         IF (JJ==II)POUT(N10,J,K,X1,X2,X3,X4);
 317 #endif
 318
 319 /*
 320 C
 321 C       Module 11: Standard functions
 322 C
 323 */
 324         X = 0.75;
 325
 326         for (I = 1; I <= N11; I++)
 327                 X = DSQRT(DEXP(DLOG(X)/T1));
 328
 329 #ifdef PRINTOUT
 330         IF (JJ==II)POUT(N11,J,K,X,X,X,X);
 331 #endif
 332
 333 /*
 334 C
 335 C      THIS IS THE END OF THE MAJOR LOOP.
 336 C
 337 */
 338         if (++JJ <= II)
 339                 goto IILOOP;
 340
 341 /*
 342 C
 343 C      Stop benchmark timing at this point.
 344 C
 345 */
 346         finimsec = clock();
 347
 348 /*
 349 C----------------------------------------------------------------
 350 C      Performance in Whetstone KIP's per second is given by
 351 C
 352 C       (100*LOOP*II)/TIME
 353 C
 354 C      where TIME is in seconds.
 355 C--------------------------------------------------------------------
 356 */
 357         printf("\n");
 358         if (finimsec-startmsec <= 0) {
 359                 printf("Insufficient duration- Increase the LOOP count\n");
 360                 return(1);
 361         }
 362
 363         printf("Loops: %ld, Iterations: %d, Duration: %ld msec.\n",
 364                         LOOP, II, finimsec-startmsec);
 365
 366         KIPS = (100.0*LOOP*II)/((float)(finimsec-startmsec)/1000.0f);
 367         if (KIPS >= 1000.0)
 368                 printf("C Converted Double Precision Whetstones: %.1f MIPS\n", KIPS/1000.0);
 369         else
 370                 printf("C Converted Double Precision Whetstones: %.1f KIPS\n", KIPS);
 371
 372         if (continuous)
 373                 goto LCONT;
 374
 375         return(0);
 376 }
 377
 378 void
 379 PA(double E[])
 380 {
 381         J = 0;
 382
 383 L10:
 384         E[1] = ( E[1] + E[2] + E[3] - E[4]) * T;
 385         E[2] = ( E[1] + E[2] - E[3] + E[4]) * T;
 386         E[3] = ( E[1] - E[2] + E[3] + E[4]) * T;
 387         E[4] = (-E[1] + E[2] + E[3] + E[4]) / T2;
 388         J += 1;
 389
 390         if (J < 6)
 391                 goto L10;
 392 }
 393
 394 void
 395 P0(void)
 396 {
 397         E1[J] = E1[K];
 398         E1[K] = E1[L];
 399         E1[L] = E1[J];
 400 }
 401
 402 void
 403 P3(double X, double Y, double *Z)
 404 {
 405         double X1, Y1;
 406
 407         X1 = X;
 408         Y1 = Y;
 409         X1 = T * (X1 + Y1);
 410         Y1 = T * (X1 + Y1);
 411         *Z  = (X1 + Y1) / T2;
 412 }
 413
 414 #ifdef PRINTOUT
 415 void
 416 POUT(long N, long J, long K, double X1, double X2, double X3, double X4)
 417 {
 418         printf("%7ld %7ld %7ld %12.4e %12.4e %12.4e %12.4e\n",
 419                                                 N, J, K, X1, X2, X3, X4);
 420 }
 421 #endif