def max_min_mapping(tg, ag, shm, logging): """ :param tg: Task Graph :param ag: Architecture Graph :param shm: System Health Map :param logging: logging file :return: (TG, AG) """ # this function finds the task with the biggest WCET and # maps it on the machine that can offer smallest completion time... # this means that the mapping algorithm has to take into account the mapping # of the edges of the task graph on the links. # Note:: this is a heuristic for independent tasks... so we are not going to # schedule any link # Note 2:: This heuristic is not taking task ciriticality into account... print ("===========================================") print ("STARTING MAX-MIN MAPPING") longest_tasks = Mapping_Functions.unmapped_task_with_biggest_wcet(tg, logging) while len(longest_tasks) > 0: task_to_be_mapped = longest_tasks.pop() # map the task on the Node that yields smallest Completion time candidate_nodes = Mapping_Functions.nodes_with_smallest_ct(ag, tg, shm, task_to_be_mapped) print ("CANDIDATE NODES FOR MAPPING: "+str(candidate_nodes)) if len(candidate_nodes) > 0: chosen_node = random.choice(candidate_nodes) if len(candidate_nodes) > 1: print ("\tMAPPING TASK "+str(task_to_be_mapped)+" WITH RELEASE: " + str(tg.node[task_to_be_mapped]['task'].release) + " ---> NODE: "+str(chosen_node)+" (RANDOMLY CHOSEN FROM CANDIDATES)") else: print ("\tMAPPING TASK "+str(task_to_be_mapped)+" WITH RELEASE: " + str(tg.node[task_to_be_mapped]['task'].release) + " ---> NODE: "+str(chosen_node)) tg.node[task_to_be_mapped]['task'].node = chosen_node ag.node[chosen_node]['PE'].mapped_tasks.append(task_to_be_mapped) ag.node[chosen_node]['PE'].utilization += tg.node[task_to_be_mapped]['task'].wcet node_speed_down = 1+((100.0-shm.node[chosen_node]['NodeSpeed'])/100) task_execution_on_node = tg.node[task_to_be_mapped]['task'].wcet*node_speed_down completion_on_node = tg.node[task_to_be_mapped]['task'].release + task_execution_on_node Scheduling_Functions_Nodes.add_tg_task_to_node(tg, ag, task_to_be_mapped, chosen_node, tg.node[task_to_be_mapped]['task'].release, completion_on_node, None) if len(longest_tasks) == 0: longest_tasks = Mapping_Functions.unmapped_task_with_biggest_wcet(tg, logging) print ("MIN-MAX MAPPING FINISHED...") Scheduling_Reports.report_mapped_tasks(ag, logging) return tg, ag
def max_min_mapping(tg, ag, shm, logging): """ :param tg: Task Graph :param ag: Architecture Graph :param shm: System Health Map :param logging: logging file :return: (TG, AG) """ # this function finds the task with the biggest WCET and # maps it on the machine that can offer smallest completion time... # this means that the mapping algorithm has to take into account the mapping # of the edges of the task graph on the links. # Note:: this is a heuristic for independent tasks... so we are not going to # schedule any link # Note 2:: This heuristic is not taking task ciriticality into account... print("===========================================") print("STARTING MAX-MIN MAPPING") longest_tasks = Mapping_Functions.unmapped_task_with_biggest_wcet( tg, logging) while len(longest_tasks) > 0: task_to_be_mapped = longest_tasks.pop() # map the task on the Node that yields smallest Completion time candidate_nodes = Mapping_Functions.nodes_with_smallest_ct( ag, tg, shm, task_to_be_mapped) print("CANDIDATE NODES FOR MAPPING: " + str(candidate_nodes)) if len(candidate_nodes) > 0: chosen_node = random.choice(candidate_nodes) if len(candidate_nodes) > 1: print("\tMAPPING TASK " + str(task_to_be_mapped) + " WITH RELEASE: " + str(tg.node[task_to_be_mapped]['task'].release) + " ---> NODE: " + str(chosen_node) + " (RANDOMLY CHOSEN FROM CANDIDATES)") else: print("\tMAPPING TASK " + str(task_to_be_mapped) + " WITH RELEASE: " + str(tg.node[task_to_be_mapped]['task'].release) + " ---> NODE: " + str(chosen_node)) tg.node[task_to_be_mapped]['task'].node = chosen_node ag.node[chosen_node]['PE'].mapped_tasks.append(task_to_be_mapped) ag.node[chosen_node]['PE'].utilization += tg.node[ task_to_be_mapped]['task'].wcet node_speed_down = 1 + ( (100.0 - shm.node[chosen_node]['NodeSpeed']) / 100) task_execution_on_node = tg.node[task_to_be_mapped][ 'task'].wcet * node_speed_down completion_on_node = tg.node[task_to_be_mapped][ 'task'].release + task_execution_on_node Scheduling_Functions_Nodes.add_tg_task_to_node( tg, ag, task_to_be_mapped, chosen_node, tg.node[task_to_be_mapped]['task'].release, completion_on_node, None) if len(longest_tasks) == 0: longest_tasks = Mapping_Functions.unmapped_task_with_biggest_wcet( tg, logging) print("MIN-MAX MAPPING FINISHED...") Scheduling_Reports.report_mapped_tasks(ag, logging) return tg, ag
def Max_Min_Mapping(TG, AG, NoCRG, SHM, logging): """ :param TG: Task Graph :param AG: Architecture Graph :param NoCRG: NoC Routing Graph :param SHM: System Health Map :param logging: logging file :return: (TG, AG) """ # this function finds the task with the biggest WCET and # maps it on the machine that can offer smallest completion time... # this means that the mapping algorithm has to take into account the mapping # of the edges of the task graph on the links. # Note:: this is a heuristic for independent tasks... so we are not going to # schedule any link # Note 2:: This heuristic is not taking task ciriticality into account... print("===========================================") print("STARTING MAX-MIN MAPPING") LongestTasks = Mapping_Functions.unmapped_task_with_biggest_wcet( TG, logging) while len(LongestTasks) > 0: TaskToBeMapped = LongestTasks.pop() # map the task on the Node that yields smallest Completion time CandidateNodes = Mapping_Functions.nodes_with_smallest_ct( AG, TG, SHM, TaskToBeMapped) print("CANDIDATE NODES FOR MAPPING: " + str(CandidateNodes)) if len(CandidateNodes) > 0: ChosenNode = random.choice(CandidateNodes) if len(CandidateNodes) > 1: print("\tMAPPING TASK " + str(TaskToBeMapped) + " WITH RELEASE: " + str(TG.node[TaskToBeMapped]['Release']) + " ---> NODE: " + str(ChosenNode) + " (RANDOMLY CHOSEN FROM CANDIDATES)") else: print("\tMAPPING TASK " + str(TaskToBeMapped) + " WITH RELEASE: " + str(TG.node[TaskToBeMapped]['Release']) + " ---> NODE: " + str(ChosenNode)) TG.node[TaskToBeMapped]['Node'] = ChosenNode AG.node[ChosenNode]['PE'].MappedTasks.append(TaskToBeMapped) AG.node[ChosenNode]['PE'].Utilization += TG.node[TaskToBeMapped][ 'WCET'] NodeSpeedDown = 1 + ( (100.0 - SHM.node[ChosenNode]['NodeSpeed']) / 100) TaskExecutionOnNode = TG.node[TaskToBeMapped][ 'WCET'] * NodeSpeedDown CompletionOnNode = TG.node[TaskToBeMapped][ 'Release'] + TaskExecutionOnNode Scheduling_Functions_Nodes.Add_TG_TaskToNode( TG, AG, TaskToBeMapped, ChosenNode, TG.node[TaskToBeMapped]['Release'], CompletionOnNode, logging) if len(LongestTasks) == 0: LongestTasks = Mapping_Functions.unmapped_task_with_biggest_wcet( TG, logging) print("MIN-MAX MAPPING FINISHED...") Scheduling_Reports.report_mapped_tasks(AG, logging) return TG, AG