def bfs_sync_pg(graph: PropertyGraph, source, property_name): next_level_number = 0 curr_level = InsertBag[np.uint64]() next_level = InsertBag[np.uint64]() timer = StatTimer("BFS Property Graph Numba: " + property_name) timer.start() distance = np.empty((len(graph), ), dtype=np.uint32) initialize(graph, source, distance) next_level.push(source) while not next_level.empty(): curr_level.swap(next_level) next_level.clear() next_level_number += 1 do_all( curr_level, bfs_sync_operator_pg(graph, next_level, next_level_number, distance), steal=True, loop_name="bfs_sync_pg", ) timer.stop() graph.add_node_property(pyarrow.table({property_name: distance}))
def kcore_async(graph: PropertyGraph, k_core_num, property_name): num_nodes = graph.num_nodes() initial_worklist = InsertBag[np.uint64]() current_degree = LargeArray[np.uint64](num_nodes, AllocationPolicy.INTERLEAVED) timer = StatTimer("Kcore: Property Graph Numba: " + property_name) timer.start() # Initialize do_all( range(num_nodes), compute_degree_count_operator(graph, current_degree.as_numpy()), steal=True, ) # Setup initial worklist do_all( range(num_nodes), setup_initial_worklist_operator(initial_worklist, current_degree.as_numpy(), k_core_num), steal=True, ) # Compute k-core for_each( initial_worklist, compute_async_kcore_operator(graph, current_degree.as_numpy(), k_core_num), steal=True, disable_conflict_detection=True, ) timer.stop() # Add the ranks as a new property to the property graph graph.add_node_property(pyarrow.table({property_name: current_degree}))
def cc_push_topo(graph: PropertyGraph, property_name): print("Executing Push algo\n") num_nodes = graph.num_nodes() timer = StatTimer("CC: Property Graph Numba: " + property_name) timer.start() # Stores the component id assignment comp_current = np.empty((num_nodes, ), dtype=np.uint32) comp_old = np.empty((num_nodes, ), dtype=np.uint32) # Initialize do_all( range(num_nodes), initialize_cc_push_operator(graph, comp_current, comp_old), steal=True, loop_name="initialize_cc_push", ) # Execute while component ids are updated changed = GReduceLogicalOr() changed.update(True) while changed.reduce(): changed.reset() do_all( range(num_nodes), cc_push_topo_operator(graph, changed, comp_current, comp_old), steal=True, loop_name="cc_push_topo", ) timer.stop() # Add the component assignment as a new property to the property graph graph.add_node_property(pyarrow.table({property_name: comp_current}))
def calculate_degree(graph: PropertyGraph, in_degree_property, out_degree_property, weight_property=None): """ Calculate the (potentially weighted) in and out degrees of a graph. The function will modify the given graph by adding two new node properties, one for the in degree and one for the out degree. Nothing is returned. Parameters: graph: a PropertyGraph in_degree_property: the property name for the in degree out_degree_property: the property name for the out degree weight_property: an edge property to use in calculating the weighted degree """ num_nodes = graph.num_nodes() nout = LargeArray[np.uint64](num_nodes, AllocationPolicy.INTERLEAVED) nin = LargeArray[np.uint64](num_nodes, AllocationPolicy.INTERLEAVED) do_all(range(num_nodes), initialize_in_degree(nin.as_numpy()), steal=False) # are we calculating weighted degree? if not weight_property: count_operator = count_in_and_out_degree(graph, nout.as_numpy(), nin.as_numpy()) else: count_operator = count_weighted_in_and_out_degree( graph, nout.as_numpy(), nin.as_numpy(), graph.get_edge_property(weight_property)) do_all(range(num_nodes), count_operator, steal=True) graph.add_node_property( pyarrow.table({ in_degree_property: nin, out_degree_property: nout }))
def test_assert_valid(property_graph: PropertyGraph): with raises(AssertionError): bfs_assert_valid(property_graph, "workFrom") property_name = "NewProp" start_node = 0 bfs(property_graph, start_node, property_name) v = property_graph.get_node_property(property_name).to_numpy().copy() v[0] = 100 property_graph.add_node_property(table({"Prop2": v})) with raises(AssertionError): bfs_assert_valid(property_graph, "Prop2")
def pagerank_pull_sync_residual(graph: PropertyGraph, maxIterations, tolerance, property_name): num_nodes = graph.num_nodes() rank = LargeArray[float](num_nodes, AllocationPolicy.INTERLEAVED) nout = LargeArray[np.uint64](num_nodes, AllocationPolicy.INTERLEAVED) delta = LargeArray[float](num_nodes, AllocationPolicy.INTERLEAVED) residual = LargeArray[float](num_nodes, AllocationPolicy.INTERLEAVED) # Initialize do_all( range(num_nodes), initialize_residual_operator(rank.as_numpy(), nout.as_numpy(), delta.as_numpy(), residual.as_numpy(),), steal=True, loop_name="initialize_pagerank_pull_residual", ) # Compute out-degree for each node do_all( range(num_nodes), compute_out_deg_operator(graph, nout.as_numpy()), steal=True, loop_name="Compute_out_degree", ) print("Out-degree of 0: ", nout[0]) changed = GReduceLogicalOr(True) iterations = 0 timer = StatTimer("Pagerank: Property Graph Numba: " + property_name) timer.start() while iterations < maxIterations and changed.reduce(): print("Iter: ", iterations, "\n") changed.reset() iterations += 1 do_all( range(num_nodes), compute_pagerank_pull_delta_operator( rank.as_numpy(), nout.as_numpy(), delta.as_numpy(), residual.as_numpy(), tolerance, changed, ), steal=True, loop_name="pagerank_delta", ) do_all( range(num_nodes), compute_pagerank_pull_residual_operator(graph, delta.as_numpy(), residual.as_numpy()), steal=True, loop_name="pagerank", ) timer.stop() # Add the ranks as a new property to the property graph graph.add_node_property(pyarrow.table({property_name: rank}))
def sssp(graph: PropertyGraph, source, length_property, shift, property_name): dists = create_distance_array(graph, source, length_property) # Define the struct type here so it can depend on the type of the weight property UpdateRequest = np.dtype([("src", np.uint32), ("dist", dists.dtype)]) init_bag = InsertBag[UpdateRequest]() init_bag.push((source, 0)) t = StatTimer("Total SSSP") t.start() for_each( init_bag, sssp_operator(graph, dists, graph.get_edge_property(length_property)), worklist=OrderedByIntegerMetric(obim_indexer(shift)), disable_conflict_detection=True, loop_name="SSSP", ) t.stop() print("Elapsed time: ", t.get(), "milliseconds.") graph.add_node_property(pyarrow.table({property_name: dists}))