【先楫半导体HPM6750EVKMINI评估板试用体验】基准性能测试之三:whetstone

本文来源电子发烧友社区，作者：李先生， 帖子地址：https://bbs.elecfans.com/jishu_2284399_1_1.html


前言

之前我们使用dhrystone和coremark进行了相关的性能测试。这次我们使用whetstone进行测试，该测试关注浮点相关的计算性能。

获取代码

http://www.roylongbottom.org.uk/classic_benchmarks.tar.gz

下下载classic_benchmarks.tar.gz文件

解压文件

将classic_benchmarksclassic_benchmarkssource_codewhetstone复制到工程目录

projled下

添加代码

按照上一步将文件复制到工程目录下后，按照如下方式刷新

可以看到源码添加到了工程目录

修改代码

前面注释**************************************************************************少了/

注释掉#include"cpuidh.h"

注释掉getDetails

删除whets.txt相关操作

fprintf改为rt_kprintf

Main改为whetstone_main

pout调用时字符串中删除

浮点数都放大100倍整数打印

详见后面附录代码

在main中调用

intcore_main(intargc,char*argv[]);

whetstone_main(0, 0);

测试

注以下结果放大100倍，整数打印

-O0

-O3

			RT_tiCK_PER_SECOND=1000
			优化等级0	优化等级3
RAM中运行	MWIPS		38.970	44.858
ROM中运行

对比

可以从下网站看看打败了全国多少网友

http://www.roylongbottom.org.uk/whetstone%20results.htm

附whets.c代码

