21ic电子技术开发论坛 › 单片机与嵌入式系统 › 灵动MM32 MCU › Dhrystone移植说明
返回列表 发新帖我要提问

[MM32软件] Dhrystone移植说明

[复制链接]
 楼主| MindMotion 发表于 2024-8-9 16:24 | 显示全部楼层 |阅读模式
移植说明, ST, ps, MIPS, ip, 移植
本帖最后由 MindMotion 于 2024-8-9 16:25 编辑

1. Dhrystone简介

Dhrystone是由Reinhold P. Weicker在1984年提出来的一个基准测试程序，其主要目的是测试处理器的整数运算和逻辑运算的性能。Dhrystone首先用Ada语言发布，后来Rick Richardson为Unix开发了用C语言编写的Version 1.1，这个版本也成功的推动了Dhrystone的广泛应用。

Dhrystone标准的测试方法很简单，就是单位时间内跑了多少次Dhrystone程序，其指标单位为DMIPS/MHz。MIPS是Million Instructions Per Second的缩写，每秒处理的百万级的机器语言指令数。DMIPS中的D是Dhrystone的缩写，它表示了在Dhrystone标准的测试方法下的MIPS。

DMIPS表示的是一个相对值，由于历史原因将VAX-11/780机器上每秒运行1757次 Dhrystone程序定义为1 DMIPS，因此在其他平台测试到的每秒Dhrystone次数应除以1757，才是DMIPS数值。

DMIPS/MHz：表示CPU在每1MHz的运行速度下可以执行多少个DMIPS，由于DMIPS与CPU频率具有正相关性，所以这一分数更容易比较不同的CPU在不同的时钟频率下运行Dhrystone的结果。


作为一项基准程序Dhrystone具有以下缺陷：

1) 代码与具有代表性的实际程序代码并不相同。
2) 易受编译器影响。
3) 代码量过小，在现代CPU中，它能够被放进指令缓存中，所以它并不能严格的测量取指性能。


2. 源码获取

Dhrystone程序的最新版本是2.1，其实际上于1988年便已停更。Dhrystone并没有官网，所以想下载其源程序可能会有很多来源，有各种语言版本的实现，以及各种平台下的移植程序。

Roy Longbottom，是一个来自英国政府计算机采购部门Central Computer and Telecommunications Agency (CCTA)的职员，他制作了一个PC性能测试结果网站，搜集了很多性能测试程序以及结果，其中便有Dhrystone，我们可以从他的网站下载Dhrystone源码(C语言版)。

下载地址：http://www.roylongbottom.org.uk/classic_benchmarks.tar.gz

源代码在\classic_benchmarks\source_code\dhrystone2\ 目录下，文件如下：

001.png


文件介绍：

dhry.h —— 关于兼容性的原型定义
dhry_1.c —— 主程序入口
dhry_2.c —— 算法子程序


Dhrystone其源码本是用作在PC上运行的，移植到ARM Cortex-M平台下裸系统运行，一般需要修改dhry.h和dhry_1.c文件、删除I/O的相关代码、实现计时函数和打印函数。

3. 移植

Dhrystone作为一项基准测试程序，C编译器的编译效率对测试结果也有很大影响，实测在IAR代码优化下的跑分较高。本文以MM32F5270 MCU为例，开发板型号为Mini-F5277-OB|MB-100，使用IAR 9.30.1 IDE，介绍Dhrystone程序的移植和相关配置。

3.1   创建工程

工程可以参考灵动微电子官网的MM32F5270 LibSamples（https://www.mindmotion.com.cn/products/mm32mcu/mm32f/mm32f_performance/mm32f5270/），也可以直接选择一个简单的工程稍作修改。

3.2   加入Dhrystone

在工程中新创建一个文件夹，命名为“Dhrystone”。

002.png

Dhrystone源代码在\classic_benchmarks\source_code\dhrystone2\目录，将dhry.h、dhry_1.c、dhry_2.c复制到该文件夹。

003.png

在项目栏添加DHRYSTONE组，并加入dhry_1.c、dhry_2.c文件。

