Programmer's ROM - The Computer Language Library/programmersrom.iso/ada/test/benchpfc.src

Text File | 1988-05-03 | 79.4 KB | 3,150 lines

--::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
--whetpasa.pas
--::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
PROGRAM Whetpasa(Input, Output, Whetpasa);
  VAR Whetpasa: TEXT;

  { Filename: WHETPASA.PAS }

  { PASCAL version of Whetstone Benchmark Program.               }
  {        (With stubbed MATH lib NO CHECK)                      }
  { Reference: "Computer Journal," February 1976, pages 43-49,   }
  {            for description of benchmark and ALGOL60 version. }
  { Note: Procedure POUT is omitted.                             }

  PROCEDURE Whetstone(I, NumOfCycles: INTEGER;
                      VAR StartTime, StopTime: INTEGER);

    TYPE VECTOR = ARRAY[1..4] OF REAL;

    VAR
      X1,X2,X3,X4,X,Y,Z,T,T1,T2: REAL;
      E1: VECTOR;
      J,K,L,N1,N2,N3,N4,N5,N6,N7,N8,N9,N10,N11: INTEGER;
      CycleNumber: INTEGER;

  {Uncomment following function to run benchmark with math library stubbed off}

      FUNCTION MYSTUB(X: REAL): REAL;
        BEGIN
          MYSTUB:= 1.0;
        END;

      PROCEDURE PA(VAR E: VECTOR);
        LABEL 1;
        VAR J: INTEGER;
        BEGIN
          J:= 0;
          1:
          E[1]:= (E[1]+E[2]+E[3]-E[4])*T;
          E[2]:= (E[1]+E[2]-E[3]+E[4])*T;
          E[3]:= (E[1]-E[2]+E[3]+E[4])*T;
          E[4]:= (-E[1]+E[2]+E[3]+E[4])/T2;
          J:= J+1;
          IF J < 6 THEN
             GOTO 1;
        END; { PA }

      PROCEDURE P0;
        BEGIN
          E1[J]:= E1[K];
          E1[K]:= E1[L];
          E1[L]:= E1[J];
        END; { P0 }

      PROCEDURE P3(X, Y: REAL; VAR Z: REAL);
        BEGIN
          X:= T*(X+Y);
          Y:= T*(X+Y);
          Z:= (X+Y)/T2;
        END; { P3 }

    BEGIN { Whetstone }
      { Initialize constants }
      T:= 0.499975;
      T1:= 0.50025;
      T2:= 2.0;

      { Compute execution frequencies for benchmark modules }
      N1:= 0;    { Module 1 not executed }
      N2:= 12*I;
      N3:= 14*I;
      N4:= 345*I;
      N5:= 0;    { Module 5 not executed }
      N6:= 210*I;
      N7:= 32*I;
      N8:= 899*I;
      N9:= 616*I;
      N10:= 0;   { Module 10 not executed }
      N11:= 93*I;

      StartTime:= CLOCK; { Get current CPU time in milliseconds }

      FOR CycleNumber:= 1 TO NumOfCycles DO
        BEGIN { Main loop }
          { Module 1: simple identifiers }
          X1:= 1.0;
          X2:= -1.0;
          X3:= -1.0;
          X4:= -1.0;
          FOR I:= 1 TO N1 DO
            BEGIN
              X1:= (X1+X2+X3-X4)*T;
              X2:= (X1+X2-X3+X4)*T;
              X3:= (X1-X2+X3+X4)*T;
              X4:= (-X1+X2+X3+X4)*T;
            END; { Module 1 }

          { Module 2: array elements }
          E1[1]:= 1.0;
          E1[2]:= -1.0;
          E1[3]:= -1.0;
          E1[4]:= -1.0;
          FOR I:= 1 TO N2 DO
            BEGIN
              E1[1]:= (E1[1]+E1[2]+E1[3]-E1[4])*T;
              E1[2]:= (E1[1]+E1[2]-E1[3]+E1[4])*T;
              E1[3]:= (E1[1]-E1[2]+E1[3]+E1[4])*T;
              E1[4]:= (-E1[1]+E1[2]+E1[3]+E1[4])*T;
            END; { Module 2 }

          { Module 3: array as parameter }
          FOR I:= 1 TO N3 DO
            PA(E1);
          { End Module 3 }

          { Module 4: conditional jumps }
          J:= 1;
          FOR I:= 1 TO N4 DO
            BEGIN
              IF J = 1 THEN
                 J:= 2
              ELSE
                 J:= 3;
              IF J > 2 THEN
                 J:= 0
              ELSE
                 J:= 1;
              IF J < 1 THEN
                 J:= 1
              ELSE
                 J:= 0;
            END; { Module 4 }

          { Module 5: omitted }

          { Module 6: integer arithmetic }
          J:= 1;
          K:= 2;
          L:= 3;
          FOR I:= 1 TO N6 DO
            BEGIN
              J:= J*(K-J)*(L-K);
              K:= L*K-(L-J)*K;
              L:= (L-K)*(K+J);
              E1[L-1]:= J+K+L;
              E1[K-1]:= J*K*L;
            END; { Module 6 }

          { Module 7: trigonometric functions }
          X:= 0.5;
          Y:= 0.5;
          FOR I:= 1 TO N7 DO
           BEGIN
    { Comment out next 2 lines to run benchmark with math library stubbed off }
    {      X:= T*ARCTAN(T2*SIN(X)*COS(X)/(COS(X+Y)+COS(X-Y)-1.0));            }
    {      Y:= T*ARCTAN(T2*SIN(Y)*COS(Y)/(COS(X+Y)+COS(X-Y)-1.0));            }

    { Uncomment next 2 lines to run benchmark with math library stubbed off }
          X:= T*MYSTUB(T2*MYSTUB(X)*MYSTUB(X)/(MYSTUB(X+Y)+MYSTUB(X-Y)-1.0));
          Y:= T*MYSTUB(T2*MYSTUB(Y)*MYSTUB(Y)/(MYSTUB(X+Y)+MYSTUB(X-Y)-1.0));
           END; { Module 7 }

          { Module 8: procedure calls }
          X:= 1.0;
          Y:= 1.0;
          Z:= 1.0;
          FOR I:= 1 TO N8 DO
            P3(X,Y,Z);
          { End Module 8 }

          { Module 9: array references }
          J:= 1;
          K:= 2;
          L:= 3;
          E1[1]:= 1.0;
          E1[2]:= 2.0;
          E1[3]:= 3.0;
          FOR I:= 1 TO N9 DO
            P0;
          { End Module 9 }

          { Module 10: integer arithmetic }
          J:= 2;
          K:= 3;
          FOR I:= 1 TO N10 DO
            BEGIN
              J:= J+K;
              K:= J+K;
              J:= K-J;
              K:= K-J-J;
            END; { Module 10 }

          { Module 11: standard functions }
          X:= 0.75;
          FOR I:= 1 TO N11 DO
    { Comment out next line to run benchmark with math library stubbed off }
    {       X:= SQRT(EXP(LN(X)/T1));                                       }

    { Uncomment next line to run benchmark with library stubbed off }
            X:= MYSTUB(MYSTUB(MYSTUB(X)/T1));
          { End Module 11 }
        END; { Main loop }

      StopTime:= CLOCK; { Get current CPU time in milliseconds }

    END; { Whetstone }



  PROCEDURE ComputeKWIPS;
    VAR
      NumOfRuns, NumOfCycles, StartTime, StopTime,
      IntRating, ElapsedTime, RunNumber, I: INTEGER;
      MeanTime, MeanRating, Rating: REAL;

    BEGIN
      REWRITE(Whetpasa);
      WRITELN(Whetpasa,' PASCAL Whetstone benchmark(with stubbed MATH lib no check)');
      WRITELN(Whetpasa);
      WRITELN; WRITELN(' PASCAL Whetstone benchmark(with stubbed MATH lib no check)');
      WRITELN;

      MeanTime:= 0.0;
      MeanRating:= 0.0;
      NumOfCycles:= 10;
      NumOfRuns:= 5;
      I:= 10;

      FOR RunNumber:= 1 TO NumOfRuns DO
        BEGIN { Main loop }
          Whetstone(I, NumOfCycles, StartTime, StopTime);

          WRITELN; WRITELN(' Whetstone CPU start time: ',StartTime:8,
                           ' milliseconds');
          WRITELN(Whetpasa); WRITELN(Whetpasa,' Whetstone CPU start time: ',
                                     StartTime:8,' milliseconds');

          WRITELN; WRITELN(' Whetstone CPU stop time: ',StopTime:8,
                           ' milliseconds');
          WRITELN(Whetpasa); WRITELN(Whetpasa,' Whetstone CPU stop time: ',
                                     StopTime:8,' milliseconds');

          ElapsedTime:= StopTime - StartTime;
          WRITELN; WRITELN(' Elapsed CPU time for ',NumOfCycles:3,' cycles: ',
                           ElapsedTime:8,' milliseconds');
          WRITELN(Whetpasa); WRITELN(Whetpasa,' Elapsed CPU time for ',
                      NumOfCycles:3,' cycles: ',ElapsedTime:8,' milliseconds');

      { Sum time in milliseconds per cycle }
      MeanTime:= MeanTime + (ElapsedTime/NumOfCycles);

          Rating:= (1000.0*1000.0*NumOfCycles)/ElapsedTime;

      { Sum Whetstone rating }
          MeanRating:= MeanRating + Rating;
          IntRating:= ROUND(Rating);
          WRITELN;WRITELN(' Whetstone rating: ',IntRating:5,' KWIPS');WRITELN;
          WRITELN(Whetpasa);WRITELN(Whetpasa,' Whetstone rating: ',IntRating:5,
                                    ' KWIPS');WRITELN(Whetpasa);

          NumOfCycles:= NumOfCycles + 10;
        END; { Main loop }

        MeanTime:= MeanTime/NumOfRuns;
        WRITELN; WRITELN(' Average time per cycle: ',MeanTime:11:2,
                         ' milliseconds');
        WRITELN(Whetpasa); WRITELN(Whetpasa,' Average time per cycle: ',
                                   MeanTime:11:2,' milliseconds');

        MeanRating:= MeanRating/NumOfRuns;
        IntRating:= ROUND(MeanRating);
        WRITELN; WRITELN(' Average Whetstone rating: ',IntRating:5,' KWIPS');
        WRITELN(Whetpasa); WRITELN(Whetpasa,' Average Whetstone rating: ',
                                   IntRating:5,' KWIPS');
        CLOSE(Whetpasa);

    END; { ComputeKWIPS }

  BEGIN { Mainline }
    ComputeKWIPS;
  END. { Mainline }
