'''
Cost model.
'''
#import numpy as np
from operator import mul
from operator import add
import copy
import math
import loop_enum as le
import buffer_enum as be
def get_comp_cost(layer):
'''
Compute the computation cost, it is indepdent of other optimizations
'''
cost = layer.wofm * layer.hofm * layer.nifm * layer.nofm \
* layer.nimg * layer.wfil * layer.hfil
return cost
def get_ideal_performance(layer, resource):
'''
Compute the ideal runtime in cycles, assuming overhead of data fetching
'''
total_comp = get_comp_cost(layer)
number_pe = reduce(mul, resource.para_count_list, 1)
runtime = math.ceil(total_comp *1.0 / number_pe)
return runtime
def get_layer_size(layer):
'''
Get size of ifmap, ofmap, filter of the layer
'''
ifmap_size = layer.wifm * layer.hifm * layer.nifm * layer.nimg
ofmap_size = layer.wofm * layer.hofm * layer.nofm * layer.nimg
flmap_size = layer.wfil * layer.hfil * layer.nifm * layer.nofm
return [ifmap_size, ofmap_size, flmap_size]
def get_hinted_para(level, hint):
assert hint
hinted_para = 1
for loop in xrange(le.NUM):
if loop in hint:
hinted_loop_para = hint[loop][level][2]
hinted_para *= hinted_loop_para
return hinted_para
def valid_dataflow(resource, hint):
num_levels = resource.buffer_levels()
for level in xrange(num_levels):
if resource.paras[level].count != 1 and \
get_hinted_para(level, hint) < (resource.paras[level].count * resource.utilization_threshold):
return False
return True
def get_if_access(level, point, layer, mac_capacity = 1):
'''
Get # access of if block at current level
The repeated access to ifmap is determined by the blocking factors and
parallelism counts of those loops other than ifmap-related loops outside of
this level.
At the same buffer level, if the other loops are outside of the innermost
loop of ifmap-related loops, their blocking factors and parallelism counts
at this level should also contribute to the number of accesses.
'''
if level == 0 and mac_capacity == 0:
return layer.wfil * layer.hfil * layer.nofm / (layer.wstd * layer.hstd)
ex_order_index = min(point.loop_orders[le.OX][level],
point.loop_orders[le.OY][level],
point.loop_orders[le.IC][level],
point.loop_orders[le.ON][level])
fx_exclusive = point.loop_orders[le.FX][level] < ex_order_index
fy_exclusive = point.loop_orders[le.FY][level] < ex_order_index
oc_exclusive = point.loop_orders[le.OC][level] < ex_order_index
fx_acc = reduce(mul, point.loop_blockings[le.FX][level+fx_exclusive:], 1)
fy_acc = reduce(mul, point.loop_blockings[le.FY][level+fy_exclusive:], 1)
oc_acc = reduce(mul, point.loop_blockings[le.OC][level+oc_exclusive:], 1)
# No loop orders among unrolled loops, they have the same order
fx_par = reduce(mul, point.loop_partitionings[le.FX][level:], 1)
fy_par = reduce(mul, point.loop_partitionings[le.FY][level:], 1)
oc_par = reduce(mul, point.loop_partitionings[le.OC][level:], 1)
return fx_acc * fy_acc * oc_acc * fx_par * fy_par * oc_par / (layer.wstd * layer.hstd)
def get_of_access(level, point, layer, mac_capacity = 1):
'''
Get # access of of block at current level
See comments in routine for ifmap.
'''
if level == 0 and mac_capacity == 0 :
return layer.wfil * layer.hfil * layer.nifm
ex_order_index = min(point.loop_orders[le.OX][level],
point.loop_orders[le.OY][level],
point.loop_orders[le.OC][level],
point.loop_orders[le.ON][level])
fx_exclusive = point.loop_orders[le.FX][level] < ex_order_index
fy_exclusive = point.loop_orders[le.FY][level] < ex_order_index
ic_exclusive = point.loop_orders[le.IC][level] < ex_order_index
fx_acc = reduce(mul, point.loop_blockings[le.FX][level+fx_exclusive:], 1)
fy_acc = reduce(mul, point.loop_blockings[le.FY][level+fy_exclusive:], 1)
ic_acc = reduce(mul, point.loop_blockings[le.IC][level+ic_exclusive:], 1)
fx_par = reduce(mul, point.loop_partitionings[le.FX][level:], 1)
fy_par = reduce(mul, point.loop_partitionings[le.FY][level:], 1)
ic_par = reduce(mul, point.loop_partitionings[le.IC][level:], 1)
return fx_acc * fy_acc * ic_acc * fx_par * fy_par * ic_par
def get_fl_access(level, point, layer, mac_capacity = 1):
'''
Get # access of fl block at current level
See comments in routine for ifmap.
'''
if level == 0 and mac_capacity == 0:
return layer.wofm * layer.hofm * layer.nimg
ex_order_index = min(point.loop_orders[le.FX][level],
point.loop_orders[le.FY][level],
point.loop_orders[le.IC][level],
point.loop_orders[le.OC][level])
ox_exclusive = point.loop_orders[le.OX][level] < ex_order_index
oy_exclusive = point.loop_orders[le.OY][level] < ex_order_index
on_exclusive = point.loop_orders[le.ON][level] < ex_order_index
ox_acc = reduce(mul, point.loop_blockings[le.OX][level+ox_exclusive:], 1)
oy_acc = reduce(mul, point.loop_blockings[le.OY][level+oy_exclusive:], 1)
on_acc = reduce(mul, point.loop_blockings[le.ON][level+on_exclusive:], 1)
ox_par = reduce(mul, point.loop_partitionings[le.OX][level:], 1)
oy_par = reduce(mul, point.loop_partitionings[le.OY][level:], 1)
on_par = reduce(mul, point.loop_partitionings[le.ON][level:], 1)
return ox_acc * oy_acc * on_acc * ox_par * oy_par * on_par
def opt_get_if_access(level, point, ba_arr, pa_arr):
'''
Get # access of if block at current level
The repeated access to ifmap is determined by the blocking factors and
parallelism counts of those loops other than ifmap-related loops outside of
this level.
At the same buffer level, if the other loops are outside of the innermost
loop of ifmap-related loops, their blocking factors and parallelism counts
at this level should also contribute to the number of accesses.
'''
ex_order_index = min(point.loop_orders[le.OX][level],
point.loop_orders[le.OY][level],
point.loop_orders[le.IC][level],
point.loop_orders[le.ON][level])
fx_exclusive = point.loop_orders[le.FX][level] < ex_order_index
fy_exclusive = point.loop_orders[le.FY][level] < ex_order_index
oc_exclusive = point.loop_orders[le.OC][level] < ex_order_index
fx_acc = ba_arr[le.FX][level+fx_exclusive] #reduce(mul, point.loop_blockings[le.FX][level+fx_exclusive:], 1)
fy_acc = ba_arr[le.FY][level+fy_exclusive] #reduce(mul, point.loop_blockings[le.FY][level+fy_exclusive:], 1)
oc_acc = ba_arr[le.OC][level+oc_exclusive] #reduce(mul, point.loop_blockings[le.OC][level+oc_exclusive:], 1)
fx_par = pa_arr[le.FX][level] #reduce(mul, point.loop_partitionings[le.FX][level+fx_exclusive:], 1)
fy_par = pa_arr[le.FY][level] #reduce(mul, point.loop_partitionings[le.FY][level+fy_exclusive:], 1)
oc_par = pa_arr[le.OC][level] #reduce(mul, point.loop_partitionings[le.OC][level+oc_exclusive:], 1)
return fx_acc * fy_acc * oc_acc * fx_par * fy_par * oc_par
def opt_get_of_access(level, point, ba_arr, pa_arr):
'''
Get # access of of block at current level
See comments in routine for ifmap.
'''
ex_order_index = min(point.loop_orders[le.OX][level],
point.loop_orders[le.OY][level],
point.loop_orders[le.OC][level],
point.loop_orders[le.ON][level])
fx_exclusive = point.loop_orders[le.FX][level] < ex_order_index
fy_exclusive = point.loop_orders[le.FY][level] < ex_order_index
ic_exclusive = point.loop_orders[le.IC][level] < ex_order_index
#TODO
fx_acc = ba_arr[le.FX][level+fx_exclusive] #reduce(mul, point.loop_blockings[le.FX][level+fx_exclusive:], 1)
fy_acc = ba_arr[le.FY][level+fy_exclusive] #reduce(mul, point.loop_blockings[le.FY][level+fy_exclusive:], 1)
ic_acc = ba_arr[le.IC][level+ic_exclusive] #reduce(mul, point.loop_blockings[le.OC][level+oc_exclusive:], 1)
fx_par = pa_arr[le.FX][level] #reduce(mul, point.loop_partitionings[le.FX][level+fx_exclusive:], 1)
fy_par = pa_arr[le.FY][level] #reduce(mul, point.loop_partitionings[le.FY][level+fy_exclusive:], 1)
ic_par = pa_arr[le.IC][level] #reduce(mul, point.loop_partitionings[le.OC][level+oc_exclusive:], 1)
return fx_acc * fy_acc * ic_acc * fx_par * fy_par * ic_par
def opt_get_fl_access(level, point, ba_arr, pa_arr):
'''
Get # access of fl block at current level
See comments in routine for ifmap.
'''
ex_order_index = min(point.loop_orders[le.FX][level],
point.loop_orders[le.FY][level],
point.loop_orders[le.IC][level],
point.loop_orders[le.OC][level])
ox_exclusive = point.loop_orders[le.OX][level] < ex_order_index
oy_exclusive = point.loop_orders[le.OY][level] < ex_order_index
on_exclusive = point.loop_orders[le.ON][level] < ex_order_index
ox_acc = ba_arr[le.OX][level+ox_exclusive] #reduce(mul, point.loop_blockings[le.OX][level+ox_exclusive:], 1)
oy_acc = ba_arr[le.OY][level+oy_exclusive] #reduce(mul, point.loop_blockings[le.OY][level+oy_exclusive:], 1)
on_acc = ba_arr[le.ON][level+on_exclusive] #reduce(mul, point.loop_blockings[le.ON][level+on_exclusive:], 1)
ox_par = pa_arr[le.OX][level] #reduce(mul, point.loop_partitionings[le.OX][level+ox_exclusive:], 1)
oy_par = pa_arr[le.OY][level] #reduce(mul, point.loop_partitionings[le.OY][level+oy_exclusive:], 1)
on_par = pa_arr[le.ON][level] #reduce(mul, point.loop_partitionings[le.ON][level+on_exclusive:], 1)
return ox_acc * oy_acc * on_acc * ox_par * oy_par * on_par
def get_if_size(blocking_accum_list, partitioning_accum_list, partitioning_list, layer):
'''
Get size of if block at current level
'''
fx_acc = blocking_accum_list[le.FX] * partitioning_accum_list[le.FX]
fy_acc = blocking_accum_list[le.FY] * partitioning_accum_list[le.FY]
ox_acc = blocking_accum_list[le.OX] * partitioning_accum_list[le.OX]
oy_acc = blocking_accum_list[le.OY] * partitioning_accum_list[le.OY]
width = fx_acc + (ox_acc - 1) * layer.wstd
height = fy_acc + (oy_acc - 1) * layer.hstd
return width * height * \
blocking_accum_list[le.IC] * partitioning_accum_list[le.IC] * \
blocking_accum_list[le.ON] * partitioning_accum_list[le.ON] * \
partitioning_list[le.OC] # Duplication when OC partitions
def get_of_size(blocking_accum_list, partitioning_accum_list, partitioning_list):
'''
Get size of of block at current level
'''
return blocking_accum_list[le.OX] * partitioning_accum_list[le.OX] * \
blocking_accum_list[le.OY] * partitioning_accum_list[le.OY] * \
blocking_accum_list[le.OC] * partitioning_accum_list[le.OC] * \
blocking_accum_list[le.ON] * partitioning_accum_list[le.ON] * \
partitioning_list[le.IC] * partitioning_list[le.FX] * \
partitioning_list[le.FY] # Duplication when IC, FX or FY partitions
def get_fl_size(blocking_accum_list, partitioning_accum_list, partitioning_list):
'''
Get size of fl block at current level
'''
return blocking_accum_list[le.FX] * partitioning_accum_list[le.FX] * \
blocking_accum_list[le.FY] * partitioning_accum_list[le.FY] * \
blocking_accum_list[le.IC] * partitioning_accum_list[le.IC] * \
blocking_accum_list[le.OC] * partitioning_accum_list[le.OC] * \
partitioning_list[le.OX] * partitioning_list[le.OY] *\
partitioning_list[le.ON] # Duplication when OX, OY or ON partitions
def get_if_bank_size(blocking_accum_list, layer):
'''
Get size of if block at current level
'''
fx_acc = blocking_accum_list[le.FX]
fy_acc = blocking_accum_list[le.FY]
ox_acc = blocking_accum_list[le.OX]
oy_acc = blocking_accum_list[le.OY]
width = fx_acc + (ox_acc - 1) * layer.wstd
height = fy_acc + (oy_acc - 1) * layer.hstd
return width * height * \
blocking_accum_list[le.IC] * blocking_accum_list[le.ON]
def get_of_bank_size(blocking_accum_list):
'''
Get size of of block at current level
'''
return blocking_accum_list[le.OX] * blocking_accum_list[le.OY] * \
blocking_accum_list[le.OC] *blocking_accum_list[le.ON]
def get_fl_bank_size(blocking_accum_list):
'''
Get size of fl block at current level
'''
return blocking_accum_list[le.FX] * blocking_accum_list[le.FY] * \
blocking_accum_list[le.IC] * blocking_accum_list[le.OC]
def get_array_access_and_cost(level, para, access_list, point):
'''
Get the access at array level from the access at the
lower level of memory hierachy
'''
para_mode = para.access_mode
assert para_mode == 1 or para_mode == 2
array_dim = para.array_dim
para_count = para.array_width
para_cost = para.array_access_cost * 1.0
nearest_pe_cost = para_cost
[if_block_access, of_block_access, fl_block_access] = access_list
partitions = zip(*point.loop_partitionings)[level]
para_dim = point.para_loop_dim[level]
partitions_nearest = [1,]*le.NUM
partitions_far = []
across_block_cost = [0]*array_dim
if para_mode == 1:
for i in xrange(len(para_dim)):
para_index = para_dim[i]
partitions_far.append([1,]*le.NUM)
if len(para_index) == 1:
partitions_nearest[para_index[0]] = partitions[para_index[0]]
else:
inner_loop, outer_loop = para_index
partitions_nearest[inner_loop] = partitions[inner_loop]
partitions_far[i][outer_loop] = partitions[outer_loop]
across_block_cost[i] = para_cost * partitions[inner_loop]
array_if_block_access_nearest = if_block_access * partitions_nearest[le.FX] * \
partitions_nearest[le.FY] * partitions_nearest[le.OC]
array_of_block_access_nearest = of_block_access * partitions_nearest[le.FX] * \
partitions_nearest[le.FY] * partitions_nearest[le.IC]
array_fl_block_access_nearest = fl_block_access * partitions_nearest[le.OX] * \
partitions_nearest[le.OY] * partitions_nearest[le.ON]
array_access = [[array_if_block_access_nearest, array_of_block_access_nearest, array_fl_block_access_nearest]]
for i in xrange(array_dim):
if_partitions_far = partitions_far[i][le.FX] * partitions_far[i][le.FY] * partitions_far[i][le.OC]
if_partitions_far = if_partitions_far if if_partitions_far != 1 else 0
of_partitions_far = partitions_far[i][le.FX] * partitions_far[i][le.FY] * partitions_far[i][le.IC]
of_partitions_far = of_partitions_far if of_partitions_far != 1 else 0
fl_partitions_far = partitions_far[i][le.OX] * partitions_far[i][le.OY] * partitions_far[i][le.ON]
fl_partitions_far = fl_partitions_far if fl_partitions_far != 1 else 0
if_array_block_access = if_block_access * if_partitions_far
of_array_block_access = of_block_access * of_partitions_far
fl_array_block_access = fl_block_access * fl_partitions_far
array_access.append([if_array_block_access, of_array_block_access, fl_array_block_access])
return [array_access, [nearest_pe_cost] + across_block_cost]
elif para_mode == 2:
for i in xrange(len(para_dim)):
para_index = para_dim[i]
for j in para_index:
partitions_nearest[j] = partitions[j]
array_if_block_access_nearest = if_block_access * partitions_nearest[le.FX] * \
partitions_nearest[le.FY] * partitions_nearest[le.OC]
array_of_block_access_nearest = of_block_access * partitions_nearest[le.FX] * \
partitions_nearest[le.FY] * partitions_nearest[le.IC]
array_fl_block_access_nearest = fl_block_access * partitions_nearest[le.OX] * \
partitions_nearest[le.OY] * partitions_nearest[le.ON]
array_access = [[array_if_block_access_nearest, array_of_block_access_nearest, array_fl_block_access_nearest]]
return [array_access, [nearest_pe_cost]]
def get_access(point, layer, resource):
'''
Get the total access of each block at each level,
return the list as
[[if_block_access, of_block_access, fl_block_access], ...].
Assume all the buffers are inclusive, so buffers in lower level
appear in higher level as well.
For the parallelism case assume read from next memory level,
Support more access modes in parallelism case
'''
#TODO support more customized memory
#TODO more access at overlapped boundary
num_levels = resource.buffer_levels()
mac_capacity = resource.mac_capacity
access_list = []
for level in xrange(num_levels):
if_block_access = get_if_access(level, point, layer, mac_capacity)
of_block_access = 2 * get_of_access(level, point, layer, mac_capacity) - 1
fl_block_access = get_fl_access(level, point, layer, mac_capacity)
access_list.append([if_block_access, of_block_access, fl_block_access])
#para_mode = [e.access_mode for i, e in enumerate(resource.paras) if e.access_mode != 0]
para_mode_level = [i for i, e in enumerate(resource.paras) if e.access_mode != 0]
partitions = zip(*point.loop_partitionings)
array_costs = []
if para_mode_level:
# access at array level
#para_mode_level = [i for i, e in enumerate(resource.paras) if e.access_mode != 0]
delta = 0
for level in para_mode_level:
if level + delta + 1 >= num_levels :
next_level_access = [1, 1, 1]
else:
next_level_access = copy.copy(access_list[level + delta + 1])
next_level_access[1] = (next_level_access[1] + 1)/2
array_access, array_cost = get_array_access_and_cost(level, resource.paras[level], next_level_access, point)
array_costs.append(array_cost)
access_list.insert(level + delta + 1, array_access)
delta += 1
return [access_list, array_costs]
def opt_get_access(num_levels, point, mac_capacity):
'''
See the above function's comments. This function is just an
optimized version of the above function
'''
''' blocking_accum_arr is reversed cumprod numpy array '''
#TODO support mac_capacity
#blocking_arr = np.ones((le.NUM, num_levels+1))
#partitioning_arr = np.ones((le.NUM, num_levels+1))
#blocking_arr[:,:-1] = np.array(point.loop_blockings)
#partitioning_arr[:,:-1] = np.array(point.loop_partitionings)
#blocking_accum_arr = np.ones((le.NUM, num_levels+1))
#partitioning_accum_arr = np.ones((le.NUM, num_levels+1))
#for i in xrange(le.NUM):
# blocking_accum_arr[i][:-1] = np.cumprod(blocking_arr[i][::-1])[::-1]
# partitioning_accum_arr[i][:-1] = np.cumprod(partitioning_arr[i][::-1])[::-1]
#blocking_accum_arr = blocking_arr[...,::-1].cumprod(axis=-1)[...,::-1]
#partitioning_accum_arr = partitioning_arr[...,::-1].cumprod(axis=-1)[...,::-1]
#blocking_accum_arr = np.hstack((blocking_accum_arr, np.ones((le.NUM, 1))))
#partitioning_accum_arr = np.hstack((partitioning_accum_arr, np.ones((le.NUM, 1))))
blocking_accum_arr = []
partitioning_accum_arr = []
for i in xrange(le.NUM):
ba_current_level = [1]
pa_current_level = [1]
ba_tmp = 1
pa_tmp = 1
for level in xrange(num_levels-1, -1, -1):
ba_tmp = ba_tmp * point.loop_blockings[i][level]
pa_tmp = pa_tmp * point.loop_partitionings[i][level]
ba_current_level.append(ba_tmp)
pa_current_level.append(pa_tmp)
blocking_accum_arr.append(ba_current_level[::-1])
partitioning_accum_arr.append(pa_current_level[::-1])
access_arr = np.zeros((num_levels, 3))
for level in xrange(num_levels):
access_arr[level][0] = opt_get_if_access(level, point, blocking_accum_arr, partitioning_accum_arr)
access_arr[level][1] = 2 * opt_get_of_access(level, point, blocking_accum_arr, partitioning_accum_arr) - 1
access_arr[level][2] = opt_get_fl_access(level, point, blocking_accum_arr, partitioning_accum_arr)
return access_arr
def get_bank_size(point, layer, level):
blocking_accum_list = []
for i in xrange(le.NUM):
blocking_accum_list.append(reduce(mul, point.loop_blocking(i)[:level+1], 1))
if_bank_size = get_if_bank_size(blocking_accum_list, layer)
of_bank_size = get_of_bank_size(blocking_accum_list)
fl_bank_size = get_fl_bank_size(blocking_accum_list)
return (if_bank_size, of_bank_size, fl_bank_size)
def get_block_size(point, layer, level):
blocking_accum_list = []
partitioning_accum_list = []
partitioning_reshape = zip(*point.loop_partitionings)
partitioning_list = partitioning_reshape[level]
for i in xrange(le.NUM):
blocking_accum_list.append(reduce(mul, point.loop_blocking(i)[:level+1], 1))
partitioning_accum_list.append(reduce(mul, point.loop_partitioning(i)[:level+1], 1)) #FIXME inclusive mode also duplicates data
if_block_size = get_if_size(blocking_accum_list, partitioning_accum_list, partitioning_list, layer)
of_block_size = get_of_size(blocking_accum_list, partitioning_accum_list, partitioning_list)
fl_block_size = get_fl_size(blocking_accum_list, partitioning_accum_list, partitioning_list)
return (if_block_size, of_block_size, fl_block_size)
def get_block_sizes(num_levels, point, layer):
'''
Get size of ifmap, ofmap, filter
'''
bank_list = []
block_list = []
for level in xrange(num_levels):
block_list.append(get_block_size(point, layer, level))
bank_list.append(get_bank_size(point, layer, level))
return [bank_list, block_list]
def fit_in_level(cap, blocks, invalid_underutilized):
total_size = sum(blocks)
if invalid_underutilized:
return (total_size <= cap) and (2*total_size >= cap)
else:
return (total_size <= cap)
def valid_partition_number(resource, partitioning, level):
max_parallelism = resource.parallelism(level).count
actual_parallelism = reduce(mul, partitioning[level], 1)
return actual_parallelism <= max_parallelism
def valid_partitioning_current_level(resource, point, layer, level, verbose=False):
valid_size = fit_in_level(resource.buffer(level).capacity, \
get_bank_size(point, layer, level), True)
return valid_size
def valid_mapping_point_current_level(resource, point, layer, level, verbose=False):
if resource.paras[level].count > 1:
valid_size = fit_in_level(resource.buffer(level).capacity,
get_bank_size(point, layer, level))
else :
valid_size = fit_in_level(resource.buffer(level).capacity,
get_block_size(point, layer, level))
partitioning = zip(*(point.loop_partitionings))
valid_para = valid_partition_number(resource, partitioning, level)
if verbose == 3:
print "Level ", level, ": Partitioned block size fit in bank: ", valid_size
print "Level ", level, ": Partition number is valid: ", valid_para
return valid_size and valid_para
def valid_partitioning(resource, point, layer, verbose=False):
para_level = resource.para_index
for level in para_level:
if not valid_partitioning_current_level(resource, point, layer, level, verbose):
return False
return True
def valid_blocking_size_current_level(resource, point, layer, level, verbose=False):
if level == resource.buffer_levels()-1:
return True
return fit_in_level(resource.buffer(level).capacity * resource.paras[level].count,
get_block_size(point, layer, level), (level not in resource.para_index))
#get_block_size(point, layer, level), (level > min(resource.para_index)))
def valid_blocking_size(resource, point, layer, verbose=False):
for level in xrange(resource.buffer_levels()):
if not valid_blocking_size_current_level(resource, point, layer, level, verbose):
return False
return True
def valid_mapping_point(resource, point, layer, verbose=False):
for i in xrange(resource.buffer_levels()):
if not valid_mapping_point_current_level(resource, point, layer, i, verbose):
return False
return True
def get_total_access_cost(resource, array_cost):
total_access_cost = copy.deepcopy(resource.access_cost)
if not resource.array_access_cost:
return total_access_cost
para_index = [i for i, e in enumerate(resource.paras) if e.access_mode != 0]
addition_levels = len(para_index)
delta = 1
for i in xrange(addition_levels):
index = para_index[i]
total_access_cost.insert(index+delta, array_cost[i])
delta += 1
return total_access_cost
def get_array_level_cost(resource, point, layer_size, level, next_level_access, verbose=False):
#TODO add support for other access_mode
assert resource.paras[level].count and resource.paras[level].access_mode
level_access, level_cost = get_array_access_and_cost(level, resource.paras[level], next_level_access, point)
total_cost = 0
for i in xrange(len(level_access)):
buffer_access = map(mul, level_access[i], layer_size)
total_cost += sum(buffer_access) *level_cost[i]
if verbose >= 3:
print "Level ", level, " array level access: ", level_access
return total_cost
def get_array_and_curr_level_cost(resource, point, layer, level, verbose=False):
layer_size = get_layer_size(layer)
mac_capacity = resource.mac_capacity
level_access = [get_if_access(level, point, layer, mac_capacity), \
get_of_access(level, point, layer, mac_capacity), \
get_fl_access(level, point, layer, mac_capacity)]
[if_access, of_access, fl_access] = level_access
buffer_level_access = [if_access, 2*of_access-1, fl_access]
total_buffer_access = map(mul, buffer_level_access, layer_size)
level_cost = sum(total_buffer_access) * resource.access_cost[level]
if verbose >= 3:
print "Level ", level, " access: ", buffer_level_access
level_cost += get_array_level_cost(resource, point, layer_size, level-1, level_access, verbose)
return level_cost
def get_level_cost(resource, point, layer, level, verbose=False):
layer_size = get_layer_size(layer)
mac_capacity = resource.mac_capacity
level_access = [get_if_access(level, point, layer, mac_capacity), \
2 * get_of_access(level, point, layer, mac_capacity) - 1, \
get_fl_access(level, point, layer, mac_capacity)]
buffer_access = map(mul, level_access, layer_size)
level_cost = sum(buffer_access) * resource.access_cost[level]
if verbose >= 3:
print "Level ", level, " access: ", level_access
return level_cost
def get_total_access(resource, point, layer, verbose=False):
layer_size = get_layer_size(layer)
access_list, array_cost = get_access(point, layer, resource)
if verbose >= 3:
print "access breakdown: ", access_list
total_level_access = []
for i in xrange(len(access_list)):
''' List of total access of each buffer at level i'''
if not isinstance(access_list[i][0], list):
buffer_access = map(mul, access_list[i], layer_size)
total_level_access.append(sum(buffer_access))
else :
for j in xrange(len(access_list[i])):
buffer_access = map(mul, access_list[i][j], layer_size)
total_level_access.append(sum(buffer_access))
return total_level_access
def get_level_costs(resource, point, layer, verbose=False):
num_levels = resource.buffer_levels()
level_energy = []
for level in xrange(num_levels):
level_energy.append(get_level_cost(resource, point, layer, level))
para_index = [i for i, e in enumerate(resource.paras) if e.access_mode != 0]
delta = 1
for index in para_index:
array_energy = get_array_and_curr_level_cost(resource, point, layer, index+1) - level_energy[index+delta]
level_energy.insert(index+delta, array_energy)
delta += 1
return level_energy
#FIXME
def get_block_cost(resource, point, layer, verbose=False):
'''
Get the cost of the given mapping point on given resource.
If the point is not feasible on the resource, return inf.
'''
#TODO include static energy
num_levels = resource.buffer_levels()
access_list, array_cost = get_access(point, layer, resource)
layer_size = get_layer_size(layer)
total_access_cost = get_total_access_cost(resource, array_cost)
assert len(total_access_cost) == len(access_list)
block_costs = [0.0, 0.0, 0.0]
for i in xrange(len(total_access_cost)):
buffer_access = [a*b for a,b in zip(access_list[i], layer_size)]
block_cost = [x * total_access_cost[i] for x in buffer_access]
block_costs = map(add, block_cost, block_costs)
if verbose:
print 'access_list: ', access_list
bank_size_list, block_size_list = get_block_sizes(num_levels, point, layer)
print 'bank_size_list: ', bank_size_list
print 'block_size_list: ', block_size_list
print 'layer_size: ', layer_size
print 'block costs: ', block_costs
return block_costs
def get_cost(resource, point, layer, verbose=False):
'''
Get the cost of the given mapping point on given resource.
If the point is not feasible on the resource, return inf.
'''
#TODO include static energy
#TODO support other access_mode
num_levels = resource.buffer_levels()
assert len(point.loop_blockings[0]) == num_levels, \
"number of blockings does not match with number of memory " \
"levels: %d" % num_levels
access_list, array_cost = get_access(point, layer, resource)
layer_size = get_layer_size(layer)
total_access_cost = get_total_access_cost(resource, array_cost)
assert len(total_access_cost) == len(access_list)
total_cost = 0.0
for i in xrange(len(total_access_cost)):
''' List of total access of each buffer at level i'''
if not isinstance(access_list[i][0], list):
buffer_access = map(mul, access_list[i], layer_size)
total_cost += sum(buffer_access) * total_access_cost[i]
else :
for j in xrange(len(access_list[i])):
buffer_access = map(mul, access_list[i][j], layer_size)
total_cost += sum(buffer_access) * total_access_cost[i][j]
if verbose:
print 'access_cost: ', total_access_cost
print 'access_list: ', access_list
bank_size_list, block_size_list = get_block_sizes(num_levels, point, layer)
print 'bank_size_list: ', bank_size_list
print 'block_size_list: ', block_size_list
print 'layer_size: ', layer_size
print 'total cost: ', total_cost
return total_cost