1 #! /usr/bin/env python

     2 

     3 """

     4 "PYSTONE" Benchmark Program

     5 

     6 Version:        Python/1.1 (corresponds to C/1.1 plus 2 Pystone fixes)

     7 

     8 Author:         Reinhold P. Weicker,  CACM Vol 27, No 10, 10/84 pg. 1013.

     9 

    10                 Translated from ADA to C by Rick Richardson.

    11                 Every method to preserve ADA-likeness has been used,

    12                 at the expense of C-ness.

    13 

    14                 Translated from C to Python by Guido van Rossum.

    15 

    16 Version History:

    17 

    18                 Version 1.1 corrects two bugs in version 1.0:

    19 

    20                 First, it leaked memory: in Proc1(), NextRecord ends

    21                 up having a pointer to itself.  I have corrected this

    22                 by zapping NextRecord.PtrComp at the end of Proc1().

    23 

    24                 Second, Proc3() used the operator != to compare a

    25                 record to None.  This is rather inefficient and not

    26                 true to the intention of the original benchmark (where

    27                 a pointer comparison to None is intended; the !=

    28                 operator attempts to find a method __cmp__ to do value

    29                 comparison of the record).  Version 1.1 runs 5-10

    30                 percent faster than version 1.0, so benchmark figures

    31                 of different versions can't be compared directly.

    32 

    33 """

    34 

    35 LOOPS = 50000

    36 

    37 from time import clock

    38 

    39 __version__ = "1.1"

    40 

    41 [Ident1, Ident2, Ident3, Ident4, Ident5] = range(1, 6)

    42 

    43 class Record:

    44 

    45     def __init__(self, PtrComp = None, Discr = 0, EnumComp = 0,

    46                        IntComp = 0, StringComp = 0):

    47         self.PtrComp = PtrComp

    48         self.Discr = Discr

    49         self.EnumComp = EnumComp

    50         self.IntComp = IntComp

    51         self.StringComp = StringComp

    52 

    53     def copy(self):

    54         return Record(self.PtrComp, self.Discr, self.EnumComp,

    55                       self.IntComp, self.StringComp)

    56 

    57 TRUE = 1

    58 FALSE = 0

    59 

    60 def main(loops=LOOPS):

    61     benchtime, stones = pystones(loops)

    62     print "Pystone(%s) time for %d passes = %g" % \

    63           (__version__, loops, benchtime)

    64     print "This machine benchmarks at %g pystones/second" % stones

    65 

    66 

    67 def pystones(loops=LOOPS):

    68     return Proc0(loops)

    69 

    70 IntGlob = 0

    71 BoolGlob = FALSE

    72 Char1Glob = '\0'

    73 Char2Glob = '\0'

    74 Array1Glob = [0]*51

    75 Array2Glob = map(lambda x: x[:], [Array1Glob]*51)

    76 PtrGlb = None

    77 PtrGlbNext = None

    78 

    79 def Proc0(loops=LOOPS):

    80     global IntGlob

    81     global BoolGlob

    82     global Char1Glob

    83     global Char2Glob

    84     global Array1Glob

    85     global Array2Glob

    86     global PtrGlb

    87     global PtrGlbNext

    88 

    89     starttime = clock()

    90     for i in range(loops):

    91         pass

    92     nulltime = clock() - starttime

    93 

    94     PtrGlbNext = Record()

    95     PtrGlb = Record()

    96     PtrGlb.PtrComp = PtrGlbNext

    97     PtrGlb.Discr = Ident1

    98     PtrGlb.EnumComp = Ident3

    99     PtrGlb.IntComp = 40

   100     PtrGlb.StringComp = "DHRYSTONE PROGRAM, SOME STRING"

   101     String1Loc = "DHRYSTONE PROGRAM, 1'ST STRING"

   102     Array2Glob[8][7] = 10

   103 

   104     starttime = clock()

   105 

   106     for i in range(loops):

   107         Proc5()

   108         Proc4()

   109         IntLoc1 = 2

   110         IntLoc2 = 3

   111         String2Loc = "DHRYSTONE PROGRAM, 2'ND STRING"

   112         EnumLoc = Ident2

   113         BoolGlob = not Func2(String1Loc, String2Loc)

   114         while IntLoc1 < IntLoc2:

   115             IntLoc3 = 5 * IntLoc1 - IntLoc2

   116             IntLoc3 = Proc7(IntLoc1, IntLoc2)

   117             IntLoc1 = IntLoc1 + 1

   118         Proc8(Array1Glob, Array2Glob, IntLoc1, IntLoc3)

   119         PtrGlb = Proc1(PtrGlb)

   120         CharIndex = 'A'

   121         while CharIndex <= Char2Glob:

   122             if EnumLoc == Func1(CharIndex, 'C'):

   123                 EnumLoc = Proc6(Ident1)

   124             CharIndex = chr(ord(CharIndex)+1)

   125         IntLoc3 = IntLoc2 * IntLoc1

   126         IntLoc2 = IntLoc3 / IntLoc1

   127         IntLoc2 = 7 * (IntLoc3 - IntLoc2) - IntLoc1

   128         IntLoc1 = Proc2(IntLoc1)

   129 

   130     benchtime = clock() - starttime - nulltime

   131     if benchtime == 0.0:

   132         loopsPerBenchtime = 0.0

   133     else:

   134         loopsPerBenchtime = (loops / benchtime)

   135     return benchtime, loopsPerBenchtime

   136 

   137 def Proc1(PtrParIn):

   138     PtrParIn.PtrComp = NextRecord = PtrGlb.copy()

   139     PtrParIn.IntComp = 5

   140     NextRecord.IntComp = PtrParIn.IntComp

   141     NextRecord.PtrComp = PtrParIn.PtrComp

   142     NextRecord.PtrComp = Proc3(NextRecord.PtrComp)

   143     if NextRecord.Discr == Ident1:

   144         NextRecord.IntComp = 6

   145         NextRecord.EnumComp = Proc6(PtrParIn.EnumComp)

   146         NextRecord.PtrComp = PtrGlb.PtrComp

   147         NextRecord.IntComp = Proc7(NextRecord.IntComp, 10)

   148     else:

   149         PtrParIn = NextRecord.copy()

   150     NextRecord.PtrComp = None

   151     return PtrParIn

   152 

   153 def Proc2(IntParIO):

   154     IntLoc = IntParIO + 10

   155     while 1:

   156         if Char1Glob == 'A':

   157             IntLoc = IntLoc - 1

   158             IntParIO = IntLoc - IntGlob

   159             EnumLoc = Ident1

   160         if EnumLoc == Ident1:

   161             break

   162     return IntParIO

   163 

   164 def Proc3(PtrParOut):

   165     global IntGlob

   166 

   167     if PtrGlb is not None:

   168         PtrParOut = PtrGlb.PtrComp

   169     else:

   170         IntGlob = 100

   171     PtrGlb.IntComp = Proc7(10, IntGlob)

   172     return PtrParOut

   173 

   174 def Proc4():

   175     global Char2Glob

   176 

   177     BoolLoc = Char1Glob == 'A'

   178     BoolLoc = BoolLoc or BoolGlob

   179     Char2Glob = 'B'

   180 

   181 def Proc5():

   182     global Char1Glob

   183     global BoolGlob

   184 

   185     Char1Glob = 'A'

   186     BoolGlob = FALSE

   187 

   188 def Proc6(EnumParIn):

   189     EnumParOut = EnumParIn

   190     if not Func3(EnumParIn):

   191         EnumParOut = Ident4

   192     if EnumParIn == Ident1:

   193         EnumParOut = Ident1

   194     elif EnumParIn == Ident2:

   195         if IntGlob > 100:

   196             EnumParOut = Ident1

   197         else:

   198             EnumParOut = Ident4

   199     elif EnumParIn == Ident3:

   200         EnumParOut = Ident2

   201     elif EnumParIn == Ident4:

   202         pass

   203     elif EnumParIn == Ident5:

   204         EnumParOut = Ident3

   205     return EnumParOut

   206 

   207 def Proc7(IntParI1, IntParI2):

   208     IntLoc = IntParI1 + 2

   209     IntParOut = IntParI2 + IntLoc

   210     return IntParOut

   211 

   212 def Proc8(Array1Par, Array2Par, IntParI1, IntParI2):

   213     global IntGlob

   214 

   215     IntLoc = IntParI1 + 5

   216     Array1Par[IntLoc] = IntParI2

   217     Array1Par[IntLoc+1] = Array1Par[IntLoc]

   218     Array1Par[IntLoc+30] = IntLoc

   219     for IntIndex in range(IntLoc, IntLoc+2):

   220         Array2Par[IntLoc][IntIndex] = IntLoc

   221     Array2Par[IntLoc][IntLoc-1] = Array2Par[IntLoc][IntLoc-1] + 1

   222     Array2Par[IntLoc+20][IntLoc] = Array1Par[IntLoc]

   223     IntGlob = 5

   224 

   225 def Func1(CharPar1, CharPar2):

   226     CharLoc1 = CharPar1

   227     CharLoc2 = CharLoc1

   228     if CharLoc2 != CharPar2:

   229         return Ident1

   230     else:

   231         return Ident2

   232 

   233 def Func2(StrParI1, StrParI2):

   234     IntLoc = 1

   235     while IntLoc <= 1:

   236         if Func1(StrParI1[IntLoc], StrParI2[IntLoc+1]) == Ident1:

   237             CharLoc = 'A'

   238             IntLoc = IntLoc + 1

   239     if CharLoc >= 'W' and CharLoc <= 'Z':

   240         IntLoc = 7

   241     if CharLoc == 'X':

   242         return TRUE

   243     else:

   244         if StrParI1 > StrParI2:

   245             IntLoc = IntLoc + 7

   246             return TRUE

   247         else:

   248             return FALSE

   249 

   250 def Func3(EnumParIn):

   251     EnumLoc = EnumParIn

   252     if EnumLoc == Ident3: return TRUE

   253     return FALSE

   254 

   255 if __name__ == '__main__':

   256     import sys

   257     def error(msg):

   258         print >>sys.stderr, msg,

   259         print >>sys.stderr, "usage: %s [number_of_loops]" % sys.argv[0]

   260         sys.exit(100)

   261     nargs = len(sys.argv) - 1

   262     if nargs > 1:

   263         error("%d arguments are too many;" % nargs)

   264     elif nargs == 1:

   265         try: loops = int(sys.argv[1])

   266         except ValueError:

   267             error("Invalid argument %r;" % sys.argv[1])

   268     else:

   269         loops = LOOPS

   270     main(loops)