svn-gvsig-desktop / tags / v1_0_2_Build_915 / extensions / extScripting / scripts / jython / Lib / test / pystone.py @ 12217
History | View | Annotate | Download (6.64 KB)
1 | 5782 | jmvivo | #! /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 = 10000
|
||
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(): |
||
61 | benchtime, stones = pystones() |
||
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 | main() |