【先楫半导体HPM6750EVKMINI评估板试用体验】基准性能测试之一:整数计算能力Dhrystone

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


前言

根据描述该新芯片整数计算能力Dhrystone达到4651 DMIPS

我们就实际测试一下。

注:

Dhrystone是于1984年由Reinhold P. Weicker设计的一套综合的基准程序，该程序用来测试CPU（整数）计算性能。其输出结果为每秒钟运行Dhrystone的次数，即每秒钟迭代主循环的次数。

获取代码

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

解压classic_benchmarks.tar.gz将classic_benchmarksclassic_benchmarkssource_codedhrystone2文件夹复制到自己的工程。

添加代码

将dhrystone2文件夹复制到工程目录projled下，按如下刷新

看到文件刷新了

修改代码

• 主要添加时间测量接口

使用rt_tick_get

start_time();

end_time();

local_time();

等接口删除

• 删除CPU相关接口

classic_benchmarksclassic_benchmarkssource_codecommon_32bit的cpuidc.c中实现相应的接口,我们不使用

删除#include "cpuidh.h"相关接口

• 修改dhry_1.c

• fprintf全部替换为printf
• 浮点打印改为整数打印
• 调用

dhry_1.c中的main改为dhry_main

在main.c的main函数中调用

1. int main(void)
3. {
5. void dhry_main (int argc, char *argv[]);
7. dhry_main(0,0);
11. app_init_led_pins();
15. static uint32_t led_thread_arg = 0;
17. rt_thread_t led_thread = rt_thread_create("led_th", thread_entry, &led_thread_arg, 1024, 1, 10);
19. rt_thread_startup(led_thread);
23. return 0;
25. }

复制代码

测试

考虑优化等级

考虑减少系统抵达中断频率

	RT_TICK_PER_SECOND=1000		RT_TICK_PER_SECOND=100
	优化等级0	优化等级3	优化等级0	优化等级3
RAM中运行	828DMIPS	2508DMIPS		2536DMIPS
ROM中运行	828	2507DMIPS		2529DMIPS

最后实测大概2536DMIPS和表明的4651 DMIPS差一倍左右，不知道是标注的是双核一起，还是有优化措施可以再提高。

测试代码
dhry_1.c

