home *** CD-ROM | disk | FTP | other *** search
/ Microsoft Programmer's Library 1.3 / Microsoft-Programers-Library-v1.3.iso / sampcode / fortran / swhet.for < prev    next >
Encoding:
Text File  |  1988-08-11  |  12.0 KB  |  378 lines
  1. CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
  2. C
  3. C       "WHETSTONE INSTRUCTIONS PER SECONDS" MEASURE OF FORTRAN
  4. C       AND CPU PERFORMANCE.
  5. C
  6. C         References on Whetstones:    Computer Journal Feb 76
  7. C                                      pg 43-49 vol 19 no 1.
  8. C                                      Curnow and Wichman.
  9. C
  10. C                                      and Timing Studies using a
  11. C                                      synthetic Whetstone Benchmark
  12. C                                      S. Harbaugh & J. Forakris
  13. C
  14. C         References on FORTRAN Benchmarks:
  15. C
  16. C                                   -  Computer Languages, Jan 1986
  17. C                                   -  EDN, Oct 3, 1985, Array Processors
  18. C                                           for PCs
  19. C                                   -  Byte, Feb 1984.
  20. C                                                         
  21. C       03/03/87
  22. C          Seeing that Microsoft distributed this without
  23. C          shipping the commented version, the timing loop 
  24. C          was reworked to eliminate all do loops and to put
  25. C          in code to print the variation in the measurment to
  26. C          make it more cook-book.  The 3 loop method described
  27. C          below was eliminated because it caused confusion.
  28. C          The printout was grouped and placed at the end of the test
  29. C          so that the outputs could be checked.  
  30. C          although it is ugly code, it checks with the Ada version
  31. C          and original article.          
  32. C          Because the Whetstones are printed as a reciprical,
  33. C          you can not average Whetstones to reduce time errors,
  34. C          you must run it multiple times and accumulate time.
  35. C          (AKT)
  36. C          
  37. C
  38. C       01/01/87
  39. C          fixed second subroutine to return seconds, not centi
  40. C          seconds and used double precision variables. (AKT)
  41. C   
  42. C       12/15/86
  43. C          Modified by Microsoft, removed reading in loop 
  44. C          option, added timer routine, removed meta-commands
  45. C          on large model.  Changed default looping from 100 to 10.
  46. C
  47. C       9/24/84
  48. C 
  49. C          ADDED CODE TO THESE SO THAT IT HAS VARIABLE LOOPING
  50. C
  51. C          from DEC but DONE BY OUTSIDE CONTRACTOR, OLD STYLE CODING
  52. C          not representative of DEC coding 
  53. C   
  54. C          A. TETEWSKY, c/o 
  55. C          555 TECH SQ MS 92 
  56. C          CAMBRIDGE MASS 02139           617/258-1287
  57. C 
  58. C          benchmarking notes:   1)    insure that timer has
  59. C                                      sufficient resolution and
  60. C                                      uses elapsed CPU time
  61. C
  62. C                                2)    to be useful for mainframe
  63. C                                      comparisons, measure
  64. C                                      INTEGER*4 time and large
  65. C                                      memory model or quote
  66. C                                      both large and small model
  67. C                                      times.  It may be necessary
  68. C                                      to make the arrays in this
  69. C                                      program large enough to span
  70. C                                      a 64K byte boundary because
  71. C                                      many micro compilers will
  72. C                                      generate small model code
  73. C                                      for small arrays even with 
  74. C                                      large models.
  75. C
  76. C                                 3)   Make sure that it loops
  77. C                                      long enough to gain
  78. C                                      stability, i.e. third-second
  79. C                                      loop = first loop time.
  80. C
  81. C         research notes,
  82. C         structure and definition:
  83. C         I received this code as a black box and based on some
  84. C         study, discovered the following background.
  85. C
  86. C            n1-n10 are loop counters for 10 tests, and tests
  87. C            n1,n5, and n10 are skipped.
  88. C            computed goto's are used to skip over tests that
  89. C            are not wanted.
  90. C     
  91. C
  92. C            n1-n10 scale with I.   When I is set to 10,
  93. C            kilo whets per second = 1000/ (time for doing n1-n10),
  94. C            the definition found in the literature.
  95. C
  96. C            If I were 100, the scale factor would be 10,000.
  97. C            which explains the 10,000 discovered in this code because
  98. C            it was shipped with IMUCH wired to 100.
  99. C
  100. C            the original DEC version uses a do-loop, 
  101. C                  imuch=100
  102. C                  do 200 loop=1,3
  103. C                       i = loop*imuch
  104. C                       n1-n10 scales by I
  105. C                       ... whetstones here ...
  106. C              200 continue
  107. C 
  108. C            and it took me a while to figure out why it worked.
  109. C
  110. C            This code loops three times 
  111. C                 TIMES(1) is time for 1*I  whets
  112. C                 TIMES(2) is time for 2*I
  113. C                 TIMES(3) is time for 3*I
  114. C            and TIMES(3)-TIMES(2) =  time for 1*I. 
  115. C            As long as TIMES(3)-TIMES(2) =  TIMES(1) to
  116. C            4 digits, then the cycle counter is sufficiently
  117. C            large enough for a given clock resolution.
  118. C
  119. C            By scaling whets * (IMUCH/10), you can alter IMUCH.
  120. C            The default definition is IMUCH = 10, hence the factor
  121. C            is unity.  IMUCH should be a factor of 10.
  122. C
  123. C
  124. C            Problems I have found:
  125. C            -  the SECONDS function is a single precision number
  126. C               and as CPUs get faster, you need to loop longer
  127. C               so that significant digits are not dropped.
  128. C
  129. C
  130. C       WHETS.FOR       09/27/77     TDR
  131. C       ...WHICH IS AN IMPROVED VERSION OF:
  132. C       WHET2A.FTN      01/22/75     RBG
  133. C
  134. CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
  135.         REAL      X1,X2,X3,X4,X,Y,Z,T,T1,T2,E1
  136.         INTEGER   J,K,L,I, N1,N2,N3,N4,N5,N6,N7,N8,N9,N10,N11,ISAVE
  137.         COMMON    T,T1,T2,E1(4),J,K,L
  138. C
  139. C
  140.         REAL*8         BEGTIM, ENDTIM, DIFTIM
  141.         REAL*8         DT,  WHETS, WS, ERR, WERR, PERR
  142.         INTEGER*4      IO1, IO1L, KREP, MKREP
  143. C
  144.         REAL*4         SECNDS
  145.         EXTERNAL       SECNDS
  146. C
  147. C****************************************************************
  148. C                         
  149. C                                            
  150.         MKREP  =    2
  151.         KREP   =    0
  152.         WRITE(*,*) ' Suggest inner > 10, outer > 1 '
  153.         WRITE(*,*) ' ENTER the number of inner/outer loops  ' 
  154.         READ(*,*)  I  ,IO1 
  155.  7020   CONTINUE
  156.         WRITE(*,*) ' Starting ',IO1,' loops, inner loop = ',I  
  157. C       ***** BEGININNING OF TIMED INTERVAL *****
  158.         IO1L   = 0
  159.         BEGTIM = DBLE(SECNDS(0.0E+00) )
  160.  7010   CONTINUE
  161. C
  162. C       ... the Whetstone code here ...
  163. C
  164.         T=0.499975E00
  165.         T1=0.50025E00
  166.         T2=2.0E00
  167. C
  168.         ISAVE=I
  169.         N1=0
  170.         N2=12*I
  171.         N3=14*I
  172.         N4=345*I
  173.         N5=0
  174.         N6=210*I
  175.         N7=32*I
  176.         N8=899*I
  177.         N9=616*I
  178.         N10=0
  179.         N11=93*I
  180.         N12=0
  181.         X1=1.0E0
  182.         X2=-1.0E0
  183.         X3=-1.0E0
  184.         X4=-1.0E0
  185.         IF(N1)19,19,11
  186.  11     DO 18 I=1,N1,1
  187.         X1=(X1+X2+X3-X4)*T
  188.         X2=(X1+X2-X3+X4)*T
  189.         X4=(-X1+X2+X3+X4)*T
  190.         X3=(X1-X2+X3+X4)*T
  191.  18     CONTINUE
  192.  19     CONTINUE
  193.         E1(1)=1.0E0
  194.         E1(2)=-1.0E0
  195.         E1(3)=-1.0E0
  196.         E1(4)=-1.0E0
  197.         IF(N2)29,29,21
  198.  21     DO 28 I=1,N2,1
  199.         E1(1)=(E1(1)+E1(2)+E1(3)-E1(4))*T
  200.         E1(2)=(E1(1)+E1(2)-E1(3)+E1(4))*T
  201.         E1(3)=(E1(1)-E1(2)+E1(3)+E1(4))*T
  202.         E1(4)=(-E1(1)+E1(2)+E1(3)+E1(4))*T
  203.  28     CONTINUE
  204.  29     CONTINUE
  205.         IF(N3)39,39,31
  206.  31     DO 38 I=1,N3,1
  207.  38     CALL PA(E1)
  208.  39     CONTINUE
  209.         J=1
  210.         IF(N4)49,49,41
  211.  41     DO 48 I=1,N4,1
  212.         IF(J-1)43,42,43
  213.  42     J=2
  214.         GOTO44
  215.  43     J=3
  216.  44     IF(J-2)46,46,45
  217.  45     J=0
  218.         GOTO47
  219.  46     J=1
  220.  47     IF(J-1)411,412,412
  221.  411    J=1
  222.         GOTO48
  223.  412    J=0
  224.  48     CONTINUE
  225.  49     CONTINUE
  226.         J=1
  227.         K=2
  228.         L=3
  229.         IF(N6)69,69,61
  230.  61     DO 68 I=1,N6,1
  231.         J=J*(K-J)*(L-K)
  232.         K=L*K-(L-J)*K
  233.         L=(L-K)*(K+J)
  234.         E1(L-1)=J+K+L
  235.         E1(K-1)=J*K*L
  236.  68     CONTINUE
  237.  69     CONTINUE
  238.         X=0.5E0
  239.         Y=0.5E0
  240.         IF(N7)79,79,71
  241.  71     DO 78 I=1,N7,1
  242.         X=T*ATAN(T2*SIN(X)*COS(X)/(COS(X+Y)+COS(X-Y)-1.0E0))
  243.         Y=T*ATAN(T2*SIN(Y)*COS(Y)/(COS(X+Y)+COS(X-Y)-1.0E0))
  244.  78     CONTINUE
  245.  79     CONTINUE
  246.         X=1.0E0
  247.         Y=1.0E0
  248.         Z=1.0E0
  249.         IF(N8)89,89,81
  250.  81     DO 88 I=1,N8,1
  251.  88     CALL P3(X,Y,Z)
  252.  89     CONTINUE
  253.         J=1
  254.         K=2
  255.         L=3
  256.         E1(1)=1.0E0
  257.         E1(2)=2.0E0
  258.         E1(3)=3.0E0
  259.         IF(N9)99,99,91
  260.  91     DO 98 I=1,N9,1
  261.  98     CALL P0
  262.  99     CONTINUE
  263.         J=2
  264.         K=3
  265.         IF(N10)109,109,101
  266.  101    DO 108 I=1,N10,1
  267.         J=J+K
  268.         K=J+K
  269.         J=J-K
  270.         K=K-J-J
  271.  108    CONTINUE
  272.  109    CONTINUE
  273.         X=0.75E0
  274.         IF(N11)119,119,111
  275.  111    DO 118 I=1,N11,1
  276.  118    X=SQRT(EXP(ALOG(X)/T1))
  277.  119    CONTINUE
  278.         I = ISAVE 
  279. C
  280. C       ... the whetstone ends here
  281. C
  282. C         ... loop counter instead of do loop ...
  283.           IO1L = IO1L + 1
  284.           IF( IO1L .LT. IO1) GOTO 7010
  285. C       ******* END of TIME INTERVALED ***********
  286. C
  287.         ENDTIM = DBLE(SECNDS(0.0E+00))
  288.         DIFTIM = ENDTIM - BEGTIM
  289. C       whets  = 1000/(TIME FOR 10 inner ITERATIONS OF PROGRAM LOOP)
  290. C       or 100 for every 1 inner count
  291.         WHETS = (100.0D+00* DBLE( FLOAT(IO1*I  ))/DIFTIM)
  292.         WRITE(*,*) ' START TIME = ',BEGTIM
  293.         WRITE(*,*) ' END   TIME = ',ENDTIM
  294.         WRITE(*,*) ' DIF   TIME = ',DIFTIM
  295. C
  296.         WRITE (*,201) WHETS
  297.   201   FORMAT(' SPEED IS: ',1PE10.3,' THOUSAND WHETSTONE',
  298.      2     ' SINGLE PRECISION INSTRUCTIONS PER SECOND')
  299.         CALL POUT(N1,N1,N1,X1,X2,X3,X4)
  300.         CALL POUT(N2,N3,N2,E1(1),E1(2),E1(3),E1(4))
  301.         CALL POUT(N3,N2,N2,E1(1),E1(2),E1(3),E1(4))
  302.         CALL POUT(N4,J,J,X1,X2,X3,X4)
  303.         CALL POUT(N6,J,K,E1(1),E1(2),E1(3),E1(4))
  304.         CALL POUT(N7,J,K,X,X,Y,Y)
  305.         CALL POUT(N8,J,K,X,Y,Z,Z)
  306.         CALL POUT(N9,J,K,E1(1),E1(2),E1(3),E1(4))
  307.         CALL POUT(N10,J,K,X1,X2,X3,X4)
  308.         CALL POUT(N11,J,K,X,X,X,X)
  309. C
  310. C
  311. C       ... repeat but double (MULTIPLY UP) inner count ...
  312.         KREP = KREP + 1
  313.         IF( KREP .LT. MKREP) THEN
  314.             DT     = DIFTIM
  315.             WT     = WHETS
  316.             I=I*MKREP
  317.             GOTO 7020
  318.         ENDIF
  319. C
  320. C       ... compute sensitivity  
  321. C
  322.         ERR =  DIFTIM - (DT*DBLE(FLOAT(MKREP)))    
  323.         WERR=  WT-WHETS          
  324.         PERR=  WERR*100.0D+00/WHETS
  325.         WRITE(*,*) ' Time ERR = ',ERR, ' seconds '
  326.         WRITE(*,*) ' Whet ERR = ',WERR,' kwhets/sec '
  327.         WRITE(*,*) ' %    ERR = ',PERR,' % whet error '
  328.         IF( DIFTIM .LT. 10.0D+00) THEN
  329.          WRITE(*,*)
  330.      1   ' TIME is less than 10 seconds, suggest larger inner loop '
  331.         ENDIF
  332. C
  333.         STOP
  334.         END
  335. C
  336.         SUBROUTINE PA(E)
  337. CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
  338. C
  339.         COMMON T,T1,T2
  340.         DIMENSION E(4)
  341.         J=0
  342.  1      E(1)=(E(1)+E(2)+E(3)-E(4))*T
  343.         E(2)=(E(1)+E(2)-E(3)+E(4))*T
  344.         E(3)=(E(1)-E(2)+E(3)+E(4))*T
  345.         E(4)=(-E(1)+E(2)+E(3)+E(4))/T2
  346.         J=J+1
  347.         IF(J-6)1,2,2
  348.  2      CONTINUE
  349.         RETURN
  350.         END
  351.         SUBROUTINE P0
  352. CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
  353. C
  354.         COMMON T,T1,T2,E1(4),J,K,L
  355.         E1(J)=E1(K)
  356.         E1(K)=E1(L)
  357.         E1(L)=E1(J)
  358.         RETURN
  359.         END
  360.         SUBROUTINE P3(X,Y,Z)
  361. CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
  362. C
  363.         COMMON T,T1,T2
  364.         X1=X
  365.         Y1=Y
  366.         X1=T*(X1+Y1)
  367.         Y1=T*(X1+Y1)
  368.         Z=(X1+Y1)/T2
  369.         RETURN
  370.         END
  371.         SUBROUTINE POUT(N,J,K,X1,X2,X3,X4)
  372. CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
  373. C
  374.         WRITE(*,1)N,J,K,X1,X2,X3,X4
  375.  1      FORMAT(1H,3(I7,1X),4(1PE12.4,1X))
  376.         RETURN
  377.         END
  378.