def __init__(self):
super(ToyTreeNetwork, self).__init__([
Flow(ArrivalCurve(1, 2), [0, 1, 2]),
Flow(ArrivalCurve(2, 3), [1, 2]),
Flow(ArrivalCurve(1, 1), [0, 1])
], [
Server(ServiceCurve(4, 2)),
Server(ServiceCurve(8, 3)),
Server(ServiceCurve(7, 1))
])
def ff_equiv(self) -> Network:
"""
transforms a non feed-forward network into a feed-forward network by splitting the flows and computing the
arrival curve of every splitted flow by the fixpoint method with SFA method
:return: The equivalent network
:rtype: Network
>>> toy = SFAFixPointAnalyzer(Ring(3, ArrivalCurve(2., 1.), Server(ServiceCurve(6, 4))))
>>> toy.ff_equiv
<Network:
Flows:
0:α(t) = 2.00 + 1.00 t; π = [0]
1:α(t) = 24.40 + 1.00 t; π = [1]
2:α(t) = 41.20 + 1.00 t; π = [2]
3:α(t) = 2.00 + 1.00 t; π = [1]
4:α(t) = 24.40 + 1.00 t; π = [2]
5:α(t) = 41.20 + 1.00 t; π = [0]
6:α(t) = 2.00 + 1.00 t; π = [2]
7:α(t) = 24.40 + 1.00 t; π = [0]
8:α(t) = 41.20 + 1.00 t; π = [1]
Servers:
0:β(t) = 6.00 . (t - 4.00)+
1:β(t) = 6.00 . (t - 4.00)+
2:β(t) = 6.00 . (t - 4.00)+>
"""
tab_sigma = resoud(self.fixpoint_matrix[0], self.fixpoint_matrix[1])
num_split = [
self.network.flows[i].length for i in range(self.network.num_flows)
]
s = self.network.size
list_flows = []
j = 0
h = 0
flow = self.network.flows[j]
for i in range(s):
if tab_sigma[i] >= 0:
list_flows += [
Flow(ArrivalCurve(tab_sigma[i], flow.acurve.rho),
[flow.path[h]])
]
else:
list_flows += [
Flow(ArrivalCurve(np.inf, flow.acurve.rho), [flow.path[h]])
]
h += 1
if h == num_split[j]:
h = 0
j += 1
if j < self.network.num_flows:
flow = self.network.flows[j]
return Network(list_flows, self.network.servers)
def trim(self, server):
"""
In a forest, remove all servers that have a larger number than server
Caveat: Should be used for ordered forests
:param server: server that will become a root of the forest
:type server: int
:return: the trimmed network
:rtype: Network
>>> tree = ToyTreeNetwork()
>>> tree.trim(1)
<Network:
Flows:
0:α(t) = 1.00 + 2.00 t; π = [0, 1]
1:α(t) = 2.00 + 3.00 t; π = [1]
2:α(t) = 1.00 + 1.00 t; π = [0, 1]
Servers:
0:β(t) = 4.00 . (t - 2.00)+
1:β(t) = 8.00 . (t - 3.00)+>
"""
list_servers = self.servers[0:server + 1]
list_path = self.num_flows * [[]]
for i in range(self.num_flows):
list_path[i] = [
self.flows[i].path[p] for p in range(self.flows[i].length)
if self.flows[i].path[p] <= server
]
list_flows = [
Flow(self.flows[i].acurve, list_path[i])
for i in range(self.num_flows)
]
return Network(list_flows, list_servers)
def __init__(self, num_servers_per_ring, acurve, server1, server2):
super(TwoRings, self).__init__([
Flow(
acurve,
np.concatenate([
np.arange(i, num_servers_per_ring - 1),
[2 * num_servers_per_ring - 2],
np.arange(0, i)
])) for i in range(num_servers_per_ring)
] + [
Flow(
acurve,
np.concatenate([
np.arange(num_servers_per_ring - 1 + i,
2 * num_servers_per_ring - 2),
[2 * num_servers_per_ring - 2],
np.arange(num_servers_per_ring - 1,
num_servers_per_ring - 1 + i)
])) for i in range(num_servers_per_ring)
], (2 * num_servers_per_ring - 2) * [server1] + [server2])
def nk2forest(self) -> tuple:
"""
Transforms the network into a forest by keeping one successor in the acyclic transformation: the one with
the smallest number higher than this server
:return: network with split flows so that the topology is a forest and the list of the number of the flow
before first split for each flow
:rtype: tuple
>>> toy = ExactFixPointAnalyzer(Ring(3, ArrivalCurve(2., 1.), Server(ServiceCurve(6, 4))))
>>> toy.nk2forest
(<Network:
Flows:
0:α(t) = 2.00 + 1.00 t; π = [0, 1, 2]
1:α(t) = 2.00 + 1.00 t; π = [1, 2]
2:α(t) = 2.00 + 1.00 t; π = [0]
3:α(t) = 2.00 + 1.00 t; π = [2]
4:α(t) = 2.00 + 1.00 t; π = [0, 1]
Servers:
0:β(t) = 6.00 . (t - 4.00)+
1:β(t) = 6.00 . (t - 4.00)+
2:β(t) = 6.00 . (t - 4.00)+>, [0, 1, 3])
"""
flow_list = []
list_prems = []
pre = 0
for flow in self.network.flows:
i = 0
list_prems += [pre]
p = [flow.path[i]]
while i < len(flow.path) - 1:
if flow.path[i + 1] == self.succ_forest[flow.path[i]]:
p += [flow.path[i + 1]]
else:
pre += 1
flow_list += [Flow(flow.acurve, p)]
p = [flow.path[i + 1]]
i += 1
pre += 1
flow_list += [Flow(flow.acurve, p)]
return Network(flow_list, self.network.servers), list_prems
def ff_equiv(self) -> Network:
"""
transforms a non feed-forward network into a feed-forward network by splitting the flows and computing the
arrival curve of every splitted flow by the fixpoint method with exact method
:return: The equivalent network
:rtype: Network
>>> toy = ExactFixPointAnalyzer(Ring(3, ArrivalCurve(2., 1.), Server(ServiceCurve(6, 4))))
>>> toy.ff_equiv
<Network:
Flows:
0:α(t) = 2.00 + 1.00 t; π = [0, 1, 2]
1:α(t) = 2.00 + 1.00 t; π = [1, 2]
2:α(t) = 23.89 + 1.00 t; π = [0]
3:α(t) = 2.00 + 1.00 t; π = [2]
4:α(t) = 16.39 + 1.00 t; π = [0, 1]
Servers:
0:β(t) = 6.00 . (t - 4.00)+
1:β(t) = 6.00 . (t - 4.00)+
2:β(t) = 6.00 . (t - 4.00)+>
"""
tab_sigma = resoud(self.fixpoint_matrix[0], self.fixpoint_matrix[1])
forest = self.nk2forest[0]
s = forest.num_flows
list_flows = []
for i in range(s):
flow = forest.flows[i]
if tab_sigma[i] >= 0:
list_flows += [
Flow(ArrivalCurve(tab_sigma[i], flow.acurve.rho),
flow.path)
]
else:
list_flows += [
Flow(ArrivalCurve(np.inf, flow.acurve.rho), flow.path)
]
return Network(list_flows, self.network.servers)
def ff_equiv(self) -> Network:
"""
transforms a non feed-forward network into a feed-forward network by splitting the flows and computing the
arrival curve of every splitted flow by the fixpoint method with exact method and grouping flows.
:return: The equivalent network
:rtype: Network
>>> toy = GroupFixPointAnalyzer(Ring(3, ArrivalCurve(2., 1.), Server(ServiceCurve(6, 4))))
>>> toy.ff_equiv
<Network:
Flows:
0:α(t) = 2.00 + 1.00 t; π = [0, 1, 2]
1:α(t) = 2.00 + 1.00 t; π = [1, 2]
2:α(t) = 30.53 + 1.00 t; π = [0]
3:α(t) = 2.00 + 1.00 t; π = [2]
4:α(t) = 30.53 + 1.00 t; π = [0, 1]
Servers:
0:β(t) = 6.00 . (t - 4.00)+
1:β(t) = 6.00 . (t - 4.00)+
2:β(t) = 6.00 . (t - 4.00)+>
"""
tab_sigma = resoud(self.fixpoint_matrix[0], self.fixpoint_matrix[1])
forest, list_prems = self.nk2forest
s = forest.num_flows
r = len(self._removed_edges)
list_sigma = np.zeros(s)
for i in range(self.network.num_flows):
list_sigma[list_prems[i]] = self.network.flows[i].acurve.sigma
for i in range(r):
for f in self.foi_group[i]:
if tab_sigma[i] >= 0:
list_sigma[f + 1] = tab_sigma[i]
else:
list_sigma[f + 1] = np.inf
list_flows = []
for i in range(s):
flow = forest.flows[i]
list_flows += [
Flow(ArrivalCurve(list_sigma[i], flow.acurve.rho), flow.path)
]
return Network(list_flows, self.network.servers)
def __init__(self, num_servers, acurve, server):
super(Ring, self).__init__([
Flow(acurve,
np.concatenate([np.arange(i, num_servers),
np.arange(0, i)])) for i in range(num_servers)
], num_servers * [server])