def egress_max_throughput(self, fake_node_id, dst_topo): #generate traffic matrix trafficMatrix = {} dst_topo_node_num = networkx.number_of_nodes(dst_topo._graph) for node in self.topo._graph.nodes(): trafficMatrix[( node, fake_node_id)] = CITY_TRAFFIC_VOLUME * (dst_topo_node_num - 2) #generate fake topology self.fake_topo = copy.deepcopy(self.topo) self.fake_topo._graph.add_node(fake_node_id) #self.fake_topo._graph.add_edge(fake_node_id, 0) self.fake_topo._graph.add_edge(0, fake_node_id) #self.fake_topo._graph.add_edge(fake_node_id, 1) self.fake_topo._graph.add_edge(1, fake_node_id) #generate traffic classes ie_path_map = generatePath(trafficMatrix.keys(), self.fake_topo, nullPredicate, 'shortest', maxPaths=3) trafficClasses = generateTrafficClasses(0, trafficMatrix.keys(), trafficMatrix, {'a': 1}, {'a': 100}) norm_list = get_norm_weight(trafficClasses) #optimization pptc = initOptimization(ie_path_map, self.fake_topo, trafficClasses) throughput = maxmin_fair_allocate(trafficClasses, self.linkcaps, pptc, norm_list, False) print 'cp net max throughput:{}'.format(throughput) egress_bw_dict = {} for tc, paths in pptc.iteritems(): for path in paths: nodes = path.getNodes() real_egress = nodes[-2] if real_egress in egress_bw_dict: egress_bw_dict[real_egress] += path.bw else: egress_bw_dict[real_egress] = path.bw for egress, bw in egress_bw_dict.iteritems(): print 'egress:{} bw:{}'.format(egress, bw) result = {} dst_topo_node_num = networkx.number_of_nodes(dst_topo._graph) for node in dst_topo.nodes(): if node == 0 or node == 1: continue for egress, bw in egress_bw_dict.iteritems(): result[(egress, node)] = bw / (dst_topo_node_num - 2) return result
def TE(): # ============== # Let's generate some example data; # ============== topo = Topology('Abilene', 'data/topologies/simple-flex.graphml') # Let's load an existing gravity traffic matrix. It's just a dict mapping ingress-egress tuples to flow volume (a float). trafficMatrix_1 = TrafficMatrix.load('data/tm/tc-3.tm') trafficMatrix_2 = TrafficMatrix.load('data/tm/tc-4.tm') # compute traffic classes. We will only have one class that encompasses all the traffic; # assume that each flow consumes 2000 units of bandwidth ie_path_map_1 = generatePath(trafficMatrix_1.keys(), topo, nullPredicate, "shortest", 5) ie_path_map_2 = generatePath(trafficMatrix_2.keys(), topo, nullPredicate, "shortest", 5) ie_path_map = dict(ie_path_map_1.items() + ie_path_map_2.items()) #f = pptc_set.copy() trafficClasses_1 = generateTrafficClasses(trafficMatrix_1.keys(), trafficMatrix_1, {'vn1':1}, {'vn1': 100}) trafficClasses_2 = generateTrafficClasses(trafficMatrix_2.keys(), trafficMatrix_2, {'vn2':1}, {'vn2': 100}, index_base=len(trafficClasses_1)) for tc in trafficClasses_2: print tc trafficClasses = trafficClasses_1 + trafficClasses_2 for tc in trafficClasses: print tc print "ID:",tc.ID,";name:",tc.name,"src:",tc.src,";dst:",tc.dst,";flows:",tc.volFlows,";byte:",tc.volBytes # since our topology is "fake", provision our links and generate link capacities in our network linkcaps = setLinkCaps(topo) # these will be our link constraints: do not load links more than 50% linkConstrCaps = {(u, v): 1.0 for u, v in topo.links()} # ============== # Optimization # ============== pptc = initOptimization(ie_path_map, topo, trafficClasses) maxmin_fair_allocate(trafficClasses, linkcaps, pptc, False)
def egress_volume_shortest(self, egress_nodes, dst_topos): g = self.topo.getGraph() egress_nodes_num = len(egress_nodes) node_path_dict = {} for node in g.nodes(): for egress in egress_nodes: node_path_dict[(node, egress)] = networkx.shortest_path( g, node, egress) dst_node_num = 11 trafficMatrix = {} for k in node_path_dict.keys(): trafficMatrix[k] = CITY_TRAFFIC_VOLUME * 10 print 'k {} value {}'.format(k, trafficMatrix[k]) trafficClasses = generateTrafficClasses(0, node_path_dict.keys(), trafficMatrix, {'a': 1}, {'a': 100}) pptc = {} for tc in trafficClasses: pptc[copy.deepcopy(tc)] = [Path(node_path_dict[tc.src, tc.dst])] norm_list = get_norm_weight(trafficClasses) throughput = maxmin_fair_allocate(trafficClasses, self.linkcaps, pptc, norm_list, False) print 'cp net shortest throughput:{}'.format(throughput) egress_bw_dict = {} for tc, paths in pptc.iteritems(): for path in paths: nodes = path.getNodes() egress = nodes[-1] if egress in egress_bw_dict: egress_bw_dict[egress] += path.bw else: egress_bw_dict[egress] = path.bw for egress, bw in egress_bw_dict.iteritems(): print 'egress:{} bw:{}'.format(egress, bw) dst_topo_node_num = networkx.number_of_nodes(dst_topos[0]) result = {} for egress, dst_topo in zip(egress_bw_dict.keys(), dst_topos): for node in dst_topo: if node == 0 or node == 11 or node == 22: continue bw = egress_bw_dict[egress] result[(egress, node)] = bw / 10 return result
def set_traffic(self, trafficMatrix, topo, isp_id, path_num=3): self.trafficMatrix = {} isp_nodes = self.topo._graph.nodes() print 'ispnodes {}'.format(isp_nodes) for cp_id, tm in trafficMatrix.iteritems(): self.trafficMatrix[cp_id] = {} for k, v in tm.iteritems(): (ingress, dst) = k if ingress == isp_id: k1 = (11 * isp_id, dst) self.trafficMatrix[cp_id][k1] = v for cp_id, tm in self.trafficMatrix.iteritems(): print "cp {}".format(cp_id) for k in tm.keys(): print 'k {}'.format(k) self.trafficClasses = [] self.ie_path_map = {} base_index = 0 for key in trafficMatrix.keys(): self.ie_path_map[key] = generatePath( self.trafficMatrix[key].keys(), topo, nullPredicate, "shortest", maxPaths=path_num) tcs = generateTrafficClasses(key, self.trafficMatrix[key].keys(), self.trafficMatrix[key], {'a': 1}, {'a': 100}, index_base=base_index) base_index += len(tcs) self.trafficClasses.extend(tcs) print 'test trafficclass' for tc in self.trafficClasses: print tc #self.linkcaps = provisionLinks(self.topo, self.trafficClasses, 1) self.norm_list = get_norm_weight(self.trafficClasses)
def egress_volume_shortest(self, egress_nodes, dst_topo): g = self.topo.getGraph() node_path_dict = {} for node in g.nodes(): egress_path_dict = {} for egress in egress_nodes: egress_path_dict[egress] = networkx.shortest_path(g, node, egress) min_val = min(egress_path_dict.itervalues()) closest_egress = [k for k, v in egress_path_dict.iteritems() if v == min_val] node_path_dict[(node, closest_egress[0])] = egress_path_dict[closest_egress[0]] dst_node_num = networkx.number_of_nodes(dst_topo._graph) trafficMatrix = dict(zip(node_path_dict.keys(), [CITY_TRAFFIC_VOLUME * (dst_node_num - 2)] * len(node_path_dict.keys()))) trafficClasses = generateTrafficClasses(0, node_path_dict.keys(), trafficMatrix, {'a':1}, {'a':100}) pptc = {} for tc in trafficClasses: pptc[copy.deepcopy(tc)] = [Path(node_path_dict[tc.src, tc.dst])] norm_list = get_norm_weight(trafficClasses) throughput = maxmin_fair_allocate(trafficClasses, self.linkcaps, pptc, norm_list, False) print 'cp net shortest throughput:{}'.format(throughput) egress_bw_dict = {} for tc, paths in pptc.iteritems(): for path in paths: nodes = path.getNodes() egress = nodes[-1] if egress in egress_bw_dict: egress_bw_dict[egress] += path.bw else: egress_bw_dict[egress] = path.bw for egress, bw in egress_bw_dict.iteritems(): print 'egress:{} bw:{}'.format(egress, bw) dst_topo_node_num = networkx.number_of_nodes(dst_topo._graph) result = {} for node in dst_topo.nodes(): if node == 0 or node == 1: continue for egress, bw in egress_bw_dict.iteritems(): result[(egress, node)] = bw / (dst_topo_node_num - 2) return result
def set_traffic(self, trafficMatrix): self.trafficMatrix = trafficMatrix self.trafficClasses = [] self.ie_path_map = {} base_index = 0 print self.topo._graph.edges() for key in trafficMatrix.keys(): self.ie_path_map[key] = generatePath( self.trafficMatrix[key].keys(), self.topo, nullPredicate, "shortest", 5) tcs = generateTrafficClasses(key, self.trafficMatrix[key].keys(), self.trafficMatrix[key], {'a': 1}, {'a': 100}, index_base=base_index) base_index += len(tcs) self.trafficClasses.extend(tcs) #for tc in self.trafficClasses: #print tc #self.linkcaps = provisionLinks(self.topo, self.trafficClasses, 1) self.linkcaps = self.setLinkCaps() self.norm_list = self.getNormWeight()
def set_traffic(self, trafficMatrix, topo, path_num=3): self.trafficMatrix = trafficMatrix self.trafficClasses = [] self.ie_path_map = {} base_index = 0 for key in trafficMatrix.keys(): self.ie_path_map[key] = generatePath( self.trafficMatrix[key].keys(), topo, nullPredicate, "shortest", maxPaths=path_num) tcs = generateTrafficClasses(key, self.trafficMatrix[key].keys(), self.trafficMatrix[key], {'a': 1}, {'a': 100}, index_base=base_index) base_index += len(tcs) self.trafficClasses.extend(tcs) #for tc in self.trafficClasses: #print tc #self.linkcaps = provisionLinks(self.topo, self.trafficClasses, 1) self.norm_list = get_norm_weight(self.trafficClasses)
def TE(): # ============== # Let's generate some example data; # ============== topo = Topology('Abilene', './data/topologies/Abilene.graphml') # Let's load an existing gravity traffic matrix. It's just a dict mapping ingress-egress tuples to flow volume (a float). trafficMatrix_1 = TrafficMatrix.load('./data/tm/Abilene.tm') #trafficMatrix_2 = TrafficMatrix.load('data/tm/tc-4.tm') trafficMatrix_2 = {} print trafficMatrix_1.keys() for key, value in trafficMatrix_1.iteritems(): trafficMatrix_2.update({key: 7 * value}) #print trafficMatrix_2 # compute traffic classes. We will only have one class that encompasses all the traffic; # assume that each flow consumes 2000 units of bandwidth ie_path_map_1 = generatePath(trafficMatrix_1.keys(), topo, nullPredicate, "shortest", 5) ie_path_map_2 = generatePath(trafficMatrix_2.keys(), topo, nullPredicate, "shortest", 5) ie_path_map = dict(ie_path_map_1.items() + ie_path_map_2.items()) #f = pptc_set.copy() trafficClasses_1 = generateTrafficClasses(trafficMatrix_1.keys(), trafficMatrix_1, {'vn1': 1}, {'vn1': 100}) trafficClasses_2 = generateTrafficClasses(trafficMatrix_2.keys(), trafficMatrix_2, {'vn2': 1}, {'vn2': 100}, index_base=len(trafficClasses_1)) trafficClasses = trafficClasses_1 + trafficClasses_2 v1_sum = sum(tc.demand for tc in trafficClasses_1) v2_sum = sum(tc.demand for tc in trafficClasses_2) demand_sum = sum(tc.demand for tc in trafficClasses) norm_list = {} for tc in trafficClasses: norm_list[tc] = tc.demand / demand_sum max_val = max(norm_list.values()) for tc in trafficClasses: norm_list[tc] = norm_list[tc] / max_val # since our topology is "fake", provision our links and generate link capacities in our network linkcaps = setLinkCaps(topo) # these will be our link constraints: do not load links more than 50% linkConstrCaps = {(u, v): 1.0 for u, v in topo.links()} # ============== # Optimization # ============== pptc = initOptimization(ie_path_map, topo, trafficClasses) maxmin_fair_allocate(trafficClasses, linkcaps, pptc, norm_list, False) print "calculating fairness index..." pptc_1 = initOptimization(ie_path_map_1, topo, trafficClasses_1) maxmin_fair_allocate(trafficClasses_1, linkcaps, pptc_1, norm_list) pptc_2 = initOptimization(ie_path_map_2, topo, trafficClasses_2) maxmin_fair_allocate(trafficClasses_2, linkcaps, pptc_2, norm_list) s_1 = 0.0 s_2 = 0.0 s1_num = 0 s2_num = 0 for tc in pptc: if tc in trafficClasses_1: for tc1 in pptc_1: if tc.src == tc1.src and tc.dst == tc1.dst: print 'tc:{} tc1:{}'.format(tc.allocate_bw, tc1.allocate_bw) if tc1.allocate_bw == 0: tc1.allocate_bw = 0.1 s_1 += tc.allocate_bw / tc1.allocate_bw s1_num += 1 break elif tc in trafficClasses_2: for tc2 in pptc_2: if tc.src == tc2.src and tc.dst == tc2.dst: if tc2.allocate_bw == 0: tc2.allocate_bw = 0.1 s_2 += tc.allocate_bw / tc2.allocate_bw s2_num += 1 break s_1 = s_1 / s1_num s_2 = s_2 / s2_num print 's1:{} s2:{}'.format(s_1, s_2) g1 = copy.deepcopy(pptc_1) g2 = copy.deepcopy(pptc_2) for tc1 in pptc_1: if tc1.calc_flag == 1: continue for path1 in pptc_1[tc1]: for tc2 in pptc_2: if tc2.calc_flag == 1: continue for path2 in pptc_2[tc2]: links1 = path1.getLinks() links2 = path2.getLinks() if set(links1).intersection(links2): g1[copy.deepcopy(tc2)] = copy.deepcopy(pptc_2[tc2]) g2[copy.deepcopy(tc1)] = copy.deepcopy(pptc_1[tc1]) flag = 1 tc2.calc_flag = 1 tc1.calc_flag = 1 maxmin_fair_allocate(g1.keys(), linkcaps, g1, norm_list) maxmin_fair_allocate(g2.keys(), linkcaps, g2, norm_list) u_1 = 0.0 u_2 = 0.0 u1_num = 0 u2_num = 0 for tc1 in g1: for tc in pptc: if tc.src == tc1.src and tc.dst == tc1.dst: print 'tc:{} tc1:{}'.format(tc.allocate_bw, tc1.allocate_bw) u_1 += min({tc.allocate_bw / tc1.allocate_bw, 1}) u1_num += 1 break for tc2 in g2: for tc in pptc: if tc.src == tc2.src and tc.dst == tc2.dst: u_2 += min({tc.allocate_bw / tc2.allocate_bw, 1}) u2_num += 1 break u_1 = u_1 / u1_num u_2 = u_2 / u2_num print 'u1:{} u2:{}'.format(u_1, u_2) netstat_1 = s_1 / u_1 netstat_2 = s_2 / u_2 u = (netstat_1 * v1_sum + netstat_2 * v2_sum) / (v1_sum + v2_sum) print u gfi = math.sqrt( (pow(netstat_1 - u, 2) * v1_sum + pow(netstat_2 - u, 2) * v2_sum) / (v1_sum + v2_sum)) print gfi