1. /* gcc dhry_1.c dhry_2.c cpuidc64.o cpuida64.o -m64 -lrt -lc -lm -o dhry2
2. *************************************************************************
3. *
4. * "DHRYSTONE" Benchmark Program
5. * -----------------------------
6. *
7. *Version: C, Version 2.1
8. *
9. *File: dhry_1.c (part 2 of 3)
10. *
11. *Date: May 25, 1988
12. *
13. *Author: Reinhold P. Weicker
14. *
15. *************************************************************************
16. *
17. * #define options not used
18. */
20. #include
21. #include
22. #include
23. #include "rtthread.h"
24. #include "dhry.h"
25. //#include "cpuidh.h"
27. #ifdef CNNT
28. #define options "Non-optimised"
29. #define opt "0"
30. #else
31. // #define options "Optimised"
32. #define options "Opt 3 64 Bit"
33. #define opt ""
34. #endif
37. /* Global Variables: */
39. Rec_Pointer Ptr_Glob,
40. Next_Ptr_Glob;
41. int Int_Glob;
42. Boolean Bool_Glob;
43. char Ch_1_Glob,
44. Ch_2_Glob;
45. int Arr_1_Glob [50];
46. int Arr_2_Glob [50] [50];
48. char Reg_Define[40] = "Register option Selected.";
51. Enumeration Func_1 (Capital_Letter Ch_1_Par_Val,
52. Capital_Letter Ch_2_Par_Val);
53. /*
54. forward declaration necessary since Enumeration may not simply be int
55. */
57. #ifndef ROPT
58. #define REG
59. /* REG becomes defined as empty */
60. /* i.e. no register variables */
61. #else
62. #define REG register
63. #endif
65. void Proc_1 (REG Rec_Pointer Ptr_Val_Par);
66. void Proc_2 (One_Fifty *Int_Par_Ref);
67. void Proc_3 (Rec_Pointer *Ptr_Ref_Par);
68. void Proc_4 ();
69. void Proc_5 ();
70. void Proc_6 (Enumeration Enum_Val_Par, Enumeration *Enum_Ref_Par);
71. void Proc_7 (One_Fifty Int_1_Par_Val, One_Fifty Int_2_Par_Val,
72. One_Fifty *Int_Par_Ref);
73. void Proc_8 (Arr_1_Dim Arr_1_Par_Ref, Arr_2_Dim Arr_2_Par_Ref,
74. int Int_1_Par_Val, int Int_2_Par_Val);
76. Boolean Func_2 (Str_30 Str_1_Par_Ref, Str_30 Str_2_Par_Ref);
79. /* variables for time measurement: */
81. #define Too_Small_Time 2
82. /* Measurements should last at least 2 seconds */
84. double User_Time;
86. double Microseconds,
87. Dhrystones_Per_Second,
88. Vax_Mips;
90. /* end of variables for time measurement */
93. void dhry_main (int argc, char *argv[])
94. /*****/
96. /* main program, corresponds to procedures */
97. /* Main and Proc_0 in the Ada version */
98. {
100. One_Fifty Int_1_Loc;
101. REG One_Fifty Int_2_Loc;
102. One_Fifty Int_3_Loc;
103. REG char Ch_Index;
104. Enumeration Enum_Loc;
105. Str_30 Str_1_Loc;
106. Str_30 Str_2_Loc;
107. REG int Run_Index;
108. REG int Number_Of_Runs;
109. int endit, count = 10;
110. FILE *Ap;
111. int errors = 0;
112. int i;
113. int nopause = 1;
116. /* Initializations */
117. if (argc > 1)
118. {
119. switch (argv[1][0])
120. {
121. case 'N':
122. nopause = 0;
123. break;
124. case 'n':
125. nopause = 0;
126. break;
127. }
128. }
130. // if ((Ap = fopen("Dhry.txt","a+")) == NULL)
131. // {
132. // printf(" Can not open Dhry.txtnn");
133. // printf(" Press Enternn");
134. // int g = getchar();
135. // exit(1);
136. //}
138. /***********************************************************************
139. * Change for compiler and optimisation used *
140. ***********************************************************************/
142. Next_Ptr_Glob = (Rec_Pointer) malloc (sizeof (Rec_Type));
143. Ptr_Glob = (Rec_Pointer) malloc (sizeof (Rec_Type));
145. Ptr_Glob->Ptr_Comp = Next_Ptr_Glob;
146. Ptr_Glob->Discr = Ident_1;
147. Ptr_Glob->variant.var_1.Enum_Comp = Ident_3;
148. Ptr_Glob->variant.var_1.Int_Comp = 40;
149. strcpy (Ptr_Glob->variant.var_1.Str_Comp,
150. "DHRYSTONE PROGRAM, SOME STRING");
151. strcpy (Str_1_Loc, "DHRYSTONE PROGRAM, 1'ST STRING");
153. Arr_2_Glob [8][7] = 10;
154. /* Was missing in published program. Without this statement, */
155. /* Arr_2_Glob [8][7] would have an undefined value. */
156. /* Warning: With 16-Bit processors and Number_Of_Runs > 32000, */
157. /* overflow may occur for this array element. */
159. //getDetails();
160. //for (i=1; i<10; i++)
161. //{
162. // printf("%sn", configdata[i]);
163. //}
164. //printf("n");
166. //printf ( " #####################################################nn");
167. //for (i=1; i<10; i++)
168. //{
169. // printf( "%s n", configdata[i]);
170. //}
171. //printf ( "n");
173. printf("##########################################n");
175. printf ("n");
176. printf ("Dhrystone Benchmark, Version 2.1 (Language: C or C++)n");
177. printf ("n");
179. printf ("Optimisation %sn", options);
180. #ifdef ROPT
181. printf ("Register option selectednn");
182. #else
183. printf ("Register option not selectednn");
184. strcpy(Reg_Define, "Register optionNot selected.");
185. #endif // "Register option Selected."
187. /*
188. if (Reg)
189. {
190. printf ("Program compiled with 'register' attributen");
191. printf ("n");
192. }
193. else
194. {
195. printf ("Program compiled without 'register' attributen");
196. printf ("n");
197. }
199. printf ("Please give the number of runs through the benchmark: ");
200. {
201. int n;
202. scanf ("%d", &n);
203. Number_Of_Runs = n;
204. }
205. printf ("n");
206. printf ("Execution starts, %d runs through Dhrystonen",
207. Number_Of_Runs);
208. */
210. Number_Of_Runs = 5000;
212. do
213. {
215. Number_Of_Runs = Number_Of_Runs * 2;
216. count = count - 1;
217. Arr_2_Glob [8][7] = 10;
219. /***************/
220. /* Start timer */
221. /***************/
223. ///start_time();
224. rt_tick_t start_time = rt_tick_get();
226. for (Run_Index = 1; Run_Index <= Number_Of_Runs; ++Run_Index)
227. {
229. Proc_5();
230. Proc_4();
231. /* Ch_1_Glob == 'A', Ch_2_Glob == 'B', Bool_Glob == true */
232. Int_1_Loc = 2;
233. Int_2_Loc = 3;
234. strcpy (Str_2_Loc, "DHRYSTONE PROGRAM, 2'ND STRING");
235. Enum_Loc = Ident_2;
236. Bool_Glob = ! Func_2 (Str_1_Loc, Str_2_Loc);
237. /* Bool_Glob == 1 */
238. while (Int_1_Loc < Int_2_Loc)  /* loop body executed once */
239. {
240. Int_3_Loc = 5 * Int_1_Loc - Int_2_Loc;
241. /* Int_3_Loc == 7 */
242. Proc_7 (Int_1_Loc, Int_2_Loc, &Int_3_Loc);
243. /* Int_3_Loc == 7 */
244. Int_1_Loc += 1;
245. } /* while */
246. /* Int_1_Loc == 3, Int_2_Loc == 3, Int_3_Loc == 7 */
247. Proc_8 (Arr_1_Glob, Arr_2_Glob, Int_1_Loc, Int_3_Loc);
248. /* Int_Glob == 5 */
249. Proc_1 (Ptr_Glob);
250. for (Ch_Index = 'A'; Ch_Index <= Ch_2_Glob; ++Ch_Index)
251. /* loop body executed twice */
252. {
253. if (Enum_Loc == Func_1 (Ch_Index, 'C'))
254. /* then, not executed */
255. {
256. Proc_6 (Ident_1, &Enum_Loc);
257. strcpy (Str_2_Loc, "DHRYSTONE PROGRAM, 3'RD STRING");
258. Int_2_Loc = Run_Index;
259. Int_Glob = Run_Index;
260. }
261. }
262. /* Int_1_Loc == 3, Int_2_Loc == 3, Int_3_Loc == 7 */
263. Int_2_Loc = Int_2_Loc * Int_1_Loc;
264. Int_1_Loc = Int_2_Loc / Int_3_Loc;
265. Int_2_Loc = 7 * (Int_2_Loc - Int_3_Loc) - Int_1_Loc;
266. /* Int_1_Loc == 1, Int_2_Loc == 13, Int_3_Loc == 7 */
267. Proc_2 (&Int_1_Loc);
268. /* Int_1_Loc == 5 */
270. } /* loop "for Run_Index" */
272. /**************/
273. /* Stop timer */
274. /**************/
276. ///end_time();
277. ///User_Time = secs;
278. User_Time = ((rt_tick_get() - start_time)*1.0)/RT_TICK_PER_SECOND;
280. printf ("%d runs %d milliseconds n",Number_Of_Runs, (int)(User_Time*1000));
281. if (User_Time > 2)
282. {
283. count = 0;
284. }
285. else
286. {
287. if (User_Time < 0.05)
288. {
289. Number_Of_Runs = Number_Of_Runs * 5;
290. }
291. }
292. } /* calibrate/run do while */
293. while (count >0);
295. printf ("n");
296. printf ("Final values (* implementation-dependent):n");
297. printf ("n");
298. printf ("Int_Glob: ");
299. if (Int_Glob == 5)printf ("O.K.");
300. else printf ("WRONG ");
301. printf ("%d", Int_Glob);
303. printf ("Bool_Glob: ");
304. if (Bool_Glob == 1) printf ("O.K.");
305. else printf ("WRONG ");
306. printf ("%dn", Bool_Glob);
308. printf ("Ch_1_Glob: ");
309. if (Ch_1_Glob == 'A')printf ("O.K.");
310. else printf ("WRONG ");
311. printf ("%c", Ch_1_Glob);
313. printf ("Ch_2_Glob: ");
314. if (Ch_2_Glob == 'B')printf ("O.K.");
315. else printf ("WRONG ");
316. printf ("%cn",Ch_2_Glob);
318. printf ("Arr_1_Glob[8]: ");
319. if (Arr_1_Glob[8] == 7)printf ("O.K.");
320. else printf ("WRONG ");
321. printf ("%d", Arr_1_Glob[8]);
323. printf ("Arr_2_Glob8/7: ");
324. if (Arr_2_Glob[8][7] == Number_Of_Runs + 10)
325. printf ("O.K.");
326. else printf ("WRONG ");
327. printf ("%10dn", Arr_2_Glob[8][7]);
329. printf ("Ptr_Glob-> ");
330. printf ("Ptr_Comp: * %dn", (int) Ptr_Glob->Ptr_Comp);
332. printf ("Discr: ");
333. if (Ptr_Glob->Discr == 0)printf ("O.K.");
334. else printf ("WRONG ");
335. printf ("%d", Ptr_Glob->Discr);
337. printf ("Enum_Comp: ");
338. if (Ptr_Glob->variant.var_1.Enum_Comp == 2)
339. printf ("O.K.");
340. else printf ("WRONG ");
341. printf ("%dn", Ptr_Glob->variant.var_1.Enum_Comp);
343. printf ("Int_Comp: ");
344. if (Ptr_Glob->variant.var_1.Int_Comp == 17)printf ("O.K.");
345. else printf ("WRONG ");
346. printf ("%d ", Ptr_Glob->variant.var_1.Int_Comp);
348. printf ("Str_Comp: ");
349. if (strcmp(Ptr_Glob->variant.var_1.Str_Comp,
350. "DHRYSTONE PROGRAM, SOME STRING") == 0)
351. printf ("O.K.");
352. else printf ("WRONG ");
353. printf ("%sn", Ptr_Glob->variant.var_1.Str_Comp);
355. printf ("Next_Ptr_Glob-> ");
356. printf ("Ptr_Comp: * %d", (int) Next_Ptr_Glob->Ptr_Comp);
357. printf (" same as aboven");
359. printf ("Discr: ");
360. if (Next_Ptr_Glob->Discr == 0)
361. printf ("O.K.");
362. else printf ("WRONG ");
363. printf ("%d", Next_Ptr_Glob->Discr);
365. printf ("Enum_Comp: ");
366. if (Next_Ptr_Glob->variant.var_1.Enum_Comp == 1)
367. printf ("O.K.");
368. else printf ("WRONG ");
369. printf ("%dn", Next_Ptr_Glob->variant.var_1.Enum_Comp);
371. printf ("Int_Comp: ");
372. if (Next_Ptr_Glob->variant.var_1.Int_Comp == 18)
373. printf ("O.K.");
374. else printf ("WRONG ");
375. printf ("%d ", Next_Ptr_Glob->variant.var_1.Int_Comp);
377. printf ("Str_Comp: ");
378. if (strcmp(Next_Ptr_Glob->variant.var_1.Str_Comp,
379. "DHRYSTONE PROGRAM, SOME STRING") == 0)
380. printf ("O.K.");
381. else printf ("WRONG ");
382. printf ("%sn", Next_Ptr_Glob->variant.var_1.Str_Comp);
384. printf ("Int_1_Loc: ");
385. if (Int_1_Loc == 5)
386. printf ("O.K.");
387. else printf ("WRONG ");
388. printf ("%d", Int_1_Loc);
390. printf ("Int_2_Loc: ");
391. if (Int_2_Loc == 13)
392. printf ("O.K.");
393. else printf ("WRONG ");
394. printf ("%dn", Int_2_Loc);
396. printf ("Int_3_Loc: ");
397. if (Int_3_Loc == 7)
398. printf ("O.K.");
399. else printf ("WRONG ");
400. printf ("%d", Int_3_Loc);
402. printf ("Enum_Loc: ");
403. if (Enum_Loc == 1)
404. printf ("O.K.");
405. else printf ("WRONG ");
406. printf ("%dn", Enum_Loc);
409. printf ("Str_1_Loc: ");
410. if (strcmp(Str_1_Loc, "DHRYSTONE PROGRAM, 1'ST STRING") == 0)
411. printf ("O.K.");
413. else printf ("WRONG ");
414. printf ("%sn", Str_1_Loc);
416. printf ("Str_2_Loc: ");
417. if (strcmp(Str_2_Loc, "DHRYSTONE PROGRAM, 2'ND STRING") == 0)
418. printf ("O.K.");
419. else printf ("WRONG ");
420. printf ("%sn", Str_2_Loc);
423. printf ("n");
426. if (User_Time < Too_Small_Time)
427. {
428. printf ("Measured time too small to obtain meaningful resultsn");
429. printf ("Please increase number of runsn");
430. printf ("n");
431. }
432. else
433. {
434. Microseconds = User_Time * Mic_secs_Per_Second
435. / (double) Number_Of_Runs;
436. Dhrystones_Per_Second = (double) Number_Of_Runs / User_Time;
437. Vax_Mips = Dhrystones_Per_Second / 1757.0;
439. printf ("Microseconds(/1000) for one run through Dhrystone: ");
440. printf ("%d n", (int)(Microseconds*1000));
441. printf ("Dhrystones per Second: ");
442. printf ("%d n",(int)Dhrystones_Per_Second);
443. printf ("VAXMIPS rating = ");
444. printf ("%d n", (int)Vax_Mips);
445. printf ("n");
448. /************************************************************************
449. * Add results to output file Dhry.txt *
450. ************************************************************************/
451. ///local_time();
452. ///printf ( " #####################################################nn");
453. ///printf ( " Dhrystone Benchmark 2.1 %s via C/C++ %sn", options, timeday);
454. ///printf ( " VAX MIPS rating: %12.2lfnn",Vax_Mips);
456. // printf( " Classic Benchmark Ratings for CPUSpeed.txt where 100 MHz Pentium = 100n");
457. /*
458. if (strtol(opt, NULL, 10) == 1)
459. {
460. printf( " Integer Dhry2 Opt %dnn", (int)(Vax_Mips / 130 * 100));
461. }
462. else
463. {
464. printf( " Integer Dhry2 NoOpt %dnn", (int)(Vax_Mips / 32 * 100));
465. }
466. */
468. if (Int_Glob != 5)
469. {
470. printf ( " Wrong result Int_Glob Was %d Should be 5n", Int_Glob);
471. errors = errors + 1;
472. }
473. if (Bool_Glob != 1)
474. {
475. printf ( " Wrong result Bool_Glob Was %d Should be 1n", Bool_Glob);
476. errors = errors + 1;
477. }
478. if (Ch_1_Glob != 'A')
479. {
480. printf ( " Wrong result Ch_1_Glob Was %c Should be An", Ch_1_Glob);
481. errors = errors + 1;
482. }
483. if (Ch_2_Glob != 'B')
484. {
485. printf ( " Wrong result Ch_2_Glob Was %c Should be Bn", Ch_2_Glob);
486. errors = errors + 1;
487. }
488. if (Arr_1_Glob[8] != 7)
489. {
490. printf ( " Wrong result Arr_1_Glob[8] Was %d Should be 7n", Arr_1_Glob[8]);
491. errors = errors + 1;
492. }
493. if (Arr_2_Glob[8][7] != Number_Of_Runs + 10)
494. {
495. printf ( " Wrong result Arr_2_Glob[8][7] Was %d Should be %dn", Arr_2_Glob[8][7], Number_Of_Runs + 10);
496. errors = errors + 1;
497. }
498. if (Ptr_Glob->Discr != 0)
499. {
500. printf ( " Wrong result Ptr_Glob->Discr Was %d Should be 0n", Ptr_Glob->Discr);
501. errors = errors + 1;
502. }
503. if (Ptr_Glob->variant.var_1.Enum_Comp != 2)
504. {
505. printf ( " Wrong result Ptr_Glob->variant.var_1.Enum_Comp Was %d Should be 2n", Ptr_Glob->variant.var_1.Enum_Comp);
506. errors = errors + 1;
507. }
508. if (Ptr_Glob->variant.var_1.Int_Comp != 17)
509. {
510. printf ( " Wrong result Ptr_Glob->variant.var_1.Int_Comp Was %d Should be 17n", Ptr_Glob->variant.var_1.Int_Comp);
511. errors = errors + 1;
512. }
513. if (strcmp(Ptr_Glob->variant.var_1.Str_Comp,"DHRYSTONE PROGRAM, SOME STRING") != 0)
514. {
515. printf ( " Wrong result Ptr_Glob->variant.var_1.Str_Comp Was %s Should be DHRYSTONE PROGRAM, SOME STRINGn", Ptr_Glob->variant.var_1.Str_Comp);
516. errors = errors + 1;
517. }
518. if (Next_Ptr_Glob->Discr != 0)
519. {
520. printf ( " Wrong result Next_Ptr_Glob->Discr Was %d Should be 0n", Next_Ptr_Glob->Discr);
521. errors = errors + 1;
522. }
523. if (Next_Ptr_Glob->variant.var_1.Enum_Comp != 1)
524. {
525. printf ( " Wrong result Next_Ptr_Glob->variant.var_1.Enum_Comp Was %d Should be 1n", Next_Ptr_Glob->variant.var_1.Enum_Comp);
526. errors = errors + 1;
527. }
528. if (Next_Ptr_Glob->variant.var_1.Int_Comp != 18)
529. {
530. printf ( " Wrong result Next_Ptr_Glob->variant.var_1.Int_Comp Was %d Should be 18n", Next_Ptr_Glob->variant.var_1.Int_Comp);
531. errors = errors + 1;
532. }
533. if (strcmp(Next_Ptr_Glob->variant.var_1.Str_Comp,"DHRYSTONE PROGRAM, SOME STRING") != 0)
534. {
535. printf ( " Wrong result Next_Ptr_Glob->variant.var_1.Str_Comp Was %s Should be DHRYSTONE PROGRAM, SOME STRINGn", Next_Ptr_Glob->variant.var_1.Str_Comp);
536. errors = errors + 1;
537. }
538. if (Int_1_Loc != 5)
539. {
540. printf ( " Wrong result Int_1_Loc Was %d Should be 5n", Int_1_Loc);
541. errors = errors + 1;
542. }
543. if (Int_2_Loc != 13)
544. {
545. printf ( " Wrong result Int_2_Loc Was %d Should be 13n", Int_2_Loc);
546. errors = errors + 1;
547. }
548. if (Int_3_Loc != 7)
549. {
550. printf ( " Wrong result Int_3_Loc Was %d Should be 7n", Int_3_Loc);
551. errors = errors + 1;
552. }
553. if (Enum_Loc != 1)
554. {
555. printf ( " Wrong result Enum_Loc Was %d Should be 1n", Enum_Loc);
556. errors = errors + 1;
557. }
558. if (strcmp(Str_1_Loc, "DHRYSTONE PROGRAM, 1'ST STRING") != 0)
559. {
560. printf ( " Wrong result Str_1_Loc Was %s Should be DHRYSTONE PROGRAM, 1'ST STRINGn", Str_1_Loc);
561. errors = errors + 1;
562. }
563. if (strcmp(Str_2_Loc, "DHRYSTONE PROGRAM, 2'ND STRING") != 0)
564. {
565. printf ( " Wrong result Str_2_Loc Was %s Should be DHRYSTONE PROGRAM, 2'ND STRINGn", Str_2_Loc);
566. errors = errors + 1;
567. }
568. if (errors == 0)
569. {
570. printf ( " Numeric results were correctnn");
571. }
572. else
573. {
574. printf ( "n");
575. }
577. ///fclose(Ap);
578. }
579. if (nopause)
580. {
581. printf(" Press Enternn");
582. int g = getchar();
583. }
584. }
586. void Proc_1 (REG Rec_Pointer Ptr_Val_Par)
587. /******************/
589. /* executed once */
590. {
591. REG Rec_Pointer Next_Record = Ptr_Val_Par->Ptr_Comp;
592. /* == Ptr_Glob_Next */
593. /* Local variable, initialized with Ptr_Val_Par->Ptr_Comp, */
594. /* corresponds to "rename" in Ada, "with" in Pascal */
596. structassign (*Ptr_Val_Par->Ptr_Comp, *Ptr_Glob);
597. Ptr_Val_Par->variant.var_1.Int_Comp = 5;
598. Next_Record->variant.var_1.Int_Comp
599. = Ptr_Val_Par->variant.var_1.Int_Comp;
600. Next_Record->Ptr_Comp = Ptr_Val_Par->Ptr_Comp;
601. Proc_3 (&Next_Record->Ptr_Comp);
602. /* Ptr_Val_Par->Ptr_Comp->Ptr_Comp
603. == Ptr_Glob->Ptr_Comp */
604. if (Next_Record->Discr == Ident_1)
605. /* then, executed */
606. {
607. Next_Record->variant.var_1.Int_Comp = 6;
608. Proc_6 (Ptr_Val_Par->variant.var_1.Enum_Comp,
609. &Next_Record->variant.var_1.Enum_Comp);
610. Next_Record->Ptr_Comp = Ptr_Glob->Ptr_Comp;
611. Proc_7 (Next_Record->variant.var_1.Int_Comp, 10,
612. &Next_Record->variant.var_1.Int_Comp);
613. }
614. else /* not executed */
615. structassign (*Ptr_Val_Par, *Ptr_Val_Par->Ptr_Comp);
616. } /* Proc_1 */
619. void Proc_2 (One_Fifty *Int_Par_Ref)
620. /******************/
621. /* executed once */
622. /* *Int_Par_Ref == 1, becomes 4 */
624. {
625. One_FiftyInt_Loc;
626. Enumeration Enum_Loc;
628. Int_Loc = *Int_Par_Ref + 10;
629. do /* executed once */
630. if (Ch_1_Glob == 'A')
631. /* then, executed */
632. {
633. Int_Loc -= 1;
634. *Int_Par_Ref = Int_Loc - Int_Glob;
635. Enum_Loc = Ident_1;
636. } /* if */
637. while (Enum_Loc != Ident_1); /* true */
638. } /* Proc_2 */
641. void Proc_3 (Rec_Pointer *Ptr_Ref_Par)
642. /******************/
643. /* executed once */
644. /* Ptr_Ref_Par becomes Ptr_Glob */
646. {
647. if (Ptr_Glob != Null)
648. /* then, executed */
649. *Ptr_Ref_Par = Ptr_Glob->Ptr_Comp;
650. Proc_7 (10, Int_Glob, &Ptr_Glob->variant.var_1.Int_Comp);
651. } /* Proc_3 */
654. void Proc_4 () /* without parameters */
655. /*******/
656. /* executed once */
657. {
658. Boolean Bool_Loc;
660. Bool_Loc = Ch_1_Glob == 'A';
661. Bool_Glob = Bool_Loc | Bool_Glob;
662. Ch_2_Glob = 'B';
663. } /* Proc_4 */
666. void Proc_5 () /* without parameters */
667. /*******/
668. /* executed once */
669. {
670. Ch_1_Glob = 'A';
671. Bool_Glob = false;
672. } /* Proc_5 */
675. /* Procedure for the assignment of structures, */
676. /* if the C compiler doesn't support this feature */
677. #ifdefNOSTRUCTASSIGN
678. memcpy (d, s, l)
679. register char *d;
680. register char *s;
681. register int l;
682. {
683. while (l--) *d++ = *s++;
684. }
685. #endif

