home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / xc212os2.zip / SAMPLES / SIMPLE / whet.mod < prev   
Text File  |  1996-01-06  |  9KB  |  255 lines
  1. <*# IF __GEN_X86__ THEN *>
  2.   <*+NOPTRALIAS*>
  3.   <*-SPACE*>
  4.   <*-GENHISTORY*>
  5. <*# END *>
  6. <*+M2EXTENSIONS*>
  7. <*+ALIGNMENT*>
  8. <*+PROCINLINE*>
  9. <*-CHECKINDEX*>
  10. <*-CHECKRANGE*>
  11. <*-CHECKNIL*>
  12. <*-IOVERFLOW*>
  13. <*-COVERFLOW*>
  14. <*-GENDEBUG*>
  15. <*-LINENO*>
  16.  
  17. MODULE Whet;
  18.  
  19. IMPORT InOut, RealInOut, LongInOut, SysClock;
  20. FROM LongMath IMPORT sin, cos, arctan, sqrt, exp, ln;
  21.  
  22. (**********************************************************************
  23. C     Benchmark #2 -- Double  Precision Whetstone (A001)
  24. C
  25. C     o    This is a LONGREAL*8 version of
  26. C    the Whetstone benchmark program.
  27. C     o FOR-loop semantics are ANSI-66 compatible.
  28. C     o    Final measurements are to be made with all
  29. C    WRITE statements and FORMAT sttements removed.
  30. C
  31. C**********************************************************************)
  32.  
  33. PROCEDURE time (VAR tm: INTEGER);
  34. VAR t: SysClock.DateTime;
  35. BEGIN
  36.     SysClock.GetClock (t);
  37.     tm := (t.hour * 60 + t.minute) * 60 + t.second;
  38. END time;
  39.  
  40. TYPE ARRAY4 = ARRAY [1..4] OF LONGREAL;
  41.  
  42. VAR E1                  : ARRAY4;
  43.     T, T1, T2           : LONGREAL;
  44.     J, K, L             : INTEGER;
  45.     ptime, time0, time1 : INTEGER;
  46.  
  47. PROCEDURE PA (VAR E : ARRAY4);
  48. VAR J1 : INTEGER;
  49. BEGIN
  50.         J1 := 0;
  51.         REPEAT
  52.                 E [1] := ( E [1] + E [2] + E [3] - E [4]) * T;
  53.                 E [2] := ( E [1] + E [2] - E [3] + E [4]) * T;
  54.                 E [3] := ( E [1] - E [2] + E [3] + E [4]) * T;
  55.                 E [4] := (-E [1] + E [2] + E [3] + E [4]) / T2;
  56.                 J1 := J1 + 1;
  57.         UNTIL J1 >= 6;
  58. END PA;
  59.  
  60. PROCEDURE P0;
  61. BEGIN
  62.         E1 [J] := E1 [K]; E1 [K] := E1 [L]; E1 [L] := E1 [J];
  63. END P0;
  64.  
  65. PROCEDURE P3 (X,Y : LONGREAL; VAR Z : LONGREAL);
  66. VAR X1, Y1 : LONGREAL;
  67. BEGIN
  68.         X1 := X;
  69.         Y1 := Y;
  70.         X1 := T * (X1 + Y1);
  71.         Y1 := T * (X1 + Y1);
  72.         Z := (X1 + Y1) / T2;
  73. END P3;
  74.  
  75. PROCEDURE POUT (N, J, K : INTEGER; X1, X2, X3, X4 : LONGREAL);
  76. VAR time1 : INTEGER;
  77. BEGIN
  78.         time (time1);
  79.         InOut.WriteCard (time1 - time0, 2);
  80.         InOut.WriteCard (time1 - ptime, 2);
  81.         InOut.WriteCard (N, 6);
  82.         InOut.WriteCard (J, 6);
  83.         InOut.WriteCard (K, 6);
  84.         LongInOut.WriteReal (X1, 10);
  85.         LongInOut.WriteReal (X2, 10);
  86.         LongInOut.WriteReal (X3, 10);
  87.         LongInOut.WriteReal (X4, 10);
  88.         InOut.WriteLn;
  89.         ptime := time1;
  90. END POUT;
  91.  
  92. PROCEDURE Do;
  93. VAR NLoop, I, II, JJ : INTEGER;
  94.     N1, N2, N3, N4, N5, N6, N7, N8, N9, N10, N11 : INTEGER;
  95.     X1, X2, X3, X4, X, Y, Z : LONGREAL;
  96. BEGIN
  97.         time (time0);
  98.         ptime := time0;
  99. (* The actual benchmark starts here. *)
  100.         T  := 0.499975;
  101.         T1 := 0.50025;
  102.         T2 := 2.0;
  103. (* With loopcount NLoop=10, one million Whetstone instructions
  104.    will be executed in each major loop.
  105.    A major loop is executed 'II' times to increase wall-clock timing accuracy *)
  106.         NLoop := 30;
  107.         II    := 80;
  108.         FOR JJ:=1 TO II DO
  109. (* Establish the relative loop counts of each module. *)
  110.                 N1 := 0;
  111.                 N2 := 12 * NLoop;
  112.                 N3 := 14 * NLoop;
  113.                 N4 := 345 * NLoop;
  114.                 N5 := 0;
  115.                 N6 := 210 * NLoop;
  116.                 N7 := 32 * NLoop;
  117.                 N8 := 899 * NLoop;
  118.                 N9 := 616 * NLoop;
  119.                 N10 := 0;
  120.                 N11 := 93 * NLoop;
  121. (* Module 1: Simple identifiers *)
  122.                 X1 := 1.0;
  123.                 X2 := -1.0;
  124.                 X3 := -1.0;
  125.                 X4 := -1.0;
  126.                 FOR I:=1 TO N1 DO
  127.                         X1 := (X1 + X2 + X3 - X4)*T;
  128.                         X2 := (X1 + X2 - X3 + X4)*T;
  129.                         X3 := (X1 - X2 + X3 + X4)*T;
  130.                         X4 := (-X1 + X2 + X3 + X4)*T;
  131.                 END;
  132.                 IF (JJ = II) THEN
  133.                         POUT (N1, N1, N1, X1, X2, X3, X4);
  134.                 END;
  135. (* Module 2: Array elements *)
  136.                 E1 [1] :=  1.0;
  137.                 E1 [2] := -1.0;
  138.                 E1 [3] := -1.0;
  139.                 E1 [4] := -1.0;
  140.                 FOR I:=1 TO N2 DO
  141.                         E1 [1] := (E1 [1] + E1 [2] + E1 [3] - E1 [4])*T;
  142.                         E1 [2] := (E1 [1] + E1 [2] - E1 [3] + E1 [4])*T;
  143.                         E1 [3] := (E1 [1] - E1 [2] + E1 [3] + E1 [4])*T;
  144.                         E1 [4] := (-E1 [1] + E1 [2] + E1 [3] + E1 [4])*T;
  145.                 END;
  146.                 IF (JJ = II) THEN
  147.                         POUT (N2, N3, N2, E1 [1], E1 [2], E1 [3], E1 [4]);
  148.                 END;
  149. (* Module 3: Array as parameter *)
  150.                 FOR I:=1 TO N3 DO
  151.                         PA (E1);
  152.                 END;
  153.                 IF (JJ = II) THEN
  154.                         POUT(N3, N2, N2, E1 [1], E1 [2], E1 [3], E1 [4]);
  155.                 END;
  156. (* Module 4: Conditional jumps *)
  157.                 J := 1;
  158.                 FOR I:=1 TO N4 DO
  159.                         IF (J <> 1) THEN J := 3 ELSE J := 2 END;
  160.                         IF (J <= 2) THEN J := 1 ELSE J := 0 END;
  161.                         IF (J >= 1) THEN J := 0 ELSE J := 1 END;
  162.                 END;
  163.                 IF (JJ = II) THEN
  164.                         POUT (N4, J, J, X1, X2, X3, X4)
  165.                 END;
  166. (* Module 5: Omitted; Module 6: Integer arithmetic *)
  167.                 J := 1;
  168.                 K := 2;
  169.                 L := 3;
  170.                 FOR I:=1 TO N6 DO
  171.                         J := J * (K-J) * (L-K);
  172.                         K := L * K - (L-J) * K;
  173.                         L := (L - K) * (K + J);
  174.                         E1 [L-1] := VAL (LONGREAL, (J + K + L));
  175.                         E1 [K-1] := VAL (LONGREAL, (J * K * L));
  176.                 END;
  177.                 IF (JJ = II) THEN
  178.                         POUT (N6, J, K, E1 [1], E1 [2], E1 [3], E1 [4]);
  179.                 END;
  180. (* Module 7: Trigonometric functions *)
  181.                 X := 0.5;
  182.                 Y := 0.5;
  183.                 FOR I:=1 TO N7 DO
  184.                         X:=T*arctan(T2*sin(X)*cos(X)/(cos(X+Y)+cos(X-Y)-1.0));
  185.                         Y:=T*arctan(T2*sin(Y)*cos(Y)/(cos(X+Y)+cos(X-Y)-1.0));
  186.                 END;
  187.                 IF (JJ = II) THEN
  188.                         POUT (N7, J, K, X, X, Y, Y);
  189.                 END;
  190. (* Module 8: Procedure calls *)
  191.                 X := 1.0;
  192.                 Y := 1.0;
  193.                 Z := 1.0;
  194.                 FOR I:=1 TO N8 DO
  195.                         P3 (X,Y,Z);
  196.                 END;
  197.                 IF (JJ = II) THEN
  198.                         POUT (N8, J, K, X, Y, Z, Z);
  199.                 END;
  200. (* Module 9: Array references *)
  201.                 J := 1;
  202.                 K := 2;
  203.                 L := 3;
  204.                 E1 [1] := 1.0;
  205.                 E1 [2] := 2.0;
  206.                 E1 [3] := 3.0;
  207.                 FOR I:=1 TO N9 DO
  208.                         P0;
  209.                 END;
  210.                 IF (JJ = II) THEN
  211.                         POUT (N9, J, K, E1 [1], E1 [2], E1 [3], E1 [4])
  212.                 END;
  213. (* Module 10: Integer arithmetic *)
  214.                 J := 2;
  215.                 K := 3;
  216.                 FOR I:=1 TO N10 DO
  217.                         J := J + K;
  218.                         K := J + K;
  219.                         J := K - J;
  220.                         K := K - J - J;
  221.                 END;
  222.                 IF (JJ = II) THEN
  223.                         POUT (N10, J, K, X1, X2, X3, X4)
  224.                 END;
  225. (* Module 11: Standard functions *)
  226.                 X := 0.75;
  227.                 FOR I:=1 TO N11 DO
  228.                         X := sqrt (exp (ln (X)/T1))
  229.                 END;
  230.                 IF (JJ = II) THEN
  231.                         POUT (N11, J, K, X, X, X, X)
  232.                 END;
  233. (* THIS IS THE END OF THE MAJOR LOOP. *)
  234.         END;
  235. (* Stop benchmark timing at this point. *)
  236.         time (time1);
  237. (*----------------------------------------------------------------
  238.       Performance in Whetstone KIP's per second is given by
  239.        (100*NLoop*II)/TIME
  240.       where TIME is in seconds.
  241. --------------------------------------------------------------------*)
  242.         InOut.WriteLn;
  243.         InOut.WriteString ('Double Whetstone KIPS ');
  244.         InOut.WriteCard (TRUNC ((100.0 * FLOAT (NLoop) * FLOAT (II)) /
  245.                                 FLOAT (time1 - time0)), 0);
  246.         InOut.WriteLn;
  247.         InOut.WriteString ('Whetstone MIPS ');
  248.         RealInOut.WriteReal (FLOAT (NLoop) * FLOAT (II) /
  249.                              FLOAT ((time1 - time0) * 10), 10);
  250. END Do;
  251.  
  252. BEGIN
  253.     Do;
  254. END Whet.
  255.