| 1 | #! /usr/bin/env python
|
|---|
| 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)
|
|---|
