Thomas Kirchner / Mbed 2 deprecated Nucleo_vs_Arduino_Speed_Test

Whetstone performance benchmark to compare the speed of my new Nucleo STM32 F401RE board to the Arduino. To summarize, while my Arduino Leonardo knockoff running at 16 Mhz runs through the 1,000 loops in 82 seconds for 1.21MIPS the Nucleo takes only 30-31 seconds and yields 3.2-3.3 MIPS. I would have expected better relative performance from a 32 bit ARM M4 processor over an 8 bit AVR. Maybe it will get better once the FPU is enabled in the online compiler.

Dependencies:   ST_401_84MHZ mbed

Whetstone on the Nucleo at 84 MHz:

  • Loops: 1000, Iterations: 1, Duration: 30 sec.
  • C Converted Double Precision Whetstones: 3.3 MIPS
  • Code size: 22.1 kB

Whetstone on the Arduino Leonardo at 16 MHz:

  • Loops: 1000Iterations: 1Duration: 82320 millisec.
  • C Converted Double Precision Whetstones: 1.21 MIPS
  • Code size: 9,086 bytes

arduino.txt@1:466dbb9d16a8, 2014-04-28 (annotated)

Committer:
kirchnet
Date:
Mon Apr 28 00:44:57 2014 +0000
Revision:
1:466dbb9d16a8
Parent:
0:525baf7de2db 
Whetstone performance benchmark to compare my new Nucleo STM32 F401RE board to the Arduino. While my Arduino Leonardo knockoff at 16 Mhz runs through the 1,000 loops in 82 seconds for 1.21 MIPS the Nucleo takes only 30 secs and yields 3.2 MIPS

Who changed what in which revision?

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