在Option->C/C++ Complier菜单加入dhry.h文件包含路径。

工程结构如下：

004.png

3.3   文件修改

参考MM32F5270 LibSamples，其工程具有统一的代码结构，以及做好了硬件的初始化，为了便于移植，将dhry_1.c自带的main函数名称改为dhrystone，在硬件初始化之后调用。

005.png

Dhrystone本是用作在PC上运行的，需要删除计时部分、文件I/O部分，以适合在嵌入式平台运行。

计时部分：删除dhry_1.c文件里的#include语句、删除dhry.h文件里跟TIME宏相关的代码；

文件I/O部分：删除dhry_1.c文件里的#include语句、删除涉及Dhry.txt的代码。

修改后的代码如下：

dhry1.c文件：

复制
  1. /*
    

  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.  */
    


  19. 


  20. 

  21. #include <stdlib.h>
    

  22. #include <stdio.h>
    

  23. #include "dhry.h"
    


  24. 

  25. /* Global Variables: */
    


  26. 

  27. Rec_Pointer     Ptr_Glob, Next_Ptr_Glob;
    

  28. int             Int_Glob;
    

  29. Boolean         Bool_Glob;
    

  30. char            Ch_1_Glob, Ch_2_Glob;
    

  31. int             Arr_1_Glob [50];
    

  32. int             Arr_2_Glob [50] [50];
    


  33. 


  34. 

  35. Enumeration Func_1 (Capital_Letter Ch_1_Par_Val, Capital_Letter Ch_2_Par_Val);
    

  36.     /* 
    

  37.     forward declaration necessary since Enumeration may not simply be int
    

  38.     */
    


  39. 

  40. #ifndef REG
    

  41. Boolean Reg = false;
    

  42. #define REG
    

  43.     /* REG becomes defined as empty */
    

  44.     /* i.e. no register variables   */
    

  45. #else
    

  46. Boolean Reg = true;
    

  47. #endif
    


  48. 


  49. 

  50. void Proc_1 (REG Rec_Pointer Ptr_Val_Par);
    

  51. void Proc_2 (One_Fifty *Int_Par_Ref);
    

  52. void Proc_3 (Rec_Pointer *Ptr_Ref_Par);
    

  53. void Proc_4 (); 
    

  54. void Proc_5 ();
    

  55. void Proc_6 (Enumeration Enum_Val_Par, Enumeration *Enum_Ref_Par);
    

  56. void Proc_7 (One_Fifty Int_1_Par_Val, One_Fifty Int_2_Par_Val, One_Fifty *Int_Par_Ref);
    

  57. void Proc_8 (Arr_1_Dim Arr_1_Par_Ref, Arr_2_Dim Arr_2_Par_Ref, int Int_1_Par_Val, int Int_2_Par_Val);                            
    

  58. Boolean Func_2 (Str_30 Str_1_Par_Ref, Str_30 Str_2_Par_Ref);
    


  59. 


  60. 

  61. /* variables for time measurement: */
    

  62. #define Too_Small_Time 2 /* Measurements should last at least 2 seconds */
    


  63. 

  64. double User_Time;
    

  65. double Microseconds, Dhrystones_Per_Second, Vax_Mips;
    


  66. 

  67. /* end of variables for time measurement */
    


  68. 

  69. void dhrystone(void)
    

  70.     /*****/
    

  71.     /* main program, corresponds to procedures        */
    

  72.     /* Main and Proc_0 in the Ada version             */
    

  73. {
    


  74. 

  75.         One_Fifty   Int_1_Loc;
    

  76.   REG   One_Fifty   Int_2_Loc;
    

  77.         One_Fifty   Int_3_Loc;
    

  78.   REG   char        Ch_Index;
    

  79.         Enumeration Enum_Loc;
    

  80.         Str_30      Str_1_Loc;
    

  81.         Str_30      Str_2_Loc;
    

  82.   REG   int         Run_Index;
    

  83.   REG   int         Number_Of_Runs; 
    


  84. 

  85.   /* Initializations */
    

  86.   Next_Ptr_Glob = (Rec_Pointer) malloc (sizeof (Rec_Type));
    

  87.   Ptr_Glob = (Rec_Pointer) malloc (sizeof (Rec_Type));
    


  88. 

  89.   Ptr_Glob->Ptr_Comp                    = Next_Ptr_Glob;
    

  90.   Ptr_Glob->Discr                       = Ident_1;
    

  91.   Ptr_Glob->variant.var_1.Enum_Comp     = Ident_3;
    

  92.   Ptr_Glob->variant.var_1.Int_Comp      = 40;
    

  93.   strcpy (Ptr_Glob->variant.var_1.Str_Comp, "DHRYSTONE PROGRAM, SOME STRING");       
    

  94.   strcpy (Str_1_Loc, "DHRYSTONE PROGRAM, 1'ST STRING");
    


  95. 

  96.   Arr_2_Glob [8][7] = 10;
    

  97.   /* Was missing in published program. Without this statement,   */
    

  98.   /* Arr_2_Glob [8][7] would have an undefined value.            */
    

  99.   /* Warning: With 16-Bit processors and Number_Of_Runs > 32000, */
    

  100.   /* overflow may occur for this array element.                  */
    


  101. 

  102.   printf ("Dhrystone Benchmark, Version 2.1 (Language: C or C++)\n");
    


  103. 

  104.   getDetails();
    


  105. 

  106.   if (Reg)
    

  107.   {
    

  108.     printf ("Program compiled with 'register' attribute\n");
    

  109.   }
    

  110.   else
    

  111.   {
    

  112.     printf ("Program compiled without 'register' attribute\n");
    

  113.   }
    


  114. 

  115.   Number_Of_Runs = NUMBER_Of_RUNS;
    

  116.   printf ("Execution starts, %d runs through Dhrystone......\n", Number_Of_Runs);
    

  117.   /***************/
    

  118.   /* Start timer */
    

  119.   /***************/
    

  120.   start_time();
    


  121. 

  122.   for (Run_Index = 1; Run_Index <= Number_Of_Runs; ++Run_Index)
    

  123.   {
    

  124.     Proc_5();
    

  125.     Proc_4();
    

  126.     /* Ch_1_Glob == 'A', Ch_2_Glob == 'B', Bool_Glob == true */
    

  127.     Int_1_Loc = 2;
    

  128.     Int_2_Loc = 3;
    

  129.     strcpy (Str_2_Loc, "DHRYSTONE PROGRAM, 2'ND STRING");
    

  130.     Enum_Loc = Ident_2;
    

  131.     Bool_Glob = ! Func_2 (Str_1_Loc, Str_2_Loc);
    

  132.     /* Bool_Glob == 1 */
    

  133.     while (Int_1_Loc < Int_2_Loc)  /* loop body executed once */
    

  134.     {
    

  135.       Int_3_Loc = 5 * Int_1_Loc - Int_2_Loc;
    

  136.         /* Int_3_Loc == 7 */
    

  137.       Proc_7 (Int_1_Loc, Int_2_Loc, &Int_3_Loc);
    

  138.         /* Int_3_Loc == 7 */
    

  139.       Int_1_Loc += 1;
    

  140.     }   /* while */
    

  141.       /* Int_1_Loc == 3, Int_2_Loc == 3, Int_3_Loc == 7 */
    

  142.     Proc_8 (Arr_1_Glob, Arr_2_Glob, Int_1_Loc, Int_3_Loc);
    

  143.      /* Int_Glob == 5 */
    

  144.     Proc_1 (Ptr_Glob);
    

  145.     for (Ch_Index = 'A'; Ch_Index <= Ch_2_Glob; ++Ch_Index)
    

  146.      /* loop body executed twice */
    

  147.     {
    

  148.       if (Enum_Loc == Func_1 (Ch_Index, 'C'))
    

  149.       /* then, not executed */
    

  150.       {
    

  151.          Proc_6 (Ident_1, &Enum_Loc);
    

  152.          strcpy (Str_2_Loc, "DHRYSTONE PROGRAM, 3'RD STRING");
    

  153.          Int_2_Loc = Run_Index;
    

  154.          Int_Glob = Run_Index;
    

  155.       }
    

  156.     }
    

  157.     /* Int_1_Loc == 3, Int_2_Loc == 3, Int_3_Loc == 7 */
    

  158.     Int_2_Loc = Int_2_Loc * Int_1_Loc;
    

  159.     Int_1_Loc = Int_2_Loc / Int_3_Loc;
    

  160.     Int_2_Loc = 7 * (Int_2_Loc - Int_3_Loc) - Int_1_Loc;
    

  161.     /* Int_1_Loc == 1, Int_2_Loc == 13, Int_3_Loc == 7 */
    

  162.     Proc_2 (&Int_1_Loc);
    

  163.     /* Int_1_Loc == 5 */
    


  164. 

  165.   } /* loop "for Run_Index" */
    


  166. 

  167.   /**************/
    

  168.   /* Stop timer */
    

  169.   /**************/
    

  170.   User_Time = end_time();
    


  171. 

  172.   printf ("Execution ends!\n");      
    

  173.   printf ("%12.0f runs %6.2f seconds \n",(double)Number_Of_Runs, (double)User_Time);
    

  174.   printf ("\n");
    


  175. 

  176.   printf ("Final values:\n");
    

  177.   printf ("Int_Glob:      ");
    

  178.   if (Int_Glob == 5)  printf ("O.K.  ");
    

  179.   else                printf ("WRONG ");
    

  180.   printf ("%d\n", Int_Glob);
    


  181. 

  182.   printf ("Bool_Glob:     ");
    

  183.   if (Bool_Glob == 1) printf ("O.K.  ");
    

  184.   else                printf ("WRONG ");
    

  185.   printf ("%d\n", Bool_Glob);
    


  186. 

  187.   printf ("Ch_1_Glob:     ");
    

  188.   if (Ch_1_Glob == 'A')  printf ("O.K.  ");               
    

  189.   else                   printf ("WRONG ");
    

  190.   printf ("%c\n", Ch_1_Glob);
    


  191. 

  192.   printf ("Ch_2_Glob:     ");
    

  193.   if (Ch_2_Glob == 'B')  printf ("O.K.  ");
    

  194.   else                   printf ("WRONG ");
    

  195.   printf ("%c\n",  Ch_2_Glob);
    


  196. 

  197.   printf ("Arr_1_Glob[8]: ");
    

  198.   if (Arr_1_Glob[8] == 7)  printf ("O.K.  ");
    

  199.   else                     printf ("WRONG ");
    

  200.   printf ("%d\n", Arr_1_Glob[8]);
    


  201. 

  202.   printf ("Arr_2_Glob8/7: ");
    

  203.   if (Arr_2_Glob[8][7] == Number_Of_Runs + 10)
    

  204.                          printf ("O.K.  ");
    

  205.   else                   printf ("WRONG ");
    

  206.   printf ("%10d\n", Arr_2_Glob[8][7]);
    


  207. 

  208.   printf ("Ptr_Glob->            ");
    

  209.   printf ("  Ptr_Comp:       *    %d\n", (int) Ptr_Glob->Ptr_Comp);
    


  210. 

  211.   printf ("  Discr:       ");
    

  212.   if (Ptr_Glob->Discr == 0)  printf ("O.K.  ");
    

  213.   else                       printf ("WRONG ");
    

  214.   printf ("%d\n", Ptr_Glob->Discr);
    


  215. 

  216.   printf ("Enum_Comp:     ");
    

  217.   if (Ptr_Glob->variant.var_1.Enum_Comp == 2)
    

  218.                        printf ("O.K.  ");
    

  219.   else                printf ("WRONG ");
    

  220.   printf ("%d\n", Ptr_Glob->variant.var_1.Enum_Comp);
    


  221. 

  222.   printf ("  Int_Comp:    ");
    

  223.   if (Ptr_Glob->variant.var_1.Int_Comp == 17)  printf ("O.K.  ");
    

  224.   else                                         printf ("WRONG ");
    

  225.   printf ("%d\n", Ptr_Glob->variant.var_1.Int_Comp);
    


  226. 

  227.   printf ("Str_Comp:      ");
    

  228.   if (strcmp(Ptr_Glob->variant.var_1.Str_Comp,
    

  229.                        "DHRYSTONE PROGRAM, SOME STRING") == 0)
    

  230.                        printf ("O.K.  ");
    

  231.   else                printf ("WRONG ");   
    

  232.   printf ("%s\n", Ptr_Glob->variant.var_1.Str_Comp);
    


  233. 

  234.   printf ("Next_Ptr_Glob->       "); 
    

  235.   printf ("  Ptr_Comp:       *    %d", (int) Next_Ptr_Glob->Ptr_Comp);
    

  236.   printf (" same as above\n");
    


  237. 

  238.   printf ("  Discr:       ");
    

  239.   if (Next_Ptr_Glob->Discr == 0)
    

  240.                        printf ("O.K.  ");
    

  241.   else                printf ("WRONG ");
    

  242.   printf ("%d\n", Next_Ptr_Glob->Discr);
    


  243. 

  244.   printf ("Enum_Comp:     ");
    

  245.   if (Next_Ptr_Glob->variant.var_1.Enum_Comp == 1)
    

  246.                        printf ("O.K.  ");
    

  247.   else                printf ("WRONG ");
    

  248.   printf ("%d\n", Next_Ptr_Glob->variant.var_1.Enum_Comp);
    


  249. 

  250.   printf ("  Int_Comp:    ");
    

  251.   if (Next_Ptr_Glob->variant.var_1.Int_Comp == 18)
    

  252.                        printf ("O.K.  ");
    

  253.   else                printf ("WRONG ");
    

  254.   printf ("%d\n", Next_Ptr_Glob->variant.var_1.Int_Comp);
    


  255. 

  256.   printf ("Str_Comp:      ");
    

  257.   if (strcmp(Next_Ptr_Glob->variant.var_1.Str_Comp,
    

  258.                        "DHRYSTONE PROGRAM, SOME STRING") == 0)
    

  259.                        printf ("O.K.  ");
    

  260.   else                printf ("WRONG ");   
    

  261.   printf ("%s\n", Next_Ptr_Glob->variant.var_1.Str_Comp);
    


  262. 

  263.   printf ("Int_1_Loc:     ");
    

  264.   if (Int_1_Loc == 5)
    

  265.                        printf ("O.K.  ");
    

  266.   else                printf ("WRONG ");
    

  267.   printf ("%d\n", Int_1_Loc);
    


  268. 

  269.   printf ("Int_2_Loc:     ");
    

  270.   if (Int_2_Loc == 13)
    

  271.                        printf ("O.K.  ");
    

  272.   else                printf ("WRONG ");
    

  273.   printf ("%d\n", Int_2_Loc);
    


  274. 

  275.   printf ("Int_3_Loc:     ");
    

  276.   if (Int_3_Loc == 7)
    

  277.                        printf ("O.K.  ");
    

  278.   else                printf ("WRONG ");
    

  279.   printf ("%d\n", Int_3_Loc);
    


  280. 

  281.   printf ("Enum_Loc:      ");
    

  282.   if (Enum_Loc == 1)
    

  283.                        printf ("O.K.  ");
    

  284.   else                printf ("WRONG ");
    

  285.   printf ("%d\n", Enum_Loc);
    


  286. 


  287. 

  288.   printf ("Str_1_Loc:                             ");
    

  289.   if (strcmp(Str_1_Loc, "DHRYSTONE PROGRAM, 1'ST STRING") == 0)
    

  290.                        printf ("O.K.  ");
    


  291. 

  292.   else                printf ("WRONG ");   
    

  293.   printf ("%s\n", Str_1_Loc);
    


  294. 

  295.   printf ("Str_2_Loc:                             ");
    

  296.   if (strcmp(Str_2_Loc, "DHRYSTONE PROGRAM, 2'ND STRING") == 0)
    

  297.                        printf ("O.K.  ");
    

  298.   else                printf ("WRONG ");   
    

  299.   printf ("%s\n", Str_2_Loc);  
    

  300.   printf ("\n");
    


  301. 

  302.   if (User_Time < Too_Small_Time)
    

  303.   {
    

  304.     printf ("Measured time too small to obtain meaningful results\n");
    

  305.     printf ("Please increase number of runs\n");
    

  306.     printf ("\n");
    

  307.   }
    

  308.   else
    

  309.   {
    

  310.     Microseconds = User_Time * Mic_secs_Per_Second / (double) Number_Of_Runs;
    

  311.     Dhrystones_Per_Second = (double) Number_Of_Runs / User_Time;
    

  312.     Vax_Mips = Dhrystones_Per_Second / 1757.0;
    


  313. 

  314.     printf ("Microseconds for one run through Dhrystone: ");
    

  315.     printf ("%12.2lf \n", Microseconds);
    

  316.     printf ("Dhrystones per Second:                      ");
    

  317.     printf ("%10.0lf \n", Dhrystones_Per_Second);
    

  318.     printf ("VAX  MIPS rating =                          ");
    

  319.     printf ("%12.2lf \n",Vax_Mips);
    

  320.     printf ("\n");
    

  321.     printf ("\n");
    

  322.     printf ("\n");
    

  323.   }
    

  324. }
    


  325. 


  326. 

  327. void Proc_1 (REG Rec_Pointer Ptr_Val_Par)
    

  328. /******************/
    

  329.     /* executed once */
    

  330. {
    

  331.    REG Rec_Pointer Next_Record = Ptr_Val_Par->Ptr_Comp;  
    

  332.    /* == Ptr_Glob_Next */
    

  333.    /* Local variable, initialized with Ptr_Val_Par->Ptr_Comp,    */
    

  334.    /* corresponds to "rename" in Ada, "with" in Pascal           */
    


  335. 

  336.    structassign (*Ptr_Val_Par->Ptr_Comp, *Ptr_Glob);
    

  337.    Ptr_Val_Par->variant.var_1.Int_Comp = 5;
    

  338.    Next_Record->variant.var_1.Int_Comp = Ptr_Val_Par->variant.var_1.Int_Comp;
    

  339.    Next_Record->Ptr_Comp = Ptr_Val_Par->Ptr_Comp;
    

  340.    Proc_3 (&Next_Record->Ptr_Comp);
    

  341.      /* Ptr_Val_Par->Ptr_Comp->Ptr_Comp = Ptr_Glob->Ptr_Comp */
    

  342.    if (Next_Record->Discr == Ident_1)
    

  343.      /* then, executed */
    

  344.    {
    

  345.      Next_Record->variant.var_1.Int_Comp = 6;
    

  346.      Proc_6 (Ptr_Val_Par->variant.var_1.Enum_Comp, &Next_Record->variant.var_1.Enum_Comp);
    

  347.      Next_Record->Ptr_Comp = Ptr_Glob->Ptr_Comp;
    

  348.      Proc_7 (Next_Record->variant.var_1.Int_Comp, 10, &Next_Record->variant.var_1.Int_Comp);
    

  349.    }
    

  350.    else /* not executed */
    

  351.      structassign (*Ptr_Val_Par, *Ptr_Val_Par->Ptr_Comp);
    

  352. } /* Proc_1 */
    


  353. 


  354. 

  355. void Proc_2 (One_Fifty *Int_Par_Ref)
    

  356. /******************/
    

  357.     /* executed once */
    

  358.     /* *Int_Par_Ref == 1, becomes 4 */
    

  359. {
    

  360.   One_Fifty  Int_Loc;
    

  361.   Enumeration   Enum_Loc;
    


  362. 

  363.   Int_Loc = *Int_Par_Ref + 10;
    

  364.   do /* executed once */
    

  365.     if (Ch_1_Glob == 'A')
    

  366.       /* then, executed */
    

  367.     {
    

  368.       Int_Loc -= 1;
    

  369.       *Int_Par_Ref = Int_Loc - Int_Glob;
    

  370.       Enum_Loc = Ident_1;
    

  371.     } /* if */
    

  372.   while (Enum_Loc != Ident_1); /* true */
    

  373. } /* Proc_2 */
    


  374. 


  375. 

  376. void Proc_3 (Rec_Pointer *Ptr_Ref_Par)
    

  377. /******************/
    

  378.     /* executed once */
    

  379.     /* Ptr_Ref_Par becomes Ptr_Glob */
    

  380. {
    

  381.   if (Ptr_Glob != Null)
    

  382.     /* then, executed */
    

  383.     *Ptr_Ref_Par = Ptr_Glob->Ptr_Comp;
    

  384.     Proc_7 (10, Int_Glob, &Ptr_Glob->variant.var_1.Int_Comp);
    

  385. } /* Proc_3 */
    


  386. 


  387. 

  388. void Proc_4 (void) /* without parameters */
    

  389. /*******/
    

  390.     /* executed once */
    

  391. {
    

  392.   Boolean Bool_Loc;
    


  393. 

  394.   Bool_Loc = Ch_1_Glob == 'A';
    

  395.   Bool_Glob = Bool_Loc | Bool_Glob;
    

  396.   Ch_2_Glob = 'B';
    

  397. } /* Proc_4 */
    


  398. 


  399. 

  400. void Proc_5 (void) /* without parameters */
    

  401. /*******/
    

  402.     /* executed once */
    

  403. {
    

  404.   Ch_1_Glob = 'A';
    

  405.   Bool_Glob = false;
    

  406. } /* Proc_5 */
    


  407. 


  408. 

  409. /* Procedure for the assignment of structures,          */
    

  410. /* if the C compiler doesn't support this feature       */
    

  411. #ifdef  NOSTRUCTASSIGN
    

  412. memcpy (d, s, l)
    

  413. register char   *d;
    

  414. register char   *s;
    

  415. register int    l;
    

  416. {
    

  417.     while (l--) 
    

  418.         *d++ = *s++;
    

  419. }
    

  420. #endif

