def minimum_completion_time(tg, ag, shm, logging): """ :param tg: Task Graph :param ag: Architecture Graph :param shm: System Health Map :param logging: logging File :return: (TG, AG) """ # The difference with Min Min or Max Min is that we don't add priorities to # tasks based on their WCET but we randomly choose a task and schedule it... # Note :: This heuristic is not taking task ciriticality into account... print ("===========================================") print ("STARTING MIN COMPLETION TIME MAPPING") for task_to_be_mapped in tg.nodes(): chosen_node = random.choice(Mapping_Functions.nodes_with_smallest_ct(ag, tg, shm, task_to_be_mapped)) 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) print ("\tTASK "+str(task_to_be_mapped)+" MAPPED ON NODE: "+str(chosen_node)) print ("MIN COMPLETION TIME MAPPING FINISHED...") Scheduling_Reports.report_mapped_tasks(ag, logging) return tg, ag
def min_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 smallest 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 MIN-MIN MAPPING") shortest_tasks = Mapping_Functions.unmapped_task_with_smallest_wcet( tg, logging) while len(shortest_tasks) > 0: task_to_be_mapped = shortest_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("\tCANDIDATE NODES FOR MAPPING: " + str(candidate_nodes)) if len(candidate_nodes) > 0: chosen_node = random.choice(candidate_nodes) print("\t\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(shortest_tasks) == 0: shortest_tasks = Mapping_Functions.unmapped_task_with_smallest_wcet( tg, logging) print("MIN-MIN MAPPING FINISHED...") Scheduling_Reports.report_mapped_tasks(ag, logging) return tg, ag
def Min_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 smallest 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 MIN-MIN MAPPING") ShortestTasks = Mapping_Functions.unmapped_task_with_smallest_wcet( TG, logging) while len(ShortestTasks) > 0: TaskToBeMapped = ShortestTasks.pop() # map the task on the Node that yields smallest Completion time CandidateNodes = Mapping_Functions.nodes_with_smallest_ct( AG, TG, SHM, TaskToBeMapped) print("\tCANDIDATE NODES FOR MAPPING: " + str(CandidateNodes)) if len(CandidateNodes) > 0: ChosenNode = random.choice(CandidateNodes) print("\t\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(ShortestTasks) == 0: ShortestTasks = Mapping_Functions.unmapped_task_with_smallest_wcet( TG, logging) print("MIN-MIN 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 minimum_completion_time(tg, ag, shm, logging): """ :param tg: Task Graph :param ag: Architecture Graph :param shm: System Health Map :param logging: logging File :return: (TG, AG) """ # The difference with Min Min or Max Min is that we don't add priorities to # tasks based on their WCET but we randomly choose a task and schedule it... # Note :: This heuristic is not taking task ciriticality into account... print("===========================================") print("STARTING MIN COMPLETION TIME MAPPING") for task_to_be_mapped in tg.nodes(): chosen_node = random.choice( Mapping_Functions.nodes_with_smallest_ct(ag, tg, shm, task_to_be_mapped)) 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) print("\tTASK " + str(task_to_be_mapped) + " MAPPED ON NODE: " + str(chosen_node)) print("MIN COMPLETION TIME MAPPING FINISHED...") Scheduling_Reports.report_mapped_tasks(ag, logging) return tg, ag
def MinimumCompletionTime(TG, AG, SHM, logging): """ :param TG: Task Graph :param AG: Architecture Graph :param SHM: System Health Map :param logging: logging File :return: (TG, AG) """ # The difference with Min Min or Max Min is that we don't add priorities to # tasks based on their WCET but we randomly choose a task and schedule it... # Note :: This heuristic is not taking task ciriticality into account... print("===========================================") print("STARTING MIN COMPLETION TIME MAPPING") for TaskToBeMapped in TG.nodes(): ChosenNode = random.choice( Mapping_Functions.nodes_with_smallest_ct(AG, TG, SHM, TaskToBeMapped)) 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) print("\tTASK " + str(TaskToBeMapped) + " MAPPED ON NODE: " + str(ChosenNode)) print("MIN COMPLETION TIME MAPPING FINISHED...") Scheduling_Reports.report_mapped_tasks(AG, logging) return TG, AG