--::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
--whetpasb.pas
--::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
PROGRAM Whetpasb(Input, Output, Whetpasb);
  VAR Whetpasb: TEXT;

  { Filename: WHETPASB.PAS }

  { PASCAL version of Whetstone Benchmark Program.               }
  {        (with stubbed MATH lib with check)                    }
  { Reference: "Computer Journal," February 1976, pages 43-49,   }
  {            for description of benchmark and ALGOL60 version. }
  { Note: Procedure POUT is omitted.                             }

  PROCEDURE Whetstone(I, NumOfCycles: INTEGER;
                      VAR StartTime, StopTime: INTEGER);

    TYPE VECTOR = ARRAY[1..4] OF REAL;

    VAR
      X1,X2,X3,X4,X,Y,Z,T,T1,T2: REAL;
      E1: VECTOR;
      J,K,L,N1,N2,N3,N4,N5,N6,N7,N8,N9,N10,N11: INTEGER;
      CycleNumber: INTEGER;

  {Uncomment following function to run benchmark with math library stubbed off}

      FUNCTION MYSTUB(X: REAL): REAL;
        BEGIN
          MYSTUB:= 1.0;
        END;

      PROCEDURE PA(VAR E: VECTOR);
        LABEL 1;
        VAR J: INTEGER;
        BEGIN
          J:= 0;
          1:
          E[1]:= (E[1]+E[2]+E[3]-E[4])*T;
          E[2]:= (E[1]+E[2]-E[3]+E[4])*T;
          E[3]:= (E[1]-E[2]+E[3]+E[4])*T;
          E[4]:= (-E[1]+E[2]+E[3]+E[4])/T2;
          J:= J+1;
          IF J < 6 THEN
             GOTO 1;
        END; { PA }

      PROCEDURE P0;
        BEGIN
          E1[J]:= E1[K];
          E1[K]:= E1[L];
          E1[L]:= E1[J];
        END; { P0 }

      PROCEDURE P3(X, Y: REAL; VAR Z: REAL);
        BEGIN
          X:= T*(X+Y);
          Y:= T*(X+Y);
          Z:= (X+Y)/T2;
        END; { P3 }

    BEGIN { Whetstone }
      { Initialize constants }
      T:= 0.499975;
      T1:= 0.50025;
      T2:= 2.0;

      { Compute execution frequencies for benchmark modules }
      N1:= 0;    { Module 1 not executed }
      N2:= 12*I;
      N3:= 14*I;
      N4:= 345*I;
      N5:= 0;    { Module 5 not executed }
      N6:= 210*I;
      N7:= 32*I;
      N8:= 899*I;
      N9:= 616*I;
      N10:= 0;   { Module 10 not executed }
      N11:= 93*I;

      StartTime:= CLOCK; { Get current CPU time in milliseconds }

      FOR CycleNumber:= 1 TO NumOfCycles DO
        BEGIN { Main loop }
          { Module 1: simple identifiers }
          X1:= 1.0;
          X2:= -1.0;
          X3:= -1.0;
          X4:= -1.0;
          FOR I:= 1 TO N1 DO
            BEGIN
              X1:= (X1+X2+X3-X4)*T;
              X2:= (X1+X2-X3+X4)*T;
              X3:= (X1-X2+X3+X4)*T;
              X4:= (-X1+X2+X3+X4)*T;
            END; { Module 1 }

          { Module 2: array elements }
          E1[1]:= 1.0;
          E1[2]:= -1.0;
          E1[3]:= -1.0;
          E1[4]:= -1.0;
          FOR I:= 1 TO N2 DO
            BEGIN
              E1[1]:= (E1[1]+E1[2]+E1[3]-E1[4])*T;
              E1[2]:= (E1[1]+E1[2]-E1[3]+E1[4])*T;
              E1[3]:= (E1[1]-E1[2]+E1[3]+E1[4])*T;
              E1[4]:= (-E1[1]+E1[2]+E1[3]+E1[4])*T;
            END; { Module 2 }

          { Module 3: array as parameter }
          FOR I:= 1 TO N3 DO
            PA(E1);
          { End Module 3 }

          { Module 4: conditional jumps }
          J:= 1;
          FOR I:= 1 TO N4 DO
            BEGIN
              IF J = 1 THEN
                 J:= 2
              ELSE
                 J:= 3;
              IF J > 2 THEN
                 J:= 0
              ELSE
                 J:= 1;
              IF J < 1 THEN
                 J:= 1
              ELSE
                 J:= 0;
            END; { Module 4 }

          { Module 5: omitted }

          { Module 6: integer arithmetic }
          J:= 1;
          K:= 2;
          L:= 3;
          FOR I:= 1 TO N6 DO
            BEGIN
              J:= J*(K-J)*(L-K);
              K:= L*K-(L-J)*K;
              L:= (L-K)*(K+J);
              E1[L-1]:= J+K+L;
              E1[K-1]:= J*K*L;
            END; { Module 6 }

          { Module 7: trigonometric functions }
          X:= 0.5;
          Y:= 0.5;
          FOR I:= 1 TO N7 DO
           BEGIN
    { Comment out next 2 lines to run benchmark with math library stubbed off }
    {      X:= T*ARCTAN(T2*SIN(X)*COS(X)/(COS(X+Y)+COS(X-Y)-1.0));            }
    {      Y:= T*ARCTAN(T2*SIN(Y)*COS(Y)/(COS(X+Y)+COS(X-Y)-1.0));            }

    { Uncomment next 2 lines to run benchmark with math library stubbed off }
           X:= T*MYSTUB(T2*MYSTUB(X)*MYSTUB(X)/(MYSTUB(X+Y)+MYSTUB(X-Y)-1.0));
           Y:= T*MYSTUB(T2*MYSTUB(Y)*MYSTUB(Y)/(MYSTUB(X+Y)+MYSTUB(X-Y)-1.0));
           END; { Module 7 }

          { Module 8: procedure calls }
          X:= 1.0;
          Y:= 1.0;
          Z:= 1.0;
          FOR I:= 1 TO N8 DO
            P3(X,Y,Z);
          { End Module 8 }

          { Module 9: array references }
          J:= 1;
          K:= 2;
          L:= 3;
          E1[1]:= 1.0;
          E1[2]:= 2.0;
          E1[3]:= 3.0;
          FOR I:= 1 TO N9 DO
            P0;
          { End Module 9 }

          { Module 10: integer arithmetic }
          J:= 2;
          K:= 3;
          FOR I:= 1 TO N10 DO
            BEGIN
              J:= J+K;
              K:= J+K;
              J:= K-J;
              K:= K-J-J;
            END; { Module 10 }

          { Module 11: standard functions }
          X:= 0.75;
          FOR I:= 1 TO N11 DO
    { Comment out next line to run benchmark with math library stubbed off }
            {X:= SQRT(EXP(LN(X)/T1));                                      }

    { Uncomment next line to run benchmark with library stubbed off }
            X:= MYSTUB(MYSTUB(MYSTUB(X)/T1));
          { End Module 11 }
        END; { Main loop }

      StopTime:= CLOCK; { Get current CPU time in milliseconds }

    END; { Whetstone }



  PROCEDURE ComputeKWIPS;
    VAR
      NumOfRuns, NumOfCycles, StartTime, StopTime,
      IntRating, ElapsedTime, RunNumber, I: INTEGER;
      MeanTime, MeanRating, Rating: REAL;

    BEGIN
      REWRITE(Whetpasb);
      WRITELN(Whetpasb,' PASCAL Whetstone benchmark(with stubbed MATH lib with check)');
      WRITELN(Whetpasb);
      WRITELN; WRITELN(' PASCAL Whetstone benchmark(with stubbed MATH lib with check)');
      WRITELN;

      MeanTime:= 0.0;
      MeanRating:= 0.0;
      NumOfCycles:= 10;
      NumOfRuns:= 5;
      I:= 10;

      FOR RunNumber:= 1 TO NumOfRuns DO
        BEGIN { Main loop }
          Whetstone(I, NumOfCycles, StartTime, StopTime);

          WRITELN; WRITELN(' Whetstone CPU start time: ',StartTime:8,
                           ' milliseconds');
          WRITELN(Whetpasb); WRITELN(Whetpasb,' Whetstone CPU start time: ',
                                     StartTime:8,' milliseconds');

          WRITELN; WRITELN(' Whetstone CPU stop time: ',StopTime:8,
                           ' milliseconds');
          WRITELN(Whetpasb); WRITELN(Whetpasb,' Whetstone CPU stop time: ',
                                     StopTime:8,' milliseconds');

          ElapsedTime:= StopTime - StartTime;
          WRITELN; WRITELN(' Elapsed CPU time for ',NumOfCycles:3,' cycles: ',
                           ElapsedTime:8,' milliseconds');
          WRITELN(Whetpasb); WRITELN(Whetpasb,' Elapsed CPU time for ',
                      NumOfCycles:3,' cycles: ',ElapsedTime:8,' milliseconds');

      { Sum time in milliseconds per cycle }
      MeanTime:= MeanTime + (ElapsedTime/NumOfCycles);

          Rating:= (1000.0*1000.0*NumOfCycles)/ElapsedTime;

      { Sum Whetstone rating }
          MeanRating:= MeanRating + Rating;
          IntRating:= ROUND(Rating);
          WRITELN;WRITELN(' Whetstone rating: ',IntRating:5,' KWIPS');WRITELN;
          WRITELN(Whetpasb);WRITELN(Whetpasb,' Whetstone rating: ',IntRating:5,
                                    ' KWIPS');WRITELN(Whetpasb);

          NumOfCycles:= NumOfCycles + 10;
        END; { Main loop }

        MeanTime:= MeanTime/NumOfRuns;
        WRITELN; WRITELN(' Average time per cycle: ',MeanTime:11:2,
                         ' milliseconds');
        WRITELN(Whetpasb); WRITELN(Whetpasb,' Average time per cycle: ',
                                   MeanTime:11:2,' milliseconds');

        MeanRating:= MeanRating/NumOfRuns;
        IntRating:= ROUND(MeanRating);
        WRITELN; WRITELN(' Average Whetstone rating: ',IntRating:5,' KWIPS');
        WRITELN(Whetpasb); WRITELN(Whetpasb,' Average Whetstone rating: ',
                                   IntRating:5,' KWIPS');
        CLOSE(Whetpasb);

    END; { ComputeKWIPS }

  BEGIN { Mainline }
    ComputeKWIPS;
  END. { Mainline }
