def test_sort_all_edges_by_dest(property_graph: PropertyGraph):
original_dests = [[property_graph.get_edge_dst(e) for e in property_graph.edges(n)] for n in range(NODES_TO_SAMPLE)]
mapping = sort_all_edges_by_dest(property_graph)
new_dests = [[property_graph.get_edge_dst(e) for e in property_graph.edges(n)] for n in range(NODES_TO_SAMPLE)]
for n in range(NODES_TO_SAMPLE):
assert len(original_dests[n]) == len(new_dests[n])
my_mapping = [mapping[e].as_py() for e in property_graph.edges(n)]
for i in range(len(my_mapping)):
assert original_dests[n][i] == new_dests[n][my_mapping[i] - property_graph.edges(n)[0]]
original_dests[n].sort()
assert original_dests[n] == new_dests[n]
def count_in_and_out_degree(graph: PropertyGraph, nout, nin, nid):
out_degree = 0
for edge in graph.edges(nid):
out_degree += 1
dst = graph.get_edge_dst(edge)
atomic_add(nin, dst, 1)
nout[nid] = out_degree
def test_triangle_count():
property_graph = PropertyGraph(get_input("propertygraphs/rmat15_cleaned_symmetric"))
original_first_edge_list = [property_graph.get_edge_dst(e) for e in property_graph.edges(0)]
n = triangle_count(property_graph)
assert n == 282617
n = triangle_count(property_graph, TriangleCountPlan.node_iteration())
assert n == 282617
n = triangle_count(property_graph, TriangleCountPlan.edge_iteration())
assert n == 282617
assert [property_graph.get_edge_dst(e) for e in property_graph.edges(0)] == original_first_edge_list
sort_all_edges_by_dest(property_graph)
n = triangle_count(property_graph, TriangleCountPlan.ordered_count(edges_sorted=True))
assert n == 282617
def compute_async_kcore_operator(graph: PropertyGraph, current_degree, k_core_num, nid, ctx):
# Decrement degree of all the neighbors of dead node
for ii in graph.edges(nid):
dst = graph.get_edge_dst(ii)
old_degree = atomic_sub(current_degree, dst, 1)
# Add new dead nodes to the worklist
if old_degree == k_core_num:
ctx.push(dst)
def cc_pull_topo_operator(graph: PropertyGraph, changed,
comp_current: np.ndarray, nid):
for ii in graph.edges(nid):
dst = graph.get_edge_dst(ii)
# Pull the minimum component from your neighbors
if comp_current[nid] > comp_current[dst]:
comp_current[nid] = comp_current[dst]
# Indicates that update happened
changed.update(True)
def compute_pagerank_pull_residual_operator(graph: PropertyGraph, delta, residual, nid):
sum = 0
for ii in graph.edges(nid):
dst = graph.get_edge_dst(ii)
if delta[dst] > 0:
sum += delta[dst]
if sum > 0:
residual[nid] = sum
def count_weighted_in_and_out_degree(graph: PropertyGraph, nout, nin,
weight_array, nid):
out_degree = 0
for edge in graph.edges(nid):
weight = weight_array[edge]
out_degree += weight
dst = graph.get_edge_dst(edge)
atomic_add(nin, dst, weight)
nout[nid] = out_degree
def sssp_operator(g: PropertyGraph, dists: np.ndarray, edge_weights, item,
ctx: UserContext):
if dists[item.src] < item.dist:
return
for ii in g.edges(item.src):
dst = g.get_edge_dst(ii)
edge_length = edge_weights[ii]
new_distance = edge_length + dists[item.src]
old_distance = atomic_min(dists, dst, new_distance)
if new_distance < old_distance:
ctx.push((dst, new_distance))
def cc_push_topo_operator(graph: PropertyGraph, changed,
comp_current: np.ndarray, comp_old: np.ndarray, nid):
if comp_old[nid] > comp_current[nid]:
comp_old[nid] = comp_current[nid]
# Indicates that update happened
changed.update(True)
for ii in graph.edges(nid):
dst = graph.get_edge_dst(ii)
new_comp = comp_current[nid]
# Push the minimum component to your neighbors
atomic_min(comp_current, dst, new_comp)
def bfs_sync_operator_pg(
graph: PropertyGraph,
next_level: InsertBag[np.uint64],
next_level_number: int,
distance: np.ndarray,
nid,
):
for ii in graph.edges(nid):
dst = graph.get_edge_dst(ii)
if distance[dst] == distance_infinity:
distance[dst] = next_level_number
next_level.push(dst)
def sum_degree_operator(
graph: PropertyGraph,
source_degree,
sum_source: GAccumulator[np.uint64],
destination_degree,
sum_destination: GAccumulator[np.uint64],
nid,
):
for edge in graph.edges(nid):
sum_source.update(source_degree[nid])
dst = graph.get_edge_dst(edge)
sum_destination.update(destination_degree[dst])
def degree_assortativity_coefficient_operator(
graph: PropertyGraph,
source_degree,
source_average,
destination_degree,
destination_average,
product_of_dev: GAccumulator[float],
square_of_source_dev: GAccumulator[float],
square_of_destination_dev: GAccumulator[float],
nid,
):
# deviation of source node from average
source_dev = source_degree[nid] - source_average
for edge in graph.edges(nid):
dst = graph.get_edge_dst(edge)
destination_dev = destination_degree[dst] - destination_average
product_of_dev.update(source_dev * destination_dev)
square_of_source_dev.update(source_dev * source_dev)
square_of_destination_dev.update(destination_dev * destination_dev)
def compute_out_deg_operator(graph: PropertyGraph, nout, nid):
"""Operator for computing outdegree of nodes in the Graph"""
for ii in graph.edges(nid):
dst = graph.get_edge_dst(ii)
atomic_add(nout, dst, 1)