复制代码

dhry_2.c

1. /*
2. *************************************************************************
3. *
4. * "DHRYSTONE" Benchmark Program
5. * -----------------------------
6. *
7. *Version: C, Version 2.1
8. *
9. *File: dhry_2.c (part 3 of 3)
10. *
11. *Date: May 25, 1988
12. *
13. *Author: Reinhold P. Weicker
14. *
15. *************************************************************************
16. */
18. #include "dhry.h"
20. #ifndef REG
21. #define REG
22. /* REG becomes defined as empty */
23. /* i.e. no register variables */
24. #else
25. #define REG register
26. #endif
28. externint Int_Glob;
29. externchar Ch_1_Glob;
31. Boolean Func_3 (Enumeration Enum_Par_Val);
33. void Proc_6 (Enumeration Enum_Val_Par, Enumeration *Enum_Ref_Par)
34. /*********************************/
35. /* executed once */
36. /* Enum_Val_Par == Ident_3, Enum_Ref_Par becomes Ident_2 */
38. {
39. *Enum_Ref_Par = Enum_Val_Par;
40. if (! Func_3 (Enum_Val_Par))
41. /* then, not executed */
42. *Enum_Ref_Par = Ident_4;
43. switch (Enum_Val_Par)
44. {
45. case Ident_1:
46. *Enum_Ref_Par = Ident_1;
47. break;
48. case Ident_2:
49. if (Int_Glob > 100)
50. /* then */
51. *Enum_Ref_Par = Ident_1;
52. else *Enum_Ref_Par = Ident_4;
53. break;
54. case Ident_3: /* executed */
55. *Enum_Ref_Par = Ident_2;
56. break;
57. case Ident_4: break;
58. case Ident_5:
59. *Enum_Ref_Par = Ident_3;
60. break;
61. } /* switch */
62. } /* Proc_6 */
65. void Proc_7 (One_Fifty Int_1_Par_Val, One_Fifty Int_2_Par_Val,
66. One_Fifty *Int_Par_Ref)
67. /**********************************************/
68. /* executed three times */
69. /* first call: Int_1_Par_Val == 2, Int_2_Par_Val == 3,*/
70. /* Int_Par_Ref becomes 7 */
71. /* second call: Int_1_Par_Val == 10, Int_2_Par_Val == 5, */
72. /* Int_Par_Ref becomes 17 */
73. /* third call: Int_1_Par_Val == 6, Int_2_Par_Val == 10, */
74. /* Int_Par_Ref becomes 18 */
76. {
77. One_Fifty Int_Loc;
79. Int_Loc = Int_1_Par_Val + 2;
80. *Int_Par_Ref = Int_2_Par_Val + Int_Loc;
81. } /* Proc_7 */
84. void Proc_8 (Arr_1_Dim Arr_1_Par_Ref, Arr_2_Dim Arr_2_Par_Ref,
85. int Int_1_Par_Val, int Int_2_Par_Val)
86. /*********************************************************************/
87. /* executed once */
88. /* Int_Par_Val_1 == 3 */
89. /* Int_Par_Val_2 == 7 */
91. {
92. REG One_Fifty Int_Index;
93. REG One_Fifty Int_Loc;
95. Int_Loc = Int_1_Par_Val + 5;
96. Arr_1_Par_Ref [Int_Loc] = Int_2_Par_Val;
97. Arr_1_Par_Ref [Int_Loc+1] = Arr_1_Par_Ref [Int_Loc];
98. Arr_1_Par_Ref [Int_Loc+30] = Int_Loc;
99. for (Int_Index = Int_Loc; Int_Index <= Int_Loc+1; ++Int_Index)
100. Arr_2_Par_Ref [Int_Loc] [Int_Index] = Int_Loc;
101. Arr_2_Par_Ref [Int_Loc] [Int_Loc-1] += 1;
102. Arr_2_Par_Ref [Int_Loc+20] [Int_Loc] = Arr_1_Par_Ref [Int_Loc];
103. Int_Glob = 5;
104. } /* Proc_8 */
107. Enumeration Func_1 (Capital_Letter Ch_1_Par_Val,
108. Capital_Letter Ch_2_Par_Val)
109. /*************************************************/
110. /* executed three times */
111. /* first call: Ch_1_Par_Val == 'H', Ch_2_Par_Val == 'R' */
112. /* second call: Ch_1_Par_Val == 'A', Ch_2_Par_Val == 'C' */
113. /* third call: Ch_1_Par_Val == 'B', Ch_2_Par_Val == 'C' */
115. {
116. Capital_Letter Ch_1_Loc;
117. Capital_Letter Ch_2_Loc;
119. Ch_1_Loc = Ch_1_Par_Val;
120. Ch_2_Loc = Ch_1_Loc;
121. if (Ch_2_Loc != Ch_2_Par_Val)
122. /* then, executed */
123. return (Ident_1);
124. else/* not executed */
125. {
126. Ch_1_Glob = Ch_1_Loc;
127. return (Ident_2);
128. }
129. } /* Func_1 */
132. Boolean Func_2 (Str_30 Str_1_Par_Ref, Str_30 Str_2_Par_Ref)
133. /*************************************************/
134. /* executed once */
135. /* Str_1_Par_Ref == "DHRYSTONE PROGRAM, 1'ST STRING" */
136. /* Str_2_Par_Ref == "DHRYSTONE PROGRAM, 2'ND STRING" */
138. {
139. REG One_Thirty Int_Loc;
140. Capital_Letter Ch_Loc;
142. Int_Loc = 2;
143. while (Int_Loc <= 2) /* loop body executed once */
144. if (Func_1 (Str_1_Par_Ref[Int_Loc],
145. Str_2_Par_Ref[Int_Loc+1]) == Ident_1)
146. /* then, executed */
147. {
148. Ch_Loc = 'A';
149. Int_Loc += 1;
150. } /* if, while */
151. if (Ch_Loc >= 'W' && Ch_Loc < 'Z')
152. /* then, not executed */
153. Int_Loc = 7;
154. if (Ch_Loc == 'R')
155. /* then, not executed */
156. return (true);
157. else /* executed */
158. {
159. if (strcmp (Str_1_Par_Ref, Str_2_Par_Ref) > 0)
160. /* then, not executed */
161. {
162. Int_Loc += 7;
163. Int_Glob = Int_Loc;
164. return (true);
165. }
166. else /* executed */
167. return (false);
168. } /* if Ch_Loc */
169. } /* Func_2 */
172. Boolean Func_3 (Enumeration Enum_Par_Val)
173. /***************************/
174. /* executed once */
175. /* Enum_Par_Val == Ident_3 */
177. {
178. Enumeration Enum_Loc;
180. Enum_Loc = Enum_Par_Val;
181. if (Enum_Loc == Ident_3)
182. /* then, executed */
183. return (true);
184. else /* not executed */
185. return (false);
186. } /* Func_3 */