dhry.h文件：

复制
  1. /* Compiler and system dependent definitions: */
    


  2. 

  3. #define Mic_secs_Per_Second     1000000.0
    

  4.                 /* Berkeley UNIX C returns process times in seconds/HZ */
    


  5. 

  6. #ifdef  NOSTRUCTASSIGN
    

  7. #define structassign(d, s)      memcpy(&(d), &(s), sizeof(d))
    

  8. #else
    

  9. #define structassign(d, s)      d = s
    

  10. #endif
    


  11. 

  12. #ifdef  NOENUM
    

  13. #define Ident_1 0
    

  14. #define Ident_2 1
    

  15. #define Ident_3 2
    

  16. #define Ident_4 3
    

  17. #define Ident_5 4
    

  18.   typedef int   Enumeration;
    

  19. #else
    

  20.   typedef       enum    {Ident_1, Ident_2, Ident_3, Ident_4, Ident_5}
    

  21.                 Enumeration;
    

  22. #endif
    

  23.         /* for boolean and enumeration types in Ada, Pascal */
    


  24. 

  25. /* General definitions: */
    


  26. 

  27. #include <stdio.h>
    

  28. #include <string.h>
    

  29.                 /* for strcpy, strcmp */
    


  30. 

  31. #define Null 0 
    

  32.                 /* Value of a Null pointer */
    


  33. 

  34. #define true  1
    

  35. #define false 0
    


  36. 

  37. typedef int     One_Thirty;
    

  38. typedef int     One_Fifty;
    

  39. typedef char    Capital_Letter;
    

  40. typedef int     Boolean;
    

  41. typedef char    Str_30 [31];
    

  42. typedef int     Arr_1_Dim [50];
    

  43. typedef int     Arr_2_Dim [50] [50];
    


  44. 

  45. typedef struct record 
    

  46.     {
    

  47.     struct record *Ptr_Comp;
    

  48.     Enumeration    Discr;
    

  49.     union {
    

  50.           struct {
    

  51.                   Enumeration Enum_Comp;
    

  52.                   int         Int_Comp;
    

  53.                   char        Str_Comp [31];
    

  54.                   } var_1;
    

  55.           struct {
    

  56.                   Enumeration E_Comp_2;
    

  57.                   char        Str_2_Comp [31];
    

  58.                   } var_2;
    

  59.           struct {
    

  60.                   char        Ch_1_Comp;
    

  61.                   char        Ch_2_Comp;
    

  62.                   } var_3;
    

  63.           } variant;
    

  64.       } Rec_Type, *Rec_Pointer;

