in design_utils/design.py [0:0]
def get_memory_system_attr(self):
memory_system_attr = {}
local_memories = [el for el in self.dp_rep.get_blocks() if el.subtype == "sram"]
global_memories = [el for el in self.dp_rep.get_blocks() if el.subtype == "dram"]
buses = [el for el in self.dp_rep.get_blocks() if el.subtype == "ic"]
# get frequency data
local_memory_freqs = [mem.get_block_freq() for mem in local_memories]
global_memory_freqs = [mem.get_block_freq() for mem in global_memories]
if len(local_memory_freqs) == 0:
local_memory_avg_freq = 0
else:
local_memory_avg_freq= sum(local_memory_freqs)/max(len(local_memory_freqs),1)
if len(local_memory_freqs) in [0, 1]:
local_memory_freq_std = 0
local_memory_freq_coeff_var = 0
else:
local_memory_freq_std = st.stdev(local_memory_freqs)
local_memory_freq_coeff_var = st.stdev(local_memory_freqs) / st.mean(local_memory_freqs)
if len(global_memory_freqs) == 0:
global_memory_avg_freq = 0
else:
global_memory_avg_freq= sum(global_memory_freqs)/max(len(global_memory_freqs),1)
# get bus width data
local_memory_bus_widths = [mem.get_block_bus_width() for mem in local_memories]
global_memory_bus_widths = [mem.get_block_bus_width() for mem in global_memories]
if len(local_memory_bus_widths) == 0:
local_memory_avg_bus_width = 0
else:
local_memory_avg_bus_width= sum(local_memory_bus_widths)/max(len(local_memory_bus_widths),1)
if len(local_memory_bus_widths) in [0, 1]:
local_memory_bus_width_std = 0
local_memory_bus_width_coeff_var = 0
else:
local_memory_bus_width_std = st.stdev(local_memory_bus_widths)
local_memory_bus_width_coeff_var = st.stdev(local_memory_bus_widths) / st.mean(local_memory_bus_widths)
if len(global_memory_bus_widths) == 0:
global_memory_avg_bus_width = 0
else:
global_memory_avg_bus_width= sum(global_memory_bus_widths)/max(len(global_memory_bus_widths),1)
#get bytes data
local_memory_bytes = []
for mem in local_memories:
mem_bytes = max(mem.get_area_in_bytes(), config.cacti_min_memory_size_in_bytes) # to make sure we don't go smaller than cacti's minimum size
local_memory_bytes.append((math.ceil(mem_bytes / config.min_mem_size[mem.subtype])) * config.min_mem_size[mem.subtype]) # modulo calculation
if len(local_memory_bytes) == 0:
local_memory_total_bytes = 0
local_memory_bytes_avg = 0
else:
local_memory_total_bytes = sum(local_memory_bytes)
local_memory_bytes_avg = st.mean(local_memory_bytes)
if len(local_memory_bytes) in [0,1]:
local_memory_bytes_std = 0
local_memory_bytes_coeff_var = 0
else:
local_memory_bytes_std = st.stdev(local_memory_bytes)
local_memory_bytes_coeff_var = st.stdev(local_memory_bytes)/max(st.mean(local_memory_bytes),.0000000001)
global_memory_bytes = []
for mem in global_memories:
mem_bytes = max(mem.get_area_in_bytes(), config.cacti_min_memory_size_in_bytes) # to make sure we don't go smaller than cacti's minimum size
global_memory_bytes.append((math.ceil(mem_bytes / config.min_mem_size[mem.subtype])) * config.min_mem_size[mem.subtype]) # modulo calculation
if len(global_memory_bytes) == 0:
global_memory_total_bytes = 0
else:
global_memory_total_bytes = sum(global_memory_bytes)
if len(global_memory_bytes) in [0,1]:
global_memory_bytes_std = 0
global_memory_bytes_coeff_var = 0
else:
global_memory_bytes_std = st.stdev(global_memory_bytes)
global_memory_bytes_coeff_var = st.stdev(global_memory_bytes) / max(st.mean(global_memory_bytes),.00000001)
# get area data
local_memory_area = [mem.get_area() for mem in local_memories]
global_memory_area = [mem.get_area() for mem in global_memories]
if len(local_memory_area) == 0:
local_memory_total_area = 0
else:
local_memory_total_area = sum(local_memory_area)
if len(local_memory_area) in [0,1]:
local_memory_area_std = 0
local_memory_area_coeff_var = 0
else:
local_memory_area_std = st.stdev(local_memory_area)
local_memory_area_coeff_var = st.stdev(local_memory_area) / st.mean(local_memory_area)
if len(global_memory_area) == 0:
global_memory_total_area = 0
else:
global_memory_total_area = sum(global_memory_area)
# get traffic data
local_total_traffic = 0
for mem in local_memories:
block_s_krnels = self.get_krnels_of_block(mem)
for krnl in block_s_krnels:
local_total_traffic += krnl.calc_traffic_per_block(mem)
local_traffic_per_mem = {}
for mem in local_memories:
local_traffic_per_mem[mem] =0
block_s_krnels = self.get_krnels_of_block(mem)
for krnl in block_s_krnels:
local_traffic_per_mem[mem] += krnl.calc_traffic_per_block(mem)
global_total_traffic = 0
for mem in global_memories:
block_s_krnels = self.get_krnels_of_block(mem)
for krnl in block_s_krnels:
global_total_traffic += krnl.calc_traffic_per_block(mem)
local_bus_traffic = {}
for mem in local_memories:
local_traffic = 0
block_s_krnels = self.get_krnels_of_block(mem)
for krnl in block_s_krnels:
local_traffic += krnl.calc_traffic_per_block(mem)
for bus in buses:
if mem in bus.get_neighs():
if bus not in local_bus_traffic.keys():
local_bus_traffic[bus] = 0
local_bus_traffic[bus] += local_traffic
break
# get traffic reuse
local_traffic_reuse_no_read_ratio = []
local_traffic_reuse_no_read_in_bytes = []
local_traffic_reuse_no_read_in_size = []
local_traffic_reuse_with_read_ratio= []
local_traffic_reuse_with_read_in_bytes = []
local_traffic_reuse_with_read_in_size = []
mem_local_traffic = {}
for mem in local_memories:
local_traffic = 0
block_s_krnels = self.get_krnels_of_block(mem)
for krnl in block_s_krnels:
local_traffic += krnl.calc_traffic_per_block(mem)
mem_local_traffic[mem] = local_traffic
mem_bytes = max(mem.get_area_in_bytes(), config.cacti_min_memory_size_in_bytes) # to make sure we don't go smaller than cacti's minimum size
#mem_bytes_modulo = (math.ceil(mem_bytes/config.min_mem_size[mem.subtype]))*config.min_mem_size[mem.subtype] # modulo calculation
mem_size = mem.get_area()
reuse_ratio_no_read = max((local_traffic/mem_bytes)-2, 0)
local_traffic_reuse_no_read_ratio.append(reuse_ratio_no_read)
local_traffic_reuse_no_read_in_bytes.append(reuse_ratio_no_read*mem_bytes)
local_traffic_reuse_no_read_in_size.append(reuse_ratio_no_read*mem_size)
reuse_ratio_with_read = max((local_traffic/mem_bytes)-1, 0)
local_traffic_reuse_with_read_ratio.append(reuse_ratio_with_read)
local_traffic_reuse_with_read_in_bytes.append(reuse_ratio_with_read*mem_bytes)
local_traffic_reuse_with_read_in_size.append(reuse_ratio_with_read*mem_size)
if len(local_memories) == 0:
local_total_traffic_reuse_no_read_ratio = 0
local_total_traffic_reuse_no_read_in_bytes = 0
local_total_traffic_reuse_no_read_in_size = 0
local_total_traffic_reuse_with_read_ratio = 0
local_total_traffic_reuse_with_read_in_bytes = 0
local_total_traffic_reuse_with_read_in_size = 0
local_traffic_per_mem_avg = 0
else:
local_total_traffic_reuse_no_read_ratio = max((local_total_traffic/local_memory_total_bytes)-2, 0)
local_total_traffic_reuse_no_read_in_bytes = sum(local_traffic_reuse_no_read_in_bytes)
local_total_traffic_reuse_no_read_in_size = sum(local_traffic_reuse_no_read_in_size)
local_total_traffic_reuse_with_read_ratio = max((local_total_traffic/local_memory_total_bytes)-1, 0)
local_total_traffic_reuse_with_read_in_bytes = sum(local_traffic_reuse_with_read_in_bytes)
local_total_traffic_reuse_with_read_in_size = sum(local_traffic_reuse_with_read_in_size)
local_traffic_per_mem_avg = st.mean(list(local_traffic_per_mem.values()))
if len(local_bus_traffic) == 0:
local_bus_traffic_avg = 0
else:
local_bus_traffic_avg = st.mean(list(local_bus_traffic.values()))
if len(local_memories) in [0,1]:
local_traffic_per_mem_std = 0
local_traffic_per_mem_coeff_var = 0
else:
local_traffic_per_mem_std = st.stdev(list(local_traffic_per_mem.values()))
local_traffic_per_mem_coeff_var = st.stdev(list(local_traffic_per_mem.values()))/st.mean(list(local_traffic_per_mem.values()))
if len(local_bus_traffic) in [0,1]:
local_bus_traffic_std = 0
local_bus_traffic_coeff_var = 0
else:
local_bus_traffic_std = st.stdev(list(local_bus_traffic.values()))
local_bus_traffic_coeff_var = st.stdev(list(local_bus_traffic.values()))/st.mean(list(local_bus_traffic.values()))
# get traffic reuse
global_traffic_reuse_no_read_ratio= []
global_traffic_reuse_no_read_in_bytes = []
global_traffic_reuse_no_read_in_size = []
global_traffic_reuse_with_read_ratio= []
global_traffic_reuse_with_read_in_bytes = []
global_traffic_reuse_with_read_in_size = []
for mem in global_memories:
global_traffic = 0
block_s_krnels = self.get_krnels_of_block(mem)
for krnl in block_s_krnels:
global_traffic += krnl.calc_traffic_per_block(mem)
mem_bytes = max(mem.get_area_in_bytes(), config.cacti_min_memory_size_in_bytes) # to make sure we don't go smaller than cacti's minimum size
#mem_bytes_modulo = (math.ceil(mem_bytes/config.min_mem_size[mem.subtype]))*config.min_mem_size[mem.subtype] # modulo calculation
mem_size = mem.get_area()
reuse_ratio_no_read = max((global_traffic/mem_bytes)-2, 0)
global_traffic_reuse_no_read_ratio.append(reuse_ratio_no_read)
global_traffic_reuse_no_read_in_bytes.append(reuse_ratio_no_read*mem_bytes)
global_traffic_reuse_no_read_in_size.append(reuse_ratio_no_read*mem_size)
reuse_ratio_with_read = max((global_traffic/mem_bytes)-1, 0)
global_traffic_reuse_with_read_ratio.append(reuse_ratio_with_read)
global_traffic_reuse_with_read_in_bytes.append(reuse_ratio_with_read*mem_bytes)
global_traffic_reuse_with_read_in_size.append(reuse_ratio_with_read*mem_size)
if len(global_memories) == 0:
global_total_traffic_reuse_no_read_ratio = 0
global_total_traffic_reuse_no_read_in_bytes = 0
global_total_traffic_reuse_no_read_in_size = 0
global_total_traffic_reuse_with_read_ratio = 0
global_total_traffic_reuse_with_read_in_bytes = 0
global_total_traffic_reuse_with_read_in_size = 0
else:
global_total_traffic_reuse_no_read_ratio = max((global_total_traffic/global_memory_total_bytes)-2, 0)
global_total_traffic_reuse_no_read_in_bytes = sum(global_traffic_reuse_no_read_in_bytes)
global_total_traffic_reuse_no_read_in_size = sum(global_traffic_reuse_no_read_in_size)
global_total_traffic_reuse_with_read_ratio = max((global_total_traffic/global_memory_total_bytes)-1, 0)
global_total_traffic_reuse_with_read_in_bytes = sum(global_traffic_reuse_with_read_in_bytes)
global_total_traffic_reuse_with_read_in_size = sum(global_traffic_reuse_with_read_in_size)
# per cluster start
# get traffic reuse
local_traffic_reuse_no_read_in_bytes_per_cluster = {}
local_traffic_reuse_no_read_in_size_per_cluster = {}
local_traffic_reuse_with_read_ratio_per_cluster = {}
local_traffic_reuse_with_read_in_bytes_per_cluster = {}
local_traffic_reuse_with_read_in_size_per_cluster = {}
for bus in buses:
mems = [blk for blk in bus.get_neighs() if blk.subtype == "sram"]
local_traffic_reuse_no_read_in_bytes_per_cluster[bus] = 0
local_traffic_reuse_no_read_in_size_per_cluster[bus] = 0
local_traffic_reuse_with_read_in_bytes_per_cluster[bus] = 0
local_traffic_reuse_with_read_in_size_per_cluster[bus] = 0
for mem in mems:
local_traffic = 0
block_s_krnels = self.get_krnels_of_block(mem)
for krnl in block_s_krnels:
local_traffic += krnl.calc_traffic_per_block(mem)
mem_bytes = max(mem.get_area_in_bytes(), config.cacti_min_memory_size_in_bytes) # to make sure we don't go smaller than cacti's minimum size
#mem_bytes_modulo = (math.ceil(mem_bytes/config.min_mem_size[mem.subtype]))*config.min_mem_size[mem.subtype] # modulo calculation
mem_size = mem.get_area()
reuse_ratio_no_read_per_cluster = max((local_traffic/mem_bytes)-2, 0)
local_traffic_reuse_no_read_in_bytes_per_cluster[bus]+= (reuse_ratio_no_read_per_cluster*mem_bytes)
local_traffic_reuse_no_read_in_size_per_cluster[bus]+=(reuse_ratio_no_read_per_cluster*mem_size)
reuse_ratio_with_read_per_cluster = max((local_traffic/mem_bytes)-1, 0)
local_traffic_reuse_with_read_in_bytes_per_cluster[bus] += (reuse_ratio_with_read_per_cluster*mem_bytes)
local_traffic_reuse_with_read_in_size_per_cluster[bus] += (reuse_ratio_with_read_per_cluster*mem_size)
local_total_traffic_reuse_no_read_in_size_per_cluster_avg = st.mean(list(local_traffic_reuse_no_read_in_size_per_cluster.values()))
local_total_traffic_reuse_with_read_in_size_per_cluster_avg = st.mean(list(local_traffic_reuse_with_read_in_size_per_cluster.values()))
local_total_traffic_reuse_no_read_in_bytes_per_cluster_avg = st.mean(list(local_traffic_reuse_no_read_in_bytes_per_cluster.values()))
local_total_traffic_reuse_with_read_in_bytes_per_cluster_avg = st.mean(list(local_traffic_reuse_with_read_in_bytes_per_cluster.values()))
if len(buses) in [0,1]:
local_total_traffic_reuse_no_read_in_size_per_cluster_std = 0
local_total_traffic_reuse_with_read_in_size_per_cluster_std = 0
local_total_traffic_reuse_no_read_in_bytes_per_cluster_std = 0
local_total_traffic_reuse_with_read_in_bytes_per_cluster_std = 0
local_total_traffic_reuse_no_read_in_size_per_cluster_var = 0
local_total_traffic_reuse_with_read_in_size_per_cluster_var = 0
local_total_traffic_reuse_no_read_in_bytes_per_cluster_var = 0
local_total_traffic_reuse_with_read_in_bytes_per_cluster_var = 0
else:
local_total_traffic_reuse_no_read_in_size_per_cluster_std = st.stdev(
list(local_traffic_reuse_no_read_in_size_per_cluster.values()))
local_total_traffic_reuse_with_read_in_size_per_cluster_std = st.stdev(
list(local_traffic_reuse_with_read_in_size_per_cluster.values()))
local_total_traffic_reuse_no_read_in_bytes_per_cluster_std = st.stdev(
list(local_traffic_reuse_no_read_in_bytes_per_cluster.values()))
local_total_traffic_reuse_with_read_in_bytes_per_cluster_std = st.stdev(
list(local_traffic_reuse_with_read_in_bytes_per_cluster.values()))
local_total_traffic_reuse_no_read_in_size_per_cluster_var = st.stdev(list(local_traffic_reuse_no_read_in_size_per_cluster.values()))/max(st.mean(list(local_traffic_reuse_no_read_in_size_per_cluster.values())),.000001)
local_total_traffic_reuse_with_read_in_size_per_cluster_var = st.stdev(list(local_traffic_reuse_with_read_in_size_per_cluster.values()))/max(st.mean(list(local_traffic_reuse_with_read_in_size_per_cluster.values())),.0000001)
local_total_traffic_reuse_no_read_in_bytes_per_cluster_var = st.stdev(list(local_traffic_reuse_no_read_in_bytes_per_cluster.values()))/max(st.mean(list(local_traffic_reuse_no_read_in_bytes_per_cluster.values())),.000000001)
local_total_traffic_reuse_with_read_in_bytes_per_cluster_var = st.stdev(list(local_traffic_reuse_with_read_in_bytes_per_cluster.values()))/max(st.mean(list(local_traffic_reuse_with_read_in_bytes_per_cluster.values())),.00000001)
# per cluseter end
locality_in_bytes = 0
for krnl in self.__kernels:
pe = [blk for blk in krnl.get_blocks() if blk.type == "pe"][0]
mems = [blk for blk in krnl.get_blocks() if blk.type == "mem"]
for mem in mems:
path_length = len(self.dp_rep.get_hardware_graph().get_path_between_two_vertecies(pe, mem))
locality_in_bytes += krnl.calc_traffic_per_block(mem)/(path_length-2)
"""
#parallelism data
for mem in local_memories:
bal_traffic = 0
block_s_krnels = self.get_krnels_of_block(mem)
for krnl in blocks_krnels:
krnl.block_phase_read_dict[mem][self.phase_num] += read_work
"""
return {"local_total_traffic":local_total_traffic, "global_total_traffic":global_total_traffic,
"local_total_traffic_reuse_no_read_ratio": local_total_traffic_reuse_no_read_ratio, "global_total_traffic_reuse_no_read_ratio": global_total_traffic_reuse_no_read_ratio,
"local_total_traffic_reuse_no_read_in_bytes": local_total_traffic_reuse_no_read_in_bytes, "global_total_traffic_reuse_no_read_in_bytes": global_total_traffic_reuse_no_read_in_bytes,
"local_total_traffic_reuse_no_read_in_size": local_total_traffic_reuse_no_read_in_size, "global_total_traffic_reuse_no_read_in_size": global_total_traffic_reuse_no_read_in_size,
"local_total_traffic_reuse_with_read_ratio": local_total_traffic_reuse_with_read_ratio,
"global_total_traffic_reuse_with_read_ratio": global_total_traffic_reuse_with_read_ratio,
"local_total_traffic_reuse_with_read_in_bytes": local_total_traffic_reuse_with_read_in_bytes,
"global_total_traffic_reuse_with_read_in_bytes": global_total_traffic_reuse_with_read_in_bytes,
"local_total_traffic_reuse_with_read_in_size": local_total_traffic_reuse_with_read_in_size,
"global_total_traffic_reuse_with_read_in_size": global_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_bytes_per_cluster_avg,
"local_total_traffic_reuse_no_read_in_bytes_per_cluster_std": local_total_traffic_reuse_no_read_in_bytes_per_cluster_std,
"local_total_traffic_reuse_no_read_in_bytes_per_cluster_var": local_total_traffic_reuse_no_read_in_bytes_per_cluster_var,
"local_total_traffic_reuse_no_read_in_size_per_cluster_avg": local_total_traffic_reuse_no_read_in_size_per_cluster_avg,
"local_total_traffic_reuse_no_read_in_size_per_cluster_std": local_total_traffic_reuse_no_read_in_size_per_cluster_std,
"local_total_traffic_reuse_no_read_in_size_per_cluster_var": local_total_traffic_reuse_no_read_in_size_per_cluster_var,
"local_total_traffic_reuse_with_read_in_bytes_per_cluster_avg": local_total_traffic_reuse_with_read_in_bytes_per_cluster_avg,
"local_total_traffic_reuse_with_read_in_bytes_per_cluster_std": local_total_traffic_reuse_with_read_in_bytes_per_cluster_std,
"local_total_traffic_reuse_with_read_in_bytes_per_cluster_var": local_total_traffic_reuse_with_read_in_bytes_per_cluster_var,
"local_total_traffic_reuse_with_read_in_size_per_cluster_avg": local_total_traffic_reuse_with_read_in_size_per_cluster_avg,
"local_total_traffic_reuse_with_read_in_size_per_cluster_std": local_total_traffic_reuse_with_read_in_size_per_cluster_std,
"local_total_traffic_reuse_with_read_in_size_per_cluster_var": local_total_traffic_reuse_with_read_in_size_per_cluster_var,
"global_memory_avg_freq": global_memory_avg_freq,
"local_memory_avg_freq": local_memory_avg_freq,
"local_memory_freq_coeff_var": local_memory_freq_coeff_var, "local_memory_freq_std": local_memory_freq_std,
"global_memory_avg_bus_width": global_memory_avg_bus_width,
"local_memory_avg_bus_width": local_memory_avg_bus_width,
"local_memory_bus_width_coeff_var": local_memory_bus_width_coeff_var,
"local_memory_bus_width_std": local_memory_bus_width_std,
"global_memory_total_area": global_memory_total_area,
"local_memory_total_area":local_memory_total_area,
"local_memory_area_coeff_var": local_memory_area_coeff_var, "local_memory_area_std": local_memory_area_std,
"global_memory_total_bytes": global_memory_total_bytes,
"local_memory_total_bytes": local_memory_total_bytes,
"local_memory_bytes_avg": local_memory_bytes_avg,
"local_memory_bytes_coeff_var": local_memory_bytes_coeff_var, "local_memory_bytes_std": local_memory_bytes_std,
"memory_total_area":global_memory_total_area+local_memory_total_area,
"local_mem_cnt":len(local_memory_freqs),
"local_memory_traffic_per_mem_avg": local_traffic_per_mem_avg,
"local_memory_traffic_per_mem_std": local_traffic_per_mem_coeff_var,
"local_memory_traffic_per_mem_coeff_var": local_traffic_per_mem_coeff_var,
"local_bus_traffic_avg": local_bus_traffic_avg,
"local_bus_traffic_std": local_bus_traffic_std,
"local_bus_traffic_coeff_var": local_bus_traffic_coeff_var,
"locality_in_bytes": locality_in_bytes
}