Package test :: Module pystone |
[hide private]
[frames] | no frames]

# Source Code for Module test.pystone

      1  #! /usr/bin/python2.7
      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)
    271