def nodes_with_smallest_ct(ag, tg, shm, task):
"""
finds nodes with smallest completion time of the task!
THIS FUNCTION CAN BE STRICTLY USED FOR INDEPENDENT TGs
:param ag: Arch Graph
:param tg: Task Graph
:param shm: System Health Map
:param task: Task number
:return: list of nodes with smallest completion time for Task
"""
node_with_smallest_ct = []
random_node = random.choice(list(ag.nodes()))
while (not shm.node[random_node]['NodeHealth']
) or ag.node[random_node]['PE'].dark:
random_node = random.choice(list(ag.nodes()))
node_speed_down = 1 + ((100.0 - shm.node[random_node]['NodeSpeed']) / 100)
task_execution_on_node = tg.node[task]['task'].wcet * node_speed_down
last_allocated_time_on_node = Scheduling_Functions_Nodes.find_last_allocated_time_on_node(
ag, random_node, logging=None)
if last_allocated_time_on_node < tg.node[task]['task'].release:
smallest_completion_time = tg.node[task][
'task'].release + task_execution_on_node
else:
smallest_completion_time = last_allocated_time_on_node + task_execution_on_node
for node in ag.nodes():
if shm.node[node]['NodeHealth'] and (
not ag.node[random_node]['PE'].dark):
node_speed_down = 1 + ((100.0 - shm.node[node]['NodeSpeed']) / 100)
task_execution_on_node = tg.node[task][
'task'].wcet * node_speed_down
last_allocated_time_on_node = Scheduling_Functions_Nodes.find_last_allocated_time_on_node(
ag, node, logging=None)
if last_allocated_time_on_node < tg.node[task]['task'].release:
completion_on_node = tg.node[task][
'task'].release + task_execution_on_node
else:
completion_on_node = last_allocated_time_on_node + task_execution_on_node
if ceil(completion_on_node) < smallest_completion_time:
smallest_completion_time = completion_on_node
for node in ag.nodes():
if shm.node[node]['NodeHealth'] and (
not ag.node[random_node]['PE'].dark):
node_speed_down = 1 + ((100.0 - shm.node[node]['NodeSpeed']) / 100)
last_allocated_time_on_node = Scheduling_Functions_Nodes.find_last_allocated_time_on_node(
ag, node, logging=None)
task_execution_on_node = tg.node[task][
'task'].wcet * node_speed_down
if last_allocated_time_on_node < tg.node[task]['task'].release:
completion_on_node = tg.node[task][
'task'].release + task_execution_on_node
else:
completion_on_node = last_allocated_time_on_node + task_execution_on_node
if completion_on_node == smallest_completion_time:
node_with_smallest_ct.append(node)
return node_with_smallest_ct
def nodes_with_smallest_ct(ag, tg, shm, task):
"""
finds nodes with smallest completion time of the task!
THIS FUNCTION CAN BE STRICTLY USED FOR INDEPENDENT TGs
:param ag: Arch Graph
:param tg: Task Graph
:param shm: System Health Map
:param task: Task number
:return: list of nodes with smallest completion time for Task
"""
node_with_smallest_ct = []
random_node = random.choice(ag.nodes())
while (not shm.node[random_node]['NodeHealth']) or ag.node[random_node]['PE'].dark:
random_node = random.choice(ag.nodes())
node_speed_down = 1+((100.0-shm.node[random_node]['NodeSpeed'])/100)
task_execution_on_node = tg.node[task]['task'].wcet*node_speed_down
last_allocated_time_on_node = Scheduling_Functions_Nodes.find_last_allocated_time_on_node(ag, random_node,
logging=None)
if last_allocated_time_on_node < tg.node[task]['task'].release:
smallest_completion_time = tg.node[task]['task'].release + task_execution_on_node
else:
smallest_completion_time = last_allocated_time_on_node + task_execution_on_node
for node in ag.nodes():
if shm.node[node]['NodeHealth'] and (not ag.node[random_node]['PE'].dark):
node_speed_down = 1+((100.0-shm.node[node]['NodeSpeed'])/100)
task_execution_on_node = tg.node[task]['task'].wcet*node_speed_down
last_allocated_time_on_node = Scheduling_Functions_Nodes.find_last_allocated_time_on_node(ag, node,
logging=None)
if last_allocated_time_on_node < tg.node[task]['task'].release:
completion_on_node = tg.node[task]['task'].release + task_execution_on_node
else:
completion_on_node = last_allocated_time_on_node + task_execution_on_node
if ceil(completion_on_node) < smallest_completion_time:
smallest_completion_time = completion_on_node
for node in ag.nodes():
if shm.node[node]['NodeHealth'] and (not ag.node[random_node]['PE'].dark):
node_speed_down = 1+((100.0-shm.node[node]['NodeSpeed'])/100)
last_allocated_time_on_node = Scheduling_Functions_Nodes.find_last_allocated_time_on_node(ag, node,
logging=None)
task_execution_on_node = tg.node[task]['task'].wcet*node_speed_down
if last_allocated_time_on_node < tg.node[task]['task'].release:
completion_on_node = tg.node[task]['task'].release+task_execution_on_node
else:
completion_on_node = last_allocated_time_on_node+task_execution_on_node
if completion_on_node == smallest_completion_time:
node_with_smallest_ct.append(node)
return node_with_smallest_ct
def find_task_asap_scheduling(tg, ag, shm, task, node, logging=None):
"""
:param tg:
:param ag:
:param shm: System Health Map
:param task:
:param node:
:param logging: logging file
:return:
"""
start_time = max(Scheduling_Functions_Nodes.find_last_allocated_time_on_node(ag, node, logging),
task_predecessors_finish_time(tg, ag, task),
tg.node[task]['task'].release)
# This includes the aging and lower frequency of the nodes of graph...
# however, we do not include fractions of a cycle so we take ceiling of the execution time
node_speed_down = 1+((100.0-shm.node[node]['NodeSpeed'])/100)
task_execution_on_node = ceil(tg.node[task]['task'].wcet*node_speed_down)
if tg.node[task]['task'].criticality == 'H':
end_time = start_time+task_execution_on_node + Config.Task_SlackCount*task_execution_on_node
else:
end_time = start_time+task_execution_on_node
return start_time, end_time
def mapping_cost_function(tg, ag, shm, report, initial_mapping_string=None):
"""
Calculates the Costs of a mapping based on the configurations of Config file
:param tg: Task Graph
:param ag: Architecture Graph
:param shm: System Health Map
:param report: If true prints cost function report to Command-line
:param initial_mapping_string: Initial mapping string used for calculating distance from the current mapping
:return: cost of the mapping
"""
node_makespan_list = []
link_makespan_list = []
for node in ag.nodes():
if shm.node[node]['NodeHealth'] and (not ag.node[node]['PE'].dark):
node_makespan_list.append(Scheduling_Functions_Nodes.find_last_allocated_time_on_node(ag, node,
logging=None))
for link in ag.edges():
if shm.edge[link[0]][link[1]]['LinkHealth']:
link_makespan_list.append(Scheduling_Functions_Links.find_last_allocated_time_on_link(ag, link,
logging=None))
node_makspan_sd = statistics.stdev(node_makespan_list)
node_makspan_max = max(node_makespan_list)
link_makspan_sd = statistics.stdev(link_makespan_list)
link_makspan_max = max(link_makespan_list)
node_util_list = []
link_util_list = []
for node in ag.nodes():
if shm.node[node]['NodeHealth'] and (not ag.node[node]['PE'].dark):
node_util_list.append(AG_Functions.return_node_util(tg, ag, node))
for link in ag.edges():
link_util_list.append(AG_Functions.return_link_util(tg,ag,link))
node_util_sd = statistics.stdev(node_util_list)
link_util_sd = statistics.stdev(link_util_list)
if Config.Mapping_CostFunctionType == 'SD':
cost = node_makspan_sd + link_makspan_sd
elif Config.Mapping_CostFunctionType == 'Node_SD':
cost = node_makspan_sd
elif Config.Mapping_CostFunctionType == 'Link_Util_SD':
cost = link_util_sd
elif Config.Mapping_CostFunctionType == 'Node_Util_SD':
cost = node_util_sd
elif Config.Mapping_CostFunctionType == 'Util_SD':
cost = node_util_sd + link_util_sd
elif Config.Mapping_CostFunctionType == 'Link_SD':
cost = link_makspan_sd
elif Config.Mapping_CostFunctionType == 'SD+MAX':
cost = node_makspan_max + node_makspan_sd + link_makspan_sd + link_makspan_max
elif Config.Mapping_CostFunctionType == 'MAX':
cost = node_makspan_max + link_makspan_max
elif Config.Mapping_CostFunctionType == 'CONSTANT':
cost = 1
else:
raise ValueError("Mapping_CostFunctionType is not valid")
distance = None
if initial_mapping_string is not None:
distance = hamming_distance_of_mapping(initial_mapping_string, mapping_into_string(tg))
cost += 20* distance
if report:
print ("===========================================")
print (" REPORTING MAPPING COST")
print ("===========================================")
print ("NODES MAKE SPAN MAX:"+str(node_makspan_max))
print ("NODES MAKE SPAN STANDARD DEVIATION:"+str(node_makspan_sd))
print ("LINKS MAKE SPAN MAX:"+str(link_makspan_max))
print ("LINKS MAKE SPAN STANDARD DEVIATION:"+str(link_makspan_sd))
if distance is not None:
print ("DISTANCE FROM STARTING SOLUTION:"+str(distance))
print ("MAPPING SCHEDULING COST:"+str(cost))
if cost == 0:
raise ValueError("Mapping with 0 cost... Something is wrong here...")
if check_if_all_deadlines_are_met(tg, ag):
return cost
else:
return cost+1000
def mapping_cost_function(tg, ag, shm, report, initial_mapping_string=None):
"""
Calculates the Costs of a mapping based on the configurations of Config file
:param tg: Task Graph
:param ag: Architecture Graph
:param shm: System Health Map
:param report: If true prints cost function report to Command-line
:param initial_mapping_string: Initial mapping string used for calculating distance from the current mapping
:return: cost of the mapping
"""
node_makespan_list = []
link_makespan_list = []
for node in ag.nodes():
if shm.node[node]['NodeHealth'] and (not ag.node[node]['PE'].dark):
node_makespan_list.append(
Scheduling_Functions_Nodes.find_last_allocated_time_on_node(
ag, node, logging=None))
for link in ag.edges():
if shm.edges[link]['LinkHealth']:
link_makespan_list.append(
Scheduling_Functions_Links.find_last_allocated_time_on_link(
ag, link, logging=None))
node_makspan_sd = statistics.stdev(node_makespan_list)
node_makspan_max = max(node_makespan_list)
link_makspan_sd = statistics.stdev(link_makespan_list)
link_makspan_max = max(link_makespan_list)
node_util_list = []
link_util_list = []
for node in ag.nodes():
if shm.node[node]['NodeHealth'] and (not ag.node[node]['PE'].dark):
node_util_list.append(AG_Functions.return_node_util(tg, ag, node))
for link in ag.edges():
link_util_list.append(AG_Functions.return_link_util(tg, ag, link))
node_util_sd = statistics.stdev(node_util_list)
link_util_sd = statistics.stdev(link_util_list)
if Config.Mapping_CostFunctionType == 'SD':
cost = node_makspan_sd + link_makspan_sd
elif Config.Mapping_CostFunctionType == 'Node_SD':
cost = node_makspan_sd
elif Config.Mapping_CostFunctionType == 'Link_Util_SD':
cost = link_util_sd
elif Config.Mapping_CostFunctionType == 'Node_Util_SD':
cost = node_util_sd
elif Config.Mapping_CostFunctionType == 'Util_SD':
cost = node_util_sd + link_util_sd
elif Config.Mapping_CostFunctionType == 'Link_SD':
cost = link_makspan_sd
elif Config.Mapping_CostFunctionType == 'SD+MAX':
cost = node_makspan_max + node_makspan_sd + link_makspan_sd + link_makspan_max
elif Config.Mapping_CostFunctionType == 'MAX':
cost = node_makspan_max + link_makspan_max
elif Config.Mapping_CostFunctionType == 'CONSTANT':
cost = 1
else:
raise ValueError("Mapping_CostFunctionType is not valid")
distance = None
if initial_mapping_string is not None:
distance = hamming_distance_of_mapping(initial_mapping_string,
mapping_into_string(tg))
cost += 20 * distance
if report:
print("===========================================")
print(" REPORTING MAPPING COST")
print("===========================================")
print("NODES MAKE SPAN MAX:" + str(node_makspan_max))
print("NODES MAKE SPAN STANDARD DEVIATION:" + str(node_makspan_sd))
print("LINKS MAKE SPAN MAX:" + str(link_makspan_max))
print("LINKS MAKE SPAN STANDARD DEVIATION:" + str(link_makspan_sd))
if distance is not None:
print("DISTANCE FROM STARTING SOLUTION:" + str(distance))
print("MAPPING SCHEDULING COST:" + str(cost))
if cost == 0:
raise ValueError("Mapping with 0 cost... Something is wrong here...")
if check_if_all_deadlines_are_met(tg, ag):
return cost
else:
return cost + 1000
