def insert_sendrecvs(orders, jobson, succ, send, recv):
""" Insert send an recv events into the orders at approprate places """
prec = reverse_dict(succ)
jobson = jobson.copy()
neworders = dict()
for agent, order in orders.items():
order = insert_sends(order, jobson, succ, send)
order = insert_recvs(order, jobson, prec, recv)
neworders[agent] = order
return neworders, jobson
def test_insert_sendrecvs():
prec = {3: (1, 2), 2: (1, )}
succ = reverse_dict(prec)
jobson = {1: 'a', 2: 'b', 3: 'a'}
orders = {'a': [Event(1, 0, 1), Event(3, 4, 8)], 'b': [Event(2, 2, 3)]}
neworders, newjobson = insert_sendrecvs(orders, jobson, succ, send, recv)
print neworders
print newjobson
assert Event(send('a', 'b', 1, 2), 1, 1) in neworders['a']
assert Event(recv('a', 'b', 1, 2), 2, 2) in neworders['b']
assert all(e in neworders[agent] for agent in orders
for e in orders[agent])
def test_insert_sendrecvs():
prec = {3: (1, 2),
2: (1,)}
succ = reverse_dict(prec)
jobson = {1: 'a', 2: 'b', 3: 'a'}
orders = {'a': [Event(1, 0, 1), Event(3, 4, 8)],
'b': [Event(2, 2, 3)]}
neworders, newjobson = insert_sendrecvs(orders, jobson, succ)
print neworders
print newjobson
assert Event(send('a', 'b', 1, 2), 1, 1) in neworders['a']
assert Event(recv('a', 'b', 1, 2), 2, 2) in neworders['b']
assert all(e in neworders[agent] for agent in orders
for e in orders[agent])
def __init__(self, dag):
self.succ = dag['succ']
self.cost = dag['cost']
self.deadline = dag['deadline']
self.comm_delay = dag['comm_delay']
self.agents = dag['cost'].keys()
self.tasks = dag['succ'].keys()
self.sort = None
self.wbar = np.mean(list(dag['cost'].values()), axis=0)
self.rank = OrderedDict()
self.prec = reverse_dict(self.succ)
# Allocate constants
self.schedule_order = {agent: [] for agent in self.agents}
self.task_on = dict()
def schedule(succ, agents, compcost, commcost):
""" Schedule computation dag onto worker agents
inputs:
succ - DAG of tasks {a: (b, c)} where b, and c follow a
agents - set of agents that can perform work
compcost - function :: job, agent -> runtime
commcost - function :: j1, j2, a1, a2 -> communication time
"""
rank = partial(ranku, agents=agents, succ=succ,
compcost=compcost, commcost=commcost)
prec = reverse_dict(succ)
jobs = set(succ.keys()) | set(x for xx in succ.values() for x in xx)
jobs = sorted(jobs, key=rank)
orders = {agent: [] for agent in agents}
jobson = dict()
for job in reversed(jobs):
allocate(job, orders, jobson, prec, compcost, commcost)
return orders, jobson
sL.update({eachP: sl})
eL.update({eachP: el})
jL.update({eachP: jl})
sl = []
el = []
jl = []
result = {}
for i in range(0, len(G), 1):
for j in range(0, len(jL[vm[i]]), 1):
result.update({jL[vm[i]][j]: {'vm': vm[i], 'pos': j, 'starttime': sL[vm[i]][j], 'endtime': eL[vm[i]][j]}})
print(result)
"""Add waitcost into the schedule result"""
dag = getdict()
reverse_dag = reverse_dict(dag)
for i in range(0, len(G), 1):
for j in range(1, len(jL[vm[i]]), 1):
if jL[vm[i]][j] in dag:
temp = 999999
for k in range(0, len(dag[jL[vm[i]][j]]), 1):
if result[dag[jL[vm[i]][j]][k]]['endtime'] < temp:
temp = result[dag[jL[vm[i]][j]][k]]['endtime']
sL[vm[i]][j] = temp
"""Add communication cost to the schedule"""
for i in range(0, len(G), 1):
for j in range(0, len(jL[vm[i]]) - 1, 1):
if jL[vm[i]][j] in reverse_dag:
temp = 0
for k in range(0, len(reverse_dag[jL[vm[i]][j]]), 1):
def getdag():
return reverse_dict(dag)
def test_reverse_dict():
d = {'a': (1, 2), 'b': (2, 3), 'c': ()}
assert reverse_dict(d) == {1: ('a',), 2: ('a', 'b'), 3: ('b',)}
# # + self.commcost(self.pro_id, self.previous[x], 'A', 'B'))
# else:
for i in pro_list:
if i.pro_id == self.previous[x]:
n = i
m = pro_list.index(n)
tmp.append(
pro_list[m].run() + self.compcost +
self.commcost(self.previous[x], self.pro_id, 'A', 'B'))
# print(tmp)
total = max(tmp)
# print(total)
return total
dag = reverse_dict(getdag())
jobs_tup = getjobs_tup()
pro_list = []
pro_0 = Pro(0, compcost, [0], commcost, pro_list)
# pro_0.status = True
list1 = [pro_0]
for index in range(len(jobs_tup)):
a = jobs_tup[index]['id']
if a not in dag:
# pro_1 = Pro(jobs_tup[index]['id'], jobs_tup[index]['runtime'], [0], commcost, pro_list)
list1.append(
Pro(jobs_tup[index]['id'], compcost, [0], commcost, pro_list))
else:
# pro_1 = Pro(jobs_tup[index]['id'], jobs_tup[index]['runtime'], list(dag[a]), commcost, pro_list)
jobs_tup += temp_tup
else:
# 第二层节点的标签名称和属性
# print("\t",child.tag,":", child.attrib)
# print('\t'+child.get('ref'))
tup = ()
# 遍历xml文档的第三层
for children in child:
# 第三层节点的标签名称和属性
# print('\t\t'+children.get('ref'));
temp = (children.get('ref'), )
tup = tup + temp
# print(tup)
dict.update({child.get('ref'): tup, })
# print(dict)
dag = reverse_dict(dict)
# print(jobs)
# print(jobs_tup)
# print(dict.keys()[0])
def getdag():
return dag
def getjobs_tup():
return jobs_tup
def getdict():
return dict
def compcost(job, agent):
def test_reverse_dict():
d = {'a': (1, 2), 'b': (2, 3), 'c': ()}
assert reverse_dict(d) == {1: ('a', ), 2: ('a', 'b'), 3: ('b', )}
