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 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
