def generate_random_fault_time_dict(runtime, shm):
"""
generates random fault time dictionary
:param runtime: simulation runtime
:param shm: system health map
:return: fault time dictionary
"""
fault_time_dict = {}
fault_time = 0
time_until_next_fault = numpy.random.normal(Config.MTBF, Config.SD4MTBF)
fault_time += time_until_next_fault
while fault_time < runtime:
fault_location, fault_type = SHMU_Functions.random_fault_generation(
shm)
fault_time_dict[float("{0:.1f}".format(fault_time))] = (fault_location,
fault_type)
time_until_next_fault = numpy.random.normal(Config.MTBF,
Config.SD4MTBF)
fault_time += time_until_next_fault
fault_file = open('Generated_Files/Injected_Faults.txt', 'w')
for item in fault_time_dict:
fault_file.write(
str(item) + "\t" + str(fault_time_dict[item][0]) + "\t" +
str(fault_time_dict[item][1]) + "\n")
draw_faults_locations(fault_time_dict)
return fault_time_dict
def test_apply_initial_faults(self):
# todo: generate some random faults and put them in Config and then return to normal
ag_4_test = copy.deepcopy(generate_ag(logging=None))
shmu_4_test = SystemHealthMonitoringUnit.SystemHealthMonitoringUnit()
shmu_4_test.setup_noc_shm(ag_4_test, Config.TurnsHealth, False)
SHMU_Functions.apply_initial_faults(shmu_4_test)
for broken_link in Config.ListOfBrokenLinks:
self.assertEqual(shmu_4_test.SHM.edge[broken_link[0]][broken_link[1]]['LinkHealth'], False)
for router_with_broken_turn in Config.ListOfBrokenTurns:
broken_turn = Config.ListOfBrokenTurns[router_with_broken_turn]
self.assertEqual(shmu_4_test.SHM.node[router_with_broken_turn]['TurnsHealth'][broken_turn], False)
for broken_node in Config.ListOfBrokenPEs:
self.assertEqual(shmu_4_test.SHM.node[broken_node]['NodeHealth'], False)
for aged_pe in Config.ListOfAgedPEs:
self.assertEqual(shmu_4_test.SHM.node[aged_pe]['NodeSpeed'], Config.ListOfAgedPEs[aged_pe])
del ag_4_test
del shmu_4_test
def add_current_mapping_to_mpm(self, tg):
"""
Adds a mapping (Extracted from TG) under a fault configuration to MPM.
The dictionary key would be the hash of fault config
:param tg: Task Graph
:return: None
"""
mapping_string = Mapping_Functions.mapping_into_string(tg)
self.MPM[hashlib.md5(SHMU_Functions.generate_fault_config(
self)).hexdigest()] = mapping_string
return None
def initialize_system_DoS(logging):
"""
Generates the Task graph, Architecture Graph, System Health Monitoring Unit, NoC routing graph(s) and
Test Task Graphs and does the mapping and scheduling and returns to the user the initial system
:param logging: logging file
:return: ag, shmu, noc_rg
"""
####################################################################
ag = copy.deepcopy(AG_Functions.generate_ag(logging))
AG_Functions.update_ag_regions(ag)
AG_Functions.random_darkness(ag)
if Config.EnablePartitioning:
AG_Functions.setup_network_partitioning(ag)
if Config.FindOptimumAG:
Arch_Graph_Reports.draw_ag(ag, "AG_Full")
else:
Arch_Graph_Reports.draw_ag(ag, "AG")
####################################################################
Config.setup_turns_health()
shmu = SystemHealthMonitoringUnit.SystemHealthMonitoringUnit()
shmu.setup_noc_shm(ag, Config.TurnsHealth, True)
# Here we are injecting initial faults of the system: we assume these fault
# information is obtained by post manufacturing system diagnosis
SHMU_Functions.apply_initial_faults(shmu)
if Config.viz.shm:
SHMU_Reports.draw_shm(shmu.SHM)
SHMU_Reports.draw_temp_distribution(shmu.SHM)
# SHM_Reports.report_noc_shm()
####################################################################
routing_graph_start_time = time.time()
noc_rg = copy.deepcopy(Routing.generate_noc_route_graph(ag, shmu, Config.UsedTurnModel,
Config.DebugInfo, Config.DebugDetails))
Routing_Functions.check_deadlock_freeness(noc_rg)
print ("\033[92mTIME::\033[0m ROUTING GRAPH GENERATION TOOK: " +
str(round(time.time()-routing_graph_start_time))+" SECONDS")
# Some visualization...
if Config.viz.rg:
RoutingGraph_Reports.draw_rg(noc_rg)
return ag, shmu, noc_rg
def initialize_system_DoS(logging):
"""
Generates the Task graph, Architecture Graph, System Health Monitoring Unit, NoC routing graph(s) and
Test Task Graphs and does the mapping and scheduling and returns to the user the initial system
:param logging: logging file
:return: ag, shmu, noc_rg
"""
####################################################################
ag = copy.deepcopy(AG_Functions.generate_ag(logging))
AG_Functions.update_ag_regions(ag)
AG_Functions.random_darkness(ag)
if Config.EnablePartitioning:
AG_Functions.setup_network_partitioning(ag)
if Config.FindOptimumAG:
Arch_Graph_Reports.draw_ag(ag, "AG_Full")
else:
Arch_Graph_Reports.draw_ag(ag, "AG")
####################################################################
Config.setup_turns_health()
shmu = SystemHealthMonitoringUnit.SystemHealthMonitoringUnit()
shmu.setup_noc_shm(ag, Config.TurnsHealth, True)
# Here we are injecting initial faults of the system: we assume these fault
# information is obtained by post manufacturing system diagnosis
SHMU_Functions.apply_initial_faults(shmu)
if Config.viz.shm:
SHMU_Reports.draw_shm(shmu.SHM)
SHMU_Reports.draw_temp_distribution(shmu.SHM)
# SHM_Reports.report_noc_shm()
####################################################################
routing_graph_start_time = time.time()
noc_rg = copy.deepcopy(Routing.generate_noc_route_graph(ag, shmu, Config.UsedTurnModel,
Config.DebugInfo, Config.DebugDetails))
Routing_Functions.check_deadlock_freeness(noc_rg)
print("\033[92mTIME::\033[0m ROUTING GRAPH GENERATION TOOK: " +
str(round(time.time()-routing_graph_start_time))+" SECONDS")
# Some visualization...
if Config.viz.rg:
RoutingGraph_Reports.draw_rg(noc_rg)
return ag, shmu, noc_rg
def test_apply_initial_faults(self):
# todo: generate some random faults and put them in Config and then return to normal
ag_4_test = copy.deepcopy(generate_ag(logging=None))
shmu_4_test = SystemHealthMonitoringUnit.SystemHealthMonitoringUnit()
shmu_4_test.setup_noc_shm(ag_4_test, Config.TurnsHealth, False)
SHMU_Functions.apply_initial_faults(shmu_4_test)
for broken_link in Config.ListOfBrokenLinks:
self.assertEqual(shmu_4_test.SHM.edges[broken_link]['LinkHealth'],
False)
for router_with_broken_turn in Config.ListOfBrokenTurns:
broken_turn = Config.ListOfBrokenTurns[router_with_broken_turn]
self.assertEqual(
shmu_4_test.SHM.node[router_with_broken_turn]['TurnsHealth']
[broken_turn], False)
for broken_node in Config.ListOfBrokenPEs:
self.assertEqual(shmu_4_test.SHM.node[broken_node]['NodeHealth'],
False)
for aged_pe in Config.ListOfAgedPEs:
self.assertEqual(shmu_4_test.SHM.node[aged_pe]['NodeSpeed'],
Config.ListOfAgedPEs[aged_pe])
del ag_4_test
del shmu_4_test
def fault_event(env, ag, shmu, noc_rg, schedule_length, fault_time_dict, counter_threshold, logging):
"""
Injects rand fault events (random location and type of fault) at times taken from fault_time_list
:param env: Simulator Environment
:param ag: Architecture Graph
:param shmu: System health Monitoring Unit
:param noc_rg: NoC routing Graph
:param fault_time_dict: Dictionary with Fault time as key and (Location, Type) tuple as value
:param counter_threshold: counter threshold object
:param logging: logging file
:return:
"""
fault = False
while True:
for fault_time in fault_time_dict.keys():
# print env.now, fault_time
if float("{0:.1f}".format(env.now)) == fault_time:
fault_location, fault_type = fault_time_dict[fault_time]
fault = True
# print "Fault Location:", FaultLocation, "Type:", FaultType
pass
else:
# print env.now, FaultTime
pass
if fault:
if type(fault_location) is int:
for scheduling_item in ag.node[fault_location]['PE'].Scheduling:
start_time = ag.node[fault_location]['PE'].Scheduling[scheduling_item][0]
end_time = ag.node[fault_location]['PE'].Scheduling[scheduling_item][1]
if start_time < env.now % schedule_length < end_time:
SHMU_Functions.apply_fault_event(ag, shmu, noc_rg, fault_location, fault_type)
if random.random() > Config.error_correction_rate:
counter_threshold.increase_fault_counter(ag, fault_location, logging)
else:
counter_threshold.increase_intermittent_counter(ag, fault_location, logging)
elif type(fault_location) is tuple:
for scheduling_item in ag.edge[fault_location[0]][fault_location[1]]["Scheduling"]:
start_time = ag.edge[fault_location[0]][fault_location[1]]["Scheduling"][scheduling_item][0][0]
end_time = ag.edge[fault_location[0]][fault_location[1]]["Scheduling"][scheduling_item][0][1]
if start_time < env.now % schedule_length < end_time:
SHMU_Functions.apply_fault_event(ag, shmu, noc_rg, fault_location, fault_type)
if random.random() > Config.error_correction_rate:
counter_threshold.increase_fault_counter(ag, fault_location, logging)
else:
counter_threshold.increase_intermittent_counter(ag, fault_location, logging)
elif type(fault_location) is dict:
for scheduling_item in ag.node[fault_location.keys()[0]]['Router'].Scheduling:
start_time = ag.node[fault_location.keys()[0]]['Router'].Scheduling[scheduling_item][0][0]
end_time = ag.node[fault_location.keys()[0]]['Router'].Scheduling[scheduling_item][0][1]
if start_time < env.now % schedule_length < end_time:
SHMU_Functions.apply_fault_event(ag, shmu, noc_rg, fault_location, fault_type)
if random.random() > Config.error_correction_rate:
counter_threshold.increase_fault_counter(ag, fault_location, logging)
else:
counter_threshold.increase_intermittent_counter(ag, fault_location, logging)
fault = False
yield env.timeout(0.1)
def generate_random_fault_time_dict(runtime, shm):
"""
generates random fault time dictionary
:param runtime: simulation runtime
:param shm: system health map
:return: fault time dictionary
"""
fault_time_dict = {}
fault_time = 0
time_until_next_fault = numpy.random.normal(Config.MTBF, Config.SD4MTBF)
fault_time += time_until_next_fault
while fault_time < runtime:
fault_location, fault_type = SHMU_Functions.random_fault_generation(shm)
fault_time_dict[float("{0:.1f}".format(fault_time))] = (fault_location, fault_type)
time_until_next_fault = numpy.random.normal(Config.MTBF, Config.SD4MTBF)
fault_time += time_until_next_fault
fault_file = open('Generated_Files/Injected_Faults.txt', 'w')
for item in fault_time_dict:
fault_file.write(str(item)+"\t"+str(fault_time_dict[item][0])+"\t"+str(fault_time_dict[item][1])+"\n")
draw_faults_locations(fault_time_dict)
return fault_time_dict
def run_simulator(runtime, ag, shmu, noc_rg, logging):
"""
prepares and runs the simulator
:param runtime: duration of which the user wants to run the program in cycles
:param ag: architecture graph
:param shmu: system health monitoring unit
:param noc_rg: noc routing graph
:param logging: logging file
:return: None
"""
print "==========================================="
print "SETTING UP THE SIMULATOR..."
env = simpy.Environment()
print "SETTING UP counter-threshold MODULE..."
if Config.classification_method == "counter_threshold":
counter_threshold = CounterThreshold.CounterThreshold(
Config.fault_counter_threshold, Config.health_counter_threshold,
Config.intermittent_counter_threshold)
elif Config.classification_method == "machine_learning":
counter_threshold = MachineLearning.MachineLearning(
Config.fault_counter_threshold, # Rene's addition
Config.health_counter_threshold * 3,
Config.intermittent_counter_threshold)
else:
raise ValueError("Unknown Classification Method!! Check config file")
fault_time_dict = {}
fault_time = 0
schedule_length = Scheduling_Functions.FindScheduleMakeSpan(ag)
if Config.EventDrivenFaultInjection:
time_until_next_fault = numpy.random.normal(Config.MTBF,
Config.SD4MTBF)
fault_time += time_until_next_fault
while fault_time < runtime:
fault_location, fault_type = SHMU_Functions.RandomFaultGeneration(
shmu.SHM)
fault_time_dict[float(
"{0:.1f}".format(fault_time))] = (fault_location, fault_type)
time_until_next_fault = numpy.random.normal(
Config.MTBF, Config.SD4MTBF)
fault_time += time_until_next_fault
env.process(
fault_event(env, ag, shmu, noc_rg, schedule_length,
fault_time_dict, counter_threshold, logging))
print "SETTING UP ROUTERS AND PES..."
for node in ag.nodes():
# print node, AG.node[node]["Scheduling"]
env.process(
processor_sim(env, ag, node, ag.node[node]['PE'].Scheduling,
schedule_length, fault_time_dict, counter_threshold,
logging))
env.process(
router_sim(env, ag, node, ag.node[node]['Router'].Scheduling,
schedule_length, fault_time_dict, counter_threshold,
logging))
print "SETTING UP LINKS..."
for link in ag.edges():
# print link, AG.edge[link[0]][link[1]]["Scheduling"]
env.process(
link_sim(env, ag, link, ag.edge[link[0]][link[1]]["Scheduling"],
schedule_length, fault_time_dict, counter_threshold,
logging))
env.process(sim_report(env, ag, counter_threshold))
print "STARTING SIMULATION..."
env.run(until=runtime)
print "SIMULATION FINISHED..."
counter_threshold.report(len(ag.nodes()), len(ag.edges()))
Counter_Threshold_Viz.counter_threshold_viz(ag, counter_threshold)
Scheduling_Reports.report_scheduling_memory_usage(ag)
return None
def initialize_system(logging):
"""
Generates the Task graph, Architecture Graph, System Health Monitoring Unit, NoC routing graph(s) and
Test Task Graphs and does the mapping and scheduling and returns to the user the initial system
:param logging: logging file
:return: tg, ag, shmu, noc_rg, critical_rg, noncritical_rg, pmcg
"""
tg = copy.deepcopy(TG_Functions.generate_tg())
if Config.DebugInfo:
Task_Graph_Reports.report_task_graph(tg, logging)
Task_Graph_Reports.draw_task_graph(tg)
if Config.TestMode:
TG_Test.check_acyclic(tg, logging)
####################################################################
ag = copy.deepcopy(AG_Functions.generate_ag(logging))
AG_Functions.update_ag_regions(ag)
AG_Functions.random_darkness(ag)
if Config.EnablePartitioning:
AG_Functions.setup_network_partitioning(ag)
if Config.FindOptimumAG:
Arch_Graph_Reports.draw_ag(ag, "AG_Full")
else:
Arch_Graph_Reports.draw_ag(ag, "AG")
####################################################################
Config.setup_turns_health()
shmu = SystemHealthMonitoringUnit.SystemHealthMonitoringUnit()
shmu.setup_noc_shm(ag, Config.TurnsHealth, True)
# Here we are injecting initial faults of the system: we assume these fault
# information is obtained by post manufacturing system diagnosis
if Config.FindOptimumAG:
vl_opt.optimize_ag_vertical_links(ag, shmu, logging)
vl_opt_functions.cleanup_ag(ag, shmu)
Arch_Graph_Reports.draw_ag(ag, "AG_VLOpt")
SHMU_Functions.apply_initial_faults(shmu)
if Config.viz.shm:
SHMU_Reports.draw_shm(shmu.SHM)
SHMU_Reports.draw_temp_distribution(shmu.SHM)
# SHM_Reports.report_noc_shm()
####################################################################
routing_graph_start_time = time.time()
if Config.SetRoutingFromFile:
noc_rg = copy.deepcopy(Routing.gen_noc_route_graph_from_file(ag, shmu, Config.RoutingFilePath,
Config.DebugInfo, Config.DebugDetails))
else:
noc_rg = copy.deepcopy(Routing.generate_noc_route_graph(ag, shmu, Config.UsedTurnModel,
Config.DebugInfo, Config.DebugDetails))
Routing_Functions.check_deadlock_freeness(noc_rg)
print ("\033[92mTIME::\033[0m ROUTING GRAPH GENERATION TOOK: " +
str(round(time.time()-routing_graph_start_time))+" SECONDS")
# this is for double checking...
if Config.FindOptimumAG:
Calculate_Reachability.reachability_metric(ag, noc_rg, True)
# Some visualization...
if Config.viz.rg:
RoutingGraph_Reports.draw_rg(noc_rg)
####################################################################
# in case of partitioning, we have to route based on different Route-graphs
if Config.EnablePartitioning:
critical_rg, noncritical_rg = Calculate_Reachability.calculate_reachability_with_regions(ag, shmu)
ReachabilityReports.report_gsnoc_friendly_reachability_in_file(ag)
else:
critical_rg, noncritical_rg = None, None
Calculate_Reachability.calculate_reachability(ag, noc_rg)
Calculate_Reachability.optimize_reachability_rectangles(ag, Config.NumberOfRects)
# ReachabilityReports.report_reachability(ag)
ReachabilityReports.report_reachability_in_file(ag, "ReachAbilityNodeReport")
ReachabilityReports.report_gsnoc_friendly_reachability_in_file(ag)
####################################################################
if Config.read_mapping_from_file:
Mapping_Functions.read_mapping_from_file(tg, ag, shmu.SHM, noc_rg, critical_rg, noncritical_rg,
Config.mapping_file_path, logging)
Scheduler.schedule_all(tg, ag, shmu.SHM, False, logging)
else:
best_tg, best_ag = Mapping.mapping(tg, ag, noc_rg, critical_rg, noncritical_rg, shmu.SHM, logging)
if best_ag is not None and best_tg is not None:
tg = copy.deepcopy(best_tg)
ag = copy.deepcopy(best_ag)
del best_tg, best_ag
# SHM.add_current_mapping_to_mpm(tg)
Mapping_Functions.write_mapping_to_file(ag, "mapping_report")
if Config.viz.mapping_distribution:
Mapping_Reports.draw_mapping_distribution(ag, shmu)
if Config.viz.mapping:
Mapping_Reports.draw_mapping(tg, ag, shmu.SHM, "Mapping_post_opt")
if Config.viz.scheduling:
Scheduling_Reports.generate_gantt_charts(tg, ag, "SchedulingTG")
####################################################################
# PMC-Graph
# at this point we assume that the system health map knows about the initial faults from
# the diagnosis process
if Config.GeneratePMCG:
pmcg_start_time = time.time()
if Config.OneStepDiagnosable:
pmcg = TestSchedulingUnit.gen_one_step_diagnosable_pmcg(ag, shmu.SHM)
else:
pmcg = TestSchedulingUnit.gen_sequentially_diagnosable_pmcg(ag, shmu.SHM)
test_tg = TestSchedulingUnit.generate_test_tg_from_pmcg(pmcg)
print ("\033[92mTIME::\033[0m PMCG AND TTG GENERATION TOOK: " +
str(round(time.time()-pmcg_start_time)) + " SECONDS")
if Config.viz.pmcg:
TestSchedulingUnit.draw_pmcg(pmcg)
if Config.viz.ttg:
TestSchedulingUnit.draw_ttg(test_tg)
TestSchedulingUnit.insert_test_tasks_in_tg(pmcg, tg)
Task_Graph_Reports.draw_task_graph(tg, ttg=test_tg)
TestSchedulingUnit.map_test_tasks(tg, ag, shmu.SHM, noc_rg, logging)
Scheduler.schedule_test_in_tg(tg, ag, shmu.SHM, False, logging)
Scheduling_Reports.report_mapped_tasks(ag, logging)
# TestSchedulingUnit.remove_test_tasks_from_tg(test_tg, tg)
# Task_Graph_Reports.draw_task_graph(tg, TTG=test_tg)
Scheduling_Reports.generate_gantt_charts(tg, ag, "SchedulingWithTTG")
else:
pmcg = None
Arch_Graph_Reports.gen_latex_ag(ag, shmu.SHM)
print ("===========================================")
print ("SYSTEM IS UP...")
TrafficTableGenerator.generate_noxim_traffic_table(ag, tg)
if Config.viz.mapping_frames:
Mapping_Animation.generate_frames(ag, shmu.SHM)
return tg, ag, shmu, noc_rg, critical_rg, noncritical_rg, pmcg
def initialize_system(logging):
"""
Generates the Task graph, Architecture Graph, System Health Monitoring Unit, NoC routing graph(s) and
Test Task Graphs and does the mapping and scheduling and returns to the user the initial system
:param logging: logging file
:return: tg, ag, shmu, noc_rg, critical_rg, noncritical_rg, pmcg
"""
tg = copy.deepcopy(TG_Functions.generate_tg())
if Config.DebugInfo:
Task_Graph_Reports.report_task_graph(tg, logging)
Task_Graph_Reports.draw_task_graph(tg)
if Config.TestMode:
TG_Test.CheckAcyclic(tg, logging)
####################################################################
ag = copy.deepcopy(AG_Functions.generate_ag(logging))
AG_Functions.update_ag_regions(ag)
AG_Functions.random_darkness(ag)
if Config.EnablePartitioning:
AG_Functions.setup_network_partitioning(ag)
if Config.TestMode:
AG_Test.ag_test()
if Config.FindOptimumAG:
Arch_Graph_Reports.draw_ag(ag, "AG_Full")
else:
Arch_Graph_Reports.draw_ag(ag, "AG")
####################################################################
Config.setup_turns_health()
if Config.TestMode:
SHMU_Test.test_shmu(ag)
shmu = SystemHealthMonitoringUnit.SystemHealthMonitoringUnit()
shmu.setup_noc_shm(ag, Config.TurnsHealth)
# Here we are injecting initial faults of the system: we assume these fault
# information is obtained by post manufacturing system diagnosis
if Config.FindOptimumAG:
Optimize_3D_AG.optimize_ag_vertical_links(ag, shmu, logging)
Optimize_3D_AG.cleanup_ag(ag, shmu)
Arch_Graph_Reports.draw_ag(ag, "AG_VLOpt")
SHMU_Functions.ApplyInitialFaults(shmu)
if Config.SHM_Drawing:
SHMU_Reports.DrawSHM(shmu.SHM)
SHMU_Reports.DrawTempDistribution(shmu.SHM)
# SHM_Reports.Report_NoC_SystemHealthMap()
####################################################################
routing_graph_start_time = time.time()
if Config.SetRoutingFromFile:
noc_rg = copy.deepcopy(
Routing.GenerateNoCRouteGraphFromFile(ag, shmu,
Config.RoutingFilePath,
Config.DebugInfo,
Config.DebugDetails))
else:
noc_rg = copy.deepcopy(
Routing.GenerateNoCRouteGraph(ag, shmu, Config.UsedTurnModel,
Config.DebugInfo,
Config.DebugDetails))
print("\033[92mTIME::\033[0m ROUTING GRAPH GENERATION TOOK: " +
str(round(time.time() - routing_graph_start_time)) + " SECONDS")
# this is for double checking...
if Config.FindOptimumAG:
Calculate_Reachability.ReachabilityMetric(ag, noc_rg, True)
# Some visualization...
if Config.RG_Draw:
RoutingGraph_Reports.draw_rg(noc_rg)
####################################################################
# in case of partitioning, we have to route based on different Route-graphs
if Config.EnablePartitioning:
critical_rg, noncritical_rg = Calculate_Reachability.calculate_reachability_with_regions(
ag, shmu)
ReachabilityReports.ReportGSNoCFriendlyReachabilityInFile(ag)
else:
if Config.TestMode:
Reachability_Test.ReachabilityTest()
critical_rg, noncritical_rg = None, None
Calculate_Reachability.calculate_reachability(ag, noc_rg)
Calculate_Reachability.OptimizeReachabilityRectangles(
ag, Config.NumberOfRects)
# ReachabilityReports.ReportReachability(ag)
ReachabilityReports.ReportReachabilityInFile(ag,
"ReachAbilityNodeReport")
ReachabilityReports.ReportGSNoCFriendlyReachabilityInFile(ag)
####################################################################
if Config.read_mapping_from_file:
Mapping_Functions.read_mapping_from_file(tg, ag, shmu.SHM, noc_rg,
critical_rg, noncritical_rg,
Config.mapping_file_path,
logging)
Scheduler.schedule_all(tg, ag, shmu.SHM, False, False, logging)
else:
best_tg, best_ag = Mapping.mapping(tg, ag, noc_rg, critical_rg,
noncritical_rg, shmu.SHM, logging)
if best_ag is not None and best_tg is not None:
tg = copy.deepcopy(best_tg)
ag = copy.deepcopy(best_ag)
del best_tg, best_ag
# SHM.AddCurrentMappingToMPM(tg)
Mapping_Functions.write_mapping_to_file(ag, "mapping_report")
if Config.Mapping_Dstr_Drawing:
Mapping_Reports.draw_mapping_distribution(ag, shmu)
if Config.Mapping_Drawing:
Mapping_Reports.draw_mapping(tg, ag, shmu.SHM, "Mapping_post_opt")
if Config.Scheduling_Drawing:
Scheduling_Reports.generate_gantt_charts(tg, ag, "SchedulingTG")
####################################################################
# PMC-Graph
# at this point we assume that the system health map knows about the initial faults from
# the diagnosis process
if Config.GeneratePMCG:
pmcg_start_time = time.time()
if Config.OneStepDiagnosable:
pmcg = TestSchedulingUnit.GenerateOneStepDiagnosablePMCG(
ag, shmu.SHM)
else:
pmcg = TestSchedulingUnit.GenerateSequentiallyDiagnosablePMCG(
ag, shmu.SHM)
test_tg = TestSchedulingUnit.GenerateTestTGFromPMCG(pmcg)
print("\033[92mTIME::\033[0m PMCG AND TTG GENERATION TOOK: " +
str(round(time.time() - pmcg_start_time)) + " SECONDS")
if Config.PMCG_Drawing:
TestSchedulingUnit.DrawPMCG(pmcg)
if Config.TTG_Drawing:
TestSchedulingUnit.DrawTTG(test_tg)
TestSchedulingUnit.InsertTestTasksInTG(pmcg, tg)
Task_Graph_Reports.draw_task_graph(tg, ttg=test_tg)
TestSchedulingUnit.MapTestTasks(tg, ag, shmu.SHM, noc_rg, logging)
Scheduler.schedule_test_in_tg(tg, ag, shmu.SHM, False, logging)
Scheduling_Reports.report_mapped_tasks(ag, logging)
# TestSchedulingUnit.RemoveTestTasksFromTG(test_tg, tg)
# Task_Graph_Reports.draw_task_graph(tg, TTG=test_tg)
Scheduling_Reports.generate_gantt_charts(tg, ag, "SchedulingWithTTG")
else:
pmcg = None
print("===========================================")
print("SYSTEM IS UP...")
TrafficTableGenerator.generate_noxim_traffic_table(ag, tg)
TrafficTableGenerator.generate_gsnoc_traffic_table(ag, tg)
if Config.GenMappingFrames:
Mapping_Animation.generate_frames(tg, ag, shmu.SHM)
return ag, shmu, noc_rg, critical_rg, noncritical_rg, pmcg
def initialize_system(logging):
"""
Generates the Task graph, Architecture Graph, System Health Monitoring Unit, NoC routing graph(s) and
Test Task Graphs and does the mapping and scheduling and returns to the user the initial system
:param logging: logging file
:return: tg, ag, shmu, noc_rg, critical_rg, noncritical_rg, pmcg
"""
tg = copy.deepcopy(TG_Functions.generate_tg())
if Config.DebugInfo:
Task_Graph_Reports.report_task_graph(tg, logging)
Task_Graph_Reports.draw_task_graph(tg)
if Config.TestMode:
TG_Test.check_acyclic(tg, logging)
####################################################################
ag = copy.deepcopy(AG_Functions.generate_ag(logging))
AG_Functions.update_ag_regions(ag)
AG_Functions.random_darkness(ag)
if Config.EnablePartitioning:
AG_Functions.setup_network_partitioning(ag)
if Config.FindOptimumAG:
Arch_Graph_Reports.draw_ag(ag, "AG_Full")
else:
Arch_Graph_Reports.draw_ag(ag, "AG")
####################################################################
Config.setup_turns_health()
shmu = SystemHealthMonitoringUnit.SystemHealthMonitoringUnit()
shmu.setup_noc_shm(ag, Config.TurnsHealth, True)
# Here we are injecting initial faults of the system: we assume these fault
# information is obtained by post manufacturing system diagnosis
if Config.FindOptimumAG:
vl_opt.optimize_ag_vertical_links(ag, shmu, logging)
vl_opt_functions.cleanup_ag(ag, shmu)
Arch_Graph_Reports.draw_ag(ag, "AG_VLOpt")
SHMU_Functions.apply_initial_faults(shmu)
if Config.viz.shm:
SHMU_Reports.draw_shm(shmu.SHM)
SHMU_Reports.draw_temp_distribution(shmu.SHM)
# SHM_Reports.report_noc_shm()
####################################################################
routing_graph_start_time = time.time()
if Config.SetRoutingFromFile:
noc_rg = copy.deepcopy(Routing.gen_noc_route_graph_from_file(ag, shmu, Config.RoutingFilePath,
Config.DebugInfo, Config.DebugDetails))
else:
noc_rg = copy.deepcopy(Routing.generate_noc_route_graph(ag, shmu, Config.UsedTurnModel,
Config.DebugInfo, Config.DebugDetails))
Routing_Functions.check_deadlock_freeness(noc_rg)
print("\033[92mTIME::\033[0m ROUTING GRAPH GENERATION TOOK: " +
str(round(time.time()-routing_graph_start_time))+" SECONDS")
# this is for double checking...
if Config.FindOptimumAG:
Calculate_Reachability.reachability_metric(ag, noc_rg, True)
# Some visualization...
if Config.viz.rg:
RoutingGraph_Reports.draw_rg(noc_rg)
####################################################################
# in case of partitioning, we have to route based on different Route-graphs
if Config.EnablePartitioning:
critical_rg, noncritical_rg = Calculate_Reachability.calculate_reachability_with_regions(ag, shmu)
ReachabilityReports.report_gsnoc_friendly_reachability_in_file(ag)
else:
critical_rg, noncritical_rg = None, None
Calculate_Reachability.calculate_reachability(ag, noc_rg)
Calculate_Reachability.optimize_reachability_rectangles(ag, Config.NumberOfRects)
# ReachabilityReports.report_reachability(ag)
ReachabilityReports.report_reachability_in_file(ag, "ReachAbilityNodeReport")
ReachabilityReports.report_gsnoc_friendly_reachability_in_file(ag)
####################################################################
if Config.read_mapping_from_file:
Mapping_Functions.read_mapping_from_file(tg, ag, shmu.SHM, noc_rg, critical_rg, noncritical_rg,
Config.mapping_file_path, logging)
Scheduler.schedule_all(tg, ag, shmu.SHM, False, logging)
else:
best_tg, best_ag = Mapping.mapping(tg, ag, noc_rg, critical_rg, noncritical_rg, shmu.SHM, logging)
if best_ag is not None and best_tg is not None:
tg = copy.deepcopy(best_tg)
ag = copy.deepcopy(best_ag)
del best_tg, best_ag
# SHM.add_current_mapping_to_mpm(tg)
Mapping_Functions.write_mapping_to_file(ag, "mapping_report")
if Config.viz.mapping_distribution:
Mapping_Reports.draw_mapping_distribution(ag, shmu)
if Config.viz.mapping:
Mapping_Reports.draw_mapping(tg, ag, shmu.SHM, "Mapping_post_opt")
if Config.viz.scheduling:
Scheduling_Reports.generate_gantt_charts(tg, ag, "SchedulingTG")
####################################################################
# PMC-Graph
# at this point we assume that the system health map knows about the initial faults from
# the diagnosis process
if Config.GeneratePMCG:
pmcg_start_time = time.time()
if Config.OneStepDiagnosable:
pmcg = TestSchedulingUnit.gen_one_step_diagnosable_pmcg(ag, shmu.SHM)
else:
pmcg = TestSchedulingUnit.gen_sequentially_diagnosable_pmcg(ag, shmu.SHM)
test_tg = TestSchedulingUnit.generate_test_tg_from_pmcg(pmcg)
print("\033[92mTIME::\033[0m PMCG AND TTG GENERATION TOOK: " +
str(round(time.time()-pmcg_start_time)) + " SECONDS")
if Config.viz.pmcg:
TestSchedulingUnit.draw_pmcg(pmcg)
if Config.viz.ttg:
TestSchedulingUnit.draw_ttg(test_tg)
TestSchedulingUnit.insert_test_tasks_in_tg(pmcg, tg)
Task_Graph_Reports.draw_task_graph(tg, ttg=test_tg)
TestSchedulingUnit.map_test_tasks(tg, ag, shmu.SHM, noc_rg, logging)
Scheduler.schedule_test_in_tg(tg, ag, shmu.SHM, False, logging)
Scheduling_Reports.report_mapped_tasks(ag, logging)
# TestSchedulingUnit.remove_test_tasks_from_tg(test_tg, tg)
# Task_Graph_Reports.draw_task_graph(tg, TTG=test_tg)
Scheduling_Reports.generate_gantt_charts(tg, ag, "SchedulingWithTTG")
else:
pmcg = None
Arch_Graph_Reports.gen_latex_ag(ag, shmu.SHM)
print("===========================================")
print("SYSTEM IS UP...")
TrafficTableGenerator.generate_noxim_traffic_table(ag, tg)
if Config.viz.mapping_frames:
Mapping_Animation.generate_frames(ag, shmu.SHM)
return tg, ag, shmu, noc_rg, critical_rg, noncritical_rg, pmcg