def test_static_traffic_matrix_parallel(self): # If number of edges is greater than 100, computation is parallelized G = fnss.full_mesh_topology(15) fnss.set_capacities_constant(G, 10, capacity_unit='Mbps') tm = fnss.static_traffic_matrix(G, 10, 8, max_u=0.9) self.assertAlmostEqual(0.9, max(fnss.link_loads(G, tm).values())) self.assertLessEqual(0, min(fnss.link_loads(G, tm).values()))
def test_to_omnetpp_directed(self): t = fnss.DirectedTopology() t.add_path([1, 2, 3, 4]) fnss.set_capacities_constant(t, 10, 'Gbps') fnss.set_delays_constant(t, 2, 'us') fnss.set_buffer_sizes_constant(t, 20, 'packets') fnss.to_omnetpp(t, path.join(TMP_DIR, 'omnetpp-dir.ned'))
def test_to_ns2_directed(self): t = fnss.DirectedTopology() t.add_path([1, 2, 3, 4]) fnss.set_capacities_constant(t, 10, 'Gbps') fnss.set_delays_constant(t, 2, 'us') fnss.set_buffer_sizes_constant(t, 20, 'packets') fnss.to_ns2(t, path.join(TMP_DIR, 'ns2-dir.tcl'), stacks=False)
def test_to_mininet(self): t = fnss.Topology() t.add_path([1, 2, 3, 4]) for n in (1, 4): t.node[n]['type'] = 'host' for n in (2, 3): t.node[n]['type'] = 'switch' fnss.set_capacities_constant(t, 10, 'Mbps') fnss.set_delays_constant(t, 10, 'ms') mn_topo = fnss.to_mininet(t, relabel_nodes=False) self.assertIsNotNone(mn_topo) hosts = mn_topo.hosts() switches = mn_topo.switches() for h in '1', '4': self.assertIn(h, hosts) for s in '2', '3': self.assertIn(s, switches) mn_topo = fnss.to_mininet(t, relabel_nodes=True) # Relabeling should be: # 1 -> h1 # 2 -> s1 # 3 -> s2 # 4 -> h2 self.assertIsNotNone(mn_topo) hosts = mn_topo.hosts() switches = mn_topo.switches() for h in 'h1', 'h2': self.assertIn(h, hosts) for s in 's1', 's2': self.assertIn(s, switches)
def test_to_ns2_directed(self): t = fnss.DirectedTopology() t.add_path([1,2,3,4]) fnss.set_capacities_constant(t, 10, 'Gbps') fnss.set_delays_constant(t, 2, 'us') fnss.set_buffer_sizes_constant(t, 20, 'packets') fnss.to_ns2(t, path.join(TMP_DIR,'ns2-dir.tcl'), stacks=False)
def test_buffer_sizes_bw_delay_prod_no_return_path(self): topo = fnss.DirectedTopology() topo.add_edge(1, 2, weight=1) topo.add_edge(1, 3, weight=1) topo.add_edge(3, 2, weight=1) fnss.set_capacities_constant(topo, 10) fnss.set_delays_constant(topo, 2) self.assertRaises(ValueError, fnss.set_buffer_sizes_bw_delay_prod, topo)
def test_link_loads_ecmp(self): topo = fnss.ring_topology(5) topo.add_edge(1, 3) fnss.set_capacities_constant(topo, 100, capacity_unit='Mbps') tm = fnss.TrafficMatrix(volume_unit='Mbps') tm.add_flow(0, 1, 20) tm.add_flow(1, 0, 30) tm.add_flow(0, 2, 40) tm.add_flow(1, 4, 70) rm = { 0: { 0: [[0]], 1: [[0, 1]], 2: [[0, 1, 2]], 3: [[0, 1, 3], [0, 4, 3]], 4: [[0, 4]] }, 1: { 0: [[1, 0]], 1: [[1]], 2: [[1, 2]], 3: [[1, 3]], 4: [[1, 3, 4], [1, 0, 4]] }, 2: { 0: [[2, 1, 0]], 1: [[2, 1]], 2: [[2]], 3: [[2, 3]], 4: [[2, 3, 4]] }, 3: { 0: [[3, 1, 0], [3, 4, 0]], 1: [[3, 1]], 2: [[3, 2]], 3: [[3]], 4: [[3, 4]] }, 4: { 0: [[4, 0]], 1: [[4, 0, 1], [4, 3, 1]], 2: [[4, 3, 2]], 3: [[4, 3]], 4: [[4]] } } load = fnss.link_loads(topo, tm, routing_matrix=rm, ecmp=True) self.assertAlmostEqual(0.6, load[(0, 1)]) self.assertAlmostEqual(0.65, load[(1, 0)]) self.assertAlmostEqual(0.4, load[(1, 2)]) self.assertAlmostEqual(0.0, load[(2, 1)]) self.assertAlmostEqual(0.35, load[(0, 4)]) self.assertAlmostEqual(0.35, load[(3, 4)]) self.assertAlmostEqual(0.0, load[(4, 3)]) self.assertAlmostEqual(0.0, load[(4, 0)]) self.assertAlmostEqual(0.0, load[(2, 1)]) self.assertAlmostEqual(0.0, load[(2, 3)])
def test_validate_traffic_matrix_diff_units(self): topo = fnss.line_topology(2) fnss.set_capacities_constant(topo, 1, capacity_unit='Gbps') valid_tm = fnss.TrafficMatrix(volume_unit='Mbps') valid_tm.add_flow(0, 1, 999) self.assertTrue(fnss.validate_traffic_matrix(topo, valid_tm, validate_load=True)) invalid_tm = fnss.TrafficMatrix(volume_unit='Mbps') invalid_tm.add_flow(0, 1, 1001) self.assertFalse(fnss.validate_traffic_matrix(topo, invalid_tm, validate_load=True))
def test_link_loads_ecmp(self): topo = fnss.ring_topology(5) topo.add_edge(1, 3) fnss.set_capacities_constant(topo, 100, capacity_unit='Mbps') tm = fnss.TrafficMatrix(volume_unit='Mbps') tm.add_flow(0, 1, 20) tm.add_flow(1, 0, 30) tm.add_flow(0, 2, 40) tm.add_flow(1, 4, 70) rm = {0 : { 0: [[0]], 1: [[0, 1]], 2: [[0, 1, 2]], 3: [[0, 1, 3], [0, 4, 3]], 4: [[0, 4]] }, 1 : { 0: [[1, 0]], 1: [[1]], 2: [[1, 2]], 3: [[1, 3]], 4: [[1, 3, 4], [1, 0, 4]] }, 2 : { 0: [[2, 1, 0]], 1: [[2, 1]], 2: [[2]], 3: [[2, 3]], 4: [[2, 3, 4]] }, 3 : { 0: [[3, 1, 0], [3, 4, 0]], 1: [[3, 1]], 2: [[3, 2]], 3: [[3]], 4: [[3, 4]] }, 4 : { 0: [[4, 0]], 1: [[4, 0, 1], [4, 3, 1]], 2: [[4, 3, 2]], 3: [[4, 3]], 4: [[4]] }} load = fnss.link_loads(topo, tm, routing_matrix=rm, ecmp=True) self.assertAlmostEqual(0.6, load[(0, 1)]) self.assertAlmostEqual(0.65, load[(1, 0)]) self.assertAlmostEqual(0.4, load[(1, 2)]) self.assertAlmostEqual(0.0, load[(2, 1)]) self.assertAlmostEqual(0.35, load[(0, 4)]) self.assertAlmostEqual(0.35, load[(3, 4)]) self.assertAlmostEqual(0.0, load[(4, 3)]) self.assertAlmostEqual(0.0, load[(4, 0)]) self.assertAlmostEqual(0.0, load[(2, 1)]) self.assertAlmostEqual(0.0, load[(2, 3)])
def test_capacities_constant(self): odd_links = [(u, v) for (u, v) in self.topo.edges() if (u + v) % 2 == 1] even_links = [(u, v) for (u, v) in self.topo.edges() if (u + v) % 2 == 0] fnss.set_capacities_constant(self.topo, 2, 'Mbps', odd_links) fnss.set_capacities_constant(self.topo, 5000, 'Kbps', even_links) self.assertEqual('Mbps', self.topo.graph['capacity_unit']) self.assertTrue(all(self.topo.edge[u][v]['capacity'] in [2, 5] for (u, v) in self.topo.edges_iter()))
def test_buffer_sizes_bw_delay_prod_unused_links(self): topo = fnss.Topology() topo.add_edge(1, 2, weight=100) topo.add_edge(2, 3, weight=1) topo.add_edge(3, 1, weight=1) fnss.set_capacities_constant(topo, 10) fnss.set_delays_constant(topo, 2) fnss.set_buffer_sizes_bw_delay_prod(topo) self.assertTrue(all((topo.adj[u][v]['buffer'] is not None for (u, v) in topo.edges())))
def test_fan_in_out_capacities_directed(self): dir_topology = fnss.DirectedTopology() dir_topology.add_edge(0, 1) dir_topology.add_edge(1, 0) dir_topology.add_edge(1, 2) dir_topology.add_edge(3, 2) fnss.set_capacities_constant(dir_topology, 10, 'Mbps') in_cap, out_cap = fnss.fan_in_out_capacities(dir_topology) self.assertEqual({0: 10, 1: 10, 2: 20, 3: 0}, in_cap) self.assertEqual({0: 10, 1: 20, 2: 0, 3: 10}, out_cap)
def test_fan_in_out_capacities_directed(self): dir_topology = fnss.DirectedTopology() dir_topology.add_edge(0, 1) dir_topology.add_edge(1, 0) dir_topology.add_edge(1, 2) dir_topology.add_edge(3, 2) fnss.set_capacities_constant(dir_topology, 10, 'Mbps') in_cap, out_cap = fnss.fan_in_out_capacities(dir_topology) self.assertEquals({0: 10, 1: 10, 2: 20, 3: 0}, in_cap) self.assertEquals({0: 10, 1: 20, 2: 0, 3: 10}, out_cap)
def test_buffers_size_link_bandwidth_default_size(self): topo = fnss.line_topology(4) fnss.set_capacities_constant(topo, 8, 'Mbps', [(0, 1)]) fnss.set_capacities_constant(topo, 16, 'Mbps', [(1, 2)]) fnss.set_buffer_sizes_link_bandwidth(topo, buffer_unit='bytes', default_size=10) self.assertEquals(topo.graph['buffer_unit'], 'bytes') self.assertEquals(topo.adj[0][1]['buffer'], 1000000) self.assertEquals(topo.adj[1][2]['buffer'], 2000000) self.assertEquals(topo.adj[2][3]['buffer'], 10) fnss.clear_buffer_sizes(topo) self.assertTrue('capacity' not in topo.adj[2][3]) self.assertRaises(ValueError, fnss.set_buffer_sizes_link_bandwidth, topo)
def test_validate_traffic_matrix(self): topology = fnss.DirectedTopology() topology.add_path([1, 2, 3]) topology.add_path([3, 2, 1]) topology.add_edge(3, 4) fnss.set_capacities_constant(topology, 1, 'Mbps') flows_valid_load = {1: {3: 0.4}, 2: {4: 0.3}} flows_invalid_load = {1: {3: 0.4}, 2: {4: 0.7}} flows_invalid_routes = {4: {1: 0.4}} flows_invalid_pairs = {5: {2: 0.1}} self.assertTrue( fnss.validate_traffic_matrix(topology, fnss.TrafficMatrix( 'Mbps', flows_valid_load), validate_load=False)) self.assertTrue( fnss.validate_traffic_matrix(topology, fnss.TrafficMatrix( 'Mbps', flows_valid_load), validate_load=True)) self.assertTrue( fnss.validate_traffic_matrix(topology, fnss.TrafficMatrix( 'Mbps', flows_invalid_load), validate_load=False)) self.assertFalse( fnss.validate_traffic_matrix(topology, fnss.TrafficMatrix( 'Mbps', flows_invalid_load), validate_load=True)) self.assertFalse( fnss.validate_traffic_matrix(topology, fnss.TrafficMatrix( 'Mbps', flows_invalid_routes), validate_load=False)) self.assertFalse( fnss.validate_traffic_matrix(topology, fnss.TrafficMatrix( 'Mbps', flows_invalid_routes), validate_load=True)) self.assertFalse( fnss.validate_traffic_matrix(topology, fnss.TrafficMatrix( 'Mbps', flows_invalid_pairs), validate_load=False)) self.assertFalse( fnss.validate_traffic_matrix(topology, fnss.TrafficMatrix( 'Mbps', flows_invalid_pairs), validate_load=True))
def test_link_loads(self): topo = fnss.ring_topology(5) fnss.set_capacities_constant(topo, 100, capacity_unit='Mbps') tm = fnss.TrafficMatrix(volume_unit='Mbps') tm.add_flow(0, 1, 20) tm.add_flow(1, 0, 30) tm.add_flow(0, 2, 40) tm.add_flow(1, 4, 70) tm.add_flow(4, 2, 50) load = fnss.link_loads(topo, tm) self.assertAlmostEqual(0.6, load[(0, 1)]) self.assertAlmostEqual(1.0, load[(1, 0)]) self.assertAlmostEqual(0.4, load[(1, 2)]) self.assertAlmostEqual(0.0, load[(2, 1)]) self.assertAlmostEqual(0.7, load[(0, 4)]) self.assertAlmostEqual(0.5, load[(4, 3)])
def test_to_mininet(self): t = fnss.Topology() t.add_path([1, 2, 3, 4]) for n in (1, 4): t.node[n]['type'] = 'host' for n in (2, 3): t.node[n]['type'] = 'switch' fnss.set_capacities_constant(t, 10, 'Mbps') fnss.set_delays_constant(t, 10, 'ms') mn_topo = fnss.to_mininet(t) self.assertIsNotNone(mn_topo) hosts = mn_topo.hosts() switches = mn_topo.switches() for h in '1', '4': self.assertIn(h, hosts) for s in '2', '3': self.assertIn(s, switches)
def test_validate_traffic_matrix(self): topology = fnss.DirectedTopology() topology.add_path([1, 2, 3]) topology.add_path([3, 2, 1]) topology.add_edge(3, 4) fnss.set_capacities_constant(topology, 1, 'Mbps') flows_valid_load = {1: {3: 0.4}, 2: {4: 0.3}} flows_invalid_load = {1: {3: 0.4}, 2: {4: 0.7}} flows_invalid_routes = {4: {1: 0.4}} flows_invalid_pairs = {5: {2: 0.1}} self.assertTrue(fnss.validate_traffic_matrix(topology, fnss.TrafficMatrix('Mbps', flows_valid_load), validate_load=False)) self.assertTrue(fnss.validate_traffic_matrix(topology, fnss.TrafficMatrix('Mbps', flows_valid_load), validate_load=True)) self.assertTrue(fnss.validate_traffic_matrix(topology, fnss.TrafficMatrix('Mbps', flows_invalid_load), validate_load=False)) self.assertFalse(fnss.validate_traffic_matrix(topology, fnss.TrafficMatrix('Mbps', flows_invalid_load), validate_load=True)) self.assertFalse(fnss.validate_traffic_matrix(topology, fnss.TrafficMatrix('Mbps', flows_invalid_routes), validate_load=False)) self.assertFalse(fnss.validate_traffic_matrix(topology, fnss.TrafficMatrix('Mbps', flows_invalid_routes), validate_load=True)) self.assertFalse(fnss.validate_traffic_matrix(topology, fnss.TrafficMatrix('Mbps', flows_invalid_pairs), validate_load=False)) self.assertFalse(fnss.validate_traffic_matrix(topology, fnss.TrafficMatrix('Mbps', flows_invalid_pairs), validate_load=True))
def test_base_topology_class(self): weight = 2 capacity = 3 delay = 4 buffer_size = 5 topology = fnss.Topology() topology.add_path([1, 2, 3]) fnss.set_weights_constant(topology, weight) fnss.set_capacities_constant(topology, capacity) fnss.set_delays_constant(topology, delay) fnss.set_buffer_sizes_constant(topology, buffer_size) weights = topology.weights() capacities = topology.capacities() delays = topology.delays() buffer_sizes = topology.buffers() for e in topology.edges_iter(): self.assertEqual(weight, weights[e]) self.assertEqual(capacity, capacities[e]) self.assertEqual(delay, delays[e]) self.assertEqual(buffer_size, buffer_sizes[e])
def test_base_topology_class(self): weight = 2 capacity = 3 delay = 4 buffer_size = 5 topology = fnss.Topology() topology.add_path([1, 2, 3]) fnss.set_weights_constant(topology, weight) fnss.set_capacities_constant(topology, capacity) fnss.set_delays_constant(topology, delay) fnss.set_buffer_sizes_constant(topology, buffer_size) weights = topology.weights() capacities = topology.capacities() delays = topology.delays() buffer_sizes = topology.buffers() for e in topology.edges(): self.assertEqual(weight, weights[e]) self.assertEqual(capacity, capacities[e]) self.assertEqual(delay, delays[e]) self.assertEqual(buffer_size, buffer_sizes[e])
# this return a dictionary of egdes and value of attribute type # This function is provided by the NetworkX library. # Since FNSS Topology and DirecteedTopology objects inherit from NetworkX's # Graph and DiGraph, respectively, NetworkX functions can be used in FNSS too. link_types = nx.get_edge_attributes(topology, 'type') core_links = [links for links in link_types if link_types[links] == 'core'] edge_links = [links for links in link_types if link_types[links] == 'right_bell' or link_types[links] == 'left_bell'] # set delay equal to 1 ms in edge links and equal to 2 ms in core links fnss.set_delays_constant(topology, 1, 'ms', edge_links) fnss.set_delays_constant(topology, 2, 'ms', core_links) # set capacity of 10 Mbps in edge links and 40 Mbps in core links fnss.set_capacities_constant(topology, 10, 'Mbps', edge_links) fnss.set_capacities_constant(topology, 40, 'Mbps', core_links) # Now we deploy a traffic sources on right bell and traffic receivers on left # bell node_types = nx.get_node_attributes(topology, 'type') left_nodes = [nodes for nodes in node_types if node_types[nodes] == 'left_bell'] right_nodes = [nodes for nodes in node_types if node_types[nodes] == 'right_bell'] for node in left_nodes: fnss.add_application(topology, node, 'receiver', {}) for node in right_nodes: fnss.add_application(topology, node, 'source', {})
def test_fan_in_out_capacities_undirected(self): topology = fnss.star_topology(3) fnss.set_capacities_constant(topology, 10, 'Mbps') in_cap, out_cap = fnss.fan_in_out_capacities(topology) self.assertEquals({0: 30, 1: 10, 2: 10, 3: 10}, in_cap) self.assertEquals(in_cap, out_cap)
from mininet.net import Mininet from mininet.link import TCLink from mininet.util import dumpNodeConnections from mininet.log import setLogLevel from mininet.node import RemoteController from mininet.cli import CLI # Create FNSS topology. Let's create a simple datacenter topology # This topology does not contain loops. If you want to use a topology with # loops or multiple paths in Mininet you need to use a custom controller. # More info here: # https://github.com/mininet/mininet/wiki/Introduction-to-Mininet#multipath-routing fnss_topo = fnss.two_tier_topology(n_core=1, n_edge=2, n_hosts=2) # Set link attributes fnss.set_capacities_constant(fnss_topo, 10, 'Mbps') fnss.set_delays_constant(fnss_topo, 2, 'ms') fnss.set_buffer_sizes_constant(fnss_topo, 50, 'packets') # Convert FNSS topology to Mininet # If argument relabel_nodes is set to False, node labels are not changed when # converting an FNSS topology to a Mininet one, except converting the type to # string (e.g. 1 -> '1'). If relabel_nodes is set to True (default option) # then nodes are label according to Mininet conventions, e.g. hosts are # prepended an h (e.g. 1 -> 'h1') and switches are prepended an s # (e.g. 2 -> 's2') mn_topo = fnss.to_mininet(fnss_topo, relabel_nodes=True) # Create a Mininet instance and start it # Use TCLink to implement links enables Linux Traffic Container (TC) for rate # limitation
def build_topology(): # We use fat tree topology for datacenters kval = 0 edgeLinkCapacity = [10, 'Mbps'] aggrLinkCapacity = [100,'Mbps'] coreLinkCapacity = [1, 'Gbps'] linkDelay = [10, 'ns'] # Get the value from the network.config file lines = open('./network.config', 'r').readlines() for line in lines: val = line.split() if val[0] == "K_VALUE": kval = int(val[1]) elif val[0] == "EDGE_LINK_SPEED": edgeLinkCapacity[0] = val[1] edgeLinkCapacity[1] = val[2] elif val[0] == "AGGR_LINK_SPEED": aggrLinkCapacity[0] = val[1] aggrLinkCapacity[1] = val[2] elif val[0] == "CORE_LINK_SPEED": coreLinkCapacity[0] = val[1] coreLinkCapacity[1] = val[2] elif val[0] == "LINK_DELAY": linkDelay[0] = val[1] linkDelay[1] = val[2] if kval == 0: print "ERROR: Wrong value of K for a fat tree topo, exiting" sys.exit(0) # Build the topology using fnss topology = fnss.fat_tree_topology(kval) # Get link types link_types = nx.get_edge_attributes(topology, 'type') edge_leaf_links = [link for link in link_types if link_types[link] == 'edge_leaf'] aggregation_edge_links = [link for link in link_types if link_types[link] == 'aggregation_edge'] core_edge_links = [link for link in link_types if link_types[link] == 'core_edge'] # Set the link speeds fnss.set_capacities_constant(topology, edgeLinkCapacity[0], edgeLinkCapacity[1], edge_leaf_links) fnss.set_capacities_constant(topology, aggrLinkCapacity[0], aggrLinkCapacity[1], aggregation_edge_links) fnss.set_capacities_constant(topology, coreLinkCapacity[0], coreLinkCapacity[1], core_edge_links) # Set default weight of 1 to all links fnss.set_weights_constant(topology, 1) # Set link delay to be 10 ns fnss.set_delays_constant(topology, linkDelay[0], linkDelay[1]) # Generate the topology.xml file fnss.write_topology(topology, 'topology.xml') # Create mininet topology from fnss with renaming to mininet format mn_topo = fnss.to_mininet(topology, relabel_nodes=True) net = Mininet(topo=mn_topo, link=TCLink, controller=None) net.addController('floodlight', controller=RemoteController, ip="127.0.0.1", port=6653) net.start() # Dump host connections dumpNodeConnections(net.hosts) # Test network connectivity net.pingAll()
def test_fan_in_out_capacities_undirected(self): topology = fnss.star_topology(3) fnss.set_capacities_constant(topology, 10, 'Mbps') in_cap, out_cap = fnss.fan_in_out_capacities(topology) self.assertEqual({0: 30, 1: 10, 2: 10, 3: 10}, in_cap) self.assertEqual(in_cap, out_cap)
# this return a dictionary of egdes and value of attribute type # This function is provided by the NetworkX library. # Since FNSS Topology and DirecteedTopology objects inherit from NetworkX's # Graph and DiGraph, respectively, NetworkX functions can be used in FNSS too. link_types = nx.get_edge_attributes(fnss_topo, 'type') core_links = [links for links in link_types if link_types[links] == 'core'] edge_links = [links for links in link_types if link_types[links] == 'right_bell' or link_types[links] == 'left_bell'] # set delay equal to 1 ms in edge links and equal to 2 ms in core links fnss.set_delays_constant(fnss_topo, 1, 'ms', edge_links) fnss.set_delays_constant(fnss_topo, 2, 'ms', core_links) # set capacity of 10 Mbps in edge links and 40 Mbps in core links fnss.set_capacities_constant(fnss_topo, 10, 'Mbps', edge_links) fnss.set_capacities_constant(fnss_topo, 40, 'Mbps', core_links) # Set buffer size constant to all interfaces fnss.set_buffer_sizes_constant(fnss_topo, 50, 'packets') # Now we deploy a traffic sources on right bell and traffic receivers on left # bell node_types = nx.get_node_attributes(fnss_topo, 'type') core_nodes = [nodes for nodes in node_types if node_types[nodes] == 'core'] left_nodes = [nodes for nodes in node_types if node_types[nodes] == 'left_bell'] right_nodes = [nodes for nodes in node_types if node_types[nodes] == 'right_bell']
# This function is provided by the NetworkX library. # Since FNSS Topology and DirecteedTopology objects inherit from NetworkX's # Graph and DiGraph, respectively, NetworkX functions can be used in FNSS too. link_types = nx.get_edge_attributes(topology, 'type') core_links = [links for links in link_types if link_types[links] == 'core'] edge_links = [ links for links in link_types if link_types[links] == 'right_bell' or link_types[links] == 'left_bell' ] # set delay equal to 1 ms in edge links and equal to 2 ms in core links fnss.set_delays_constant(topology, 1, 'ms', edge_links) fnss.set_delays_constant(topology, 2, 'ms', core_links) # set capacity of 10 Mbps in edge links and 40 Mbps in core links fnss.set_capacities_constant(topology, 10, 'Mbps', edge_links) fnss.set_capacities_constant(topology, 40, 'Mbps', core_links) # Now we deploy a traffic sources on right bell and traffic receivers on left # bell node_types = nx.get_node_attributes(topology, 'type') left_nodes = [ nodes for nodes in node_types if node_types[nodes] == 'left_bell' ] right_nodes = [ nodes for nodes in node_types if node_types[nodes] == 'right_bell' ] for node in left_nodes: fnss.add_application(topology, node, 'receiver', {})
# create a topology with 10 core switches, 20 edge switches and 10 hosts # per switch (i.e. 200 hosts in total) topology = fnss.two_tier_topology(n_core=10, n_edge=20, n_hosts=10) # assign capacities # let's set links connecting servers to edge switches to 1 Gbps # and links connecting core and edge switches to 10 Gbps. # get list of core_edge links and edge_leaf links link_types = nx.get_edge_attributes(topology, 'type') core_edge_links = [ link for link in link_types if link_types[link] == 'core_edge' ] edge_leaf_links = [ link for link in link_types if link_types[link] == 'edge_leaf' ] # assign capacities fnss.set_capacities_constant(topology, 1, 'Gbps', edge_leaf_links) fnss.set_capacities_constant(topology, 10, 'Gbps', core_edge_links) # assign weight 1 to all links fnss.set_weights_constant(topology, 1) # assign delay of 10 nanoseconds to each link fnss.set_delays_constant(topology, 10, 'ns') # save topology to a file fnss.write_topology(topology, 'datacenter_topology.xml')
""" import fnss from mininet.topo import Topo from mininet.net import Mininet from mininet.link import TCLink from mininet.util import dumpNodeConnections from mininet.log import setLogLevel from mininet.cli import CLI from mininet.node import RemoteController from mininet.node import OVSController # Create FNSS topology -- FatTree with k = 4 fnss_topo = fnss.fat_tree_topology(k=4) # Set link attributes 10Mbps bandwidth fnss.set_capacities_constant(fnss_topo, 10, "Mbps") # Set link delay to be 2ms fnss.set_delays_constant(fnss_topo, 2, "ms") # Set switch buffer to be 50 packets size fnss.set_buffer_sizes_constant(fnss_topo, 50, "packets") # Convert FNSS topology to Mininet mn_topo = fnss.to_mininet(fnss_topo, relabel_nodes=True) # Create a remote controller object in local host RemoteCon = RemoteController("RemoteCon1", ip="127.0.0.1") # Create a Mininet instance and start it # Use TCLink to implement links enables Linux Traffic Container (TC) for rate # limitation net = Mininet(topo=mn_topo, link=TCLink, controller=RemoteCon) net.start() # Dump host connections
""" import fnss from mininet.topo import Topo from mininet.net import Mininet from mininet.link import TCLink from mininet.util import dumpNodeConnections from mininet.log import setLogLevel from mininet.cli import CLI from mininet.node import RemoteController from mininet.node import OVSController import time # Create FNSS topology -- FatTree with k = 4 fnss_topo = fnss.fat_tree_topology(k=4) # Set link attributes 10Mbps bandwidth fnss.set_capacities_constant(fnss_topo, 10, 'Mbps') # Set link delay to be 2ms fnss.set_delays_constant(fnss_topo, 2, 'ms') # Set switch buffer to be 50 packets size fnss.set_buffer_sizes_constant(fnss_topo, 50, 'packets') # Convert FNSS topology to Mininet mn_topo = fnss.to_mininet(fnss_topo, relabel_nodes=True) # Create a remote controller object in local host RemoteCon = RemoteController('RemoteCon1', ip='127.0.0.1') # Create a Mininet instance and start it # Use TCLink to implement links enables Linux Traffic Container (TC) for rate # limitation net = Mininet(topo=mn_topo, link=TCLink, controller=RemoteCon) net.start() # Dump host connections
def generate_traffic_matrix(): parser = argparse.ArgumentParser( formatter_class=argparse.ArgumentDefaultsHelpFormatter) parser.add_argument("--as_no", type=str, required=True) parser.add_argument('--arrival_rate', type=float, default=0.003) # 10 sfc per hour parser.add_argument('--max_simulation_time', type=int, default=86400) # 24 hour parser.add_argument('--sfc_lifetime', type=int, default=5400) # 1 hour 30 minute parser.add_argument('--num_time_slots', type=int, default=24) parser.add_argument('--stddev', type=float, default=0.03) args = parser.parse_args() co_file = args.as_no + ".co" co_topology = read_co_topology(co_file) slot_width = args.max_simulation_time / args.num_time_slots times = [] current_time = 0 while current_time < args.max_simulation_time: wait_time = int(random.expovariate(args.arrival_rate)) + 1 duration = int(random.expovariate(1.0 / args.sfc_lifetime)) + 1 times.append((current_time, current_time + duration)) current_time += wait_time timeslot_sfc_count = dict() flow_time_slot = dict() sources = random.sample(range(0, len(co_topology.nodes()) - 1), len(co_topology.nodes()) / 2) destinations = random.sample(range(0, len(co_topology.nodes()) - 1), len(co_topology.nodes()) / 2) topology = fnss.Topology(co_topology) fnss.set_capacities_constant(topology, 10000, 'Mbps') tmc = fnss.sin_cyclostationary_traffic_matrix( topology, mean=0.1, # average flow in TM is 100 Mbps stddev=args. stddev, # this is the std among average flows of different OD pairs gamma=0.8, # gamma and log_psi are parameters for fitting the std of log_psi= -0.033, # volume fluctuations over time. Look at Nucci et al. paper delta= 0.2, # traffic variation from period max and avg as fraction of average n=1, # number of samples per each period periods=args.num_time_slots, # number of periods max_u=0.50, # max link utilization desired origin_nodes=sources, destination_nodes=destinations) flow_id = 0 all_flows = [] for i in range(len(tmc)): tm = tmc.get(i) flows = tm.flows() for (endpoint, traffic) in flows.items(): [source, destination] = endpoint traffic *= 1000 traffic /= round((24 * 1.0 / args.num_time_slots) * 3600.0, 0) if source == destination: continue if traffic < 10: continue if traffic > 8000: traffic = 8000 mbox_seq = GenerateMiddleboxSequence(random.randint(3, 6)) flow = dict() flow["flow_id"] = flow_id flow["src"] = source flow["dst"] = destination flow["bw"] = int(round(traffic, 0)) flow["mbox_seq"] = mbox_seq flow["delay"] = int(round(random.uniform(1000, 2000), 0)) all_flows.append(flow) flow_id += 1 # traffic_file.write(str(current_time) + "," + str(source) + "," + # str(destination) + "," + str(int(round(traffic, 0))) + "," + str(max_latency) + # ",0.00000010," + mbox_seq[0] + "," + mbox_seq[1] + "," + mbox_seq[2] + # "\n") num_flows = len(all_flows) with open(args.as_no + ".timeslots", "w") as f: f.write(str(len(times)) + "\n") f.write(str(args.num_time_slots) + "\n") flow_index = 0 for time_point in times: current_time, ends_at = time_point cur_slot_idx, end_slot_idx = get_timeslot_index( current_time, slot_width), get_timeslot_index(ends_at, slot_width) if cur_slot_idx not in timeslot_sfc_count.keys(): timeslot_sfc_count[cur_slot_idx] = 0 flow_time_slot[cur_slot_idx] = [] timeslot_sfc_count[cur_slot_idx] += 1 ttl = end_slot_idx - cur_slot_idx + 1 flow_idx = random.randint(0, num_flows - 1) flow = all_flows[flow_idx] flow['ttl'] = ttl flow_str = " ".join([ str(flow_index), str(flow["src"]), str(flow["dst"]), str(flow["ttl"]), str(len(flow["mbox_seq"])), " ".join(flow["mbox_seq"]), str(flow["bw"]), str(flow["delay"]) ]) flow_time_slot[cur_slot_idx].append(flow_str) flow_index += 1 for (ts, flows) in flow_time_slot.iteritems(): f.write(str(len(flows)) + "\n") for flow in flows: f.write(flow + "\n")
""" import fnss import networkx as nx # create a topology with 10 core switches, 20 edge switches and 10 hosts # per switch (i.e. 200 hosts in total) topology = fnss.two_tier_topology(n_core=10, n_edge=20, n_hosts=10) # assign capacities # let's set links connecting servers to edge switches to 1 Gbps # and links connecting core and edge switches to 10 Gbps. # get list of core_edge links and edge_leaf links link_types = nx.get_edge_attributes(topology, 'type') core_edge_links = [link for link in link_types if link_types[link] == 'core_edge'] edge_leaf_links = [link for link in link_types if link_types[link] == 'edge_leaf'] # assign capacities fnss.set_capacities_constant(topology, 1, 'Gbps', edge_leaf_links) fnss.set_capacities_constant(topology, 10, 'Gbps', core_edge_links) # assign weight 1 to all links fnss.set_weights_constant(topology, 1) # assign delay of 10 nanoseconds to each link fnss.set_delays_constant(topology, 10, 'ns') # save topology to a file fnss.write_topology(topology, 'datacenter_topology.xml')
""" Export topology to ns-2 ======================= This example shows how to generate a topology (a line in this case) and export it to the ns-2 simulator """ import fnss # create a line topology with 10 nodes topology = fnss.line_topology(10) # assign capacity of 10 Mbps to each link fnss.set_capacities_constant(topology, 10, 'Mbps') # assign delay of 2 ms to each link fnss.set_delays_constant(topology, 2, 'ms') # set buffers in each node (use packets, bytes not supported by ns-2) fnss.set_buffer_sizes_bw_delay_prod(topology, 'packets', 1500) # Add FTP application to first and last node of the line tcp_stack_props = {'class': 'Agent/TCP', 'class_': 2, 'fid_': 1} fnss.add_stack(topology, 0, 'tcp', tcp_stack_props) fnss.add_stack(topology, 9, 'tcp', tcp_stack_props) ftp_app_props = {'class': 'Application/FTP', 'type': 'FTP'} fnss.add_application(topology, 0, 'ftp', ftp_app_props) fnss.add_application(topology, 9, 'ftp', ftp_app_props) # export topology to a Tcl script for ns-2
for i in dir(fnss): print i link_types = nx.get_edge_attributes(fnss_topo, 'type') core_links = [links for links in link_types if link_types[links] == 'core'] edge_links = [ links for links in link_types if link_types[links] == 'right_bell' or link_types[links] == 'left_bell' ] # set delay equal to 1 ms in edge links and equal to 2 ms in core links fnss.set_delays_constant(fnss_topo, 1, 'ms', edge_links) fnss.set_delays_constant(fnss_topo, 2, 'ms', core_links) # set capacity of 10 Mbps in edge links and 40 Mbps in core links fnss.set_capacities_constant(fnss_topo, 10, 'Mbps', edge_links) fnss.set_capacities_constant(fnss_topo, 40, 'Mbps', core_links) # Set buffer size constant to all interfaces fnss.set_buffer_sizes_constant(fnss_topo, 50, 'packets') # Now we deploy a traffic sources on right bell and traffic receivers on left # bell node_types = nx.get_node_attributes(fnss_topo, 'type') core_nodes = [nodes for nodes in node_types if node_types[nodes] == 'core'] left_nodes = [ nodes for nodes in node_types if node_types[nodes] == 'left_bell' ] right_nodes = [ nodes for nodes in node_types if node_types[nodes] == 'right_bell' ]