复制代码

dhry.h

1. /*
2. **************************************************************************
3. * DHRYSTONE 2.1 BENCHMARK PC VERSION
4. **************************************************************************
5. *
6. * "DHRYSTONE" Benchmark Program
7. * -----------------------------
8. *
9. *Version: C, Version 2.1
10. *
11. *File: dhry.h (part 1 of 3)
12. *
13. *Date: May 25, 1988
14. *
15. *Author: Reinhold P. Weicker
16. * Siemens AG, AUT E 51
17. * Postfach 3220
18. * 8520 Erlangen
19. * Germany (West)
20. * Phone:[+49]-9131-7-20330
21. * (8-17 Central European Time)
22. * Usenet: ..!mcsun!unido!estevax!weicker
23. *
24. * Original Version (in Ada) published in
25. * "Communications of the ACM" vol. 27., no. 10 (Oct. 1984),
26. * pp. 1013 - 1030, together with the statistics
27. * on which the distribution of statements etc. is based.
28. *
29. * In this C version, the following C library functions are used:
30. * - strcpy, strcmp (inside the measurement loop)
31. * - printf, scanf (outside the measurement loop)
32. * In addition, Berkeley UNIX system calls "times ()" or "time ()"
33. * are used for execution time measurement. For measurements
34. * on other systems, these calls have to be changed.
35. *
36. *Collection of Results:
37. * Reinhold Weicker (address see above) and
38. *
39. * Rick Richardson
40. * PC Research. Inc.
41. * 94 Apple Orchard Drive
42. * Tinton Falls, NJ 07724
43. * Phone:[phone] (9-17 EST)
44. * Usenet: ...!uunet!pcrat!rick
45. *
46. * Please send results to Rick Richardson and/or Reinhold Weicker.
47. * Complete information should be given on hardware and software used.
48. * Hardware information includes: Machine type, CPU, type and size
49. * of caches; for microprocessors: clock frequency, memory speed
50. * (number of wait states).
51. * Software information includes: Compiler (and runtime library)
52. * manufacturer and version, compilation switches, OS version.
53. * The Operating System version may give an indication about the
54. * compiler; Dhrystone itself performs no OS calls in the measurement
55. * loop.
56. *
57. * The complete output generated by the program should be mailed
58. * such that at least some checks for correctness can be made.
59. *
60. **************************************************************************
61. *
62. *This version has changes made by Roy Longbottom to conform to a common
63. *format for a series of standard benchmarks for PCs:
64. *
65. *Running time greater than 5 seconds due to inaccuracy of the PC clock.
66. *
67. *Automatic adjustment of run time, no manually inserted parameters.
68. *
69. *Initial display of calibration times to confirm linearity.
70. *
71. *Display of results within one screen (or at a slow speed as the test
72. *progresses) so that it can be seen to have run successfully.
73. *
74. *Facilities to type in details of system used etc.
75. *
76. *All results and details appended to a results file.
77. *
78. *
79. *Roy Longbottom
80. *[e-mail]
81. *
82. **************************************************************************
83. *
84. *For details of history, changes, other defines, benchmark construction
85. *statistics see official versions from ftp.nosc.mil/pub/aburto where
86. *the latest table of results (dhry.tbl) are available. See also
87. *[e-mail]
88. *
89. **************************************************************************
90. *
91. * Defines: The following "Defines" are possible:
92. * -DREG=register (default: Not defined)
93. * As an approximation to what an average C programmer
94. * might do, the "register" storage class is applied
95. * (if enabled by -DREG=register)
96. * - for local variables, if they are used (dynamically)
97. * five or more times
98. * - for parameters if they are used (dynamically)
99. * six or more times
100. * Note that an optimal "register" strategy is
101. * compiler-dependent, and that "register" declarations
102. * do not necessarily lead to faster execution.
103. * -DNOSTRUCTASSIGN (default: Not defined)
104. * Define if the C compiler does not support
105. * assignment of structures.
106. * -DNOENUMS (default: Not defined)
107. * Define if the C compiler does not support
108. * enumeration types.
109. ***************************************************************************
110. *
111. *Compilation model and measurement (IMPORTANT):
112. *
113. *This C version of Dhrystone consists of three files:
114. *- dhry.h (this file, containing global definitions and comments)
115. *- dhry_1.c (containing the code corresponding to Ada package Pack_1)
116. *- dhry_2.c (containing the code corresponding to Ada package Pack_2)
117. *
118. *The following "ground rules" apply for measurements:
119. *- Separate compilation
120. *- No procedure merging
121. *- Otherwise, compiler optimizations are allowed but should be indicated
122. *- Default results are those without register declarations
123. *See the companion paper "Rationale for Dhrystone Version 2" for a more
124. *detailed discussion of these ground rules.
125. *
126. *For 16-Bit processors (e.g. 80186, 80286), times for all compilation
127. *models ("small", "medium", "large" etc.) should be given if possible,
128. *together with a definition of these models for the compiler system used.
129. *
130. **************************************************************************
131. * Examples of Pentium Results
132. *
133. * Dhrystone BenchmarkVersion 2.1 (Language: C)
134. *
135. * Month run 4/1996
136. * PC model Escom
137. * CPU Pentium
138. * Clock MHz 100
139. * Cache 256K
140. * Options Neptune chipset
141. * OS/DOS Windows 95
142. * Compiler Watcom C/ C++ 10.5 Win386
143. * OptLevel -otexan -zp8 -fp5 -5r
144. * Run by Roy Longbottom
145. * From UK
146. * Mail [e-mail]
147. *
148. * Final values (* implementation-dependent):
149. *
150. * Int_Glob: O.K.5
151. * Bool_Glob: O.K.1
152. * Ch_1_Glob: O.K.A
153. * Ch_2_Glob: O.K.B
154. * Arr_1_Glob[8]: O.K.7
155. * Arr_2_Glob8/7: O.K. 1600010
156. * Ptr_Glob->
157. * Ptr_Comp: *98008
158. * Discr: O.K.0
159. * Enum_Comp: O.K.2
160. * Int_Comp: O.K.17
161. * Str_Comp: O.K.DHRYSTONE PROGRAM, SOME STRING
162. * Next_Ptr_Glob->
163. * Ptr_Comp: *98008 same as above
164. * Discr: O.K.0
165. * Enum_Comp: O.K.1
166. * Int_Comp: O.K.18
167. * Str_Comp: O.K.DHRYSTONE PROGRAM, SOME STRING
168. * Int_1_Loc: O.K.5
169. * Int_2_Loc: O.K.13
170. * Int_3_Loc: O.K.7
171. * Enum_Loc: O.K.1
172. * Str_1_Loc: O.K.DHRYSTONE PROGRAM, 1'ST STRING
173. * Str_2_Loc: O.K.DHRYSTONE PROGRAM, 2'ND STRING
174. *
175. * Register option Selected.
176. *
177. * Microseconds 1 loop: 4.53
178. * Dhrystones / second: 220690
179. * VAX MIPS rating: 125.61
180. *
181. *
182. * Dhrystone BenchmarkVersion 2.1 (Language: C)
183. *
184. * Month run 4/1996
185. * PC model Escom
186. * CPU Pentium
187. * Clock MHz 100
188. * Cache 256K
189. * Options Neptune chipset
190. * OS/DOS Windows 95
191. * Compiler Watcom C/ C++ 10.5 Win386
192. * OptLevel No optimisation
193. * Run by Roy Longbottom
194. * From UK
195. * Mail [e-mail]
196. *
197. * Final values (* implementation-dependent):
198. *
199. * Int_Glob: O.K.5
200. * Bool_Glob: O.K.1
201. * Ch_1_Glob: O.K.A
202. * Ch_2_Glob: O.K.B
203. * Arr_1_Glob[8]: O.K.7
204. * Arr_2_Glob8/7: O.K. 320010
205. * Ptr_Glob->
206. * Ptr_Comp: *98004
207. * Discr: O.K.0
208. * Enum_Comp: O.K.2
209. * Int_Comp: O.K.17
210. * Str_Comp: O.K.DHRYSTONE PROGRAM, SOME STRING
211. * Next_Ptr_Glob->
212. * Ptr_Comp: *98004 same as above
213. * Discr: O.K.0
214. * Enum_Comp: O.K.1
215. * Int_Comp: O.K.18
216. * Str_Comp: O.K.DHRYSTONE PROGRAM, SOME STRING
217. * Int_1_Loc: O.K.5
218. * Int_2_Loc: O.K.13
219. * Int_3_Loc: O.K.7
220. * Enum_Loc: O.K.1
221. * Str_1_Loc: O.K.DHRYSTONE PROGRAM, 1'ST STRING
222. * Str_2_Loc: O.K.DHRYSTONE PROGRAM, 2'ND STRING
223. *
224. * Register option Not selected.
225. *
226. * Microseconds 1 loop: 20.06
227. * Dhrystones / second: 49844
228. * VAX MIPS rating: 28.37
229. *
230. **************************************************************************
231. */
233. /* Compiler and system dependent definitions: */
235. #ifndef TIME
236. #define TIMES
237. #endif
238. /* Use times(2) time function unless */
239. /* explicitly defined otherwise */
241. #ifdef TIMES
242. /* #include
243. #include*/
244. /* for "times" */
245. #endif
247. #define Mic_secs_Per_Second 1000000.0
248. /* Berkeley UNIX C returns process times in seconds/HZ */
250. #ifdefNOSTRUCTASSIGN
251. #define structassign(d, s) memcpy(&(d), &(s), sizeof(d))
252. #else
253. #define structassign(d, s) d = s
254. #endif
256. #ifdefNOENUM
257. #define Ident_1 0
258. #define Ident_2 1
259. #define Ident_3 2
260. #define Ident_4 3
261. #define Ident_5 4
262. typedef int Enumeration;
263. #else
264. typedef enum {Ident_1, Ident_2, Ident_3, Ident_4, Ident_5}
265. Enumeration;
266. #endif
267. /* for boolean and enumeration types in Ada, Pascal */
269. /* General definitions: */
271. #include
272. #include
274. /* for strcpy, strcmp */
276. #define Null 0
277. /* Value of a Null pointer */
278. #define true1
279. #define false 0
281. typedef int One_Thirty;
282. typedef int One_Fifty;
283. typedef char Capital_Letter;
284. typedef int Boolean;
285. typedef char Str_30 [31];
286. typedef int Arr_1_Dim [50];
287. typedef int Arr_2_Dim [50] [50];
289. typedef struct record
290. {
291. struct record *Ptr_Comp;
292. Enumeration Discr;
293. union {
294. struct {
295. Enumeration Enum_Comp;
296. int Int_Comp;
297. char Str_Comp [31];
298. } var_1;
299. struct {
300. Enumeration E_Comp_2;
301. char Str_2_Comp [31];
302. } var_2;
303. struct {
304. char Ch_1_Comp;
305. char Ch_2_Comp;
306. } var_3;
307. } variant;
308. } Rec_Type, *Rec_Pointer;

复制代码