def test_sort_nodes_by_degree(graph: Graph):
sort_nodes_by_degree(graph)
assert len(graph.edge_ids(0)) == 103
last_node_n_edges = 103
for n in range(1, NODES_TO_SAMPLE):
v = len(graph.edge_ids(n))
assert v <= last_node_n_edges
last_node_n_edges = v
def test_sort_all_edges_by_dest(graph: Graph):
original_dests = [[graph.get_edge_dest(e) for e in graph.edge_ids(n)]
for n in range(NODES_TO_SAMPLE)]
mapping = sort_all_edges_by_dest(graph)
new_dests = [[graph.get_edge_dest(e) for e in graph.edge_ids(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] for e in graph.edge_ids(n)]
for i, _ in enumerate(my_mapping):
assert original_dests[n][i] == new_dests[n][my_mapping[i] -
graph.edge_ids(n)[0]]
original_dests[n].sort()
assert original_dests[n] == new_dests[n]
def count_in_and_out_degree(graph: Graph, nout, nin, nid):
out_degree = 0
for edge in graph.edge_ids(nid):
out_degree += 1
dst = graph.get_edge_dest(edge)
atomic_add(nin, dst, 1)
nout[nid] = out_degree
def count_weighted_in_and_out_degree(graph: Graph, nout, nin, weight_array,
nid):
out_degree = 0
for edge in graph.edge_ids(nid):
weight = weight_array[edge]
out_degree += weight
dst = graph.get_edge_dest(edge)
atomic_add(nin, dst, weight)
nout[nid] = out_degree
def cc_pull_topo_operator(graph: Graph, changed, comp_current: np.ndarray,
nid):
for ii in graph.edge_ids(nid):
dst = graph.get_edge_dest(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_async_kcore_operator(graph: Graph, current_degree, k_core_num, nid,
ctx):
# Decrement degree of all the neighbors of dead node
for ii in graph.edge_ids(nid):
dst = graph.get_edge_dest(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 compute_pagerank_pull_residual_operator(graph: Graph, delta, residual,
nid):
total = 0
for ii in graph.edge_ids(nid):
dst = graph.get_edge_dest(ii)
if delta[dst] > 0:
total += delta[dst]
if total > 0:
residual[nid] = total
def sssp_operator(g: Graph, dists: np.ndarray, edge_weights, item,
ctx: UserContext):
if dists[item.src] < item.dist:
return
for ii in g.edge_ids(item.src):
dst = g.get_edge_dest(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: Graph, 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.edge_ids(nid):
dst = graph.get_edge_dest(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: Graph,
next_level: InsertBag[np.uint64],
next_level_number: int,
distance: np.ndarray,
nid,
):
for ii in graph.edge_ids(nid):
dst = graph.get_edge_dest(ii)
if distance[dst] == distance_infinity:
distance[dst] = next_level_number
next_level.push(dst)
def test_triangle_count():
graph = Graph(get_input("propertygraphs/rmat15_cleaned_symmetric"))
original_first_edge_list = [
graph.get_edge_dest(e) for e in graph.edge_ids(0)
]
n = triangle_count(graph)
assert n == 282617
n = triangle_count(graph, TriangleCountPlan.node_iteration())
assert n == 282617
n = triangle_count(graph, TriangleCountPlan.edge_iteration())
assert n == 282617
assert [graph.get_edge_dest(e)
for e in graph.edge_ids(0)] == original_first_edge_list
sort_all_edges_by_dest(graph)
n = triangle_count(graph,
TriangleCountPlan.ordered_count(edges_sorted=True))
assert n == 282617
def sum_degree_operator(
graph: Graph,
source_degree,
sum_source: ReduceSum[np.uint64],
destination_degree,
sum_destination: ReduceSum[np.uint64],
nid,
):
for edge in graph.edge_ids(nid):
sum_source.update(source_degree[nid])
dst = graph.get_edge_dest(edge)
sum_destination.update(destination_degree[dst])
def degree_assortativity_coefficient_operator(
graph: Graph,
source_degree,
source_average,
destination_degree,
destination_average,
product_of_dev: ReduceSum[float],
square_of_source_dev: ReduceSum[float],
square_of_destination_dev: ReduceSum[float],
nid,
):
# deviation of source node from average
source_dev = source_degree[nid] - source_average
for edge in graph.edge_ids(nid):
dst = graph.get_edge_dest(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 test_subgraph_extraction():
graph = Graph(get_input("propertygraphs/rmat15_cleaned_symmetric"))
sort_all_edges_by_dest(graph)
nodes = [1, 3, 11, 120]
expected_edges = [[
nodes.index(graph.get_edge_dest(e)) for e in graph.edge_ids(i)
if graph.get_edge_dest(e) in nodes
] for i in nodes]
pg = subgraph_extraction(graph, nodes)
assert isinstance(pg, Graph)
assert len(pg) == len(nodes)
assert pg.num_edges() == 6
for i, _ in enumerate(expected_edges):
assert len(pg.edge_ids(i)) == len(expected_edges[i])
assert [pg.get_edge_dest(e)
for e in pg.edge_ids(i)] == expected_edges[i]
def compute_out_deg_operator(graph: Graph, nout, nid):
"""Operator for computing outdegree of nodes in the Graph"""
for ii in graph.edge_ids(nid):
dst = graph.get_edge_dest(ii)
atomic_add(nout, dst, 1)
def compute_degree_count_operator(graph: Graph, current_degree, nid):
"""
Operator to initialize degree fields in graph with current degree. Since symmetric,
out edge count is equivalent to in-edge count.
"""
current_degree[nid] = len(graph.edge_ids(nid))