def test_routing_functions(self):
initial_config_ag = deepcopy(Config.ag)
initial_turn_model = Config.UsedTurnModel
initial_routing_type = Config.RotingType
Config.ag.type = "Generic"
Config.ag.topology = "2DMesh"
Config.ag.x_size = 3
Config.ag.y_size = 3
Config.ag.z_size = 1
for turn_model in PackageFile.routing_alg_list_2d:
Config.UsedTurnModel = deepcopy(turn_model)
Config.TurnsHealth = deepcopy(Config.setup_turns_health())
ag_4_test = deepcopy(generate_ag(logging=None))
shmu_4_test = SystemHealthMonitoringUnit.SystemHealthMonitoringUnit()
shmu_4_test.setup_noc_shm(ag_4_test, Config.TurnsHealth, False)
noc_rg = generate_noc_route_graph(ag_4_test, shmu_4_test, turn_model, False, False)
self.assertEqual(check_deadlock_freeness(noc_rg), True)
if turn_model in [PackageFile.XY_TurnModel, PackageFile.YX_TurnModel]:
if turn_model == PackageFile.XY_TurnModel:
self.assertEqual(return_turn_model_name(turn_model), '0')
else:
self.assertEqual(return_turn_model_name(turn_model), '13')
self.assertEqual(degree_of_adaptiveness(ag_4_test, noc_rg, False)/72, 1)
self.assertEqual(extended_degree_of_adaptiveness(ag_4_test, noc_rg, False)/72, 1)
del ag_4_test
del shmu_4_test
Config.ag.type = "Generic"
Config.ag.topology = "3DMesh"
Config.ag.x_size = 3
Config.ag.y_size = 3
Config.ag.z_size = 3
Config.RotingType = "NonMinimalPath"
for turn_model in PackageFile.routing_alg_list_3d:
Config.UsedTurnModel = deepcopy(turn_model)
Config.TurnsHealth = deepcopy(Config.setup_turns_health())
ag_4_test = deepcopy(generate_ag(logging=None))
shmu_4_test = SystemHealthMonitoringUnit.SystemHealthMonitoringUnit()
shmu_4_test.setup_noc_shm(ag_4_test, Config.TurnsHealth, False)
noc_rg = generate_noc_route_graph(ag_4_test, shmu_4_test, turn_model, False, False)
self.assertEqual(check_deadlock_freeness(noc_rg), True)
if turn_model == PackageFile.XYZ_TurnModel:
self.assertEqual(return_turn_model_name(turn_model), "3d_XYZ")
self.assertEqual(degree_of_adaptiveness(ag_4_test, noc_rg, False)/702, 1)
self.assertEqual(extended_degree_of_adaptiveness(ag_4_test, noc_rg, False)/702, 1)
if turn_model == PackageFile.NegativeFirst3D_TurnModel:
self.assertEqual(return_turn_model_name(turn_model), "3d_NegFirst")
del ag_4_test
del shmu_4_test
del noc_rg
Config.ag = deepcopy(initial_config_ag)
Config.UsedTurnModel = initial_turn_model
Config.TurnsHealth = deepcopy(Config.setup_turns_health())
Config.RotingType = initial_routing_type
def enumerate_all_2d_turn_models_based_on_df(combination):
"""
Lists all 2D deadlock free turn models in "deadlock_free_turns" in "Generated_Files"
folder!
---------------------
We have 256 turns in 2D Mesh NoC!
---------------------
:param combination: number of turns which should be checked for combination!
:return: None
"""
counter = 0
all_turns_file = open('Generated_Files/Turn_Model_Lists/all_2D_turn_models_'+str(combination)+'.txt', 'w')
turns_health_2d_network = {"N2W": False, "N2E": False, "S2W": False, "S2E": False,
"W2N": False, "W2S": False, "E2N": False, "E2S": False}
Config.ag.topology = '2DMesh'
Config.ag.x_size = 3
Config.ag.y_size = 3
Config.ag.z_size = 1
Config.RotingType = 'NonMinimalPath'
all_turns_file.write("#"+"\t\tDF/D\t"+'%25s' % "turns"+'%20s' % " "+"\t\t"+'%10s' % "c-metric" +
"\t\t"+'%10s' % "DoA"+"\t\t"+'%10s' % "DoAx"+"\n")
all_turns_file.write("--------------"*8+"\n")
ag = copy.deepcopy(AG_Functions.generate_ag())
number_of_pairs = len(ag.nodes())*(len(ag.nodes())-1)
turn_model_list = copy.deepcopy(PackageFile.FULL_TurnModel_2D)
deadlock_free_counter = 0
deadlock_counter = 0
# print "Number of Turns:", combination
for turns in itertools.combinations(turn_model_list, combination):
turns_health = copy.deepcopy(turns_health_2d_network)
for turn in turns:
turns_health[turn] = True
counter += 1
shmu = SystemHealthMonitoringUnit.SystemHealthMonitoringUnit()
shmu.setup_noc_shm(ag, turns_health, False)
noc_rg = copy.deepcopy(Routing.generate_noc_route_graph(ag, shmu, list(turns), False, False))
if check_deadlock_freeness(noc_rg):
connectivity_metric = reachability_metric(ag, noc_rg, False)
doa = degree_of_adaptiveness(ag, noc_rg, False)/float(number_of_pairs)
doa_ex = extended_degree_of_adaptiveness(ag, noc_rg, False)/float(number_of_pairs)
deadlock_free_counter += 1
# print counter, "\t \033[92mDF\033[0m \t", list(turns), "\t\t", connectivity_metric
all_turns_file.write(str(counter)+"\t\tDF\t"+'%51s' % str(list(turns)) +
"\t\t"+'%10s' % str(connectivity_metric) +
"\t\t"+'%10s' % str(round(doa, 2))+"\t\t"+'%10s' % str(round(doa_ex, 2))+"\n")
else:
deadlock_counter += 1
# print counter, "\t \033[31mDL\033[0m \t", list(turns), "\t\t----"
all_turns_file.write(str(counter)+"\t\tDL\t"+'%51s' % str(list(turns)) +
"\t\t-----"+"\t\t-----"+"\t\t-----"+"\n")
del shmu
del noc_rg
all_turns_file.write("---------------------------"+"\n")
all_turns_file.write("Number of turn models with deadlock: "+str(deadlock_counter)+"\n")
all_turns_file.write("Number of turn models without deadlock: "+str(deadlock_free_counter)+"\n")
all_turns_file.write("=========================================="+"\n")
all_turns_file.close()
return None
def evaluate_actual_odd_even_turn_model():
"""
evaluates the classic odd-even turn model in terms of DoA and DoA_ex
:return: None
"""
turns_health_2d_network = {"N2W": False, "N2E": False, "S2W": False, "S2E": False,
"W2N": False, "W2S": False, "E2N": False, "E2S": False}
Config.ag.topology = '2DMesh'
Config.ag.x_size = 3
Config.ag.y_size = 3
Config.ag.z_size = 1
Config.RotingType = 'MinimalPath'
ag = copy.deepcopy(AG_Functions.generate_ag())
number_of_pairs = len(ag.nodes())*(len(ag.nodes())-1)
turn_model_odd = ['E2N', 'E2S', 'W2N', 'W2S', 'S2E', 'N2E']
turn_model_even = ['E2N', 'E2S', 'S2W', 'S2E', 'N2W', 'N2E']
if not check_tm_domination(turn_model_odd, turn_model_even): # taking out the domination!
turns_health = copy.deepcopy(turns_health_2d_network)
shmu = SystemHealthMonitoringUnit.SystemHealthMonitoringUnit()
shmu.setup_noc_shm(ag, turns_health, False)
noc_rg = copy.deepcopy(Routing.generate_noc_route_graph(ag, shmu, [], False, False))
update_rg_odd_even(ag, turn_model_odd, turn_model_even, shmu, noc_rg)
draw_rg(noc_rg)
connectivity_metric = reachability_metric(ag, noc_rg, False)
print "connectivity_metric:", connectivity_metric
if check_deadlock_freeness(noc_rg):
print "Deadlock free!"
doa = degree_of_adaptiveness(ag, noc_rg, False)/float(number_of_pairs)
doa_ex = extended_degree_of_adaptiveness(ag, noc_rg, False)/float(number_of_pairs)
print "doa:", doa
print "doa_ex", doa_ex
return None
def evaluate_actual_odd_even_turn_model():
turns_health_2d_network = {
"N2W": False,
"N2E": False,
"S2W": False,
"S2E": False,
"W2N": False,
"W2S": False,
"E2N": False,
"E2S": False
}
Config.ag.topology = '2DMesh'
Config.ag.x_size = 3
Config.ag.y_size = 3
Config.ag.z_size = 1
Config.RotingType = 'MinimalPath'
ag = copy.deepcopy(AG_Functions.generate_ag())
number_of_pairs = len(ag.nodes()) * (len(ag.nodes()) - 1)
turn_model_odd = ['E2N', 'E2S', 'W2N', 'W2S', 'S2E', 'N2E']
turn_model_even = ['E2N', 'E2S', 'S2W', 'S2E', 'N2W', 'N2E']
if not check_tm_domination(turn_model_odd,
turn_model_even): # taking out the domination!
turns_health = copy.deepcopy(turns_health_2d_network)
shmu = SystemHealthMonitoringUnit.SystemHealthMonitoringUnit()
shmu.setup_noc_shm(ag, turns_health, False)
noc_rg = copy.deepcopy(
Routing.generate_noc_route_graph(ag, shmu, [], False, False))
for node in ag.nodes():
node_x, node_y, node_z = AG_Functions.return_node_location(node)
if node_x % 2 == 1:
for turn in turn_model_odd:
shmu.restore_broken_turn(node, turn, False)
from_port = str(node) + str(turn[0]) + "I"
to_port = str(node) + str(turn[2]) + "O"
Routing.update_noc_route_graph(noc_rg, from_port, to_port,
'ADD')
else:
for turn in turn_model_even:
shmu.restore_broken_turn(node, turn, False)
from_port = str(node) + str(turn[0]) + "I"
to_port = str(node) + str(turn[2]) + "O"
Routing.update_noc_route_graph(noc_rg, from_port, to_port,
'ADD')
draw_rg(noc_rg)
connectivity_metric = reachability_metric(ag, noc_rg, False)
print("connectivity_metric:", connectivity_metric)
if check_deadlock_freeness(noc_rg):
print("Deadlock free!")
doa = degree_of_adaptiveness(ag, noc_rg,
False) / float(number_of_pairs)
doa_ex = extended_degree_of_adaptiveness(
ag, noc_rg, False) / float(number_of_pairs)
print("doa:", doa)
print("doa_ex", doa_ex)
sys.stdout.flush()
def enumerate_all_3d_turn_models_based_on_df(combination):
"""
Lists all 3D deadlock free turn models in "deadlock_free_turns" in "Generated_Files"
folder!
---------------------
We have 16,777,216 turns in 3D Mesh NoC! if it takes one second to calculate
deadlock freeness Then it takes almost 194.2 Days (almost 6.4 Months) to
check all of them. that is the reason we need to make this parallel!
---------------------
:param combination: number of turns which should be checked for combination!
:return: None
"""
counter = 0
all_turns_file = open('Generated_Files/Turn_Model_Lists/all_3D_turn_models_'+str(combination)+'.txt', 'w')
turns_health_3d_network = {"N2W": False, "N2E": False, "S2W": False, "S2E": False,
"W2N": False, "W2S": False, "E2N": False, "E2S": False,
"N2U": False, "N2D": False, "S2U": False, "S2D": False,
"W2U": False, "W2D": False, "E2U": False, "E2D": False,
"U2W": False, "U2E": False, "U2N": False, "U2S": False,
"D2W": False, "D2E": False, "D2N": False, "D2S": False}
Config.ag.topology = '3DMesh'
Config.ag.x_size = 3
Config.ag.y_size = 3
Config.ag.z_size = 3
ag = copy.deepcopy(AG_Functions.generate_ag())
turn_model_list = copy.deepcopy(PackageFile.FULL_TurnModel_3D)
deadlock_free_counter = 0
deadlock_counter = 0
# print "Number of Turns:", combination
for turns in itertools.combinations(turn_model_list, combination):
turns_health = copy.deepcopy(turns_health_3d_network)
for turn in turns:
turns_health[turn] = True
counter += 1
shmu = SystemHealthMonitoringUnit.SystemHealthMonitoringUnit()
shmu.setup_noc_shm(ag, turns_health, False)
noc_rg = copy.deepcopy(Routing.generate_noc_route_graph(ag, shmu, list(turns), False, False))
if check_deadlock_freeness(noc_rg):
connectivity_metric = reachability_metric(ag, noc_rg, False)
doa = degree_of_adaptiveness(ag, noc_rg, False)
deadlock_free_counter += 1
# print counter, "\t \033[92mDF\033[0m \t", list(turns), "\t\t", connectivity_metric
all_turns_file.write(str(counter)+"\t\tDF\t"+str(list(turns))+"\t\t"+str(connectivity_metric) +
"\t\t"+str(doa)+"\n")
else:
deadlock_counter += 1
# print counter, "\t \033[31mDL\033[0m \t", list(turns), "\t\t----"
all_turns_file.write(str(counter)+"\t\tDL\t"+str(list(turns))+"\t\t-----""\n")
del shmu
del noc_rg
all_turns_file.write("---------------------------"+"\n")
all_turns_file.write("Number of turn models with deadlock: "+str(deadlock_counter)+"\n")
all_turns_file.write("Number of turn models without deadlock: "+str(deadlock_free_counter)+"\n")
all_turns_file.write("=========================================="+"\n")
all_turns_file.close()
return None
def evaluate_actual_odd_even_turn_model():
"""
evaluates the classic odd-even turn model in terms of DoA and DoA_ex
:return: None
"""
turns_health_2d_network = {
"N2W": False,
"N2E": False,
"S2W": False,
"S2E": False,
"W2N": False,
"W2S": False,
"E2N": False,
"E2S": False
}
Config.ag.topology = '2DMesh'
Config.ag.x_size = 3
Config.ag.y_size = 3
Config.ag.z_size = 1
Config.RotingType = 'MinimalPath'
ag = copy.deepcopy(AG_Functions.generate_ag())
number_of_pairs = len(ag.nodes()) * (len(ag.nodes()) - 1)
turn_model_odd = ['E2N', 'E2S', 'W2N', 'W2S', 'S2E', 'N2E']
turn_model_even = ['E2N', 'E2S', 'S2W', 'S2E', 'N2W', 'N2E']
if not check_tm_domination(turn_model_odd,
turn_model_even): # taking out the domination!
turns_health = copy.deepcopy(turns_health_2d_network)
shmu = SystemHealthMonitoringUnit.SystemHealthMonitoringUnit()
shmu.setup_noc_shm(ag, turns_health, False)
noc_rg = copy.deepcopy(
Routing.generate_noc_route_graph(ag, shmu, [], False, False))
update_rg_odd_even(ag, turn_model_odd, turn_model_even, shmu, noc_rg)
draw_rg(noc_rg)
connectivity_metric = reachability_metric(ag, noc_rg, False)
print("connectivity_metric:", connectivity_metric)
if check_deadlock_freeness(noc_rg):
print("Deadlock free!")
doa = degree_of_adaptiveness(ag, noc_rg,
False) / float(number_of_pairs)
doa_ex = extended_degree_of_adaptiveness(
ag, noc_rg, False) / float(number_of_pairs)
print("doa:", doa)
print("doa_ex", doa_ex)
return None
def test_routing_functions(self):
initial_config_ag = deepcopy(Config.ag)
initial_turn_model = Config.UsedTurnModel
initial_routing_type = Config.RotingType
Config.ag.type = "Generic"
Config.ag.topology = "2DMesh"
Config.ag.x_size = 3
Config.ag.y_size = 3
Config.ag.z_size = 1
for turn_model in PackageFile.routing_alg_list_2d:
Config.UsedTurnModel = deepcopy(turn_model)
Config.TurnsHealth = deepcopy(Config.setup_turns_health())
ag_4_test = deepcopy(generate_ag(logging=None))
shmu_4_test = SystemHealthMonitoringUnit.SystemHealthMonitoringUnit(
)
shmu_4_test.setup_noc_shm(ag_4_test, Config.TurnsHealth, False)
noc_rg = generate_noc_route_graph(ag_4_test, shmu_4_test,
turn_model, False, False)
self.assertEqual(check_deadlock_freeness(noc_rg), True)
if turn_model in [
PackageFile.XY_TurnModel, PackageFile.YX_TurnModel
]:
if turn_model == PackageFile.XY_TurnModel:
self.assertEqual(return_turn_model_name(turn_model), '0')
else:
self.assertEqual(return_turn_model_name(turn_model), '13')
self.assertEqual(
degree_of_adaptiveness(ag_4_test, noc_rg, False) / 72, 1)
self.assertEqual(
extended_degree_of_adaptiveness(ag_4_test, noc_rg, False) /
72, 1)
del ag_4_test
del shmu_4_test
Config.ag.type = "Generic"
Config.ag.topology = "3DMesh"
Config.ag.x_size = 3
Config.ag.y_size = 3
Config.ag.z_size = 3
Config.RotingType = "NonMinimalPath"
for turn_model in PackageFile.routing_alg_list_3d:
Config.UsedTurnModel = deepcopy(turn_model)
Config.TurnsHealth = deepcopy(Config.setup_turns_health())
ag_4_test = deepcopy(generate_ag(logging=None))
shmu_4_test = SystemHealthMonitoringUnit.SystemHealthMonitoringUnit(
)
shmu_4_test.setup_noc_shm(ag_4_test, Config.TurnsHealth, False)
noc_rg = generate_noc_route_graph(ag_4_test, shmu_4_test,
turn_model, False, False)
self.assertEqual(check_deadlock_freeness(noc_rg), True)
if turn_model == PackageFile.XYZ_TurnModel:
self.assertEqual(return_turn_model_name(turn_model), "3d_XYZ")
self.assertEqual(
degree_of_adaptiveness(ag_4_test, noc_rg, False) / 702, 1)
self.assertEqual(
extended_degree_of_adaptiveness(ag_4_test, noc_rg, False) /
702, 1)
if turn_model == PackageFile.NegativeFirst3D_TurnModel:
self.assertEqual(return_turn_model_name(turn_model),
"3d_NegFirst")
del ag_4_test
del shmu_4_test
del noc_rg
Config.ag = deepcopy(initial_config_ag)
Config.UsedTurnModel = initial_turn_model
Config.TurnsHealth = deepcopy(Config.setup_turns_health())
Config.RotingType = initial_routing_type
def enumerate_all_2d_turn_models_based_on_df(combination):
"""
Lists all 2D deadlock free turn models in "deadlock_free_turns" in "Generated_Files"
folder!
---------------------
We have 256 turns in 2D Mesh NoC!
---------------------
:param combination: number of turns which should be checked for combination!
:return: None
"""
counter = 0
all_turns_file = open(
'Generated_Files/Turn_Model_Lists/all_2D_turn_models_' +
str(combination) + '.txt', 'w')
turns_health_2d_network = {
"N2W": False,
"N2E": False,
"S2W": False,
"S2E": False,
"W2N": False,
"W2S": False,
"E2N": False,
"E2S": False
}
Config.ag.topology = '2DMesh'
Config.ag.x_size = 3
Config.ag.y_size = 3
Config.ag.z_size = 1
Config.RotingType = 'NonMinimalPath'
all_turns_file.write("#" + "\t\tDF/D\t" + '%25s' % "turns" + '%20s' % " " +
"\t\t" + '%10s' % "c-metric" + "\t\t" +
'%10s' % "DoA" + "\t\t" + '%10s' % "DoAx" + "\n")
all_turns_file.write("--------------" * 8 + "\n")
ag = copy.deepcopy(AG_Functions.generate_ag())
number_of_pairs = len(ag.nodes()) * (len(ag.nodes()) - 1)
turn_model_list = copy.deepcopy(PackageFile.FULL_TurnModel_2D)
deadlock_free_counter = 0
deadlock_counter = 0
# print("Number of Turns:", combination)
for turns in itertools.combinations(turn_model_list, combination):
turns_health = copy.deepcopy(turns_health_2d_network)
for turn in turns:
turns_health[turn] = True
counter += 1
shmu = SystemHealthMonitoringUnit.SystemHealthMonitoringUnit()
shmu.setup_noc_shm(ag, turns_health, False)
noc_rg = copy.deepcopy(
Routing.generate_noc_route_graph(ag, shmu, list(turns), False,
False))
if check_deadlock_freeness(noc_rg):
connectivity_metric = reachability_metric(ag, noc_rg, False)
doa = degree_of_adaptiveness(ag, noc_rg,
False) / float(number_of_pairs)
doa_ex = extended_degree_of_adaptiveness(
ag, noc_rg, False) / float(number_of_pairs)
deadlock_free_counter += 1
all_turns_file.write(
str(counter) + "\t\tDF\t" + '%51s' % str(list(turns)) +
"\t\t" + '%10s' % str(connectivity_metric) + "\t\t" +
'%10s' % str(round(doa, 2)) + "\t\t" +
'%10s' % str(round(doa_ex, 2)) + "\n")
else:
deadlock_counter += 1
all_turns_file.write(
str(counter) + "\t\tDL\t" + '%51s' % str(list(turns)) +
"\t\t-----" + "\t\t-----" + "\t\t-----" + "\n")
del shmu
del noc_rg
all_turns_file.write("---------------------------" + "\n")
all_turns_file.write("Number of turn models with deadlock: " +
str(deadlock_counter) + "\n")
all_turns_file.write("Number of turn models without deadlock: " +
str(deadlock_free_counter) + "\n")
all_turns_file.write("==========================================" + "\n")
all_turns_file.close()
return None
def enumerate_all_3d_turn_models_based_on_df(combination):
"""
Lists all 3D deadlock free turn models in "deadlock_free_turns" in "Generated_Files"
folder!
---------------------
We have 16,777,216 turns in 3D Mesh NoC! if it takes one second to calculate
deadlock freeness Then it takes almost 194.2 Days (almost 6.4 Months) to
check all of them. that is the reason we need to make this parallel!
---------------------
:param combination: number of turns which should be checked for combination!
:return: None
"""
counter = 0
all_turns_file = open(
'Generated_Files/Turn_Model_Lists/all_3D_turn_models_' +
str(combination) + '.txt', 'w')
turns_health_3d_network = {
"N2W": False,
"N2E": False,
"S2W": False,
"S2E": False,
"W2N": False,
"W2S": False,
"E2N": False,
"E2S": False,
"N2U": False,
"N2D": False,
"S2U": False,
"S2D": False,
"W2U": False,
"W2D": False,
"E2U": False,
"E2D": False,
"U2W": False,
"U2E": False,
"U2N": False,
"U2S": False,
"D2W": False,
"D2E": False,
"D2N": False,
"D2S": False
}
Config.ag.topology = '3DMesh'
Config.ag.x_size = 3
Config.ag.y_size = 3
Config.ag.z_size = 3
ag = copy.deepcopy(AG_Functions.generate_ag())
turn_model_list = copy.deepcopy(PackageFile.FULL_TurnModel_3D)
deadlock_free_counter = 0
deadlock_counter = 0
# print("Number of Turns:", combination)
for turns in itertools.combinations(turn_model_list, combination):
turns_health = copy.deepcopy(turns_health_3d_network)
for turn in turns:
turns_health[turn] = True
counter += 1
shmu = SystemHealthMonitoringUnit.SystemHealthMonitoringUnit()
shmu.setup_noc_shm(ag, turns_health, False)
noc_rg = copy.deepcopy(
Routing.generate_noc_route_graph(ag, shmu, list(turns), False,
False))
if check_deadlock_freeness(noc_rg):
connectivity_metric = reachability_metric(ag, noc_rg, False)
doa = degree_of_adaptiveness(ag, noc_rg, False)
deadlock_free_counter += 1
all_turns_file.write(
str(counter) + "\t\tDF\t" + str(list(turns)) + "\t\t" +
str(connectivity_metric) + "\t\t" + str(doa) + "\n")
else:
deadlock_counter += 1
all_turns_file.write(
str(counter) + "\t\tDL\t" + str(list(turns)) + "\t\t-----"
"\n")
del shmu
del noc_rg
all_turns_file.write("---------------------------" + "\n")
all_turns_file.write("Number of turn models with deadlock: " +
str(deadlock_counter) + "\n")
all_turns_file.write("Number of turn models without deadlock: " +
str(deadlock_free_counter) + "\n")
all_turns_file.write("==========================================" + "\n")
all_turns_file.close()
return None
def odd_even_fault_tolerance_metric(network_size, routing_type):
turns_health_2d_network = {"N2W": False, "N2E": False, "S2W": False, "S2E": False,
"W2N": False, "W2S": False, "E2N": False, "E2S": False}
Config.ag.topology = '2DMesh'
Config.ag.x_size = network_size
Config.ag.y_size = network_size
Config.ag.z_size = 1
Config.RotingType = routing_type
all_odd_evens_file = open('Generated_Files/Turn_Model_Eval/'+str(network_size)+"x"+str(network_size)+
'_OE_metric_'+Config.RotingType+'.txt', 'w')
all_odd_evens_file.write("TOPOLOGY::"+str(Config.ag.topology)+"\n")
all_odd_evens_file.write("X SIZE:"+str(Config.ag.x_size)+"\n")
all_odd_evens_file.write("Y SIZE:"+str(Config.ag.y_size)+"\n")
all_odd_evens_file.write("Z SIZE:"+str(Config.ag.z_size)+"\n")
ag = copy.deepcopy(AG_Functions.generate_ag())
shmu = SystemHealthMonitoringUnit.SystemHealthMonitoringUnit()
turns_health = copy.deepcopy(turns_health_2d_network)
shmu.setup_noc_shm(ag, turns_health, False)
noc_rg = copy.deepcopy(Routing.generate_noc_route_graph(ag, shmu, [], False, False))
classes_of_doa_ratio = []
turn_model_class_dict = {}
tm_counter = 0
for turn_model in all_odd_even_list:
sys.stdout.write("\rnumber of processed turn models: %i " % tm_counter)
sys.stdout.flush()
tm_counter += 1
link_dict = {}
turn_model_index = all_odd_even_list.index(turn_model)
turn_model_odd = turn_model[0]
turn_model_even = turn_model[1]
update_rg_odd_even(ag, turn_model_odd, turn_model_even, shmu, noc_rg)
number_of_pairs = len(ag.nodes())*(len(ag.nodes())-1)
all_paths_in_graph = []
for source_node in ag.nodes():
for destination_node in ag.nodes():
if source_node != destination_node:
if is_destination_reachable_from_source(noc_rg, source_node, destination_node):
if Config.RotingType == 'MinimalPath':
shortest_paths = list(all_shortest_paths(noc_rg, str(source_node)+str('L')+str('I'),
str(destination_node)+str('L')+str('O')))
paths = []
for path in shortest_paths:
minimal_hop_count = manhattan_distance(source_node, destination_node)
if (len(path)/2)-1 <= minimal_hop_count:
paths.append(path)
all_paths_in_graph.append(path)
else:
paths = list(all_simple_paths(noc_rg, str(source_node)+str('L')+str('I'),
str(destination_node)+str('L')+str('O')))
all_paths_in_graph += paths
link_dict = find_similarity_in_paths(link_dict, paths)
metric = 0
for item in link_dict.keys():
metric += link_dict[item]
if Config.RotingType == 'MinimalPath':
doa = degree_of_adaptiveness(ag, noc_rg, False)/float(number_of_pairs)
metric = 1/(float(metric)/len(ag.edges()))
metric = float("{:3.3f}".format(metric))
else:
doa_ex = extended_degree_of_adaptiveness(ag, noc_rg, False)/float(number_of_pairs)
metric = 1/(float(metric)/len(ag.edges()))
metric = float("{:3.3f}".format(metric))
if metric not in classes_of_doa_ratio:
classes_of_doa_ratio.append(metric)
if metric in turn_model_class_dict.keys():
turn_model_class_dict[metric].append(turn_model_index)
else:
turn_model_class_dict[metric] = [turn_model_index]
# return SHMU and RG back to default
clean_rg_from_odd_even(ag, turn_model_odd, turn_model_even, shmu, noc_rg)
all_odd_evens_file.write("classes of metric"+str(classes_of_doa_ratio)+"\n")
all_odd_evens_file.write("----------"*3+"\n")
all_odd_evens_file.write("turn models of class"+"\n")
for item in sorted(turn_model_class_dict.keys()):
all_odd_evens_file.write(str(item)+" "+str(turn_model_class_dict[item])+"\n")
all_odd_evens_file.write("----------"*3+"\n")
all_odd_evens_file.write("distribution of turn models"+"\n")
for item in sorted(turn_model_class_dict.keys()):
temp_list = []
for tm in turn_model_class_dict[item]:
turn_model = all_odd_even_list[tm]
number_of_turns = len(turn_model[0])+len(turn_model[1])
temp_list.append(number_of_turns)
all_odd_evens_file.write(str(item)+" "+str(temp_list.count(8))+" "+str(temp_list.count(9))+" " +
str(temp_list.count(10))+" "+str(temp_list.count(11))+" " +
str(temp_list.count(12))+"\n")
all_odd_evens_file.close()
return turn_model_class_dict
def evaluate_doa_for_all_odd_even_turn_model_list(network_size):
all_odd_evens_file = open('Generated_Files/Turn_Model_Lists/all_odd_evens_doa.txt', 'w')
turns_health_2d_network = {"N2W": False, "N2E": False, "S2W": False, "S2E": False,
"W2N": False, "W2S": False, "E2N": False, "E2S": False}
Config.ag.topology = '2DMesh'
Config.ag.x_size = network_size
Config.ag.y_size = network_size
Config.ag.z_size = 1
ag = copy.deepcopy(AG_Functions.generate_ag())
number_of_pairs = len(ag.nodes())*(len(ag.nodes())-1)
turn_model_list = []
for length in range(0, len(turns_health_2d_network.keys())+1):
for item in list(itertools.combinations(turns_health_2d_network.keys(), length)):
if len(item) > 0:
turn_model_list.append(list(item))
classes_of_doa = {}
classes_of_doax = {}
tm_counter = 0
all_odd_evens_file.write(" # | "+'%51s' % " "+" \t|")
all_odd_evens_file.write(" DoA | DoAx | \tC-metric\n")
all_odd_evens_file.write("-------|--------------------------------------------" +
"----------------------------|--------|--------|-------------"+"\n")
for turn_model in all_odd_even_list:
turn_model_odd = turn_model[0]
turn_model_even = turn_model[1]
turns_health = copy.deepcopy(turns_health_2d_network)
shmu = SystemHealthMonitoringUnit.SystemHealthMonitoringUnit()
shmu.setup_noc_shm(ag, turns_health, False)
noc_rg = copy.deepcopy(Routing.generate_noc_route_graph(ag, shmu, [], False, False))
update_rg_odd_even(ag, turn_model_odd, turn_model_even, shmu, noc_rg)
doa = degree_of_adaptiveness(ag, noc_rg, False)/float(number_of_pairs)
doa_ex = extended_degree_of_adaptiveness(ag, noc_rg, False)/float(number_of_pairs)
if round(doa, 2) not in classes_of_doa.keys():
classes_of_doa[round(doa, 2)] = [tm_counter]
else:
classes_of_doa[round(doa, 2)].append(tm_counter)
if round(doa_ex, 2) not in classes_of_doax.keys():
classes_of_doax[round(doa_ex, 2)] = [tm_counter]
else:
classes_of_doax[round(doa_ex, 2)].append(tm_counter)
all_odd_evens_file.write('%5s' % str(tm_counter)+" | even turn model:"+'%53s' % str(turn_model_even)+"\t|")
all_odd_evens_file.write(" | |\n")
all_odd_evens_file.write(" | odd turn model: "+'%53s' % str(turn_model_odd)+" \t|")
all_odd_evens_file.write('%8s' % str(round(doa, 2)) + "|" + '%8s' % str(round(doa_ex, 2)) +
"|\n") # +'%8s' % str(round(connectivity_metric,2))+"\n")
all_odd_evens_file.write("-------|--------------------------------------------" +
"----------------------------|--------|--------|-------------"+"\n")
tm_counter += 1
sys.stdout.write("\rchecked TM: %i " % tm_counter)
sys.stdout.flush()
all_odd_evens_file.write("----------"*3+"\n")
all_odd_evens_file.write("distribution of turn models"+"\n")
for item in sorted(classes_of_doa.keys()):
temp_list = []
for tm in classes_of_doa[item]:
turn_model = all_odd_even_list[tm]
number_of_turns = len(turn_model[0])+len(turn_model[1])
temp_list.append(number_of_turns)
all_odd_evens_file.write(str(item)+" "+str(temp_list.count(8))+" "+str(temp_list.count(9))+" " +
str(temp_list.count(10))+" "+str(temp_list.count(11))+" " +
str(temp_list.count(12))+"\n")
all_odd_evens_file.write("----------"*3+"\n")
all_odd_evens_file.write("distribution of turn models"+"\n")
for item in sorted(classes_of_doax.keys()):
temp_list = []
for tm in classes_of_doax[item]:
turn_model = all_odd_even_list[tm]
number_of_turns = len(turn_model[0])+len(turn_model[1])
temp_list.append(number_of_turns)
all_odd_evens_file.write(str(item)+" "+str(temp_list.count(8))+" "+str(temp_list.count(9))+" " +
str(temp_list.count(10))+" "+str(temp_list.count(11))+" " +
str(temp_list.count(12))+"\n")
all_odd_evens_file.close()
return classes_of_doa, classes_of_doax
def odd_even_fault_tolerance_metric(network_size, routing_type):
turns_health_2d_network = {
"N2W": False,
"N2E": False,
"S2W": False,
"S2E": False,
"W2N": False,
"W2S": False,
"E2N": False,
"E2S": False
}
Config.ag.topology = '2DMesh'
Config.ag.x_size = network_size
Config.ag.y_size = network_size
Config.ag.z_size = 1
Config.RotingType = routing_type
all_odd_evens_file = open(
'Generated_Files/Turn_Model_Eval/' + str(network_size) + "x" +
str(network_size) + '_OE_metric_' + Config.RotingType + '.txt', 'w')
all_odd_evens_file.write("TOPOLOGY::" + str(Config.ag.topology) + "\n")
all_odd_evens_file.write("X SIZE:" + str(Config.ag.x_size) + "\n")
all_odd_evens_file.write("Y SIZE:" + str(Config.ag.y_size) + "\n")
all_odd_evens_file.write("Z SIZE:" + str(Config.ag.z_size) + "\n")
ag = copy.deepcopy(AG_Functions.generate_ag())
shmu = SystemHealthMonitoringUnit.SystemHealthMonitoringUnit()
turns_health = copy.deepcopy(turns_health_2d_network)
shmu.setup_noc_shm(ag, turns_health, False)
noc_rg = copy.deepcopy(
Routing.generate_noc_route_graph(ag, shmu, [], False, False))
classes_of_doa_ratio = []
turn_model_class_dict = {}
tm_counter = 0
"""
selected_turn_models = []
for tm in all_odd_even_list:
if len(tm[0])+len(tm[1]) == 11 or len(tm[0])+len(tm[1]) == 12:
selected_turn_models.append(all_odd_even_list.index(tm))
"""
#selected_turn_models = [677, 678, 697, 699, 717, 718, 737, 739, 757, 759, 778, 779, 797, 799, 818, 819,
# 679, 698, 719, 738, 758, 777, 798, 817]
for turn_model in all_odd_even_list:
#for item in selected_turn_models:
# print item
# turn_model = all_odd_even_list[item]
sys.stdout.write("\rnumber of processed turn models: %i " % tm_counter)
sys.stdout.flush()
tm_counter += 1
link_dict = {}
turn_model_index = all_odd_even_list.index(turn_model)
turn_model_odd = turn_model[0]
turn_model_even = turn_model[1]
for node in ag.nodes():
node_x, node_y, node_z = AG_Functions.return_node_location(node)
if node_x % 2 == 1:
for turn in turn_model_odd:
shmu.restore_broken_turn(node, turn, False)
from_port = str(node) + str(turn[0]) + "I"
to_port = str(node) + str(turn[2]) + "O"
Routing.update_noc_route_graph(noc_rg, from_port, to_port,
'ADD')
else:
for turn in turn_model_even:
shmu.restore_broken_turn(node, turn, False)
from_port = str(node) + str(turn[0]) + "I"
to_port = str(node) + str(turn[2]) + "O"
Routing.update_noc_route_graph(noc_rg, from_port, to_port,
'ADD')
number_of_pairs = len(ag.nodes()) * (len(ag.nodes()) - 1)
all_paths_in_graph = []
for source_node in ag.nodes():
for destination_node in ag.nodes():
if source_node != destination_node:
if is_destination_reachable_from_source(
noc_rg, source_node, destination_node):
# print source_node, "--->", destination_node
if Config.RotingType == 'MinimalPath':
shortest_paths = list(
all_shortest_paths(
noc_rg,
str(source_node) + str('L') + str('I'),
str(destination_node) + str('L') +
str('O')))
paths = []
for path in shortest_paths:
minimal_hop_count = manhattan_distance(
source_node, destination_node)
if (len(path) / 2) - 1 <= minimal_hop_count:
paths.append(path)
all_paths_in_graph.append(path)
else:
paths = list(
all_simple_paths(
noc_rg,
str(source_node) + str('L') + str('I'),
str(destination_node) + str('L') +
str('O')))
all_paths_in_graph += paths
link_dict = find_similarity_in_paths(link_dict, paths)
metric = 0
for item in link_dict.keys():
metric += link_dict[item]
if Config.RotingType == 'MinimalPath':
doa = degree_of_adaptiveness(ag, noc_rg,
False) / float(number_of_pairs)
#metric = doa/(float(metric)/len(ag.edges()))
metric = 1 / (float(metric) / len(ag.edges()))
metric = float("{:3.3f}".format(metric))
# print "Turn Model ", '%5s' %turn_model_index, "\tdoa:", "{:3.3f}".format(doa),
# "\tmetric:", "{:3.3f}".format(metric)
else:
doa_ex = extended_degree_of_adaptiveness(
ag, noc_rg, False) / float(number_of_pairs)
#metric = doa_ex/(float(metric)/len(ag.edges()))
metric = 1 / (float(metric) / len(ag.edges()))
metric = float("{:3.3f}".format(metric))
# print "Turn Model ", '%5s' %turn_model_index, "\tdoa:", "{:3.3f}".format(doa_ex),
# "\tmetric:", "{:3.3f}".format(metric)
if metric not in classes_of_doa_ratio:
classes_of_doa_ratio.append(metric)
if metric in turn_model_class_dict.keys():
turn_model_class_dict[metric].append(turn_model_index)
else:
turn_model_class_dict[metric] = [turn_model_index]
# return SHMU and RG back to default
for node in ag.nodes():
node_x, node_y, node_z = AG_Functions.return_node_location(node)
if node_x % 2 == 1:
for turn in turn_model_odd:
shmu.break_turn(node, turn, False)
from_port = str(node) + str(turn[0]) + "I"
to_port = str(node) + str(turn[2]) + "O"
Routing.update_noc_route_graph(noc_rg, from_port, to_port,
'REMOVE')
else:
for turn in turn_model_even:
shmu.break_turn(node, turn, False)
from_port = str(node) + str(turn[0]) + "I"
to_port = str(node) + str(turn[2]) + "O"
Routing.update_noc_route_graph(noc_rg, from_port, to_port,
'REMOVE')
all_odd_evens_file.write("classes of metric" + str(classes_of_doa_ratio) +
"\n")
all_odd_evens_file.write("----------" * 3 + "\n")
all_odd_evens_file.write("turn models of class" + "\n")
# print "classes of metric", classes_of_doa_ratio
for item in sorted(turn_model_class_dict.keys()):
# print item, turn_model_class_dict[item]
all_odd_evens_file.write(
str(item) + " " + str(turn_model_class_dict[item]) + "\n")
all_odd_evens_file.write("----------" * 3 + "\n")
all_odd_evens_file.write("distribution of turn models" + "\n")
for item in sorted(turn_model_class_dict.keys()):
temp_list = []
for tm in turn_model_class_dict[item]:
turn_model = all_odd_even_list[tm]
number_of_turns = len(turn_model[0]) + len(turn_model[1])
temp_list.append(number_of_turns)
# print item, temp_list.count(8), temp_list.count(9), temp_list.count(10),
# temp_list.count(11), temp_list.count(12)
all_odd_evens_file.write(
str(item) + " " + str(temp_list.count(8)) + " " +
str(temp_list.count(9)) + " " + str(temp_list.count(10)) + " " +
str(temp_list.count(11)) + " " + str(temp_list.count(12)) + "\n")
all_odd_evens_file.close()
return turn_model_class_dict
def evaluate_doa_for_all_odd_even_turn_model_list(network_size):
all_odd_evens_file = open(
'Generated_Files/Turn_Model_Lists/all_odd_evens_doa.txt', 'w')
turns_health_2d_network = {
"N2W": False,
"N2E": False,
"S2W": False,
"S2E": False,
"W2N": False,
"W2S": False,
"E2N": False,
"E2S": False
}
Config.ag.topology = '2DMesh'
Config.ag.x_size = network_size
Config.ag.y_size = network_size
Config.ag.z_size = 1
ag = copy.deepcopy(AG_Functions.generate_ag())
number_of_pairs = len(ag.nodes()) * (len(ag.nodes()) - 1)
turn_model_list = []
for length in range(0, len(turns_health_2d_network.keys()) + 1):
for item in list(
itertools.combinations(turns_health_2d_network.keys(),
length)):
if len(item) > 0:
turn_model_list.append(list(item))
classes_of_doa = {}
classes_of_doax = {}
tm_counter = 0
all_odd_evens_file.write(" # | " + '%51s' % " " +
" \t|")
all_odd_evens_file.write(" DoA | DoAx | \tC-metric\n")
all_odd_evens_file.write(
"-------|--------------------------------------------" +
"----------------------------|--------|--------|-------------" + "\n")
for turn_model in all_odd_even_list:
turn_model_odd = turn_model[0]
turn_model_even = turn_model[1]
turns_health = copy.deepcopy(turns_health_2d_network)
shmu = SystemHealthMonitoringUnit.SystemHealthMonitoringUnit()
shmu.setup_noc_shm(ag, turns_health, False)
noc_rg = copy.deepcopy(
Routing.generate_noc_route_graph(ag, shmu, [], False, False))
for node in ag.nodes():
node_x, node_y, node_z = AG_Functions.return_node_location(node)
if node_x % 2 == 1:
for turn in turn_model_odd:
shmu.restore_broken_turn(node, turn, False)
from_port = str(node) + str(turn[0]) + "I"
to_port = str(node) + str(turn[2]) + "O"
Routing.update_noc_route_graph(noc_rg, from_port, to_port,
'ADD')
else:
for turn in turn_model_even:
shmu.restore_broken_turn(node, turn, False)
from_port = str(node) + str(turn[0]) + "I"
to_port = str(node) + str(turn[2]) + "O"
Routing.update_noc_route_graph(noc_rg, from_port, to_port,
'ADD')
doa = degree_of_adaptiveness(ag, noc_rg,
False) / float(number_of_pairs)
doa_ex = extended_degree_of_adaptiveness(
ag, noc_rg, False) / float(number_of_pairs)
if round(doa, 2) not in classes_of_doa.keys():
classes_of_doa[round(doa, 2)] = [tm_counter]
else:
classes_of_doa[round(doa, 2)].append(tm_counter)
if round(doa_ex, 2) not in classes_of_doax.keys():
classes_of_doax[round(doa_ex, 2)] = [tm_counter]
else:
classes_of_doax[round(doa_ex, 2)].append(tm_counter)
all_odd_evens_file.write('%5s' % str(tm_counter) +
" | even turn model:" +
'%53s' % str(turn_model_even) + "\t|")
all_odd_evens_file.write(" | |\n")
all_odd_evens_file.write(" | odd turn model: " +
'%53s' % str(turn_model_odd) + " \t|")
all_odd_evens_file.write(
'%8s' % str(round(doa, 2)) + "|" + '%8s' % str(round(doa_ex, 2)) +
"|\n") # +'%8s' % str(round(connectivity_metric,2))+"\n")
all_odd_evens_file.write(
"-------|--------------------------------------------" +
"----------------------------|--------|--------|-------------" +
"\n")
tm_counter += 1
sys.stdout.write("\rchecked TM: %i " % tm_counter)
sys.stdout.flush()
# print
# print "----------------------------------------"
# print "classes of DOA:", sorted(classes_of_doa.keys())
#for item in sorted(classes_of_doa.keys()):
# print item, sorted(classes_of_doa[item])
all_odd_evens_file.write("----------" * 3 + "\n")
all_odd_evens_file.write("distribution of turn models" + "\n")
for item in sorted(classes_of_doa.keys()):
temp_list = []
for tm in classes_of_doa[item]:
turn_model = all_odd_even_list[tm]
number_of_turns = len(turn_model[0]) + len(turn_model[1])
temp_list.append(number_of_turns)
# print item, temp_list.count(8), temp_list.count(9), temp_list.count(10),
# temp_list.count(11), temp_list.count(12)
all_odd_evens_file.write(
str(item) + " " + str(temp_list.count(8)) + " " +
str(temp_list.count(9)) + " " + str(temp_list.count(10)) + " " +
str(temp_list.count(11)) + " " + str(temp_list.count(12)) + "\n")
# print "------------------------------"
# print "classes of DOA_ex:", sorted(classes_of_doax.keys())
# for item in sorted(classes_of_doax.keys()):
# print item, sorted(classes_of_doax[item])
all_odd_evens_file.write("----------" * 3 + "\n")
all_odd_evens_file.write("distribution of turn models" + "\n")
for item in sorted(classes_of_doax.keys()):
temp_list = []
for tm in classes_of_doax[item]:
turn_model = all_odd_even_list[tm]
number_of_turns = len(turn_model[0]) + len(turn_model[1])
temp_list.append(number_of_turns)
# print item, temp_list.count(8), temp_list.count(9), temp_list.count(10),
# temp_list.count(11), temp_list.count(12)
all_odd_evens_file.write(
str(item) + " " + str(temp_list.count(8)) + " " +
str(temp_list.count(9)) + " " + str(temp_list.count(10)) + " " +
str(temp_list.count(11)) + " " + str(temp_list.count(12)) + "\n")
all_odd_evens_file.close()
return classes_of_doa, classes_of_doax
def odd_even_fault_tolerance_metric(network_size, routing_type):
turns_health_2d_network = {"N2W": False, "N2E": False, "S2W": False, "S2E": False,
"W2N": False, "W2S": False, "E2N": False, "E2S": False}
Config.ag.topology = '2DMesh'
Config.ag.x_size = network_size
Config.ag.y_size = network_size
Config.ag.z_size = 1
Config.RotingType = routing_type
all_odd_evens_file = open('Generated_Files/Turn_Model_Eval/'+str(network_size)+"x"+str(network_size)+
'_OE_metric_'+Config.RotingType+'.txt', 'w')
all_odd_evens_file.write("TOPOLOGY::"+str(Config.ag.topology)+"\n")
all_odd_evens_file.write("X SIZE:"+str(Config.ag.x_size)+"\n")
all_odd_evens_file.write("Y SIZE:"+str(Config.ag.y_size)+"\n")
all_odd_evens_file.write("Z SIZE:"+str(Config.ag.z_size)+"\n")
ag = copy.deepcopy(AG_Functions.generate_ag())
shmu = SystemHealthMonitoringUnit.SystemHealthMonitoringUnit()
turns_health = copy.deepcopy(turns_health_2d_network)
shmu.setup_noc_shm(ag, turns_health, False)
noc_rg = copy.deepcopy(Routing.generate_noc_route_graph(ag, shmu, [], False, False))
classes_of_doa_ratio = []
turn_model_class_dict = {}
tm_counter = 0
"""
selected_turn_models = []
for tm in all_odd_even_list:
if len(tm[0])+len(tm[1]) == 11 or len(tm[0])+len(tm[1]) == 12:
selected_turn_models.append(all_odd_even_list.index(tm))
"""
#selected_turn_models = [677, 678, 697, 699, 717, 718, 737, 739, 757, 759, 778, 779, 797, 799, 818, 819,
# 679, 698, 719, 738, 758, 777, 798, 817]
for turn_model in all_odd_even_list:
#for item in selected_turn_models:
# print item
# turn_model = all_odd_even_list[item]
sys.stdout.write("\rnumber of processed turn models: %i " % tm_counter)
sys.stdout.flush()
tm_counter += 1
link_dict = {}
turn_model_index = all_odd_even_list.index(turn_model)
turn_model_odd = turn_model[0]
turn_model_even = turn_model[1]
for node in ag.nodes():
node_x, node_y, node_z = AG_Functions.return_node_location(node)
if node_x % 2 == 1:
for turn in turn_model_odd:
shmu.restore_broken_turn(node, turn, False)
from_port = str(node)+str(turn[0])+"I"
to_port = str(node)+str(turn[2])+"O"
Routing.update_noc_route_graph(noc_rg, from_port, to_port, 'ADD')
else:
for turn in turn_model_even:
shmu.restore_broken_turn(node, turn, False)
from_port = str(node)+str(turn[0])+"I"
to_port = str(node)+str(turn[2])+"O"
Routing.update_noc_route_graph(noc_rg, from_port, to_port, 'ADD')
number_of_pairs = len(ag.nodes())*(len(ag.nodes())-1)
all_paths_in_graph = []
for source_node in ag.nodes():
for destination_node in ag.nodes():
if source_node != destination_node:
if is_destination_reachable_from_source(noc_rg, source_node, destination_node):
# print source_node, "--->", destination_node
if Config.RotingType == 'MinimalPath':
shortest_paths = list(all_shortest_paths(noc_rg, str(source_node)+str('L')+str('I'),
str(destination_node)+str('L')+str('O')))
paths = []
for path in shortest_paths:
minimal_hop_count = manhattan_distance(source_node, destination_node)
if (len(path)/2)-1 <= minimal_hop_count:
paths.append(path)
all_paths_in_graph.append(path)
else:
paths = list(all_simple_paths(noc_rg, str(source_node)+str('L')+str('I'),
str(destination_node)+str('L')+str('O')))
all_paths_in_graph += paths
link_dict = find_similarity_in_paths(link_dict, paths)
metric = 0
for item in link_dict.keys():
metric += link_dict[item]
if Config.RotingType == 'MinimalPath':
doa = degree_of_adaptiveness(ag, noc_rg, False)/float(number_of_pairs)
#metric = doa/(float(metric)/len(ag.edges()))
metric = 1/(float(metric)/len(ag.edges()))
metric = float("{:3.3f}".format(metric))
# print "Turn Model ", '%5s' %turn_model_index, "\tdoa:", "{:3.3f}".format(doa),
# "\tmetric:", "{:3.3f}".format(metric)
else:
doa_ex = extended_degree_of_adaptiveness(ag, noc_rg, False)/float(number_of_pairs)
#metric = doa_ex/(float(metric)/len(ag.edges()))
metric = 1/(float(metric)/len(ag.edges()))
metric = float("{:3.3f}".format(metric))
# print "Turn Model ", '%5s' %turn_model_index, "\tdoa:", "{:3.3f}".format(doa_ex),
# "\tmetric:", "{:3.3f}".format(metric)
if metric not in classes_of_doa_ratio:
classes_of_doa_ratio.append(metric)
if metric in turn_model_class_dict.keys():
turn_model_class_dict[metric].append(turn_model_index)
else:
turn_model_class_dict[metric] = [turn_model_index]
# return SHMU and RG back to default
for node in ag.nodes():
node_x, node_y, node_z = AG_Functions.return_node_location(node)
if node_x % 2 == 1:
for turn in turn_model_odd:
shmu.break_turn(node, turn, False)
from_port = str(node)+str(turn[0])+"I"
to_port = str(node)+str(turn[2])+"O"
Routing.update_noc_route_graph(noc_rg, from_port, to_port, 'REMOVE')
else:
for turn in turn_model_even:
shmu.break_turn(node, turn, False)
from_port = str(node)+str(turn[0])+"I"
to_port = str(node)+str(turn[2])+"O"
Routing.update_noc_route_graph(noc_rg, from_port, to_port, 'REMOVE')
all_odd_evens_file.write("classes of metric"+str(classes_of_doa_ratio)+"\n")
all_odd_evens_file.write("----------"*3+"\n")
all_odd_evens_file.write("turn models of class"+"\n")
# print "classes of metric", classes_of_doa_ratio
for item in sorted(turn_model_class_dict.keys()):
# print item, turn_model_class_dict[item]
all_odd_evens_file.write(str(item)+" "+str(turn_model_class_dict[item])+"\n")
all_odd_evens_file.write("----------"*3+"\n")
all_odd_evens_file.write("distribution of turn models"+"\n")
for item in sorted(turn_model_class_dict.keys()):
temp_list = []
for tm in turn_model_class_dict[item]:
turn_model = all_odd_even_list[tm]
number_of_turns = len(turn_model[0])+len(turn_model[1])
temp_list.append(number_of_turns)
# print item, temp_list.count(8), temp_list.count(9), temp_list.count(10),
# temp_list.count(11), temp_list.count(12)
all_odd_evens_file.write(str(item)+" "+str(temp_list.count(8))+" "+str(temp_list.count(9))+" " +
str(temp_list.count(10))+" "+str(temp_list.count(11))+" " +
str(temp_list.count(12))+"\n")
all_odd_evens_file.close()
return turn_model_class_dict
def odd_even_fault_tolerance_metric(network_size, routing_type):
turns_health_2d_network = {
"N2W": False,
"N2E": False,
"S2W": False,
"S2E": False,
"W2N": False,
"W2S": False,
"E2N": False,
"E2S": False
}
Config.ag.topology = '2DMesh'
Config.ag.x_size = network_size
Config.ag.y_size = network_size
Config.ag.z_size = 1
Config.RotingType = routing_type
all_odd_evens_file = open(
'Generated_Files/Turn_Model_Eval/' + str(network_size) + "x" +
str(network_size) + '_OE_metric_' + Config.RotingType + '.txt', 'w')
all_odd_evens_file.write("TOPOLOGY::" + str(Config.ag.topology) + "\n")
all_odd_evens_file.write("X SIZE:" + str(Config.ag.x_size) + "\n")
all_odd_evens_file.write("Y SIZE:" + str(Config.ag.y_size) + "\n")
all_odd_evens_file.write("Z SIZE:" + str(Config.ag.z_size) + "\n")
ag = copy.deepcopy(AG_Functions.generate_ag())
shmu = SystemHealthMonitoringUnit.SystemHealthMonitoringUnit()
turns_health = copy.deepcopy(turns_health_2d_network)
shmu.setup_noc_shm(ag, turns_health, False)
noc_rg = copy.deepcopy(
Routing.generate_noc_route_graph(ag, shmu, [], False, False))
classes_of_doa_ratio = []
turn_model_class_dict = {}
tm_counter = 0
for turn_model in all_odd_even_list:
sys.stdout.write("\rnumber of processed turn models: %i " % tm_counter)
sys.stdout.flush()
tm_counter += 1
link_dict = {}
turn_model_index = all_odd_even_list.index(turn_model)
turn_model_odd = turn_model[0]
turn_model_even = turn_model[1]
update_rg_odd_even(ag, turn_model_odd, turn_model_even, shmu, noc_rg)
number_of_pairs = len(ag.nodes()) * (len(ag.nodes()) - 1)
all_paths_in_graph = []
for source_node in ag.nodes():
for destination_node in ag.nodes():
if source_node != destination_node:
if is_destination_reachable_from_source(
noc_rg, source_node, destination_node):
if Config.RotingType == 'MinimalPath':
shortest_paths = list(
all_shortest_paths(
noc_rg,
str(source_node) + str('L') + str('I'),
str(destination_node) + str('L') +
str('O')))
paths = []
for path in shortest_paths:
minimal_hop_count = manhattan_distance(
source_node, destination_node)
if (len(path) / 2) - 1 <= minimal_hop_count:
paths.append(path)
all_paths_in_graph.append(path)
else:
paths = list(
all_simple_paths(
noc_rg,
str(source_node) + str('L') + str('I'),
str(destination_node) + str('L') +
str('O')))
all_paths_in_graph += paths
link_dict = find_similarity_in_paths(link_dict, paths)
metric = 0
for item in link_dict.keys():
metric += link_dict[item]
if Config.RotingType == 'MinimalPath':
doa = degree_of_adaptiveness(ag, noc_rg,
False) / float(number_of_pairs)
metric = 1 / (float(metric) / len(ag.edges()))
metric = float("{:3.3f}".format(metric))
else:
doa_ex = extended_degree_of_adaptiveness(
ag, noc_rg, False) / float(number_of_pairs)
metric = 1 / (float(metric) / len(ag.edges()))
metric = float("{:3.3f}".format(metric))
if metric not in classes_of_doa_ratio:
classes_of_doa_ratio.append(metric)
if metric in turn_model_class_dict.keys():
turn_model_class_dict[metric].append(turn_model_index)
else:
turn_model_class_dict[metric] = [turn_model_index]
# return SHMU and RG back to default
clean_rg_from_odd_even(ag, turn_model_odd, turn_model_even, shmu,
noc_rg)
all_odd_evens_file.write("classes of metric" + str(classes_of_doa_ratio) +
"\n")
all_odd_evens_file.write("----------" * 3 + "\n")
all_odd_evens_file.write("turn models of class" + "\n")
for item in sorted(turn_model_class_dict.keys()):
all_odd_evens_file.write(
str(item) + " " + str(turn_model_class_dict[item]) + "\n")
all_odd_evens_file.write("----------" * 3 + "\n")
all_odd_evens_file.write("distribution of turn models" + "\n")
for item in sorted(turn_model_class_dict.keys()):
temp_list = []
for tm in turn_model_class_dict[item]:
turn_model = all_odd_even_list[tm]
number_of_turns = len(turn_model[0]) + len(turn_model[1])
temp_list.append(number_of_turns)
all_odd_evens_file.write(
str(item) + " " + str(temp_list.count(8)) + " " +
str(temp_list.count(9)) + " " + str(temp_list.count(10)) + " " +
str(temp_list.count(11)) + " " + str(temp_list.count(12)) + "\n")
all_odd_evens_file.close()
return turn_model_class_dict
def test():
all_odd_evens_file = open(
'Generated_Files/Turn_Model_Lists/all_odd_evens_doa.txt', 'w')
turns_health_2d_network = {
"N2W": False,
"N2E": False,
"S2W": False,
"S2E": False,
"W2N": False,
"W2S": False,
"E2N": False,
"E2S": False
}
Config.ag.topology = '2DMesh'
Config.ag.x_size = 3
Config.ag.y_size = 3
Config.ag.z_size = 1
Config.RotingType = 'NonMinimalPath'
ag = copy.deepcopy(AG_Functions.generate_ag())
number_of_pairs = len(ag.nodes()) * (len(ag.nodes()) - 1)
max_ratio = 0
classes_of_doa_ratio = []
turn_model_class_dict = {}
for turn_model in all_odd_even_list:
#for item in selected_turn_models:
#print item
#turn_model = all_odd_even_list[item]
#print turn_model
turn_model_index = all_odd_even_list.index(turn_model)
turn_model_odd = turn_model[0]
turn_model_even = turn_model[1]
turns_health = copy.deepcopy(turns_health_2d_network)
shmu = SystemHealthMonitoringUnit.SystemHealthMonitoringUnit()
shmu.setup_noc_shm(ag, turns_health, False)
noc_rg = copy.deepcopy(
Routing.generate_noc_route_graph(ag, shmu, [], False, False))
for node in ag.nodes():
node_x, node_y, node_z = AG_Functions.return_node_location(node)
if node_x % 2 == 1:
for turn in turn_model_odd:
shmu.restore_broken_turn(node, turn, False)
from_port = str(node) + str(turn[0]) + "I"
to_port = str(node) + str(turn[2]) + "O"
Routing.update_noc_route_graph(noc_rg, from_port, to_port,
'ADD')
else:
for turn in turn_model_even:
shmu.restore_broken_turn(node, turn, False)
from_port = str(node) + str(turn[0]) + "I"
to_port = str(node) + str(turn[2]) + "O"
Routing.update_noc_route_graph(noc_rg, from_port, to_port,
'ADD')
#draw_rg(noc_rg)
number_of_pairs = len(ag.nodes()) * (len(ag.nodes()) - 1)
doa_ex = extended_degree_of_adaptiveness(
ag, noc_rg, False) / float(number_of_pairs)
doa = degree_of_adaptiveness(ag, noc_rg,
False) / float(number_of_pairs)
sum_of_paths = 0
sum_of_sim_ratio = 0
for source_node in ag.nodes():
for destination_node in ag.nodes():
if source_node != destination_node:
if is_destination_reachable_from_source(
noc_rg, source_node, destination_node):
#print source_node, "--->", destination_node
if Config.RotingType == 'MinimalPath':
shortest_paths = list(
all_shortest_paths(
noc_rg,
str(source_node) + str('L') + str('I'),
str(destination_node) + str('L') +
str('O')))
paths = []
for path in shortest_paths:
minimal_hop_count = manhattan_distance(
source_node, destination_node)
if (len(path) / 2) - 1 <= minimal_hop_count:
paths.append(path)
else:
paths = list(
all_simple_paths(
noc_rg,
str(source_node) + str('L') + str('I'),
str(destination_node) + str('L') +
str('O')))
#for path in paths:
# print path
local_sim_ratio = 0
counter = 0
if len(paths) > 1:
for i in range(0, len(paths)):
for j in range(i, len(paths)):
if paths[i] != paths[j]:
sm = difflib.SequenceMatcher(
None, paths[i], paths[j])
counter += 1
local_sim_ratio += sm.ratio()
#print float(local_sim_ratio)/counter
sum_of_sim_ratio += float(
local_sim_ratio) / counter
else:
sum_of_sim_ratio += 1
if Config.RotingType == 'MinimalPath':
print("Turn Model ", '%5s' % turn_model_index, "\tdoa:",
"{:3.3f}".format(doa), "\tsimilarity ratio:",
"{:3.3f}".format(sum_of_sim_ratio),
"\t\tfault tolerance metric:",
"{:3.5f}".format(float(doa) / sum_of_sim_ratio))
doa_ratio = float("{:3.5f}".format(
float(doa) / sum_of_sim_ratio, 5))
else:
print("Turn Model ", '%5s' % turn_model_index, "\tdoa:",
"{:3.3f}".format(doa_ex), "\tsimilarity ratio:",
"{:3.3f}".format(sum_of_sim_ratio),
"\t\tfault tolerance metric:",
"{:3.5f}".format(float(doa_ex) / sum_of_sim_ratio))
doa_ratio = float("{:3.5f}".format(
float(doa_ex) / sum_of_sim_ratio, 5))
if doa_ratio not in classes_of_doa_ratio:
classes_of_doa_ratio.append(doa_ratio)
if doa_ratio in list(turn_model_class_dict.keys()):
turn_model_class_dict[doa_ratio].append(turn_model_index)
else:
turn_model_class_dict[doa_ratio] = [turn_model_index]
if max_ratio < doa_ratio:
max_ratio = doa_ratio
#print "--------------------------------------------"
del noc_rg
print("max doa_ratio", max_ratio)
print("classes of doa_ratio", classes_of_doa_ratio)
for item in sorted(turn_model_class_dict.keys()):
print(item, turn_model_class_dict[item])
return None
def test_routing_functions(self):
# backing up the original config...
initial_config_ag = deepcopy(Config.ag)
initial_turn_model = Config.UsedTurnModel
initial_routing_type = Config.RotingType
# -----------------------------------------------------
Config.ag.type = "Generic"
Config.ag.topology = "2DMesh"
Config.RotingType = "MinimalPath"
Config.ag.x_size = 3
Config.ag.y_size = 3
Config.ag.z_size = 1
for turn_model in PackageFile.routing_alg_list_2d:
tmName = return_turn_model_name(turn_model)
Config.UsedTurnModel = deepcopy(turn_model)
Config.TurnsHealth = deepcopy(Config.setup_turns_health())
ag_4_test = deepcopy(generate_ag(logging=None))
shmu_4_test = SystemHealthMonitoringUnit.SystemHealthMonitoringUnit(
)
shmu_4_test.setup_noc_shm(ag_4_test, Config.TurnsHealth, False)
noc_rg = generate_noc_route_graph(ag_4_test, shmu_4_test,
turn_model, False, False)
self.assertEqual(check_deadlock_freeness(noc_rg),
True,
msg=f"TM {tmName} Deadlock freeness failed")
if turn_model in [
PackageFile.XY_TurnModel, PackageFile.YX_TurnModel
]:
if turn_model == PackageFile.XY_TurnModel:
self.assertEqual(tmName,
'0',
msg=f"TM name {tmName} is not 0")
else:
self.assertEqual(tmName,
'13',
msg=f"TM name {tmName} is not 13")
self.assertEqual(
degree_of_adaptiveness(ag_4_test, noc_rg, report=False) /
72.0,
1.0,
msg=f"TM: {tmName} DOA failed")
self.assertEqual(extended_degree_of_adaptiveness(
ag_4_test, noc_rg, report=False) / 72.0,
1.0,
msg=f"TM: {tmName} DOAex failed")
del ag_4_test
del shmu_4_test
# -----------------------------------------------------
Config.ag.type = "Generic"
Config.ag.topology = "3DMesh"
Config.RotingType = "NonMinimalPath"
Config.ag.x_size = 3
Config.ag.y_size = 3
Config.ag.z_size = 3
for turn_model in PackageFile.routing_alg_list_3d:
Config.UsedTurnModel = deepcopy(turn_model)
Config.TurnsHealth = deepcopy(Config.setup_turns_health())
ag_4_test = deepcopy(generate_ag(logging=None))
shmu_4_test = SystemHealthMonitoringUnit.SystemHealthMonitoringUnit(
)
shmu_4_test.setup_noc_shm(ag_4_test, Config.TurnsHealth, False)
noc_rg = generate_noc_route_graph(ag_4_test, shmu_4_test,
turn_model, False, False)
self.assertEqual(check_deadlock_freeness(noc_rg),
True,
msg=f"TM: {turn_model} deadlock freeness Failed!")
if turn_model == PackageFile.XYZ_TurnModel:
self.assertEqual(return_turn_model_name(turn_model),
"3d_XYZ",
msg="Turn Model is not 3d_XYZ")
self.assertEqual(
degree_of_adaptiveness(ag_4_test, noc_rg, False) / 702,
1,
msg="DoA test failed")
self.assertEqual(
extended_degree_of_adaptiveness(ag_4_test, noc_rg, False) /
702,
1,
msg="ExDoA test failed")
if turn_model == PackageFile.NegativeFirst3D_TurnModel:
self.assertEqual(return_turn_model_name(turn_model),
"3d_NegFirst",
msg="TM name is not 3d_NegFirst")
del ag_4_test
del shmu_4_test
del noc_rg
# -----------------------------------------------------
# going back to original config
Config.ag = deepcopy(initial_config_ag)
Config.UsedTurnModel = initial_turn_model
Config.TurnsHealth = deepcopy(Config.setup_turns_health())
Config.RotingType = initial_routing_type