1. /*gcc whets.c cpuidc64.o cpuida64.o -m64 -lrt -lc -lm -o whet
2. *
3. *Document: Whets.c
4. *File Group: Classic Benchmarks
5. *Creation Date: 6 November 1996
6. *Revision Date: 6 November 2010 Ubuntu Version for PCs
7. *
8. *Title: Whetstone Benchmark in C/C++
9. *Keywords: WHETSTONE BENCHMARK PERFORMANCE MIPS
10. * MWIPS MFLOPS
11. *
12. *Abstract: C or C++ version of Whetstone one of the
13. * Classic Numeric Benchmarks with example
14. * results on P3 to P6 based PCs.
15. *
16. *Contributor: [e-mail]
17. *
18. ************************************************************
19. *
20. * C/C++ Whetstone Benchmark Single or Double Precision
21. *
22. * Original concept Brian Wichmann NPL 1960's
23. * Original author Harold CurnowCCTA 1972
24. * Self timing versions Roy Longbottom CCTA 1978/87
25. * Optimisation control Bangor University 1987/90
26. * C/C++ Version Roy Longbottom 1996
27. * Compatibility & timersAl Aburto 1996
28. *
29. ************************************************************
30. *
31. * Official version approved by:
32. *
33. * Harold [e-mail]
34. *
35. * Happy 25th birthday Whetstone, 21 November 1997
36. *
37. ************************************************************
38. *
39. * The program normally runs for about 100 seconds
40. * (adjustable in main - variable duration). This time
41. * is necessary because of poor PC clock resolution.
42. * The original concept included such things as a given
43. * number of subroutine calls and divides which may be
44. * changed by optimisation. For comparison purposes the
45. * compiler and level of optimisation should be identified.
46. *
47. * This version is set to run for 10 seconds using high
48. * resolution timer.
49. *
50. ************************************************************
51. *
52. * The original benchmark had a single variable I which
53. * controlled the running time. Constants with values up
54. * to 899 were multiplied by I to control the number
55. * passes for each loop. It was found that large values
56. * of I could overflow index registers so an extra outer
57. * loop with a second variable J was added.
58. *
59. * Self timing versions were produced during the early
60. * days. The 1978 changes supplied timings of individual
61. * loops and these were used later to produce MFLOPS and
62. * MOPS ratings.
63. *
64. * 1987 changes converted the benchmark to Fortran 77
65. * standards and removed redundant IF statements and
66. * loops to leave the 8 active loops N1 to N8. Procedure
67. * P3 was changed to use global variables to avoid over-
68. * optimisation with the first two statements changed from
69. * X1=X and Y1=Y to X=Y and Y=Z. A self time calibrating
70. * version for PCs was also produced, the facility being
71. * incorporated in this version.
72. *
73. * This version has changes to avoid worse than expected
74. * speed ratings, due to underflow, and facilities to show
75. * that consistent numeric output is produced with varying
76. * optimisation levels or versions in different languages.
77. *
78. * Some of the procedures produce ever decreasing numbers.
79. * To avoid problems, variables T and T1 have been changed
80. * from 0.499975 and 0.50025 to 0.49999975 and 0.50000025.
81. *
82. * Each section now has its own double loop. Inner loops
83. * are run 100 times the loop constants. Calibration
84. * determines the number of outer loop passes. The
85. * numeric results produced in the main output are for
86. * one pass on the outer loop. As underflow problems were
87. * still likely on a processor 100 times faster than a 100
88. * MHz Pentium, three sections have T=1.0-T inserted in the
89. * outer loop to avoid the problem. The two loops avoid
90. * index register overflows.
91. *
92. * The first section is run ten times longer than required
93. * for accuracy in calculating MFLOPS. This time is divided
94. * by ten for inclusion in the MWIPS calculations.
95. *
96. * Early version has facilities for typing in details of
97. * the particular run, appended to file whets.txt along
98. * with the results. This version attemps to obtain these
99. * automatically.
100. *
101. * 2010 Section 4 modified slightly to avoid over optimisation
102. * by GCC compiler
103. *
104. * Roy [e-mail]
105. *
106. ************************************************************
107. *
108. * Whetstone benchmark results, further details of the
109. * benchmarks and history are available from:
110. *
111. * http://www.roylongbottom.org.uk/whetstone%20results.htm
112. * http://www.roylongbottom.org.uk/whetstone.htm
113. *
114. ************************************************************
115. *
116. * Source code is available in C/C++, Fortran, Basic and
117. * Visual Basic in the same format as this version. Pre-
118. * compiled versions for PCs are also available via C++.
119. * These comprise optimised and non-optimised versions
120. * for DOS, Windows and NT. See:
121. *
122. * http://www.roylongbottom.org.uk/whetstone%20results.htm
123. *
124. ************************************************************
125. *
126. * Example of initial calibration display (Pentium 100 MHz)
127. *
128. * Single Precision C/C++ Whetstone Benchmark
129. *
130. * Calibrate
131. * 0.17 Seconds 1 Passes (x 100)
132. * 0.77 Seconds 5 Passes (x 100)
133. * 3.70 Seconds 25 Passes (x 100)
134. *
135. * Use 676passes (x 100)
136. *
137. * 676 passes are used for an approximate duration of 100
138. * seconds, providing an initial estimate of a speed rating
139. * of 67.6 MWIPS.
140. *
141. * This is followed by the table of results as below.
143. * Whetstone SinglePrecision Benchmark in C/C++
144. *
145. * Loop content Result MFLOPS MOPS Seconds
146. *
147. * N1 floating point -1.12475025653839100 19.971 0.274
148. * N2 floating point -1.12274754047393800 11.822 3.240
149. * N3 if then else 1.00000000000000000 11.659 2.530
150. * N4 fixed point 12.00000000000000000 13.962 6.430
151. * N5 sin,cos etc. 0.49904659390449520 2.097 11.310
152. * N6 floating point 0.99999988079071040 3.360 45.750
153. * N7 assignments 3.00000000000000000 2.415 21.810
154. * N8 exp,sqrt etc. 0.75110864639282230 1.206 8.790
155. *
156. * MWIPS 28.462 100.134
157. *
158. *Note different numeric results to single precision. Slight variations
159. *are normal with different compilers and sometimes optimisation levels.
160. *
161. **************************************************************************/
163. #include /* for sin, exp etc. */
164. #include /* standard I/O */
165. #include /* for strcpy - 3 occurrences*/
166. #include /* for exit - 1 occurrence */
167. //#include "cpuidh.h"
169. /*PRECISION PRECISION PRECISION PRECISION PRECISION PRECISION PRECISION*/
171. /* #define DP */
173. #ifdef DP
174. #define SPDP double
175. #define Precision "Double"
176. #else
177. #define SPDP float
178. #define Precision "Single"
179. #endif
181. //#define opt "Opt 3 64 Bit"
183. void whetstones(long xtra, long x100, int calibrate);
184. void pa(SPDP e[4], SPDP t, SPDP t2);
185. void po(SPDP e1[4], long j, long k, long l);
186. void p3(SPDP *x, SPDP *y, SPDP *z, SPDP t, SPDP t1, SPDP t2);
187. void pout(char* title, float ops, int type, SPDP checknum,
188. SPDP time, int calibrate, int section);
191. static SPDP loop_time[9];
192. static SPDP loop_mops[9];
193. static SPDP loop_mflops[9];
194. static SPDP TimeUsed;
195. static SPDP mwips;
196. static char headings[9][18];
197. static SPDP Check;
198. static SPDP results[9];
201. #include "rtthread.h"
203. doubletheseSecs = 0.0;
204. doublestartSecs = 0.0;
205. doublesecs;
206. int millisecs = 0;
208. void start_time()
209. {
210. startSecs = rt_tick_get()*1.0/RT_TICK_PER_SECOND;
211. return;
212. }
214. void end_time()
215. {
216. secs = rt_tick_get()*1.0/RT_TICK_PER_SECOND - startSecs;
217. millisecs = (int)(1000.0 * secs);
218. return;
219. }
222. int whetstone_main(int argc, char *argv[])
223. {
224. int count = 10, calibrate = 1;
225. long xtra = 1;
226. int section;
227. long x100 = 100;
228. int duration = 10;
229. ///FILE *outfile;
230. char compiler[80], options[256], general[10][80] = {" "};
231. char endit[80];
232. int i;
233. int nopause = 1;
235. if (argc > 1)
236. {
237. switch (argv[1][0])
238. {
239. case 'N':
240. nopause = 0;
241. break;
242. case 'n':
243. nopause = 0;
244. break;
245. }
246. }
248. //getDetails();
249. //for (i=1; i<10; i++)
250. //{
251. // rt_kprintf("%sn", configdata[i]);
252. //}
254. ///local_time();
255. ///rt_kprintf("n");
256. ///rt_kprintf("##########################################n");
257. ///rt_kprintf("%s Precision C Whetstone Benchmark %s, %sn", Precision, opt, timeday);
259. ///outfile = fopen("whets.txt","a+");
260. ///if (outfile == NULL)
261. ///{
262. /// rt_kprintf ("Cannot open results file nn");
263. /// rt_kprintf("Press Enter to exitn");
264. /// i = getchar();
265. ///
266. /// exit (0);
267. ///}
269. rt_kprintf("Calibraten");
270. do
271. {
272. TimeUsed=0;
274. whetstones(xtra,x100,calibrate);
276. rt_kprintf("%8d mS %8d Passes (x 100)n",(int)(TimeUsed*1000),xtra);
277. calibrate++;
278. count--;
280. if (TimeUsed > 2.0)
281. {
282. count = 0;
283. }
284. else
285. {
286. xtra = xtra * 5;
287. }
288. }
290. while (count > 0);
292. if (TimeUsed > 0) xtra = (long)((SPDP)(duration * xtra) / TimeUsed);
293. if (xtra < 1) xtra = 1;
295. calibrate = 0;
297. rt_kprintf("nUse %dpasses (x 100)n", (int)xtra);
299. rt_kprintf("n %s Precision C/C++ Whetstone Benchmark",Precision);
301. #ifdef PRECOMP
302. rt_kprintf("n Compiler%s", precompiler);
303. rt_kprintf("n Options %sn", preoptions);
304. #else
305. rt_kprintf("n");
306. #endif
308. rt_kprintf("nLoop content Result MFLOPS "
309. " MOPS msnn");
311. TimeUsed=0;
312. whetstones(xtra,x100,calibrate);
314. rt_kprintf("nMWIPS ");
315. if (TimeUsed>0)
316. {
317. mwips=(float)(xtra) * (float)(x100) / (10 * TimeUsed);
318. }
319. else
320. {
321. mwips = 0;
322. }
324. rt_kprintf(" %13d%13dnn",(int)(mwips*1000),(int)(TimeUsed*1000));
326. if (Check == 0) rt_kprintf("Wrong answer");
329. /************************************************************************/
330. /* Add results to output file whets.txt */
331. /************************************************************************/
332. ///rt_kprintf( "n");
333. ///rt_kprintf( "##############################################nn");
334. ///for (i=1; i<10; i++)
335. ///{
336. /// frt_kprintf(outfile, "%s n", configdata[i]);
337. ///}
338. ///rt_kprintf( "n");
339. ///rt_kprintf( "##############################################nn");
340. ///rt_kprintf( "Whetstone %s Precision C Benchmark%s, %sn",Precision, opt, timeday);
341. ///rt_kprintf( "n");
343. //rt_kprintf("Loop content Result"
344. // " MFLOPS MOPS Secondsnn");
346. //for (section=1; section<9; section++)
347. // {
348. // rt_kprintf( "%s%24.17f ", headings[section],
349. // results[section]);
350. // if (loop_mops[section] == 99999)
351. // {
352. // rt_kprintf("%9.3f %9.3fn",
353. // loop_mflops[section], loop_time[section]);
354. // }
355. // else
356. // {
357. // rt_kprintf( " %9.3f %9.3fn",
358. // loop_mops[section], loop_time[section], results[section]);
359. // }
360. //}
361. //fflush(outfile);
362. //rt_kprintf( "nMWIPS ");
363. //rt_kprintf( "%9.3f%9.3fnn",mwips,TimeUsed);
364. // rt_kprintf( "Resultstoloadtospreadsheet ");
365. // rt_kprintf( " MWIPS Mflops1 Mflops2 Mflops3 Cosmops"
366. // " ExpmopsFixpmops Ifmops Eqmopsn");
367. //rt_kprintf( "Resultstoloadtospreadsheet ");
369. // rt_kprintf( " %9.3f %9.3f %9.3f", mwips, loop_mflops[1],
370. // loop_mflops[2]);
372. // rt_kprintf( " %9.3f %9.3f %9.3f", loop_mflops[6],
373. // loop_mops[5], loop_mops[8]);
374. //rt_kprintf( " %9.3f %9.3f %9.3fnn", loop_mops[4],
375. // loop_mops[3], loop_mops[7]);
376. ///fflush(outfile);
379. ///fclose (outfile);
381. ///rt_kprintf ("n");
382. ///rt_kprintf ("A new results file, whets.txt,will have been created in the samen");
383. ///rt_kprintf ("directory as the .EXE files, if one did not already exist.nn");
385. if (nopause)
386. {
387. rt_kprintf(" Press Enternn");
388. i = getchar();
389. }
390. return 0;
391. }
393. void whetstones(long xtra, long x100, int calibrate)
394. {
396. long n1,n2,n3,n4,n5,n6,n7,n8,i,ix,n1mult;
397. SPDP x,y,z;
398. long j,k,l;
399. SPDP e1[4];
401. SPDP t =0.49999975;
402. SPDP t0 = t;
403. SPDP t1 = 0.50000025;
404. SPDP t2 = 2.0;
406. Check=0.0;
408. n1 = 12*x100;
409. n2 = 14*x100;
410. n3 = 345*x100;
411. n4 = 210*x100;
412. n5 = 32*x100;
413. n6 = 899*x100;
414. n7 = 616*x100;
415. n8 = 93*x100;
416. n1mult = 10;
418. /* Section 1, Array elements */
420. e1[0] = 1.0;
421. e1[1] = -1.0;
422. e1[2] = -1.0;
423. e1[3] = -1.0;
424. start_time();
425. {
426. for (ix=0; ix;>
427. {
428. for(i=0; i*n1mult;>
429. {
430. e1[0] = (e1[0] + e1[1] + e1[2] - e1[3]) * t;
431. e1[1] = (e1[0] + e1[1] - e1[2] + e1[3]) * t;
432. e1[2] = (e1[0] - e1[1] + e1[2] + e1[3]) * t;
433. e1[3] = (-e1[0] + e1[1] + e1[2] + e1[3]) * t;
434. }
435. t = 1.0 - t;
436. }
437. t =t0;
438. }
439. end_time();
440. secs = secs/(SPDP)(n1mult);
441. pout("N1 floating point",(float)(n1*16)*(float)(xtra),
442. 1,e1[3],secs,calibrate,1);
444. /* Section 2, Array as parameter */
446. start_time();
447. {
448. for (ix=0; ix;>
449. {
450. for(i=0; i;>
451. {
452. pa(e1,t,t2);
453. }
454. t = 1.0 - t;
455. }
456. t =t0;
457. }
458. end_time();
459. pout("N2 floating point",(float)(n2*96)*(float)(xtra),
460. 1,e1[3],secs,calibrate,2);
462. /* Section 3, Conditional jumps */
463. j = 1;
464. start_time();
465. {
466. for (ix=0; ix;>
467. {
468. for(i=0; i;>
469. {
470. if(j==1) j = 2;
471. else j = 3;
472. if(j>2) j = 0;
473. else j = 1;
474. if(j<1)        j = 1;
475. else j = 0;
476. }
477. }
478. }
479. end_time();
480. pout("N3 if then else",(float)(n3*3)*(float)(xtra),
481. 2,(SPDP)(j),secs,calibrate,3);
483. /* Section 4, Integer arithmetic */
484. j = 1;
485. k = 2;
486. l = 3;
487. e1[0] = 0.0;
488. e1[1] = 0.0;
489. start_time();
490. {
491. for (ix=0; ix;>
492. {
493. for(i=0; i;>
494. {
495. j = j *(k-j)*(l-k);
496. k = l * k - (l-j) * k;
497. l = (l-k) * (k+j);
498. e1[l-2] = e1[l-2] + j + k + l;
499. e1[k-2] = e1[k-2] + j * k * l;
500. //was e1[l-2] = j + k + l; ande1[k-2] = j * k * l;
501. }
502. }
503. }
504. end_time();
505. x = (e1[0]+e1[1])/(SPDP)n4/(SPDP)xtra; // was x = e1[0]+e1[1];
506. pout("N4 fixed point ",(float)(n4*15)*(float)(xtra),
507. 2,x,secs,calibrate,4);
509. /* Section 5, Trig functions */
510. x = 0.5;
511. y = 0.5;
512. start_time();
513. {
514. for (ix=0; ix;>
515. {
516. for(i=1; i;>
517. {
518. x = t*atan(t2*sin(x)*cos(x)/(cos(x+y)+cos(x-y)-1.0));
519. y = t*atan(t2*sin(y)*cos(y)/(cos(x+y)+cos(x-y)-1.0));
520. }
521. t = 1.0 - t;
522. }
523. t = t0;
524. }
525. end_time();
526. pout("N5 sin,cos etc.",(float)(n5*26)*(float)(xtra),
527. 2,y,secs,calibrate,5);
530. /* Section 6, Procedure calls */
531. x = 1.0;
533. y = 1.0;
534. z = 1.0;
535. start_time();
536. {
537. for (ix=0; ix;>
538. {
539. for(i=0; i;>
540. {
541. p3(&x,&y,&z,t,t1,t2);
542. }
543. }
544. }
545. end_time();
546. pout("N6 floating point",(float)(n6*6)*(float)(xtra),
547. 1,z,secs,calibrate,6);
549. /* Section 7, Array refrences */
550. j = 0;
551. k = 1;
552. l = 2;
553. e1[0] = 1.0;
554. e1[1] = 2.0;
555. e1[2] = 3.0;
556. start_time();
557. {
558. for (ix=0; ix;>
559. {
560. for(i=0;i;i++)
561. {
562. po(e1,j,k,l);
563. }
564. }
565. }
566. end_time();
567. pout("N7 assignments ",(float)(n7*3)*(float)(xtra),
568. 2,e1[2],secs,calibrate,7);
570. /* Section 8, Standard functions */
571. x = 0.75;
572. start_time();
573. {
574. for (ix=0; ix;>
575. {
576. for(i=0; i;>
577. {
578. x = sqrt(exp(log(x)/t1));
579. }
580. }
581. }
582. end_time();
583. pout("N8 exp,sqrt etc. ",(float)(n8*4)*(float)(xtra),
584. 2,x,secs,calibrate,8);
586. return;
587. }
590. void pa(SPDP e[4], SPDP t, SPDP t2)
591. {
592. long j;
593. for(j=0;j<6;j++)
594. {
595. e[0] = (e[0]+e[1]+e[2]-e[3])*t;
596. e[1] = (e[0]+e[1]-e[2]+e[3])*t;
597. e[2] = (e[0]-e[1]+e[2]+e[3])*t;
598. e[3] = (-e[0]+e[1]+e[2]+e[3])/t2;
599. }
601. return;
602. }
604. void po(SPDP e1[4], long j, long k, long l)
605. {
606. e1[j] = e1[k];
607. e1[k] = e1[l];
608. e1[l] = e1[j];
609. return;
610. }
612. void p3(SPDP *x, SPDP *y, SPDP *z, SPDP t, SPDP t1, SPDP t2)
613. {
614. *x = *y;
615. *y = *z;
616. *x = t * (*x + *y);
617. *y = t1 * (*x + *y);
618. *z = (*x + *y)/t2;
619. return;
620. }
623. void pout(char* title, float ops, int type, SPDP checknum,
624. SPDP time, int calibrate, int section)
625. {
626. SPDP mops,mflops;
628. Check = Check + checknum;
629. loop_time[section] = time;
630. strcpy (headings[section],title);
631. TimeUsed =TimeUsed + time;
632. if (calibrate == 1)
634. {
635. results[section] = checknum;
636. }
637. if (calibrate == 0)
638. {
639. rt_kprintf("%s %13d ",headings[section],(int)(results[section]*1000));
641. if (type == 1)
642. {
643. if (time>0)
644. {
645. mflops = ops/(1000000L*time);
646. }
647. else
648. {
649. mflops = 0;
650. }
651. loop_mops[section] = 99999;
652. loop_mflops[section] = mflops;
653. rt_kprintf(" %13d %13dn",
654. (int)(loop_mflops[section]*1000), (int)(loop_time[section]*1000));
655. }
656. else
657. {
658. if (time>0)
659. {
660. mops = ops/(1000000L*time);
661. }
662. else
663. {
664. mops = 0;
665. }
666. loop_mops[section] = mops;
667. loop_mflops[section] = 0;
668. rt_kprintf(" %13d%13dn",
669. (int)(loop_mops[section]), (int)(loop_time[section]*1000));
670. }
671. }
673. return;
674. }

复制代码