| #! /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 = 10000 |
| |
| 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(): |
| benchtime, stones = pystones() |
| 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__': |
| main() |