--::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
--whetpasc.pas
--::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
PROGRAM Whetpasc(Input, Output, Whetpasc);
  VAR Whetpasc: TEXT;

  { Filename: Whetpasc.PAS }

  { PASCAL version of Whetstone Benchmark Program.               }
  {        (with MATH lib no check)                              }
  { Reference: "Computer Journal," February 1976, pages 43-49,   }
  {            for description of benchmark and ALGOL60 version. }
  { Note: Procedure POUT is omitted.                             }

  PROCEDURE Whetstone(I, NumOfCycles: INTEGER;
                      VAR StartTime, StopTime: INTEGER);

    TYPE VECTOR = ARRAY[1..4] OF REAL;

    VAR
      X1,X2,X3,X4,X,Y,Z,T,T1,T2: REAL;
      E1: VECTOR;
      J,K,L,N1,N2,N3,N4,N5,N6,N7,N8,N9,N10,N11: INTEGER;
      CycleNumber: INTEGER;

  {Uncomment following function to run benchmark with math library stubbed off}

    { FUNCTION MYSTUB(X: REAL): REAL; }
    {   BEGIN                         }
    {     MYSTUB:= 1.0;               }
    {   END;                          }

      PROCEDURE PA(VAR E: VECTOR);
        LABEL 1;
        VAR J: INTEGER;
        BEGIN
          J:= 0;
          1:
          E[1]:= (E[1]+E[2]+E[3]-E[4])*T;
          E[2]:= (E[1]+E[2]-E[3]+E[4])*T;
          E[3]:= (E[1]-E[2]+E[3]+E[4])*T;
          E[4]:= (-E[1]+E[2]+E[3]+E[4])/T2;
          J:= J+1;
          IF J < 6 THEN
             GOTO 1;
        END; { PA }

      PROCEDURE P0;
        BEGIN
          E1[J]:= E1[K];
          E1[K]:= E1[L];
          E1[L]:= E1[J];
        END; { P0 }

      PROCEDURE P3(X, Y: REAL; VAR Z: REAL);
        BEGIN
          X:= T*(X+Y);
          Y:= T*(X+Y);
          Z:= (X+Y)/T2;
        END; { P3 }

    BEGIN { Whetstone }
      { Initialize constants }
      T:= 0.499975;
      T1:= 0.50025;
      T2:= 2.0;

      { Compute execution frequencies for benchmark modules }
      N1:= 0;    { Module 1 not executed }
      N2:= 12*I;
      N3:= 14*I;
      N4:= 345*I;
      N5:= 0;    { Module 5 not executed }
      N6:= 210*I;
      N7:= 32*I;
      N8:= 899*I;
      N9:= 616*I;
      N10:= 0;   { Module 10 not executed }
      N11:= 93*I;

      StartTime:= CLOCK; { Get current CPU time in milliseconds }

      FOR CycleNumber:= 1 TO NumOfCycles DO
        BEGIN { Main loop }
          { Module 1: simple identifiers }
          X1:= 1.0;
          X2:= -1.0;
          X3:= -1.0;
          X4:= -1.0;
          FOR I:= 1 TO N1 DO
            BEGIN
              X1:= (X1+X2+X3-X4)*T;
              X2:= (X1+X2-X3+X4)*T;
              X3:= (X1-X2+X3+X4)*T;
              X4:= (-X1+X2+X3+X4)*T;
            END; { Module 1 }

          { Module 2: array elements }
          E1[1]:= 1.0;
          E1[2]:= -1.0;
          E1[3]:= -1.0;
          E1[4]:= -1.0;
          FOR I:= 1 TO N2 DO
            BEGIN
              E1[1]:= (E1[1]+E1[2]+E1[3]-E1[4])*T;
              E1[2]:= (E1[1]+E1[2]-E1[3]+E1[4])*T;
              E1[3]:= (E1[1]-E1[2]+E1[3]+E1[4])*T;
              E1[4]:= (-E1[1]+E1[2]+E1[3]+E1[4])*T;
            END; { Module 2 }

          { Module 3: array as parameter }
          FOR I:= 1 TO N3 DO
            PA(E1);
          { End Module 3 }

          { Module 4: conditional jumps }
          J:= 1;
          FOR I:= 1 TO N4 DO
            BEGIN
              IF J = 1 THEN
                 J:= 2
              ELSE
                 J:= 3;
              IF J > 2 THEN
                 J:= 0
              ELSE
                 J:= 1;
              IF J < 1 THEN
                 J:= 1
              ELSE
                 J:= 0;
            END; { Module 4 }

          { Module 5: omitted }

          { Module 6: integer arithmetic }
          J:= 1;
          K:= 2;
          L:= 3;
          FOR I:= 1 TO N6 DO
            BEGIN
              J:= J*(K-J)*(L-K);
              K:= L*K-(L-J)*K;
              L:= (L-K)*(K+J);
              E1[L-1]:= J+K+L;
              E1[K-1]:= J*K*L;
            END; { Module 6 }

          { Module 7: trigonometric functions }
          X:= 0.5;
          Y:= 0.5;
          FOR I:= 1 TO N7 DO
           BEGIN
    { Comment out next 2 lines to run benchmark with math library stubbed off }
           X:= T*ARCTAN(T2*SIN(X)*COS(X)/(COS(X+Y)+COS(X-Y)-1.0));
           Y:= T*ARCTAN(T2*SIN(Y)*COS(Y)/(COS(X+Y)+COS(X-Y)-1.0));

    { Uncomment next 2 lines to run benchmark with math library stubbed off }
          {X:= T*MYSTUB(T2*MYSTUB(X)*MYSTUB(X)/(MYSTUB(X+Y)+MYSTUB(X-Y)-1.0));}
          {Y:= T*MYSTUB(T2*MYSTUB(Y)*MYSTUB(Y)/(MYSTUB(X+Y)+MYSTUB(X-Y)-1.0));}
           END; { Module 7 }

          { Module 8: procedure calls }
          X:= 1.0;
          Y:= 1.0;
          Z:= 1.0;
          FOR I:= 1 TO N8 DO
            P3(X,Y,Z);
          { End Module 8 }

          { Module 9: array references }
          J:= 1;
          K:= 2;
          L:= 3;
          E1[1]:= 1.0;
          E1[2]:= 2.0;
          E1[3]:= 3.0;
          FOR I:= 1 TO N9 DO
            P0;
          { End Module 9 }

          { Module 10: integer arithmetic }
          J:= 2;
          K:= 3;
          FOR I:= 1 TO N10 DO
            BEGIN
              J:= J+K;
              K:= J+K;
              J:= K-J;
              K:= K-J-J;
            END; { Module 10 }

          { Module 11: standard functions }
          X:= 0.75;
          FOR I:= 1 TO N11 DO
    { Comment out next line to run benchmark with math library stubbed off }
            X:= SQRT(EXP(LN(X)/T1));

    { Uncomment next line to run benchmark with library stubbed off }
          { X:= MYSTUB(MYSTUB(MYSTUB(X)/T1)); }
          { End Module 11 }
        END; { Main loop }

      StopTime:= CLOCK; { Get current CPU time in milliseconds }

    END; { Whetstone }



  PROCEDURE ComputeKWIPS;
    VAR
      NumOfRuns, NumOfCycles, StartTime, StopTime,
      IntRating, ElapsedTime, RunNumber, I: INTEGER;
      MeanTime, MeanRating, Rating: REAL;

    BEGIN
      REWRITE(Whetpasc);
      WRITELN(Whetpasc,' PASCAL Whetstone benchmark(with MATH lib NOCHECK)');
      WRITELN(Whetpasc);
      WRITELN; WRITELN(' PASCAL Whetstone benchmark(with MATH lib NOCHECK)');
      WRITELN;

      MeanTime:= 0.0;
      MeanRating:= 0.0;
      NumOfCycles:= 10;
      NumOfRuns:= 5;
      I:= 10;

      FOR RunNumber:= 1 TO NumOfRuns DO
        BEGIN { Main loop }
          Whetstone(I, NumOfCycles, StartTime, StopTime);

          WRITELN; WRITELN(' Whetstone CPU start time: ',StartTime:8,
                           ' milliseconds');
          WRITELN(Whetpasc); WRITELN(Whetpasc,' Whetstone CPU start time: ',
                                     StartTime:8,' milliseconds');

          WRITELN; WRITELN(' Whetstone CPU stop time: ',StopTime:8,
                           ' milliseconds');
          WRITELN(Whetpasc); WRITELN(Whetpasc,' Whetstone CPU stop time: ',
                                     StopTime:8,' milliseconds');

          ElapsedTime:= StopTime - StartTime;
          WRITELN; WRITELN(' Elapsed CPU time for ',NumOfCycles:3,' cycles: ',
                           ElapsedTime:8,' milliseconds');
          WRITELN(Whetpasc); WRITELN(Whetpasc,' Elapsed CPU time for ',
                      NumOfCycles:3,' cycles: ',ElapsedTime:8,' milliseconds');

      { Sum time in milliseconds per cycle }
      MeanTime:= MeanTime + (ElapsedTime/NumOfCycles);

          Rating:= (1000.0*1000.0*NumOfCycles)/ElapsedTime;

      { Sum Whetstone rating }
          MeanRating:= MeanRating + Rating;
          IntRating:= ROUND(Rating);
          WRITELN;WRITELN(' Whetstone rating: ',IntRating:5,' KWIPS');WRITELN;
          WRITELN(Whetpasc);WRITELN(Whetpasc,' Whetstone rating: ',IntRating:5,
                                    ' KWIPS');WRITELN(Whetpasc);

          NumOfCycles:= NumOfCycles + 10;
        END; { Main loop }

        MeanTime:= MeanTime/NumOfRuns;
        WRITELN; WRITELN(' Average time per cycle: ',MeanTime:11:2,
                         ' milliseconds');
        WRITELN(Whetpasc); WRITELN(Whetpasc,' Average time per cycle: ',
                                   MeanTime:11:2,' milliseconds');

        MeanRating:= MeanRating/NumOfRuns;
        IntRating:= ROUND(MeanRating);
        WRITELN; WRITELN(' Average Whetstone rating: ',IntRating:5,' KWIPS');
        WRITELN(Whetpasc); WRITELN(Whetpasc,' Average Whetstone rating: ',
                                   IntRating:5,' KWIPS');
        CLOSE(Whetpasc);

    END; { ComputeKWIPS }

  BEGIN { Mainline }
    ComputeKWIPS;
  END. { Mainline }
--::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
--whetpasd.pas
--::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
PROGRAM Whetpasd(Input, Output, Whetpasd);
  VAR Whetpasd: TEXT;

  { Filename: Whetpasd.PAS }

  { PASCAL version of Whetstone Benchmark Program.               }
  {        (with MATH lib with CHECK)                            }
  { Reference: "Computer Journal," February 1976, pages 43-49,   }
  {            for description of benchmark and ALGOL60 version. }
  { Note: Procedure POUT is omitted.                             }

  PROCEDURE Whetstone(I, NumOfCycles: INTEGER;
                      VAR StartTime, StopTime: INTEGER);

    TYPE VECTOR = ARRAY[1..4] OF REAL;

    VAR
      X1,X2,X3,X4,X,Y,Z,T,T1,T2: REAL;
      E1: VECTOR;
      J,K,L,N1,N2,N3,N4,N5,N6,N7,N8,N9,N10,N11: INTEGER;
      CycleNumber: INTEGER;

  {Uncomment following function to run benchmark with math library stubbed off}

    { FUNCTION MYSTUB(X: REAL): REAL; }
    {   BEGIN                         }
    {     MYSTUB:= 1.0;               }
    {   END;                          }

      PROCEDURE PA(VAR E: VECTOR);
        LABEL 1;
        VAR J: INTEGER;
        BEGIN
          J:= 0;
          1:
          E[1]:= (E[1]+E[2]+E[3]-E[4])*T;
          E[2]:= (E[1]+E[2]-E[3]+E[4])*T;
          E[3]:= (E[1]-E[2]+E[3]+E[4])*T;
          E[4]:= (-E[1]+E[2]+E[3]+E[4])/T2;
          J:= J+1;
          IF J < 6 THEN
             GOTO 1;
        END; { PA }

      PROCEDURE P0;
        BEGIN
          E1[J]:= E1[K];
          E1[K]:= E1[L];
          E1[L]:= E1[J];
        END; { P0 }

      PROCEDURE P3(X, Y: REAL; VAR Z: REAL);
        BEGIN
          X:= T*(X+Y);
          Y:= T*(X+Y);
          Z:= (X+Y)/T2;
        END; { P3 }

    BEGIN { Whetstone }
      { Initialize constants }
      T:= 0.499975;
      T1:= 0.50025;
      T2:= 2.0;

      { Compute execution frequencies for benchmark modules }
      N1:= 0;    { Module 1 not executed }
      N2:= 12*I;
      N3:= 14*I;
      N4:= 345*I;
      N5:= 0;    { Module 5 not executed }
      N6:= 210*I;
      N7:= 32*I;
      N8:= 899*I;
      N9:= 616*I;
      N10:= 0;   { Module 10 not executed }
      N11:= 93*I;

      StartTime:= CLOCK; { Get current CPU time in milliseconds }

      FOR CycleNumber:= 1 TO NumOfCycles DO
        BEGIN { Main loop }
          { Module 1: simple identifiers }
          X1:= 1.0;
          X2:= -1.0;
          X3:= -1.0;
          X4:= -1.0;
          FOR I:= 1 TO N1 DO
            BEGIN
              X1:= (X1+X2+X3-X4)*T;
              X2:= (X1+X2-X3+X4)*T;
              X3:= (X1-X2+X3+X4)*T;
              X4:= (-X1+X2+X3+X4)*T;
            END; { Module 1 }

          { Module 2: array elements }
          E1[1]:= 1.0;
          E1[2]:= -1.0;
          E1[3]:= -1.0;
          E1[4]:= -1.0;
          FOR I:= 1 TO N2 DO
            BEGIN
              E1[1]:= (E1[1]+E1[2]+E1[3]-E1[4])*T;
              E1[2]:= (E1[1]+E1[2]-E1[3]+E1[4])*T;
              E1[3]:= (E1[1]-E1[2]+E1[3]+E1[4])*T;
              E1[4]:= (-E1[1]+E1[2]+E1[3]+E1[4])*T;
            END; { Module 2 }

          { Module 3: array as parameter }
          FOR I:= 1 TO N3 DO
            PA(E1);
          { End Module 3 }

          { Module 4: conditional jumps }
          J:= 1;
          FOR I:= 1 TO N4 DO
            BEGIN
              IF J = 1 THEN
                 J:= 2
              ELSE
                 J:= 3;
              IF J > 2 THEN
                 J:= 0
              ELSE
                 J:= 1;
              IF J < 1 THEN
                 J:= 1
              ELSE
                 J:= 0;
            END; { Module 4 }

          { Module 5: omitted }

          { Module 6: integer arithmetic }
          J:= 1;
          K:= 2;
          L:= 3;
          FOR I:= 1 TO N6 DO
            BEGIN
              J:= J*(K-J)*(L-K);
              K:= L*K-(L-J)*K;
              L:= (L-K)*(K+J);
              E1[L-1]:= J+K+L;
              E1[K-1]:= J*K*L;
            END; { Module 6 }

          { Module 7: trigonometric functions }
          X:= 0.5;
          Y:= 0.5;
          FOR I:= 1 TO N7 DO
           BEGIN
    { Comment out next 2 lines to run benchmark with math library stubbed off }
           X:= T*ARCTAN(T2*SIN(X)*COS(X)/(COS(X+Y)+COS(X-Y)-1.0));
           Y:= T*ARCTAN(T2*SIN(Y)*COS(Y)/(COS(X+Y)+COS(X-Y)-1.0));

    { Uncomment next 2 lines to run benchmark with math library stubbed off }
          {X:= T*MYSTUB(T2*MYSTUB(X)*MYSTUB(X)/(MYSTUB(X+Y)+MYSTUB(X-Y)-1.0));}
          {Y:= T*MYSTUB(T2*MYSTUB(Y)*MYSTUB(Y)/(MYSTUB(X+Y)+MYSTUB(X-Y)-1.0));}
           END; { Module 7 }

          { Module 8: procedure calls }
          X:= 1.0;
          Y:= 1.0;
          Z:= 1.0;
          FOR I:= 1 TO N8 DO
            P3(X,Y,Z);
          { End Module 8 }

          { Module 9: array references }
          J:= 1;
          K:= 2;
          L:= 3;
          E1[1]:= 1.0;
          E1[2]:= 2.0;
          E1[3]:= 3.0;
          FOR I:= 1 TO N9 DO
            P0;
          { End Module 9 }

          { Module 10: integer arithmetic }
          J:= 2;
          K:= 3;
          FOR I:= 1 TO N10 DO
            BEGIN
              J:= J+K;
              K:= J+K;
              J:= K-J;
              K:= K-J-J;
            END; { Module 10 }

          { Module 11: standard functions }
          X:= 0.75;
          FOR I:= 1 TO N11 DO
    { Comment out next line to run benchmark with math library stubbed off }
            X:= SQRT(EXP(LN(X)/T1));

    { Uncomment next line to run benchmark with library stubbed off }
          { X:= MYSTUB(MYSTUB(MYSTUB(X)/T1)); }
          { End Module 11 }
        END; { Main loop }

      StopTime:= CLOCK; { Get current CPU time in milliseconds }

    END; { Whetstone }



  PROCEDURE ComputeKWIPS;
    VAR
      NumOfRuns, NumOfCycles, StartTime, StopTime,
      IntRating, ElapsedTime, RunNumber, I: INTEGER;
      MeanTime, MeanRating, Rating: REAL;

    BEGIN
      REWRITE(Whetpasd);
      WRITELN(Whetpasd,' PASCAL Whetstone benchmark(with MATH lib with CHECK)');
      WRITELN(Whetpasd);
      WRITELN; WRITELN(' PASCAL Whetstone benchmark(with MATH lib with CHECK)');
      WRITELN;

      MeanTime:= 0.0;
      MeanRating:= 0.0;
      NumOfCycles:= 10;
      NumOfRuns:= 5;
      I:= 10;

      FOR RunNumber:= 1 TO NumOfRuns DO
        BEGIN { Main loop }
          Whetstone(I, NumOfCycles, StartTime, StopTime);

          WRITELN; WRITELN(' Whetstone CPU start time: ',StartTime:8,
                           ' milliseconds');
          WRITELN(Whetpasd); WRITELN(Whetpasd,' Whetstone CPU start time: ',
                                     StartTime:8,' milliseconds');

          WRITELN; WRITELN(' Whetstone CPU stop time: ',StopTime:8,
                           ' milliseconds');
          WRITELN(Whetpasd); WRITELN(Whetpasd,' Whetstone CPU stop time: ',
                                     StopTime:8,' milliseconds');

          ElapsedTime:= StopTime - StartTime;
          WRITELN; WRITELN(' Elapsed CPU time for ',NumOfCycles:3,' cycles: ',
                           ElapsedTime:8,' milliseconds');
          WRITELN(Whetpasd); WRITELN(Whetpasd,' Elapsed CPU time for ',
                      NumOfCycles:3,' cycles: ',ElapsedTime:8,' milliseconds');

      { Sum time in milliseconds per cycle }
      MeanTime:= MeanTime + (ElapsedTime/NumOfCycles);

          Rating:= (1000.0*1000.0*NumOfCycles)/ElapsedTime;

      { Sum Whetstone rating }
          MeanRating:= MeanRating + Rating;
          IntRating:= ROUND(Rating);
          WRITELN;WRITELN(' Whetstone rating: ',IntRating:5,' KWIPS');WRITELN;
          WRITELN(Whetpasd);WRITELN(Whetpasd,' Whetstone rating: ',IntRating:5,
                                    ' KWIPS');WRITELN(Whetpasd);

          NumOfCycles:= NumOfCycles + 10;
        END; { Main loop }

        MeanTime:= MeanTime/NumOfRuns;
        WRITELN; WRITELN(' Average time per cycle: ',MeanTime:11:2,
                         ' milliseconds');
        WRITELN(Whetpasd); WRITELN(Whetpasd,' Average time per cycle: ',
                                   MeanTime:11:2,' milliseconds');

        MeanRating:= MeanRating/NumOfRuns;
        IntRating:= ROUND(MeanRating);
        WRITELN; WRITELN(' Average Whetstone rating: ',IntRating:5,' KWIPS');
        WRITELN(Whetpasd); WRITELN(Whetpasd,' Average Whetstone rating: ',
                                   IntRating:5,' KWIPS');
        CLOSE(Whetpasd);

    END; { ComputeKWIPS }

  BEGIN { Mainline }
    ComputeKWIPS;
  END. { Mainline }
