def manipulator(self): """ Define the search space by creating a ConfigurationManipulator """ manipulator = ConfigurationManipulator() manipulator.add_parameter(IntegerParameter(PARAM, 0, 1000)) return manipulator
def manipulator(self):
"""
Define the search space by creating a
ConfigurationManipulator
"""
manipulator = ConfigurationManipulator()
manipulator.add_parameter(
IntegerParameter('BLOCK_SIZE', 1, 10))
return manipulator
def manipulator(self):
"""
Define the search space by creating a
ConfigurationManipulator
"""
m_max = min(160, self.args.end)
n_max = min(160, self.args.end)
self.granularity = 1
assert(0 < self.granularity)
m_max = (m_max + self.granularity - 1) / self.granularity
n_max = (n_max + self.granularity - 1) / self.granularity
m_param = IntegerParameter("M", self.granularity, m_max)
n_param = IntegerParameter("N", self.granularity, n_max)
manipulator = ConfigurationManipulator()
manipulator.add_parameter(m_param)
manipulator.add_parameter(n_param)
return manipulator
def manipulator(self):
"""
Define the search space by creating a
ConfigurationManipulator
"""
self.granularity = 1
assert(0 < self.granularity)
m_max = (64 + self.granularity - 1) / self.granularity
n_max = (256 + self.granularity - 1) / self.granularity
k_max = (256 + self.granularity - 1) / self.granularity
m_param = IntegerParameter("M", self.granularity, m_max)
n_param = IntegerParameter("N", self.granularity, n_max)
k_param = IntegerParameter("K", self.granularity, k_max)
manipulator = ConfigurationManipulator()
manipulator.add_parameter(m_param)
manipulator.add_parameter(n_param)
manipulator.add_parameter(k_param)
return manipulator
def manipulator(self):
"""
Define the search space by creating a
ConfigurationManipulator
"""
self.mintilesize = 2
self.granularity = 1
assert(0 < self.granularity)
minsize = max(self.mintilesize / self.granularity, 1)
maxsize = minsize + self.granularity
m_max = max(min(self.args.maxm, self.args.end), maxsize)
n_max = max(min(self.args.maxn, self.args.end), maxsize)
m_max = (m_max + self.granularity - 1) / self.granularity
n_max = (n_max + self.granularity - 1) / self.granularity
m_param = IntegerParameter("M", minsize, m_max)
n_param = IntegerParameter("N", minsize, n_max)
manipulator = ConfigurationManipulator()
manipulator.add_parameter(m_param)
manipulator.add_parameter(n_param)
return manipulator
def manipulator(self):
"""
Define the search space by creating a
ConfigurationManipulator
"""
self.granularity = 1
assert (0 < self.granularity)
max_m = (256 + self.granularity - 1) / self.granularity
max_n = (256 + self.granularity - 1) / self.granularity
max_k = (256 + self.granularity - 1) / self.granularity
manipulator = ConfigurationManipulator()
manipulator.add_parameter(
IntegerParameter("M", self.granularity, max_m))
manipulator.add_parameter(
IntegerParameter("N", self.granularity, max_n))
manipulator.add_parameter(
IntegerParameter("K", self.granularity, max_k))
return manipulator
def manipulator(self):
"""
Define the search space by creating a
ConfigurationManipulator
"""
manipulator = ConfigurationManipulator()
manipulator.add_parameter(
IntegerParameter('opt_level', 0, 3))
for flag in GCC_FLAGS:
manipulator.add_parameter(
EnumParameter(flag,
['on', 'off']))
for param, min, max in GCC_PARAMS:
manipulator.add_parameter(
IntegerParameter(param, min, max))
return manipulator
def manipulator(self):
"""
Define the search space by creating a
ConfigurationManipulator
"""
manipulator = ConfigurationManipulator()
# manipulator.add_parameter(
# IntegerParameter('blockSize', 8,16))
manipulator.add_parameter(IntegerParameter('opt_level', 0, 3))
manipulator.add_parameter(
EnumParameter('blockSize', ['8', '16', '32', '64', '128']))
return manipulator
def manipulator(self):
"""
Define the search space by creating a
ConfigurationManipulator
"""
manipulator = ConfigurationManipulator()
manipulator.add_parameter(
PermutationParameter('hls_order', list(range(NUM_PASSES))))
for i in range(NUM_PASSES):
manipulator.add_parameter(BooleanParameter(
'hls_pass_{}'.format(i)))
return manipulator
def manipulator(self):
"""
Define the search space by creating a
ConfigurationManipulator
"""
manipulator = ConfigurationManipulator()
manipulator.add_parameter(
IntegerParameter('opt_level', 0, 3))
for flag in GCC_FLAGS:
manipulator.add_parameter(
EnumParameter(flag,
['on', 'off', 'default']))
for param, min, max in GCC_PARAMS:
manipulator.add_parameter(
IntegerParameter(param, min, max))
return manipulator
def manipulator(self):
m = ConfigurationManipulator()
for param in self.int_params:
param_value = self.int_params[param]
if param_value['max'] > 128:
m.add_parameter(
LogIntegerParameter(param, param_value['min'],
param_value['max']))
else:
m.add_parameter(
IntegerParameter(param, param_value['min'],
param_value['max']))
for param in self.power_of_two_params:
param_value = self.power_of_two_params[param]
m.add_parameter(
manipulator.PowerOfTwoParameter(param, param_value['min'],
param_value['max']))
return m
def manipulator(self):
"""Define the search space by creating a
ConfigurationManipulator
"""
list_configs = []
list_configs = read_file_configs()
manipulator = ConfigurationManipulator()
print "Executing manipulator"
for param, mini, maxi in BLOCO_PARAMETROS:
#print "param: ", param, " mini: ", mini, " maxi: ", maxi
manipulator.add_parameter(IntegerParameter(param, mini, maxi))
# E preciso gerar as configuracoes validas com o run.c.
# manipulator.add_parameter(EnumParameter(param, [ 'gx:1024, gy:1, gz:1, bx:1, by:1, bz:1, ', 'gx:32, gy:32, gz:1, bx:1, by:1, bz:1, ' ]))
for param in BLOCO_PARAMETROS_CONFIGS:
manipulator.add_parameter(EnumParameter(param, list_configs))
return manipulator
def manipulator(self):
"""
Define the search space by creating a
ConfigurationManipulator
"""
self.granularity = 1
assert (0 < self.granularity)
m_max = (64 + self.granularity - 1) / self.granularity
n_max = (256 + self.granularity - 1) / self.granularity
k_max = (256 + self.granularity - 1) / self.granularity
m_param = IntegerParameter("M", self.granularity, m_max)
n_param = IntegerParameter("N", self.granularity, n_max)
k_param = IntegerParameter("K", self.granularity, k_max)
manipulator = ConfigurationManipulator()
manipulator.add_parameter(m_param)
manipulator.add_parameter(n_param)
manipulator.add_parameter(k_param)
return manipulator
def manipulator(self) -> ConfigurationManipulator:
"""Define the search space."""
manipulator = ConfigurationManipulator()
# A permutation parameter to order the passes that are present.
manipulator.add_parameter(
PermutationParameter("flag_order", list(range(self.flags_limit))))
# Boolean parameters for whether each pass is present.
for i in range(self.flags_limit):
manipulator.add_parameter(BooleanParameter(f"flag{i}"))
def biased_random():
cfg = ConfigurationManipulator.random(manipulator)
# duplicates in the search space, bias to `n / 2` enabled
disabled = random.sample(range(self.flags_limit),
k=self.flags_limit -
self.env.action_space.n)
cfg.update({f"flag{x}": False for x in disabled})
return cfg
manipulator.random = biased_random
return manipulator
def manipulator(self):
"""
Define the search space by creating a
ConfigurationManipulator
"""
self.dimset = libxsmm_utilities.load_mnklist(self.args.mnk, 0, -1)
self.granularity = 1
assert (0 < self.granularity)
m_max = (64 + self.granularity - 1) / self.granularity
n_max = (256 + self.granularity - 1) / self.granularity
k_max = (256 + self.granularity - 1) / self.granularity
m_param = IntegerParameter("M", self.granularity, m_max)
n_param = IntegerParameter("N", self.granularity, n_max)
k_param = IntegerParameter("K", self.granularity, k_max)
manipulator = ConfigurationManipulator()
manipulator.add_parameter(m_param)
manipulator.add_parameter(n_param)
manipulator.add_parameter(k_param)
return manipulator
#!/usr/bin/env python
#
from opentuner import ConfigurationManipulator
from opentuner.search.manipulator import PowerOfTwoParameter
from opentuner.search.manipulator import IntegerParameter
mdriver_manipulator = ConfigurationManipulator()
"""
See opentuner/search/manipulator.py for more parameter types,
like IntegerParameter, EnumParameter, etc.
TODO(project3): Implement the parameters of your allocator. Once
you have at least one other parameters, feel free to remove ALIGNMENT.
"""
#mdriver_manipulator.add_parameter(IntegerParameter('SMALL_BIN_SEARCH_MAX', 0, 32))
mdriver_manipulator.add_parameter(IntegerParameter('LARGE_BIN_SEARCH_MAX', 0, 32))
mdriver_manipulator.add_parameter(IntegerParameter('EXTENSION_SIZE', 8, 2000))
#mdriver_manipulator.add_parameter(IntegerParameter('INITIAL_CHUNK_SIZE', 0, 40000))
def manipulator(self):
manipulator = ConfigurationManipulator()
manipulator.add_parameter(
LogIntegerParameter("INIT_INTERVAL_HOR", 1, 16))
manipulator.add_parameter(
LogIntegerParameter("INIT_INTERVAL_VER", 1, 16))
manipulator.add_parameter(IntegerParameter("UNROLL_FACTOR_HOR", 1, 2))
manipulator.add_parameter(IntegerParameter("UNROLL_FACTOR_VER", 1, 2))
manipulator.add_parameter(
LogIntegerParameter("ARRAY_PARTITION_FACTOR", 1, 15))
manipulator.add_parameter(
EnumParameter("ACCELERATOR_1_CLOCK", ['0', '1', '2', '3']))
manipulator.add_parameter(
EnumParameter("ACCELERATOR_2_CLOCK", ['0', '1', '2', '3']))
manipulator.add_parameter(
FloatParameter("ACCELERATOR_1_UNCERTAINTY", 0, 100))
manipulator.add_parameter(
FloatParameter("ACCELERATOR_2_UNCERTAINTY", 0, 100))
manipulator.add_parameter(
EnumParameter("DATA_MOVER_CLOCK", ['0', '1', '2', '3']))
return manipulator
#!/usr/bin/env python
#
from opentuner import ConfigurationManipulator
from opentuner.search.manipulator import PowerOfTwoParameter
mdriver_manipulator = ConfigurationManipulator()
"""
See opentuner/search/manipulator.py for more parameter types,
like IntegerParameter, EnumParameter, etc.
TODO(project3): Implement the parameters of your allocator. Once
you have at least one other parameters, feel free to remove ALIGNMENT.
"""
mdriver_manipulator.add_parameter(PowerOfTwoParameter("ALIGNMENT", 8, 8))
mdriver_manipulator.add_parameter(PowerOfTwoParameter("MIN_SIZE", 1, 1 << 17))
mdriver_manipulator.add_parameter(PowerOfTwoParameter("MIN_DIFF", 1, 1 << 17))
#!/usr/bin/env python
#
from opentuner import ConfigurationManipulator
from opentuner.search.manipulator import PowerOfTwoParameter
mdriver_manipulator = ConfigurationManipulator()
"""
See opentuner/search/manipulator.py for more parameter types,
like IntegerParameter, EnumParameter, etc.
TODO(project3): Implement the parameters of your allocator. Once
you have at least one other parameters, feel free to remove ALIGNMENT.
"""
mdriver_manipulator.add_parameter(PowerOfTwoParameter('ALIGNMENT', 8, 8))
def manipulator(self):
"""
Define the search space by creating a
ConfigurationManipulator
"""
# set the global flags needed for printing schedules
if self.args.enable_NUMA_tuning == 0:
self.enable_NUMA_tuning = False
if self.args.enable_parallel_tuning == 0:
self.enable_parallel_tuning = False
if self.args.enable_denseVertexSet_tuning == 0:
self.enable_denseVertexSet_tuning = False
manipulator = ConfigurationManipulator()
manipulator.add_parameter(
EnumParameter('direction', [
'SparsePush', 'DensePull', 'SparsePush-DensePull',
'DensePush-SparsePush'
]))
if self.enable_parallel_tuning:
manipulator.add_parameter(
EnumParameter('parallelization', [
'dynamic-vertex-parallel',
'edge-aware-dynamic-vertex-parallel'
]))
else:
manipulator.add_parameter(
EnumParameter('parallelization', ['serial']))
manipulator.add_parameter(
IntegerParameter('numSSG', 1, self.args.max_num_segments))
if self.enable_NUMA_tuning:
manipulator.add_parameter(
EnumParameter('NUMA', ['serial', 'static-parallel']))
if self.enable_denseVertexSet_tuning:
manipulator.add_parameter(
EnumParameter('DenseVertexSet',
['boolean-array', 'bitvector']))
return manipulator
def manipulator(self):
manipulator = ConfigurationManipulator()
manipulator.add_parameter(IntegerParameter('nsup', 50, 300))
manipulator.add_parameter(IntegerParameter('nrel', 10, 40))
manipulator.add_parameter(IntegerParameter('colperm', 0, 4))
manipulator.add_parameter(IntegerParameter('lookahead', 0, 10))
manipulator.add_parameter(IntegerParameter('numthreads', 1, 10))
'''
Parameters for testing SuperLU
'''
return manipulator
#!/usr/bin/env python
#
from opentuner import ConfigurationManipulator
from opentuner.search.manipulator import PowerOfTwoParameter, IntegerParameter
mdriver_manipulator = ConfigurationManipulator()
"""
See opentuner/search/manipulator.py for more parameter types,
like IntegerParameter, EnumParameter, etc.
TODO(project3): Implement the parameters of your allocator. Once
you have at least one other parameters, feel free to remove ALIGNMENT.
"""
# mdriver_manipulator.add_parameter(PowerOfTwoParameter('ALIGNMENT', 8, 8))
mdriver_manipulator.add_parameter(IntegerParameter('NUMBUCKETS', 2, 128))
mdriver_manipulator.add_parameter(IntegerParameter('BASESIZE', 2, 1000))
#!/usr/bin/env python
#
from opentuner import ConfigurationManipulator
from opentuner.search.manipulator import PowerOfTwoParameter
from opentuner.search.manipulator import IntegerParameter
mdriver_manipulator = ConfigurationManipulator()
"""
See opentuner/search/manipulator.py for more parameter types,
like IntegerParameter, EnumParameter, etc.
TODO(project3): Implement the parameters of your allocator. Once
you have at least one other parameters, feel free to remove ALIGNMENT.
"""
#mdriver_manipulator.add_parameter(IntegerParameter('SMALL_BIN_SEARCH_MAX', 0, 32))
mdriver_manipulator.add_parameter(
IntegerParameter('LARGE_BIN_SEARCH_MAX', 0, 32))
mdriver_manipulator.add_parameter(IntegerParameter('EXTENSION_SIZE', 8, 2000))
#mdriver_manipulator.add_parameter(IntegerParameter('INITIAL_CHUNK_SIZE', 0, 40000))
def manipulator(self):
"""
Returns an object that represents the parameters that can be tuned.
"""
manipulator = ConfigurationManipulator()
if 'ExhaustiveSearch' in self.args.technique:
# manipulator.add_parameter(EnumParameter("CLOCK", ['0', '1', '2', '3']))
# manipulator.add_parameter(EnumParameter("KERNEL_CLOCK", ['0', '1', '2', '3']))
manipulator.add_parameter(LogIntegerParameter("CONVOLVERS", 1, 16))
manipulator.add_parameter(
IntegerParameter("BIN_DENSE_PIPELINE", 1, 16))
# manipulator.add_parameter(IntegerParameter("FP_CONV_UNROLL", 1, 16))
else:
manipulator.add_parameter(
EnumParameter("KERNEL_CLOCK", ['0', '1', '2', '3']))
manipulator.add_parameter(
FloatParameter("CLOCK_UNCERTAINTY", 0, 100))
manipulator.add_parameter(
EnumParameter("DATA_MOVER_CLOCK", ['0', '1', '2', '3']))
manipulator.add_parameter(
EnumParameter("DATA_MOVER_SHARING", ['0', '1', '2', '3']))
manipulator.add_parameter(IntegerParameter("IMPL_STRATEGY", 0, 27))
manipulator.add_parameter(
LogIntegerParameter("CONVOLVERS", 1, 16, prior="inc"))
manipulator.add_parameter(
IntegerParameter("BIN_DENSE_PIPELINE", 1, 16, prior="dec"))
manipulator.add_parameter(
IntegerParameter("FP_CONV_UNROLL", 1, 16, prior="inc"))
return manipulator
def manipulator(self):
"""
Define the search space by creating a
ConfigurationManipulator
"""
sys.stderr.write('AUTOTUNER: Create the design space\n')
# Check if manipulator has already been invoked
defineDesignSpace = len(self.designSpace) == 0
# Read the range of each dimension of the design space
inputFile = os.environ['RANGE_FILE']
ranges = utils.readFile(inputFile)
# Describe the design space to opentuner
param = 0
manipulator = ConfigurationManipulator()
for elem in ranges:
# Check if there is a design space
if defineDesignSpace:
self.designSpace.append(elem)
# Check if the current dimension has a cardinality higher than 1
if elem > 1:
# Check the type of the parameter
paramType = param % 9
# Create the parameter
if paramType == 0:
# Should the loop be parallelized?
openTuner_param = SwitchParameter(str(param), elem)
elif paramType == 1:
# Unroll factor
openTuner_param = IntegerParameter(str(param), 0,
str(elem - 1))
elif paramType == 2:
# Peel factor
openTuner_param = IntegerParameter(str(param), 0,
str(elem - 1))
elif paramType == 3:
# Parallelization technique
openTuner_param = IntegerParameter(str(param), 0,
str(elem - 1))
elif paramType == 4:
# Number of cores to dedicate to the current loop
openTuner_param = IntegerParameter(str(param), 0,
str(elem - 1))
elif paramType == 5:
# DOALL parameter: chunk factor
openTuner_param = IntegerParameter(str(param), 0,
str(elem - 1))
elif paramType == 6:
# HELIX parameter: should we fix the maximum number of sequential segments?
openTuner_param = SwitchParameter(str(param), elem)
elif paramType == 7:
# HELIX parameter: maximum number of sequential segments
openTuner_param = IntegerParameter(str(param), 0,
str(elem - 1))
elif paramType == 8:
# DSWP parameter: should we use queue packing?
openTuner_param = SwitchParameter(str(param), elem)
# Share the parameter to OpenTuner
manipulator.add_parameter(openTuner_param)
param += 1
# Load outputDistortion module if possible
benchmark = os.environ['BENCHMARK_NAME']
self.outputDistortionModule = None
try:
self.outputDistortionModule = importlib.import_module(
'benchmark.' + benchmark + '.outputDistortion')
except ImportError:
self.outputDistortionModule = None
if defineDesignSpace:
sys.stderr.write('AUTOTUNER: Whole design space (' +
str(len(self.designSpace)) + ') = ' +
str(self.designSpace) + '\n')
return manipulator
def manipulator(self):
"""
Define the search space by creating a
ConfigurationManipulator
"""
# set the global flags needed for printing schedules
if self.args.enable_NUMA_tuning == 0:
self.enable_NUMA_tuning = False
if self.args.enable_parallel_tuning == 0:
self.enable_parallel_tuning = False
if self.args.enable_denseVertexSet_tuning == 0:
self.enable_denseVertexSet_tuning = False
manipulator = ConfigurationManipulator()
manipulator.add_parameter(
EnumParameter('direction',
['SparsePush','DensePull', 'SparsePush-DensePull', 'DensePush-SparsePush']))
#'edge-aware-dynamic-vertex-parallel' not supported with the latest g++ cilk implementation
if self.enable_parallel_tuning:
manipulator.add_parameter(EnumParameter('parallelization',['dynamic-vertex-parallel']))
else:
manipulator.add_parameter(EnumParameter('parallelization', ['serial']))
manipulator.add_parameter(IntegerParameter('numSSG', 1, self.args.max_num_segments))
if self.enable_NUMA_tuning:
manipulator.add_parameter(EnumParameter('NUMA',['serial','static-parallel']))
if self.enable_denseVertexSet_tuning:
manipulator.add_parameter(EnumParameter('DenseVertexSet', ['boolean-array', 'bitvector']))
# adding new parameters for PriorityGraph (Ordered GraphIt)
manipulator.add_parameter(IntegerParameter('delta', 1, self.args.max_delta))
manipulator.add_parameter(
EnumParameter('bucket_update_strategy',
['eager_priority_update','eager_priority_update_with_merge', 'lazy_priority_update']))
return manipulator
def manipulator(self):
"""
Define the search space by creating a
ConfigurationManipulator
"""
manipulator = ConfigurationManipulator()
manipulator.add_parameter(IntegerParameter('batch_size', 50, 200))
manipulator.add_parameter(IntegerParameter('layer', 1, 5))
manipulator.add_parameter(IntegerParameter('neural', 50, 200))
manipulator.add_parameter(IntegerParameter('max_iter', 1, 500))
manipulator.add_parameter(FloatParameter('learning_rate_init', 0.0001, 0.01))
manipulator.add_parameter(FloatParameter('power_t', 0.2, 0.8))
manipulator.add_parameter(FloatParameter('alpha', 0.00001, 0.001))
return manipulator
def manipulator(self):
"""Setup common state and define search space"""
manipulator = ConfigurationManipulator()
# parse and sanitize kernel shape argument
if not self.args.mnk:
self.args.mnk = default_mnk
mnk = tuple(max(int(i), 1) for i in self.args.mnk.split("x"))
self.mnk = (mnk + (mnk[0], mnk[0]))[:3]
# sanitize input arguments
self.args.mb = max(self.args.mb, 1)
self.args.bs = max(min(self.args.bs, self.args.mb), 1)
self.args.bm = [max(self.args.bm, 1), self.mnk[0]][0 == self.args.bm]
self.args.bn = [max(self.args.bn, 1), 1][0 == self.args.bn]
self.args.bk = [max(self.args.bk, 1), self.mnk[2]][0 == self.args.bk]
self.args.ws = min(self.args.ws, self.mnk[0] * self.mnk[1])
self.bs = self.bm = self.bn = self.bk = self.ws = self.wg = self.lu = None
self.nz = self.al = self.tb = self.tc = None
self.ap = self.aa = self.ab = self.ac = None
self.typename = self.typeid = None
self.device = self.size = None
self.gfbase = self.gflops = 0
self.config = None
self.exename = "acc_bench_smm"
self.exepath = os.path.join(
os.path.dirname(sys.argv[0]), "..", "..", self.exename
)
run_result = ( # verbosity to capture device name and tuned parameters
self.launch(["ACC_OPENCL_VERBOSE=2", "CHECK=0"], nrep=1)
if (self.args.merge is None or 0 > self.args.merge)
and (self.args.update is None or "" == self.args.update)
else None
)
if run_result:
stdout = str(run_result["stdout"])
if 0 >= self.args.size:
size = re.search(
"{}\\s+[0-9]+\\s+([0-9]+)".format(self.exepath),
stdout,
)
self.size = int(size.group(1)) if size and size.group(1) else 0
else:
self.size = self.args.size
typename = re.search("typename \\(id=([0-9]+)\\):\\s+(\\w+)", stdout)
self.typename = typename.group(2) if typename and typename.group(2) else ""
self.typeid = (
int(typename.group(1)) if typename and typename.group(1) else 0
)
device = re.search(
'INFO ACC/OpenCL:\\s+ndevices=[0-9]+\\s+device[0-9]+="(.+)"\\s+uid=',
str(run_result["stderr"]),
)
self.device = device.group(1) if device and device.group(1) else ""
elif self.args.update is not None and "" != self.args.update:
self.device = self.args.update
if run_result and 0 == run_result["returncode"]:
seedpat = "INFO ACC/OpenCL:\\s+SMM-kernel\\s+{}={}\\s+gen=".format(
"{t,m,n,k, bs,bm,bn,bk, ws,wg, lu,nz,al, tb,tc, ap,aa,ab,ac}",
"{{{}, {}}}".format( # key and value
"{},{},{},{}".format( # t,m,n,k (key)
self.typeid, self.mnk[0], self.mnk[1], self.mnk[2]
),
"{}, {}, {}, {}, {}".format( # value: some can be neg. hence "-*[0-9]+"
"(-*[0-9]+),(-*[0-9]+),(-*[0-9]+),(-*[0-9]+)", # bs,bm,bn,bk
"(-*[0-9]+),(-*[0-9]+)", # ws,wg
"(-*[0-9]+),(-*[0-9]+),(-*[0-9]+)", # lu,nz,al
"(-*[0-9]+),(-*[0-9]+)", # tb,tc
"(-*[0-9]+),(-*[0-9]+),(-*[0-9]+),(-*[0-9]+)", # ap,aa,ab,ac
),
),
)
seed = re.search(seedpat, str(run_result["stderr"]))
if 15 != (len(seed.groups()) if seed else 0):
print("WARNING: missed to parse initial parameters!")
# setup fixed and tunable parameters
params, paramt = [], []
self.create_param("BS", params, paramt, seed, 1, 1, self.args.mb)
self.create_param("BM", params, paramt, seed, 2, 1, self.mnk[0])
self.create_param("BN", params, paramt, seed, 3, 1, self.mnk[1])
self.create_param("BK", params, paramt, seed, 4, 1, self.mnk[0])
self.create_param(
"WS", params, paramt, seed, 5, 1, self.mnk[0] * self.mnk[1]
)
self.create_param("WG", params, paramt, seed, 6, -2, 1) # avoid WG=2
self.create_param("LU", params, paramt, seed, 7, -2, 2)
self.create_param("NZ", params, paramt, seed, 8, 0, 1)
self.create_param("AL", params, paramt, seed, 9, 0, 1)
self.create_param("TB", params, paramt, seed, 10, 0, 1)
self.create_param("TC", params, paramt, seed, 11, 0, 1)
self.create_param("AP", params, paramt, seed, 12, 0, 1)
self.create_param("AA", params, paramt, seed, 13, 0, 3)
self.create_param("AB", params, paramt, seed, 14, 0, 3)
self.create_param("AC", params, paramt, seed, 15, 0, 2)
if not paramt:
sys.tracebacklimit = 0
raise RuntimeError(
"All tunable parameters are fixed with environment variables!"
)
for param in params + paramt:
manipulator.add_parameter(param)
# consider to update and/or merge JSONS (update first)
if (
(self.args.merge is not None and (0 <= self.args.merge or self.typeid))
or self.args.update is None
or "" != self.args.update
):
filepattern = "{}-*.json".format(default_basename)
filenames = glob.glob(
os.path.normpath(os.path.join(self.args.jsondir, filepattern))
)
if self.args.update is None or "" != self.args.update:
self.update_jsons(filenames)
if self.args.merge is not None:
self.merge_jsons(filenames)
exit(0)
elif (
(self.typename and "" != self.typename)
and (self.device and "" != self.device)
and (self.size and 0 < self.size)
and self.typeid
): # construct label used for the database session
if not self.args.label: # consider to include self.device
self.args.label = "{}-{}-{}x{}x{}-s{}".format(
default_basename,
self.typename,
self.mnk[0],
self.mnk[1],
self.mnk[2],
ilog2(self.size),
)
else:
sys.tracebacklimit = 0
raise RuntimeError("Setup failed for {}!".format(self.exepath))
# register signal handler (CTRL-C)
signal(SIGINT, self.handle_sigint)
return manipulator
#!/usr/bin/env python
#
from opentuner import ConfigurationManipulator
from opentuner.search.manipulator import PowerOfTwoParameter
mdriver_manipulator = ConfigurationManipulator()
"""
See opentuner/search/manipulator.py for more parameter types,
like IntegerParameter, EnumParameter, etc.
TODO(project3): Implement the parameters of your allocator. Once
you have at least one other parameters, feel free to remove ALIGNMENT.
"""
mdriver_manipulator.add_parameter(PowerOfTwoParameter('ALIGNMENT', 8, 8))
def manipulator(self):
"""
Returns an object that represents the parameters that can be tuned.
"""
manipulator = ConfigurationManipulator()
manipulator.add_parameter(BooleanParameter("PIPELINE_SUB"))
manipulator.add_parameter(BooleanParameter("PIPELINE_ADDKEY"))
manipulator.add_parameter(BooleanParameter("PIPELINE_CPKEY"))
manipulator.add_parameter(BooleanParameter("PIPELINE_MIX"))
manipulator.add_parameter(BooleanParameter("PIPELINE_EXP1"))
manipulator.add_parameter(BooleanParameter("PIPELINE_EXP2"))
manipulator.add_parameter(BooleanParameter("PIPELINE_ECB1"))
manipulator.add_parameter(BooleanParameter("PIPELINE_ECB2"))
manipulator.add_parameter(BooleanParameter("PIPELINE_ECB3"))
manipulator.add_parameter(
IntegerParameter("UNROLL_FACTOR_SUB", 1, 16, prior="inc"))
manipulator.add_parameter(
IntegerParameter("UNROLL_FACTOR_ADDKEY", 1, 16, prior="inc"))
manipulator.add_parameter(
IntegerParameter("UNROLL_FACTOR_CPKEY", 1, 16, prior="inc"))
manipulator.add_parameter(
IntegerParameter("UNROLL_FACTOR_MIX", 1, 4, prior="inc"))
manipulator.add_parameter(
IntegerParameter("UNROLL_FACTOR_EXP1", 1, 3, prior="inc"))
manipulator.add_parameter(
IntegerParameter("UNROLL_FACTOR_EXP2", 1, 3, prior="inc"))
manipulator.add_parameter(
IntegerParameter("UNROLL_FACTOR_ECB1", 1, 32, prior="inc"))
manipulator.add_parameter(
IntegerParameter("UNROLL_FACTOR_ECB2", 1, 8, prior="inc"))
manipulator.add_parameter(
IntegerParameter("UNROLL_FACTOR_ECB3", 1, 13, prior="inc"))
manipulator.add_parameter(
IntegerParameter("PIPELINE_II_SUB", 1, 16, prior="dec"))
manipulator.add_parameter(
IntegerParameter("PIPELINE_II_ADDKEY", 1, 16, prior="dec"))
manipulator.add_parameter(
IntegerParameter("PIPELINE_II_CPKEY", 1, 16, prior="dec"))
manipulator.add_parameter(
IntegerParameter("PIPELINE_II_MIX", 1, 4, prior="dec"))
manipulator.add_parameter(
IntegerParameter("PIPELINE_II_EXP1", 1, 3, prior="dec"))
manipulator.add_parameter(
IntegerParameter("PIPELINE_II_EXP2", 1, 3, prior="dec"))
manipulator.add_parameter(
IntegerParameter("PIPELINE_II_ECB1", 1, 32, prior="dec"))
manipulator.add_parameter(
IntegerParameter("PIPELINE_II_ECB2", 1, 8, prior="dec"))
manipulator.add_parameter(
IntegerParameter("PIPELINE_II_ECB3", 1, 13, prior="dec"))
manipulator.add_parameter(
EnumParameter("KERNEL_CLOCK", ['0', '1', '2', '3']))
manipulator.add_parameter(
EnumParameter("DATA_MOVER_CLOCK", ['0', '1', '2', '3']))
return manipulator
def manipulator(self):
"""
Define the search space by creating a
ConfigurationManipulator
"""
manipulator = ConfigurationManipulator()
manipulator.add_parameter(
EnumParameter('hibench.yarn.executor.cores',
['1', '4', '8', '16', '24', '48']))
manipulator.add_parameter(
EnumParameter('hibench.yarn.executor.num',
['1', '2', '3', '6', '12', '48']))
manipulator.add_parameter(IntegerParameter('spark.task.cpus', 1, 4))
manipulator.add_parameter(
EnumParameter('spark.shuffle.compress', ['1', '0']))
manipulator.add_parameter(
EnumParameter('spark.memory.fraction',
['0.25', '0.4', '0.5', '0.6', '0.7', '0.8']))
manipulator.add_parameter(EnumParameter('spark.serializer',
['0', '1']))
manipulator.add_parameter(
EnumParameter('spark.scheduler.maxRegisteredResourcesWaitingTime',
['10', '15', '25', '30', '40', '60']))
manipulator.add_parameter(
EnumParameter(
'spark.default.parallelism',
['8', '15', '25', '35', '50', '-1'
])) #-1 represents default value of config and we need it
manipulator.add_parameter(
EnumParameter('spark.sql.shuffle.partitions',
['75', '100', '150', '200', '250', '400']))
manipulator.add_parameter(
EnumParameter('spark.cleaner.periodicGC.interval',
['5', '10', '15', '30', '35', '60']))
manipulator.add_parameter(
EnumParameter('spark.io.compression.lz4.blockSize',
['8', '16', '32', '40', '64', '80']))
manipulator.add_parameter(
EnumParameter('spark.memory.storageFraction',
['0.3', '0.35', '0.4', '0.5', '0.6', '0.7']))
manipulator.add_parameter(
EnumParameter('spark.yarn.am.memory',
['256', '400', '512', '750', '1000', '1500']))
manipulator.add_parameter(
EnumParameter('spark.scheduler.revive.interval',
['1000', '1500', '2000', '2500', '3000', '4000']))
manipulator.add_parameter(
EnumParameter('spark.locality.wait.process',
['1500', '2000', '2500', '3000', '4000', '6000']))
manipulator.add_parameter(
EnumParameter('spark.shuffle.sort.bypassMergeThreshold',
['75', '100', '150', '200', '250', '400']))
manipulator.add_parameter(
EnumParameter('spark.shuffle.io.preferDirectBufs', ['1', '0']))
manipulator.add_parameter(
EnumParameter('spark.task.maxFailures',
['1', '2', '3', '4', '6', '8']))
manipulator.add_parameter(
EnumParameter('spark.files.openCostInBytes', [
'1000000', '2000000', '3500000', '4194304', '7000000',
'9000000'
]))
manipulator.add_parameter(
EnumParameter('spark.shuffle.file.buffer',
['16', '28', '32', '45', '64', '80']))
manipulator.add_parameter(
EnumParameter('spark.cleaner.referenceTracking.blocking',
['1', '0']))
manipulator.add_parameter(
EnumParameter('spark.kryoserializer.buffer.max',
['24', '32', '50', '64', '90', '128']))
manipulator.add_parameter(
EnumParameter('spark.executor.memory', [
'600', '1000', '2400', '4800', '9600', '19200', '54000',
'108000'
]))
return manipulator
def manipulator(self):
manipulator = ConfigurationManipulator()
for param in self.adjParams:
manipulator.add_parameter(param)
return manipulator
#!/usr/bin/env python
#
from opentuner import ConfigurationManipulator
from opentuner.search.manipulator import PowerOfTwoParameter
from opentuner.search.manipulator import IntegerParameter
mdriver_manipulator = ConfigurationManipulator()
"""
See opentuner/search/manipulator.py for more parameter types,
like IntegerParameter, EnumParameter, etc.
TODO(project3): Implement the parameters of your allocator. Once
you have at least one other parameters, feel free to remove ALIGNMENT.
"""
mdriver_manipulator.add_parameter(PowerOfTwoParameter('ALIGNMENT', 8, 8))
mdriver_manipulator.add_parameter(
PowerOfTwoParameter('MIN_BLOCK_SIZE', 16, 32768))
mdriver_manipulator.add_parameter(
PowerOfTwoParameter('MIN_SPLIT_SIZE', 16, 32768))
def manipulator(self):
manipulator = ConfigurationManipulator()
manipulator.add_parameter(PowerOfTwoParameter('local1D', 1, 64))
#manipulator.add_parameter(PowerOfTwoParameter('local2D_x',1,1024))
#manipulator.add_parameter(PowerOfTwoParameter('local2D_y',1,1024))
return manipulator
#!/usr/bin/env python
#
from opentuner import ConfigurationManipulator
from opentuner.search.manipulator import PowerOfTwoParameter
mdriver_manipulator = ConfigurationManipulator()
"""
See opentuner/search/manipulator.py for more parameter types,
like IntegerParameter, EnumParameter, etc.
TODO(project3): Implement the parameters of your allocator. Once
you have at least one other parameters, feel free to remove ALIGNMENT.
"""
#mdriver_manipulator.add_parameter(PowerOfTwoParameter('ALIGNMENT', 8, 8))
mdriver_manipulator.add_parameter(PowerOfTwoParameter('BLOCK_SIZE', 32, 32768))
def manipulator(self):
"""
Define the search space by creating a
ConfigurationManipulator
"""
manipulator = ConfigurationManipulator()
for i, param in enumerate(self.params):
if param[0] == "None":
continue
if param[0] == "Int":
manipulator.add_parameter(
IntegerParameter(i, int(param[1]), int(param[2])))
continue
if param[0] == "Log":
manipulator.add_parameter(
LogIntegerParameter(i, int(param[1]), int(param[2])))
continue
if param[0] == "Pow":
manipulator.add_parameter(
PowerOfTwoParameter(i, 2**int(param[1]), 2**int(param[2])))
continue
if param[0] == "Switch":
manipulator.add_parameter(SwitchParameter(i, int(param[1])))
continue
if param[0] == "Bool":
manipulator.add_parameter(BooleanParameter(i))
continue
return manipulator
