home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 1996 September / PCWK996.iso / demo / wgelectr / pk51demo / files.2 / EXAMPLES / WHETS / WHETS.C < prev    next >
C/C++ Source or Header  |  1995-06-08  |  7KB  |  315 lines
  1. /*********************************************************************** */
  2. /*     Benchmark #2 -- Single Precision Whetstone (A001)                 */
  3. /*                                                                       */
  4. /*     o    This is a REAL*4 version of                              */
  5. /*    the Whetstone benchmark program.                                 */
  6. /*                                                                       */
  7. /*     o    DO-loop semantics are ANSI-66 compatible.                */
  8. /*                                                                       */
  9. /*     o    Final measurements are to be made with all               */
  10. /*    WRITE statements and FORMAT statements removed.                  */
  11. /*                                                                       */
  12. /*********************************************************************** */
  13. #include <math.h>
  14. #include <stdio.h>
  15.  
  16. #define CPU8051
  17. /*  #define NOPRINT  */
  18.  
  19. #ifdef CPU8051
  20. extern initserial ();
  21. #define HZ  125   /* 125 Interrupt per Second for time function */
  22. #else
  23. #define HZ  1
  24. #endif
  25.  
  26. extern long time (long *);
  27.  
  28. /* prototypes */
  29. POUT(int N, int J, int K, float X1, float X2, float X3, float X4);
  30. PA(float E[5]);
  31. P0();
  32. P3(float *X, float *Y, float *Z);
  33.  
  34. /*    IMPLICIT REAL*4 (A-H,O-Z); */
  35.  
  36.     float T,T1,T2,E1[5];
  37.   int J,K,L;
  38.     float X1,X2,X3,X4;
  39.     long ptime,time0;
  40.  
  41. main () {
  42.     int LOOP,I,II,JJ,N1,N2,N3,N4,N5,N6,N7,N8,N9,N10,N11;
  43.     float X,Y,Z;
  44.     long time1;
  45.  
  46. /*    Start benchmark timing at this point. */
  47. #ifdef CPU8051
  48.         initserial ();
  49. #endif
  50.     printf (" Benchmark #2 -- Single Precision Whetstone (A001)\n");
  51.     time0 = time((long *) 0);
  52.     ptime = time0;
  53.  
  54. /*    The actual benchmark starts here. */
  55.  
  56.     T = .499975;
  57.     T1 = 0.50025;
  58.     T2 = 2.0;
  59.  
  60. /*    With loopcount LOOP=10, one million Whetstone instructions */
  61. /*    will be executed in EACH MAJOR LOOP..A MAJOR LOOP IS EXECUTED */
  62. /*    'II' TIMES TO INCREASE WALL-CLOCK TIMING ACCURACY. */
  63.  
  64.     LOOP = 1;
  65.     II   = 1;
  66.  
  67.     for (JJ=1;JJ<=II;JJ++) { /* DO 500 JJ=1,II; */
  68.  
  69. /*    Establish the relative loop counts of each module. */
  70.  
  71.     N1 = 0;
  72.     N2 = 12 * LOOP;
  73.     N3 = 14 * LOOP;
  74.     N4 = 345 * LOOP;
  75.     N5 = 0;
  76.     N6 = 210 * LOOP;
  77.     N7 = 32 * LOOP;
  78.     N8 = 899 * LOOP;
  79.     N9 = 616 * LOOP;
  80.     N10 = 0;
  81.     N11 = 93 * LOOP;
  82.  
  83. /*    Module 1: Simple identifiers */
  84.  
  85.     X1 = 1.0;
  86.     X2 = -1.0;
  87.     X3 = -1.0;
  88.     X4 = -1.0;
  89.  
  90.     if (N1!=0) { /* GO TO 35; */
  91.         for(I=1;I<=N1;I++) { /* DO 30 I=1,N1; */
  92.         X1 = (X1 + X2 + X3 - X4)*T;
  93.         X2 = (X1 + X2 - X3 + X4)*T;
  94.         X3 = (X1 - X2 + X3 + X4)*T;
  95.         X4 = (-X1 + X2 + X3 + X4)*T;
  96. /* 30 */    };
  97. /* 35 */    };
  98.  
  99.     if (JJ==II) POUT(N1,N1,N1,X1,X2,X3,X4);
  100.  
  101. /*    Module 2: Array elements */
  102.  
  103.     E1[1] = 1.0;
  104.     E1[2] = -1.0;
  105.     E1[3] = -1.0;
  106.     E1[4] = -1.0;
  107.  
  108.     if (N2!=0) { /* GO TO 45; */
  109.         for (I=1;I<=N2;I++) { /* DO 40 I=1,N2; */
  110.         E1[1] = (E1[1] + E1[2] + E1[3] - E1[4])*T;
  111.         E1[2] = (E1[1] + E1[2] - E1[3] + E1[4])*T;
  112.         E1[3] = (E1[1] - E1[2] + E1[3] + E1[4])*T;
  113.         E1[4] = (-E1[1] + E1[2] + E1[3] + E1[4])*T;
  114. /* 40 */    };
  115. /* 45 */    };
  116.  
  117.     if (JJ==II) POUT(N2,N3,N2,E1[1],E1[2],E1[3],E1[4]);
  118.  
  119. /*    Module 3: Array as parameter */
  120.  
  121.     if (N3!=0) { /* GO TO 59; */
  122.         for (I=1;I<=N3;I++) { /* DO 50 I=1,N3; */
  123.         PA(E1);
  124. /* 50 */    };
  125. /* 59 */    };
  126.  
  127.     if (JJ==II) POUT(N3,N2,N2,E1[1],E1[2],E1[3],E1[4]);
  128.  
  129. /*    Module 4: Conditional jumps */
  130.  
  131.     J = 1;
  132.     if (N4!=0) { /* GO TO 65; */
  133.         for (I=1;I<=N4;I++) { /* DO 60 I=1,N4; */
  134.         if (J==1) goto L51;
  135.         J = 3;
  136.         goto L52;
  137. L51:        J = 2;
  138. L52:        if (J > 2) goto L53;
  139.         J = 1;
  140.         goto L54;
  141. L53:        J = 0;
  142. L54:        if (J < 1) goto L55;
  143.         J = 0;
  144.         goto L60;
  145. L55:        J = 1;
  146. L60:    ;    };
  147. /* 65 */    };
  148.  
  149.     if (JJ==II) POUT(N4,J,J,X1,X2,X3,X4);
  150.  
  151. /*    Module 5: Omitted */
  152. /*     Module 6: Integer arithmetic */
  153.  
  154.     J = 1;
  155.     K = 2;
  156.     L = 3;
  157.  
  158.     if (N6!=0) { /* GO TO 75; */
  159.         for (I=1;I<=N6;I++) { /* DO 70 I=1,N6; */
  160.         J = J * (K-J) * (L-K);
  161.         K = L * K - (L-J) * K;
  162.         L = (L - K) * (K + J);
  163.         E1[L-1] = J + K + L;
  164.         E1[K-1] = J * K * L;
  165. /* 70 */    };
  166. /* 75 */    };
  167.  
  168.     if (JJ==II) POUT(N6,J,K,E1[1],E1[2],E1[3],E1[4]);
  169.  
  170. /*    Module 7: Trigonometric functions */
  171.  
  172.     X = 0.5;
  173.     Y = 0.5;
  174.  
  175.     if (N7!=0) { /* GO TO 85; */
  176.         for (I=1;I<=N7;I++) { /* DO 80 I=1,N7; */
  177.         X=T*atan(T2*sin(X)*cos(X)/(cos(X+Y)+cos(X-Y)-1.0));
  178.         Y=T*atan(T2*sin(Y)*cos(Y)/(cos(X+Y)+cos(X-Y)-1.0));
  179. /* 80 */    };
  180. /* 85 */    };
  181.  
  182.     if (JJ==II) POUT(N7,J,K,X,X,Y,Y);
  183.  
  184. /*    Module 8: Procedure calls */
  185.  
  186.     X = 1.0;
  187.     Y = 1.0;
  188.     Z = 1.0;
  189.  
  190.     if (N8!=0) { /* GO TO 95; */
  191.         for (I=1;I<=N8;I++) { /* DO 90 I=1,N8; */
  192.         P3(&X,&Y,&Z); /* FORTRAN semantics */
  193. /* 90 */    };
  194. /* 95 */    };
  195.  
  196.     if (JJ==II) POUT(N8,J,K,X,Y,Z,Z);
  197.  
  198. /*    Module 9: Array references */
  199.  
  200.     J = 1;
  201.     K = 2;
  202.     L = 3;
  203.     E1[1] = 1.0;
  204.     E1[2] = 2.0;
  205.     E1[3] = 3.0;
  206.  
  207.     if (N9!=0) { /* GO TO 105; */
  208.         for (I=1;I<=N9;I++) { /* DO 100  I=1,N9; */
  209.         P0();
  210. /* 100 */    };
  211. /* 105 */    };
  212.  
  213.     if (JJ==II) POUT(N9,J,K,E1[1],E1[2],E1[3],E1[4]);
  214.  
  215. /*    Module 10: Integer arithmetic */
  216.  
  217.     J = 2;
  218.     K = 3;
  219.  
  220.     if (N10!=0) { /* GO TO 115; */
  221.         for (I=1;I<=N10;I++) { /* DO 110 I=1,N10; */
  222.         J = J + K;
  223.         K = J + K;
  224.         J = K - J;
  225.         K = K - J - J;
  226. /* 110 */    };
  227. /* 115 */    };
  228.  
  229.     if (JJ==II) POUT(N10,J,K,X1,X2,X3,X4);
  230.  
  231. /*    Module 11: Standard functions */
  232.  
  233.     X = 0.75;
  234.  
  235.     if (N11!=0) { /* GO TO 125; */
  236.         for (I=1;I<=N11;I++) { /* DO 120 I=1,N11; */
  237.         X = sqrt(exp(log(X)/T1));
  238. /* 120 */    };
  239. /* 125 */    };
  240.  
  241.     if (JJ==II) POUT(N11,J,K,X,X,X,X);
  242.  
  243. /*      THIS IS THE END OF THE MAJOR LOOP. */
  244.  
  245. /* 500 */    };
  246.  
  247. /*      Stop benchmark timing at this point. */
  248.  
  249.     time1 = time((long *) 0);
  250. /*---------------------------------------------------------------- */
  251. /*      Performance in Whetstone KIP's per second is given by */
  252.  
  253. /*    (100*LOOP*II*HZ)/TIME */
  254.  
  255. /*      where TIME is in seconds. */
  256. /*-------------------------------------------------------------------- */
  257.     printf (" Single Whetstone KIPS %d\n",(int)((100*LOOP*II*HZ)/(time1-time0)));
  258. #ifdef CPU8051
  259.     while (1);
  260. #else
  261.         exit (0);
  262. #endif
  263. }    /* END; */
  264.  
  265. PA(E) float E[5]; { /* SUBROUTINE PA(E); */
  266. /*    IMPLICIT REAL*4 (A-H,O-Z); */
  267. /*    DIMENSION E(4); */
  268. /*    COMMON T,T1,T2,E1(4),J,K,L; */
  269.     int J1;
  270.     J1 = 0;
  271. L10:    E[1] = (E[1] + E[2] + E[3] - E[4]) * T;
  272.     E[2] = (E[1] + E[2] - E[3] + E[4]) * T;
  273.     E[3] = (E[1] - E[2] + E[3] + E[4]) * T;
  274.     E[4] = (-E[1] + E[2] + E[3] + E[4]) / T2;
  275.     J1 = J1 + 1;
  276.     if ((J1 - 6) < 0) goto L10; /* 10,20,20; */
  277.  
  278. /* 20 */    return;
  279. }    /* END; */
  280.  
  281. P0() { /* SUBROUTINE P0; */
  282. /*    IMPLICIT REAL*4 (A-H,O-Z); */
  283. /*    COMMON T,T1,T2,E1(4),J,K,L; */
  284.     E1[J] = E1[K];
  285.     E1[K] = E1[L];
  286.     E1[L] = E1[J];
  287.     return;
  288. }    /* END; */
  289.  
  290. P3(X,Y,Z) float *X,*Y,*Z; { /* SUBROUTINE P3(X,Y,Z); */
  291. /*    IMPLICIT REAL*4 (A-H,O-Z); */
  292. /*    COMMON T,T1,T2,E1(4),J,K,L; */
  293.     float Y1;
  294.     X1 = *X;
  295.     Y1 = *Y;
  296.     X1 = T * (X1 + Y1);
  297.     Y1 = T * (X1 + Y1);
  298.     *Z = (X1 + Y1) / T2;
  299.     return;
  300. }    /* END; */
  301.  
  302. POUT(N,J,K,X1,X2,X3,X4) int N,J,K; float X1,X2,X3,X4; { /* SUBROUTINE POUT(N,J,K,X1,X2,X3,X4); */
  303. /*    IMPLICIT REAL*4 (A-H,O-Z); */
  304. /*    common/ptime/ptime,time0; */
  305.     long time1;
  306.     time1 = time((long *) 0);
  307. #ifndef NOPRINT
  308.     printf ("%3d%3d %7d%7d", (int)(time1-time0),(int)(time1-ptime),N,J);
  309.         printf ("%7d%12.4g%12.4g" ,K,X1,X2);
  310.         printf ("%12.4g%12.4g\n",X3,X4);
  311. #endif
  312.     ptime = time1;
  313.     return;
  314. }    /* END; */
  315.