--::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
--whetfora.for
--::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
C   FILENAME: WHETFORA.FOR
C
      PROGRAM WHETFORA
C
C   FORTRAN77 VERSION OF WHETSTONE BENCHMARK PROGRAM.
C             (WITH STUBBED LIB WITH NOCHECK)
C   REFERENCE: "COMPUTER JOURNAL," FEBRUARY 1976, PAGES 43-49,
C              FOR DESCRIPTION OF BENCHMARK AND ALGOL60 VERSION.
C   NOTE: PROCEDURE POUT IS OMITTED.
C
C   MAINLINE
C
    CALL COMPUT
      END
C
C   UNCOMMENT FOLLOWING FUNCTION TO RUN BENCHMARK WITH MATH LIBRARY STUBBED OFF
C
      REAL FUNCTION MYSTUB(X)
     REAL X
    MYSTUB=1.0
      RETURN
      END
C
C
C
      SUBROUTINE PA(E)
    COMMON/BENCH1/ T,T2
    REAL E(4),T,T2
    INTEGER J
    J=0
    1    CONTINUE
      E(1)=(E(1)+E(2)+E(3)-E(4))*T
      E(2)=(E(1)+E(2)-E(3)+E(4))*T
      E(3)=(E(1)-E(2)+E(3)+E(4))*T
      E(4)=(-E(1)+E(2)+E(3)+E(4))/T2
      J=J+1
      IF(J.LT.6)GOTO 1
      RETURN
      END
C
C
C
      SUBROUTINE P0
    COMMON/BENCH2/ E1(4),J,K,L
    REAL E1
    INTEGER J,K,L
    E1(J)=E1(K)
    E1(K)=E1(L)
    E1(L)=E1(J)
      RETURN
      END
C
C
C
      SUBROUTINE P3(X,Y,Z)
    COMMON/BENCH1/ T,T2
    REAL X,Y,Z,T,T2
    X=T*(X+Y)
    Y=T*(X+Y)
    Z=(X+Y)/T2
      RETURN
      END
C
C
C
      SUBROUTINE WHET(I, KCYCLE, TSTART, TSTOP)
    REAL X1,X2,X3,X4,X,Y,Z,T,T1,T2,E1,TSTART,TSTOP,MYSTUB
    INTEGER I,J,K,L,N1,N2,N3,N4,N5,N6,N7,N8,N9,N10,N11,LCOUNT,KCYCLE
C
    COMMON/BENCH1/ T,T2
    COMMON/BENCH2/ E1(4),J,K,L
C
C   INITIALIZE CONSTANTS
    T=0.499975
     T1=0.50025
    T2=2.0
C   COMPUTE EXECUTION FREQUENCIES FOR THE BENCHMARK MODULES
    N1=0
    N2=12*I
    N3=14*I
    N4=345*I
    N5=0
    N6=210*I
    N7=32*I
    N8=899*I
    N9=616*I
    N10=0
    N11=93*I
C
C   GET WHETSTONE START TIME FROM OPERATING SYSTEM
C
    TSTART=SECNDS(0.0)
C
    DO 1000 LCOUNT=1, KCYCLE
C
C   MODULE 1: SIMPLE IDENTIFIERS
C
      X1=1.0
      X2=-1.0
      X3=-1.0
      X4=-1.0
      DO 1 I=1,N1
        X1=(X1+X2+X3-X4)*T
        X2=(X1+X2-X3+X4)*T
        X3=(X1-X2+X3+X4)*T
        X4=(-X1+X2+X3+X4)*T
    1      CONTINUE
C
C   MODULE 2: ARRAY ELEMENTS
C
      E1(1)=1.0
      E1(2)=-1.0
      E1(3)=-1.0
      E1(4)=-1.0
      DO 2 I=1,N2
        E1(1)=(E1(1)+E1(2)+E1(3)-E1(4))*T
        E1(2)=(E1(1)+E1(2)-E1(3)+E1(4))*T
        E1(3)=(E1(1)-E1(2)+E1(3)+E1(4))*T
        E1(4)=(-E1(1)+E1(2)+E1(3)+E1(4))*T
    2      CONTINUE
C
C   MODULE 3: ARRAY AS PARAMETER
C
      DO 3 I=1,N3
        CALL PA(E1)
    3      CONTINUE
C
C   MODULE 4: CONDITIONAL JUMPS
C
      J=1
      DO 4 I=1,N4
        IF(J.EQ.1)THEN
          J=2
        ELSE
          J=3
        END IF
        IF(J.GT.2)THEN
          J=0
        ELSE
          J=1
        END IF
        IF(J.LT.1)THEN
          J=1
        ELSE
          J=0
        END IF
    4      CONTINUE
C
C   MODULE 5: OMITTED
C
C   MODULE 6: INTEGER ARITHMETIC
C
      J=1
      K=2
      L=3
      DO 6 I=1,N6
        J=J*(K-J)*(L-K)
        K=L*K-(L-J)*K
        L=(L-K)*(K+J)
        E1(L-1)=J+K+L
        E1(K-1)=J*K*L
    6      CONTINUE
C
C   MODULE 7: TRIGONOMETRIC FUNCTIONS
C
      X=0.5
      Y=0.5
      DO 7 I=1,N7
C   COMMENT OUT NEXT 2 LINES TO RUN BENCHMARK WITH MATH LIBRARY STUBBED OFF
C        X=T*ATAN(T2*SIN(X)*COS(X)/(COS(X+Y)+COS(X-Y)-1.0))
C        Y=T*ATAN(T2*SIN(Y)*COS(Y)/(COS(X+Y)+COS(X-Y)-1.0))
C
C   UNCOMMENT NEXT 2 LINES TO RUN BENCHMARK WITH MATH LIBRARY STUBBED OFF
        X=T*MYSTUB(T2*MYSTUB(X)*MYSTUB(X)/(MYSTUB(X+Y)+MYSTUB(X-Y)-1.0))
        Y=T*MYSTUB(T2*MYSTUB(Y)*MYSTUB(Y)/(MYSTUB(X+Y)+MYSTUB(X-Y)-1.0))
    7      CONTINUE
C
C   MODULE 8: PROCEDURE CALLS
C
      X=1.0
      Y=1.0
      Z=1.0
      DO 8 I=1,N8
        CALL P3(X,Y,Z)
    8      CONTINUE
C
C   MODULE 9: ARRAY REFERENCES
C
      J=1
      K=2
      L=3
      E1(1)=1.0
      E1(2)=2.0
      E1(3)=3.0
      DO 9 I=1,N9
        CALL P0
    9      CONTINUE
C
C   MODULE 10: INTEGER ARITHMETIC
C
      J=2
      K=3
      DO 10 I=1,N10
        J=J+K
        K=J+K
        J=K-J
        K=K-J-J
   10      CONTINUE
C
C   MODULE 11: STANDARD FUNCTIONS
C
      X=0.75
      DO 11 I=1,N11
C   COMMENT OUT NEXT LINE TO RUN BENCHMARK WITH MATH LIBRARY STUBBED OFF
C        X=SQRT(EXP(ALOG(X)/T1))
C
C   UNCOMMENT NEXT LINE TO RUN BENCHMARK WITH MATH LIBRARY STUBBED OFF
        X=MYSTUB(MYSTUB(MYSTUB(X)/T1))
   11      CONTINUE
C
 1000    CONTINUE
C
C   GET WHETSTONE STOP TIME FROM OPERATING SYSTEM
C
    TSTOP=SECNDS(0.0)
      RETURN
      END
C
C
C
      SUBROUTINE COMPUT
    REAL AVTIME,AVRATE,RATE,TSTART,TSTOP,DELTAT
    INTEGER NRUNS,LCOUNT,IRATE,KCYCLE,I
C
    OPEN(UNIT=21,FILE='WHETFORA.DAT',STATUS='NEW')
    WRITE(21,10)
    WRITE(6,10)
   10    FORMAT(1X,'FORTRAN77 Whetstone benchmark stubbed NOCHECK',/)
C
    AVTIME=0.0
    AVRATE=0.0
    KCYCLE=10
    NRUNS=5
C
    DO 1000 LCOUNT=1, NRUNS
      I=10
      CALL WHET(I, KCYCLE, TSTART, TSTOP)
C
      WRITE(6,20)TSTART
      WRITE(21,20)TSTART
   20      FORMAT(1X,'Whetstone start time: ',F8.2,' seconds')
C
      WRITE(6,30)TSTOP
      WRITE(21,30)TSTOP
   30      FORMAT(1X,'Whetstone stop time: ',F8.2,' seconds')
C
C   COMPUTE AND WRITE THE ELAPSED TIME
C
      DELTAT=TSTOP-TSTART
      WRITE(6,40)KCYCLE, DELTAT
      WRITE(21,40)KCYCLE, DELTAT
   40      FORMAT(1X,'Elapsed time for ',I3,' cycles: ',F8.2,' seconds')
C
C   SUM TIME IN MILLISECONDS PER CYCLE
      AVTIME=AVTIME + (DELTAT*1000.0)/FLOAT(KCYCLE)
C
C   CALCULATE WHETSTONE RATING BASED ON TIME FOR NUMBER OF CYCLES JUST EXECUTED
C
      RATE=(1000.0*FLOAT(KCYCLE))/DELTAT
C   SUM WHETSTONE RATING
      AVRATE=AVRATE + RATE
      IRATE=NINT(RATE)
      WRITE(6,50)IRATE
      WRITE(21,50)IRATE
   50      FORMAT(1X,'Whetstone rating: ',I5,' KWIPS',/)
C
      KCYCLE=KCYCLE+10
 1000    CONTINUE
C
C   COMPUTE AVERAGE TIME IN MILLISECONDS PER CYCLE AND WRITE
C
    AVTIME=AVTIME/FLOAT(NRUNS)
    WRITE(6,60)AVTIME
    WRITE(21,60)AVTIME
   60    FORMAT(1X,'Average time per cycle: ',F8.2,' milliseconds')
C
C   CALCULATE AVERAGE WHETSTONE RATING AND WRITE
C
    AVRATE=AVRATE/FLOAT(NRUNS)
    IRATE=NINT(AVRATE)
    WRITE(6,70)IRATE
    WRITE(21,70)IRATE
   70    FORMAT (1X,'Average Whetstone rating: ',I5,' KWIPS')
    CLOSE(UNIT=21,STATUS='KEEP')
C
      RETURN
      END
--::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
--whetforb.for
--::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
C   FILENAME: WHETFORB.FOR
C
      PROGRAM WHETFORB