打印函数：

工程的platform.c文件已经做好了UART初始化以及重定向相关代码，无需额外添加，源码中需要打印的地方直接用printf即可。

计时函数：

Dhrystone测试需要计算跑dhrystone程序的时间，以推算出单位时间内运行dhrystone程序的次数。这里选择使用TIM1来记录时间，定义start_time函数和end_time函数获取运行程序的时间，这两个函数已经在dhrystone主函数中调用。

006.png

为了便于计算，TIM1配置为向上计数模式。需要注意系统时钟频率，配置范围，防止溢出。

007.png

3.4   编译器优化

在Option->C/C++ Compiler界面Optimizaition选项设置优化等级如下：

008.png

4. 测试

Dhrystone测试需要配置的参数：

NUMBER_Of_RUNS，这个值是自己定义的，但要保证Dhrystone程序运行时间大于2s。

定时器的PSC和ARR，一般配置时钟频率为1KHZ，即1ms计数1次，预装载值可配置为最大值。

009.png

连接串口，运行程序，观察上位机调试助手打印情况：

110.png

其中VAX MIPS rating就是所谓的DMPIS，上面截图数据是在8MHZ跑的，一般DMIPS/MHZ信息还需要除以频率（单位MHZ），即12.10/8 = 1.5125。

回复 赏

