home *** CD-ROM | disk | FTP | other *** search
/ Meeting Pearls 3 / Meeting_Pearls_III.iso / Pearls / bench / Dhrystone / source / dhrystone21.c < prev    next >
C/C++ Source or Header  |  1995-06-04  |  7KB  |  376 lines
  1.  
  2. /* Accuracy of timings and human fatigue controlled by next two lines */
  3. /*#define LOOPS    50000        /* Use this for slow or 16 bit machines */
  4. #define LOOPS    100000        /* Use this for faster machines */
  5.  
  6. /*#define LOOPS 5000000           /* Use THIS with a 68040 ! */
  7.  
  8.  
  9. /* Compiler dependent options */
  10. #undef    NOENUM            /* Define if compiler has no enum's */
  11. #undef    NOSTRUCTASSIGN        /* Define if compiler can't assign structures */
  12.  
  13. /* define only one of the next two defines */
  14.  
  15. #define TIME            /* Use time(2) time function */
  16.  
  17.  
  18. /* define the granularity of your times(2) function (when used) */
  19. #define HZ    1000        /* times(2) returns 1/60 second (most) */
  20. /* #define HZ    100        /* times(2) returns 1/100 second (WECo) */
  21.  
  22. char    Ver[] = "$VER: Dhrystone 2.1 68000+ (29.5.95)";
  23.  
  24. #ifdef    NOSTRUCTASSIGN
  25. #define    structassign(d, s)    memcpy(&(d), &(s), sizeof(d))
  26. #else
  27. #define    structassign(d, s)    d = s
  28. #endif
  29.  
  30. #ifdef    NOENUM
  31. #define    Ident1    1
  32. #define    Ident2    2
  33. #define    Ident3    3
  34. #define    Ident4    4
  35. #define    Ident5    5
  36. typedef int    Enumeration;
  37. #else
  38. typedef enum    {Ident1, Ident2, Ident3, Ident4, Ident5} Enumeration;
  39. #endif
  40.  
  41. typedef int    OneToThirty;
  42. typedef int    OneToFifty;
  43. typedef char    CapitalLetter;
  44. typedef char    String30[31];
  45. typedef int    Array1Dim[51];
  46. typedef int    Array2Dim[51][51];
  47.  
  48. struct    Record
  49. {
  50.     struct Record        *PtrComp;
  51.     Enumeration        Discr;
  52.     Enumeration        EnumComp;
  53.     OneToFifty        intComp;
  54.     String30        StringComp;
  55. };
  56.  
  57. typedef struct Record     RecordType;
  58. typedef RecordType *    RecordPtr;
  59. typedef int        boolean;
  60.  
  61. #define    NULL        0
  62. #define    TRUE        1
  63. #define    FALSE        0
  64.  
  65. #ifndef REG
  66. #define    REG
  67. #endif
  68.  
  69. extern Enumeration    Func1();
  70. extern boolean        Func2();
  71.  
  72.  
  73. #include <stdio.h>
  74. #include <stdlib.h>
  75. #include <string.h>
  76. /* #include <sys/types.h> */
  77. #include <time.h>
  78.  
  79.  
  80. /*
  81.  * Package 1
  82.  */
  83. int        intGlob;
  84. boolean        BoolGlob;
  85. char        Char1Glob;
  86. char        Char2Glob;
  87. Array1Dim    Array1Glob;
  88. Array2Dim    Array2Glob;
  89. RecordPtr    PtrGlb;
  90. RecordPtr    PtrGlbNext;
  91.  
  92.  
  93. Proc0(void)
  94. {
  95.      unsigned long time1,time2,time3;
  96.     OneToFifty        intLoc1;
  97.     REG OneToFifty        intLoc2;
  98.     OneToFifty        intLoc3;
  99.     REG char        CharLoc;
  100.     REG char        CharIndex;
  101.     Enumeration         EnumLoc;
  102.     String30        String1Loc;
  103.     String30        String2Loc;
  104.     REG int            i;
  105.  
  106.     PtrGlbNext = (RecordPtr) malloc(sizeof(RecordType));
  107.     PtrGlb = (RecordPtr) malloc(sizeof(RecordType));
  108.     PtrGlb->PtrComp = PtrGlbNext;
  109.     PtrGlb->Discr = Ident1;
  110.     PtrGlb->EnumComp = Ident3;
  111.     PtrGlb->intComp = 40;
  112.     strcpy(PtrGlb->StringComp, "DHRYSTONE PROGRAM, SOME STRING");
  113.     strcpy(String1Loc, "DHRYSTONE PROGRAM, 1'ST STRING");    /*GOOF*/
  114.  
  115.     Array2Glob[8][7] = 10;    /* Was missing in published program */
  116.  
  117. /*****************
  118. -- Start Timer --
  119. *****************/
  120.  
  121. //Forbid();
  122. time1=GetSysTime();
  123.  
  124.     for (i = 0; i < LOOPS; ++i)
  125.     {
  126.  
  127.         Proc5();
  128.         Proc4();
  129.         
  130.         intLoc1 = 2;
  131.         intLoc2 = 3;
  132.         strcpy(String2Loc, "DHRYSTONE PROGRAM, 2'ND STRING");
  133.         EnumLoc = Ident2;
  134.         BoolGlob = ! Func2(String1Loc, String2Loc);
  135.         while (intLoc1 < intLoc2)
  136.         {
  137.             intLoc3 = 5 * intLoc1 - intLoc2;
  138.             Proc7(intLoc1, intLoc2, &intLoc3);
  139.             intLoc1 += 1;
  140.         }
  141.         Proc8(Array1Glob, Array2Glob, intLoc1, intLoc3);
  142.         Proc1(PtrGlb);
  143.         for (CharIndex = 'A'; CharIndex <= Char2Glob; ++CharIndex)
  144.         {
  145.             if (EnumLoc == Func1(CharIndex, 'C'))
  146.             {
  147.                 Proc6(Ident1, &EnumLoc);
  148.                 strcpy(String1Loc, "DHRYSTONE PROGRAM, 3'ST STRING");
  149.                 intLoc2 = i;
  150.                 intGlob = i;
  151.             }
  152.         }
  153.         intLoc2 = intLoc2 * intLoc1;
  154.         intLoc1 = intLoc2 / intLoc3;
  155.         intLoc2 = 7 * (intLoc2 - intLoc3) - intLoc1;
  156.         Proc2(&intLoc1);
  157.     }
  158.  
  159. /*****************
  160. -- Stop Timer --
  161. *****************/
  162.  
  163. time2 = GetSysTime();
  164. time3 = time2-time1;
  165. //Permit();
  166.  
  167. printf("Dhrystone (2.1) time for %ld passes = %d.%03d seconds.\n",
  168.     (long) LOOPS,time3/1000,time3%1000);
  169. printf("This machine benchmarks at %ld dhrystones/second.\n",
  170.     (LOOPS*1000) / time3 );
  171. }
  172.  
  173. GetSysTime(void)
  174. {
  175.  unsigned int t1[2]={0,0};
  176.  timer(t1);
  177.  
  178.  // printf("t1=%ld t2=%ld\n",t1[0],t1[1]);
  179.  
  180.  return ((unsigned long) (1000*t1[0])+(t1[1]/1000) );
  181.  
  182. }
  183.  
  184.  
  185. main()
  186. {
  187.     Proc0();
  188.     exit(0);
  189. }
  190.  
  191. Proc1(PtrParIn)
  192. REG RecordPtr    PtrParIn;
  193. {
  194. #define    NextRecord    (*(PtrParIn->PtrComp))
  195.  
  196.     structassign(NextRecord, *PtrGlb);
  197.     PtrParIn->intComp = 5;
  198.     NextRecord.intComp = PtrParIn->intComp;
  199.     NextRecord.PtrComp = PtrParIn->PtrComp;
  200.     Proc3(NextRecord.PtrComp);
  201.     if (NextRecord.Discr == Ident1)
  202.     {
  203.         NextRecord.intComp = 6;
  204.         Proc6(PtrParIn->EnumComp, &NextRecord.EnumComp);
  205.         NextRecord.PtrComp = PtrGlb->PtrComp;
  206.         Proc7(NextRecord.intComp, 10, &NextRecord.intComp);
  207.     }
  208.     else
  209.         structassign(*PtrParIn, NextRecord);
  210.  
  211. #undef    NextRecord
  212. }
  213.  
  214. Proc2(intParIO)
  215. OneToFifty    *intParIO;
  216. {
  217.     REG OneToFifty        intLoc;
  218.     REG Enumeration        EnumLoc;
  219.  
  220.     intLoc = *intParIO + 10;
  221.     for(;;)
  222.     {
  223.         if (Char1Glob == 'A')
  224.         {
  225.             --intLoc;
  226.             *intParIO = intLoc - intGlob;
  227.             EnumLoc = Ident1;
  228.         }
  229.         if (EnumLoc == Ident1)
  230.             break;
  231.     }
  232. }
  233.  
  234. Proc3(PtrParOut)
  235. RecordPtr    *PtrParOut;
  236. {
  237.     if (PtrGlb != NULL)
  238.         *PtrParOut = PtrGlb->PtrComp;
  239.     else
  240.         intGlob = 100;
  241.     Proc7(10, intGlob, &PtrGlb->intComp);
  242. }
  243.  
  244. Proc4()
  245. {
  246.     REG boolean    BoolLoc;
  247.  
  248.     BoolLoc = Char1Glob == 'A';
  249.     BoolLoc |= BoolGlob;
  250.     Char2Glob = 'B';
  251. }
  252.  
  253. Proc5()
  254. {
  255.     Char1Glob = 'A';
  256.     BoolGlob = FALSE;
  257. }
  258.  
  259. extern boolean Func3();
  260.  
  261. Proc6(EnumParIn, EnumParOut)
  262. REG Enumeration    EnumParIn;
  263. REG Enumeration    *EnumParOut;
  264. {
  265.     *EnumParOut = EnumParIn;
  266.     if (! Func3(EnumParIn) )
  267.         *EnumParOut = Ident4;
  268.     switch (EnumParIn)
  269.     {
  270.     case Ident1:    *EnumParOut = Ident1; break;
  271.     case Ident2:    if (intGlob > 100) *EnumParOut = Ident1;
  272.             else *EnumParOut = Ident4;
  273.             break;
  274.     case Ident3:    *EnumParOut = Ident2; break;
  275.     case Ident4:    break;
  276.     case Ident5:    *EnumParOut = Ident3;
  277.     }
  278. }
  279.  
  280. Proc7(intParI1, intParI2, intParOut)
  281. OneToFifty    intParI1;
  282. OneToFifty    intParI2;
  283. OneToFifty    *intParOut;
  284. {
  285.     REG OneToFifty    intLoc;
  286.  
  287.     intLoc = intParI1 + 2;
  288.     *intParOut = intParI2 + intLoc;
  289. }
  290.  
  291. Proc8(Array1Par, Array2Par, intParI1, intParI2)
  292. Array1Dim    Array1Par;
  293. Array2Dim    Array2Par;
  294. OneToFifty    intParI1;
  295. OneToFifty    intParI2;
  296. {
  297.     REG OneToFifty    intLoc;
  298.     REG OneToFifty    intIndex;
  299.  
  300.     intLoc = intParI1 + 5;
  301.     Array1Par[intLoc] = intParI2;
  302.     Array1Par[intLoc+1] = Array1Par[intLoc];
  303.     Array1Par[intLoc+30] = intLoc;
  304.     for (intIndex = intLoc; intIndex <= (intLoc+1); ++intIndex)
  305.         Array2Par[intLoc][intIndex] = intLoc;
  306.     ++Array2Par[intLoc][intLoc-1];
  307.     Array2Par[intLoc+20][intLoc] = Array1Par[intLoc];
  308.     intGlob = 5;
  309. }
  310.  
  311. Enumeration Func1(CharPar1, CharPar2)
  312. CapitalLetter    CharPar1;
  313. CapitalLetter    CharPar2;
  314. {
  315.     REG CapitalLetter    CharLoc1;
  316.     REG CapitalLetter    CharLoc2;
  317.  
  318.     CharLoc1 = CharPar1;
  319.     CharLoc2 = CharLoc1;
  320.     if (CharLoc2 != CharPar2)
  321.         return (Ident1);
  322.     else
  323.         return (Ident2);
  324. }
  325.  
  326. boolean Func2(StrParI1, StrParI2)
  327. String30    StrParI1;
  328. String30    StrParI2;
  329. {
  330.     REG OneToThirty        intLoc;
  331.     REG CapitalLetter    CharLoc;
  332.  
  333.     intLoc = 1;
  334.     while (intLoc <= 1)
  335.         if (Func1(StrParI1[intLoc], StrParI2[intLoc+1]) == Ident1)
  336.         {
  337.             CharLoc = 'A';
  338.             ++intLoc;
  339.         }
  340.     if (CharLoc >= 'W' && CharLoc <= 'Z')
  341.         intLoc = 7;
  342.     if (CharLoc == 'X')
  343.         return(TRUE);
  344.     else
  345.     {
  346.         if (strcmp(StrParI1, StrParI2) > 0)
  347.         {
  348.             intLoc += 7;
  349.             return (TRUE);
  350.         }
  351.         else
  352.             return (FALSE);
  353.     }
  354. }
  355.  
  356. boolean Func3(EnumParIn)
  357. REG Enumeration    EnumParIn;
  358. {
  359.     REG Enumeration    EnumLoc;
  360.  
  361.     EnumLoc = EnumParIn;
  362.     if (EnumLoc == Ident3) return (TRUE);
  363.     return (FALSE);
  364. }
  365.  
  366. #ifdef    NOSTRUCTASSIGN
  367. memcpy(d, s, l)
  368. register char    *d;
  369. register char    *s;
  370. register int    l;
  371. {
  372.     while (l--) *d++ = *s++;
  373. }
  374. #endif
  375.  
  376.