def creaRandom(): # CREAZIONE RANDOM DEL GRAFO g = Graph() for i in range(100): g.insert_vertex(i) nodi = g.vertices() for i in range(0, len(nodi)): while True: peso = randint(1, 1000000000) if g.peso_unico(peso): if i + 1 == len(nodi): g.insert_edge(nodi[i], nodi[0], peso) break else: g.insert_edge(nodi[i], nodi[i + 1], peso) break for node in nodi: i = 0 while i < 3: peso = randint(1, 1000000000) # NUMERO MOLTO GRANDE PER AVERE QUASI LA CERTEZZA DI NON AVERE ARCHI CON LO STESSO PESO # LA FUNZIONE PER IL CONTROLLO è PRESENTE NELA CLASSE DEL GRAFO MA IMPIEGA MOLTO TEMPO nodo2 = randint(0, 9999) if nodo2 != node.element() and g.get_edge( node, nodi[nodo2]) is None and g.peso_unico(peso): i = i + 1 g.insert_edge(node, nodi[nodo2], peso) return g
def grafi_connessi(): g = Graph() g2=Graph() dict_edge={} n=100 g_seq=Graph_seq(n) for i in range(n): v0=g.insert_vertex(i) g2.insert_vertex(i) v0.connessioni=Array("i",n,lock=False) v0.pesi_condivisi=Array("i",n,lock=False) nodi=g.vertices() for i in range(len(nodi)): print(i) j=i+1 for x in range(j,len(nodi)): while True: peso = randint( 1, 100000000 ) if g.peso_unico(peso): e=g.insert_edge( nodi[i], nodi[x], peso ) g_seq.addEdge(i,x,peso) dict_edge[e.element()]=e nodi[i].pesi_condivisi[nodi[x].element()]=peso nodi[x].pesi_condivisi[nodi[i].element()]=peso nodi[i].connessioni[len(nodi[i].listaArchi)-1]=nodi[x].element() nodi[x].connessioni[len(nodi[x].listaArchi)-1]=nodi[i].element() break lista_pesi_condivisi=[] lista_connessioni_condivise=[] for node in nodi: if len(node.listaArchi)<n: node.connessioni[len(node.listaArchi)]=-1 lista_pesi_condivisi.append(node.pesi_condivisi) lista_connessioni_condivise.append(node.connessioni) return g,g_seq,lista_pesi_condivisi,lista_connessioni_condivise,dict_edge
def creaRandom(): # CREAZIONE RANDOM DEL GRAFO g = Graph() g2=Graph() dict_edge={} n=100 g_seq=Graph_seq(n) for i in range(n): v0=g.insert_vertex(i) g2.insert_vertex(i) v0.connessioni=Array("i",n,lock=False) v0.pesi_condivisi=Array("i",n,lock=False) #print(i) #v0.archi_condivisi=m.list([0 for x in range(n-1)]) nodi=g.vertices() nodi2=g2.vertices() for i in range(0,len(nodi)): while True: peso = randint( 1, 100000000 ) if g.peso_unico(peso): if i+1==len(nodi): e=g.insert_edge( nodi[i], nodi[0], peso ) g_seq.addEdge(i,0,peso) dict_edge[e.element()]=e nodi[i].pesi_condivisi[nodi[0].element()]=peso nodi[0].pesi_condivisi[nodi[i].element()]=peso nodi[i].connessioni[len(nodi[i].listaArchi)-1]=nodi[0].element() nodi[0].connessioni[len(nodi[0].listaArchi)-1]=nodi[i].element() g2.insert_edge( nodi2[i], nodi2[0], peso ) break else: e=g.insert_edge( nodi[i], nodi[i+1], peso ) dict_edge[e.element()]=e g_seq.addEdge(i,i+1,peso) nodi[i].pesi_condivisi[nodi[i+1].element()]=peso nodi[i+1].pesi_condivisi[nodi[i].element()]=peso nodi[i].connessioni[len(nodi[i].listaArchi)-1]=nodi[i+1].element() nodi[i+1].connessioni[len(nodi[i+1].listaArchi)-1]=nodi[i].element() g2.insert_edge( nodi2[i], nodi2[i+1], peso ) break lista_archi_condivisi=[] for node in nodi: i=0 #print(node,flush=True) print("node",node,flush=True) while i<1: peso = randint( 1, 100000000 ) # NUMERO MOLTO GRANDE PER AVERE QUASI LA CERTEZZA DI NON AVERE ARCHI CON LO STESSO PESO # LA FUNZIONE PER IL CONTROLLO è PRESENTE NELA CLASSE DEL GRAFO MA IMPIEGA MOLTO TEMPO nodo2 = randint(0, n-1) if nodo2 != node.element() and g.get_edge(node,nodi[nodo2]) is None and g.peso_unico(peso): e=g.insert_edge( node, nodi[nodo2], peso ) g_seq.addEdge(node.element(),nodo2,peso) dict_edge[e.element()]=e g2.insert_edge( nodi2[node.element()], nodi2[nodo2], peso ) node.pesi_condivisi[nodi[nodo2].element()]=peso nodi[nodo2].pesi_condivisi[node.element()]=peso node.connessioni[len(node.listaArchi)-1]=nodi[nodo2].element() nodi[nodo2].connessioni[len( nodi[nodo2].listaArchi)-1]=node.element() i=i+1 lista_pesi_condivisi=[] lista_connessioni_condivise=[] for node in nodi: if len(node.listaArchi)<n: node.connessioni[len(node.listaArchi)]=-1 lista_pesi_condivisi.append(node.pesi_condivisi) lista_connessioni_condivise.append(node.connessioni) return g,g_seq,lista_pesi_condivisi,lista_connessioni_condivise,dict_edge
def Boruvka_parallel_array(g,lista_pesi_condivisi,lista_connessioni,dict_edge): grafoB = Graph() lista_nodi = g.vertices() for node in lista_nodi: grafoB.insert_vertex( node.element() ) peso_albero=0 parent = Array( "i", g.vertex_count(), lock=False ) successor_next =Array( "i",g.vertex_count(), lock=False ) result=Array("i",g.vertex_count(),lock=False) jobs_min=JoinableQueue() processes_minimo=minimo_paralelo(parent,successor_next,lista_pesi_condivisi,lista_connessioni,jobs_min,result) lista_nodi_boruvka=grafoB.vertices() t66=time() while len( lista_nodi ) > 1: lista_divisa_interi=dividi_gruppi(lista_nodi,8) t2=time() add_jobs(jobs_min,lista_divisa_interi,0) jobs_min.join() for node in lista_nodi: edge=dict_edge[result[node.element()]] n1,n2=edge.endpoints_posizione() e=grafoB.insert_edge(lista_nodi_boruvka[n1],lista_nodi_boruvka[n2] ,edge.element()) if e is not None: peso_albero+=edge.element() for node in lista_nodi: i=node.element() parent_opposto = parent[parent[i]] if i == parent_opposto: if i < parent[i]: parent[i] = i else: parent[parent[i]] = parent[i] while True: bool = True add_jobs(jobs_min,lista_divisa_interi,1) jobs_min.join() for x, y in zip( parent, successor_next ): if x != y: bool = False break if bool: break add_jobs(jobs_min,lista_divisa_interi,2) jobs_min.join() for node in lista_nodi: node.root =parent[node.element()] node.setElement( node.root ) dict_merge={} for node in lista_nodi: if node.root==node.posizione: dict_merge[node.root]=[] add_jobs(jobs_min,lista_divisa_interi,3) jobs_min.join() lista=[x for x in lista_nodi] lista_nodi=[] for node in lista: if node.posizione!=node.root: dict_merge[node.root].append(node.posizione) else: lista_nodi.append(node) if len(lista_nodi)<=1: break add_jobs(jobs_min,dict_merge,4) jobs_min.join() for pr in processes_minimo: pr.terminate() return (grafoB,peso_albero)
def creaRandom(): # CREAZIONE RANDOM DEL GRAFO g = Graph() g_sequenziale = Graph() g_parallel_array = Graph() g_parallel_queue = Graph() g_prim = Graph2() dict_edge = {} n = 10000 for i in range(n): g_sequenziale.insert_vertex(i) v1 = g_parallel_queue.insert_vertex(i) v2 = g_parallel_array.insert_vertex(i) v1.connessioni = Array("i", n, lock=False) v1.pesi_condivisi = Array("i", n, lock=False) v2.connessioni = Array("i", n, lock=False) v2.pesi_condivisi = Array("i", n, lock=False) g_prim.insert_vertex(i) g.insert_vertex(i) nodi = g.vertices() nodi_sequenziale = g_sequenziale.vertices() nodi_array = g_parallel_array.vertices() nodi_queue = g_parallel_queue.vertices() nodi_prim = g_prim.vertices() for i in range(0, len(nodi)): while True: peso = randint(1, 100000000) if g.peso_unico(peso): if i + 1 == len(nodi): e = g.insert_edge(nodi[i], nodi[0], peso) dict_edge[e.element()] = e g_prim.insert_edge(nodi_prim[i], nodi_prim[0], peso) g_sequenziale.insert_edge(nodi_sequenziale[i], nodi_sequenziale[0], peso) g_parallel_array.insert_edge(nodi_array[i], nodi_array[0], peso) g_parallel_queue.insert_edge(nodi_queue[i], nodi_queue[0], peso) nodi_queue[i].pesi_condivisi[ nodi_queue[0].element()] = peso nodi_queue[0].pesi_condivisi[ nodi_queue[i].element()] = peso nodi_queue[i].connessioni[len(nodi_queue[i].listaArchi) - 1] = nodi_queue[0].element() nodi_queue[0].connessioni[len(nodi_queue[0].listaArchi) - 1] = nodi_queue[i].element() nodi_array[i].pesi_condivisi[ nodi_array[0].element()] = peso nodi_array[0].pesi_condivisi[ nodi_array[i].element()] = peso nodi_array[i].connessioni[len(nodi_array[i].listaArchi) - 1] = nodi_array[0].element() nodi_array[0].connessioni[len(nodi_array[0].listaArchi) - 1] = nodi_array[i].element() break else: e = g.insert_edge(nodi[i], nodi[i + 1], peso) dict_edge[e.element()] = e g_prim.insert_edge(nodi_prim[i], nodi_prim[i + 1], peso) g_sequenziale.insert_edge(nodi_sequenziale[i], nodi_sequenziale[i + 1], peso) g_parallel_array.insert_edge(nodi_array[i], nodi_array[i + 1], peso) g_parallel_queue.insert_edge(nodi_queue[i], nodi_queue[i + 1], peso) nodi_queue[i].pesi_condivisi[nodi_queue[ i + 1].element()] = peso nodi_queue[i + 1].pesi_condivisi[ nodi_queue[i].element()] = peso nodi_queue[i].connessioni[len(nodi_queue[i].listaArchi) - 1] = nodi_queue[i + 1].element() nodi_queue[i + 1].connessioni[len(nodi_queue[i + 1].listaArchi) - 1] = nodi_queue[i].element() nodi_array[i].pesi_condivisi[nodi_array[ i + 1].element()] = peso nodi_array[i + 1].pesi_condivisi[ nodi_array[i].element()] = peso nodi_array[i].connessioni[len(nodi_array[i].listaArchi) - 1] = nodi_array[i + 1].element() nodi_array[i + 1].connessioni[len(nodi_array[i + 1].listaArchi) - 1] = nodi_array[i].element() break for node in nodi: i = 0 while i < 99: peso = randint(1, 100000000) # NUMERO MOLTO GRANDE PER AVERE QUASI LA CERTEZZA DI NON AVERE ARCHI CON LO STESSO PESO # LA FUNZIONE PER IL CONTROLLO è PRESENTE NELA CLASSE DEL GRAFO MA IMPIEGA MOLTO TEMPO nodo2 = randint(0, n - 1) if nodo2 != node.element() and g.get_edge( node, nodi[nodo2]) is None and g.peso_unico(peso): e = g.insert_edge(node, nodi[nodo2], peso) dict_edge[e.element()] = e g_sequenziale.insert_edge(nodi_sequenziale[node.element()], nodi_sequenziale[nodo2], peso) g_parallel_array.insert_edge(nodi_array[node.element()], nodi_array[nodo2], peso) g_parallel_queue.insert_edge(nodi_queue[node.element()], nodi_queue[nodo2], peso) g_prim.insert_edge(nodi_prim[node.element()], nodi_prim[nodo2], peso) nodi_queue[node.element()].pesi_condivisi[ nodi_queue[nodo2].element()] = peso nodi_queue[nodo2].pesi_condivisi[nodi_queue[ node.element()].element()] = peso nodi_queue[node.element()].connessioni[ len(nodi_queue[node.element()].listaArchi) - 1] = nodi_queue[nodo2].element() nodi_queue[nodo2].connessioni[ len(nodi_queue[nodo2].listaArchi) - 1] = nodi_queue[node.element()].element() nodi_array[node.element()].pesi_condivisi[ nodi_array[nodo2].element()] = peso nodi_array[nodo2].pesi_condivisi[nodi_array[ node.element()].element()] = peso nodi_array[node.element()].connessioni[ len(nodi_array[node.element()].listaArchi) - 1] = nodi_array[nodo2].element() nodi_array[nodo2].connessioni[ len(nodi_array[nodo2].listaArchi) - 1] = nodi_array[node.element()].element() i = i + 1 lista_pesi_condivisi_queue = [] lista_connessioni_condivise_queue = [] lista_connessioni_condivise_array = [] lista_pesi_condivisi_array = [] for node in nodi_array: if len(node.listaArchi) < n: node.connessioni[len(node.listaArchi)] = -1 lista_pesi_condivisi_array.append(node.pesi_condivisi) lista_connessioni_condivise_array.append(node.connessioni) for node in nodi_queue: if len(node.listaArchi) < n: node.connessioni[len(node.listaArchi)] = -1 lista_pesi_condivisi_queue.append(node.pesi_condivisi) lista_connessioni_condivise_queue.append(node.connessioni) return g,g_sequenziale,g_parallel_array,g_parallel_queue,\ g_prim,lista_pesi_condivisi_array,\ lista_connessioni_condivise_array,lista_pesi_condivisi_queue,lista_connessioni_condivise_queue,dict_edge
if __name__ == "__main__": g,g_sequenziale,g_parallel_array,g_parallel_queue,g_prim\ ,lista_pesi_condivisi_array,lista_connessioni_condivise_array,\ lista_pesi_condivisi_queue,lista_connessioni_condivise_queue,edge_dict=creaRandom() print("NUMERO DI NODI: {}, NUMERO DI ARCHI: {}".format( g.vertex_count(), g.edges_count()), flush=True) lista_nodi_originale = g.vertices() parent = [0 for node in g.vertices()] successor_next = [0 for node in g.vertices()] mst = Graph() for node in g.vertices(): mst.insert_vertex(node.element()) costo_mst = 0 lista_nodi_mst = mst.vertices() nodi_rimanenti = g.vertices() n_process = 8 comm = MPI.COMM_SELF.Spawn( sys.executable, args=[os.path.dirname(sys.argv[0]) + "\child_processes.py"], maxprocs=n_process) tempo_parallelo = time() cont_time = 0 processi_attivi = [True for i in range(n_process)]
def Boruvka_seq(g): lista_nodi = g.vertices() peso_albero = 0 mst = Graph() for node in g.vertices(): mst.insert_vertex(node.element()) parent = [-1] * g.vertex_count() tempo_ricerca = 0 tempo_pointer = 0 tempo_merge = 0 while len(lista_nodi) > 1: tempo_ricerca_parziale = time() for node in lista_nodi: minedge = None for edge in node.incident_edges(): if minedge == None or minedge.element() > edge.element(): minedge = edge n1, n2 = edge.endpoints() if n1 == node.element(): parent[node.element()] = n2 else: parent[node.element()] = n1 if minedge is not None: n1, n2 = minedge.endpoints_posizione() e = mst.insert_edge(mst.vertices()[n1], mst.vertices()[n2], minedge.element()) if e is not None: peso_albero += minedge.element() #print(e,flush=True) tempo_ricerca += (time() - tempo_ricerca_parziale) for node in lista_nodi: node_parent = parent[node.element()] parent_parent = parent[parent[node.element()]] if node.element() == parent_parent: if node.element() < node_parent: parent[node.element()] = node.element() else: parent[node_parent] = node_parent tempo_pointer_parziale = time() findRoot(parent) tempo_pointer += (time() - tempo_pointer_parziale) for nodo in lista_nodi: nodo.root = g.vertices()[parent[nodo.element()]] nodo.setElement(nodo.root.element()) for edge in nodo.incident_edges(): n1, n2 = edge.endpoints() edge.setElement(parent[n1], parent[n2]) i = 0 tempo_merge_parziale = time() while i < len(lista_nodi): node = lista_nodi[i] if node.root != node: merge(node, node.root) lista_nodi.pop(i) else: i = i + 1 delete_multi_edges(lista_nodi) tempo_merge += (time() - tempo_merge_parziale) print( "TEMPO RICERCA ARCHI MINIMI :{}, TEMPO POINTER JUMPING:{}, TEMPO MERGE:{}" .format(tempo_ricerca, tempo_pointer, tempo_merge)) return (mst, peso_albero)