#!/usr/bin/env python
from __future__ import print_function
import sys
import random
class TimingScriptGenerator:
"""Used to generate a bash script which will invoke the toy and time it"""
def __init__(self, scriptname, outputname):
self.timeFile = outputname
self.shfile = open(scriptname, "w")
self.shfile.write('echo "" > %s\n' % self.timeFile)
def writeTimingCall(self, filename, numFuncs, funcsCalled, totalCalls):
"""Echo some comments and invoke both versions of toy"""
rootname = filename
if "." in filename:
rootname = filename[: filename.rfind(".")]
self.shfile.write(
'echo "%s: Calls %d of %d functions, %d total" >> %s\n'
% (filename, funcsCalled, numFuncs, totalCalls, self.timeFile)
)
self.shfile.write('echo "" >> %s\n' % self.timeFile)
self.shfile.write('echo "With MCJIT" >> %s\n' % self.timeFile)
self.shfile.write(
'/usr/bin/time -f "Command %C\\n\\tuser time: %U s\\n\\tsytem time: %S s\\n\\tmax set: %M kb"'
)
self.shfile.write(" -o %s -a " % self.timeFile)
self.shfile.write(
"./toy-mcjit < %s > %s-mcjit.out 2> %s-mcjit.err\n"
% (filename, rootname, rootname)
)
self.shfile.write('echo "" >> %s\n' % self.timeFile)
self.shfile.write('echo "With JIT" >> %s\n' % self.timeFile)
self.shfile.write(
'/usr/bin/time -f "Command %C\\n\\tuser time: %U s\\n\\tsytem time: %S s\\n\\tmax set: %M kb"'
)
self.shfile.write(" -o %s -a " % self.timeFile)
self.shfile.write(
"./toy-jit < %s > %s-jit.out 2> %s-jit.err\n"
% (filename, rootname, rootname)
)
self.shfile.write('echo "" >> %s\n' % self.timeFile)
self.shfile.write('echo "" >> %s\n' % self.timeFile)
class KScriptGenerator:
"""Used to generate random Kaleidoscope code"""
def __init__(self, filename):
self.kfile = open(filename, "w")
self.nextFuncNum = 1
self.lastFuncNum = None
self.callWeighting = 0.1
# A mapping of calls within functions with no duplicates
self.calledFunctionTable = {}
# A list of function calls which will actually be executed
self.calledFunctions = []
# A comprehensive mapping of calls within functions
# used for computing the total number of calls
self.comprehensiveCalledFunctionTable = {}
self.totalCallsExecuted = 0
def updateTotalCallCount(self, callee):
# Count this call
self.totalCallsExecuted += 1
# Then count all the functions it calls
if callee in self.comprehensiveCalledFunctionTable:
for child in self.comprehensiveCalledFunctionTable[callee]:
self.updateTotalCallCount(child)
def updateFunctionCallMap(self, caller, callee):
"""Maintains a map of functions that are called from other functions"""
if not caller in self.calledFunctionTable:
self.calledFunctionTable[caller] = []
if not callee in self.calledFunctionTable[caller]:
self.calledFunctionTable[caller].append(callee)
if not caller in self.comprehensiveCalledFunctionTable:
self.comprehensiveCalledFunctionTable[caller] = []
self.comprehensiveCalledFunctionTable[caller].append(callee)
def updateCalledFunctionList(self, callee):
"""Maintains a list of functions that will actually be called"""
# Update the total call count
self.updateTotalCallCount(callee)
# If this function is already in the list, don't do anything else
if callee in self.calledFunctions:
return
# Add this function to the list of those that will be called.
self.calledFunctions.append(callee)
# If this function calls other functions, add them too
if callee in self.calledFunctionTable:
for subCallee in self.calledFunctionTable[callee]:
self.updateCalledFunctionList(subCallee)
def setCallWeighting(self, weight):
"""Sets the probably of generating a function call"""
self.callWeighting = weight
def writeln(self, line):
self.kfile.write(line + "\n")
def writeComment(self, comment):
self.writeln("# " + comment)
def writeEmptyLine(self):
self.writeln("")
def writePredefinedFunctions(self):
self.writeComment(
"Define ':' for sequencing: as a low-precedence operator that ignores operands"
)
self.writeComment("and just returns the RHS.")
self.writeln("def binary : 1 (x y) y;")
self.writeEmptyLine()
self.writeComment("Helper functions defined within toy")
self.writeln("extern putchard(x);")
self.writeln("extern printd(d);")
self.writeln("extern printlf();")
self.writeEmptyLine()
self.writeComment("Print the result of a function call")
self.writeln("def printresult(N Result)")
self.writeln(" # 'result('")
self.writeln(
" putchard(114) : putchard(101) : putchard(115) : putchard(117) : putchard(108) : putchard(116) : putchard(40) :"
)
self.writeln(" printd(N) :")
self.writeln(" # ') = '")
self.writeln(" putchard(41) : putchard(32) : putchard(61) : putchard(32) :")
self.writeln(" printd(Result) :")
self.writeln(" printlf();")
self.writeEmptyLine()
def writeRandomOperation(self, LValue, LHS, RHS):
shouldCallFunc = self.lastFuncNum > 2 and random.random() < self.callWeighting
if shouldCallFunc:
funcToCall = random.randrange(1, self.lastFuncNum - 1)
self.updateFunctionCallMap(self.lastFuncNum, funcToCall)
self.writeln(" %s = func%d(%s, %s) :" % (LValue, funcToCall, LHS, RHS))
else:
possibleOperations = ["+", "-", "*", "/"]
operation = random.choice(possibleOperations)
if operation == "-":
# Don't let our intermediate value become zero
# This is complicated by the fact that '<' is our only comparison operator
self.writeln(" if %s < %s then" % (LHS, RHS))
self.writeln(" %s = %s %s %s" % (LValue, LHS, operation, RHS))
self.writeln(" else if %s < %s then" % (RHS, LHS))
self.writeln(" %s = %s %s %s" % (LValue, LHS, operation, RHS))
self.writeln(" else")
self.writeln(
" %s = %s %s %f :"
% (LValue, LHS, operation, random.uniform(1, 100))
)
else:
self.writeln(" %s = %s %s %s :" % (LValue, LHS, operation, RHS))
def getNextFuncNum(self):
result = self.nextFuncNum
self.nextFuncNum += 1
self.lastFuncNum = result
return result
def writeFunction(self, elements):
funcNum = self.getNextFuncNum()
self.writeComment("Auto-generated function number %d" % funcNum)
self.writeln("def func%d(X Y)" % funcNum)
self.writeln(" var temp1 = X,")
self.writeln(" temp2 = Y,")
self.writeln(" temp3 in")
# Initialize the variable names to be rotated
first = "temp3"
second = "temp1"
third = "temp2"
# Write some random operations
for i in range(elements):
self.writeRandomOperation(first, second, third)
# Rotate the variables
temp = first
first = second
second = third
third = temp
self.writeln(" " + third + ";")
self.writeEmptyLine()
def writeFunctionCall(self):
self.writeComment("Call the last function")
arg1 = random.uniform(1, 100)
arg2 = random.uniform(1, 100)
self.writeln(
"printresult(%d, func%d(%f, %f) )"
% (self.lastFuncNum, self.lastFuncNum, arg1, arg2)
)
self.writeEmptyLine()
self.updateCalledFunctionList(self.lastFuncNum)
def writeFinalFunctionCounts(self):
self.writeComment(
"Called %d of %d functions" % (len(self.calledFunctions), self.lastFuncNum)
)
def generateKScript(
filename, numFuncs, elementsPerFunc, funcsBetweenExec, callWeighting, timingScript
):
"""Generate a random Kaleidoscope script based on the given parameters"""
print("Generating " + filename)
print(
" %d functions, %d elements per function, %d functions between execution"
% (numFuncs, elementsPerFunc, funcsBetweenExec)
)
print(" Call weighting = %f" % callWeighting)
script = KScriptGenerator(filename)
script.setCallWeighting(callWeighting)
script.writeComment(
"==========================================================================="
)
script.writeComment("Auto-generated script")
script.writeComment(
" %d functions, %d elements per function, %d functions between execution"
% (numFuncs, elementsPerFunc, funcsBetweenExec)
)
script.writeComment(" call weighting = %f" % callWeighting)
script.writeComment(
"==========================================================================="
)
script.writeEmptyLine()
script.writePredefinedFunctions()
funcsSinceLastExec = 0
for i in range(numFuncs):
script.writeFunction(elementsPerFunc)
funcsSinceLastExec += 1
if funcsSinceLastExec == funcsBetweenExec:
script.writeFunctionCall()
funcsSinceLastExec = 0
# Always end with a function call
if funcsSinceLastExec > 0:
script.writeFunctionCall()
script.writeEmptyLine()
script.writeFinalFunctionCounts()
funcsCalled = len(script.calledFunctions)
print(
" Called %d of %d functions, %d total"
% (funcsCalled, numFuncs, script.totalCallsExecuted)
)
timingScript.writeTimingCall(
filename, numFuncs, funcsCalled, script.totalCallsExecuted
)
# Execution begins here
random.seed()
timingScript = TimingScriptGenerator("time-toy.sh", "timing-data.txt")
dataSets = [
(5000, 3, 50, 0.50),
(5000, 10, 100, 0.10),
(5000, 10, 5, 0.10),
(5000, 10, 1, 0.0),
(1000, 3, 10, 0.50),
(1000, 10, 100, 0.10),
(1000, 10, 5, 0.10),
(1000, 10, 1, 0.0),
(200, 3, 2, 0.50),
(200, 10, 40, 0.10),
(200, 10, 2, 0.10),
(200, 10, 1, 0.0),
]
# Generate the code
for (numFuncs, elementsPerFunc, funcsBetweenExec, callWeighting) in dataSets:
filename = "test-%d-%d-%d-%d.k" % (
numFuncs,
elementsPerFunc,
funcsBetweenExec,
int(callWeighting * 100),
)
generateKScript(
filename,
numFuncs,
elementsPerFunc,
funcsBetweenExec,
callWeighting,
timingScript,
)
print("All done!")
Codebase Browser
llvm