def fillInMissingStepsWithDefaults(self, config):
print2("")
print2(
"####################################################################"
)
print1("# Filling in Parameters With Defaults")
print2(
"####################################################################"
)
print2("")
############################################################################
# (I-0) get 6 phases from config
configBenchmarkCommonParameters = config["BenchmarkCommonParameters"] \
if "BenchmarkCommonParameters" in config \
else [{"ProblemSizes": defaultProblemSizes}]
configForkParameters = config["ForkParameters"] \
if "ForkParameters" in config else []
configBenchmarkForkParameters = config["BenchmarkForkParameters"] \
if "BenchmarkForkParameters" in config \
else []
configJoinParameters = config["JoinParameters"] \
if "JoinParameters" in config else []
configBenchmarkJoinParameters = config["BenchmarkJoinParameters"] \
if "BenchmarkJoinParameters" in config \
else []
configBenchmarkFinalParameters = config["BenchmarkFinalParameters"] \
if "BenchmarkFinalParameters" in config and config["BenchmarkFinalParameters"] != None \
and len(config["BenchmarkFinalParameters"]) > 0 \
else [{"ProblemSizes": defaultBenchmarkFinalProblemSizes}]
############################################################################
# Ensure only valid solution parameters were requested
validParameterNames = validParameters.keys()
for paramDictList in [configBenchmarkCommonParameters, \
configForkParameters, configBenchmarkForkParameters, \
configBenchmarkJoinParameters]:
if paramDictList != None:
for paramDict in paramDictList:
for paramName in paramDict:
if paramName in ["ProblemSizes"]:
continue
else:
if paramName not in validParameterNames:
printExit("Invalid parameter name: %s\nValid parameters are %s." \
% (paramName, validParameterNames))
paramValues = paramDict[paramName]
for paramValue in paramValues:
if paramValue not in validParameters[
paramName]:
printExit("Invalid parameter value: %s = %s\nValid values for %s are %s." \
% (paramName, paramValue, paramName, validParameters[paramName]))
############################################################################
# (I-1) get current problem sizes
currentProblemSizes = defaultProblemSizes
if configBenchmarkCommonParameters != None:
if len(configBenchmarkCommonParameters) > 0:
if "ProblemSizes" in configBenchmarkCommonParameters[0]:
# user specified, so use it, remove it from config and insert later
currentProblemSizes = \
configBenchmarkCommonParameters[0]["ProblemSizes"]
del configBenchmarkCommonParameters[0]
# into common we put in all Dcommon that
# don't show up in Ccommon/Cfork/CBfork/Cjoin/CBjoin
# followed by Ccommon
self.benchmarkCommonParameters = [{
"ProblemSizes": currentProblemSizes
}]
for paramDict in defaultBenchmarkCommonParameters:
for paramName in paramDict:
if not hasParam( paramName, [ configBenchmarkCommonParameters, \
configForkParameters, configBenchmarkForkParameters, \
configJoinParameters, configBenchmarkJoinParameters]) \
or paramName == "ProblemSizes":
self.benchmarkCommonParameters.append(paramDict)
if configBenchmarkCommonParameters != None:
for paramDict in configBenchmarkCommonParameters:
self.benchmarkCommonParameters.append(paramDict)
else: # make empty
self.benchmarkCommonParameters = [{
"ProblemSizes":
currentProblemSizes
}]
############################################################################
# (I-2) into fork we put in all Dfork that
# don't show up in Bcommon/Cfork/CBfork/Cjoin/CBjoin
# followed by Cfork
self.forkParameters = []
for paramDict in defaultForkParameters:
for paramName in paramDict:
if not hasParam( paramName, [ self.benchmarkCommonParameters, \
configForkParameters, configBenchmarkForkParameters, \
configJoinParameters, configBenchmarkJoinParameters]) \
or paramName == "ProblemSizes":
self.forkParameters.append(paramDict)
if configForkParameters != None:
for paramDict in configForkParameters:
self.forkParameters.append(paramDict)
else: # make empty
self.forkParameters = []
############################################################################
# (I-3) get current problem sizes
if configBenchmarkForkParameters != None:
if len(configBenchmarkForkParameters) > 0:
if "ProblemSizes" in configBenchmarkForkParameters[0]:
# user specified, so use it, remove it from config and insert later
currentProblemSizes = configBenchmarkForkParameters[0][
"ProblemSizes"]
del configBenchmarkForkParameters[0]
# into Bfork we put in all DBfork that
# don't show up in Bcommon/Bfork/CBfork/Cjoin/CBjoin
# followed by CBforked
self.benchmarkForkParameters = [{"ProblemSizes": currentProblemSizes}]
for paramDict in defaultBenchmarkForkParameters:
for paramName in paramDict:
if not hasParam( paramName, [ self.benchmarkCommonParameters, \
self.forkParameters, configBenchmarkForkParameters, \
configJoinParameters, configBenchmarkJoinParameters]) \
or paramName == "ProblemSizes":
self.benchmarkForkParameters.append(paramDict)
if configBenchmarkForkParameters != None:
for paramDict in configBenchmarkForkParameters:
self.benchmarkForkParameters.append(paramDict)
else: # make empty
self.benchmarkForkParameters = [{
"ProblemSizes": currentProblemSizes
}]
############################################################################
# (I-4) into join we put in all non-derrived Djoin that
# don't show up in Bcommon/Bfork/CBfork/Cjoin/CBjoin
# followed by CBforked
self.joinParameters = []
for paramName in defaultJoinParameters:
if not hasParam( paramName, [ self.benchmarkCommonParameters, \
self.forkParameters, self.benchmarkForkParameters, \
configJoinParameters, configBenchmarkJoinParameters]) \
or paramName == "ProblemSizes":
if "JoinParameters" not in config \
or (paramName != "MacroTile"):
self.joinParameters.append(paramName)
if configJoinParameters != None:
for paramName in configJoinParameters:
self.joinParameters.append(paramName)
else: # make empty
self.joinParameters = []
############################################################################
# (I-5) benchmark join
if configBenchmarkJoinParameters != None:
if len(configBenchmarkJoinParameters) > 0:
if "ProblemSizes" in configBenchmarkJoinParameters[0]:
# user specified, so use it, remove it from config and insert later
currentProblemSizes = configBenchmarkJoinParameters[0][
"ProblemSizes"]
del configBenchmarkJoinParameters[0]
# into Bjoin we put in all DBjoin that
# don't show up in Bcommon/Bfork/BBfork/Bjoin/CBjoin
# followed by CBjoin
self.benchmarkJoinParameters = [{"ProblemSizes": currentProblemSizes}]
for paramDict in defaultBenchmarkJoinParameters:
for paramName in paramDict:
if not hasParam( paramName, [ self.benchmarkCommonParameters, \
self.forkParameters, self.benchmarkForkParameters, \
self.joinParameters, configBenchmarkJoinParameters]) \
or paramName == "ProblemSizes":
self.benchmarkJoinParameters.append(paramDict)
if configBenchmarkJoinParameters != None:
for paramDict in configBenchmarkJoinParameters:
self.benchmarkJoinParameters.append(paramDict)
else: # make empty
self.benchmarkJoinParameters = [{
"ProblemSizes": currentProblemSizes
}]
############################################################################
# (I-6) benchmark final sizes
self.benchmarkFinalParameters = configBenchmarkFinalParameters
# no other parameters besides problem sizes
############################################################################
# (I-7) any default param with 1 value will be hardcoded; move to beginning
for stepList in [self.benchmarkCommonParameters, \
self.forkParameters, self.benchmarkForkParameters, \
self.benchmarkJoinParameters]:
for paramDict in copy(stepList):
for paramName in copy(paramDict):
paramValues = paramDict[paramName]
if paramValues == None:
printExit(
"You must specify value for parameters \"%s\"" %
paramName)
if len(paramValues) < 2 and paramName != "ProblemSizes":
paramDict.pop(paramName)
#self.benchmarkCommonParameters.insert(0, {paramName: paramValues })
self.hardcodedParameters[0][paramName] = paramValues[0]
self.singleValueParameters[paramName] = [
paramValues[0]
]
self.initialSolutionParameters[
paramName] = paramValues[0]
if len(paramDict) == 0:
stepList.remove(paramDict)
############################################################################
# (I-8) if fork and join, but no benchmark fork, append dummy benchmarkFork
if len(self.forkParameters) > 0 and len(self.joinParameters) > 0 \
and (len(self.benchmarkForkParameters) == 0 \
or (len(self.benchmarkForkParameters) == 1 \
and hasParam("ProblemSizes", self.benchmarkForkParameters)) ):
self.benchmarkForkParameters.append({"BenchmarkFork": [0]})
############################################################################
# (I-9) if join, but no benchmark join, append dummy benchmarkJoin
#if len(self.joinParameters) > 0 \
# and (len(self.benchmarkJoinParameters) == 0 \
# or (len(self.benchmarkJoinParameters) == 1 \
# and hasParam("ProblemSizes", self.benchmarkJoinParameters)) ):
# self.benchmarkJoinParameters.append({"BenchmarkJoin": [0]})
# No, this is handles by Final Benchmark
############################################################################
# (I-10) Parameter Lists
# benchmarkCommonParameters
print2("HardcodedParameters:")
for paramName in self.hardcodedParameters[0]:
paramValues = self.hardcodedParameters[0][paramName]
print2(" %s: %s" % (paramName, paramValues))
print2("BenchmarkCommonParameters:")
for step in self.benchmarkCommonParameters:
print2(" %s" % step)
# forkParameters
print2("ForkParameters:")
for param in self.forkParameters:
print2(" %s" % param)
# benchmarkForkParameters
print2("BenchmarkForkParameters:")
for step in self.benchmarkForkParameters:
print2(" %s" % step)
# joinParameters
print2("JoinParameters:")
for param in self.joinParameters:
print2(" %s" % param)
# benchmarkJoinParameters
print2("BenchmarkJoinParameters:")
for step in self.benchmarkJoinParameters:
print2(" %s" % step)
# benchmarkJoinParameters
print2("BenchmarkFinalParameters:")
for step in self.benchmarkFinalParameters:
print2(" %s" % step)
def convertParametersToSteps(self):
print2("")
print2(
"####################################################################"
)
print1("# Convert Parameters to Steps")
print2(
"####################################################################"
)
print2("")
############################################################################
# (II-1) benchmark common parameters
print2("")
print2(
"####################################################################"
)
print1("# Benchmark Common Parameters")
self.addStepsForParameters(self.benchmarkCommonParameters)
############################################################################
# (II-2) fork parameters
# calculate permutations of
print2("")
print2(
"####################################################################"
)
print1("# Fork Parameters")
print2(self.forkParameters)
totalPermutations = 1
for param in self.forkParameters:
for name in param: # only 1
values = param[name]
totalPermutations *= len(values)
forkPermutations = []
for i in range(0, totalPermutations):
forkPermutations.append({})
pIdx = i
for param in self.forkParameters:
for name in param:
values = param[name]
valueIdx = pIdx % len(values)
forkPermutations[i][name] = values[valueIdx]
pIdx /= len(values)
if len(forkPermutations) > 0:
self.forkHardcodedParameters(forkPermutations)
############################################################################
# (II-3) benchmark fork parameters
print2("")
print2(
"####################################################################"
)
print1("# Benchmark Fork Parameters")
self.addStepsForParameters(self.benchmarkForkParameters)
############################################################################
# (II-4.1) join parameters
# answer should go in hard-coded parameters
# does it remove the prior forks? Yes.
print2("")
print2(
"####################################################################"
)
print1("# Join Parameters")
macroTileJoinSet = set()
totalPermutations = 1
if len(self.joinParameters) > 0:
for joinName in self.joinParameters:
# joining a parameter with only a single value
if hasParam(joinName, self.singleValueParameters):
pass
elif hasParam(joinName, self.forkParameters):
# count permutations
for param in self.forkParameters:
for name in param: # only 1
if name == joinName:
values = param[name]
localPermutations = len(values)
print2(
"JoinParameter %s has %u possibilities" %
(joinName, localPermutations))
totalPermutations *= localPermutations
##########################################################################
# (II-4.2) Join MacroTile
elif joinName == "MacroTile":
print2("JoinParam: MacroTile")
# get possible WorkGroupEdges from forked
print2("currentForkParameters = %s" %
str(self.forkParameters))
threadTileValues = []
workGroupValues = []
# todo having MacroTile as join parameter causes trouble if
# one parameter is benchmarked rather than forked
# however, this may still be the right way to do it
# count permutations
for paramList in [self.benchmarkCommonParameters, \
self.forkParameters, self.benchmarkForkParameters, \
self.benchmarkJoinParameters, self.singleValueParameters ]:
if hasParam("ThreadTile", paramList):
threadTileValues = getParamValues(
"ThreadTile", paramList)
if hasParam("WorkGroup", paramList):
workGroupValues = getParamValues(
"WorkGroup", paramList)
macroTilePermutations = len(workGroupValues) * len(
threadTileValues)
print2("# Total JoinMacroTile Permutations: %u" %
macroTilePermutations)
# enumerate permutations
for i in range(0, macroTilePermutations):
pIdx = i
workGroupIdx = pIdx % len(workGroupValues)
pIdx /= len(workGroupValues)
threadTileIdx = pIdx % len(threadTileValues)
workGroup = workGroupValues[workGroupIdx]
threadTile = threadTileValues[threadTileIdx]
macroTile0 = workGroup[0] * threadTile[0]
macroTile1 = workGroup[1] * threadTile[1]
macroTileJoinSet.add((macroTile0, macroTile1))
totalPermutations *= len(macroTileJoinSet)
print2("JoinMacroTileSet(%u): %s" %
(len(macroTileJoinSet), macroTileJoinSet))
# invalid join parameter
else:
validJoinNames = ["MacroTile"]
for validParam in self.forkParameters:
for validName in validParam: # only 1
validJoinNames.append(validName)
printExit("JoinParameter \"%s\" not in %s" %
(joinName, validJoinNames))
############################################################################
# (II-4.4) Enumerate Permutations Other * MacroTile * DepthU
macroTiles = list(macroTileJoinSet)
print2("# TotalJoinPermutations = %u" % (totalPermutations))
joinPermutations = []
for i in range(0, totalPermutations):
joinPermutations.append({})
pIdx = i
for joinName in self.joinParameters:
if hasParam(joinName, self.forkParameters):
for paramDict in self.forkParameters: # hardcodedPermutations
if joinName in paramDict:
paramValues = paramDict[joinName]
valueIdx = pIdx % len(paramValues)
joinPermutations[i][joinName] = paramValues[
valueIdx]
pIdx /= len(paramValues)
break
elif joinName == "MacroTile":
valueIdx = pIdx % len(macroTiles)
pIdx /= len(macroTiles)
joinPermutations[i]["MacroTile0"] = macroTiles[
valueIdx][0]
joinPermutations[i]["MacroTile1"] = macroTiles[
valueIdx][1]
if len(joinPermutations) > 0:
self.joinHardcodedParameters(joinPermutations)
############################################################################
# (II-5) benchmark join parameters
print2("")
print2(
"####################################################################"
)
print1("# Benchmark Join Parameters")
self.addStepsForParameters(self.benchmarkJoinParameters)
############################################################################
# (II-6) benchmark final
print2("")
print2(
"####################################################################"
)
print1("# Benchmark Final")
for problemSizesDict in self.benchmarkFinalParameters:
problemSizes = problemSizesDict["ProblemSizes"]
self.currentProblemSizes = ProblemSizes(self.problemType,
problemSizes)
currentBenchmarkParameters = {}
benchmarkStep = BenchmarkStep(self.hardcodedParameters,
currentBenchmarkParameters,
self.initialSolutionParameters,
self.currentProblemSizes,
self.benchmarkStepIdx)
self.benchmarkSteps.append(benchmarkStep)
self.benchmarkStepIdx += 1