#! /usr/bin/env python

"""

"PYSTONE" Benchmark Program

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

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

Translated from ADA to C by Rick Richardson.

Every method to preserve ADA-likeness has been used,

at the expense of C-ness.

Translated from C to Python by Guido van Rossum.

Version History:

Version 1.1 corrects two bugs in version 1.0:

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

up having a pointer to itself. I have corrected this

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

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

record to None. This is rather inefficient and not

true to the intention of the original benchmark (where

a pointer comparison to None is intended; the !=

operator attempts to find a method __cmp__ to do value

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

percent faster than version 1.0, so benchmark figures

of different versions can't be compared directly.

"""

LOOPS = 50000

from time import clock

__version__ = "1.1"

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

class Record:

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

IntComp = 0, StringComp = 0):

self.PtrComp = PtrComp

self.Discr = Discr

self.EnumComp = EnumComp

self.IntComp = IntComp

self.StringComp = StringComp

def copy(self):

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

self.IntComp, self.StringComp)

TRUE = 1

FALSE = 0

def main(loops=LOOPS):

benchtime, stones = pystones(loops)

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

(__version__, loops, benchtime)

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

def pystones(loops=LOOPS):

return Proc0(loops)

IntGlob = 0

BoolGlob = FALSE

Char1Glob = '\0'

Char2Glob = '\0'

Array1Glob = [0]*51

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

PtrGlb = None

PtrGlbNext = None

def Proc0(loops=LOOPS):

global IntGlob

global BoolGlob

global Char1Glob

global Char2Glob

global Array1Glob

global Array2Glob

global PtrGlb

global PtrGlbNext

starttime = clock()

for i in range(loops):

pass

nulltime = clock() - starttime

PtrGlbNext = Record()

PtrGlb = Record()

PtrGlb.PtrComp = PtrGlbNext

PtrGlb.Discr = Ident1

PtrGlb.EnumComp = Ident3

PtrGlb.IntComp = 40

PtrGlb.StringComp = "DHRYSTONE PROGRAM, SOME STRING"

String1Loc = "DHRYSTONE PROGRAM, 1'ST STRING"

Array2Glob[8][7] = 10

starttime = clock()

for i in range(loops):

Proc5()

Proc4()

IntLoc1 = 2

IntLoc2 = 3

String2Loc = "DHRYSTONE PROGRAM, 2'ND STRING"

EnumLoc = Ident2

BoolGlob = not Func2(String1Loc, String2Loc)

while IntLoc1 < IntLoc2:

IntLoc3 = 5 * IntLoc1 - IntLoc2

IntLoc3 = Proc7(IntLoc1, IntLoc2)

IntLoc1 = IntLoc1 + 1

Proc8(Array1Glob, Array2Glob, IntLoc1, IntLoc3)

PtrGlb = Proc1(PtrGlb)

CharIndex = 'A'

while CharIndex <= Char2Glob:

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

EnumLoc = Proc6(Ident1)

CharIndex = chr(ord(CharIndex)+1)

IntLoc3 = IntLoc2 * IntLoc1

IntLoc2 = IntLoc3 / IntLoc1

IntLoc2 = 7 * (IntLoc3 - IntLoc2) - IntLoc1

IntLoc1 = Proc2(IntLoc1)

benchtime = clock() - starttime - nulltime

return benchtime, (loops / benchtime)

def Proc1(PtrParIn):

PtrParIn.PtrComp = NextRecord = PtrGlb.copy()

PtrParIn.IntComp = 5

NextRecord.IntComp = PtrParIn.IntComp

NextRecord.PtrComp = PtrParIn.PtrComp

NextRecord.PtrComp = Proc3(NextRecord.PtrComp)

if NextRecord.Discr == Ident1:

NextRecord.IntComp = 6

NextRecord.EnumComp = Proc6(PtrParIn.EnumComp)

NextRecord.PtrComp = PtrGlb.PtrComp

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

else:

PtrParIn = NextRecord.copy()

NextRecord.PtrComp = None

return PtrParIn

def Proc2(IntParIO):

IntLoc = IntParIO + 10

while 1:

if Char1Glob == 'A':

IntLoc = IntLoc - 1

IntParIO = IntLoc - IntGlob

EnumLoc = Ident1

if EnumLoc == Ident1:

break

return IntParIO

def Proc3(PtrParOut):

global IntGlob

if PtrGlb is not None:

PtrParOut = PtrGlb.PtrComp

else:

IntGlob = 100

PtrGlb.IntComp = Proc7(10, IntGlob)

return PtrParOut

def Proc4():

global Char2Glob

BoolLoc = Char1Glob == 'A'

BoolLoc = BoolLoc or BoolGlob

Char2Glob = 'B'

def Proc5():

global Char1Glob

global BoolGlob

Char1Glob = 'A'

BoolGlob = FALSE

def Proc6(EnumParIn):

EnumParOut = EnumParIn

if not Func3(EnumParIn):

EnumParOut = Ident4

if EnumParIn == Ident1:

EnumParOut = Ident1

elif EnumParIn == Ident2:

if IntGlob > 100:

EnumParOut = Ident1

else:

EnumParOut = Ident4

elif EnumParIn == Ident3:

EnumParOut = Ident2

elif EnumParIn == Ident4:

pass

elif EnumParIn == Ident5:

EnumParOut = Ident3

return EnumParOut

def Proc7(IntParI1, IntParI2):

IntLoc = IntParI1 + 2

IntParOut = IntParI2 + IntLoc

return IntParOut

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

global IntGlob

IntLoc = IntParI1 + 5

Array1Par[IntLoc] = IntParI2

Array1Par[IntLoc+1] = Array1Par[IntLoc]

Array1Par[IntLoc+30] = IntLoc

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

Array2Par[IntLoc][IntIndex] = IntLoc

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

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

IntGlob = 5

def Func1(CharPar1, CharPar2):

CharLoc1 = CharPar1

CharLoc2 = CharLoc1

if CharLoc2 != CharPar2:

return Ident1

else:

return Ident2

def Func2(StrParI1, StrParI2):

IntLoc = 1

while IntLoc <= 1:

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

CharLoc = 'A'

IntLoc = IntLoc + 1

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

IntLoc = 7

if CharLoc == 'X':

return TRUE

else:

if StrParI1 > StrParI2:

IntLoc = IntLoc + 7

return TRUE

else:

return FALSE

def Func3(EnumParIn):

EnumLoc = EnumParIn

if EnumLoc == Ident3: return TRUE

return FALSE

if __name__ == '__main__':

import sys

def error(msg):

print >>sys.stderr, msg,

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

sys.exit(100)

nargs = len(sys.argv) - 1

if nargs > 1:

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

elif nargs == 1:

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

except ValueError:

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

else:

loops = LOOPS

main(loops)