summaryrefslogtreecommitdiffstats
path: root/Tools/scripts/pystone.py
blob: 23e3b7fbf00cf7151bdca078f0d7dd13b1607fd3 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
#! /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 = 1000

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():
	Proc0()

IntGlob = 0
BoolGlob = FALSE
Char1Glob = '\0'
Char2Glob = '\0'
Array1Glob = [0]*51
Array2Glob = map(lambda x: x[:], [Array1Glob]*51)
PtrGlb = None
PtrGlbNext = None

def Proc0():
	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
	print "Pystone(%s) time for %d passes = %g" % \
	      (__version__, LOOPS, benchtime)
	print "This machine benchmarks at %g pystones/second" % \
	      (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()