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 test_how_many_paths_from_source(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
turn_model = PackageFile.XY_TurnModel
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)
for source_node in ag_4_test.nodes():
for destination_node in ag_4_test.nodes():
if source_node != destination_node:
self.assertEqual(
how_many_paths_from_source(noc_rg, source_node,
destination_node), 1)
Config.ag = deepcopy(initial_config_ag)
Config.UsedTurnModel = initial_turn_model
Config.TurnsHealth = deepcopy(Config.setup_turns_health())
Config.RotingType = initial_routing_type
def calculate_reachability_with_regions(ag, shmu):
"""
calculates the routing graph for different regions of partitioned network
:param ag: architecture graph
:param shmu: system health monitoring unit
:return: routing graph of critical partition and non-critical partition
"""
# first Add the VirtualBrokenLinksForNonCritical
already_broken_links = []
for virtual_broken_link in Config.VirtualBrokenLinksForNonCritical:
if shmu.SHM.edges[virtual_broken_link]['LinkHealth']:
shmu.break_link(virtual_broken_link, True)
else:
already_broken_links.append(virtual_broken_link)
# Construct The RoutingGraph
non_critical_rg = deepcopy(
generate_noc_route_graph(ag, shmu, Config.UsedTurnModel, False, False))
# calculate the rectangles for Non-Critical
calculate_reachability(ag, non_critical_rg)
# save Non Critical rectangles somewhere
non_critical_rect = {}
gate_way_rect = {}
for node in Config.GateToNonCritical:
gate_way_rect[node] = deepcopy(ag.node[node]['Router'].unreachable)
for node in ag.nodes():
if node not in Config.CriticalRegionNodes:
non_critical_rect[node] = deepcopy(
ag.node[node]['Router'].unreachable)
# Restore the VirtualBrokenLinksForNonCritical
for virtual_broken_link in Config.VirtualBrokenLinksForNonCritical:
if virtual_broken_link not in already_broken_links:
shmu.restore_broken_link(virtual_broken_link, True)
already_broken_links = []
# Add VirtualBrokenLinksForCritical
for virtual_broken_link in Config.VirtualBrokenLinksForCritical:
if shmu.SHM.edges[virtual_broken_link]['LinkHealth']:
shmu.break_link(virtual_broken_link, True)
else:
already_broken_links.append(virtual_broken_link)
clear_reachability_calculations(ag)
# Construct The RoutingGraph
critical_rg = deepcopy(
generate_noc_route_graph(ag, shmu, Config.UsedTurnModel, False, False))
# calculate the rectangles for Critical
calculate_reachability(ag, critical_rg)
# save Critical rectangles somewhere
critical_rect = {}
for node in Config.CriticalRegionNodes:
critical_rect[node] = deepcopy(ag.node[node]['Router'].unreachable)
for node in Config.GateToCritical:
gate_way_rect[node] = deepcopy(ag.node[node]['Router'].unreachable)
# Restore the VirtualBrokenLinksForNonCritical
for virtual_broken_link in Config.VirtualBrokenLinksForCritical:
if virtual_broken_link not in already_broken_links:
shmu.restore_broken_link(virtual_broken_link, True)
# Combine Lists
for node in ag.nodes():
if node in critical_rect:
ag.node[node]['Router'].unreachable = deepcopy(critical_rect[node])
elif node in Config.GateToCritical:
ag.node[node]['Router'].unreachable = deepcopy(gate_way_rect[node])
elif node in Config.GateToNonCritical:
ag.node[node]['Router'].unreachable = deepcopy(gate_way_rect[node])
else:
ag.node[node]['Router'].unreachable = deepcopy(
non_critical_rect[node])
# optimize the results
optimize_reachability_rectangles(ag, Config.NumberOfRects)
return critical_rg, non_critical_rg
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 test_is_destination_reachable_from_source(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)
for source_node in ag_4_test.nodes():
for destination_node in ag_4_test.nodes():
if source_node != destination_node:
self.assertEqual(
is_destination_reachable_from_source(
noc_rg, source_node, destination_node), True)
s_x, s_y, s_z = return_node_location(source_node)
d_x, d_y, d_z = return_node_location(destination_node)
# is_destination_reachable_via_port checks output ports only
self.assertEqual(
is_destination_reachable_via_port(
noc_rg, source_node, 'L', destination_node,
False), False)
if turn_model == PackageFile.XY_TurnModel:
if s_x > d_x:
self.assertEqual(
is_destination_reachable_via_port(
noc_rg, source_node, 'W',
destination_node, False), True)
if s_x < d_x:
self.assertEqual(
is_destination_reachable_via_port(
noc_rg, source_node, 'E',
destination_node, False), True)
if s_x == d_x:
if s_y < d_y:
self.assertEqual(
is_destination_reachable_via_port(
noc_rg, source_node, 'N',
destination_node, False), True)
else:
self.assertEqual(
is_destination_reachable_via_port(
noc_rg, source_node, 'S',
destination_node, False), True)
del ag_4_test
del shmu_4_test
del noc_rg
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 = "MinimalPath"
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)
for source_node in ag_4_test.nodes():
for destination_node in ag_4_test.nodes():
if source_node != destination_node:
self.assertEqual(
is_destination_reachable_from_source(
noc_rg, source_node, destination_node), True)
# todo: check is_destination_reachable_via_port
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 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