def single_experiment(size):
# Original graph to clone several times, with the second best path strategy applied
network_graph = rip_gen.generate_rip_graph(size)
# This creates two more copies of the graph so I can apply each backup strategy on them
network_graph_wbp = network_graph.subgraph(network_graph.nodes())
network_graph_lbp = network_graph.subgraph(network_graph.nodes())
lbp.least_overlapping_backup_path(network_graph_lbp)
# Compute all the shortest paths in the graph as primary paths
print "A graph with %d nodes and %d edges was generated." % (
network_graph.number_of_nodes(), network_graph.number_of_edges())
primary_paths = []
for k, v in nx.shortest_path(network_graph).iteritems():
for n, m in v.iteritems():
if len(m) > 1:
primary_paths.append(m)
# print primary_paths
# rip_gen.draw_graph(network_graph)
global outfile
# Changing the topology by deleting 10%, 30%, 50% and 70% of the edges
for tp in [10, 30, 50, 70]:
print "\n%d%% of topology change" % tp
print "======================"
reduced_graph = network_graph.subgraph(network_graph.nodes())
deleted_edges = reduce_edges(reduced_graph, tp)
print "%d edges deleted" % len(deleted_edges)
print deleted_edges
ap = detect_affected_paths(primary_paths, deleted_edges)
# print ap
print "Affection rate (paths affected after deletion): %d/%d = %.2f%%" % (
len(ap), len(primary_paths), len(ap) * 100.0 / len(primary_paths))
sbp.second_best_cost_backup_path(network_graph)
global fail_count
fail_count = 0
for (s, d) in ap:
check_backup_strategy(network_graph, reduced_graph, s, d)
print "\nUsing SECOND BEST COST backup strategy... Fail rate: %d/%d = %.2f%%" % (
fail_count, len(ap), fail_count * 100.0 / len(ap))
#outfile.write("\nUsing SECOND BEST COST backup strategy... Fail rate: %d/%d = %.2f%%" % (fail_count, len(ap), fail_count*100.0/len(ap)))
wbp.worst_cost_backup_path(network_graph_wbp)
global fail_count
fail_count = 0
for (s, d) in ap:
check_backup_strategy(network_graph_wbp, reduced_graph, s, d)
print "Using WORST COST backup strategy... Fail rate: %d/%d = %.2f%%" % (
fail_count, len(ap), fail_count * 100.0 / len(ap))
#outfile.write("Using WORST BEST COST backup strategy... Fail rate: %d/%d = %.2f%%" % (fail_count, len(ap), fail_count*100.0/len(ap)))
global fail_count
fail_count = 0
check_backup_strategy_lbp(network_graph_lbp, ap, deleted_edges)
print "Using LEAST OVERLAPPING backup strategy... Fail rate: %d/%d = %.2f%%" % (
fail_count, len(ap), fail_count * 100.0 / len(ap))
def single_experiment(size):
# Original graph to clone several times, with the second best path strategy applied
network_graph = rip_gen.generate_rip_graph(size)
# This creates two more copies of the graph so I can apply each backup strategy on them
network_graph_wbp = network_graph.subgraph(network_graph.nodes())
network_graph_lbp = network_graph.subgraph(network_graph.nodes())
lbp.least_overlapping_backup_path(network_graph_lbp)
# Compute all the shortest paths in the graph as primary paths
print "A graph with %d nodes and %d edges was generated." % (network_graph.number_of_nodes(), network_graph.number_of_edges())
primary_paths = []
for k,v in nx.shortest_path(network_graph).iteritems():
for n,m in v.iteritems():
if len(m) > 1:
primary_paths.append(m)
# print primary_paths
# rip_gen.draw_graph(network_graph)
global outfile
# Changing the topology by deleting 10%, 30%, 50% and 70% of the edges
for tp in [10, 30, 50, 70]:
print "\n%d%% of topology change" % tp
print "======================"
reduced_graph = network_graph.subgraph(network_graph.nodes())
deleted_edges = reduce_edges(reduced_graph, tp)
print "%d edges deleted" % len(deleted_edges)
print deleted_edges
ap = detect_affected_paths(primary_paths, deleted_edges)
# print ap
print "Affection rate (paths affected after deletion): %d/%d = %.2f%%" % (len(ap), len(primary_paths), len(ap)*100.0/len(primary_paths))
sbp.second_best_cost_backup_path(network_graph)
global fail_count
fail_count = 0
for (s,d) in ap:
check_backup_strategy(network_graph, reduced_graph, s, d)
print "\nUsing SECOND BEST COST backup strategy... Fail rate: %d/%d = %.2f%%" % (fail_count, len(ap), fail_count*100.0/len(ap))
#outfile.write("\nUsing SECOND BEST COST backup strategy... Fail rate: %d/%d = %.2f%%" % (fail_count, len(ap), fail_count*100.0/len(ap)))
wbp.worst_cost_backup_path(network_graph_wbp)
global fail_count
fail_count = 0
for (s,d) in ap:
check_backup_strategy(network_graph_wbp, reduced_graph, s, d)
print "Using WORST COST backup strategy... Fail rate: %d/%d = %.2f%%" % (fail_count, len(ap), fail_count*100.0/len(ap))
#outfile.write("Using WORST BEST COST backup strategy... Fail rate: %d/%d = %.2f%%" % (fail_count, len(ap), fail_count*100.0/len(ap)))
global fail_count
fail_count = 0
check_backup_strategy_lbp(network_graph_lbp, ap, deleted_edges)
print "Using LEAST OVERLAPPING backup strategy... Fail rate: %d/%d = %.2f%%" % (fail_count, len(ap), fail_count*100.0/len(ap))
worst_distance = np.max(array[array < sys.maxint])
result = np.where(array == worst_distance)[0]
bnhv[i] = result[0]
# If unluckily there is just one different from infinity or two with same distance
if bnhv[i] == nhv[i] and len(result) <= 1:
bnhv[i] = None
elif bnhv[i] == nhv[i]:
bnhv[i] = result[1]
#print nhv
#print bnhv
if __name__ == '__main__':
network_graph = rip_gen.generate_rip_graph(6)
np.set_printoptions(precision=1)
worst_cost_backup_path(network_graph)
#Comparing with bellman-ford for testing
for n, nattr in network_graph.nodes(
data=True): # For each node n and attribute nattr
print n
print nattr['distance_matrix']
print nattr['best_weights_vector']
print nattr['default_next_hop']
print nattr['backup_next_hop']
print "\n"
worst_distance = np.max(array[array < sys.maxint])
result = np.where(array == worst_distance)[0]
bnhv[i] = result[0]
# If unluckily there is just one different from infinity or two with same distance
if bnhv[i] == nhv[i] and len(result) <= 1:
bnhv[i] = None
elif bnhv[i] == nhv[i]:
bnhv[i] = result[1]
#print nhv
#print bnhv
if __name__ == '__main__':
network_graph = rip_gen.generate_rip_graph(6)
np.set_printoptions(precision=1)
worst_cost_backup_path(network_graph)
#Comparing with bellman-ford for testing
for n, nattr in network_graph.nodes(data=True): # For each node n and attribute nattr
print n
print nattr['distance_matrix']
print nattr['best_weights_vector']
print nattr['default_next_hop']
print nattr['backup_next_hop']
print "\n"