def __init__(self,
instructions,
attribute,
targetvalue,
maxvalue=None,
minvalue=None):
"""
:param instructions:
:param attribute:
:param targetvalue:
:param maxvalue: (Default value = None)
:param minvalue: (Default value = None)
"""
super(SetInstructionTypeByPropertyPass, self).__init__(instructions)
self._targetvalue = targetvalue
self._attribute = attribute
self._profile = generate_weighted_profile(instructions,
attribute,
targetvalue,
maxvalue=maxvalue,
minvalue=minvalue)
self._func = weighted_choice(self._profile)
self._description = "Generate instruction profile with average" \
" attribute '%s' value of %d." % (attribute,
targetvalue)
if maxvalue is not None:
self._description += "Filter out values above %d." % maxvalue
if minvalue is not None:
self._description += "Filter out values below %d" % maxvalue
def __init__(self, name, cache_hierarchy, percentages):
"""
:param name:
:param cache_hierarchy:
:param percentages:
"""
super(EndlessLoopDataMemoryModel,
self).__init__(name, "Generic memory model for endless loops")
self._cache_hierarchy = cache_hierarchy
self._percentages = percentages
assert len(cache_hierarchy) == len(percentages)
items = []
all_ratio = 0
accum = 100
mcomp_ants = []
sets_dict = {}
for mcomp, ratio in zip(cache_hierarchy, percentages):
items.append((mcomp, ratio))
all_ratio += ratio
if accum == 0:
sets = []
elif len(mcomp_ants) == 0:
sets = mcomp.setsways()
lsets = len(sets)
sets = sets[0:int(lsets * ratio // accum)]
else:
sets = mcomp.setsways()
sets_length = len(sets)
setm = [1] * len(sets)
for mcomp_ant in mcomp_ants:
# sets = mcomp.setsways()
sets_ant = (elem & ((1 << mcomp_ant.set_ways_bits) - 1)
for elem in sets)
sets_ant = list(sets_ant)
# zipping = zip(sets, sets_ant)
# fset = frozenset(sets_dict[mcomp_ant])
# sets = [s1 for s1, s2 in zipping if s2 not in fset]
# print(len(sets))
if len(sets_dict[mcomp_ant]) > 0:
fset = frozenset(sets_dict[mcomp_ant])
idxes = (idx for idx in range(0, sets_length)
if setm[idx] != 0)
for idx in idxes:
# print(idx, sets_length)
# if setm[idx] == 0:
# continue
if sets_ant[idx] in fset: # sets_dict[mcomp_ant]:
# print(idx, sets_length)
setm[idx] = 0
# sets = mcomp.setsways()
sets = [s1 for s1, s2 in zip(sets, setm) if s2 != 0]
lsets = len(sets)
sets = sets[0:int(lsets * ratio // accum)]
sets_dict[mcomp] = sets
accum = accum - ratio
mcomp_ants.append(mcomp)
mcomp_ant = None
for mcomp, ratio in zip(cache_hierarchy, percentages):
slist = [elem << mcomp.offset_bits for elem in sets_dict[mcomp]]
# TODO: strided parameter or random or pseudorandom (32k ranges)
# TODO: shuffle function too slow for pseudorandom
if mcomp_ant is None:
mcomp_ant = mcomp
if False:
slist = shuffle(slist, 32768)
elif False:
slist = shuffle(slist, -1)
elif False:
slist = shuffle(slist, mcomp_ant.size)
if len(slist) > 0:
tlist = []
tlist.append(slist[0])
tlist.append(slist[-1])
sets_dict[mcomp] = slist
mcomp_ant = mcomp
self._sets = sets_dict
self._func = weighted_choice(dict(items))
self._state = {}
assert all_ratio == 100, "The memory access model is not complete"
assert accum == 0, "Something wrong"