def _get_minmax_ccr(Iwcc, Pwcc, Bwcc, Ibcc, Pbcc, Bbcc, gop_len, max_payload):
nPmax = gop_len - 1
nPmin = int(float(gop_len - 1) / float(NBMAX + 1))
nBmax = (gop_len - 1) - nPmin
nBmin = 0
nhops = (NOC_H - 1) + (NOC_W - 1)
#nhops = (NOC_H) + (NOC_W)
max_bl = NoCFlow.getCommunicationCost(max_payload * 0.5, nhops, NOC_PERIOD,
NOC_ARBITRATION_COST)
# print "Iwcc, %.9f" % Iwcc
# print "Pwcc, %.9f" % Pwcc
# print "Bwcc, %.9f" % Bwcc
print "max_bl: ", max_bl
## calculate upper-bound CCR ##
# how many num P's and B's do we consider ?
nP = nPmin
nB = nBmax
# upper ccr occurs when there are as many as possible edges, when there are max amount of B-frames
# B frames can have max 3 incoming edges
# P frames can have only 1 incoming edge
# and have to take best-case ccs
num_edges = (nP * 1) + (nB * 3)
print "w.c. num_edges:", num_edges
wc_comm_cost = num_edges * max_bl
bc_comp_cost = Ibcc + (nP * Pbcc) + (nB * Bbcc)
ub_ccr = float(wc_comm_cost) / float(bc_comp_cost)
## calculate best-case CCR ##
# how many num P's and B's do we consider ?
nP = nPmax
nB = nBmin
# bc ccr occurs when there are as less as possible edges, when there are min amount of B-frames
# B frames can have max 3 incoming edges
# P frames can have only 1 incoming edge
num_edges = (nP * 1) + (nB * 2)
print "b.c. num_edges:", num_edges
bl = max_bl
#print bl
bc_comm_cost = float(num_edges) * bl
wc_comp_cost = Iwcc + (nP * Pwcc) + (nB * Bwcc)
#print bc_comm_cost, bc_comp_cost
lb_ccr = float(bc_comm_cost) / float(wc_comp_cost)
return (lb_ccr, ub_ccr)
def _get_max_ccr(self, vid_res, I_wcc, P_wcc, B_wcc):
# assuming fixed gop seq - "IPBBPBBPBBBB"
total_nodes_cost = I_wcc + (P_wcc * 3.0) + (B_wcc * 8.0)
each_edge_payload = (vid_res[0] * vid_res[1] * 2)
nhops = (NOC_H - 1) + (NOC_W - 1)
total_edges_cost = NoCFlow.getCommunicationCost(
each_edge_payload, nhops, NOC_PERIOD, NOC_ARBITRATION_COST) * 19.0
max_ratio_ccr = float(total_edges_cost) / float(total_nodes_cost)
return max_ratio_ccr
def get_ccr_range(enable_print=True):
result_data = []
frame_h = res_list[0][0]
frame_w = res_list[0][1]
for cpu_exec_speed_ratio in [0.1]:
#for cpu_exec_speed_ratio in np.arange(cpu_exec_rat_min,cpu_exec_rat_max,(cpu_exec_rat_max-cpu_exec_rat_min)/2):
for noc_period in np.arange(noc_period_min, noc_period_max,
(noc_period_max - noc_period_min) / 10):
# computation cost
(iframe_cc, pframe_cc,
bframe_cc) = MPEG2FrameTask.getStaticComputationCost(
frame_h, frame_w, cpu_exec_speed_ratio)
mean_computation_cost = float(iframe_cc + pframe_cc +
bframe_cc) / 3.0
# communication cost
max_hop_count = (SimParams.NOC_W - 1) + (SimParams.NOC_H - 1)
payload = ((frame_h * frame_w) * 16) / 8
arb_cost = noc_period * 7
noc_flow_cc = NoCFlow.getCommunicationCost(payload, max_hop_count,
noc_period, arb_cost)
# CCR : communication to computation ratio
ccr = noc_flow_cc / mean_computation_cost
# CCS : communication + computation (summation)
ccs = noc_flow_cc + mean_computation_cost
entry = {
'cpu_exec_speed_ratio': cpu_exec_speed_ratio,
'noc_period': noc_period,
'mean_computation_cost': mean_computation_cost,
'noc_flow_cc': noc_flow_cc,
'ccr': ccr,
'ccs': ccs,
}
result_data.append(entry)
# print table of results
if (enable_print == True):
_report_ccr(result_data)
return result_data
def _get_ccr(self, payloads, fr_ccs, num_nodes, num_edges):
# checks
assert (len(payloads) == num_edges)
assert (len(fr_ccs) == num_nodes)
total_nodes_cost = np.sum(fr_ccs)
total_edges_cost = 0
nhops = (NOC_H - 1) + (NOC_W - 1)
for each_flw_payload in payloads:
total_edges_cost += NoCFlow.getCommunicationCost(
each_flw_payload, nhops, NOC_PERIOD, NOC_ARBITRATION_COST)
ratio_ccr = float(total_edges_cost) / float(total_nodes_cost)
return ratio_ccr
def _get_runtime_ccr(Iwcc, Pwcc, Bwcc, max_payload, num_edges, gop_seq):
total_node_cost = 0.0
for ft_type in gop_seq:
if ft_type == "I": total_node_cost += Iwcc
elif ft_type == "P": total_node_cost += Pwcc
elif ft_type == "B": total_node_cost += Bwcc
else:
sys.exit("Error - _get_runtime_ccr")
nhops = (NOC_H - 1) + (NOC_W - 1)
max_bl = NoCFlow.getCommunicationCost(max_payload, nhops, NOC_PERIOD,
NOC_ARBITRATION_COST)
total_edges_cost = max_bl * float(num_edges)
runtime_ccr = float(total_edges_cost) / float(total_node_cost)
return runtime_ccr
def _gen_ccr(result_ccr_list, ccs_range, ccr_range, param_res_list):
#cpu_exec_speed_ratio = random.choice(np.arange(cpu_exec_rat_min,cpu_exec_rat_max,(cpu_exec_rat_max-cpu_exec_rat_min)/10000))
#noc_period = random.choice(np.arange(noc_period_min,noc_period_max,(noc_period_max-noc_period_min)/10000))
# global_noc_period_list.append(noc_period)
# while(noc_period in global_noc_period_list):
# global_noc_period_list.append(noc_period)
# noc_period = random.choice(np.arange(noc_period_min,noc_period_max,(noc_period_max-noc_period_min)/1000000))
cpu_exec_speed_ratio = 0.8
noc_period = random.uniform(noc_period_min, noc_period_max)
list_mean_computation_cost = []
list_sum_computation_cost_all_tasks = []
list_mean_computation_cost_all_tasks = []
list_noc_flow_cc_all_edges = []
list_noc_flow_cc = []
list_ccr = []
list_ccs = []
for each_res in param_res_list:
frame_h = each_res[0]
frame_w = each_res[1]
# computation cost
(iframe_cc, pframe_cc,
bframe_cc) = MPEG2FrameTask.getStaticComputationCost(
frame_h, frame_w, cpu_exec_speed_ratio)
mean_computation_cost = float(iframe_cc + pframe_cc + bframe_cc) / 3.0
sum_computation_cost_all_tasks = (iframe_cc * 1.0) + (
pframe_cc * 3.0) + (bframe_cc * 8.0)
mean_computation_cost_all_tasks = (
sum_computation_cost_all_tasks) / 12.0
# communication cost
noc_w = np.sqrt(len(param_res_list) - 3)
max_hop_count = (noc_w) + (noc_w)
payload = ((frame_h * frame_w) * 16) / 8
arb_cost = noc_period * 7
noc_flow_cc = NoCFlow.getCommunicationCost(payload, max_hop_count,
noc_period, arb_cost)
num_edges = 19
noc_flow_cc_all_edges = (noc_flow_cc * num_edges)
# CCR : communication to computation
#ccr = noc_flow_cc/mean_computation_cost
ccr = (noc_flow_cc_all_edges / sum_computation_cost_all_tasks)
# CCS : communication + computation (summation)
#ccs = noc_flow_cc + mean_computation_cost
ccs = (noc_flow_cc_all_edges + sum_computation_cost_all_tasks)
list_mean_computation_cost.append(mean_computation_cost)
list_noc_flow_cc.append(noc_flow_cc)
list_sum_computation_cost_all_tasks.append(
sum_computation_cost_all_tasks)
list_mean_computation_cost_all_tasks.append(
mean_computation_cost_all_tasks)
list_noc_flow_cc_all_edges.append(noc_flow_cc_all_edges)
list_ccr.append(ccr)
list_ccs.append(ccs)
if (((np.mean(list_ccs) >= float(ccs_range[0])) and
(np.mean(list_ccs) <= float(ccs_range[1])))
and (round(np.mean(list_ccr), 3) not in result_ccr_list)
and (round(np.mean(list_ccr), 3) in ccr_range)):
entry = {
'cpu_exec_speed_ratio': cpu_exec_speed_ratio,
'noc_period': noc_period,
'mean_computation_cost': np.mean(list_mean_computation_cost),
'noc_flow_cc': np.mean(list_noc_flow_cc),
'ccr': np.mean(list_ccr),
'ccs': np.mean(list_ccs),
}
return entry
else:
return None
def get_specific_ccr(cpu_exec_speed_ratio, noc_period):
list_ipb_frame_cost = []
list_mean_computation_cost = []
list_sum_computation_cost_all_tasks = []
list_mean_computation_cost_all_tasks = []
list_noc_flow_cc_all_edges = []
list_noc_flow_cc = []
list_ccr = []
list_ccs = []
for each_res in res_list:
frame_h = each_res[0]
frame_w = each_res[1]
# computation cost
(iframe_cc, pframe_cc,
bframe_cc) = MPEG2FrameTask.getStaticComputationCost(
frame_h, frame_w, cpu_exec_speed_ratio)
mean_computation_cost = float(iframe_cc + pframe_cc + bframe_cc) / 3.0
sum_computation_cost_all_tasks = (iframe_cc * 1.0) + (
pframe_cc * 3.0) + (bframe_cc * 8.0)
mean_computation_cost_all_tasks = (iframe_cc) + (pframe_cc) + (
bframe_cc)
# communication cost
max_hop_count = (SimParams.NOC_W - 1) + (SimParams.NOC_H - 1)
payload = ((frame_h * frame_w) * 16) / 8
arb_cost = noc_period * 7
noc_flow_cc = NoCFlow.getCommunicationCost(payload, max_hop_count,
noc_period, arb_cost)
num_edges = 19
noc_flow_cc_all_edges = (noc_flow_cc * num_edges)
# CCR : communication to computation
#ccr = noc_flow_cc/mean_computation_cost
ccr = (noc_flow_cc_all_edges / sum_computation_cost_all_tasks)
# CCS : communication + computation (summation)
#ccs = noc_flow_cc + mean_computation_cost
ccs = (noc_flow_cc_all_edges + sum_computation_cost_all_tasks)
list_mean_computation_cost.append(mean_computation_cost)
list_noc_flow_cc.append(noc_flow_cc)
list_sum_computation_cost_all_tasks.append(
sum_computation_cost_all_tasks)
list_mean_computation_cost_all_tasks.append(
mean_computation_cost_all_tasks)
list_noc_flow_cc_all_edges.append(noc_flow_cc_all_edges)
list_ccr.append(ccr)
list_ccs.append(ccs)
list_ipb_frame_cost.append((iframe_cc, pframe_cc, bframe_cc))
# print list_ccr
# print list_ccs
entry = {
'cpu_exec_speed_ratio':
cpu_exec_speed_ratio,
'noc_period':
noc_period,
'mean_computation_cost':
np.mean(list_mean_computation_cost),
'noc_flow_cc':
np.mean(list_noc_flow_cc),
'sum_computation_cost_all_tasks':
list_sum_computation_cost_all_tasks,
'mean_computation_cost_all_tasks':
list_mean_computation_cost_all_tasks,
'noc_flow_cc_all_edges':
list_noc_flow_cc_all_edges,
'list_ipb_frame_cost':
list_ipb_frame_cost,
'list_ccr':
list_ccr,
'list_ccs':
list_ccs,
'mean_ccr':
np.mean(list_ccr),
'mean_ccs':
np.mean(list_ccs),
'ccr_v2':
np.sum(list_noc_flow_cc_all_edges) /
np.sum(list_mean_computation_cost_all_tasks),
'csr_v2':
np.sum(list_noc_flow_cc_all_edges) +
np.sum(list_mean_computation_cost_all_tasks)
}
pprint.pprint(entry)
def get_properties_fixed_ccs_fixed_ccr_range(ccs_range,
ccr_range,
enable_print=True):
random.seed(1234)
result_data = []
n = 0
count = 0
result_ccr_list = []
while (n < len(ccr_range)):
#cpu_exec_speed_ratio = random.choice(np.arange(cpu_exec_rat_min,cpu_exec_rat_max,(cpu_exec_rat_max-cpu_exec_rat_min)/10000))
#noc_period = random.choice(np.arange(noc_period_min,noc_period_max,(noc_period_max-noc_period_min)/10000))
cpu_exec_speed_ratio = 0.8
noc_period = random.uniform(noc_period_min, noc_period_max)
list_mean_computation_cost = []
list_sum_computation_cost_all_tasks = []
list_mean_computation_cost_all_tasks = []
list_noc_flow_cc_all_edges = []
list_noc_flow_cc = []
list_ccr = []
list_ccs = []
for each_res in res_list:
frame_h = each_res[0]
frame_w = each_res[1]
# computation cost
(iframe_cc, pframe_cc,
bframe_cc) = MPEG2FrameTask.getStaticComputationCost(
frame_h, frame_w, cpu_exec_speed_ratio)
mean_computation_cost = float(iframe_cc + pframe_cc +
bframe_cc) / 3.0
sum_computation_cost_all_tasks = (iframe_cc * 1.0) + (
pframe_cc * 3.0) + (bframe_cc * 8.0)
mean_computation_cost_all_tasks = (iframe_cc) + (pframe_cc) + (
bframe_cc)
# communication cost
max_hop_count = (SimParams.NOC_W - 1) + (SimParams.NOC_H - 1)
payload = ((frame_h * frame_w) * 16) / 8
arb_cost = noc_period * 7
noc_flow_cc = NoCFlow.getCommunicationCost(payload, max_hop_count,
noc_period, arb_cost)
num_edges = 19
noc_flow_cc_all_edges = (noc_flow_cc * num_edges)
# CCR : communication to computation
#ccr = noc_flow_cc/mean_computation_cost
ccr = (noc_flow_cc_all_edges / sum_computation_cost_all_tasks)
# CCS : communication + computation (summation)
#ccs = noc_flow_cc + mean_computation_cost
ccs = (noc_flow_cc_all_edges + sum_computation_cost_all_tasks)
list_mean_computation_cost.append(mean_computation_cost)
list_noc_flow_cc.append(noc_flow_cc)
list_sum_computation_cost_all_tasks.append(
sum_computation_cost_all_tasks)
list_mean_computation_cost_all_tasks.append(
mean_computation_cost_all_tasks)
list_noc_flow_cc_all_edges.append(noc_flow_cc_all_edges)
list_ccr.append(ccr)
list_ccs.append(ccs)
if (((np.mean(list_ccs) >= float(ccs_range[0])) and
(np.mean(list_ccs) <= float(ccs_range[1])))
and (round(np.mean(list_ccr), 3) not in result_ccr_list)
and (round(np.mean(list_ccr), 3) in ccr_range)):
entry = {
'cpu_exec_speed_ratio': cpu_exec_speed_ratio,
'noc_period': noc_period,
'mean_computation_cost': np.mean(list_mean_computation_cost),
'noc_flow_cc': np.mean(list_noc_flow_cc),
'ccr': np.mean(list_ccr),
'ccs': np.mean(list_ccs),
}
result_data.append(entry)
result_ccr_list.append(round(np.mean(list_ccr), 3))
n += 1
print n, np.mean(list_ccr)
count += 1
# print table of results
if (enable_print == True):
# sort
new_result_data = sorted(result_data, key=lambda k: k['ccr'])
_report_ccr(new_result_data)
## write data file output
fname = 'ccr_list_output_' + str(ccr_range[0]) + "_" + str(
ccr_range[-1]) + ".js"
_write_formatted_file(fname, new_result_data, "json")
return result_data