C
C   FORTRAN77 VERSION OF WHETSTONE BENCHMARK PROGRAM.
C             (WITH STUBBED MATH LIB WITH CHECK)
C   REFERENCE: "COMPUTER JOURNAL," FEBRUARY 1976, PAGES 43-49,
C              FOR DESCRIPTION OF BENCHMARK AND ALGOL60 VERSION.
C   NOTE: PROCEDURE POUT IS OMITTED.
C
C   MAINLINE
C
    CALL COMPUT
      END
C
C   UNCOMMENT FOLLOWING FUNCTION TO RUN BENCHMARK WITH MATH LIBRARY STUBBED OFF
C
      REAL FUNCTION MYSTUB(X)
    REAL X
    MYSTUB=1.0
      RETURN
      END
C
C
C
      SUBROUTINE PA(E)
    COMMON/BENCH1/ T,T2
    REAL E(4),T,T2
    INTEGER J
    J=0
    1    CONTINUE
      E(1)=(E(1)+E(2)+E(3)-E(4))*T
      E(2)=(E(1)+E(2)-E(3)+E(4))*T
      E(3)=(E(1)-E(2)+E(3)+E(4))*T
      E(4)=(-E(1)+E(2)+E(3)+E(4))/T2
      J=J+1
      IF(J.LT.6)GOTO 1
      RETURN
      END
C
C
C
      SUBROUTINE P0
    COMMON/BENCH2/ E1(4),J,K,L
    REAL E1
    INTEGER J,K,L
    E1(J)=E1(K)
    E1(K)=E1(L)
    E1(L)=E1(J)
      RETURN
      END
C
C
C
      SUBROUTINE P3(X,Y,Z)
    COMMON/BENCH1/ T,T2
    REAL X,Y,Z,T,T2
    X=T*(X+Y)
    Y=T*(X+Y)
    Z=(X+Y)/T2
      RETURN
      END
C
C
C
      SUBROUTINE WHET(I, KCYCLE, TSTART, TSTOP)
    REAL X1,X2,X3,X4,X,Y,Z,T,T1,T2,E1,TSTART,TSTOP,MYSTUB
    INTEGER I,J,K,L,N1,N2,N3,N4,N5,N6,N7,N8,N9,N10,N11,LCOUNT,KCYCLE
C
    COMMON/BENCH1/ T,T2
    COMMON/BENCH2/ E1(4),J,K,L
C
C   INITIALIZE CONSTANTS
    T=0.499975
     T1=0.50025
    T2=2.0
C   COMPUTE EXECUTION FREQUENCIES FOR THE BENCHMARK MODULES
    N1=0
    N2=12*I
    N3=14*I
    N4=345*I
    N5=0
    N6=210*I
    N7=32*I
    N8=899*I
    N9=616*I
    N10=0
    N11=93*I
C
C   GET WHETSTONE START TIME FROM OPERATING SYSTEM
C
    TSTART=SECNDS(0.0)
C
    DO 1000 LCOUNT=1, KCYCLE
C
C   MODULE 1: SIMPLE IDENTIFIERS
C
      X1=1.0
      X2=-1.0
      X3=-1.0
      X4=-1.0
      DO 1 I=1,N1
        X1=(X1+X2+X3-X4)*T
        X2=(X1+X2-X3+X4)*T
        X3=(X1-X2+X3+X4)*T
        X4=(-X1+X2+X3+X4)*T
    1      CONTINUE
C
C   MODULE 2: ARRAY ELEMENTS
C
      E1(1)=1.0
      E1(2)=-1.0
      E1(3)=-1.0
      E1(4)=-1.0
      DO 2 I=1,N2
        E1(1)=(E1(1)+E1(2)+E1(3)-E1(4))*T
        E1(2)=(E1(1)+E1(2)-E1(3)+E1(4))*T
        E1(3)=(E1(1)-E1(2)+E1(3)+E1(4))*T
        E1(4)=(-E1(1)+E1(2)+E1(3)+E1(4))*T
    2      CONTINUE
C
C   MODULE 3: ARRAY AS PARAMETER
C
      DO 3 I=1,N3
        CALL PA(E1)
    3      CONTINUE
C
C   MODULE 4: CONDITIONAL JUMPS
C
      J=1
      DO 4 I=1,N4
        IF(J.EQ.1)THEN
          J=2
        ELSE
          J=3
        END IF
        IF(J.GT.2)THEN
          J=0
        ELSE
          J=1
        END IF
        IF(J.LT.1)THEN
          J=1
        ELSE
          J=0
        END IF
    4      CONTINUE
C
C   MODULE 5: OMITTED
C
C   MODULE 6: INTEGER ARITHMETIC
C
      J=1
      K=2
      L=3
      DO 6 I=1,N6
        J=J*(K-J)*(L-K)
        K=L*K-(L-J)*K
        L=(L-K)*(K+J)
        E1(L-1)=J+K+L
        E1(K-1)=J*K*L
    6      CONTINUE
C
C   MODULE 7: TRIGONOMETRIC FUNCTIONS
C
      X=0.5
      Y=0.5
      DO 7 I=1,N7
C   COMMENT OUT NEXT 2 LINES TO RUN BENCHMARK WITH MATH LIBRARY STUBBED OFF
C        X=T*ATAN(T2*SIN(X)*COS(X)/(COS(X+Y)+COS(X-Y)-1.0))
C        Y=T*ATAN(T2*SIN(Y)*COS(Y)/(COS(X+Y)+COS(X-Y)-1.0))
C
C   UNCOMMENT NEXT 2 LINES TO RUN BENCHMARK WITH MATH LIBRARY STUBBED OFF
        X=T*MYSTUB(T2*MYSTUB(X)*MYSTUB(X)/(MYSTUB(X+Y)+MYSTUB(X-Y)-1.0))
        Y=T*MYSTUB(T2*MYSTUB(Y)*MYSTUB(Y)/(MYSTUB(X+Y)+MYSTUB(X-Y)-1.0))
    7      CONTINUE
C
C   MODULE 8: PROCEDURE CALLS
C
      X=1.0
      Y=1.0
      Z=1.0
      DO 8 I=1,N8
        CALL P3(X,Y,Z)
    8      CONTINUE
C
C   MODULE 9: ARRAY REFERENCES
C
      J=1
      K=2
      L=3
      E1(1)=1.0
      E1(2)=2.0
      E1(3)=3.0
      DO 9 I=1,N9
        CALL P0
    9      CONTINUE
C
C   MODULE 10: INTEGER ARITHMETIC
C
      J=2
      K=3
      DO 10 I=1,N10
        J=J+K
        K=J+K
        J=K-J
        K=K-J-J
   10      CONTINUE
C
C   MODULE 11: STANDARD FUNCTIONS
C
      X=0.75
      DO 11 I=1,N11
C   COMMENT OUT NEXT LINE TO RUN BENCHMARK WITH MATH LIBRARY STUBBED OFF
C        X=SQRT(EXP(ALOG(X)/T1))
C
C   UNCOMMENT NEXT LINE TO RUN BENCHMARK WITH MATH LIBRARY STUBBED OFF
        X=MYSTUB(MYSTUB(MYSTUB(X)/T1))
   11      CONTINUE
C
 1000    CONTINUE
C
C   GET WHETSTONE STOP TIME FROM OPERATING SYSTEM
C
    TSTOP=SECNDS(0.0)
      RETURN
      END
C
C
C
      SUBROUTINE COMPUT
    REAL AVTIME,AVRATE,RATE,TSTART,TSTOP,DELTAT
    INTEGER NRUNS,LCOUNT,IRATE,KCYCLE,I
C
    OPEN(UNIT=21,FILE='WHETFORB.DAT',STATUS='NEW')
    WRITE(21,10)
    WRITE(6,10)
   10    FORMAT(1X,'FORTRAN77 Whetstone benchmark(stubbed CHECK)',/)
C
    AVTIME=0.0
    AVRATE=0.0
    KCYCLE=10
    NRUNS=5
C
    DO 1000 LCOUNT=1, NRUNS
      I=10
      CALL WHET(I, KCYCLE, TSTART, TSTOP)
C
      WRITE(6,20)TSTART
      WRITE(21,20)TSTART
   20      FORMAT(1X,'Whetstone start time: ',F8.2,' seconds')
C
      WRITE(6,30)TSTOP
      WRITE(21,30)TSTOP
   30      FORMAT(1X,'Whetstone stop time: ',F8.2,' seconds')
C
C   COMPUTE AND WRITE THE ELAPSED TIME
C
      DELTAT=TSTOP-TSTART
      WRITE(6,40)KCYCLE, DELTAT
      WRITE(21,40)KCYCLE, DELTAT
   40      FORMAT(1X,'Elapsed time for ',I3,' cycles: ',F8.2,' seconds')
C
C   SUM TIME IN MILLISECONDS PER CYCLE
      AVTIME=AVTIME + (DELTAT*1000.0)/FLOAT(KCYCLE)
C
C   CALCULATE WHETSTONE RATING BASED ON TIME FOR NUMBER OF CYCLES JUST EXECUTED
C
      RATE=(1000.0*FLOAT(KCYCLE))/DELTAT
C   SUM WHETSTONE RATING
      AVRATE=AVRATE + RATE
      IRATE=NINT(RATE)
      WRITE(6,50)IRATE
      WRITE(21,50)IRATE
   50      FORMAT(1X,'Whetstone rating: ',I5,' KWIPS',/)
C
      KCYCLE=KCYCLE+10
 1000    CONTINUE
C
C   COMPUTE AVERAGE TIME IN MILLISECONDS PER CYCLE AND WRITE
C
    AVTIME=AVTIME/FLOAT(NRUNS)
    WRITE(6,60)AVTIME
    WRITE(21,60)AVTIME
   60    FORMAT(1X,'Average time per cycle: ',F8.2,' milliseconds')
C
C   CALCULATE AVERAGE WHETSTONE RATING AND WRITE
C
    AVRATE=AVRATE/FLOAT(NRUNS)
    IRATE=NINT(AVRATE)
    WRITE(6,70)IRATE
    WRITE(21,70)IRATE
   70    FORMAT (1X,'Average Whetstone rating: ',I5,' KWIPS')
    CLOSE(UNIT=21,STATUS='KEEP')
C
      RETURN
      END
--::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
--whetforc.for
--::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
C   FILENAME: WHETFORC.FOR
C
      PROGRAM WHETFORC
C
C   FORTRAN77 VERSION OF WHETSTONE BENCHMARK PROGRAM.
C             (WITH MATH LIB WITH NOCHECK)
C   REFERENCE: "COMPUTER JOURNAL," FEBRUARY 1976, PAGES 43-49,
C              FOR DESCRIPTION OF BENCHMARK AND ALGOL60 VERSION.
C   NOTE: PROCEDURE POUT IS OMITTED.
C
C   MAINLINE
C
    CALL COMPUT
      END
C
C   UNCOMMENT FOLLOWING FUNCTION TO RUN BENCHMARK WITH MATH LIBRARY STUBBED OFF
C
C     REAL FUNCTION MYSTUB(X)
C    REAL X
C    MYSTUB=1.0
C     RETURN
C     END
C
C
C
      SUBROUTINE PA(E)
    COMMON/BENCH1/ T,T2
    REAL E(4),T,T2
    INTEGER J
    J=0
    1    CONTINUE
      E(1)=(E(1)+E(2)+E(3)-E(4))*T
      E(2)=(E(1)+E(2)-E(3)+E(4))*T
      E(3)=(E(1)-E(2)+E(3)+E(4))*T
      E(4)=(-E(1)+E(2)+E(3)+E(4))/T2
      J=J+1
      IF(J.LT.6)GOTO 1
      RETURN
      END
C
C
C
      SUBROUTINE P0
    COMMON/BENCH2/ E1(4),J,K,L
    REAL E1
    INTEGER J,K,L
    E1(J)=E1(K)
    E1(K)=E1(L)
    E1(L)=E1(J)
      RETURN
      END
C
C
C
      SUBROUTINE P3(X,Y,Z)
    COMMON/BENCH1/ T,T2
    REAL X,Y,Z,T,T2
    X=T*(X+Y)
    Y=T*(X+Y)
    Z=(X+Y)/T2
      RETURN
      END
C
C
C
      SUBROUTINE WHET(I, KCYCLE, TSTART, TSTOP)
    REAL X1,X2,X3,X4,X,Y,Z,T,T1,T2,E1,TSTART,TSTOP,MYSTUB
    INTEGER I,J,K,L,N1,N2,N3,N4,N5,N6,N7,N8,N9,N10,N11,LCOUNT,KCYCLE
C
    COMMON/BENCH1/ T,T2
    COMMON/BENCH2/ E1(4),J,K,L
C
C   INITIALIZE CONSTANTS
    T=0.499975
     T1=0.50025
    T2=2.0
C   COMPUTE EXECUTION FREQUENCIES FOR THE BENCHMARK MODULES
    N1=0
    N2=12*I
    N3=14*I
    N4=345*I
    N5=0
    N6=210*I
    N7=32*I
    N8=899*I
    N9=616*I
    N10=0
    N11=93*I
