in visualization_utils/plotting.py [0:0]
def get_budget_optimality_for_paper(input_dir_names,all_result_files, reg_summary_res_column_name_number, a_e_h_summary_res_column_name_number):
#methodology 1:
e = {"power":0.00211483379112716, "area":0.00000652737916}
a = {"power": 0.00133071013064968, "area":0.0000048380066802}
hc = {"power": 0.000471573339922609, "area":0.0000019979449678}
e_budget = {"power":0.00190575, "area":0.0000038115}
a_budget = {"power":0.0015485, "area":0.0000030975}
hc_budget = {"power":0.001005, "area":0.00000201}
e_dis_budget = {"power":0, "area":0}
a_dis_budget = {"power":0, "area":0}
hc_dis_budget = {"power":0, "area":0}
for el in e_dis_budget.keys():
e_dis_budget[el] = (e_budget[el]-e[el])/e[el]
for el in a_dis_budget.keys():
a_dis_budget[el] = (a_budget[el]-a[el])/a[el]
for el in hc_dis_budget.keys():
hc_dis_budget[el] = (hc_budget[el]-hc[el])/hc[el]
combined_design_methodology_A = {"power":0, "area":0}
for el in e.keys() :
combined_design_methodology_A[el] += e[el]
for el in a.keys() :
combined_design_methodology_A[el] += e[el]
for el in hc.keys() :
combined_design_methodology_A[el] += e[el]
def get_equivalent_total(charac):
if charac == "ips_avg_freq":
return "ip_cnt"
if charac == "cluster_pe_cnt_avg":
return "ip_cnt"
elif charac == "avg_accel_parallelism":
return "ip_cnt"
elif charac in ["local_memory_avg_freq"]:
return "local_mem_cnt"
elif charac in ["local_bus_avg_actual_bandwidth", "local_bus_avg_theoretical_bandwidth", "local_bus_avg_bus_width", "avg_freq"]:
return "local_bus_count"
else:
return charac
def find_sys_char(power,area, results_with_sys_char):
for vals in results_with_sys_char:
for power_area , sys_chars in vals.items():
power_ = power_area[0]
area_ = power_area[1]
if power == power_ and area_ == area:
return sys_chars
def points_exceed_one_of_the_budgets(point, base_budget, budget_scaling_to_consider):
power = point[0]
area = point[1]
if power > base_budgets["power"] * budget_scale_to_consider and area > base_budgets[
"area"] * budget_scale_to_consider:
return True
return False
workload_results = {}
results_with_sys_char = []
system_char_to_keep_track_of = {"memory_total_area", "local_memory_total_area","pe_total_area", "ip_cnt","ips_total_area", "ips_avg_freq", "local_mem_cnt",
"local_bus_avg_actual_bandwidth", "local_bus_avg_theoretical_bandwidth", "local_memory_avg_freq", "local_bus_count", "local_bus_avg_bus_width", "avg_freq", "local_total_traffic",
"global_total_traffic","local_memory_avg_freq", "global_memory_avg_freq", "gpps_total_area", "avg_gpp_parallelism", "avg_accel_parallelism", "channel_cnt",
"local_total_traffic_reuse_with_read_in_bytes",
}
system_char_to_keep_track_of = {"ip_cnt"
}
#system_char_to_show = ["local_memory_total_area"]
#system_char_to_show = ["avg_accel_parallelism"]
#system_char_to_show = ["avg_gpp_parallelism"]
#system_char_to_show = ["local_bus_avg_actual_bandwidth"]
#system_char_to_show = ["avg_freq"] # really is buses avg freq
#system_char_to_show = ["local_memory_avg_freq"] # really is buses avg freq
#system_char_to_show = ["ips_avg_freq"]
#system_char_to_show = ["gpps_total_area"]
#system_char_to_show = ["local_bus_avg_bus_width"]
#system_char_to_show = ["local_memory_avg_freq"]
#system_char_to_show = ["ips_total_area"]
system_char_to_show = ["ip_cnt"]
#system_char_to_show = ["local_mem_cnt"]
#system_char_to_show = ["global_memory_avg_freq"]
#system_char_to_show = ["local_bus_avg_theoretical_bandwidth"]
#system_char_to_show = ["local_memory_avg_freq"]
#system_char_to_show = ["local_total_traffic"]
#system_char_to_show = ["global_total_traffic"]
#system_char_to_show = ["local_total_traffic_reuse_with_read_in_bytes"]
#system_char_to_show = ["local_bus_count"]
#system_char_to_show = ["cluster_pe_cnt_avg"]
#system_char_to_show = ["ip_cnt"]
#system_char_to_show = ["channel_cnt"]
# budget scaling to consider
budget_scale_to_consider = .5
# get budget first
base_budgets = {}
"""
for file in all_result_files:
with open(file, newline='') as csvfile:
if not ("a_e_h" in file and "lat_1__pow_1__area_1" in file):
continue
resultReader = csv.reader(csvfile, delimiter=',', quotechar='|')
for i, row in enumerate(resultReader):
if i == 1:
print("file"+file)
if float(row[reg_summary_res_column_name_number["budget_scaling_latency"]]) == 1 and\
float(row[reg_summary_res_column_name_number["budget_scaling_power"]]) == 1 and \
float(row[reg_summary_res_column_name_number["budget_scaling_area"]]) == 1:
base_budgets["power"] = float(row[summary_res_column_name_number["power_budget"]])
base_budgets["area"] = float(row[summary_res_column_name_number["area_budget"]])
break
"""
base_budgets = {"power":.008738,"area":.000017475}
for file in all_result_files:
if "a_e_h" in file and "lat_1__pow_1__area_1" in file:
continue
if ("a_e_h" in file):
summary_res_column_name_number = a_e_h_summary_res_column_name_number
else:
summary_res_column_name_number = reg_summary_res_column_name_number
with open(file, newline='') as csvfile:
resultReader = csv.reader(csvfile, delimiter=',', quotechar='|')
for i, row in enumerate(resultReader):
if i == 1:
workload_set_name = row[summary_res_column_name_number["workload_set"]]
if workload_set_name not in workload_results.keys():
workload_results[workload_set_name] = []
latency = ((row[summary_res_column_name_number["latency"]].split(";"))[0].split("="))[1]
latency_budget = ((row[summary_res_column_name_number["latency_budget"]].split(";"))[0].split("="))[1]
if float(latency) > float(latency_budget):
continue
power = float(row[summary_res_column_name_number["power"]])
area = float(row[summary_res_column_name_number["area"]])
system_complexity = row[summary_res_column_name_number["ip_cnt"]] # + row[summary_res_column_name_number["gpp_cnt"]]
#workload_results[workload_set_name].append((float(power),float(area), float(system_complexity)))
workload_results[workload_set_name].append((power,area))
system_char = {}
for el in system_char_to_keep_track_of:
#if "latency" == el:
# system_char[el] = row[summary_res_column_name_number[el]]
#else:
system_char[el] = float(row[summary_res_column_name_number[el]])
system_char["file"] = file
point_system_char = {(power, area): system_char}
results_with_sys_char.append(point_system_char)
workload_pareto_points = {}
for workload, points in workload_results.items():
workload_pareto_points[workload] = find_pareto_points(list(set(points)))
""""
# combine the results
combined_area_power = []
for results_combined in itertools.product(*list(workload_pareto_points.values())):
combined_power_area_tuple = [0,0]
for el in results_combined:
combined_power_area_tuple[0] += el[0]
combined_power_area_tuple[1] += el[1]
combined_area_power.append(combined_power_area_tuple[:])
"""
all_points_in_isolation = []
all_points_cross_workloads = []
workload_in_isolation = {}
for workload, points in workload_results.items():
if "cava" in workload and "audio" in workload and "edge_detection" in workload:
for point in points:
all_points_cross_workloads.append(point)
else:
workload_in_isolation[workload] = points
ctr = 0
workload_in_isolation_pareto = {}
for workload, points in workload_in_isolation.items():
optimal_points = find_pareto_points(list(set(points)))
workload_in_isolation_pareto[workload] = optimal_points
#workload_in_isolation_pareto[workload] = points # show all points instead
combined_area_power_in_isolation= []
combined_area_power_in_isolation_with_sys_char = []
s = time.time()
for results_combined in itertools.product(*list(workload_in_isolation_pareto.values())):
# add up all the charactersitics
combined_sys_chars = {}
system_char_to_keep_track_of.add("file")
for el in system_char_to_keep_track_of:
if el =="file":
combined_sys_chars[el] = []
else:
combined_sys_chars[el] = (0,0)
# add up area,power
combined_power_area_tuple = [0,0]
for el in results_combined:
combined_power_area_tuple[0] += el[0]
combined_power_area_tuple[1] += el[1]
sys_char = find_sys_char(el[0], el[1], results_with_sys_char)
for el_,val_ in sys_char.items():
if el_ == "file":
combined_sys_chars[el_].append(val_)
continue
if "avg" in el_:
total = sys_char[get_equivalent_total(el_)]
coeff = total
else:
coeff = 1
#if "latency" in el_:
# combined_sys_chars[el_] = (combined_sys_chars[el_][0]+coeff, str(combined_sys_chars[el_][1])+"_"+val_)
#else:
combined_sys_chars[el_] = (combined_sys_chars[el_][0]+coeff, combined_sys_chars[el_][1]+coeff*float(val_))
for key, values in combined_sys_chars.items():
if "avg" in key:
combined_sys_chars[key] = values[1] /max(values[0],.00000000000000000000000000000001)
elif "file" in key:
combined_sys_chars[key] = values
else:
combined_sys_chars[key] = values[1]
if float(combined_sys_chars[system_char_to_show[0]]) == 53675449.0:
for f in combined_sys_chars["file"]:
print("/".join(f.split("/")[:-2])+"./runs/0/system_image.dot")
#if float(combined_sys_chars[system_char_to_show[0]]) == 53008113:
#combined_area_power_in_isolation.append((combined_power_area_tuple[0],combined_power_area_tuple[1], combined_power_area_tuple[2]))
combined_area_power_in_isolation.append((combined_power_area_tuple[0],combined_power_area_tuple[1]))
combined_area_power_in_isolation_with_sys_char.append({(combined_power_area_tuple[0],combined_power_area_tuple[1]): combined_sys_chars})
#if len(combined_area_power_in_isolation)%100000 == 0:
# print("time passed is" + str(time.time()-s))
combined_area_power_in_isolation_filtered = []
for point in combined_area_power_in_isolation:
if not points_exceed_one_of_the_budgets(point, base_budgets, budget_scale_to_consider):
combined_area_power_in_isolation_filtered.append(point)
combined_area_power_pareto = find_pareto_points(list(set(combined_area_power_in_isolation_filtered)))
all_points_cross_workloads_filtered = []
for point in all_points_cross_workloads:
if not points_exceed_one_of_the_budgets(point, base_budgets, budget_scale_to_consider):
all_points_cross_workloads_filtered.append(point)
all_points_cross_workloads_area_power_pareto = find_pareto_points(list(set(all_points_cross_workloads_filtered)))
# prepare for plotting and plot
fig = plt.figure(figsize=(7, 7)) # Ying: (7.5, 7.5) for the main paper, (5, 5) for the extended abstract
axis_font = {'size':'30'}
fontSize = 30
plt.rc('font', **axis_font)
ax = fig.add_subplot(111)
# ax.set_xscale('log')
x_values = [(el[0]) for el in combined_area_power_in_isolation_filtered]
y_values = [(el[1]) for el in combined_area_power_in_isolation_filtered]
x_values.reverse()
y_values.reverse()
ax.scatter(x_values, y_values, label="Myopic Opt",marker="+", color='gold', alpha=1, s=700)
# plt.tight_layout()
x_values = [(el[0]) for el in combined_area_power_pareto]
y_values = [(el[1]) for el in combined_area_power_pareto]
x_values.reverse()
y_values.reverse()
ax.scatter(x_values, y_values, label="Myopic Opt Pareto Front",marker="+", color='darkorange', alpha=0.8, s=700)
# for idx, _ in enumerate(x_values) :
# power= x_values[idx]
# area = y_values[idx]
# sys_char = find_sys_char(power, area, combined_area_power_in_isolation_with_sys_char)
#
# value_to_show = 0
# value_to_show = sys_char[system_char_to_show[0]]
# #for el in system_char_to_show:
# # value_to_show += sys_char[el]
#
# #if system_char_to_show[0] == "latency":
# # value_in_scientific_notation = value_to_show
# #else:
# #value_to_show = sys_char["local_total_traffic"]/(sys_char["local_memory_total_area"]*4*10**12)
# value_in_scientific_notation = "{:.10e}".format(value_to_show)
# value_in_scientific_notation = value_to_show
# #if idx ==0:
#
# #plt.text(power,area, value_in_scientific_notation)
x_values = [(el[0]) for el in all_points_cross_workloads_filtered]
y_values = [(el[1]) for el in all_points_cross_workloads_filtered]
x_values.reverse()
y_values.reverse()
ax.scatter(x_values, y_values, label="FARSI",marker="*", color='limegreen', alpha=1, s=700)
# ax.legend(loc="upper right") # bbox_to_anchor=(1, 1), loc="upper left")
# for idx, _ in enumerate(x_values) :
# power= x_values[idx]
# area = y_values[idx]
# sys_char = find_sys_char(power, area, results_with_sys_char)
#
# value_to_show = 0
# value_to_show = sys_char[system_char_to_show[0]]
# #for el in system_char_to_show:
# # value_to_show += sys_char[el]
#
# #if system_char_to_show[0] == "latency":
# # value_in_scientific_notation = value_to_show
# #else:
# #value_to_show = sys_char["local_total_traffic"]/(sys_char["local_memory_total_area"]*4*10**12)
# value_in_scientific_notation = "{:.2e}".format(value_to_show)
#
# #plt.text(power,area, value_in_scientific_notation)
# #plt.text(power,area, value_in_scientific_notation)
x_values = [(el[0]) for el in all_points_cross_workloads_area_power_pareto]
y_values = [(el[1]) for el in all_points_cross_workloads_area_power_pareto]
x_values.reverse()
y_values.reverse()
ax.scatter(x_values, y_values, label="FARSI Pareto Front",marker="*", color='darkgreen', alpha=0.8, s=700)
# for idx, _ in enumerate(x_values) :
# # power= x_values[idx]
# # area = y_values[idx]
# # sys_char = find_sys_char(power, area, results_with_sys_char)
# #
# # value_to_show = sys_char[system_char_to_show[0]]
# #
# # #if system_char_to_show[0] == "latency":
# # # value_in_scientific_notation = value_to_show
# # #else:
# # #value_to_show = sys_char["local_total_traffic"]/sys_char["local_memory_total_area"]
# # #value_to_show = sys_char["local_total_traffic"]/(sys_char["local_memory_total_area"]*4*10**12)
# # value_in_scientific_notation = "{:.2e}".format(value_to_show)
# #
# # #plt.text(power,area, value_in_scientific_notation)
# ax.set_xticks(np.arange(0.002, 0.009, 0.002))
ax.set_xlabel("Power (W)", fontsize=fontSize)
ax.set_ylabel("Area (mm2)", fontsize=fontSize)
# dump in the top folder
output_base_dir = '/'.join(input_dir_names[0].split("/")[:-2])
output_dir = os.path.join(output_base_dir, "budget_optimality/")
if not os.path.exists(output_dir):
os.makedirs(output_dir)
ax.scatter(combined_design_methodology_A["power"], combined_design_methodology_A["area"], label="Myopic Budgetting",marker="x", color='red', s=700) # Ying: comment out for the extended abstract
ax.legend(loc="upper left", fontsize=fontSize, bbox_to_anchor=(1, 1.1), borderpad=1) # , borderpad=0) # bbox_to_anchor=(1, 1), loc="upper left")
# ax.set_title(system_char_to_show[0] +" for FARSI vs in isolation")
#ax.set_title("memory_reuse for FARSI vs in isolation")
plt.tight_layout()
fig.savefig(os.path.join(output_dir, system_char_to_show[0] + "_budget_optimality.png"), bbox_inches='tight')
#plt.show()
plt.close('all')
def find_pareto_points(points):
efficients = is_pareto_efficient_dumb(np.array(points))
pareto_points_array = [points[idx] for idx, el in enumerate(efficients) if el]
return pareto_points_array
pareto_points = []
for el in pareto_points_array:
list_ = []
for el_ in el:
list.append(el)
pareto_points.append(list_)
return pareto_points
def is_pareto_efficient_dumb(costs):
is_efficient = np.ones(costs.shape[0], dtype = bool)
for i, c in enumerate(costs):
is_efficient[i] = np.all(np.any(costs[:i]>c, axis=1)) and np.all(np.any(costs[i+1:]>c, axis=1))
return is_efficient
###########################################
# the main function. comment out the plots if you do not need them
if __name__ == "__main__":
# populate parameters
run_folder_name = config_plotting.run_folder_name
if config_plotting.run_folder_name == "":
run_folder_name = find_the_most_recent_directory(config_plotting.top_result_folder)[0]
zoneNum = config_plotting.zoneNum
# get all the experiments under the run folder
print(run_folder_name)
experiment_full_addr_list = get_experiment_dir_list(run_folder_name)
# according to the plot type, plot
all_res_column_name_number = get_column_name_number(experiment_full_addr_list[0], "all")
all_results_files = get_experiment_full_file_addr_list(experiment_full_addr_list)
summary_res_column_name_number = get_column_name_number(experiment_full_addr_list[0], "simple")
case_studies = {}
case_studies["bandwidth_analysis"] = ["local_bus_avg_theoretical_bandwidth",
"local_bus_max_actual_bandwidth",
"local_bus_avg_actual_bandwidth",
"system_bus_avg_theoretical_bandwidth",
"system_bus_max_actual_bandwidth",
"system_bus_avg_actual_bandwidth",
"local_channel_avg_actual_bandwidth",
"local_channel_max_actual_bandwidth"
]
case_studies["freq_analysis"] = [
"global_memory_avg_freq", "local_memory_avg_freq", "local_bus_avg_freq",]
case_studies["bus_width_analysis"] = [
"global_memory_avg_bus_width","local_memory_avg_bus_width","local_bus_avg_bus_width"]
case_studies["traffic_analysis"] = ["global_total_traffic", "local_total_traffic",
"local_memory_traffic_per_mem_avg",
"locality_in_bytes",
"local_memory_traffic_per_mem_avg",
"local_bus_traffic_avg",
]
case_studies["local_mem_re_use"] =[
"local_total_traffic_reuse_no_read_ratio",
"local_total_traffic_reuse_no_read_in_bytes",
"local_total_traffic_reuse_no_read_in_size",
"local_total_traffic_reuse_with_read_ratio",
"local_total_traffic_reuse_with_read_in_bytes",
"local_total_traffic_reuse_with_read_in_size",
"local_total_traffic_reuse_no_read_in_bytes_per_cluster_avg",
"local_total_traffic_reuse_no_read_in_size_per_cluster_avg",
"local_total_traffic_reuse_with_read_in_bytes_per_cluster_avg",
"local_total_traffic_reuse_with_read_in_size_per_cluster_avg"
]
case_studies["global_mem_re_use"] =[
"global_total_traffic_reuse_no_read_ratio",
"global_total_traffic_reuse_with_read_ratio",
"global_total_traffic_reuse_with_read_in_bytes",
"global_total_traffic_reuse_with_read_in_size",
"global_total_traffic_reuse_no_read_in_bytes",
"global_total_traffic_reuse_no_read_in_size",
]
case_studies["area_analysis"] = ["global_memory_total_area", "local_memory_total_area", "ips_total_area",
"gpps_total_area",
]
case_studies["area_in_bytes_analysis"] = ["global_memory_total_bytes", "local_memory_total_bytes", "local_memory_bytes_avg"
]
case_studies["accel_paral_analysis"] = ["ip_cnt","max_accel_parallelism", "avg_accel_parallelism",
"gpp_cnt", "max_gpp_parallelism", "avg_gpp_parallelism"]
case_studies["system_complexity"] = ["system block count", "routing complexity", "system PE count",
"local_mem_cnt", "local_bus_cnt","local_channel_count_per_bus_avg", "channel_cnt",
"loop_itr_ratio_avg",
] # , "channel_cnt"]
case_studies["heterogeneity_var_system_compleixty"] = [
"local_channel_count_per_bus_coeff_var",
"loop_itr_ratio_var",
# "cluster_pe_cnt_coeff_var"
]
case_studies["heterogeneity_std_system_compleixty"] = [
"local_channel_count_per_bus_std",
"loop_itr_ratio_std" # , "cluster_pe_cnt_std"
]
"""
case_studies["speedup"] = [
# "customization_speed_up_full_system",
# "loop_unrolling_parallelism_speed_up_full_system",
"customization_speed_up_full_system",
"task_level_parallelism_speed_up_full_system",
"interference_degradation_avg"]
"""
"""
[
"customization_first_speed_up_avg",
"customization_second_speed_up_avg",
"parallelism_first_speed_up_avg",
"parallelism_second_speed_up_avg",
"interference_degradation_avg",
"customization_first_speed_up_full_system",
"customization_second_speed_up_full_system",
"parallelism_first_speed_up_full_system",
"parallelism_second_speed_up_full_system",
]
case_studies["speedup"] = [
"interference_degradation_avg",
"customization_speed_up_full_system",
"parallelism_speed_up_full_system",
"parallelism_nd_speed_up_full_system",
]
"""
case_studies["heterogenity_area"] = [
"local_memory_area_coeff_var",
"ips_area_coeff_var",
"pes_area_coeff_var",
]
case_studies["heterogenity_std_re_use"] = [
"local_total_traffic_reuse_no_read_in_bytes_per_cluster_std",
"local_total_traffic_reuse_no_read_in_size_per_cluster_std",
"local_total_traffic_reuse_with_read_in_bytes_per_cluster_std",
"local_total_traffic_reuse_with_read_in_size_per_cluster_std",
]
case_studies["heterogenity_var_re_use"] = [
"local_total_traffic_reuse_no_read_in_bytes_per_cluster_var",
"local_total_traffic_reuse_no_read_in_size_per_cluster_var",
"local_total_traffic_reuse_with_read_in_bytes_per_cluster_var",
"local_total_traffic_reuse_with_read_in_size_per_cluster_var",
]
case_studies["heterogenity_var_freq"] =[
"local_bus_freq_coeff_var",
"local_memory_freq_coeff_var",
"ips_freq_coeff_var",
"pes_freq_coeff_var"]
case_studies["heterogenity_std_freq"] =[
"local_memory_freq_std",
"local_bus_freq_std",
]
case_studies["heterogenity_std_bus_width"] =[
"local_memory_bus_width_std",
"local_bus_bus_width_std",
]
case_studies["heterogenity_var_bus_width"] =[
"local_memory_bus_width_coeff_var",
"local_bus_bus_width_coeff_var",
]
case_studies["heterogenity_std_bandwidth"]=[
"local_bus_actual_bandwidth_std",
"local_channel_actual_bandwidth_std"]
case_studies["heterogenity_var_bandwidth"]=[
"local_bus_actual_bandwidth_coeff_var",
"local_channel_actual_bandwidth_coeff_var"]
case_studies["heterogenity_std_traffic"] =[
"local_memory_bytes_std",
"local_memory_traffic_per_mem_coeff_var",
"local_bus_traffic_coeff_var",
]
case_studies["heterogenity_var_traffic"] =[
"local_memory_bytes_coeff_var",
"local_memory_traffic_per_mem_coeff_var",
"local_bus_traffic_coeff_var",
]
if "budget_optimality" in config_plotting.plot_list: # Ying: optimal_budgetting_problem_08_1
#get_budget_optimality_advanced(experiment_full_addr_list, all_results_files, summary_res_column_name_number)
for el in experiment_full_addr_list:
if "a_e_h" in el and not "lat_1__pow_1__area_1" in el:
a_e_h_summary_res_column_name_number = get_column_name_number(el, "simple")
if config_plotting.draw_for_paper:
get_budget_optimality_for_paper(experiment_full_addr_list, all_results_files, summary_res_column_name_number, a_e_h_summary_res_column_name_number)
else:
get_budget_optimality(experiment_full_addr_list, all_results_files, summary_res_column_name_number, a_e_h_summary_res_column_name_number)
if "cross_workloads" in config_plotting.plot_list: # Ying: from for_paper/workload_awareness (PE, Mem, IC, TLP, comm_comp); or blind_study_smart_krnel_selection/blind_vs_arch_ware; or blind_study_dumb_kernel_selection/blind_vs_arch_aware; or blind_study_all_dumb_versions/blind_vs_arch_aware (SA and other aware)
# get column orders (assumption is that the column order doesn't change between experiments)
if config_plotting.draw_for_paper:
column_column_value_experiment_frequency_dict = plot_codesign_nav_breakdown_cross_workload_for_paper(
experiment_full_addr_list, all_res_column_name_number)
plot_convergence_cross_workloads_for_paper(experiment_full_addr_list, all_res_column_name_number)
else:
column_column_value_experiment_frequency_dict = plot_codesign_nav_breakdown_cross_workload(experiment_full_addr_list, all_res_column_name_number)
plot_convergence_cross_workloads(experiment_full_addr_list, all_res_column_name_number)
for key, val in case_studies.items():
case_study = {key:val}
# plot_system_implication_analysis(experiment_full_addr_list, summary_res_column_name_number, case_study)
plot_co_design_nav_breakdown_post_processing(experiment_full_addr_list, column_column_value_experiment_frequency_dict)
if config_plotting.draw_for_paper:
plot_codesign_rate_efficacy_cross_workloads_updated_for_paper(experiment_full_addr_list, all_res_column_name_number)
else:
#plot_codesign_rate_efficacy_cross_workloads_updated(experiment_full_addr_list, all_res_column_name_number)
pass
if "single_workload" in config_plotting.plot_list: # Ying: blind_study_all_dumb_versions/blind_vs_arch_aware
#single workload
# plot_codesign_progression_per_workloads(experiment_full_addr_list, all_res_column_name_number)
_ = plot_codesign_nav_breakdown_per_workload(experiment_full_addr_list, all_res_column_name_number)
if config_plotting.draw_for_paper:
# plot_convergence_per_workloads_for_paper(experiment_full_addr_list, all_res_column_name_number)
plot_convergence_vs_time_for_paper(experiment_full_addr_list, all_res_column_name_number)
else:
plot_convergence_per_workloads(experiment_full_addr_list, all_res_column_name_number)
plot_convergence_vs_time(experiment_full_addr_list, all_res_column_name_number)
if "plot_3d" in config_plotting.plot_list:
plot_3d(experiment_full_addr_list, summary_res_column_name_number)
if "pie_chart" in config_plotting.plot_list: # Ying: 1_1_1_for_paper_07-31
pie_chart_case_study = {"Performance Breakdown": ["transformation generation time", "simulation time",
"neighbour selection time"],
"Transformation_Generation_Breakdown": ["metric selection time", "dir selection time", "kernel selection time",
"block selection time", "transformation selection time",
"design duplication time", "metric selection time"]}
# , "architectural principle", "high level optimization name", "exact optimization name"]
for case_study_ in pie_chart_case_study.items():
if config_plotting.draw_for_paper:
pie_chart_for_paper(experiment_full_addr_list, all_res_column_name_number, case_study_)
else:
pie_chart(experiment_full_addr_list, all_res_column_name_number, case_study_)
if "pandas_plots" in config_plotting.plot_list: # Ying: from scaling_of_1_2_4_across_all_budgets_07-31
#pandas_case_studies = {}
case_studies["system_complexity"] = ["system block count", "routing complexity", "system PE count",
"local_mem_cnt", "local_bus_cnt" , "channel_cnt", "ip_cnt", "gpp_cnt"]
case_studies["pe_parallelism"] = ["max_accel_parallelism", "avg_accel_parallelism", "avg_gpp_parallelism", "max_gpp_parallelism"]
case_studies["ip_frequency"] = ["ips_avg_freq", "gpps_avg_freq", "ips_freq_std", "pes_freq_std",
"ips_freq_coeff_var", "pes_freq_coeff_var"]
case_studies["pe_area"] = ["ips_total_area", "gpps_total_area", "ips_area_std", "pes_area_std",
"ips_area_coeff_var", "pes_area_coeff_var"]
case_studies["mem_frequency"] = ["local_memory_avg_freq", "global_memory_avg_freq",
"local_memory_freq_std","local_memory_freq_coeff_var"]
case_studies["mem_area"] = ["local_memory_total_area", "global_memory_total_area", "local_memory_area_std",
"local_memory_area_coeff_var"]
case_studies["traffic"] = ["local_total_traffic", "global_total_traffic"]
case_studies["bus_width"] = ["local_bus_avg_bus_width",
"system_bus_avg_bus_width"]
case_studies["bus_bandwidth"] = ["local_bus_avg_actual_bandwidth", "system_bus_avg_actual_bandwidth",
"local_bus_avg_theoretical_bandwidth", "system_bus_avg_theoretical_bandwidth",
"local_bus_max_actual_bandwidth", "system_bus_max_actual_bandwidth"]
for case_study_name, metrics in case_studies.items():
for metric in metrics:
if config_plotting.draw_for_paper:
pandas_plots_for_paper(experiment_full_addr_list, all_results_files, metric)
else:
pandas_plots(experiment_full_addr_list, all_results_files, metric)
# get the the workload_set folder
# each workload_set has a bunch of experiments underneath it
workload_set_folder_list = os.listdir(run_folder_name)
if "drivers" in config_plotting.plot_list:
simple_stack_bar_plot(run_folder_name)
# iterate and generate plots
for workload_set_folder in workload_set_folder_list:
# ignore irelevant files
if workload_set_folder in config_plotting.ignore_file_names:
continue
# start plotting
#plotBudgets3d(run_folder_name, workload_set_folder)
"""
# get experiment folder
workload_set_full_addr = os.path.join(run_folder_name,workload_set_folder)
folder_list = os.listdir(workload_set_full_addr)
for experiment_name_relative_addr in folder_list:
print(experiment_name_relative_addr)
if experiment_name_relative_addr in config_plotting.ignore_file_names:
continue
experiment_full_addr = os.path.join(workload_set_full_addr, experiment_name_relative_addr)
all_res_column_name_number = get_column_name_number(experiment_full_addr, "all")
summary_res_column_name_number = get_column_name_number(experiment_full_addr, "simple")
workload_set_full_addr +="/" # this is because you didn't use join
commcompColNum = columnNum(workload_set_full_addr, experiment_name_relative_addr, "comm_comp", "all")
trueNum = columnNum(workload_set_full_addr, experiment_name_relative_addr, "move validity", "all")
optColNum = columnNum(workload_set_full_addr, experiment_name_relative_addr, "high level optimization name", "all")
archColNum = columnNum(workload_set_full_addr, experiment_name_relative_addr, "architectural principle", "all")
sysBlkNum = columnNum(workload_set_full_addr, experiment_name_relative_addr, "system block count", "all")
simColNum = columnNum(workload_set_full_addr, experiment_name_relative_addr, "simulation time", "all")
movGenColNum = columnNum(workload_set_full_addr, experiment_name_relative_addr, "transformation generation time", "all")
movColNum = columnNum(workload_set_full_addr, experiment_name_relative_addr, "move name", "all")
itrNum = columnNum(workload_set_full_addr, experiment_name_relative_addr, "iteration cnt", "all")
distColNum = columnNum(workload_set_full_addr, experiment_name_relative_addr, "dist_to_goal_non_cost", "all")
refDistColNum = columnNum(workload_set_full_addr, experiment_name_relative_addr, "ref_des_dist_to_goal_non_cost", "all")
latNum = columnNum(workload_set_full_addr, experiment_name_relative_addr, "latency", "all")
powNum = columnNum(workload_set_full_addr, experiment_name_relative_addr, "power", "all")
areaNum = columnNum(workload_set_full_addr, experiment_name_relative_addr, "area", "all")
# comment or uncomment the following functions for your plottings
plotDistToGoalVSitr([experiment_full_addr], all_res_column_name_number)
plotCommCompAll(workload_set_full_addr, experiment_name_relative_addr, all_res_column_name_number)
plothighLevelOptAll(workload_set_full_addr, experiment_name_relative_addr, all_res_column_name_number)
plotArchVarImpAll(workload_set_full_addr, experiment_name_relative_addr, archColNum, trueNum)
plotSimTimeVSblk(workload_set_full_addr, experiment_name_relative_addr, sysBlkNum, simColNum, trueNum)
plotMoveGenTimeVSblk(workload_set_full_addr, experiment_name_relative_addr, sysBlkNum, movGenColNum, trueNum)
plotRefDistToGoalVSitr(workload_set_full_addr, experiment_name_relative_addr, itrNum, refDistColNum, trueNum)
plotSimTimeVSmoveNameZoneDist(workload_set_full_addr, experiment_name_relative_addr, zoneNum, movColNum, distColNum, simColNum, trueNum)
plotMovGenTimeVSmoveNameZoneDist(workload_set_full_addr, experiment_name_relative_addr, zoneNum, movColNum, distColNum, movGenColNum, trueNum)
plotSimTimeVScommCompZoneDist(workload_set_full_addr, experiment_name_relative_addr, zoneNum, commcompColNum, distColNum, simColNum, trueNum)
plotMovGenTimeVScommCompZoneDist(workload_set_full_addr, experiment_name_relative_addr, zoneNum, commcompColNum, distColNum, movGenColNum, trueNum)
plotSimTimeVShighLevelOptZoneDist(workload_set_full_addr, experiment_name_relative_addr, zoneNum, optColNum, distColNum, simColNum, trueNum)
plotMovGenTimeVShighLevelOptZoneDist(workload_set_full_addr, experiment_name_relative_addr, zoneNum, optColNum, distColNum, movGenColNum, trueNum)
plotSimTimeVSarchVarImpZoneDist(workload_set_full_addr, experiment_name_relative_addr, zoneNum, archColNum, distColNum, simColNum, trueNum)
plotMovGenTimeVSarchVarImpZoneDist(workload_set_full_addr, experiment_name_relative_addr, zoneNum, archColNum, distColNum, movGenColNum, trueNum)