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)