graphanalysis Namespace Reference

Functions
def	read_graph_from_json (filename)
def	analyze_and_fix_cycles (gr)
def	analyze_connected_componets (gr)
def	analyze_critical_path (gr)
def	print_graph_to_json (gr, filename)

Variables
	filename
	gr
	had_to_fix_cycles

Function Documentation

analyze_and_fix_cycles()

def graphanalysis.analyze_and_fix_cycles

(

gr

)

Definition at line 45 of file graphanalysis.py.

def analyze_and_fix_cycles(gr):
    has_loop = True
    n_cycles = 0
    while has_loop:
        cycle = find_cycle(gr)
        if len(cycle) == 0:
            has_loop = False
            continue
        n_cycles += 1
        print(cycle)
        print("Removed loop by deleting edge (%s,%s)" % (cycle[-1], cycle[0]))
        gr.del_edge((cycle[-1], cycle[0]))
    print("\nIN TOTAL %i CYCLES\n" % (n_cycles))
    return n_cycles > 0  # whether it needed to fix cycles
 
 

analyze_connected_componets()

def graphanalysis.analyze_connected_componets

(

gr

)

Definition at line 61 of file graphanalysis.py.

def analyze_connected_componets(gr):
    cc = connected_components(gr)
    cc_size = {}
    for i in cc.values():
        cc_size[i] = 0
    for k, v in cc.iteritems():
        cc_size[v] = cc_size[v] + 1
    print("Connected components have the following size:")
    #    for k,v in cc_size.iteritems():
    #      print "%i : %i" %(k,v)
    print("NUMBER OF CONNECTED COMPONENTS: %i" % (len(cc_size.keys())))
 
 

analyze_critical_path()

def graphanalysis.analyze_critical_path

(

gr

)

Definition at line 74 of file graphanalysis.py.

def analyze_critical_path(gr):
    total_time = 0
    critical_time = 0
    cp = critical_path(gr)
    # calculate total time
    for edge in gr.edges():
        total_time += gr.edge_weight(edge)
 
    # calculate time of critical path
    edges = [tuple(cp[i : i + 2]) for i in range(0, len(cp))]
    for edge in edges:
        critical_time += gr.edge_weight(edge)
 
    print("Total time   : %s" % total_time)
    print("Critical path: %s" % critical_time)
    print("POSSIBLE SPEEDUP: %s" % (total_time / critical_time))
 
 

print_graph_to_json()

def graphanalysis.print_graph_to_json	(		gr,
			filename
	)

Definition at line 92 of file graphanalysis.py.

def print_graph_to_json(gr, filename):
    algorithms = {}  # still make it known to workflow
    known_names = set()
    for edge in gr.edges():
        if edge[0].endswith("_algo"):
            algoname = edge[0].rstrip("_algo")
            product = edge[1]
            reading = False
        else:
            algoname = edge[1].rstrip("_algo")
            product = edge[0]
            reading = True
 
        if algoname not in known_names:
            algorithms[algoname] = {
                "name": algoname,
                "inputs": [],
                "outputs": [],
                "runtimes": [1000],  # TODO dummy
                "runtimes_wall": [1000],  # TODO dummy
            }
            known_names.add(algoname)
        if reading:
            algorithms[algoname]["inputs"].append(product)
        else:
            algorithms[algoname]["outputs"].append(product)
            algorithms[algoname]["runtimes_wall"] = [
                gr.edge_weight(edge) / 100,
            ]
    out = open(filename, "w")
    algorithm_list = [item for item in algorithms.values()]
    workflow = {"algorithms": algorithm_list}
    out.write(workflow.__repr__())
    out.close()
 
 

read_graph_from_json()

def graphanalysis.read_graph_from_json

(

filename

)

Definition at line 18 of file graphanalysis.py.

def read_graph_from_json(filename):
    data = open(filename).read()
    workflow = eval(data)
    gr = digraph()
    # create all nodes
    for algo in workflow["algorithms"]:
        # to differentiate algos from equally named products
        name = algo["name"] + "_algo"
        gr.add_nodes([name])
        for input in algo["inputs"]:
            if input == "":
                input = "dummy"
            if not gr.has_node(input):
                gr.add_nodes([input])
            if not gr.has_edge((input, name)):
                gr.add_edge((input, name), wt=0)
        for output in algo["outputs"]:
            if output == "":
                output = "dummy"
            if not gr.has_node(output):
                gr.add_nodes([output])
            if not gr.has_edge((name, output)):
                # the output edge gets the weigth corresponding to the runtime
                gr.add_edge((name, output), wt=algo["runtimes_wall"][0] * 100)
    return gr
 
 

Variable Documentation

filename

graphanalysis.filename

Definition at line 130 of file graphanalysis.py.

gr

graphanalysis.gr

Definition at line 131 of file graphanalysis.py.

had_to_fix_cycles

graphanalysis.had_to_fix_cycles

Definition at line 134 of file graphanalysis.py.