C
C   GET WHETSTONE START TIME FROM OPERATING SYSTEM
C
    TSTART=SECNDS(0.0)
C
    DO 1000 LCOUNT=1, KCYCLE
C
C   MODULE 1: SIMPLE IDENTIFIERS
C
      X1=1.0
      X2=-1.0
      X3=-1.0
      X4=-1.0
      DO 1 I=1,N1
        X1=(X1+X2+X3-X4)*T
        X2=(X1+X2-X3+X4)*T
        X3=(X1-X2+X3+X4)*T
        X4=(-X1+X2+X3+X4)*T
    1      CONTINUE
C
C   MODULE 2: ARRAY ELEMENTS
C
      E1(1)=1.0
      E1(2)=-1.0
      E1(3)=-1.0
      E1(4)=-1.0
      DO 2 I=1,N2
        E1(1)=(E1(1)+E1(2)+E1(3)-E1(4))*T
        E1(2)=(E1(1)+E1(2)-E1(3)+E1(4))*T
        E1(3)=(E1(1)-E1(2)+E1(3)+E1(4))*T
        E1(4)=(-E1(1)+E1(2)+E1(3)+E1(4))*T
    2      CONTINUE
C
C   MODULE 3: ARRAY AS PARAMETER
C
      DO 3 I=1,N3
        CALL PA(E1)
    3      CONTINUE
C
C   MODULE 4: CONDITIONAL JUMPS
C
      J=1
      DO 4 I=1,N4
        IF(J.EQ.1)THEN
          J=2
        ELSE
          J=3
        END IF
        IF(J.GT.2)THEN
          J=0
        ELSE
          J=1
        END IF
        IF(J.LT.1)THEN
          J=1
        ELSE
          J=0
        END IF
    4      CONTINUE
C
C   MODULE 5: OMITTED
C
C   MODULE 6: INTEGER ARITHMETIC
C
      J=1
      K=2
      L=3
      DO 6 I=1,N6
        J=J*(K-J)*(L-K)
        K=L*K-(L-J)*K
        L=(L-K)*(K+J)
        E1(L-1)=J+K+L
        E1(K-1)=J*K*L
    6      CONTINUE
C
C   MODULE 7: TRIGONOMETRIC FUNCTIONS
C
      X=0.5
      Y=0.5
      DO 7 I=1,N7
C   COMMENT OUT NEXT 2 LINES TO RUN BENCHMARK WITH MATH LIBRARY STUBBED OFF
        X=T*ATAN(T2*SIN(X)*COS(X)/(COS(X+Y)+COS(X-Y)-1.0))
        Y=T*ATAN(T2*SIN(Y)*COS(Y)/(COS(X+Y)+COS(X-Y)-1.0))
C
C   UNCOMMENT NEXT 2 LINES TO RUN BENCHMARK WITH MATH LIBRARY STUBBED OFF
C        X=T*MYSTUB(T2*MYSTUB(X)*MYSTUB(X)/(MYSTUB(X+Y)+MYSTUB(X-Y)-1.0))
C        Y=T*MYSTUB(T2*MYSTUB(Y)*MYSTUB(Y)/(MYSTUB(X+Y)+MYSTUB(X-Y)-1.0))
    7      CONTINUE
C
C   MODULE 8: PROCEDURE CALLS
C
      X=1.0
      Y=1.0
      Z=1.0
      DO 8 I=1,N8
        CALL P3(X,Y,Z)
    8      CONTINUE
C
C   MODULE 9: ARRAY REFERENCES
C
      J=1
      K=2
      L=3
      E1(1)=1.0
      E1(2)=2.0
      E1(3)=3.0
      DO 9 I=1,N9
        CALL P0
    9      CONTINUE
C
C   MODULE 10: INTEGER ARITHMETIC
C
      J=2
      K=3
      DO 10 I=1,N10
        J=J+K
        K=J+K
        J=K-J
        K=K-J-J
   10      CONTINUE
C
C   MODULE 11: STANDARD FUNCTIONS
C
      X=0.75
      DO 11 I=1,N11
C   COMMENT OUT NEXT LINE TO RUN BENCHMARK WITH MATH LIBRARY STUBBED OFF
        X=SQRT(EXP(ALOG(X)/T1))
C
C   UNCOMMENT NEXT LINE TO RUN BENCHMARK WITH MATH LIBRARY STUBBED OFF
C        X=MYSTUB(MYSTUB(MYSTUB(X)/T1))
   11      CONTINUE
C
 1000    CONTINUE
C
C   GET WHETSTONE STOP TIME FROM OPERATING SYSTEM
C
    TSTOP=SECNDS(0.0)
      RETURN
      END
C
C
C
      SUBROUTINE COMPUT
    REAL AVTIME,AVRATE,RATE,TSTART,TSTOP,DELTAT
    INTEGER NRUNS,LCOUNT,IRATE,KCYCLE,I
C
    OPEN(UNIT=21,FILE='WHETFORC.DAT',STATUS='NEW')
    WRITE(21,10)
    WRITE(6,10)
   10    FORMAT(1X,'FORTRAN77 Whetstone benchmark(MATH NOCHECK)',/)
C
    AVTIME=0.0
    AVRATE=0.0
    KCYCLE=10
    NRUNS=5
C
    DO 1000 LCOUNT=1, NRUNS
      I=10
      CALL WHET(I, KCYCLE, TSTART, TSTOP)
C
      WRITE(6,20)TSTART
      WRITE(21,20)TSTART
   20      FORMAT(1X,'Whetstone start time: ',F8.2,' seconds')
C
      WRITE(6,30)TSTOP
      WRITE(21,30)TSTOP
   30      FORMAT(1X,'Whetstone stop time: ',F8.2,' seconds')
C
C   COMPUTE AND WRITE THE ELAPSED TIME
C
      DELTAT=TSTOP-TSTART
      WRITE(6,40)KCYCLE, DELTAT
      WRITE(21,40)KCYCLE, DELTAT
   40      FORMAT(1X,'Elapsed time for ',I3,' cycles: ',F8.2,' seconds')
C
C   SUM TIME IN MILLISECONDS PER CYCLE
      AVTIME=AVTIME + (DELTAT*1000.0)/FLOAT(KCYCLE)
C
C   CALCULATE WHETSTONE RATING BASED ON TIME FOR NUMBER OF CYCLES JUST EXECUTED
C
      RATE=(1000.0*FLOAT(KCYCLE))/DELTAT
C   SUM WHETSTONE RATING
      AVRATE=AVRATE + RATE
      IRATE=NINT(RATE)
      WRITE(6,50)IRATE
      WRITE(21,50)IRATE
   50      FORMAT(1X,'Whetstone rating: ',I5,' KWIPS',/)
C
      KCYCLE=KCYCLE+10
 1000    CONTINUE
C
C   COMPUTE AVERAGE TIME IN MILLISECONDS PER CYCLE AND WRITE
C
    AVTIME=AVTIME/FLOAT(NRUNS)
    WRITE(6,60)AVTIME
    WRITE(21,60)AVTIME
   60    FORMAT(1X,'Average time per cycle: ',F8.2,' milliseconds')
C
C   CALCULATE AVERAGE WHETSTONE RATING AND WRITE
C
    AVRATE=AVRATE/FLOAT(NRUNS)
    IRATE=NINT(AVRATE)
    WRITE(6,70)IRATE
    WRITE(21,70)IRATE
   70    FORMAT (1X,'Average Whetstone rating: ',I5,' KWIPS')
    CLOSE(UNIT=21,STATUS='KEEP')
C
      RETURN
      END
--::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
--whetford.for
--::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
C   FILENAME: WHETFORD.FOR
C
      PROGRAM WHETFORD
C
C   FORTRAN77 VERSION OF WHETSTONE BENCHMARK PROGRAM.
C             (WITH MATH WITH CHECK)
C   REFERENCE: "COMPUTER JOURNAL," FEBRUARY 1976, PAGES 43-49,
C              FOR DESCRIPTION OF BENCHMARK AND ALGOL60 VERSION.
C   NOTE: PROCEDURE POUT IS OMITTED.
C
C   MAINLINE
C
    CALL COMPUT
      END
C
C   UNCOMMENT FOLLOWING FUNCTION TO RUN BENCHMARK WITH MATH LIBRARY STUBBED OFF
C
C     REAL FUNCTION MYSTUB(X)
C    REAL X
C    MYSTUB=1.0
C     RETURN
C     END
C
C
C
      SUBROUTINE PA(E)
    COMMON/BENCH1/ T,T2
    REAL E(4),T,T2
    INTEGER J
    J=0
    1    CONTINUE
      E(1)=(E(1)+E(2)+E(3)-E(4))*T
      E(2)=(E(1)+E(2)-E(3)+E(4))*T
      E(3)=(E(1)-E(2)+E(3)+E(4))*T
      E(4)=(-E(1)+E(2)+E(3)+E(4))/T2
      J=J+1
      IF(J.LT.6)GOTO 1
      RETURN
      END
C
C
C
      SUBROUTINE P0
    COMMON/BENCH2/ E1(4),J,K,L
    REAL E1
    INTEGER J,K,L
    E1(J)=E1(K)
    E1(K)=E1(L)
    E1(L)=E1(J)
      RETURN
      END
C
C
C
      SUBROUTINE P3(X,Y,Z)
    COMMON/BENCH1/ T,T2
    REAL X,Y,Z,T,T2
    X=T*(X+Y)
    Y=T*(X+Y)
    Z=(X+Y)/T2
      RETURN
      END
C
C
C
      SUBROUTINE WHET(I, KCYCLE, TSTART, TSTOP)
    REAL X1,X2,X3,X4,X,Y,Z,T,T1,T2,E1,TSTART,TSTOP,MYSTUB
    INTEGER I,J,K,L,N1,N2,N3,N4,N5,N6,N7,N8,N9,N10,N11,LCOUNT,KCYCLE
C
    COMMON/BENCH1/ T,T2
    COMMON/BENCH2/ E1(4),J,K,L
C
C   INITIALIZE CONSTANTS
    T=0.499975
     T1=0.50025
    T2=2.0
C   COMPUTE EXECUTION FREQUENCIES FOR THE BENCHMARK MODULES
    N1=0
    N2=12*I
    N3=14*I
    N4=345*I
    N5=0
    N6=210*I
    N7=32*I
    N8=899*I
    N9=616*I
    N10=0
    N11=93*I
C
C   GET WHETSTONE START TIME FROM OPERATING SYSTEM
C
    TSTART=SECNDS(0.0)
C
    DO 1000 LCOUNT=1, KCYCLE
C
C   MODULE 1: SIMPLE IDENTIFIERS
C
      X1=1.0
      X2=-1.0
      X3=-1.0
      X4=-1.0
      DO 1 I=1,N1
        X1=(X1+X2+X3-X4)*T
        X2=(X1+X2-X3+X4)*T
        X3=(X1-X2+X3+X4)*T
        X4=(-X1+X2+X3+X4)*T
    1      CONTINUE
C
C   MODULE 2: ARRAY ELEMENTS
C
      E1(1)=1.0
      E1(2)=-1.0
      E1(3)=-1.0
      E1(4)=-1.0
      DO 2 I=1,N2
        E1(1)=(E1(1)+E1(2)+E1(3)-E1(4))*T
        E1(2)=(E1(1)+E1(2)-E1(3)+E1(4))*T
        E1(3)=(E1(1)-E1(2)+E1(3)+E1(4))*T
        E1(4)=(-E1(1)+E1(2)+E1(3)+E1(4))*T
    2      CONTINUE
C
C   MODULE 3: ARRAY AS PARAMETER
C
      DO 3 I=1,N3
        CALL PA(E1)
    3      CONTINUE
C
C   MODULE 4: CONDITIONAL JUMPS
C
      J=1
      DO 4 I=1,N4
        IF(J.EQ.1)THEN
          J=2
        ELSE
          J=3
        END IF
        IF(J.GT.2)THEN
          J=0
        ELSE
          J=1
        END IF
        IF(J.LT.1)THEN
          J=1
        ELSE
          J=0
        END IF
    4      CONTINUE
C
C   MODULE 5: OMITTED
C
C   MODULE 6: INTEGER ARITHMETIC
C
      J=1
      K=2
      L=3
      DO 6 I=1,N6
        J=J*(K-J)*(L-K)
        K=L*K-(L-J)*K
        L=(L-K)*(K+J)
        E1(L-1)=J+K+L
        E1(K-1)=J*K*L
    6      CONTINUE
C
C   MODULE 7: TRIGONOMETRIC FUNCTIONS
C
      X=0.5
      Y=0.5
      DO 7 I=1,N7
C   COMMENT OUT NEXT 2 LINES TO RUN BENCHMARK WITH MATH LIBRARY STUBBED OFF
        X=T*ATAN(T2*SIN(X)*COS(X)/(COS(X+Y)+COS(X-Y)-1.0))
        Y=T*ATAN(T2*SIN(Y)*COS(Y)/(COS(X+Y)+COS(X-Y)-1.0))