举报

相关帖子
tpgf 发表于 2024-8-10 09:33 | 显示全部楼层
Dhrystone移植是一个涉及修改标准Dhrystone基准测试程序，使其能够在特定微控制器单元（MCU）上运行的过程
回复 赏

举报

木木guainv 发表于 2024-8-10 23:23 | 显示全部楼层
移植过程通常包括获取源码、修改源码以适应目标平台、配置相关参数，以及确保测试程序可以在新平台上正确执行
回复 赏

举报

磨砂 发表于 2024-8-11 18:44 | 显示全部楼层
Dhrystone程序的最新版本是2.1，实际上在1988年便已停更
回复 赏

举报

晓伍 发表于 2024-8-15 09:12 | 显示全部楼层
针对嵌入式系统，需要删除Dhrystone源码中的I/O相关代码，并重新实现计时函数和打印函数
回复 赏

举报

八层楼 发表于 2024-8-15 19:31 | 显示全部楼层
由于Dhrystone测试结果受编译器效率影响较大，可能需要针对使用的编译器进行特定的优化设置，以获得准确的性能评估
回复 赏

举报

观海 发表于 2024-8-16 20:57 | 显示全部楼层
针对嵌入式系统，需要删除Dhrystone源码中的I/O相关代码，并重新实现计时函数和打印函数
回复 赏

举报

1115745 发表于 2024-9-10 17:04 | 显示全部楼层
请问在armv8架构下的a53处理器中一直dhrystone程序时，在malloc时出现异常，指令是B.CC处，感觉是内存对齐相关的问题，这个应该怎么解决
回复 赏

举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

MindMotion Image
认证：上海灵动微电子股份有限公司
简介：上海灵动微电子股份有限公司成立于 2011 年，是中国本土通用 32 位 MCU 产品及解决方案供应商。 灵动股份的 MCU 产品以 MM32 为标识，基于 Arm Cortex-M 系列内核，自主研发软硬件和生态系统。目前已量产近 300 多款型号，累计交付超 4 亿颗，在本土通用 32 位 MCU 公司中位居前列。

93

主题

111

帖子

10

粉丝
快速回复 在线客服 返回列表 返回顶部