[pypy-svn] r10588 - pypy/dist/pypy/translator/test
tismer at codespeak.net
tismer at codespeak.net
Wed Apr 13 19:51:23 CEST 2005
Author: tismer
Date: Wed Apr 13 19:51:23 2005
New Revision: 10588
Added:
pypy/dist/pypy/translator/test/rpystone.py (contents, props changed)
Log:
this is an adjusted version of pystone.py,
to be valid for flow space.
It can be run like pystone. Without an argument,
it tries to be quick for PyPy.
Added: pypy/dist/pypy/translator/test/rpystone.py
==============================================================================
--- (empty file)
+++ pypy/dist/pypy/translator/test/rpystone.py Wed Apr 13 19:51:23 2005
@@ -0,0 +1,282 @@
+#! /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
+
+# use a global instance instead of globals
+class G:pass
+g = G()
+
+import sys
+
+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)
+ sys.stdout.write("Pystone(%s) time for %d passes = %g\n" % \
+ (__version__, loops, benchtime) )
+ #print "This machine benchmarks at %g pystones/second" % stones
+ sys.stdout.write("This machine benchmarks at %g pystones/second\n" % stones)
+
+
+def pystones(loops=LOOPS):
+ return Proc0(loops)
+
+g.IntGlob = 0
+g.BoolGlob = FALSE
+g.Char1Glob = '\0'
+g.Char2Glob = '\0'
+g.Array1Glob = [0]*51
+g.Array2Glob = map(lambda x: x[:], [g.Array1Glob]*51)
+g.PtrGlb = None
+g.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
+
+ g.PtrGlbNext = Record()
+ g.PtrGlb = Record()
+ g.PtrGlb.PtrComp = g.PtrGlbNext
+ g.PtrGlb.Discr = Ident1
+ g.PtrGlb.EnumComp = Ident3
+ g.PtrGlb.IntComp = 40
+ g.PtrGlb.StringComp = "DHRYSTONE PROGRAM, SOME STRING"
+ String1Loc = "DHRYSTONE PROGRAM, 1'ST STRING"
+ g.Array2Glob[8][7] = 10
+
+ EnumLoc = None # addition for flow space
+ starttime = clock()
+
+ for i in range(loops):
+ Proc5()
+ Proc4()
+ IntLoc1 = 2
+ IntLoc2 = 3
+ String2Loc = "DHRYSTONE PROGRAM, 2'ND STRING"
+ EnumLoc = Ident2
+ g.BoolGlob = not Func2(String1Loc, String2Loc)
+ while IntLoc1 < IntLoc2:
+ IntLoc3 = 5 * IntLoc1 - IntLoc2
+ IntLoc3 = Proc7(IntLoc1, IntLoc2)
+ IntLoc1 = IntLoc1 + 1
+ Proc8(g.Array1Glob, g.Array2Glob, IntLoc1, IntLoc3)
+ g.PtrGlb = Proc1(g.PtrGlb)
+ CharIndex = 'A'
+ while CharIndex <= g.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 = g.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 = g.PtrGlb.PtrComp
+ NextRecord.IntComp = Proc7(NextRecord.IntComp, 10)
+ else:
+ PtrParIn = NextRecord.copy()
+ NextRecord.PtrComp = None
+ return PtrParIn
+
+def Proc2(IntParIO):
+ IntLoc = IntParIO + 10
+ EnumLoc = None # addition for flow space
+ while 1:
+ if g.Char1Glob == 'A':
+ IntLoc = IntLoc - 1
+ IntParIO = IntLoc - g.IntGlob
+ EnumLoc = Ident1
+ if EnumLoc == Ident1:
+ break
+ return IntParIO
+
+def Proc3(PtrParOut):
+ #global IntGlob
+
+ if g.PtrGlb is not None:
+ PtrParOut = g.PtrGlb.PtrComp
+ else:
+ g.IntGlob = 100
+ g.PtrGlb.IntComp = Proc7(10, g.IntGlob)
+ return PtrParOut
+
+def Proc4():
+ #global Char2Glob
+
+ BoolLoc = g.Char1Glob == 'A'
+ BoolLoc = BoolLoc or g.BoolGlob
+ g.Char2Glob = 'B'
+
+def Proc5():
+ #global Char1Glob
+ #global BoolGlob
+
+ g.Char1Glob = 'A'
+ g.BoolGlob = FALSE
+
+def Proc6(EnumParIn):
+ EnumParOut = EnumParIn
+ if not Func3(EnumParIn):
+ EnumParOut = Ident4
+ if EnumParIn == Ident1:
+ EnumParOut = Ident1
+ elif EnumParIn == Ident2:
+ if g.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]
+ g.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__':
+ def error(msg):
+ #print >>sys.stderr, msg,
+ sys.stderr.write(msg+" ")
+ #print >>sys.stderr, "usage: %s [number_of_loops]" % sys.argv[0]
+ sys.stderr.write("usage: %s [number_of_loops]\n" % 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:
+ if hasattr(sys, 'pypy_objspaceclass'):
+ loops = LOOPS / 2000 # XXX rough estimate, adjust
+ else:
+ loops = LOOPS
+ main(loops)
+
More information about the Pypy-commit
mailing list