#! /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 | |
if benchtime == 0.0: | |
loopsPerBenchtime = 0.0 | |
else: | |
loopsPerBenchtime = (loops / benchtime) | |
return benchtime, loopsPerBenchtime | |
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) |