main.cpp

00001 //********************************************************
00002 //**   Whetstone benchmark DP for  ARM Cx-M7        ******
00003 //**   ST Nucleo-144 Stm32F746 and Stm32F767        ******
00004 //**         Whetstone benchmark DP                 ******
00005 //**           Jovan Ivkovic 2016.                  ******
00006 //**         JovanEps (jovan.eps@gmail.com).        ******
00007 //********************************************************
00008 #include "mbed.h"
00009 DigitalOut myled(LED1);
00010 Serial pc(USBTX, USBRX);
00011 Timer timer;
00012 
00013 #include <stdlib.h>
00014 #include <stdio.h>
00015 #include <string.h>
00016 #include <math.h>
00017 /* the following is optional depending on the timing function used */
00018 #include <time.h>
00019 
00020 /* map the FORTRAN math functions, etc. to the C versions */
00021 #define DSIN    sin
00022 #define DCOS    cos
00023 #define DATAN   atan
00024 #define DLOG    log
00025 #define DEXP    exp
00026 #define DSQRT   sqrt
00027 #define IF      if
00028 
00029 /* function prototypes */
00030 void POUT(long N, long J, long K, double X1, double X2, double X3, double X4);
00031 void PA(double E[]);
00032 void P0(void);
00033 void P3(double X, double Y, double *Z);
00034 #define USAGE   "usage: whetdc [-c] [loops]\n"
00035 
00036 /*
00037     COMMON T,T1,T2,E1(4),J,K,L
00038 */
00039 double T,T1,T2,E1[5];
00040 int J,K,L;
00041 int argc = 0;   //Mod for nucleo. Change in code below if you want non-default loop count
00042 
00043 //************************************
00044 //**    Whetstone    64b-DP         **
00045 //**        SUB                     **
00046 //************************************
00047 int Whetstone() // ------------ Metoda -----------
00048 {
00049     pc.baud(57600);
00050     pc.printf("Beginning Whetstone benchmark at ");
00051     
00052     pc.printf("default 216 MHz ...\n");
00053     /* used in the FORTRAN version */
00054     long I;
00055     long N1, N2, N3, N4, N6, N7, N8, N9, N10, N11;
00056     double X1,X2,X3,X4,X,Y,Z;
00057     long LOOP;
00058     int II, JJ;
00059 
00060     /* added for this version */
00061     long loopstart = 0;
00062     long startsec,finisec = 0;
00063     double KIPS;
00064     int continuous;
00065 
00066     loopstart = 25000;       /* 1000 see the note about LOOP below */
00067     continuous = 0;
00068 
00069     II = 1;     /* start at the first arg (temp use of II here) */
00070  
00071 LCONT:
00072 /*
00073 ********************************************
00074 *   Start benchmark timing at this point.
00075 ********************************************
00076 */
00077     timer.start();
00078     startsec = 0;
00079     finisec = 0;
00080     startsec = timer.read_us();
00081 
00082 /*
00083 ********************************************
00084 *   The actual benchmark starts here.
00085 ********************************************
00086 */
00087     T  = .499975;
00088     T1 = 0.50025;
00089     T2 = 2.0;
00090 /*
00091 ********************************************
00092 *   With loopcount LOOP=10, one million Whetstone instructions
00093 *   will be executed in EACH MAJOR LOOP..A MAJOR LOOP IS EXECUTED
00094 *   'II' TIMES TO INCREASE WALL-CLOCK TIMING ACCURACY.
00095 *
00096 *   LOOP = 1000;
00097 */
00098     LOOP = loopstart;
00099     II   = 1;
00100     JJ = 1;
00101 
00102 IILOOP:
00103     N1  = 0;
00104     N2  = 12 * LOOP;
00105     N3  = 14 * LOOP;
00106     N4  = 345 * LOOP;
00107     N6  = 210 * LOOP;
00108     N7  = 32 * LOOP;
00109     N8  = 899 * LOOP;
00110     N9  = 616 * LOOP;
00111     N10 = 0;
00112     N11 = 93 * LOOP;
00113 /*
00114 ********************************************
00115 *   Module 1: Simple identifiers
00116 ********************************************
00117 */
00118     X1  =  1.0;
00119     X2  = -1.0;
00120     X3  = -1.0;
00121     X4  = -1.0;
00122 
00123     for (I = 1; I <= N1; I++)
00124     {
00125         X1 = (X1 + X2 + X3 - X4) * T;
00126         X2 = (X1 + X2 - X3 + X4) * T;
00127         X3 = (X1 - X2 + X3 + X4) * T;
00128         X4 = (-X1+ X2 + X3 + X4) * T;
00129     }
00130 #ifdef PRINTOUT
00131     IF (JJ==II) POUT(N1,N1,N1,X1,X2,X3,X4);
00132 #endif
00133 
00134 /*
00135 ********************************************
00136 *   Module 2: Array elements
00137 ********************************************
00138 */
00139     E1[1] =  1.0;
00140     E1[2] = -1.0;
00141     E1[3] = -1.0;
00142     E1[4] = -1.0;
00143 
00144     for (I = 1; I <= N2; I++)
00145     {
00146         E1[1] = ( E1[1] + E1[2] + E1[3] - E1[4]) * T;
00147         E1[2] = ( E1[1] + E1[2] - E1[3] + E1[4]) * T;
00148         E1[3] = ( E1[1] - E1[2] + E1[3] + E1[4]) * T;
00149         E1[4] = (-E1[1] + E1[2] + E1[3] + E1[4]) * T;
00150     }
00151 
00152 #ifdef PRINTOUT
00153     IF (JJ==II) POUT(N2,N3,N2,E1[1],E1[2],E1[3],E1[4]);
00154 #endif
00155 
00156 /*
00157 ********************************************
00158 *  Module 3: Array as parameter
00159 ********************************************
00160 */
00161     for (I = 1; I <= N3; I++)
00162     {
00163         PA(E1);
00164     }
00165 #ifdef PRINTOUT
00166     IF (JJ==II) POUT(N3,N2,N2,E1[1],E1[2],E1[3],E1[4]);
00167 #endif
00168 
00169 /*
00170 ********************************************
00171 *   Module 4: Conditional jumps
00172 ********************************************
00173 */
00174     J = 1;
00175     for (I = 1; I <= N4; I++)
00176     {
00177         if (J == 1)
00178             J = 2;
00179         else
00180             J = 3;
00181 
00182         if (J > 2)
00183             J = 0;
00184         else
00185             J = 1;
00186 
00187         if (J < 1)
00188             J = 1;
00189         else
00190             J = 0;
00191     }
00192 
00193 #ifdef PRINTOUT
00194     IF (JJ==II) POUT(N4,J,J,X1,X2,X3,X4);
00195 #endif
00196 
00197 /*
00198 ********************************************
00199 *   Module 5: Omitted
00200 *   Module 6: Integer arithmetic
00201 ********************************************
00202 */
00203 
00204     J = 1;
00205     K = 2;
00206     L = 3;
00207 
00208     for (I = 1; I <= N6; I++)
00209     {
00210         J = J * (K-J) * (L-K);
00211         K = L * K - (L-J) * K;
00212         L = (L-K) * (K+J);
00213         E1[L-1] = J + K + L;
00214         E1[K-1] = J * K * L;
00215     }
00216 
00217 #ifdef PRINTOUT
00218     IF (JJ==II) POUT(N6,J,K,E1[1],E1[2],E1[3],E1[4]);
00219 #endif
00220 
00221 /*
00222 ********************************************
00223 *   Module 7: Trigonometric functions
00224 ********************************************
00225 */
00226     X = 0.5;
00227     Y = 0.5;
00228 
00229     for (I = 1; I <= N7; I++)
00230     {
00231         X = T * DATAN(T2*DSIN(X)*DCOS(X)/(DCOS(X+Y)+DCOS(X-Y)-1.0));
00232         Y = T * DATAN(T2*DSIN(Y)*DCOS(Y)/(DCOS(X+Y)+DCOS(X-Y)-1.0));
00233     }
00234 
00235 #ifdef PRINTOUT
00236     IF (JJ==II)POUT(N7,J,K,X,X,Y,Y);
00237 #endif
00238 
00239 /*
00240 ********************************************
00241 *   Module 8: Procedure calls
00242 ********************************************
00243 */
00244     X = 1.0;
00245     Y = 1.0;
00246     Z = 1.0;
00247 
00248     for (I = 1; I <= N8; I++)
00249     {
00250         P3(X,Y,&Z);
00251     }
00252 #ifdef PRINTOUT
00253     IF (JJ==II)POUT(N8,J,K,X,Y,Z,Z);
00254 #endif
00255 
00256 /*
00257 ********************************************
00258 *   Module 9: Array references
00259 ********************************************
00260 */
00261     J = 1;
00262     K = 2;
00263     L = 3;
00264     E1[1] = 1.0;
00265     E1[2] = 2.0;
00266     E1[3] = 3.0;
00267 
00268     for (I = 1; I <= N9; I++)
00269     {
00270         P0();
00271     }
00272 #ifdef PRINTOUT
00273     IF (JJ==II) POUT(N9,J,K,E1[1],E1[2],E1[3],E1[4]);
00274 #endif
00275 
00276 /*
00277 ********************************************
00278 *   Module 10: Integer arithmetic
00279 ********************************************
00280 */
00281     J = 2;
00282     K = 3;
00283 
00284     for (I = 1; I <= N10; I++)
00285     {
00286         J = J + K;
00287         K = J + K;
00288         J = K - J;
00289         K = K - J - J;
00290     }
00291 
00292 #ifdef PRINTOUT
00293     IF (JJ==II) POUT(N10,J,K,X1,X2,X3,X4);
00294 #endif
00295 
00296 /*
00297 ********************************************
00298 *   Module 11: Standard functions
00299 ********************************************
00300 */
00301     X = 0.75;
00302 
00303     for (I = 1; I <= N11; I++)
00304     {
00305         X = DSQRT(DEXP(DLOG(X)/T1));
00306     }
00307 #ifdef PRINTOUT
00308     IF (JJ==II) POUT(N11,J,K,X,X,X,X);
00309 #endif
00310 
00311 /*
00312 ********************************************
00313 *      THIS IS THE END OF THE MAJOR LOOP.
00314 ********************************************
00315 */
00316     if (++JJ <= II)
00317         goto IILOOP;
00318 
00319 /*
00320 ********************************************
00321 *      Stop benchmark timing at this point.
00322 ********************************************
00323 */
00324    // finisec = time(0);
00325     finisec = timer.read_us();
00326     //timer.reset();
00327 
00328 /*
00329 *--------------------------------------------------------------------
00330 *      Performance in Whetstone KIP's per second is given by
00331 *
00332 *   (100*LOOP*II)/TIME
00333 *
00334 *      where TIME is in seconds.
00335 *--------------------------------------------------------------------
00336 */
00337     pc.printf(" kraj \n");
00338     double vreme;
00339     vreme = (finisec - startsec) / 1000000;
00340     
00341     if (vreme <= 0)
00342      {
00343         pc.printf("Insufficient duration- Increase the LOOP count \n");
00344         finisec = 0; 
00345         startsec = 0;
00346         return 1;
00347      }
00348 
00349     pc.printf("Loops: %ld , \t Iterations: %d, \t Duration: %.3f sec. \n",
00350             LOOP, II, vreme);
00351 
00352     KIPS = (100.0 * LOOP * II) / vreme ;
00353    
00354   //  if (KIPS >= 1000.0)
00355   //      pc.printf("C Converted Double Precision Whetstones: %.3f MIPS \n\n", KIPS / 1000);
00356   //  else
00357   //      pc.printf("C Converted Double Precision Whetstones: %.3f KIPS \n\n", KIPS);
00358         
00359         pc.printf("C Converted Double Precision Whetstones: %.3f MIPS \n\n", KIPS / 1000);
00360 
00361     if (continuous)
00362         goto LCONT;
00363 
00364     finisec = 0; 
00365     startsec = 0;
00366     return 1;
00367 }
00368 
00369 void PA(double E[])
00370 {
00371     J = 0;
00372 
00373 L10:
00374     E[1] = ( E[1] + E[2] + E[3] - E[4]) * T;
00375     E[2] = ( E[1] + E[2] - E[3] + E[4]) * T;
00376     E[3] = ( E[1] - E[2] + E[3] + E[4]) * T;
00377     E[4] = (-E[1] + E[2] + E[3] + E[4]) / T2;
00378     J += 1;
00379 
00380     if (J < 6)
00381         goto L10;
00382 }
00383 
00384 void P0(void)
00385 {
00386     E1[J] = E1[K];
00387     E1[K] = E1[L];
00388     E1[L] = E1[J];
00389 }
00390 
00391 void P3(double X, double Y, double *Z)
00392 {
00393     double X1, Y1;
00394 
00395     X1 = X;
00396     Y1 = Y;
00397     X1 = T * (X1 + Y1);
00398     Y1 = T * (X1 + Y1);
00399     *Z  = (X1 + Y1) / T2;
00400 }
00401 
00402 #ifdef PRINTOUT
00403 void POUT(long N, long J, long K, double X1, double X2, double X3, double X4)
00404 {
00405     pc.printf("%7ld %7ld %7ld %12.4e %12.4e %12.4e %12.4e\n",
00406                         N, J, K, X1, X2, X3, X4);
00407 }
00408 #endif   
00409 
00410 //*********************************
00411 //**         MAIN block          **
00412 //*********************************
00413 int main()
00414 {
00415     int rez=0;  
00416     printf("\n My Benchmark example for Whetstones \n");
00417     
00418     while(1)
00419     {
00420         myled=1-rez;
00421     
00422         rez = Whetstone(); //Call of Whetstone banchmark methode
00423     
00424         myled=1-rez;
00425         wait_us(0.3);
00426     }
00427     pc.close();
00428 }