C
C   UNCOMMENT NEXT 2 LINES TO RUN BENCHMARK WITH MATH LIBRARY STUBBED OFF
C        X=T*MYSTUB(T2*MYSTUB(X)*MYSTUB(X)/(MYSTUB(X+Y)+MYSTUB(X-Y)-1.0))
C        Y=T*MYSTUB(T2*MYSTUB(Y)*MYSTUB(Y)/(MYSTUB(X+Y)+MYSTUB(X-Y)-1.0))
    7      CONTINUE
C
C   MODULE 8: PROCEDURE CALLS
C
      X=1.0
      Y=1.0
      Z=1.0
      DO 8 I=1,N8
        CALL P3(X,Y,Z)
    8      CONTINUE
C
C   MODULE 9: ARRAY REFERENCES
C
      J=1
      K=2
      L=3
      E1(1)=1.0
      E1(2)=2.0
      E1(3)=3.0
      DO 9 I=1,N9
        CALL P0
    9      CONTINUE
C
C   MODULE 10: INTEGER ARITHMETIC
C
      J=2
      K=3
      DO 10 I=1,N10
        J=J+K
        K=J+K
        J=K-J
        K=K-J-J
   10      CONTINUE
C
C   MODULE 11: STANDARD FUNCTIONS
C
      X=0.75
      DO 11 I=1,N11
C   COMMENT OUT NEXT LINE TO RUN BENCHMARK WITH MATH LIBRARY STUBBED OFF
        X=SQRT(EXP(ALOG(X)/T1))
C
C   UNCOMMENT NEXT LINE TO RUN BENCHMARK WITH MATH LIBRARY STUBBED OFF
C        X=MYSTUB(MYSTUB(MYSTUB(X)/T1))
   11      CONTINUE
C
 1000    CONTINUE
C
C   GET WHETSTONE STOP TIME FROM OPERATING SYSTEM
C
    TSTOP=SECNDS(0.0)
      RETURN
      END
C
C
C
      SUBROUTINE COMPUT
    REAL AVTIME,AVRATE,RATE,TSTART,TSTOP,DELTAT
    INTEGER NRUNS,LCOUNT,IRATE,KCYCLE,I
C
    OPEN(UNIT=21,FILE='WHETFORD.DAT',STATUS='NEW')
    WRITE(21,10)
    WRITE(6,10)
   10    FORMAT(1X,'FORTRAN77 Whetstone benchmark(MATH CHECK)',/)
C
    AVTIME=0.0
    AVRATE=0.0
    KCYCLE=10
    NRUNS=5
C
    DO 1000 LCOUNT=1, NRUNS
      I=10
      CALL WHET(I, KCYCLE, TSTART, TSTOP)
C
      WRITE(6,20)TSTART
      WRITE(21,20)TSTART
   20      FORMAT(1X,'Whetstone start time: ',F8.2,' seconds')
C
      WRITE(6,30)TSTOP
      WRITE(21,30)TSTOP
   30      FORMAT(1X,'Whetstone stop time: ',F8.2,' seconds')
C
C   COMPUTE AND WRITE THE ELAPSED TIME
C
      DELTAT=TSTOP-TSTART
      WRITE(6,40)KCYCLE, DELTAT
      WRITE(21,40)KCYCLE, DELTAT
   40      FORMAT(1X,'Elapsed time for ',I3,' cycles: ',F8.2,' seconds')
C
C   SUM TIME IN MILLISECONDS PER CYCLE
      AVTIME=AVTIME + (DELTAT*1000.0)/FLOAT(KCYCLE)
C
C   CALCULATE WHETSTONE RATING BASED ON TIME FOR NUMBER OF CYCLES JUST EXECUTED
C
      RATE=(1000.0*FLOAT(KCYCLE))/DELTAT
C   SUM WHETSTONE RATING
      AVRATE=AVRATE + RATE
      IRATE=NINT(RATE)
      WRITE(6,50)IRATE
      WRITE(21,50)IRATE
   50      FORMAT(1X,'Whetstone rating: ',I5,' KWIPS',/)
C
      KCYCLE=KCYCLE+10
 1000    CONTINUE
C
C   COMPUTE AVERAGE TIME IN MILLISECONDS PER CYCLE AND WRITE
C
    AVTIME=AVTIME/FLOAT(NRUNS)
    WRITE(6,60)AVTIME
    WRITE(21,60)AVTIME
   60    FORMAT(1X,'Average time per cycle: ',F8.2,' milliseconds')
C
C   CALCULATE AVERAGE WHETSTONE RATING AND WRITE
C
    AVRATE=AVRATE/FLOAT(NRUNS)
    IRATE=NINT(AVRATE)
    WRITE(6,70)IRATE
    WRITE(21,70)IRATE
   70    FORMAT (1X,'Average Whetstone rating: ',I5,' KWIPS')
    CLOSE(UNIT=21,STATUS='KEEP')
C
      RETURN
      END
--::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
--whetca.c
--::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
/* Filename: WHETCA.C */

main()

  {
    /* C version of Whetstone Benchmark Program (with stubbed MATH lib) */
    /* Reference: "Computer Journal", February 1976, pages 43-49,       */
    /*            for description of benchmark and ALGOL60 version.     */
    /* Note     : Procedure POUT is omitted.                            */

    COMPUT();
  }
/*                                               */
/* Uncomment following function to run Benchmark */
/* with MATH library stubbed off                 */
/*                                               */

float MYSTUB(X)

float X;

  {
         return(1.0);
  }

PA(E)

  float E[4];

  {
    int J;
    extern float T,T2;

    J=0;

ONE:E[0]=(E[0]+E[1]+E[2]-E[3])*T;
    E[1]=(E[0]+E[1]-E[2]+E[3])*T;
    E[2]=(E[0]-E[1]+E[2]+E[3])*T;
    E[3]=(-E[0]+E[1]+E[2]+E[3])/T2;

    J=J+1;

    if (J<6) goto ONE;

  }

P0()

  {
    extern float E1[4];
    extern int J,K,L;

    E1[J]=E1[K];
    E1[K]=E1[L];
    E1[L]=E1[J];

  }

P3(X,Y,Z)

  float X,Y,Z;

  {

    extern float T,T2;

    X=T*(X+Y);
    Y=T*(X+Y);
    Z=(X+Y)/T2;

  }

#include timeb

WHET(I,KCYCLE,TSTART,TSTOP)

   double *TSTART,*TSTOP;
   int I,KCYCLE;
  {
    float X1,X2,X3,X4,X,Y,Z,T1;
    int   N1,N2,N3,N4,N5,N6,N7,N8,N9,N10,N11,LCOUNT;

    extern float T,T2,E1[4];
    extern int J,K,L;

    struct timeb *TIME_POINTER;/* timeb structure has the members            */
                               /* time_t  (gives time in seconds)            */
                               /* unsigned short millitm ( in milliseconds)  */
                               /* short time zone        (0)                 */
                               /* short dstflag          (0)                 */

    /*                    */
    /*  Initialize Constants            */
    /*                    */

    T=0.499975;
    T1=0.50025;
    T2=2.0;

    /*                          */
    /* Compute Execution Frequencies    */
    /* for the Benchmark Modules        */

    N1=0;
    N2=12*I;
    N3=14*I;
    N4=345*I;
    N5=0;
    N6=210*I;
    N7=32*I;
    N8=899*I;
    N9=616*I;
    N10=0;
    N11=93*I;

    /*                    */
    /*  Get Whetstone Start Time from   */
    /*          Operating System        */
    /*                                  */

    ftime(&TIME_POINTER);

    *TSTART=TIME_POINTER.time+TIME_POINTER.millitm/1000.0;

    for (LCOUNT=1;LCOUNT<=KCYCLE;LCOUNT++)
      {
         /*                              */
         /* Module 1: Simple Identifiers */
         /*                              */

         X1=1.0;
         X2=-1.0;
         X3=-1.0;
         X4=-1.0;
         for (I=1;I<=N1;I++)
           {
              X1=(X1+X2+X3-X4)*T;
              X2=(X1+X2-X3+X4)*T;
              X3=(X1-X2+X3+X4)*T;
              X4=(-X1+X2+X3+X4)*T;
           }

         /*                               */
         /*    Module 2: Array Elements   */
         /*       Note : Arrary Subscripts*/
         /*              in C begin       */
         /*              with 0.          */

         E1[0]=1.0;
         E1[1]=-1.0;
         E1[2]=-1.0;
         E1[3]=-1.0;

         for (I=1;I<=N2;I++)
           {
              E1[0]=(E1[0]+E1[1]+E1[2]-E1[3])*T;
              E1[1]=(E1[0]+E1[1]-E1[2]+E1[3])*T;
              E1[2]=(E1[0]-E1[1]+E1[2]+E1[3])*T;
              E1[3]=(-E1[0]+E1[1]+E1[2]+E1[3])*T;

           }

         /*                                */
         /*  Module 3: Array as Parameter  */
         /*                                */

         for (I=1;I<=N3;I++)
           {
             PA(E1);
           }

         /*                                */
         /*  Module 4: Conditional Jumps   */
         /*                                */

         J=1;

         for (I=1;I<=N4;I++)
           {
             if (J==1)
               J=2;
             else
               J=3;
             if (J>2)
               J=0;
             else
               J=1;
             if (J<1)
               J=1;
             else
               J=0;
            }

          /*                                */
          /*       Module 5 Omitted         */
          /*                                */

          /*                                */
          /*  Module 6: Integer Arithmetic  */
          /*                                */

          J=1;
          K=2;
          L=3;

          for (I=1;I<=N6;I++)
            {
              J=J*(K-J)*(L-K);
              K=L*K-(L-J)*K;
              L=(L-K)*(K+J);
              E1[L-1]=J+K+L;
              E1[K-1]=J*K*L;
            }

           /*                                     */
           /*  Module 7: Trigonometric Functions  */
           /*                                     */

           X=0.5;
           Y=0.5;

           for (I=1;I<=N7;I++)
             {
               /*                                 */
               /* Comment Out Next 2 Lines to Run */
               /*   Benchmark With Math Library   */
               /*          Stubbed Off            */

               /*X=T*ATAN(T2*SIN(X)*COS(X)/(COS(X+Y)+COS(X-Y)-1.0));*/
               /*Y=T*ATAN(T2*SIN(Y)*COS(Y)/(COS(X+Y)+COS(X-Y)-1.0));*/

               /*   Uncomment Next 2 Line to Run  */
               /*   Benchmark With Math Library   */
               /*          Stubbed Off            */

               X=T*MYSTUB(T2*MYSTUB(X)*MYSTUB(X)/(MYSTUB(X+Y)+MYSTUB(X-Y)-1.0));
               Y=T*MYSTUB(T2*MYSTUB(Y)*MYSTUB(Y)/(MYSTUB(X+Y)+MYSTUB(X-Y)-1.0));

              }

            /*                                    */
            /*     Module 8: Procedure Calls      */
            /*                                    */

            X=1.0;
            Y=1.0;
            Z=1.0;

            for (I=1;I<=N8;I++)
              {
                P3(X,Y,Z);
              }

            /*                                     */
            /*     Module 9: Array References      */
            /*                                     */

            J=0;
            K=1;
            L=2;

            E1[0]=1.0;
            E1[1]=2.0;
            E1[2]=3.0;

            for (I=1;I<=N9;I++)
              {
                P0();
              }

            /*                                      */
            /*     Module 10: Integer Arithmetic    */
            /*                                      */

            J=2;
            K=3;

            for (I=1;I<=N10;I++)
              {
                J=J+K;
                K=J+K;
                J=K-J;
                K=K-J-J;
              }

             /*                                      */
             /*     Module 11: Standard Functions    */
             /*                                      */

             X=0.75;

             for (I=1;I<=N11;I++)
               {

                 /*                                 */
                 /* Comment Out Next   Line  to Run */
                 /*   Benchmark With Math Library   */
                 /*          Stubbed Off            */

                 /*X=SQRT(EXP(LOG(X)/T1));          */

                 /*   Uncomment Next   Line to Run  */
                 /*   Benchmark With Math Library   */
                 /*          Stubbed Off            */

                 X=MYSTUB(MYSTUB(MYSTUB(X)/T1));
               }
      }

    /*                                        */
    /*  Get Whetstone Stop Time from Operating  */
    /*                        */

    ftime(&TIME_POINTER);
    *TSTOP=TIME_POINTER.time+TIME_POINTER.millitm/1000.0;

  }

#include stdio            /* standard I/O library*/

