Commit | Line | Data |
---|---|---|
920dae64 AT |
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 | return benchtime, (loops / benchtime) | |
132 | ||
133 | def Proc1(PtrParIn): | |
134 | PtrParIn.PtrComp = NextRecord = PtrGlb.copy() | |
135 | PtrParIn.IntComp = 5 | |
136 | NextRecord.IntComp = PtrParIn.IntComp | |
137 | NextRecord.PtrComp = PtrParIn.PtrComp | |
138 | NextRecord.PtrComp = Proc3(NextRecord.PtrComp) | |
139 | if NextRecord.Discr == Ident1: | |
140 | NextRecord.IntComp = 6 | |
141 | NextRecord.EnumComp = Proc6(PtrParIn.EnumComp) | |
142 | NextRecord.PtrComp = PtrGlb.PtrComp | |
143 | NextRecord.IntComp = Proc7(NextRecord.IntComp, 10) | |
144 | else: | |
145 | PtrParIn = NextRecord.copy() | |
146 | NextRecord.PtrComp = None | |
147 | return PtrParIn | |
148 | ||
149 | def Proc2(IntParIO): | |
150 | IntLoc = IntParIO + 10 | |
151 | while 1: | |
152 | if Char1Glob == 'A': | |
153 | IntLoc = IntLoc - 1 | |
154 | IntParIO = IntLoc - IntGlob | |
155 | EnumLoc = Ident1 | |
156 | if EnumLoc == Ident1: | |
157 | break | |
158 | return IntParIO | |
159 | ||
160 | def Proc3(PtrParOut): | |
161 | global IntGlob | |
162 | ||
163 | if PtrGlb is not None: | |
164 | PtrParOut = PtrGlb.PtrComp | |
165 | else: | |
166 | IntGlob = 100 | |
167 | PtrGlb.IntComp = Proc7(10, IntGlob) | |
168 | return PtrParOut | |
169 | ||
170 | def Proc4(): | |
171 | global Char2Glob | |
172 | ||
173 | BoolLoc = Char1Glob == 'A' | |
174 | BoolLoc = BoolLoc or BoolGlob | |
175 | Char2Glob = 'B' | |
176 | ||
177 | def Proc5(): | |
178 | global Char1Glob | |
179 | global BoolGlob | |
180 | ||
181 | Char1Glob = 'A' | |
182 | BoolGlob = FALSE | |
183 | ||
184 | def Proc6(EnumParIn): | |
185 | EnumParOut = EnumParIn | |
186 | if not Func3(EnumParIn): | |
187 | EnumParOut = Ident4 | |
188 | if EnumParIn == Ident1: | |
189 | EnumParOut = Ident1 | |
190 | elif EnumParIn == Ident2: | |
191 | if IntGlob > 100: | |
192 | EnumParOut = Ident1 | |
193 | else: | |
194 | EnumParOut = Ident4 | |
195 | elif EnumParIn == Ident3: | |
196 | EnumParOut = Ident2 | |
197 | elif EnumParIn == Ident4: | |
198 | pass | |
199 | elif EnumParIn == Ident5: | |
200 | EnumParOut = Ident3 | |
201 | return EnumParOut | |
202 | ||
203 | def Proc7(IntParI1, IntParI2): | |
204 | IntLoc = IntParI1 + 2 | |
205 | IntParOut = IntParI2 + IntLoc | |
206 | return IntParOut | |
207 | ||
208 | def Proc8(Array1Par, Array2Par, IntParI1, IntParI2): | |
209 | global IntGlob | |
210 | ||
211 | IntLoc = IntParI1 + 5 | |
212 | Array1Par[IntLoc] = IntParI2 | |
213 | Array1Par[IntLoc+1] = Array1Par[IntLoc] | |
214 | Array1Par[IntLoc+30] = IntLoc | |
215 | for IntIndex in range(IntLoc, IntLoc+2): | |
216 | Array2Par[IntLoc][IntIndex] = IntLoc | |
217 | Array2Par[IntLoc][IntLoc-1] = Array2Par[IntLoc][IntLoc-1] + 1 | |
218 | Array2Par[IntLoc+20][IntLoc] = Array1Par[IntLoc] | |
219 | IntGlob = 5 | |
220 | ||
221 | def Func1(CharPar1, CharPar2): | |
222 | CharLoc1 = CharPar1 | |
223 | CharLoc2 = CharLoc1 | |
224 | if CharLoc2 != CharPar2: | |
225 | return Ident1 | |
226 | else: | |
227 | return Ident2 | |
228 | ||
229 | def Func2(StrParI1, StrParI2): | |
230 | IntLoc = 1 | |
231 | while IntLoc <= 1: | |
232 | if Func1(StrParI1[IntLoc], StrParI2[IntLoc+1]) == Ident1: | |
233 | CharLoc = 'A' | |
234 | IntLoc = IntLoc + 1 | |
235 | if CharLoc >= 'W' and CharLoc <= 'Z': | |
236 | IntLoc = 7 | |
237 | if CharLoc == 'X': | |
238 | return TRUE | |
239 | else: | |
240 | if StrParI1 > StrParI2: | |
241 | IntLoc = IntLoc + 7 | |
242 | return TRUE | |
243 | else: | |
244 | return FALSE | |
245 | ||
246 | def Func3(EnumParIn): | |
247 | EnumLoc = EnumParIn | |
248 | if EnumLoc == Ident3: return TRUE | |
249 | return FALSE | |
250 | ||
251 | if __name__ == '__main__': | |
252 | import sys | |
253 | def error(msg): | |
254 | print >>sys.stderr, msg, | |
255 | print >>sys.stderr, "usage: %s [number_of_loops]" % sys.argv[0] | |
256 | sys.exit(100) | |
257 | nargs = len(sys.argv) - 1 | |
258 | if nargs > 1: | |
259 | error("%d arguments are too many;" % nargs) | |
260 | elif nargs == 1: | |
261 | try: loops = int(sys.argv[1]) | |
262 | except ValueError: | |
263 | error("Invalid argument %r;" % sys.argv[1]) | |
264 | else: | |
265 | loops = LOOPS | |
266 | main(loops) |