[llvm-commits] CVS: llvm/test/Programs/SingleSource/Benchmarks/Misc/whetstone.c
Chris Lattner
lattner at cs.uiuc.edu
Sat Oct 18 02:07:01 PDT 2003
Changes in directory llvm/test/Programs/SingleSource/Benchmarks/Misc:
whetstone.c added (r1.1)
---
Log message:
We've got to have the original whetstone benchmark!
Modified to:
1. #define PRINTOUT so we don't optimize the whole thing away, and to
provide something to diff
2. Remove timing printouts, because the timing is super low res and
messes with the diffs anyway
---
Diffs of the changes: (+435 -0)
Index: llvm/test/Programs/SingleSource/Benchmarks/Misc/whetstone.c
diff -c /dev/null llvm/test/Programs/SingleSource/Benchmarks/Misc/whetstone.c:1.1
*** /dev/null Sat Oct 18 02:06:53 2003
--- llvm/test/Programs/SingleSource/Benchmarks/Misc/whetstone.c Sat Oct 18 02:06:43 2003
***************
*** 0 ****
--- 1,435 ----
+ #define PRINTOUT
+ /*
+ * C Converted Whetstone Double Precision Benchmark
+ * Version 1.2 22 March 1998
+ *
+ * (c) Copyright 1998 Painter Engineering, Inc.
+ * All Rights Reserved.
+ *
+ * Permission is granted to use, duplicate, and
+ * publish this text and program as long as it
+ * includes this entire comment block and limited
+ * rights reference.
+ *
+ * Converted by Rich Painter, Painter Engineering, Inc. based on the
+ * www.netlib.org benchmark/whetstoned version obtained 16 March 1998.
+ *
+ * A novel approach was used here to keep the look and feel of the
+ * FORTRAN version. Altering the FORTRAN-based array indices,
+ * starting at element 1, to start at element 0 for C, would require
+ * numerous changes, including decrementing the variable indices by 1.
+ * Instead, the array E1[] was declared 1 element larger in C. This
+ * allows the FORTRAN index range to function without any literal or
+ * variable indices changes. The array element E1[0] is simply never
+ * used and does not alter the benchmark results.
+ *
+ * The major FORTRAN comment blocks were retained to minimize
+ * differences between versions. Modules N5 and N12, like in the
+ * FORTRAN version, have been eliminated here.
+ *
+ * An optional command-line argument has been provided [-c] to
+ * offer continuous repetition of the entire benchmark.
+ * An optional argument for setting an alternate LOOP count is also
+ * provided. Define PRINTOUT to cause the POUT() function to print
+ * outputs at various stages. Final timing measurements should be
+ * made with the PRINTOUT undefined.
+ *
+ * Questions and comments may be directed to the author at
+ * r.painter at ieee.org
+ */
+ /*
+ C**********************************************************************
+ C Benchmark #2 -- Double Precision Whetstone (A001)
+ C
+ C o This is a REAL*8 version of
+ C the Whetstone benchmark program.
+ C
+ C o DO-loop semantics are ANSI-66 compatible.
+ C
+ C o Final measurements are to be made with all
+ C WRITE statements and FORMAT sttements removed.
+ C
+ C**********************************************************************
+ */
+
+ /* standard C library headers required */
+ #include <stdlib.h>
+ #include <stdio.h>
+ #include <string.h>
+ #include <math.h>
+
+ /* the following is optional depending on the timing function used */
+ #include <time.h>
+
+ /* map the FORTRAN math functions, etc. to the C versions */
+ #define DSIN sin
+ #define DCOS cos
+ #define DATAN atan
+ #define DLOG log
+ #define DEXP exp
+ #define DSQRT sqrt
+ #define IF if
+
+ /* function prototypes */
+ void POUT(long N, long J, long K, double X1, double X2, double X3, double X4);
+ void PA(double E[]);
+ void P0(void);
+ void P3(double X, double Y, double *Z);
+ #define USAGE "usage: whetdc [-c] [loops]\n"
+
+ /*
+ COMMON T,T1,T2,E1(4),J,K,L
+ */
+ double T,T1,T2,E1[5];
+ int J,K,L;
+
+ int
+ main(int argc, char *argv[])
+ {
+ /* used in the FORTRAN version */
+ long I;
+ long N1, N2, N3, N4, N6, N7, N8, N9, N10, N11;
+ double X1,X2,X3,X4,X,Y,Z;
+ long LOOP;
+ int II, JJ;
+
+ /* added for this version */
+ long loopstart;
+ long startsec, finisec;
+ float KIPS;
+ int continuous;
+
+ loopstart = 10000; /* see the note about LOOP below */
+ continuous = 0;
+
+ II = 1; /* start at the first arg (temp use of II here) */
+ while (II < argc) {
+ if (strncmp(argv[II], "-c", 2) == 0 || argv[II][0] == 'c') {
+ continuous = 1;
+ } else if (atol(argv[II]) > 0) {
+ loopstart = atol(argv[II]);
+ } else {
+ fprintf(stderr, USAGE);
+ return(1);
+ }
+ II++;
+ }
+
+ LCONT:
+ /*
+ C
+ C Start benchmark timing at this point.
+ C
+ */
+ startsec = time(0);
+
+ /*
+ C
+ C The actual benchmark starts here.
+ C
+ */
+ T = .499975;
+ T1 = 0.50025;
+ T2 = 2.0;
+ /*
+ C
+ C With loopcount LOOP=10, one million Whetstone instructions
+ C will be executed in EACH MAJOR LOOP..A MAJOR LOOP IS EXECUTED
+ C 'II' TIMES TO INCREASE WALL-CLOCK TIMING ACCURACY.
+ C
+ LOOP = 1000;
+ */
+ LOOP = loopstart;
+ II = 1;
+
+ JJ = 1;
+
+ IILOOP:
+ N1 = 0;
+ N2 = 12 * LOOP;
+ N3 = 14 * LOOP;
+ N4 = 345 * LOOP;
+ N6 = 210 * LOOP;
+ N7 = 32 * LOOP;
+ N8 = 899 * LOOP;
+ N9 = 616 * LOOP;
+ N10 = 0;
+ N11 = 93 * LOOP;
+ /*
+ C
+ C Module 1: Simple identifiers
+ C
+ */
+ X1 = 1.0;
+ X2 = -1.0;
+ X3 = -1.0;
+ X4 = -1.0;
+
+ for (I = 1; I <= N1; I++) {
+ X1 = (X1 + X2 + X3 - X4) * T;
+ X2 = (X1 + X2 - X3 + X4) * T;
+ X3 = (X1 - X2 + X3 + X4) * T;
+ X4 = (-X1+ X2 + X3 + X4) * T;
+ }
+ #ifdef PRINTOUT
+ IF (JJ==II)POUT(N1,N1,N1,X1,X2,X3,X4);
+ #endif
+
+ /*
+ C
+ C Module 2: Array elements
+ C
+ */
+ E1[1] = 1.0;
+ E1[2] = -1.0;
+ E1[3] = -1.0;
+ E1[4] = -1.0;
+
+ for (I = 1; I <= N2; I++) {
+ E1[1] = ( E1[1] + E1[2] + E1[3] - E1[4]) * T;
+ E1[2] = ( E1[1] + E1[2] - E1[3] + E1[4]) * T;
+ E1[3] = ( E1[1] - E1[2] + E1[3] + E1[4]) * T;
+ E1[4] = (-E1[1] + E1[2] + E1[3] + E1[4]) * T;
+ }
+
+ #ifdef PRINTOUT
+ IF (JJ==II)POUT(N2,N3,N2,E1[1],E1[2],E1[3],E1[4]);
+ #endif
+
+ /*
+ C
+ C Module 3: Array as parameter
+ C
+ */
+ for (I = 1; I <= N3; I++)
+ PA(E1);
+
+ #ifdef PRINTOUT
+ IF (JJ==II)POUT(N3,N2,N2,E1[1],E1[2],E1[3],E1[4]);
+ #endif
+
+ /*
+ C
+ C Module 4: Conditional jumps
+ C
+ */
+ J = 1;
+ for (I = 1; I <= N4; I++) {
+ if (J == 1)
+ J = 2;
+ else
+ J = 3;
+
+ if (J > 2)
+ J = 0;
+ else
+ J = 1;
+
+ if (J < 1)
+ J = 1;
+ else
+ J = 0;
+ }
+
+ #ifdef PRINTOUT
+ IF (JJ==II)POUT(N4,J,J,X1,X2,X3,X4);
+ #endif
+
+ /*
+ C
+ C Module 5: Omitted
+ C Module 6: Integer arithmetic
+ C
+ */
+
+ J = 1;
+ K = 2;
+ L = 3;
+
+ for (I = 1; I <= N6; I++) {
+ J = J * (K-J) * (L-K);
+ K = L * K - (L-J) * K;
+ L = (L-K) * (K+J);
+ E1[L-1] = J + K + L;
+ E1[K-1] = J * K * L;
+ }
+
+ #ifdef PRINTOUT
+ IF (JJ==II)POUT(N6,J,K,E1[1],E1[2],E1[3],E1[4]);
+ #endif
+
+ /*
+ C
+ C Module 7: Trigonometric functions
+ C
+ */
+ X = 0.5;
+ Y = 0.5;
+
+ for (I = 1; I <= N7; I++) {
+ X = T * DATAN(T2*DSIN(X)*DCOS(X)/(DCOS(X+Y)+DCOS(X-Y)-1.0));
+ Y = T * DATAN(T2*DSIN(Y)*DCOS(Y)/(DCOS(X+Y)+DCOS(X-Y)-1.0));
+ }
+
+ #ifdef PRINTOUT
+ IF (JJ==II)POUT(N7,J,K,X,X,Y,Y);
+ #endif
+
+ /*
+ C
+ C Module 8: Procedure calls
+ C
+ */
+ X = 1.0;
+ Y = 1.0;
+ Z = 1.0;
+
+ for (I = 1; I <= N8; I++)
+ P3(X,Y,&Z);
+
+ #ifdef PRINTOUT
+ IF (JJ==II)POUT(N8,J,K,X,Y,Z,Z);
+ #endif
+
+ /*
+ C
+ C Module 9: Array references
+ C
+ */
+ J = 1;
+ K = 2;
+ L = 3;
+ E1[1] = 1.0;
+ E1[2] = 2.0;
+ E1[3] = 3.0;
+
+ for (I = 1; I <= N9; I++)
+ P0();
+
+ #ifdef PRINTOUT
+ IF (JJ==II)POUT(N9,J,K,E1[1],E1[2],E1[3],E1[4]);
+ #endif
+
+ /*
+ C
+ C Module 10: Integer arithmetic
+ C
+ */
+ J = 2;
+ K = 3;
+
+ for (I = 1; I <= N10; I++) {
+ J = J + K;
+ K = J + K;
+ J = K - J;
+ K = K - J - J;
+ }
+
+ #ifdef PRINTOUT
+ IF (JJ==II)POUT(N10,J,K,X1,X2,X3,X4);
+ #endif
+
+ /*
+ C
+ C Module 11: Standard functions
+ C
+ */
+ X = 0.75;
+
+ for (I = 1; I <= N11; I++)
+ X = DSQRT(DEXP(DLOG(X)/T1));
+
+ #ifdef PRINTOUT
+ IF (JJ==II)POUT(N11,J,K,X,X,X,X);
+ #endif
+
+ /*
+ C
+ C THIS IS THE END OF THE MAJOR LOOP.
+ C
+ */
+ if (++JJ <= II)
+ goto IILOOP;
+
+ /*
+ C
+ C Stop benchmark timing at this point.
+ C
+ */
+ finisec = time(0);
+
+ /*
+ C----------------------------------------------------------------
+ C Performance in Whetstone KIP's per second is given by
+ C
+ C (100*LOOP*II)/TIME
+ C
+ C where TIME is in seconds.
+ C--------------------------------------------------------------------
+ */
+ printf("\n");
+ if (finisec-startsec <= 0) {
+ printf("Insufficient duration- Increase the LOOP count\n");
+ return(1);
+ }
+
+ #if 0
+ printf("Loops: %ld, Iterations: %d, Duration: %ld sec.\n",
+ LOOP, II, finisec-startsec);
+
+ KIPS = (100.0*LOOP*II)/(float)(finisec-startsec);
+ if (KIPS >= 1000.0)
+ printf("C Converted Double Precision Whetstones: %.1f MIPS\n", KIPS/1000.0);
+ else
+ printf("C Converted Double Precision Whetstones: %.1f KIPS\n", KIPS);
+ #endif
+ if (continuous)
+ goto LCONT;
+
+ return(0);
+ }
+
+ void
+ PA(double E[])
+ {
+ J = 0;
+
+ L10:
+ E[1] = ( E[1] + E[2] + E[3] - E[4]) * T;
+ E[2] = ( E[1] + E[2] - E[3] + E[4]) * T;
+ E[3] = ( E[1] - E[2] + E[3] + E[4]) * T;
+ E[4] = (-E[1] + E[2] + E[3] + E[4]) / T2;
+ J += 1;
+
+ if (J < 6)
+ goto L10;
+ }
+
+ void
+ P0(void)
+ {
+ E1[J] = E1[K];
+ E1[K] = E1[L];
+ E1[L] = E1[J];
+ }
+
+ void
+ P3(double X, double Y, double *Z)
+ {
+ double X1, Y1;
+
+ X1 = X;
+ Y1 = Y;
+ X1 = T * (X1 + Y1);
+ Y1 = T * (X1 + Y1);
+ *Z = (X1 + Y1) / T2;
+ }
+
+ #ifdef PRINTOUT
+ void
+ POUT(long N, long J, long K, double X1, double X2, double X3, double X4)
+ {
+ printf("%7ld %7ld %7ld %12.4e %12.4e %12.4e %12.4e\n",
+ N, J, K, X1, X2, X3, X4);
+ }
+ #endif
More information about the llvm-commits
mailing list