COMPUT()
    {
     float AVTIME,AVRATE,RATE;
     double TSTART,TSTOP;
     float DELTAT;
     int NRUNS,LCOUNT,IRATE,KCYCLE,I;

     int FILE_NAME;

     FILE *FP;

     FILE_NAME=creat("WHETCA.DAT");

     FP=fdopen(FILE_NAME,"rw");

     fprintf(FP,"C Whetstone Benchmark (with stubbed MATH lib)\n");
     printf("C Whetstone Benchmark (with stubbed MATH lib)\n");

     AVTIME = 0.0;
     AVRATE = 0.0;
     KCYCLE =10;
     NRUNS  = 5;
     I = 10;

     for ( LCOUNT=1; LCOUNT <= NRUNS; LCOUNT++)
       {
          WHET(I,KCYCLE,&TSTART,&TSTOP);

          printf("\nWhetstone start time: %8.2f Seconds",TSTART);
          fprintf(FP,"\nWhetstone start time: %8.2f Seconds",TSTART);

          printf("\nWhetstone stop time: %8.2f Seconds",TSTOP);
          fprintf(FP,"\nWhetstone stop time: %8.2f Seconds",TSTOP);

          /*                      */
          /*  Compute and Write the Elapsed Time  */
          /*                      */
          /*                                      */
          DELTAT = TSTOP - TSTART;

          printf("\nElapsed time for %3d cycles %8.2f seconds",KCYCLE,DELTAT);
          fprintf(FP,"\nElapsed time for %3d cycles %8.2f seconds",KCYCLE,
                     DELTAT);

          /*  Sum Time in Milliseconds per Cycle */

          AVTIME=AVTIME+(DELTAT*1000.0)/KCYCLE;

          /*                      */
          /*  Calculate Whetstone Rating Based on */
          /*  Time for Number of Cycles Just      */
          /*  Executed                   */

          RATE = (1000.0*KCYCLE)/DELTAT;

          /* Sum Whetstone Rating                 */

          AVRATE = AVRATE + RATE;
          IRATE  = RATE;

          printf("\nWhetstone rating: %5d KWIPS\n",IRATE);
          fprintf(FP,"\nWhetstone rating: %5d KWIPS\n",IRATE);

          KCYCLE=KCYCLE+10;

       }

     /*                        */
     /*  Compute Average Time in Milliseconds      */
     /*  Per Cycle and Write                       */
     /*                                            */

     AVTIME = AVTIME/NRUNS;

     printf("\nAverage Time Per Cycle: %8.2f Milliseconds",AVTIME);
     fprintf(FP,"\nAverage Time Per Cycle: %8.2f Milliseconds",AVTIME);

     /*                                  */
     /* Calculate Average Whetstone Rating and Write  */
     /*                           */

     AVRATE = AVRATE/NRUNS;
     IRATE  = AVRATE;

     printf("\nAverage Whetstone rating: %5d KWIPS",IRATE);
     fprintf(FP,"\nAverage Whetstone rating: %5d KWIPS",IRATE);

     fclose(FP);
    }
--::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
--whetcb.c
--::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
/* Filename: WHETCB.C */

main()

  {
    /* C version of Whetstone Benchmark Program (with MATH lib)    */
    /* Reference: "Computer Journal", February 1976, pages 43-49,  */
    /*            for description of benchmark and ALGOL60 version.*/
    /* Note     : Procedure POUT is omitted.                       */

    COMPUT();
  }
/*                                               */
/* Uncomment following function to run Benchmark */
/* with MATH library stubbed off                 */
/*                                               */

/*float MYSTUB(X)                                */

/*float X;                                       */

/* {                                             */
/*         return(1.0);                          */
/*  }                                            */

PA(E)

  float E[4];

  {
    int J;
    extern float T,T2;

    J=0;

ONE:E[0]=(E[0]+E[1]+E[2]-E[3])*T;
    E[1]=(E[0]+E[1]-E[2]+E[3])*T;
    E[2]=(E[0]-E[1]+E[2]+E[3])*T;
    E[3]=(-E[0]+E[1]+E[2]+E[3])/T2;

    J=J+1;

    if (J<6) goto ONE;

  }

P0()

  {
    extern float E1[4];
    extern int J,K,L;

    E1[J]=E1[K];
    E1[K]=E1[L];
    E1[L]=E1[J];

  }

P3(X,Y,Z)

  float X,Y,Z;

  {

    extern float T,T2;

    X=T*(X+Y);
    Y=T*(X+Y);
    Z=(X+Y)/T2;

  }

#include timeb

WHET(I,KCYCLE,TSTART,TSTOP)

   double *TSTART,*TSTOP;
   int I,KCYCLE;
  {
    float X1,X2,X3,X4,X,Y,Z,T1;
    int   N1,N2,N3,N4,N5,N6,N7,N8,N9,N10,N11,LCOUNT;

    extern float T,T2,E1[4];
    extern int J,K,L;

    struct timeb *TIME_POINTER;/* timeb structure has the members            */
                               /* time_t  (gives time in seconds)            */
                               /* unsigned short millitm ( in milliseconds)  */
                               /* short time zone        (0)                 */
                               /* short dstflag          (0)                 */

    /*                    */
    /*  Initialize Constants            */
    /*                    */

    T=0.499975;
    T1=0.50025;
    T2=2.0;

    /*                          */
    /* Compute Execution Frequencies    */
    /* for the Benchmark Modules        */

    N1=0;
    N2=12*I;
    N3=14*I;
    N4=345*I;
    N5=0;
    N6=210*I;
    N7=32*I;
    N8=899*I;
    N9=616*I;
    N10=0;
    N11=93*I;

    /*                    */
    /*  Get Whetstone Start Time from   */
    /*          Operating System        */
    /*                                  */

    ftime(&TIME_POINTER);

    *TSTART=TIME_POINTER.time+TIME_POINTER.millitm/1000.0;

    for (LCOUNT=1;LCOUNT<=KCYCLE;LCOUNT++)
      {
         /*                              */
         /* Module 1: Simple Identifiers */
         /*                              */

         X1=1.0;
         X2=-1.0;
         X3=-1.0;
         X4=-1.0;
         for (I=1;I<=N1;I++)
           {
              X1=(X1+X2+X3-X4)*T;
              X2=(X1+X2-X3+X4)*T;
              X3=(X1-X2+X3+X4)*T;
              X4=(-X1+X2+X3+X4)*T;
           }

         /*                               */
         /*    Module 2: Array Elements   */
         /*       Note : Arrary Subscripts*/
         /*              in C begin       */
         /*              with 0.          */

         E1[0]=1.0;
         E1[1]=-1.0;
         E1[2]=-1.0;
         E1[3]=-1.0;

         for (I=1;I<=N2;I++)
           {
              E1[0]=(E1[0]+E1[1]+E1[2]-E1[3])*T;
              E1[1]=(E1[0]+E1[1]-E1[2]+E1[3])*T;
              E1[2]=(E1[0]-E1[1]+E1[2]+E1[3])*T;
              E1[3]=(-E1[0]+E1[1]+E1[2]+E1[3])*T;

           }

         /*                                */
         /*  Module 3: Array as Parameter  */
         /*                                */

         for (I=1;I<=N3;I++)
           {
             PA(E1);
           }

         /*                                */
         /*  Module 4: Conditional Jumps   */
         /*                                */

         J=1;

         for (I=1;I<=N4;I++)
           {
             if (J==1)
               J=2;
             else
               J=3;
             if (J>2)
               J=0;
             else
               J=1;
             if (J<1)
               J=1;
             else
               J=0;
            }

          /*                                */
          /*       Module 5 Omitted         */
          /*                                */

          /*                                */
          /*  Module 6: Integer Arithmetic  */
          /*                                */

          J=1;
          K=2;
          L=3;

          for (I=1;I<=N6;I++)
            {
              J=J*(K-J)*(L-K);
              K=L*K-(L-J)*K;
              L=(L-K)*(K+J);
              E1[L-1]=J+K+L;
              E1[K-1]=J*K*L;
            }

           /*                                     */
           /*  Module 7: Trigonometric Functions  */
           /*                                     */

           X=0.5;
           Y=0.5;

           for (I=1;I<=N7;I++)
             {
               /*                                 */
               /* Comment Out Next 2 Lines to Run */
               /*   Benchmark With Math Library   */
               /*          Stubbed Off            */

               X=T*ATAN(T2*SIN(X)*COS(X)/(COS(X+Y)+COS(X-Y)-1.0));
               Y=T*ATAN(T2*SIN(Y)*COS(Y)/(COS(X+Y)+COS(X-Y)-1.0));

               /*   Uncomment Next 2 Line to Run  */
               /*   Benchmark With Math Library   */
               /*          Stubbed Off            */

               /*X=T*MYSTUB(T2*MYSTUB(X)*MYSTUB(X)/(MYSTUB(X+Y)+MYSTUB(X-Y)-1.0));*/
               /*Y=T*MYSTUB(T2*MYSTUB(Y)*MYSTUB(Y)/(MYSTUB(X+Y)+MYSTUB(X-Y)-1.0));*/

              }

            /*                                    */
            /*     Module 8: Procedure Calls      */
            /*                                    */

            X=1.0;
            Y=1.0;
            Z=1.0;

            for (I=1;I<=N8;I++)
              {
                P3(X,Y,Z);
              }

            /*                                     */
            /*     Module 9: Array References      */
            /*                                     */

            J=0;
            K=1;
            L=2;

            E1[0]=1.0;
            E1[1]=2.0;
            E1[2]=3.0;

            for (I=1;I<=N9;I++)
              {
                P0();
              }

            /*                                      */
            /*     Module 10: Integer Arithmetic    */
            /*                                      */

            J=2;
            K=3;

            for (I=1;I<=N10;I++)
              {
                J=J+K;
                K=J+K;
                J=K-J;
                K=K-J-J;
              }

             /*                                      */
             /*     Module 11: Standard Functions    */
             /*                                      */

             X=0.75;

             for (I=1;I<=N11;I++)
               {

                 /*                                 */
                 /* Comment Out Next   Line  to Run */
                 /*   Benchmark With Math Library   */
                 /*          Stubbed Off            */

                 X=SQRT(EXP(LOG(X)/T1));

                 /*   Uncomment Next   Line to Run  */
                 /*   Benchmark With Math Library   */
                 /*          Stubbed Off            */

                 /*X=MYSTUB(MYSTUB(MYSTUB(X)/T1));  */
               }
      }

    /*                                        */
    /*  Get Whetstone Stop Time from Operating  */
    /*                        */

    ftime(&TIME_POINTER);
    *TSTOP=TIME_POINTER.time+TIME_POINTER.millitm/1000.0;

  }

#include stdio            /* standard I/O library*/

COMPUT()
    {
     float AVTIME,AVRATE,RATE;
     double TSTART,TSTOP;
     float DELTAT;
     int NRUNS,LCOUNT,IRATE,KCYCLE,I;

     int FILE_NAME;

     FILE *FP;

     FILE_NAME=creat("WHETCB.DAT");

     FP=fdopen(FILE_NAME,"rw");

     fprintf(FP,"C Whetstone Benchmark (with MATH lib)\n");
     printf("C Whetstone Benchmark (with MATH lib)\n");

     AVTIME = 0.0;
     AVRATE = 0.0;
     KCYCLE =10;
     NRUNS  = 5;
     I = 10;

     for ( LCOUNT=1; LCOUNT <= NRUNS; LCOUNT++)
       {
          WHET(I,KCYCLE,&TSTART,&TSTOP);

          printf("\nWhetstone start time: %8.2f Seconds",TSTART);
          fprintf(FP,"\nWhetstone start time: %8.2f Seconds",TSTART);

          printf("\nWhetstone stop time: %8.2f Seconds",TSTOP);
          fprintf(FP,"\nWhetstone stop time: %8.2f Seconds",TSTOP);

          /*                      */
          /*  Compute and Write the Elapsed Time  */
          /*                      */
          /*                                      */
          DELTAT = TSTOP - TSTART;

          printf("\nElapsed time for %3d cycles %8.2f seconds",KCYCLE,DELTAT);
          fprintf(FP,"\nElapsed time for %3d cycles %8.2f seconds",KCYCLE,
                     DELTAT);

          /*  Sum Time in Milliseconds per Cycle */

          AVTIME=AVTIME+(DELTAT*1000.0)/KCYCLE;

          /*                      */
          /*  Calculate Whetstone Rating Based on */
          /*  Time for Number of Cycles Just      */
          /*  Executed                   */

          RATE = (1000.0*KCYCLE)/DELTAT;

          /* Sum Whetstone Rating                 */

          AVRATE = AVRATE + RATE;
          IRATE  = RATE;

          printf("\nWhetstone rating: %5d KWIPS\n",IRATE);
          fprintf(FP,"\nWhetstone rating: %5d KWIPS\n",IRATE);

          KCYCLE=KCYCLE+10;

       }

     /*                        */
     /*  Compute Average Time in Milliseconds      */
     /*  Per Cycle and Write                       */
     /*                                            */

     AVTIME = AVTIME/NRUNS;

     printf("\nAverage Time Per Cycle: %8.2f Milliseconds",AVTIME);
     fprintf(FP,"\nAverage Time Per Cycle: %8.2f Milliseconds",AVTIME);

     /*                                  */
     /* Calculate Average Whetstone Rating and Write  */
     /*                           */

     AVRATE = AVRATE/NRUNS;
     IRATE  = AVRATE;

     printf("\nAverage Whetstone rating: %5d KWIPS",IRATE);
     fprintf(FP,"\nAverage Whetstone rating: %5d KWIPS",IRATE);

     fclose(FP);
    }