Subversion Repositories an-fpga-implementation-of-low-latency-noc-based-mpsoc

import networkx as nx
from s_c_c import filter_big_scc
from s_c_c import get_big_sccs
from file_io import write_pairs_to_file
from file_io import read_dict_from_file
#from network_functions import analysis_graph
 
def remove_cycle_edges_by_ranking_score_iterately(sccs,players,edges_to_be_removed,is_Forward):
	while True:
		graph = sccs.pop()
		node_scores_dict = {}
		for node in graph.nodes():
			node_scores_dict[node] = players[node]
		from helper_funs import pick_from_dict
		max_k,max_v,min_k,min_v = pick_from_dict(node_scores_dict,"both")
 
		#node_scores = [(node,players[node]) for node in graph.nodes_iter()]
		#sorted_node_scores = sorted(node_scores,key = lambda x: x[1])
 
		if is_Forward:
			node,score = max_k,max_v
			target_edges = [(node,v) for v in graph.successors(node)]
			#target_edges = [(v,node) for v in graph.predecessors_iter(node)]
		else:
			node,score = min_k,min_v
			#node,score = sorted_node_scores.pop()
			target_edges = [(v,node) for v in graph.predecessors(node)]
 
		'''
		from remove_cycle_edges_by_agony import get_agonies
		pair_agony_dict = get_agonies(target_edges,players)
		from helper_funs import pick_from_dict
		pair_max_agony,agony = pick_from_dict(pair_agony_dict)
		print("edge with max agony: %s, max agony: %0.4f" % (pair_max_agony,agony))
		target_edges = [pair_max_agony]
		'''
 
		edges_to_be_removed += target_edges
		graph.remove_edges_from(target_edges)
 
		sub_graphs = filter_big_scc(graph,target_edges)
		if sub_graphs:
			sccs += sub_graphs
		if not sccs:
			return 
 
def scores_of_nodes_in_scc(sccs,players):
	from s_c_c import nodes_in_scc
	scc_nodes = nodes_in_scc(sccs)
	scc_nodes_score_dict = {}
	for node in scc_nodes:
		scc_nodes_score_dict[node] = players[node]
	#print("# scores of nodes in scc: %d" % (len(scc_nodes_score_dict)))
	return scc_nodes_score_dict
 
 
def scc_based_to_remove_cycle_edges_iterately(g,nodes_score,is_Forward):
	big_sccs = get_big_sccs(g)
	if len(big_sccs) == 0:
		print("After removal of self loop edgs: %s" % nx.is_directed_acyclic_graph(g))
		return []
	scc_nodes_score_dict = scores_of_nodes_in_scc(big_sccs,nodes_score)
	edges_to_be_removed = []
	remove_cycle_edges_by_ranking_score_iterately(big_sccs,scc_nodes_score_dict,edges_to_be_removed,is_Forward)
	#print(" # edges to be removed: %d" % len(edges_to_be_removed))
	return edges_to_be_removed
 
def remove_cycle_edges_BF_iterately(g,players,is_Forward = True,score_name = "socialagony"):
	from remove_self_loops import remove_self_loops_from_graph
	self_loops = remove_self_loops_from_graph(g)
	edges_to_be_removed = scc_based_to_remove_cycle_edges_iterately(g,players,is_Forward)
	edges_to_be_removed = list(set(edges_to_be_removed))
	return edges_to_be_removed+self_loops