def test_QueueNetwork_blocking(self):
g = nx.random_geometric_graph(100, 0.2).to_directed()
g = qt.set_types_random(g, proportions={k: 1.0 / 6 for k in range(1, 7)})
q_cls = {
1: qt.LossQueue,
2: qt.QueueServer,
3: qt.InfoQueue,
4: qt.ResourceQueue,
5: qt.ResourceQueue,
6: qt.QueueServer
}
q_arg = {
3: {'net_size': g.number_of_edges()},
4: {'num_servers': 500},
6: {'AgentFactory': qt.GreedyAgent}
}
qn = qt.QueueNetwork(g, q_classes=q_cls, q_args=q_arg, seed=17)
qn.blocking = 'RS'
self.assertEqual(qn.blocking, 'RS')
self.assertEqual(qn._blocking, False)
qn.clear()
self.assertEqual(qn._initialized, False)
def test_NullQueue_data_collection(self):
adj = {
0: {
1: {
'edge_type': 1
}
},
1: {
2: {
'edge_type': 2
},
3: {
'edge_type': 2
},
4: {
'edge_type': 2
}
}
}
g = qt.adjacency2graph(adj)
qcl = {1: qt.QueueServer, 2: qt.NullQueue}
qn = qt.QueueNetwork(g, q_classes=qcl)
qn.initialize(edges=(0, 1))
qn.start_collecting_data(edge_type=2)
qn.max_agents = 5000
qn.simulate(n=10000)
data = qn.get_queue_data()
# Data collected by NullQueues do not have departure and
# service start times in the data
self.assertFalse(data[:, (1, 2)].any())
def test_QueueNetwork_copy(self):
g = nx.random_geometric_graph(100, 0.2).to_directed()
g = qt.set_types_random(g, proportions={k: 0.2 for k in range(1, 6)})
q_cls = {
1: qt.LossQueue,
2: qt.QueueServer,
3: qt.InfoQueue,
4: qt.ResourceQueue,
5: qt.ResourceQueue
}
q_arg = {3: {'net_size': g.number_of_edges()},
4: {'num_servers': 500}}
qn = qt.QueueNetwork(g, q_classes=q_cls, q_args=q_arg, seed=17)
qn.max_agents = np.infty
qn.initialize(queues=range(g.number_of_edges()))
qn.simulate(n=50000)
qn2 = qn.copy()
stamp = [(q.num_arrivals, q.time) for q in qn2.edge2queue]
qn2.simulate(n=25000)
self.assertFalse(qn.current_time == qn2.current_time)
self.assertFalse(qn.time == qn2.time)
ans = []
for k, q in enumerate(qn2.edge2queue):
if stamp[k][1] != q.time:
ans.append(q.time != qn.edge2queue[k].time)
self.assertTrue(np.array(ans).all())
def test_QueueNetwork_greedy_routing(self):
lam = np.random.randint(1, 10) + 0.0
rho = np.random.uniform(0.75, 1)
nSe = np.random.randint(1, 10)
mu = lam / (3 * rho * nSe)
def arr(t):
return t + np.random.exponential(1 / lam)
def ser(t):
return t + np.random.exponential(1 / mu)
def ser_id(t):
return t
adj = {
0: {1: {'edge_type': 1}},
1: {
2: {'edge_type': 2},
3: {'edge_type': 2},
4: {'edge_type': 2}
}
}
g = qt.adjacency2graph(adj)
qcl = {1: qt.QueueServer, 2: qt.QueueServer}
arg = {
1: {
'arrival_f': arr,
'service_f': ser_id,
'AgentFactory': qt.GreedyAgent
},
2: {
'service_f': ser,
'num_servers': nSe
}
}
qn = qt.QueueNetwork(g, q_classes=qcl, q_args=arg)
qn.initialize(edges=(0, 1))
qn.max_agents = 5000
num_events = 1000
ans = np.zeros(num_events, bool)
e01 = qn.g.edge_index[(0, 1)]
edg = qn.edge2queue[e01].edge
c = 0
while c < num_events:
qn.simulate(n=1)
if qn.next_event_description() == ('Departure', e01):
d0 = qn.edge2queue[e01]._departures[0].desired_destination(qn, edg)
a1 = np.argmin([qn.edge2queue[e].number_queued() for e in qn.out_edges[1]])
d1 = qn.out_edges[1][a1]
ans[c] = d0 == d1
c += 1
self.assertTrue(ans.all())
def test_QueueNetwork_simulate(self):
g = qt.generate_pagerank_graph(50)
qn = qt.QueueNetwork(g)
qn.max_agents = 2000
qn.initialize(50)
t0 = np.random.uniform(30, 50)
qn.max_agents = 2000
qn.simulate(t=t0)
self.assertGreater(qn.current_time, t0)
def test_InfoQueue_network(self):
g = nx.random_geometric_graph(100, 0.2).to_directed()
q_cls = {1: qt.InfoQueue}
q_arg = {1: {'net_size': g.number_of_edges()}}
qn = qt.QueueNetwork(g, q_classes=q_cls, q_args=q_arg, seed=17)
qn.max_agents = 40000
qn.initialize(queues=range(qn.g.number_of_edges()))
qn.simulate(n=2000)
# Finish this
self.assertTrue(True)
def test_ResourceQueue_network(self):
g = nx.random_geometric_graph(100, 0.2).to_directed()
q_cls = {1: qt.ResourceQueue, 2: qt.ResourceQueue}
q_arg = {1: {'num_servers': 50}, 2: {'num_servers': 500}}
qn = qt.QueueNetwork(g, q_classes=q_cls, q_args=q_arg)
qn.max_agents = 400000
qn.initialize(queues=range(qn.g.number_of_edges()))
qn.simulate(n=50000)
nServ = {1: 50, 2: 500}
ans = np.array(
[q.num_servers != nServ[q.edge[3]] for q in qn.edge2queue])
self.assertTrue(ans.any())
def creat_network():
g = qt.generate_random_graph(10, seed=3)
q = qt.QueueNetwork(g, seed=3)
q.max_agents = 20
q.initialize(100)
q.simulate(10000)
pos = nx.nx_agraph.graphviz_layout(g.to_undirected(), prog='neato')
scatter_kwargs = {'s': 30}
q.draw(pos=pos,
scatter_kwargs=scatter_kwargs,
bgcolor=[0, 0, 0, 0],
figsize=(6, 6),
fname='fig.png',
bbox_inches='tight')
plt.show()
def createQueueingNetwork(g,checkIn_rate,polling_rate):
q_classes = {1: qt.QueueServer, 2: qt.QueueServer, 3: qt.QueueServer}
q_args = {
1: {
'arrival_f':arr_f,
'service_f': lambda t: t,
'AgentFactory: ': qt.Agent
},
2: {
'service_f': lambda t: t + np.random.exponential(1/checkIn_rate)
},
3: {
'service_f': lambda t: t + np.random.exponential(1/polling_rate)
}
}
qn = qt.QueueNetwork(g=g, q_classes=q_classes, q_args=q_args, seed=13)
return qn
def test_QueueNetwork_get_queue_data(self):
g = nx.random_geometric_graph(50, 0.5).to_directed()
q_cls = {1: qt.QueueServer}
qn = qt.QueueNetwork(g, q_classes=q_cls, seed=17)
k = np.random.randint(10000, 20000)
qn.max_agents = 4000
qn.initialize(queues=range(qn.nE))
qn.start_collecting_data()
qn.simulate(n=k)
data = qn.get_queue_data()
self.assertEqual(data.shape, (k, 6))
qn.stop_collecting_data()
qn.clear_data()
ans = np.array([q.data == {} for q in qn.edge2queue])
self.assertTrue(ans.all())
def test_ResourceQueue_network_data_collection(self):
g = qt.generate_random_graph(100)
q_cls = {1: qt.ResourceQueue, 2: qt.ResourceQueue}
q_arg = {
1: {
'num_servers': 500
},
2: {
'num_servers': 500,
'AgentFactory': qt.Agent
}
}
qn = qt.QueueNetwork(g, q_classes=q_cls, q_args=q_arg)
qn.max_agents = 40000
qn.initialize(queues=range(qn.g.number_of_edges()))
qn.start_collecting_data()
qn.simulate(n=5000)
data = qn.get_queue_data()
self.assertTrue(len(data) > 0)
def test_QueueNetwork_add_arrival(self):
adj = {0: [1], 1: [2, 3]}
g = qt.adjacency2graph(adj)
qn = qt.QueueNetwork(g)
mat = qt.generate_transition_matrix(g)
qn.set_transitions(mat)
qn.initialize(edges=(0, 1))
qn.start_collecting_data(edge=[(1, 2), (1, 3)])
qn.simulate(150000)
data = qn.get_queue_data(edge=[(1, 2), (1, 3)])
e0, e1 = qn.out_edges[1]
p0 = np.sum(data[:, 5] == e0, dtype=float) / data.shape[0]
p1 = np.sum(data[:, 5] == e1, dtype=float) / data.shape[0]
trans = qn.transitions(False)
self.assertAlmostEqual(trans[1][2], p0, 2)
self.assertAlmostEqual(trans[1][3], p1, 2)
import queueing_tool as qt
import networkx as nx
g = qt.generate_random_graph(200, seed=3)
q = qt.QueueNetwork(g, seed=3)
q.max_agents = 2000
q.initialize(100)
q.simulate(10000)
pos = nx.nx_agraph.graphviz_layout(g.to_undirected(), prog='fdp')
scatter_kwargs = {'s': 30}
q.draw(pos=pos,
scatter_kwargs=scatter_kwargs,
bgcolor=[0, 0, 0, 0],
figsize=(10, 16),
fname='fig.png',
bbox_inches='tight')
# 4:{0:1,3:1,6:1,9:1}, 5:{2:1,7:1}, 6:{2:1,4:1,7:1,10:1}, 7:{5:1,6:1,11:1},
# 8:{3:1,9:1,12:1}, 9:{4:1,8:1,10:1,13:1,14:1}, 10:{6:1,9:1,11:1,14:1},
# 11:{7:1,10:1,15:1}, 12:{8:1,13:1}, 13:{9:1,12:1,14:1}, 14:{9:1,10:1,13:1,15:1},
# 15:{11:1,14:1}}
# adja_list = {0: [1], 1: [2,3,4], 2:[5,6] }
# edge_list = {0: {1:1}, 1: {2:2,3:2,4:2}, 2: {5:3,6:3}}
# adja_list = {0: [1,2,3], 1: [2, 4], 2:[1,3,4],3:[2, 4] }
# edge_list = {0: {1:1, 2:1, 3:1}, 1: {2:2 ,4:3}, 2: {1:2,3:2,4:3}, 3: {2:2 ,4:3}}
adja_list = {0: [1], 1: [2, 3]}
edge_list = {0: {1: 1}, 1: {2: 2, 3: 3}}
g = qt.adjacency2graph(adjacency=adja_list, edge_type=edge_list)
qn = qt.QueueNetwork(g=g, q_classes=q_classes, q_args=q_args, seed=13)
qn.draw(fname="sim.png", figsize=(12, 3), bbox_inches='tight')
pos = nx.spring_layout(g)
nx.draw_networkx_nodes(g,
pos,
node_color='green',
edge_color='orange',
alpha=0.6)
nx.draw_networkx_edges(g,
pos,
node_color='green',
edge_color='orange',
alpha=0.6)
nx.draw_networkx_labels(g, pos)
def simulation(adja_list, edge_list, matrix_seed, graph_seed):
s = matrix_seed
ss = graph_seed
g = qt.adjacency2graph(adjacency=adja_list, edge_type=edge_list)
qn = qt.QueueNetwork(g=g,
q_classes=q_classes,
q_args=q_args,
seed=ss,
blocking='BAS')
# mat = create_mat(g,s)
# qn.set_transitions(mat)
"""
mat = qt.generate_transition_matrix(g, seed=96)
qn.set_transitions(mat)
"""
qn.draw(fname="sim.png", figsize=(12, 3), bbox_inches='tight')
# plt.show()
qn.initialize(edge_type=1)
qn.clear_data()
qn.start_collecting_data(edge_type=1)
qn.start_collecting_data(edge_type=2)
qn.start_collecting_data(edge_type=3)
qn.start_collecting_data(edge_type=4)
qn.start_collecting_data(edge_type=5)
qn.start_collecting_data(edge_type=6)
qn.start_collecting_data(edge_type=7)
qn.start_collecting_data(edge_type=8)
qn.start_collecting_data(edge_type=9)
qn.start_collecting_data(edge_type=10)
qn.start_collecting_data(edge_type=11)
qn.start_collecting_data(edge_type=12)
qn.simulate(t=0.3)
"""
len(data2), means the total job in server 2
"""
np.set_printoptions(suppress=True)
data1 = qn.get_queue_data(edge_type=1)
data2 = qn.get_queue_data(edge_type=2)
data3 = qn.get_queue_data(edge_type=3)
data4 = qn.get_queue_data(edge_type=4)
data5 = qn.get_queue_data(edge_type=5)
data6 = qn.get_queue_data(edge_type=6)
data7 = qn.get_queue_data(edge_type=7)
data8 = qn.get_queue_data(edge_type=8)
data9 = qn.get_queue_data(edge_type=9)
data10 = qn.get_queue_data(edge_type=10)
data11 = qn.get_queue_data(edge_type=11)
data12 = qn.get_queue_data(edge_type=12)
dataa1 = qn.get_agent_data(edge_type=1)
dataa2 = qn.get_agent_data(edge_type=2)
dataa3 = qn.get_agent_data(edge_type=3)
dataa4 = qn.get_agent_data(edge_type=4)
dataa5 = qn.get_agent_data(edge_type=5)
dataa6 = qn.get_agent_data(edge_type=6)
dataa7 = qn.get_agent_data(edge_type=7)
dataa8 = qn.get_agent_data(edge_type=8)
dataa9 = qn.get_agent_data(edge_type=9)
dataa10 = qn.get_agent_data(edge_type=10)
dataa11 = qn.get_agent_data(edge_type=11)
dataa12 = qn.get_agent_data(edge_type=12)
total_job_num = len(data1)
job_pool = 0
each_total_job = [] # a list with each server's total job
each_thoughtput = [] # a list with each server's throught
print("==========edge_type=1================")
print(data1)
print("==========edge_type=2================")
print(data2)
print("==========edge_type=3================")
print(data3)
print("==========edge_type=4================")
print(data4)
print("==========edge_type=5================")
print(data5)
print("==========edge_type=6================")
print(data6)
print("==========edge_type=7================")
print(data7)
print("==========edge_type=8================")
print(data8)
print("==========edge_type=9================")
print(data9)
print("==========edge_type=10================")
print(data10)
print("==========edge_type11================")
print(data11)
print("==========edge_type=12================")
print(data12)
print("totol job of server1: ", len(data1))
print("totol job of server2: ", len(data2))
print("totol job of server3: ", len(data3))
print("totol job of server4: ", len(data4))
print("totol job of server5: ", len(data5))
print("totol job of server6: ", len(data6))
print("totol job of server7: ", len(data7))
print("totol job of server8: ", len(data8))
print("totol job of server9: ", len(data9))
print("totol job of server10: ", len(data10))
print("totol job of server11: ", len(data11))
print("totol job of server12: ", len(data12), "\n")
print("==========agent=1================")
print(dataa1)
print("==========agent=2================")
print(dataa2)
print("==========agent=3================")
print(dataa3)
print("==========agent=4================")
print(dataa4)
print("==========agent=5================")
print(dataa5)
print("==========agent=6================")
print(dataa6)
print("==========agent=7================")
print(dataa7)
print("==========agent=8================")
print(dataa8)
print("==========agent=9================")
print(dataa9)
print("==========agent=10================")
print(dataa10)
print("==========agent11================")
print(dataa11)
print("==========agent=12================")
print(dataa12)
each_total_job.append(len(data1))
each_total_job.append(len(data2))
each_total_job.append(len(data3))
each_total_job.append(len(data4))
each_total_job.append(len(data5))
each_total_job.append(len(data6))
each_total_job.append(len(data7))
each_total_job.append(len(data8))
each_total_job.append(len(data9))
each_total_job.append(len(data10))
each_total_job.append(len(data11))
each_total_job.append(len(data12))
for i in range(len(data1)):
if data1[i][2] != 0.:
job_pool = job_pool + 1
each_thoughtput.append(job_pool)
print("TOTAL NUMBER OF JOBS IN THIS SIMULATION: ", job_pool)
counter = 0
for i in range(len(data2)):
if data2[i][2] != 0.:
counter = counter + 1
each_thoughtput.append(counter)
print("through put of server2: ", counter)
counter = 0
for i in range(len(data3)):
if data3[i][2] != 0.:
counter = counter + 1
each_thoughtput.append(counter)
print("through put of server3: ", counter)
counter = 0
for i in range(len(data4)):
if data4[i][2] != 0.:
counter = counter + 1
each_thoughtput.append(counter)
print("through put of server4: ", counter)
counter = 0
for i in range(len(data5)):
if data5[i][2] != 0.:
counter = counter + 1
each_thoughtput.append(counter)
print("through put of server5: ", counter)
counter = 0
for i in range(len(data6)):
if data6[i][2] != 0.:
counter = counter + 1
each_thoughtput.append(counter)
print("through put of server6: ", counter)
counter = 0
for i in range(len(data7)):
if data7[i][2] != 0.:
counter = counter + 1
each_thoughtput.append(counter)
print("through put of server7: ", counter)
counter = 0
for i in range(len(data8)):
if data8[i][2] != 0.:
counter = counter + 1
each_thoughtput.append(counter)
print("through put of server8: ", counter)
counter = 0
for i in range(len(data9)):
if data9[i][2] != 0.:
counter = counter + 1
each_thoughtput.append(counter)
print("through put of server9: ", counter)
counter = 0
for i in range(len(data10)):
if data10[i][2] != 0.:
counter = counter + 1
each_thoughtput.append(counter)
print("through put of server9: ", counter)
counter = 0
for i in range(len(data11)):
if data11[i][2] != 0.:
counter = counter + 1
each_thoughtput.append(counter)
print("through put of server11: ", counter)
container = len(data12)
each_thoughtput.append(container)
print("CONTAINER HAS RECIEVED: ", container, "\n")
print("the through put of the map / the total number of jobs in map: ",
container / job_pool, "\n")
data_caculate(each_total_job, each_thoughtput)
import queueing_tool as qt import networkx as nx import numpy as np import matplotlib.pyplot as plt g = qt.generate_random_graph(5, seed=10) # 5 nodes network net = qt.QueueNetwork(g) net.transitions(False) print(net.transitions(True)) # shown as a matrix print(net.transitions(False)) # shown as a dictionary """ the probability will be changed if the seed is changed """
},
4: {
6: 7
},
5: {
6: 8
},
6: {
7: 9
}
}
g = qt.adjacency2graph(adjacency=adja_list, edge_type=edge_list)
qn = qt.QueueNetwork(g=g,
q_classes=q_classes,
q_args=q_args,
seed=13,
blocking='BAS')
"""
mat = qt.generate_transition_matrix(g, seed=96)
qn.set_transitions(mat)
"""
qn.draw(fname="sim.png", figsize=(12, 3), bbox_inches='tight')
# pos = nx.spring_layout(g)
# nx.draw_networkx_nodes(g,pos,node_color='green',edge_color='orange',alpha=0.6)
# nx.draw_networkx_edges(g,pos,node_color='green',edge_color='orange',alpha=0.6)
# nx.draw_networkx_labels(g,pos)
plt.show()
g = nx.moebius_kantor_graph()
q_cl = {1: qt.QueueServer}
def arr(t):
return t + np.random.gamma(4, 0.0025)
def ser(t):
return t + np.random.exponential(0.025)
q_ar = {1: {'arrival_f': arr, 'service_f': ser, 'num_servers': 5}}
net = qt.QueueNetwork(g, q_classes=q_cl, q_args=q_ar, seed=13)
#To specify that arrivals enter from type 1 edges and simulate run:
########################################
net.initialize(edge_type=1)
net.simulate(n=100)
#Now we’d like to see how many agents are in type 1 edges:
###########################################################
for i in range(len(net.edge2queue)):
data = net.edge2queue[i]
print(data)
nA = [(q.num_system, q.edge[2]) for q in net.edge2queue if q.edge[3] == 1]
nA.sort(reverse=True)
print(nA[:5])
def simulation(adja_list, edge_list, matrix_seed, graph_seed):
# adja_list = {0: [1,2,3], 1: [4],2 :[4,5,6],3:[5],4:[6],5:[6],6:[7]}
# edge_list = {0: {1:1,2:1,3:1}, 1: {4:2}, 2:{4:3,6:4,5:5}, 3:{5:6}, 4:{6:7},5:{6:8},6:{7:9}}
s = matrix_seed
ss = graph_seed
g = qt.adjacency2graph(adjacency=adja_list, edge_type=edge_list)
qn = qt.QueueNetwork(g=g,
q_classes=q_classes,
q_args=q_args,
seed=ss,
blocking='BAS')
# mat = create_mat(g,s)
# qn.set_transitions(mat)
"""
mat = qt.generate_transition_matrix(g, seed=96)
qn.set_transitions(mat)
"""
qn.draw(fname="sim.png", figsize=(12, 3), bbox_inches='tight')
# plt.show()
qn.initialize(edge_type=1)
qn.clear_data()
qn.start_collecting_data(edge_type=1)
qn.start_collecting_data(edge_type=2)
qn.start_collecting_data(edge_type=3)
qn.start_collecting_data(edge_type=4)
qn.start_collecting_data(edge_type=5)
qn.start_collecting_data(edge_type=6)
qn.start_collecting_data(edge_type=7)
qn.start_collecting_data(edge_type=8)
qn.start_collecting_data(edge_type=9)
qn.simulate(t=0.2)
np.set_printoptions(suppress=True)
data1 = qn.get_queue_data(edge_type=1)
data2 = qn.get_queue_data(edge_type=2)
data3 = qn.get_queue_data(edge_type=3)
data4 = qn.get_queue_data(edge_type=4)
data5 = qn.get_queue_data(edge_type=5)
data6 = qn.get_queue_data(edge_type=6)
data7 = qn.get_queue_data(edge_type=7)
data8 = qn.get_queue_data(edge_type=8)
data9 = qn.get_queue_data(edge_type=9)
print("==========edge_type=1================")
print(data1)
print("==========edge_type=2================")
# print(data2)
# print("==========edge_type=3================")
# print(data3)
# print("==========edge_type=4================")
# print(data4)
# print("==========edge_type=5================")
# print(data5)
# print("==========edge_type=6================")
# print(data6)
# print("==========edge_type=7================")
# print(data7)
# print("==========edge_type=8================")
# print(data8)
# print("==========edge_type=9================")
# print(data9,"\n")
print("totol job of server1: ", len(data1))
print("totol job of server2: ", len(data2))
print("totol job of server3: ", len(data3))
print("totol job of server4: ", len(data4))
print("totol job of server5: ", len(data5))
print("totol job of server6: ", len(data6))
print("totol job of server7: ", len(data7))
print("totol job of server8: ", len(data8))
print("totol job of server9: ", len(data9), "\n")
through_put = 0
total_job_num = len(data1)
counter = 0
for i in range(len(data4)):
if data4[i][2] != 0.:
counter = counter + 1
through_put = through_put + counter
print("through put of server4: ", counter)
counter = 0
for i in range(len(data7)):
if data7[i][2] != 0.:
counter = counter + 1
through_put = through_put + counter
print("through put of server7: ", counter)
counter = 0
for i in range(len(data8)):
if data8[i][2] != 0.:
counter = counter + 1
through_put = through_put + counter
print("through put of server8: ", counter, "\n")
print(
"the through put of server4,7,8 is equal to the total number of job in server 9:",
through_put)
print("the through put of the map / the total number of jobs in map: ",
through_put / total_job_num)
"num_servers": 1000,
"arrival_f": lambda t: t + np.random.exponential(500),
"service_f": lambda t: t,
"AgentFactory": qt.ResourceAgent,
"qbuffer": 1000,
"active_cap": np.infty
},
2: {
"num_servers": np.infty,
"service_f": lambda t: t + np.random.exponential(1)
}
}
net = qt.QueueNetwork(g=qt.adjacency2graph(adjacency=adj_list,
edge_type=edg_list),
q_classes=q_cls,
q_args=q_args,
seed=66)
net.initialize(edges=(0, 1))
print(net.num_events)
# net.animate(t=horizon,
# figsize=(5, 5),
# filename='plots/qt_animation/test.mp4',
# frames=1000,
# fps=30,
# writer='ffmpeg',
# vertex_size=30)
net.start_collecting_data()
for _ in range(1000):
net._simulate_next_event(slow=False)
q1 = net.edge2queue[0]
def simulation(adja_list, edge_list, matrix_seed, graph_seed):
s = matrix_seed
ss = graph_seed
g = qt.adjacency2graph(adjacency=adja_list, edge_type=edge_list)
qn = qt.QueueNetwork(g=g,
q_classes=q_classes,
q_args=q_args,
seed=ss,
blocking='BAS')
# mat = data_pool_trans_matrix
# mat = np.asarray(mat)
# print("gogogoogogoogogo")
# print(mat)
# qn.set_transitions(mat)
if data_pool_trans_matrix is not None:
mat = renew_transition_matrix_2nd()
print(mat)
qn.set_transitions(mat)
else:
pass
# print(qn.transitions(True))
"""
mat = qt.generate_transition_matrix(g, seed=96)
qn.set_transitions(mat)
"""
# qn.draw(fname="sim.png", figsize=(12, 3), bbox_inches='tight')
# plt.show()
qn.initialize(edge_type=1)
qn.clear_data()
qn.start_collecting_data(edge_type=1)
qn.start_collecting_data(edge_type=2)
qn.start_collecting_data(edge_type=3)
qn.start_collecting_data(edge_type=4)
qn.start_collecting_data(edge_type=5)
qn.start_collecting_data(edge_type=6)
qn.start_collecting_data(edge_type=7)
qn.start_collecting_data(edge_type=8)
qn.start_collecting_data(edge_type=9)
qn.start_collecting_data(edge_type=10)
qn.start_collecting_data(edge_type=11)
qn.start_collecting_data(edge_type=12)
qn.simulate(t=100)
"""
len(data2), means the total job in server 2
"""
np.set_printoptions(suppress=True)
data1 = qn.get_queue_data(edge_type=1)
data2 = qn.get_queue_data(edge_type=2)
data3 = qn.get_queue_data(edge_type=3)
data4 = qn.get_queue_data(edge_type=4)
data5 = qn.get_queue_data(edge_type=5)
data6 = qn.get_queue_data(edge_type=6)
data7 = qn.get_queue_data(edge_type=7)
data8 = qn.get_queue_data(edge_type=8)
data9 = qn.get_queue_data(edge_type=9)
data10 = qn.get_queue_data(edge_type=10)
data11 = qn.get_queue_data(edge_type=11)
data12 = qn.get_queue_data(edge_type=12)
dataa1 = qn.get_agent_data(edge_type=1, return_header=False)
dataa12 = qn.get_agent_data(edge_type=12, return_header=False)
"""
========> 重要資料作業區 <============
"""
total_job_num = len(data1)
job_pool = 0
each_total_job = [] # a list with each server's total job
each_thoughtput = [] # a list with each server's throughtput
"""
========> 重要資料作業區 <============
"""
# print("==========edge_type=1================")
# print(data1)
# print("==========edge_type=2================")
# print(data2)
# print("==========edge_type=3================")
# print(data3)
# print("==========edge_type=4================")
# print(data4)
# print("==========edge_type=5================")
# print(data5)
# print("==========edge_type=6================")
# print(data6)
# print("==========edge_type=7================")
# print(data7)
# print("==========edge_type=8================")
# print(data8)
# print("==========edge_type=9================")
# print(data9)
# print("==========edge_type=10================")
# print(data10)
# print("==========edge_type11================")
# print(data11)
# print("==========edge_type=12================")
# print(data12)
# print("totol job of server1: ", len(data1))
# print("totol job of server2: ", len(data2))
# print("totol job of server3: ", len(data3))
# print("totol job of server4: ", len(data4))
# print("totol job of server5: ", len(data5))
# print("totol job of server6: ", len(data6))
# print("totol job of server7: ", len(data7))
# print("totol job of server8: ", len(data8))
# print("totol job of server9: ", len(data9))
# print("totol job of server10: ", len(data10))
# print("totol job of server11: ", len(data11))
# print("totol job of server12: ", len(data12),"\n")
# each_total_job.append(len(data1))
# each_total_job.append(len(data2))
# each_total_job.append(len(data3))
# each_total_job.append(len(data4))
# each_total_job.append(len(data5))
# each_total_job.append(len(data6))
# each_total_job.append(len(data7))
# each_total_job.append(len(data8))
# each_total_job.append(len(data9))
# each_total_job.append(len(data10))
# each_total_job.append(len(data11))
# each_total_job.append(len(data12))
for i in range(len(data1)):
if data1[i][2] != 0.:
job_pool = job_pool + 1
each_thoughtput.append(job_pool)
# print("TOTAL NUMBER OF JOBS IN THIS SIMULATION: ",job_pool)
# counter = 0
# for i in range(len(data2)):
# if data2[i][2] != 0.:
# counter = counter +1
# each_thoughtput.append(counter)
# # print("through put of server2: ",counter)
# counter = 0
# for i in range(len(data3)):
# if data3[i][2] != 0.:
# counter = counter +1
# each_thoughtput.append(counter)
# # print("through put of server3: ",counter)
# counter = 0
# for i in range(len(data4)):
# if data4[i][2] != 0.:
# counter = counter +1
# each_thoughtput.append(counter)
# # print("through put of server4: ",counter)
# counter = 0
# for i in range(len(data5)):
# if data5[i][2] != 0.:
# counter = counter +1
# each_thoughtput.append(counter)
# # print("through put of server5: ",counter)
# counter = 0
# for i in range(len(data6)):
# if data6[i][2] != 0.:
# counter = counter +1
# each_thoughtput.append(counter)
# # print("through put of server6: ",counter)
# counter = 0
# for i in range(len(data7)):
# if data7[i][2] != 0.:
# counter = counter +1
# each_thoughtput.append(counter)
# # print("through put of server7: ",counter)
# counter = 0
# for i in range(len(data8)):
# if data8[i][2] != 0.:
# counter = counter +1
# each_thoughtput.append(counter)
# # print("through put of server8: ",counter)
# counter = 0
# for i in range(len(data9)):
# if data9[i][2] != 0.:
# counter = counter +1
# each_thoughtput.append(counter)
# # print("through put of server9: ",counter)
# counter = 0
# for i in range(len(data10)):
# if data10[i][2] != 0.:
# counter = counter +1
# each_thoughtput.append(counter)
# # print("through put of server9: ",counter)
# counter = 0
# for i in range(len(data11)):
# if data11[i][2] != 0.:
# counter = counter +1
# each_thoughtput.append(counter)
# # print("through put of server11: ",counter)
container = len(data12)
each_thoughtput.append(container)
# print("CONTAINER HAS RECIEVED: ",container,"\n")
"""
========> 重要資料作業區 <============
"""
# server_delay = {}
server_delay["server2"] = particular_server_delay(data2)
server_delay["server3"] = particular_server_delay(data3)
server_delay["server4"] = particular_server_delay(data4)
server_delay["server5"] = particular_server_delay(data5)
server_delay["server6"] = particular_server_delay(data6)
server_delay["server7"] = particular_server_delay(data7)
server_delay["server8"] = particular_server_delay(data8)
server_delay["server9"] = particular_server_delay(data9)
server_delay["server10"] = particular_server_delay(data10)
server_delay["server11"] = particular_server_delay(data11)
# server_delayy = []
# server_delayy.append(particular_server_delay(data2))
# server_delayy.append(particular_server_delay(data3))
# server_delayy.append(particular_server_delay(data4))
# server_delayy.append(particular_server_delay(data5))
# server_delayy.append(particular_server_delay(data6))
# server_delayy.append(particular_server_delay(data7))
# server_delayy.append(particular_server_delay(data8))
# server_delayy.append(particular_server_delay(data9))
# server_delayy.append(particular_server_delay(data10))
# server_delayy.append(particular_server_delay(data11))
# debug(each_total_job,each_thoughtput) # for reward
drop = delay_and_drop_caculate(dataa1, dataa12,
(job_pool - container)) # for drop rate
# check_distributtion(data1)
print("total job in container: ", container)
print("compared with the container ",
"the drop rate of this simulation: ", drop / container, "\n")
improve_data(server_delay)
# print(improve_data(server_delayy))
"""
import queueing_tool as qt
import matplotlib.animation as manimation
from matplotlib import *
g = qt.generate_pagerank_graph(4, seed=13)
net = qt.QueueNetwork(g, seed=13)
net.initialize()
net.animate(figsize=(4, 4))
kwargs = {
'filename': 'test.mp4',
'frames': 300,
'fps': 30,
'writer': 'mencoder',
'figsize': (4, 4),
'vertex_size': 15
}
"""
This method calls FuncAnimation and optionally matplotlib.animation.FuncAnimation.save().
Any keyword that can be passed to these functions are passed via kwargs.
"""
net.animate(**kwargs)
def test_QueueNetwork_init_error(self):
g = qt.generate_pagerank_graph(7)
with self.assertRaises(TypeError):
qt.QueueNetwork(g, blocking=2)
q_args = {
1: {
"num_servers": 200,
"qbuffer": 2000,
"arrival_f": lambda t: t + np.random.exponential(10),
"service_f": lambda t: t,
"AgentFactory": qt.ResourceAgent
},
2: {
"num_servers": np.infty,
"service_f": lambda t: t + np.random.exponential(500)
}
}
graph = qt.adjacency2graph(adjacency=adj_list, edge_type=edg_list)
net = qt.QueueNetwork(g=graph, q_classes=q_classes, q_args=q_args, seed=13)
# r_mat = qt.generate_transition_matrix(graph, seed=100)
net.set_transitions({1: {3: 1}, 2: {0: 1}})
print(net.transitions(False))
net.initialize(edge_type=1)
print(net.num_events)
# net.animate(t=horizon,
# figsize=(5, 5),
# filename='plots/qt_animation/test.mp4',
# frames=1000,
# fps=30,
# writer='ffmpeg',
# vertex_size=30)
net.start_collecting_data()
net.simulate(n=400)
def simulation(adja_list,edge_list,matrix_seed,graph_seed):
s = matrix_seed
ss = graph_seed
g = qt.adjacency2graph(adjacency=adja_list, edge_type=edge_list)
qn = qt.QueueNetwork(g=g, q_classes=q_classes, q_args=q_args, seed=ss, blocking='BAS')
# mat = create_mat(g,s)
# qn.set_transitions(mat)
# print(qn.transitions(True))
# mat = {0: {1: 1.0}, 1: {2: 0.0, 3: 1.0, 4: 0.0},
# 2: {5: 1.0}, 3: {5: 0.0, 6: 0.0, 7: 1.0}, 4: {6: 1.0},
# 5: {7: 1.0}, 6: {7: 1.0}, 7: {8: 1.0}, 8: {8: 1.0}}
# qn.set_transitions(mat)
"""
mat = qt.generate_transition_matrix(g, seed=96)
qn.set_transitions(mat)
"""
# qn.draw(fname="sim.png", figsize=(12, 3), bbox_inches='tight')
# plt.show()
qn.initialize(edge_type=1)
qn.clear_data()
qn.start_collecting_data(edge_type=1)
qn.start_collecting_data(edge_type=2)
qn.start_collecting_data(edge_type=3)
qn.start_collecting_data(edge_type=4)
qn.start_collecting_data(edge_type=5)
qn.start_collecting_data(edge_type=6)
qn.start_collecting_data(edge_type=7)
qn.start_collecting_data(edge_type=8)
qn.start_collecting_data(edge_type=9)
qn.start_collecting_data(edge_type=10)
qn.start_collecting_data(edge_type=11)
qn.start_collecting_data(edge_type=12)
qn.simulate(t=100)
"""
len(data2), means the total job in server 2
"""
np.set_printoptions(suppress=True)
data1 = qn.get_queue_data(edge_type=1)
data2 = qn.get_queue_data(edge_type=2)
data3 = qn.get_queue_data(edge_type=3)
data4 = qn.get_queue_data(edge_type=4)
data5 = qn.get_queue_data(edge_type=5)
data6 = qn.get_queue_data(edge_type=6)
data7 = qn.get_queue_data(edge_type=7)
data8 = qn.get_queue_data(edge_type=8)
data9 = qn.get_queue_data(edge_type=9)
data10 = qn.get_queue_data(edge_type=10)
data11 = qn.get_queue_data(edge_type=11)
data12 = qn.get_queue_data(edge_type=12)
dataa1 = qn.get_agent_data(edge_type=1,return_header=False)
dataa12 = qn.get_agent_data(edge_type=12,return_header=False)
total_job_num = len(data1)
job_pool = 0
each_total_job = [] # a list with each server's total job
each_thoughtput = [] # a list with each server's throught
# print("==========edge_type=1================")
# print(data1)
# print("==========edge_type=2================")
# print(data2)
# print("==========edge_type=3================")
# print(data3)
# print("==========edge_type=4================")
# print(data4)
# print("==========edge_type=5================")
# print(data5)
# print("==========edge_type=6================")
# print(data6)
# print("==========edge_type=7================")
# print(data7)
# print("==========edge_type=8================")
# print(data8)
# print("==========edge_type=9================")
# print(data9)
# print("==========edge_type=10================")
# print(data10)
# print("==========edge_type11================")
# print(data11)
# print("==========edge_type=12================")
# print(data12)
# print("totol job of server1: ", len(data1))
# print("totol job of server2: ", len(data2))
# print("totol job of server3: ", len(data3))
# print("totol job of server4: ", len(data4))
# print("totol job of server5: ", len(data5))
# print("totol job of server6: ", len(data6))
# print("totol job of server7: ", len(data7))
# print("totol job of server8: ", len(data8))
# print("totol job of server9: ", len(data9))
# print("totol job of server10: ", len(data10))
# print("totol job of server11: ", len(data11))
# print("totol job of server12: ", len(data12),"\n")
# each_total_job.append(len(data1))
# each_total_job.append(len(data2))
# each_total_job.append(len(data3))
# each_total_job.append(len(data4))
# each_total_job.append(len(data5))
# each_total_job.append(len(data6))
# each_total_job.append(len(data7))
# each_total_job.append(len(data8))
# each_total_job.append(len(data9))
# each_total_job.append(len(data10))
# each_total_job.append(len(data11))
# each_total_job.append(len(data12))
for i in range(len(data1)):
if data1[i][2] != 0.:
job_pool = job_pool +1
each_thoughtput.append(job_pool)
# print("TOTAL NUMBER OF JOBS IN THIS SIMULATION: ",job_pool)
counter = 0
for i in range(len(data2)):
if data2[i][2] != 0.:
counter = counter +1
each_thoughtput.append(counter)
# print("through put of server2: ",counter)
counter = 0
for i in range(len(data3)):
if data3[i][2] != 0.:
counter = counter +1
each_thoughtput.append(counter)
# print("through put of server3: ",counter)
counter = 0
for i in range(len(data4)):
if data4[i][2] != 0.:
counter = counter +1
each_thoughtput.append(counter)
# print("through put of server4: ",counter)
counter = 0
for i in range(len(data5)):
if data5[i][2] != 0.:
counter = counter +1
each_thoughtput.append(counter)
# print("through put of server5: ",counter)
counter = 0
for i in range(len(data6)):
if data6[i][2] != 0.:
counter = counter +1
each_thoughtput.append(counter)
# print("through put of server6: ",counter)
counter = 0
for i in range(len(data7)):
if data7[i][2] != 0.:
counter = counter +1
each_thoughtput.append(counter)
# print("through put of server7: ",counter)
counter = 0
for i in range(len(data8)):
if data8[i][2] != 0.:
counter = counter +1
each_thoughtput.append(counter)
# print("through put of server8: ",counter)
counter = 0
for i in range(len(data9)):
if data9[i][2] != 0.:
counter = counter +1
each_thoughtput.append(counter)
# print("through put of server9: ",counter)
counter = 0
for i in range(len(data10)):
if data10[i][2] != 0.:
counter = counter +1
each_thoughtput.append(counter)
# print("through put of server9: ",counter)
counter = 0
for i in range(len(data11)):
if data11[i][2] != 0.:
counter = counter +1
each_thoughtput.append(counter)
# print("through put of server11: ",counter)
container = len(data12)
each_thoughtput.append(container)
# print("CONTAINER HAS RECIEVED: ",container,"\n")
# data_caculate(each_total_job,each_thoughtput)
drop = delay_and_drop_caculate(dataa1,dataa12,(job_pool-container))
# save_data1(data1)
print("total job in container: ",container)
print("compared with the container ","the drop rate of this simulation: ", drop/container,"\n")
print("the transition matrix is: ", qn.transitions(False))
def setUpClass(cls):
cls.g = qt.generate_pagerank_graph(200)
cls.qn = qt.QueueNetwork(cls.g)
cls.qn.g.draw_graph = mock.MagicMock()
cls.qn.max_agents = 2000
cls.qn.initialize(50)
