def topology_four_child_tree(network_cache=0.05, n_contents=100000, seed=None):
"""
Returns a tree topology
Parameters
----------
network_cache : float
Size of network cache (sum of all caches) normalized by size of content
population
n_contents : int
Size of content population
seed : int, optional
The seed used for random number generation
Returns
-------
topology : fnss.Topology
The topology object
"""
h = 5 # depth of the tree
topology = fnss.k_ary_tree_topology(4, h)
topology.add_node(1365, depth=-1)
topology.add_path([0, 1365])
receivers = [
v for v in topology.nodes_iter() if topology.node[v]['depth'] == h
]
sources = [
v for v in topology.nodes_iter() if topology.node[v]['depth'] == -1
]
caches = [
v for v in topology.nodes_iter()
if topology.node[v]['depth'] >= 0 and topology.node[v]['depth'] < h
]
# randomly allocate contents to sources
content_placement = uniform_content_placement(topology,
range(1, n_contents + 1),
sources,
seed=seed)
for v in sources:
fnss.add_stack(topology, v, 'source',
{'contents': content_placement[v]})
for v in receivers:
fnss.add_stack(topology, v, 'receiver', {})
cache_placement = uniform_cache_placement(topology,
network_cache * n_contents,
caches)
for node, size in cache_placement.iteritems():
fnss.add_stack(topology, node, 'cache', {'size': size})
# set weights and delays on all links
fnss.set_weights_constant(topology, 1.0)
fnss.set_delays_constant(topology, INTERNAL_LINK_DELAY, 'ms')
# label links as internal or external
for u, v in topology.edges_iter():
if u in sources or v in sources:
topology.edge[u][v]['type'] = 'external'
fnss.set_delays_constant(topology, EXTERNAL_LINK_DELAY, 'ms',
[(u, v)])
else:
topology.edge[u][v]['type'] = 'internal'
return topology
def test_delays_constant(self):
topo = fnss.k_ary_tree_topology(3, 4)
self.assertRaises(ValueError, fnss.set_delays_constant, topo, 2, 'Km')
odd_links = [(u, v) for (u, v) in topo.edges() if (u + v) % 2 == 1]
even_links = [(u, v) for (u, v) in topo.edges() if (u + v) % 2 == 0]
fnss.set_delays_constant(topo, 2, 's', odd_links)
fnss.set_delays_constant(topo, 5000000, 'us', even_links)
self.assertEqual('s', topo.graph['delay_unit'])
self.assertTrue(
all(topo.adj[u][v]['delay'] in [2, 5] for (u, v) in topo.edges()))
def setUpClass(cls):
# set up topology used for all traffic matrix tests
cls.topo = fnss.k_ary_tree_topology(3, 4)
cls.capacities = [10, 20]
cls.odd_links = [(u, v) for (u, v) in cls.topo.edges()
if (u + v) % 2 == 1]
cls.even_links = [(u, v) for (u, v) in cls.topo.edges()
if (u + v) % 2 == 0]
fnss.set_capacities_random_uniform(cls.topo, cls.capacities)
fnss.set_delays_constant(cls.topo, 3, 'ms', cls.odd_links)
fnss.set_delays_constant(cls.topo, 12, 'ms', cls.even_links)
def setUpClass(cls):
# set up topology used for all traffic matrix tests
cls.topo = fnss.k_ary_tree_topology(3, 4)
cls.capacities = [10, 20]
cls.odd_links = [(u, v) for (u, v) in cls.topo.edges_iter()
if (u + v) % 2 == 1]
cls.even_links = [(u, v) for (u, v) in cls.topo.edges_iter()
if (u + v) % 2 == 0]
fnss.set_capacities_random_uniform(cls.topo, cls.capacities)
fnss.set_delays_constant(cls.topo, 3, 'ms', cls.odd_links)
fnss.set_delays_constant(cls.topo, 12, 'ms', cls.even_links)
def create_topology(self, PoP, k, h):
topology = fnss.Topology()
for core in range(PoP):
tmp = fnss.k_ary_tree_topology(k, h)
for node in tmp.node:
if tmp.node[node]['type']<>'root':
tmp.node[node]['server']=core*(k**(h+1)-1)
tmp_tree = nx.relabel_nodes(tmp, {node:node+core*(k**(h+1)-1) for node in tmp.node})
topology = nx.union(topology, tmp_tree)
# Full mesh in the core of network
for i in range(core):
topology.edge[i*(k**(h+1)-1)][core*(k**(h+1)-1)] = {}
topology.edge[core*(k**(h+1)-1)][i*(k**(h+1)-1)] = {}
return topology
#class Topology(fnss.Topology):
# def __init__(self, core, k, h, cache_budget):
# cache_size = cache_budget/float(core*(k**h-1))
# self.topology = self._create_topology(core, k, h)
# self.clients = {node:self.topology.node[node] for node in self.topology.node \
# if self.topology.node[node]['type']=='leaf'}
# self.pops = {node:self.topology.node[node] for node in self.topology.node \
# if self.topology.node[node]['type']=='root'}
# self.routers = {node:self.topology.node[node] for node in self.topology.node \
# if self.topology.node[node]['type'] in ['leaf','intermediate']}
## props = open('properties', 'r').readlines()
#
#
# self.content_store = {node:cache(cache_size) for node in self.topology.nodes_iter()}
# self.informations = {node:{} for node in self.topology.nodes_iter()}
#
#
# def _create_topology(self, PoP, k, h):
# topology = fnss.Topology()
# for core in range(PoP):
# tmp = fnss.k_ary_tree_topology(k, h)
# for node in tmp.node:
# if tmp.node[node]['type']<>'leaf':
# tmp.node[node]['server']=core*(k**(h+1)-1)
# tmp_tree = nx.relabel_nodes(tmp, {node:node+core*(k**(h+1)-1) for node in tmp.node})
# topology = nx.union(topology, tmp_tree)
# # Full mesh in the core of network
# for i in range(core):
# topology.edge[i*(k**(h+1)-1)][core*(k**(h+1)-1)] = {}
# topology.edge[core*(k**(h+1)-1)][i*(k**(h+1)-1)] = {}
#
# return topology
#
#
def test_delays_constant(self):
topo = fnss.k_ary_tree_topology(3, 4)
self.assertRaises(ValueError, fnss.set_delays_constant, topo, 2, 'Km')
odd_links = [(u, v) for (u, v) in topo.edges_iter()
if (u + v) % 2 == 1]
even_links = [(u, v) for (u, v) in topo.edges_iter()
if (u + v) % 2 == 0]
fnss.set_delays_constant(topo, 2, 's', odd_links)
fnss.set_delays_constant(topo, 5000000, 'us', even_links)
self.assertEqual('s', topo.graph['delay_unit'])
self.assertTrue(all(topo.edge[u][v]['delay'] in [2, 5]
for (u, v) in topo.edges_iter()))
def topology_four_child_tree(network_cache=0.05, n_contents=100000, seed=None):
"""
Returns a tree topology
Parameters
----------
network_cache : float
Size of network cache (sum of all caches) normalized by size of content
population
n_contents : int
Size of content population
seed : int, optional
The seed used for random number generation
Returns
-------
topology : fnss.Topology
The topology object
"""
h = 5 # depth of the tree
topology = fnss.k_ary_tree_topology(4, h)
topology.add_node(1365, depth=-1)
topology.add_path([0, 1365])
receivers = [v for v in topology.nodes_iter()
if topology.node[v]['depth'] == h]
sources = [v for v in topology.nodes_iter()
if topology.node[v]['depth'] == -1]
caches = [v for v in topology.nodes_iter()
if topology.node[v]['depth'] >= 0
and topology.node[v]['depth'] < h]
# randomly allocate contents to sources
content_placement = uniform_content_placement(topology, range(1, n_contents+1), sources, seed=seed)
for v in sources:
fnss.add_stack(topology, v, 'source', {'contents': content_placement[v]})
for v in receivers:
fnss.add_stack(topology, v, 'receiver', {})
cache_placement = uniform_cache_placement(topology, network_cache*n_contents, caches)
for node, size in cache_placement.iteritems():
fnss.add_stack(topology, node, 'cache', {'size': size})
# set weights and delays on all links
fnss.set_weights_constant(topology, 1.0)
fnss.set_delays_constant(topology, INTERNAL_LINK_DELAY, 'ms')
# label links as internal or external
for u, v in topology.edges_iter():
if u in sources or v in sources:
topology.edge[u][v]['type'] = 'external'
fnss.set_delays_constant(topology, EXTERNAL_LINK_DELAY, 'ms', [(u, v)])
else:
topology.edge[u][v]['type'] = 'internal'
return topology
def topology_tree_HX(k, h, delay=1, **kwargs):
"""Returns a tree topology, with a source at the root, receivers at the
leafs and caches at all intermediate nodes.
Parameters
----------
h : int
The height of the tree
k : int
The branching factor of the tree
delay : float
The link delay in milliseconds
Returns
-------
topology : IcnTopology
The topology object
"""
topology = fnss.k_ary_tree_topology(k, h)
topology.add_path([0, 40])
topology.node[40]['depth'] = -1
receivers = [
v for v in topology.nodes_iter() if topology.node[v]['depth'] == h
]
sources = [40]
routers = [
v for v in topology.nodes_iter()
if topology.node[v]['depth'] >= 0 and topology.node[v]['depth'] < h
]
topology.graph['icr_candidates'] = set(routers)
for v in sources:
fnss.add_stack(topology, v, 'source')
for v in receivers:
fnss.add_stack(topology, v, 'receiver')
for v in routers:
fnss.add_stack(topology, v, 'router')
# set weights and delays on all links
fnss.set_weights_constant(topology, 1.0)
fnss.set_delays_constant(topology, 4, 'ms')
fnss.set_delays_constant(topology, 8, 'ms', [(0, 1), (0, 2), (0, 3),
(1, 0), (2, 0), (3, 0)])
# label links as internal
for u, v in topology.edges_iter():
if u in sources or v in sources:
topology.edge[u][v]['type'] = 'external'
else:
topology.edge[u][v]['type'] = 'internal'
return IcnTopology(topology)
def _create_topology(self, PoP, k, h):
topology = fnss.Topology()
for core in range(PoP):
tmp = fnss.k_ary_tree_topology(k, h)
for node in tmp.node:
if tmp.node[node]['type'] <> 'root':
tmp.node[node]['server'] = core * (k ** (h + 1) - 1)
tmp_tree = nx.relabel_nodes(tmp, {node: node + core * (k ** (h + 1) - 1) for node in tmp.node})
topology = nx.union(topology, tmp_tree)
# Full mesh in the core of network
for i in range(core):
topology.edge[i * (k ** (h + 1) - 1)][core * (k ** (h + 1) - 1)] = {}
topology.edge[core * (k ** (h + 1) - 1)][i * (k ** (h + 1) - 1)] = {}
return topology
def topology_tree_with_uCache(k, h, delay=1, **kwargs):
"""Returns a tree topology, with a source at the root, receivers at the
leafs and caches at the receivers and routers.
Parameters
----------
h : int
The height of the tree
k : int
The branching factor of the tree
delay : float
The link delay in milliseconds
Returns
-------
topology : IcnTopology
The topology object
"""
topology = fnss.k_ary_tree_topology(k, h)
receivers = [
v for v in topology.nodes_iter() if topology.node[v]['depth'] == h
]
sources = [
v for v in topology.nodes_iter() if topology.node[v]['depth'] == 0
]
routers = [
v for v in topology.nodes_iter()
if topology.node[v]['depth'] > 0 and topology.node[v]['depth'] < h
]
topology.graph['icr_candidates'] = set(routers)
topology.graph['uCache_candidates'] = set(receivers)
for v in sources:
fnss.add_stack(topology, v, 'source')
for v in receivers:
fnss.add_stack(topology, v, 'receiver')
for v in routers:
fnss.add_stack(topology, v, 'router')
# set weights and delays on all links
fnss.set_weights_constant(topology, 1.0)
fnss.set_delays_constant(topology, delay, 'ms')
# label links as internal
for u, v in topology.edges_iter():
topology.edge[u][v]['type'] = 'internal'
return IcnTopology(topology)
def my_topology(cls):
"""Return my topology for testing caching strategies
"""
# Topology sketch
# 0
# / \
# / \
# / \
# 1 2
# / \ / \
# 3 4 5 6
# / \ / \ / \ / \
# 7 8 9 10 11 1213 14
#
k = 2
h = 3
delay = 5
topology = IcnTopology(fnss.k_ary_tree_topology(k, h))
receivers = [
v for v in topology.nodes_iter() if topology.node[v]['depth'] == h
]
sources = [
v for v in topology.nodes_iter() if topology.node[v]['depth'] == 0
]
routers = [
v for v in topology.nodes_iter()
if topology.node[v]['depth'] > 0 and topology.node[v]['depth'] < h
]
topology.graph['icr_candidates'] = set(routers)
for v in receivers:
fnss.add_stack(topology, v, 'receiver')
for v in routers:
fnss.add_stack(topology, v, 'router', {'cache_size': 2})
contents = (1, 2, 3)
fnss.add_stack(topology, source, 'source', {'contents': contents})
# set weights and delays on all links
fnss.set_weights_constant(topology, 1.0)
fnss.set_delays_constant(topology, delay, 'ms')
fnss.set_delays_constant(topology, 20, 'ms', [(0, 1), (0, 2)])
# label links as internal
for u, v in topology.edges_iter():
topology.edge[u][v]['type'] = 'internal'
return IcnTopology(topology)
def topology_hierarchy(k, h, delay=1, **kwargs):
"""Returns a tree topology, with a source at the root, receivers at the
leafs and caches at all intermediate nodes.
Parameters
----------
h : int
The height of the tree
k : int
The branching factor of the tree
delay : float
The link delay in milliseconds
Returns
-------
topology : IcnTopology
The topology object
"""
topology = fnss.k_ary_tree_topology(k, h)
receivers = [v for v in topology.nodes()
if topology.node[v]['depth'] == h]
sources = [v for v in topology.nodes()
if topology.node[v]['depth'] == 0]
routers = [v for v in topology.nodes()
if topology.node[v]['depth'] > 0
and topology.node[v]['depth'] < h]
topology.graph['icr_candidates'] = set(routers)
for v in sources:
fnss.add_stack(topology, v, 'source')
for v in receivers:
fnss.add_stack(topology, v, 'receiver')
for v in routers:
fnss.add_stack(topology, v, 'router')
# label links as internal
for u, v in topology.edges():
topology.adj[u][v]['type'] = 'external' if u in sources or v in sources else 'internal'
# for u, v in path_links(routers):
# topology.add_edge(u, v, type='internal')
# set weights and delays on all links
fnss.set_weights_constant(topology, 1.0)
fnss.set_delays_constant(topology, delay, 'ms', [(u, v) for u, v in topology.edges() if u in receivers or v in receivers])
fnss.set_delays_constant(topology, 10*delay, 'ms', [(u, v) for u, v in topology.edges() if u in routers and v in routers])
fnss.set_delays_constant(topology, 60*delay, 'ms', [(u, v) for u, v in topology.edges() if u in sources or v in sources])
return IcnTopology(topology)
def test_K_ary_tree_connectivity(k, h):
expected_degree = {'root': k, 'intermediate': k + 1, 'leaf': 1}
G = fnss.k_ary_tree_topology(k, h)
self.assertEqual(sum(k ** d for d in range(h + 1)),
G.number_of_nodes())
self.assertEqual(sum(k ** d for d in range(1, h + 1)),
G.number_of_edges())
degree = G.degree()
for v in G.nodes():
v_type = G.node[v]['type']
v_depth = G.node[v]['depth']
self.assertEqual(expected_degree[v_type], degree[v])
neighbors = G.neighbors(v)
for u in neighbors:
u_depth = G.node[u]['depth']
if u < v:
self.assertEqual(u_depth, v_depth - 1)
elif u > v:
self.assertEqual(u_depth, v_depth + 1)
else: # u == v
self.fail("Node %s has a self-loop" % str(v))
def test_K_ary_tree_connectivity(k, h):
expected_degree = {'root': k, 'intermediate': k + 1, 'leaf': 1}
G = fnss.k_ary_tree_topology(k, h)
self.assertEquals(sum(k ** d for d in range(h + 1)),
G.number_of_nodes())
self.assertEquals(sum(k ** d for d in range(1, h + 1)),
G.number_of_edges())
degree = G.degree()
for v in G.nodes():
v_type = G.node[v]['type']
v_depth = G.node[v]['depth']
self.assertEqual(expected_degree[v_type], degree[v])
neighbors = G.neighbors(v)
for u in neighbors:
u_depth = G.node[u]['depth']
if u < v:
self.assertEqual(u_depth, v_depth - 1)
elif u > v:
self.assertEqual(u_depth, v_depth + 1)
else: # u == v
self.fail("Node %s has a self-loop" % str(v))
def topology_binary_tree(**kwargs):
"""Returns a tree topology
Parameters
----------
seed : int, optional
The seed used for random number generation
Returns
-------
topology : fnss.Topology
The topology object
"""
h = 5 # depth of the tree
topology = fnss.k_ary_tree_topology(2, h)
receivers = [v for v in topology.nodes_iter()
if topology.node[v]['depth'] == h]
sources = [v for v in topology.nodes_iter()
if topology.node[v]['depth'] == 0]
routers = [v for v in topology.nodes_iter()
if topology.node[v]['depth'] > 0
and topology.node[v]['depth'] < h]
topology.graph['icr_candidates'] = set(routers)
for v in sources:
fnss.add_stack(topology, v, 'source')
for v in receivers:
fnss.add_stack(topology, v, 'receiver')
for v in routers:
fnss.add_stack(topology, v, 'router')
# set weights and delays on all links
fnss.set_weights_constant(topology, 1.0)
fnss.set_delays_constant(topology, INTERNAL_LINK_DELAY, 'ms')
# label links as internal or external
for u, v in topology.edges_iter():
if u in sources or v in sources:
topology.edge[u][v]['type'] = 'external'
fnss.set_delays_constant(topology, EXTERNAL_LINK_DELAY, 'ms', [(u, v)])
else:
topology.edge[u][v]['type'] = 'internal'
return IcnTopology(topology)
def topology_tree(k, h, delay=1, **kwargs):
"""Returns a tree topology, with a source at the root, receivers at the
leafs and caches at all intermediate nodes.
Parameters
----------
h : height
The height of the tree
k : branching factor
The branching factor of the tree
delay : float
The link delay in milliseconds
Returns
-------
topology : IcnTopology
The topology object
"""
topology = fnss.k_ary_tree_topology(k, h)
receivers = [v for v in topology.nodes_iter()
if topology.node[v]['depth'] == h]
sources = [v for v in topology.nodes_iter()
if topology.node[v]['depth'] == 0]
routers = [v for v in topology.nodes_iter()
if topology.node[v]['depth'] > 0
and topology.node[v]['depth'] < h]
topology.graph['icr_candidates'] = set(routers)
for v in sources:
fnss.add_stack(topology, v, 'source')
for v in receivers:
fnss.add_stack(topology, v, 'receiver')
for v in routers:
fnss.add_stack(topology, v, 'router')
# set weights and delays on all links
fnss.set_weights_constant(topology, 1.0)
fnss.set_delays_constant(topology, delay, 'ms')
# label links as internal
for u, v in topology.edges_iter():
topology.edge[u][v]['type'] = 'internal'
return IcnTopology(topology)
def topology_tree(k, h, delay=1, **kwargs):
"""Returns a tree topology, with a source at the root, receivers at the
leafs and caches at all intermediate nodes.
Parameters
----------
h : int
The height of the tree
k : int
The branching factor of the tree
delay : float
The link delay in milliseconds
Returns
-------
topology : IcnTopology
The topology object
"""
topology = fnss.k_ary_tree_topology(k, h)
receivers = [v for v in topology.nodes() if topology.node[v]["depth"] == h]
sources = [v for v in topology.nodes() if topology.node[v]["depth"] == 0]
routers = [
v for v in topology.nodes()
if topology.node[v]["depth"] > 0 and topology.node[v]["depth"] < h
]
topology.graph["icr_candidates"] = set(routers)
for v in sources:
fnss.add_stack(topology, v, "source")
for v in receivers:
fnss.add_stack(topology, v, "receiver")
for v in routers:
fnss.add_stack(topology, v, "router")
# set weights and delays on all links
fnss.set_weights_constant(topology, 1.0)
fnss.set_delays_constant(topology, delay, "ms")
# label links as internal
for u, v in topology.edges():
topology.adj[u][v]["type"] = "internal"
return IcnTopology(topology)
def topology_repo_tree(k, h, delay=0.020, **kwargs):
"""
Returns a tree topology, with sources (and EDRs) at the root,
receivers at the leaves and EDRs at all intermediate nodes.
Parameters
----------
h : int
The height of the tree
k : int
The branching factor of the tree
delay : float
The link delay in milliseconds
Returns
-------
topology : IcnTopology
The topology object
"""
receiver_access_delay = 0.001
topology = fnss.k_ary_tree_topology(k, h)
topology.graph['parent'] = [None for x in range(pow(k, h + 1) - 1)]
for u, v in topology.edges():
if topology.node[u]['depth'] > topology.node[v]['depth']:
topology.graph['parent'][u] = v
else:
topology.graph['parent'][v] = u
topology.edges[u, v]['type'] = 'internal'
if u is 0 or v is 0:
topology.edges[u, v]['delay'] = delay
print("Edge between " + repr(u) + " and " + repr(v) + " delay: " +
repr(topology.edges[u, v]['delay']))
else:
topology.edges[u, v]['delay'] = delay
print("Edge between " + repr(u) + " and " + repr(v) + " delay: " +
repr(topology.edges[u, v]['delay']))
for v in topology.nodes():
print("Depth of " + repr(v) + " is " + repr(topology.node[v]['depth']))
# set weights and delays on all links
fnss.set_weights_constant(topology, 1.0)
# fnss.set_delays_constant(topology, delay, 'ms')
routers = topology.nodes()
# TODO: Add set of sources to ICR candidates and account for them as routers, as well as sources.
topology.graph['icr_candidates'] = set(routers)
topology.graph['type'] = 'TREE'
topology.graph['height'] = h
topology.graph['link_delay'] = delay
topology.graph['receiver_access_delay'] = receiver_access_delay
edge_routers = [
v for v in topology.nodes() if topology.node[v]['depth'] == h
]
root = [v for v in topology.nodes() if topology.node[v]['depth'] == 0]
# routers = [v for v in topology.nodes()
# if topology.node[v]['depth'] > 0
# and topology.node[v]['depth'] < h]
# TODO: THIS REALLY HAS TO BE CHANGED! NOT ALL RECEIVERS SHOULD BE AT THE EDGE!
# (I would argue that only a few should be, at most)
n_receivers = len(edge_routers)
receivers = ['rec_%d' % i for i in range(n_receivers)]
for i in range(n_receivers):
topology.add_edge(receivers[i],
edge_routers[i],
delay=receiver_access_delay,
type='internal')
n_sources = len(root)
sources = ['src_%d' % i for i in range(n_sources)]
for i in range(n_sources):
topology.add_edge(sources[i],
root[0],
delay=3 * delay,
type='internal')
print("The number of sources: " + repr(n_sources))
print("The number of receivers: " + repr(n_receivers))
topology.graph['receiver_access_delay'] = receiver_access_delay
topology.graph['link_delay'] = delay
topology.graph['depth'] = h
for v in routers:
fnss.add_stack(topology, v, 'router')
if 'source' not in topology.node[v]['stack']:
try:
if topology.node[v]['type'] == 'leaf':
try:
topology.node[v]['extra_types'].append('source')
topology.node[v]['extra_types'].append('router')
except Exception as e:
err_type = str(type(e)).split("'")[1].split(".")[1]
if err_type == "KeyError":
topology.node[v].update(extra_types=['source'])
topology.node[v]['extra_types'].append('router')
except Exception as e:
err_type = str(type(e)).split("'")[1].split(".")[1]
if err_type == "KeyError":
continue
for v in sources:
fnss.add_stack(topology, v, 'source')
for v in receivers:
fnss.add_stack(topology, v, 'receiver')
# label links as internal
topology.graph['receivers'] = receivers
topology.graph['sources'] = sources
topology.graph['sources'].extend(routers)
topology.graph['sources'].extend(edge_routers)
topology.graph['routers'] = routers
topology.graph['edge_routers'] = edge_routers
return IcnTopology(topology)
def topology_tree(k, h, delay=0.005, **kwargs):
"""Returns a tree topology, with a source at the root, receivers at the
leafs and caches at all intermediate nodes.
Parameters
----------
h : int
The height of the tree
k : int
The branching factor of the tree
delay : float
The link delay in milliseconds
Returns
-------
topology : IcnTopology
The topology object
"""
topology = fnss.k_ary_tree_topology(k, h)
for u, v in topology.edges_iter():
topology.edge[u][v]['type'] = 'internal'
if u is 0 or v is 0:
topology.edge[u][v]['delay'] = 3*delay
#print "Edge between " + repr(u) + " and " + repr(v) + " delay: " + repr(topology.edge[u][v]['delay'])
else:
topology.edge[u][v]['delay'] = delay
#print "Edge between " + repr(u) + " and " + repr(v) + " delay: " + repr(topology.edge[u][v]['delay'])
#for v in topology.nodes_iter():
# print "Depth of " + repr(v) + " is " + repr(topology.node[v]['depth'])
# set weights and delays on all links
fnss.set_weights_constant(topology, 1.0)
#fnss.set_delays_constant(topology, delay, 'ms')
routers = topology.nodes()
edge_routers = [v for v in topology.nodes_iter()
if topology.node[v]['depth'] == h]
#topology.graph['icr_candidates'] = (set(routers)).difference(set(edge_routers))
topology.graph['icr_candidates'] = set(routers)
root = [v for v in topology.nodes_iter()
if topology.node[v]['depth'] == 0]
#routers = [v for v in topology.nodes_iter()
# if topology.node[v]['depth'] > 0
# and topology.node[v]['depth'] < h]
n_sources = len(edge_routers)
sources = ['src_%d' % i for i in range(n_sources)]
for i in range(n_sources):
topology.add_edge(sources[i], edge_routers[i], delay=0.002, type='internal')
n_receivers = len(root)
receivers = ['rec_%d' % i for i in range(n_receivers)]
for i in range(n_receivers):
topology.add_edge(receivers[i], root[0], delay=0.002, type='internal')
for v in sources:
fnss.add_stack(topology, v, 'source')
for v in receivers:
fnss.add_stack(topology, v, 'receiver')
for v in routers:
fnss.add_stack(topology, v, 'router')
# label links as internal
return IcnTopology(topology)
def topology_mytree_fat(k, h, delay=1, **kwargs):
"""Returns a tree topology, with a source at the root, receivers at the
leafs and caches at all intermediate nodes.
Parameters
----------
h : int
The height of the tree
k : int
The branching factor of the tree
delay : float
The link delay in milliseconds
Returns
-------
topology : IcnTopology
The topology object
"""
topology = fnss.k_ary_tree_topology(k, h)
receivers = [
v for v in topology.nodes_iter() if topology.node[v]['depth'] == h
]
sources = [
v for v in topology.nodes_iter() if topology.node[v]['depth'] == 0
]
routers = [
v for v in topology.nodes_iter()
if topology.node[v]['depth'] > 0 and topology.node[v]['depth'] < h
]
topology.graph['icr_candidates'] = set(routers)
for v in sources:
fnss.add_stack(topology, v, 'source')
for v in receivers:
fnss.add_stack(topology, v, 'receiver')
for v in routers:
fnss.add_stack(topology, v, 'router')
# set weights and delays on all links
fnss.set_weights_constant(topology, 1.0)
fnss.set_delays_constant(topology, 1, 'ms')
set1 = []
set2 = []
set3 = []
for i in range(1, 4):
set1.append((0, i))
set1.append((i, 0))
for i in range(1, k + 1):
for j in range(i * k + 1, (i + 1) * k + 1):
set2.append((i, j))
set2.append((j, i))
for i in range(1, k + 1):
for j in range(i * k + 1, (i + 1) * k + 1):
for m in range(j * k + 1, (j + 1) * k + 1):
set3.append(m, j)
set3.append(j, m)
fnss.set_delays_constant(topology, 1, 'ms', set3)
fnss.set_delays_constant(topology, 2, 'ms', set2)
fnss.set_delays_constant(topology, 4, 'ms', set1)
# label links as internal
for u, v in topology.edges_iter():
topology.edge[u][v]['type'] = 'internal'
return IcnTopology(topology)
def topology_tree(k, h, delay=0.020, **kwargs):
"""Returns a tree topology, with a source at the root, receivers at the
leafs and caches at all intermediate nodes.
Parameters
----------
h : int
The height of the tree
k : int
The branching factor of the tree
delay : float
The link delay in milliseconds
Returns
-------
topology : IcnTopology
The topology object
"""
receiver_access_delay = 0.001
topology = fnss.k_ary_tree_topology(k, h)
topology.graph['parent'] = [None for x in range(pow(k, h + 1) - 1)]
for u, v in topology.edges_iter():
if topology.node[u]['depth'] > topology.node[v]['depth']:
topology.graph['parent'][u] = v
else:
topology.graph['parent'][v] = u
topology.edge[u][v]['type'] = 'internal'
if u is 0 or v is 0:
topology.edge[u][v]['delay'] = delay
print "Edge between " + repr(u) + " and " + repr(
v) + " delay: " + repr(topology.edge[u][v]['delay'])
else:
topology.edge[u][v]['delay'] = delay
print "Edge between " + repr(u) + " and " + repr(
v) + " delay: " + repr(topology.edge[u][v]['delay'])
for v in topology.nodes_iter():
print "Depth of " + repr(v) + " is " + repr(topology.node[v]['depth'])
# set weights and delays on all links
fnss.set_weights_constant(topology, 1.0)
#fnss.set_delays_constant(topology, delay, 'ms')
routers = topology.nodes()
topology.graph['icr_candidates'] = set(routers)
topology.graph['type'] = 'TREE'
topology.graph['height'] = h
topology.graph['link_delay'] = delay
topology.graph['receiver_access_delay'] = receiver_access_delay
edge_routers = [
v for v in topology.nodes_iter() if topology.node[v]['depth'] == h
]
root = [v for v in topology.nodes_iter() if topology.node[v]['depth'] == 0]
#routers = [v for v in topology.nodes_iter()
# if topology.node[v]['depth'] > 0
# and topology.node[v]['depth'] < h]
n_receivers = len(edge_routers)
receivers = ['rec_%d' % i for i in range(n_receivers)]
for i in range(n_receivers):
topology.add_edge(receivers[i],
edge_routers[i],
delay=receiver_access_delay,
type='internal')
n_sources = len(root)
sources = ['src_%d' % i for i in range(n_sources)]
for i in range(n_sources):
topology.add_edge(sources[i],
root[0],
delay=3 * delay,
type='internal')
print "The number of sources: " + repr(n_sources)
print "The number of receivers: " + repr(n_receivers)
topology.graph['receiver_access_delay'] = receiver_access_delay
topology.graph['link_delay'] = delay
topology.graph['depth'] = h
for v in sources:
fnss.add_stack(topology, v, 'source')
for v in receivers:
fnss.add_stack(topology, v, 'receiver')
for v in routers:
fnss.add_stack(topology, v, 'router')
# label links as internal
topology.graph['receivers'] = receivers
topology.graph['sources'] = sources
topology.graph['routers'] = routers
topology.graph['edge_routers'] = edge_routers
return IcnTopology(topology)
def topology_tree_with_varying_delays(k,
h,
delay=EXTERNAL_LINK_DELAY / 1000,
n_classes=10,
min_delay=INTERNAL_LINK_DELAY / 1000,
max_delay=EXTERNAL_LINK_DELAY / 1000,
**kwargs):
"""Returns a tree topology, with a source at the root, receivers at the
leafs and caches at all intermediate nodes.
Parameters
----------
h : int
The height of the tree
k : int
The branching factor of the tree
delay : float
The link delay in milliseconds
Returns
-------
topology : IcnTopology
The topology object
"""
random.seed(0)
topology = fnss.k_ary_tree_topology(k, h)
# set weights and delays on all links
fnss.set_weights_constant(topology, 1.0)
fnss.set_delays_constant(topology, delay, 'ms')
topology.graph['type'] = "TREE_WITH_VARYING_DELAYS"
topology.graph['parent'] = [None for x in range(pow(k, h + 1) - 1)]
for u, v in topology.edges_iter():
if topology.node[u]['depth'] > topology.node[v]['depth']:
topology.graph['parent'][u] = v
else:
topology.graph['parent'][v] = u
topology.edge[u][v]['type'] = 'internal'
#random_delay = random.uniform(min_delay, max_delay)
random_delay = random.uniform(max_delay - 0.003, max_delay + 0.003)
if u is 0 or v is 0:
topology.edge[u][v]['delay'] = random_delay
print "Edge between " + repr(u) + " and " + repr(
v) + " delay: " + repr(topology.edge[u][v]['delay'])
else:
topology.edge[u][v]['delay'] = 2 * random_delay
print "Edge between " + repr(u) + " and " + repr(
v) + " delay: " + repr(topology.edge[u][v]['delay'])
for v in topology.nodes_iter():
print "Depth of " + repr(v) + " is " + repr(topology.node[v]['depth'])
routers = topology.nodes()
topology.graph['icr_candidates'] = set(routers)
topology.graph['n_classes'] = n_classes
topology.graph['max_delay'] = 0.0 #[0.0]*n_classes
topology.graph['min_delay'] = float('inf') #[0.0]*n_classes
topology.graph['height'] = h
topology.graph['link_delay'] = delay
edge_routers = [
v for v in topology.nodes_iter() if topology.node[v]['depth'] == h
]
root = [v for v in topology.nodes_iter() if topology.node[v]['depth'] == 0]
#routers = [v for v in topology.nodes_iter()
# if topology.node[v]['depth'] > 0
# and topology.node[v]['depth'] < h]
n_receivers = len(edge_routers) * n_classes
receivers = ['rec_%d' % i for i in range(n_receivers)]
topology.graph['n_edgeRouters'] = len(edge_routers)
delays = [None] * n_classes
for i in range(n_classes):
random_delay = random.uniform(min_delay, max_delay)
delays[i] = random_delay
receiver_indx = 0
for edge_router in edge_routers:
for j in range(n_classes):
d = delays[j]
topology.add_edge(receivers[receiver_indx],
edge_router,
delay=d,
type='internal')
receiver_indx += 1
n_sources = len(root)
sources = ['src_%d' % i for i in range(n_sources)]
for i in range(n_sources):
topology.add_edge(sources[i], root[0], delay=delay, type='internal')
print "The number of sources: " + repr(n_sources)
print "The number of receivers: " + repr(n_receivers)
for v in sources:
fnss.add_stack(topology, v, 'source')
for v in receivers:
fnss.add_stack(topology, v, 'receiver')
for v in routers:
fnss.add_stack(topology, v, 'router')
for v in topology.nodes_iter():
if 'depth' in topology.node[v].keys():
print "Depth of " + repr(v) + " is " + repr(
topology.node[v]['depth'])
topology.graph['receivers'] = receivers
topology.graph['sources'] = sources
topology.graph['routers'] = routers
topology.graph['edge_routers'] = edge_routers
# label links as internal
return IcnTopology(topology)
