2019-06-26 05:26:20 +01:00
|
|
|
"""
|
|
|
|
"PYSTONE" Benchmark Program
|
|
|
|
|
|
|
|
Version: Python/1.2 (corresponds to C/1.1 plus 3 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__ = "1.2"
|
|
|
|
|
|
|
|
[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)
|
2020-03-23 02:26:08 +00:00
|
|
|
|
2019-06-26 05:26:20 +01:00
|
|
|
|
|
|
|
TRUE = 1
|
|
|
|
FALSE = 0
|
|
|
|
|
2020-03-23 02:26:08 +00:00
|
|
|
|
2019-06-26 05:26:20 +01:00
|
|
|
def Setup():
|
|
|
|
global IntGlob
|
|
|
|
global BoolGlob
|
|
|
|
global Char1Glob
|
|
|
|
global Char2Glob
|
|
|
|
global Array1Glob
|
|
|
|
global Array2Glob
|
|
|
|
|
|
|
|
IntGlob = 0
|
|
|
|
BoolGlob = FALSE
|
|
|
|
Char1Glob = "\0"
|
|
|
|
Char2Glob = "\0"
|
|
|
|
Array1Glob = [0] * 51
|
|
|
|
Array2Glob = [x[:] for x in [Array1Glob] * 51]
|
2020-03-23 02:26:08 +00:00
|
|
|
|
2019-06-26 05:26:20 +01:00
|
|
|
|
|
|
|
def Proc0(loops):
|
|
|
|
global IntGlob
|
|
|
|
global BoolGlob
|
|
|
|
global Char1Glob
|
|
|
|
global Char2Glob
|
|
|
|
global Array1Glob
|
|
|
|
global Array2Glob
|
|
|
|
global PtrGlb
|
|
|
|
global PtrGlbNext
|
|
|
|
|
|
|
|
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
|
|
|
|
|
|
|
|
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)
|
|
|
|
|
2020-03-23 02:26:08 +00:00
|
|
|
|
2019-06-26 05:26:20 +01:00
|
|
|
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
|
|
|
|
|
2020-03-23 02:26:08 +00:00
|
|
|
|
2019-06-26 05:26:20 +01:00
|
|
|
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
|
|
|
|
|
2020-03-23 02:26:08 +00:00
|
|
|
|
2019-06-26 05:26:20 +01:00
|
|
|
def Proc3(PtrParOut):
|
|
|
|
global IntGlob
|
|
|
|
|
|
|
|
if PtrGlb is not None:
|
|
|
|
PtrParOut = PtrGlb.PtrComp
|
|
|
|
else:
|
|
|
|
IntGlob = 100
|
|
|
|
PtrGlb.IntComp = Proc7(10, IntGlob)
|
|
|
|
return PtrParOut
|
|
|
|
|
2020-03-23 02:26:08 +00:00
|
|
|
|
2019-06-26 05:26:20 +01:00
|
|
|
def Proc4():
|
|
|
|
global Char2Glob
|
|
|
|
|
|
|
|
BoolLoc = Char1Glob == "A"
|
|
|
|
BoolLoc = BoolLoc or BoolGlob
|
|
|
|
Char2Glob = "B"
|
2020-03-23 02:26:08 +00:00
|
|
|
|
2019-06-26 05:26:20 +01:00
|
|
|
|
|
|
|
def Proc5():
|
|
|
|
global Char1Glob
|
|
|
|
global BoolGlob
|
|
|
|
|
|
|
|
Char1Glob = "A"
|
|
|
|
BoolGlob = FALSE
|
|
|
|
|
2020-03-23 02:26:08 +00:00
|
|
|
|
2019-06-26 05:26:20 +01:00
|
|
|
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
|
|
|
|
|
2020-03-23 02:26:08 +00:00
|
|
|
|
2019-06-26 05:26:20 +01:00
|
|
|
def Proc7(IntParI1, IntParI2):
|
|
|
|
IntLoc = IntParI1 + 2
|
|
|
|
IntParOut = IntParI2 + IntLoc
|
|
|
|
return IntParOut
|
|
|
|
|
2020-03-23 02:26:08 +00:00
|
|
|
|
2019-06-26 05:26:20 +01:00
|
|
|
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
|
|
|
|
|
2020-03-23 02:26:08 +00:00
|
|
|
|
2019-06-26 05:26:20 +01:00
|
|
|
def Func1(CharPar1, CharPar2):
|
|
|
|
CharLoc1 = CharPar1
|
|
|
|
CharLoc2 = CharLoc1
|
|
|
|
if CharLoc2 != CharPar2:
|
|
|
|
return Ident1
|
|
|
|
else:
|
|
|
|
return Ident2
|
|
|
|
|
2020-03-23 02:26:08 +00:00
|
|
|
|
2019-06-26 05:26:20 +01:00
|
|
|
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
|
|
|
|
|
2020-03-23 02:26:08 +00:00
|
|
|
|
2019-06-26 05:26:20 +01:00
|
|
|
def Func3(EnumParIn):
|
|
|
|
EnumLoc = EnumParIn
|
|
|
|
if EnumLoc == Ident3:
|
|
|
|
return TRUE
|
|
|
|
return FALSE
|
|
|
|
|
|
|
|
|
|
|
|
###########################################################################
|
|
|
|
# Benchmark interface
|
|
|
|
|
|
|
|
bm_params = {
|
|
|
|
(50, 10): (80,),
|
|
|
|
(100, 10): (300,),
|
|
|
|
(1000, 10): (4000,),
|
|
|
|
(5000, 10): (20000,),
|
|
|
|
}
|
|
|
|
|
2020-03-23 02:26:08 +00:00
|
|
|
|
2019-06-26 05:26:20 +01:00
|
|
|
def bm_setup(params):
|
|
|
|
Setup()
|
|
|
|
return lambda: Proc0(params[0]), lambda: (params[0], 0)
|