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