#! /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 = 50000

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(loops=LOOPS):

    benchtime, stones = pystones(loops)

    print "Pystone(%s) time for %d passes = %g" % \

          (__version__, loops, benchtime)

    print "This machine benchmarks at %g pystones/second" % stones

def pystones(loops=LOOPS):

    return Proc0(loops)

IntGlob = 0

BoolGlob = FALSE

Char1Glob = '\0'

Char2Glob = '\0'

Array1Glob = [0]*51

Array2Glob = map(lambda x: x[:], [Array1Glob]*51)

PtrGlb = None

PtrGlbNext = None

def Proc0(loops=LOOPS):

    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

    if benchtime == 0.0:

        loopsPerBenchtime = 0.0

    else:

        loopsPerBenchtime = (loops / benchtime)

    return benchtime, loopsPerBenchtime

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__':

    import sys

    def error(msg):

        print >>sys.stderr, msg,

        print >>sys.stderr, "usage: %s [number_of_loops]" % sys.argv[0]

        sys.exit(100)

    nargs = len(sys.argv) - 1

    if nargs > 1:

        error("%d arguments are too many;" % nargs)

    elif nargs == 1:

        try: loops = int(sys.argv[1])

        except ValueError:

            error("Invalid argument %r;" % sys.argv[1])

    else:

        loops = LOOPS

    main(loops)