From 46a8b0bde43f6d56f1ab6447d955d2e6615986cd Mon Sep 17 00:00:00 2001
From: Alexandria Barghi <abarghi@nvidia.com>
Date: Mon, 25 Mar 2024 09:57:25 -0700
Subject: [PATCH 01/33] dist sampler

---
 .../cugraph/gnn/data_loading/dist_sampler.py  | 109 ++++++++++++++++++
 1 file changed, 109 insertions(+)
 create mode 100644 python/cugraph/cugraph/gnn/data_loading/dist_sampler.py

diff --git a/python/cugraph/cugraph/gnn/data_loading/dist_sampler.py b/python/cugraph/cugraph/gnn/data_loading/dist_sampler.py
new file mode 100644
index 00000000000..dc3e81c297b
--- /dev/null
+++ b/python/cugraph/cugraph/gnn/data_loading/dist_sampler.py
@@ -0,0 +1,109 @@
+# Copyright (c) 2024, NVIDIA CORPORATION.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import pylibcugraph
+import numpy as np
+import cupy
+import cudf
+
+from typing import Union, List, Dict
+TensorType = Union['torch.Tensor', 'cupy.ndarray', 'cudf.Series']
+
+
+def nccl_init(rank: int, world_size: int, uid: int):
+    # calls a c++ function that calls ncclCommInitRank
+    # returns a resource handle and nccl communicator
+    # should wrap the resource handle and communicator in a CuGraph context object
+    pass
+
+class DistSampleWriter:
+    def __init__(self, format, directory, batches_per_partition):
+        self.__format = format
+        self.__directory = directory
+        self.__batches_per_partition = batches_per_partition
+    
+
+    
+    def write_minibatches(self, minibatch_dict):
+        if ("majors" in minibatch_dict) and ("minors" in minibatch_dict):
+            self.__write_minibatches_coo(minibatch_dict)
+        elif "major_offsets" in minibatch_dict and "minors" in minibatch_dict:
+            self.__write_minibatches_csr(minibatch_dict)
+        else:
+            raise ValueError("invalid columns")
+
+class DistSampler:
+    def __init__(self, graph: Union[pylibcugraph.SGGraph, pylibcugraph.MGGraph], writer: DistSampleWriter):
+        self.__graph = graph
+    
+    def sample_batches(self, nodes: TensorType, batch: TensorType, random_state: int):
+        raise NotImplementedError("Must be implemented by subclass")
+
+    def sample_from_nodes(self, nodes: TensorType, batch: TensorType, random_state: int):
+        minibatch_dict = self.sample_batches(nodes=nodes, batch=batch, random_state=random_state)
+        self.__writer.write_minibatches(minibatch_dict)
+
+
+    @property
+    def is_multi_gpu(self):
+        return isinstance(self.__graph, pylibcugraph.MGGraph)
+
+class UniformNeighborSampler(DistSampler):
+    def __init__(
+            self,
+            graph: Union[pylibcugraph.SGGraph, pylibcugraph.MGGraph],
+            fanout: List[int],
+            prior_sources_behavior: str,
+            deduplicate_sources: bool,
+            return_hops: bool,
+            renumber: bool,
+            compression: str,
+            compress_per_hop:bool):
+        super(graph)
+        self.__fanout = fanout
+        self.__prior_sources_behavior = prior_sources_behavior
+        self.__deduplicate_sources = deduplicate_sources
+        self.__return_hops = return_hops
+        self.__renumber = renumber
+        self.__compress_per_hop = compress_per_hop
+        self.__compression = compression
+
+    def sample_batches(self, nodes: TensorType, batch: TensorType, random_state: int):
+        if self.is_multi_gpu:
+            # get resource handle
+            # pass label list, label_to_comm_rank
+            # all labels on this worker should remain there
+            pylibcugraph.uniform_neighbor_sample(
+
+            )
+        else:
+            sampling_results_dict = pylibcugraph.uniform_neighbor_sample(
+                pylibcugraph.ResourceHandle(),
+                self.__graph,
+                start_list=nodes,
+                batch_id_list=batch,
+                h_fan_out=np.array(self.__fanout, dtype='int32'),
+                with_replacement=self.__with_replacement,
+                do_expensive_check=False,
+                with_edge_properties=True,
+                random_state=random_state,
+                prior_sources_behavior=self.__prior_sources_behavior,
+                deduplicate_sources=self.__deduplicate_sources,
+                return_hops=self.__return_hops,
+                renumber=self.__renumber,
+                compression=self.__compression,
+                compress_per_hop=self.__compress_per_hop,
+                return_dict=True,
+            )
+        
+        return sampling_results_dict
\ No newline at end of file

From 39d139df2b883304215d96071e8672680fc46dc7 Mon Sep 17 00:00:00 2001
From: Alexandria Barghi <abarghi@nvidia.com>
Date: Mon, 25 Mar 2024 15:22:23 -0700
Subject: [PATCH 02/33] working prototype of nccl cugraph

---
 .../cugraph_pyg/examples/cugraph_nccl.py      | 107 ++++++++++++++++++
 python/cugraph/cugraph/gnn/__init__.py        |   6 +
 python/cugraph/cugraph/gnn/comms/__init__.py  |  12 ++
 .../cugraph/gnn/comms/cugraph_nccl_comms.py   |  99 ++++++++++++++++
 .../cugraph/gnn/data_loading/dist_sampler.py  |   8 --
 .../simpleDistributedGraph.py                 |   3 +
 6 files changed, 227 insertions(+), 8 deletions(-)
 create mode 100644 python/cugraph-pyg/cugraph_pyg/examples/cugraph_nccl.py
 create mode 100644 python/cugraph/cugraph/gnn/comms/__init__.py
 create mode 100644 python/cugraph/cugraph/gnn/comms/cugraph_nccl_comms.py

diff --git a/python/cugraph-pyg/cugraph_pyg/examples/cugraph_nccl.py b/python/cugraph-pyg/cugraph_pyg/examples/cugraph_nccl.py
new file mode 100644
index 00000000000..d9f26141e0b
--- /dev/null
+++ b/python/cugraph-pyg/cugraph_pyg/examples/cugraph_nccl.py
@@ -0,0 +1,107 @@
+import os
+
+from time import sleep
+
+import pandas
+import numpy as np
+import torch
+import torch.multiprocessing as tmp
+import torch.distributed as dist
+
+from cugraph.gnn import (
+    cugraph_comms_init,
+    cugraph_comms_shutdown,
+    cugraph_comms_create_unique_id,
+    cugraph_comms_get_raft_handle,
+)
+
+from pylibcugraph import MGGraph, ResourceHandle, GraphProperties, degrees
+
+def init_pytorch(rank, world_size):
+    os.environ['MASTER_ADDR'] = 'localhost'
+    os.environ['MASTER_PORT'] = '12355'
+    dist.init_process_group('nccl', rank=rank, world_size=world_size)
+
+def train(rank:int, world_size: int, uid, edgelist):
+    init_pytorch(rank, world_size)
+
+    device = rank
+    cugraph_comms_init(rank, world_size, uid, device)
+
+    import rmm
+    rmm.reinitialize(pool_allocator=False, managed_memory=False, devices=[device])
+    
+    from rmm.allocators.cupy import rmm_cupy_allocator
+    import cupy
+    cupy.cuda.set_allocator(rmm_cupy_allocator)
+
+    import cudf
+
+    print(f'rank {rank} initialized cugraph')
+    
+    src = cudf.Series(
+        np.array_split(edgelist[0], world_size)[rank]
+    )
+    dst = cudf.Series(
+        np.array_split(edgelist[1], world_size)[rank]
+    )
+    
+    seeds = cudf.Series(
+        np.arange(rank * 50, (rank + 1) * 50)
+    )
+    handle = ResourceHandle(cugraph_comms_get_raft_handle().getHandle())
+
+    print('constructing graph')
+    G = MGGraph(
+        handle,
+        GraphProperties(is_multigraph=True,is_symmetric=False),
+        src_array=[src],
+        dst_array=[dst],
+        weight_array=None,
+        edge_id_array=None,
+        edge_type_array=None,
+        num_arrays=1,
+        store_transposed=False,
+        do_expensive_check=False,
+        drop_multi_edges=False,
+    )
+    print('graph constructed')
+
+    print('calculating degrees')
+    vertices, in_deg, out_deg = degrees(
+        handle,
+        G,
+        seeds,
+        do_expensive_check=False
+    )
+    print('degrees calculated')
+
+    print('constructing dataframe')
+    df = pandas.DataFrame({
+        'v': vertices.get(),
+        'in': in_deg.get(),
+        'out': out_deg.get()
+    })
+    print(df)
+
+    dist.barrier()
+    cugraph_comms_shutdown()
+    print(f'rank {rank} shut down cugraph')
+
+
+def main():
+    world_size = torch.cuda.device_count()
+    uid = cugraph_comms_create_unique_id()
+
+    from ogb.nodeproppred import NodePropPredDataset
+    dataset = NodePropPredDataset('ogbn-products')
+    el = dataset[0][0]['edge_index'].astype('int64')
+
+    tmp.spawn(
+        train,
+        args=(world_size, uid, el),
+        nprocs=world_size,
+    )
+
+if __name__ == '__main__':
+    main()
\ No newline at end of file
diff --git a/python/cugraph/cugraph/gnn/__init__.py b/python/cugraph/cugraph/gnn/__init__.py
index f8a3035440b..0365b6746a6 100644
--- a/python/cugraph/cugraph/gnn/__init__.py
+++ b/python/cugraph/cugraph/gnn/__init__.py
@@ -13,3 +13,9 @@
 
 from .feature_storage.feat_storage import FeatureStore
 from .data_loading.bulk_sampler import BulkSampler
+from .comms.cugraph_nccl_comms import (
+    cugraph_comms_init,
+    cugraph_comms_shutdown,
+    cugraph_comms_create_unique_id,
+    cugraph_comms_get_raft_handle,
+)
\ No newline at end of file
diff --git a/python/cugraph/cugraph/gnn/comms/__init__.py b/python/cugraph/cugraph/gnn/comms/__init__.py
new file mode 100644
index 00000000000..a205757235a
--- /dev/null
+++ b/python/cugraph/cugraph/gnn/comms/__init__.py
@@ -0,0 +1,12 @@
+# Copyright (c) 2024, NVIDIA CORPORATION.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
\ No newline at end of file
diff --git a/python/cugraph/cugraph/gnn/comms/cugraph_nccl_comms.py b/python/cugraph/cugraph/gnn/comms/cugraph_nccl_comms.py
new file mode 100644
index 00000000000..815e5bc71da
--- /dev/null
+++ b/python/cugraph/cugraph/gnn/comms/cugraph_nccl_comms.py
@@ -0,0 +1,99 @@
+# Copyright (c) 2024, NVIDIA CORPORATION.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import math
+
+from raft_dask.common.nccl import nccl
+from raft_dask.common.comms_utils import inject_comms_on_handle_coll_only
+
+from pylibraft.common.handle import Handle
+from rmm._cuda.gpu import getDevice, setDevice
+
+from cugraph.dask.comms.comms_wrapper import init_subcomms
+
+__nccl_comms = None
+__raft_handle = None
+
+def nccl_init(rank: int, world_size: int, uid: int):
+    # calls a c++ function that calls ncclCommInitRank
+    # returns a resource handle and nccl communicator
+    # should wrap the resource handle and communicator in a CuGraph context object
+    try:
+        ni = nccl()
+        ni.init(world_size, uid, rank)
+        return ni
+    except Exception as ex:
+        raise RuntimeError(f"A nccl error occurred: {ex}")
+
+def make_raft_handle(rank, world_size, nccl_comms, n_streams_per_handle=0, verbose=False):
+    handle = Handle(n_streams=n_streams_per_handle)
+    inject_comms_on_handle_coll_only(
+        handle,
+        nccl_comms,
+        world_size,
+        rank,
+        verbose
+    )
+
+    return handle
+
+def __get_2D_div(ngpus):
+    prows = int(math.sqrt(ngpus))
+    while ngpus % prows != 0:
+        prows = prows - 1
+    return prows, int(ngpus / prows)
+
+
+def cugraph_comms_init(rank, world_size, uid, device=0):
+    global __nccl_comms, __raft_handle
+    if __nccl_comms is not None or __raft_handle is not None:
+        raise RuntimeError("cuGraph has already been initialized!")
+
+    # TODO add options for rmm initialization
+
+    global __old_device
+    __old_device = getDevice()
+    setDevice(device)
+
+    nccl_comms = nccl_init(rank, world_size, uid)
+    # FIXME should we use n_streams_per_handle=1 here?
+    raft_handle = make_raft_handle(rank, world_size, nccl_comms, verbose=True)
+
+    pcols, _ = __get_2D_div(world_size)
+    init_subcomms(
+        raft_handle,
+        pcols
+    )
+
+    __nccl_comms = nccl_comms
+    __raft_handle = raft_handle
+
+
+def cugraph_comms_shutdown():
+    global __raft_handle, __nccl_comms, __old_device
+    
+    __nccl_comms.destroy()
+    setDevice(__old_device)
+    
+    del __raft_handle
+    del __nccl_comms
+    del __old_device
+
+
+def cugraph_comms_create_unique_id():
+    return nccl.get_unique_id()
+
+
+def cugraph_comms_get_raft_handle():
+    global __raft_handle
+    return __raft_handle
\ No newline at end of file
diff --git a/python/cugraph/cugraph/gnn/data_loading/dist_sampler.py b/python/cugraph/cugraph/gnn/data_loading/dist_sampler.py
index dc3e81c297b..6519eceb3e1 100644
--- a/python/cugraph/cugraph/gnn/data_loading/dist_sampler.py
+++ b/python/cugraph/cugraph/gnn/data_loading/dist_sampler.py
@@ -20,20 +20,12 @@
 TensorType = Union['torch.Tensor', 'cupy.ndarray', 'cudf.Series']
 
 
-def nccl_init(rank: int, world_size: int, uid: int):
-    # calls a c++ function that calls ncclCommInitRank
-    # returns a resource handle and nccl communicator
-    # should wrap the resource handle and communicator in a CuGraph context object
-    pass
-
 class DistSampleWriter:
     def __init__(self, format, directory, batches_per_partition):
         self.__format = format
         self.__directory = directory
         self.__batches_per_partition = batches_per_partition
     
-
-    
     def write_minibatches(self, minibatch_dict):
         if ("majors" in minibatch_dict) and ("minors" in minibatch_dict):
             self.__write_minibatches_coo(minibatch_dict)
diff --git a/python/cugraph/cugraph/structure/graph_implementation/simpleDistributedGraph.py b/python/cugraph/cugraph/structure/graph_implementation/simpleDistributedGraph.py
index 0ef5eaf1b9e..81dceff9cb6 100644
--- a/python/cugraph/cugraph/structure/graph_implementation/simpleDistributedGraph.py
+++ b/python/cugraph/cugraph/structure/graph_implementation/simpleDistributedGraph.py
@@ -135,6 +135,9 @@ def _make_plc_graph(
 
         src_array = [edata_x[i][src_col_name] for i in range(num_arrays)]
         dst_array = [edata_x[i][dst_col_name] for i in range(num_arrays)]
+
+        print(src_array, dst_array, weight_type, edge_id_type, edge_type_id, num_arrays)
+
         plc_graph = MGGraph(
             resource_handle=ResourceHandle(Comms.get_handle(sID).getHandle()),
             graph_properties=graph_props,

From ca732a95aa86a89bf54691a0a52352bed3e0a651 Mon Sep 17 00:00:00 2001
From: Alexandria Barghi <abarghi@nvidia.com>
Date: Mon, 25 Mar 2024 15:25:58 -0700
Subject: [PATCH 03/33] revert debug changes

---
 .../structure/graph_implementation/simpleDistributedGraph.py   | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/python/cugraph/cugraph/structure/graph_implementation/simpleDistributedGraph.py b/python/cugraph/cugraph/structure/graph_implementation/simpleDistributedGraph.py
index 81dceff9cb6..0ef5eaf1b9e 100644
--- a/python/cugraph/cugraph/structure/graph_implementation/simpleDistributedGraph.py
+++ b/python/cugraph/cugraph/structure/graph_implementation/simpleDistributedGraph.py
@@ -135,9 +135,6 @@ def _make_plc_graph(
 
         src_array = [edata_x[i][src_col_name] for i in range(num_arrays)]
         dst_array = [edata_x[i][dst_col_name] for i in range(num_arrays)]
-
-        print(src_array, dst_array, weight_type, edge_id_type, edge_type_id, num_arrays)
-
         plc_graph = MGGraph(
             resource_handle=ResourceHandle(Comms.get_handle(sID).getHandle()),
             graph_properties=graph_props,

From 2669596a1208f68f5f94fe5a00dc4ecce93f63c7 Mon Sep 17 00:00:00 2001
From: Alexandria Barghi <abarghi@nvidia.com>
Date: Tue, 26 Mar 2024 11:26:28 -0700
Subject: [PATCH 04/33] clean up examples, add sg

---
 .../{cugraph_nccl.py => pylibcugraph_mg.py}   | 49 ++++++------
 .../cugraph_pyg/examples/pylibcugraph_sg.py   | 75 +++++++++++++++++++
 2 files changed, 101 insertions(+), 23 deletions(-)
 rename python/cugraph-pyg/cugraph_pyg/examples/{cugraph_nccl.py => pylibcugraph_mg.py} (65%)
 create mode 100644 python/cugraph-pyg/cugraph_pyg/examples/pylibcugraph_sg.py

diff --git a/python/cugraph-pyg/cugraph_pyg/examples/cugraph_nccl.py b/python/cugraph-pyg/cugraph_pyg/examples/pylibcugraph_mg.py
similarity index 65%
rename from python/cugraph-pyg/cugraph_pyg/examples/cugraph_nccl.py
rename to python/cugraph-pyg/cugraph_pyg/examples/pylibcugraph_mg.py
index d9f26141e0b..93fa39c8ee0 100644
--- a/python/cugraph-pyg/cugraph_pyg/examples/cugraph_nccl.py
+++ b/python/cugraph-pyg/cugraph_pyg/examples/pylibcugraph_mg.py
@@ -1,6 +1,22 @@
-import os
+# Copyright (c) 2024, NVIDIA CORPORATION.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# This example shows how to use cuGraph nccl-only comms, pylibcuGraph,
+# and PyTorch DDP to run a multi-GPU workflow.  Most users of the
+# GNN packages will not interact with cuGraph directly.  This example
+# is intented for users who want to extend cuGraph within a DDP workflow.
 
-from time import sleep
+import os
 
 import pandas
 import numpy as np
@@ -8,6 +24,8 @@
 import torch.multiprocessing as tmp
 import torch.distributed as dist
 
+import cudf
+
 from cugraph.gnn import (
     cugraph_comms_init,
     cugraph_comms_shutdown,
@@ -17,26 +35,19 @@
 
 from pylibcugraph import MGGraph, ResourceHandle, GraphProperties, degrees
 
+from ogb.nodeproppred import NodePropPredDataset
+
 def init_pytorch(rank, world_size):
     os.environ['MASTER_ADDR'] = 'localhost'
     os.environ['MASTER_PORT'] = '12355'
     dist.init_process_group('nccl', rank=rank, world_size=world_size)
 
-def train(rank:int, world_size: int, uid, edgelist):
+def calc_degree(rank:int, world_size: int, uid, edgelist):
     init_pytorch(rank, world_size)
 
     device = rank
     cugraph_comms_init(rank, world_size, uid, device)
 
-    import rmm
-    rmm.reinitialize(pool_allocator=False, managed_memory=False, devices=[device])
-    
-    from rmm.allocators.cupy import rmm_cupy_allocator
-    import cupy
-    cupy.cuda.set_allocator(rmm_cupy_allocator)
-
-    import cudf
-
     print(f'rank {rank} initialized cugraph')
     
     src = cudf.Series(
@@ -55,15 +66,8 @@ def train(rank:int, world_size: int, uid, edgelist):
     G = MGGraph(
         handle,
         GraphProperties(is_multigraph=True,is_symmetric=False),
-        src_array=[src],
-        dst_array=[dst],
-        weight_array=None,
-        edge_id_array=None,
-        edge_type_array=None,
-        num_arrays=1,
-        store_transposed=False,
-        do_expensive_check=False,
-        drop_multi_edges=False,
+        [src],
+        [dst],
     )
     print('graph constructed')
 
@@ -93,12 +97,11 @@ def main():
     world_size = torch.cuda.device_count()
     uid = cugraph_comms_create_unique_id()
 
-    from ogb.nodeproppred import NodePropPredDataset
     dataset = NodePropPredDataset('ogbn-products')
     el = dataset[0][0]['edge_index'].astype('int64')
 
     tmp.spawn(
-        train,
+        calc_degree,
         args=(world_size, uid, el),
         nprocs=world_size,
     )
diff --git a/python/cugraph-pyg/cugraph_pyg/examples/pylibcugraph_sg.py b/python/cugraph-pyg/cugraph_pyg/examples/pylibcugraph_sg.py
new file mode 100644
index 00000000000..288a974ca88
--- /dev/null
+++ b/python/cugraph-pyg/cugraph_pyg/examples/pylibcugraph_sg.py
@@ -0,0 +1,75 @@
+# Copyright (c) 2024, NVIDIA CORPORATION.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# This example shows how to use cuGraph and pylibcuGraph to run a
+# single-GPU workflow.  Most users of the GNN packages will not interact
+# with cuGraph directly.  This example is intented for users who want
+# to extend cuGraph within a PyTorch workflow.
+
+import pandas
+import numpy as np
+
+import cudf
+
+from pylibcugraph import SGGraph, ResourceHandle, GraphProperties, degrees
+
+from ogb.nodeproppred import NodePropPredDataset
+
+def calc_degree(edgelist):
+    src = cudf.Series(
+        edgelist[0]
+    )
+    dst = cudf.Series(
+        edgelist[1]
+    )
+    
+    seeds = cudf.Series(
+        np.arange(256)
+    )
+
+    print('constructing graph')
+    G = SGGraph(
+        ResourceHandle(),
+        GraphProperties(is_multigraph=True,is_symmetric=False),
+        src,
+        dst,
+    )
+    print('graph constructed')
+
+    print('calculating degrees')
+    vertices, in_deg, out_deg = degrees(
+        ResourceHandle(),
+        G,
+        seeds,
+        do_expensive_check=False
+    )
+    print('degrees calculated')
+
+    print('constructing dataframe')
+    df = pandas.DataFrame({
+        'v': vertices.get(),
+        'in': in_deg.get(),
+        'out': out_deg.get()
+    })
+    print(df)
+
+    print('done')
+
+
+def main():
+    dataset = NodePropPredDataset('ogbn-products')
+    el = dataset[0][0]['edge_index'].astype('int64')
+    calc_degree(el)
+
+if __name__ == '__main__':
+    main()
\ No newline at end of file

From 8e17ee725692cc0b5e674a42cbf8ac4edef6840f Mon Sep 17 00:00:00 2001
From: Alexandria Barghi <abarghi@nvidia.com>
Date: Tue, 26 Mar 2024 12:49:56 -0700
Subject: [PATCH 05/33] wrap up sampler calls

---
 .../cugraph_pyg/examples/pylibcugraph_mg.py   |  66 ++++----
 .../cugraph_pyg/examples/pylibcugraph_sg.py   |  53 +++----
 python/cugraph/cugraph/gnn/__init__.py        |   4 +-
 python/cugraph/cugraph/gnn/comms/__init__.py  |   2 +-
 .../cugraph/gnn/comms/cugraph_nccl_comms.py   |  26 ++--
 .../cugraph/gnn/data_loading/dist_sampler.py  | 144 ++++++++++++++----
 6 files changed, 179 insertions(+), 116 deletions(-)

diff --git a/python/cugraph-pyg/cugraph_pyg/examples/pylibcugraph_mg.py b/python/cugraph-pyg/cugraph_pyg/examples/pylibcugraph_mg.py
index 93fa39c8ee0..832c5ec74f0 100644
--- a/python/cugraph-pyg/cugraph_pyg/examples/pylibcugraph_mg.py
+++ b/python/cugraph-pyg/cugraph_pyg/examples/pylibcugraph_mg.py
@@ -37,68 +37,57 @@
 
 from ogb.nodeproppred import NodePropPredDataset
 
+
 def init_pytorch(rank, world_size):
-    os.environ['MASTER_ADDR'] = 'localhost'
-    os.environ['MASTER_PORT'] = '12355'
-    dist.init_process_group('nccl', rank=rank, world_size=world_size)
+    os.environ["MASTER_ADDR"] = "localhost"
+    os.environ["MASTER_PORT"] = "12355"
+    dist.init_process_group("nccl", rank=rank, world_size=world_size)
+
 
-def calc_degree(rank:int, world_size: int, uid, edgelist):
+def calc_degree(rank: int, world_size: int, uid, edgelist):
     init_pytorch(rank, world_size)
 
     device = rank
     cugraph_comms_init(rank, world_size, uid, device)
 
-    print(f'rank {rank} initialized cugraph')
-    
-    src = cudf.Series(
-        np.array_split(edgelist[0], world_size)[rank]
-    )
-    dst = cudf.Series(
-        np.array_split(edgelist[1], world_size)[rank]
-    )
-    
-    seeds = cudf.Series(
-        np.arange(rank * 50, (rank + 1) * 50)
-    )
+    print(f"rank {rank} initialized cugraph")
+
+    src = cudf.Series(np.array_split(edgelist[0], world_size)[rank])
+    dst = cudf.Series(np.array_split(edgelist[1], world_size)[rank])
+
+    seeds = cudf.Series(np.arange(rank * 50, (rank + 1) * 50))
     handle = ResourceHandle(cugraph_comms_get_raft_handle().getHandle())
 
-    print('constructing graph')
+    print("constructing graph")
     G = MGGraph(
         handle,
-        GraphProperties(is_multigraph=True,is_symmetric=False),
+        GraphProperties(is_multigraph=True, is_symmetric=False),
         [src],
         [dst],
     )
-    print('graph constructed')
+    print("graph constructed")
 
-    print('calculating degrees')
-    vertices, in_deg, out_deg = degrees(
-        handle,
-        G,
-        seeds,
-        do_expensive_check=False
+    print("calculating degrees")
+    vertices, in_deg, out_deg = degrees(handle, G, seeds, do_expensive_check=False)
+    print("degrees calculated")
+
+    print("constructing dataframe")
+    df = pandas.DataFrame(
+        {"v": vertices.get(), "in": in_deg.get(), "out": out_deg.get()}
     )
-    print('degrees calculated')
-
-    print('constructing dataframe')
-    df = pandas.DataFrame({
-        'v': vertices.get(),
-        'in': in_deg.get(),
-        'out': out_deg.get()
-    })
     print(df)
 
     dist.barrier()
     cugraph_comms_shutdown()
-    print(f'rank {rank} shut down cugraph')
+    print(f"rank {rank} shut down cugraph")
 
 
 def main():
     world_size = torch.cuda.device_count()
     uid = cugraph_comms_create_unique_id()
 
-    dataset = NodePropPredDataset('ogbn-products')
-    el = dataset[0][0]['edge_index'].astype('int64')
+    dataset = NodePropPredDataset("ogbn-products")
+    el = dataset[0][0]["edge_index"].astype("int64")
 
     tmp.spawn(
         calc_degree,
@@ -106,5 +95,6 @@ def main():
         nprocs=world_size,
     )
 
-if __name__ == '__main__':
-    main()
\ No newline at end of file
+
+if __name__ == "__main__":
+    main()
diff --git a/python/cugraph-pyg/cugraph_pyg/examples/pylibcugraph_sg.py b/python/cugraph-pyg/cugraph_pyg/examples/pylibcugraph_sg.py
index 288a974ca88..2f273ee581e 100644
--- a/python/cugraph-pyg/cugraph_pyg/examples/pylibcugraph_sg.py
+++ b/python/cugraph-pyg/cugraph_pyg/examples/pylibcugraph_sg.py
@@ -25,51 +25,42 @@
 
 from ogb.nodeproppred import NodePropPredDataset
 
+
 def calc_degree(edgelist):
-    src = cudf.Series(
-        edgelist[0]
-    )
-    dst = cudf.Series(
-        edgelist[1]
-    )
-    
-    seeds = cudf.Series(
-        np.arange(256)
-    )
+    src = cudf.Series(edgelist[0])
+    dst = cudf.Series(edgelist[1])
+
+    seeds = cudf.Series(np.arange(256))
 
-    print('constructing graph')
+    print("constructing graph")
     G = SGGraph(
         ResourceHandle(),
-        GraphProperties(is_multigraph=True,is_symmetric=False),
+        GraphProperties(is_multigraph=True, is_symmetric=False),
         src,
         dst,
     )
-    print('graph constructed')
+    print("graph constructed")
 
-    print('calculating degrees')
+    print("calculating degrees")
     vertices, in_deg, out_deg = degrees(
-        ResourceHandle(),
-        G,
-        seeds,
-        do_expensive_check=False
+        ResourceHandle(), G, seeds, do_expensive_check=False
+    )
+    print("degrees calculated")
+
+    print("constructing dataframe")
+    df = pandas.DataFrame(
+        {"v": vertices.get(), "in": in_deg.get(), "out": out_deg.get()}
     )
-    print('degrees calculated')
-
-    print('constructing dataframe')
-    df = pandas.DataFrame({
-        'v': vertices.get(),
-        'in': in_deg.get(),
-        'out': out_deg.get()
-    })
     print(df)
 
-    print('done')
+    print("done")
 
 
 def main():
-    dataset = NodePropPredDataset('ogbn-products')
-    el = dataset[0][0]['edge_index'].astype('int64')
+    dataset = NodePropPredDataset("ogbn-products")
+    el = dataset[0][0]["edge_index"].astype("int64")
     calc_degree(el)
 
-if __name__ == '__main__':
-    main()
\ No newline at end of file
+
+if __name__ == "__main__":
+    main()
diff --git a/python/cugraph/cugraph/gnn/__init__.py b/python/cugraph/cugraph/gnn/__init__.py
index 0365b6746a6..20fefc7de8a 100644
--- a/python/cugraph/cugraph/gnn/__init__.py
+++ b/python/cugraph/cugraph/gnn/__init__.py
@@ -1,4 +1,4 @@
-# Copyright (c) 2022-2023, NVIDIA CORPORATION.
+# Copyright (c) 2022-2024, NVIDIA CORPORATION.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
@@ -18,4 +18,4 @@
     cugraph_comms_shutdown,
     cugraph_comms_create_unique_id,
     cugraph_comms_get_raft_handle,
-)
\ No newline at end of file
+)
diff --git a/python/cugraph/cugraph/gnn/comms/__init__.py b/python/cugraph/cugraph/gnn/comms/__init__.py
index a205757235a..aeae6078111 100644
--- a/python/cugraph/cugraph/gnn/comms/__init__.py
+++ b/python/cugraph/cugraph/gnn/comms/__init__.py
@@ -9,4 +9,4 @@
 # distributed under the License is distributed on an "AS IS" BASIS,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
-# limitations under the License.
\ No newline at end of file
+# limitations under the License.
diff --git a/python/cugraph/cugraph/gnn/comms/cugraph_nccl_comms.py b/python/cugraph/cugraph/gnn/comms/cugraph_nccl_comms.py
index 815e5bc71da..b668ecce424 100644
--- a/python/cugraph/cugraph/gnn/comms/cugraph_nccl_comms.py
+++ b/python/cugraph/cugraph/gnn/comms/cugraph_nccl_comms.py
@@ -24,6 +24,7 @@
 __nccl_comms = None
 __raft_handle = None
 
+
 def nccl_init(rank: int, world_size: int, uid: int):
     # calls a c++ function that calls ncclCommInitRank
     # returns a resource handle and nccl communicator
@@ -35,18 +36,16 @@ def nccl_init(rank: int, world_size: int, uid: int):
     except Exception as ex:
         raise RuntimeError(f"A nccl error occurred: {ex}")
 
-def make_raft_handle(rank, world_size, nccl_comms, n_streams_per_handle=0, verbose=False):
+
+def make_raft_handle(
+    rank, world_size, nccl_comms, n_streams_per_handle=0, verbose=False
+):
     handle = Handle(n_streams=n_streams_per_handle)
-    inject_comms_on_handle_coll_only(
-        handle,
-        nccl_comms,
-        world_size,
-        rank,
-        verbose
-    )
+    inject_comms_on_handle_coll_only(handle, nccl_comms, world_size, rank, verbose)
 
     return handle
 
+
 def __get_2D_div(ngpus):
     prows = int(math.sqrt(ngpus))
     while ngpus % prows != 0:
@@ -70,10 +69,7 @@ def cugraph_comms_init(rank, world_size, uid, device=0):
     raft_handle = make_raft_handle(rank, world_size, nccl_comms, verbose=True)
 
     pcols, _ = __get_2D_div(world_size)
-    init_subcomms(
-        raft_handle,
-        pcols
-    )
+    init_subcomms(raft_handle, pcols)
 
     __nccl_comms = nccl_comms
     __raft_handle = raft_handle
@@ -81,10 +77,10 @@ def cugraph_comms_init(rank, world_size, uid, device=0):
 
 def cugraph_comms_shutdown():
     global __raft_handle, __nccl_comms, __old_device
-    
+
     __nccl_comms.destroy()
     setDevice(__old_device)
-    
+
     del __raft_handle
     del __nccl_comms
     del __old_device
@@ -96,4 +92,4 @@ def cugraph_comms_create_unique_id():
 
 def cugraph_comms_get_raft_handle():
     global __raft_handle
-    return __raft_handle
\ No newline at end of file
+    return __raft_handle
diff --git a/python/cugraph/cugraph/gnn/data_loading/dist_sampler.py b/python/cugraph/cugraph/gnn/data_loading/dist_sampler.py
index 6519eceb3e1..b7190471c65 100644
--- a/python/cugraph/cugraph/gnn/data_loading/dist_sampler.py
+++ b/python/cugraph/cugraph/gnn/data_loading/dist_sampler.py
@@ -16,16 +16,36 @@
 import cupy
 import cudf
 
-from typing import Union, List, Dict
-TensorType = Union['torch.Tensor', 'cupy.ndarray', 'cudf.Series']
+from typing import Union, List
+from cugraph.utilities import import_optional
+from cugraph.gnn import cugraph_comms_get_raft_handle
+
+from math import ceil
+
+# PyTorch is NOT optional but this is required for container builds.
+torch = import_optional("torch")
+
+TensorType = Union[torch.Tensor, cupy.ndarray, cudf.Series]
 
 
 class DistSampleWriter:
-    def __init__(self, format, directory, batches_per_partition):
+    def __init__(self, format: str, directory: str, batches_per_partition: int):
         self.__format = format
         self.__directory = directory
         self.__batches_per_partition = batches_per_partition
-    
+
+    @property
+    def _format(self):
+        return self.__format
+
+    @property
+    def _directory(self):
+        return self.__directory
+
+    @property
+    def _batches_per_partition(self):
+        return self.__batches_per_partition
+
     def write_minibatches(self, minibatch_dict):
         if ("majors" in minibatch_dict) and ("minors" in minibatch_dict):
             self.__write_minibatches_coo(minibatch_dict)
@@ -34,33 +54,75 @@ def write_minibatches(self, minibatch_dict):
         else:
             raise ValueError("invalid columns")
 
+
 class DistSampler:
-    def __init__(self, graph: Union[pylibcugraph.SGGraph, pylibcugraph.MGGraph], writer: DistSampleWriter):
+    def __init__(
+        self,
+        graph: Union[pylibcugraph.SGGraph, pylibcugraph.MGGraph],
+        writer: DistSampleWriter,
+        local_seeds_per_call: int = 32768,
+        rank: int = 0,
+    ):
         self.__graph = graph
-    
-    def sample_batches(self, nodes: TensorType, batch: TensorType, random_state: int):
+        self.__local_seeds_per_call = local_seeds_per_call
+        self.__rank = rank
+
+    def sample_batches(
+        self, seeds: TensorType, batch_ids: TensorType, random_state: int = 0
+    ):
         raise NotImplementedError("Must be implemented by subclass")
 
-    def sample_from_nodes(self, nodes: TensorType, batch: TensorType, random_state: int):
-        minibatch_dict = self.sample_batches(nodes=nodes, batch=batch, random_state=random_state)
-        self.__writer.write_minibatches(minibatch_dict)
+    def sample_from_nodes(self, nodes: TensorType, batch_size: int, random_state: int):
+        batches_per_call = self._local_seeds_per_call // batch_size
+        actual_seeds_per_call = batches_per_call * batch_size
+        num_calls = int(ceil(len(nodes) / actual_seeds_per_call))
+
+        nodes = torch.split(torch.as_tensor(nodes, device="cuda"), num_calls)
+
+        for i, current_seeds in enumerate(nodes):
+            current_batches = torch.arange(
+                i * batches_per_call,
+                (i + 1) * batches_per_call,
+                device="cuda",
+                dtype=torch.int32,
+            )
 
+            current_batches = current_batches.repeat_interleave(batch_size)[
+                : len(current_seeds)
+            ]
+
+            minibatch_dict = self.sample_batches(
+                seeds=current_seeds,
+                batch_ids=current_batches,
+                random_state=random_state,
+            )
+            self.__writer.write_minibatches(minibatch_dict)
 
     @property
     def is_multi_gpu(self):
         return isinstance(self.__graph, pylibcugraph.MGGraph)
 
+    @property
+    def _local_seeds_per_call(self):
+        return self.__local_seeds_per_call
+
+    @property
+    def rank(self):
+        return self.__rank
+
+
 class UniformNeighborSampler(DistSampler):
     def __init__(
-            self,
-            graph: Union[pylibcugraph.SGGraph, pylibcugraph.MGGraph],
-            fanout: List[int],
-            prior_sources_behavior: str,
-            deduplicate_sources: bool,
-            return_hops: bool,
-            renumber: bool,
-            compression: str,
-            compress_per_hop:bool):
+        self,
+        graph: Union[pylibcugraph.SGGraph, pylibcugraph.MGGraph],
+        fanout: List[int],
+        prior_sources_behavior: str,
+        deduplicate_sources: bool,
+        return_hops: bool,
+        renumber: bool,
+        compression: str,
+        compress_per_hop: bool,
+    ):
         super(graph)
         self.__fanout = fanout
         self.__prior_sources_behavior = prior_sources_behavior
@@ -70,21 +132,45 @@ def __init__(
         self.__compress_per_hop = compress_per_hop
         self.__compression = compression
 
-    def sample_batches(self, nodes: TensorType, batch: TensorType, random_state: int):
+    def sample_batches(
+        self, seeds: TensorType, batch_ids: TensorType, random_state: int = 0
+    ):
         if self.is_multi_gpu:
-            # get resource handle
-            # pass label list, label_to_comm_rank
-            # all labels on this worker should remain there
-            pylibcugraph.uniform_neighbor_sample(
+            handle = pylibcugraph.ResourceHandle(
+                cugraph_comms_get_raft_handle().getHandle()
+            )
+            label_to_output_comm_rank = torch.full(
+                (len(seeds),), self.rank, dtype=torch.int32, device="cuda"
+            )
+            label_list = torch.unique(batch_ids)
 
+            sampling_results_dict = pylibcugraph.uniform_neighbor_sample(
+                handle,
+                self.__graph,
+                start_list=seeds,
+                batch_id_list=batch_ids,
+                label_list=label_list,
+                label_to_output_comm_rank=label_to_output_comm_rank,
+                h_fan_out=np.array(self.__fanout, dtype="int32"),
+                with_replacement=self.__with_replacement,
+                do_expensive_check=False,
+                with_edge_properties=True,
+                random_state=random_state,
+                prior_sources_behavior=self.__prior_sources_behavior,
+                deduplicate_sources=self.__deduplicate_sources,
+                return_hops=self.__return_hops,
+                renumber=self.__renumber,
+                compression=self.__compression,
+                compress_per_hop=self.__compress_per_hop,
+                return_dict=True,
             )
         else:
             sampling_results_dict = pylibcugraph.uniform_neighbor_sample(
                 pylibcugraph.ResourceHandle(),
                 self.__graph,
-                start_list=nodes,
-                batch_id_list=batch,
-                h_fan_out=np.array(self.__fanout, dtype='int32'),
+                start_list=seeds,
+                batch_id_list=batch_ids,
+                h_fan_out=np.array(self.__fanout, dtype="int32"),
                 with_replacement=self.__with_replacement,
                 do_expensive_check=False,
                 with_edge_properties=True,
@@ -97,5 +183,5 @@ def sample_batches(self, nodes: TensorType, batch: TensorType, random_state: int
                 compress_per_hop=self.__compress_per_hop,
                 return_dict=True,
             )
-        
-        return sampling_results_dict
\ No newline at end of file
+
+        return sampling_results_dict

From 4e367190fdbca04253a4efe391cdb2684a33ffea Mon Sep 17 00:00:00 2001
From: Alexandria Barghi <abarghi@nvidia.com>
Date: Tue, 26 Mar 2024 13:18:01 -0700
Subject: [PATCH 06/33] more cleanup

---
 python/cugraph/cugraph/gnn/comms/cugraph_nccl_comms.py | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/python/cugraph/cugraph/gnn/comms/cugraph_nccl_comms.py b/python/cugraph/cugraph/gnn/comms/cugraph_nccl_comms.py
index b668ecce424..fc27789621f 100644
--- a/python/cugraph/cugraph/gnn/comms/cugraph_nccl_comms.py
+++ b/python/cugraph/cugraph/gnn/comms/cugraph_nccl_comms.py
@@ -26,9 +26,6 @@
 
 
 def nccl_init(rank: int, world_size: int, uid: int):
-    # calls a c++ function that calls ncclCommInitRank
-    # returns a resource handle and nccl communicator
-    # should wrap the resource handle and communicator in a CuGraph context object
     try:
         ni = nccl()
         ni.init(world_size, uid, rank)

From 2fe5084aa6d016b0141972fd385dcdb391bebdfa Mon Sep 17 00:00:00 2001
From: Alexandria Barghi <abarghi@nvidia.com>
Date: Wed, 27 Mar 2024 14:48:50 -0700
Subject: [PATCH 07/33] writing

---
 .../cugraph/cugraph/gnn/data_loading/dist_sampler.py   | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/python/cugraph/cugraph/gnn/data_loading/dist_sampler.py b/python/cugraph/cugraph/gnn/data_loading/dist_sampler.py
index b7190471c65..063afb8561d 100644
--- a/python/cugraph/cugraph/gnn/data_loading/dist_sampler.py
+++ b/python/cugraph/cugraph/gnn/data_loading/dist_sampler.py
@@ -45,6 +45,9 @@ def _directory(self):
     @property
     def _batches_per_partition(self):
         return self.__batches_per_partition
+    
+    def __write_minibatches_coo(self):
+        
 
     def write_minibatches(self, minibatch_dict):
         if ("majors" in minibatch_dict) and ("minors" in minibatch_dict):
@@ -64,6 +67,7 @@ def __init__(
         rank: int = 0,
     ):
         self.__graph = graph
+        self.__writer = writer
         self.__local_seeds_per_call = local_seeds_per_call
         self.__rank = rank
 
@@ -118,8 +122,6 @@ def __init__(
         fanout: List[int],
         prior_sources_behavior: str,
         deduplicate_sources: bool,
-        return_hops: bool,
-        renumber: bool,
         compression: str,
         compress_per_hop: bool,
     ):
@@ -127,8 +129,6 @@ def __init__(
         self.__fanout = fanout
         self.__prior_sources_behavior = prior_sources_behavior
         self.__deduplicate_sources = deduplicate_sources
-        self.__return_hops = return_hops
-        self.__renumber = renumber
         self.__compress_per_hop = compress_per_hop
         self.__compression = compression
 
@@ -158,7 +158,7 @@ def sample_batches(
                 random_state=random_state,
                 prior_sources_behavior=self.__prior_sources_behavior,
                 deduplicate_sources=self.__deduplicate_sources,
-                return_hops=self.__return_hops,
+                return_hops=True,
                 renumber=self.__renumber,
                 compression=self.__compression,
                 compress_per_hop=self.__compress_per_hop,

From 50c5a8054eaa7cdb7775fe1c1660f124afc73b79 Mon Sep 17 00:00:00 2001
From: Alexandria Barghi <abarghi@nvidia.com>
Date: Mon, 1 Apr 2024 14:46:57 -0700
Subject: [PATCH 08/33] pull in change

---
 .../cugraph/gnn/data_loading/dist_sampler.py  | 60 ++++++++++++++++++-
 1 file changed, 59 insertions(+), 1 deletion(-)

diff --git a/python/cugraph/cugraph/gnn/data_loading/dist_sampler.py b/python/cugraph/cugraph/gnn/data_loading/dist_sampler.py
index 063afb8561d..68bb0539360 100644
--- a/python/cugraph/cugraph/gnn/data_loading/dist_sampler.py
+++ b/python/cugraph/cugraph/gnn/data_loading/dist_sampler.py
@@ -47,7 +47,65 @@ def _batches_per_partition(self):
         return self.__batches_per_partition
     
     def __write_minibatches_coo(self):
-        
+        label_hop_offsets_array = offsets.offsets.dropna().values
+        batch_id_array = offsets.batch_id.dropna().values
+        renumber_map_offsets_array = offsets.renumber_map_offsets.dropna().values
+
+        # Offsets is always in order, so the last batch id is always the highest
+        print(offsets_array, batch_id_array)
+        max_batch_id = batch_id_array[-1]
+        results.dropna(axis=1, how="all", inplace=True)
+
+
+        for p in range(0, int(ceil(len(batch_id_array) / batches_per_partition))):
+            partition_start = p * (batches_per_partition)
+            partition_end = (p + 1) * (batches_per_partition)
+
+            label_hop_offsets_array_current_partition = label_hop_offsets_array[
+                partition_start * fanout_length : partition_end * fanout_length + 1
+            ]
+
+            batch_ids_current_partition = batch_id_array[partition_start:partition_end]
+            start_batch_id = batch_ids_current_partition[0]
+
+            start_ix, end_ix = label_hop_offsets_array_current_partition[[0, -1]]
+            results_p = results.iloc[start_ix:end_ix].reset_index(drop=True)
+
+            if renumber_map is None:
+                raise ValueError("Bulk sampling without renumbering is no longer supported")
+            
+            # create the renumber map offsets
+            renumber_map_offsets_array_current_partition = renumber_map_offsets_array[
+                partition_start : partition_end + 1
+            ]
+
+            renumber_map_start_ix, renumber_map_end_ix = renumber_map_offsets_array_current_partition[[0,-1]]
+
+            renumber_map_current_partition = renumber_map.renumber_map.values[
+                renumber_map_start_ix:renumber_map_end_ix
+            ]
+
+            results_current_partition = create_df_from_disjoint_series(
+                [
+                    results_p.majors,
+                    results_p.minors,
+                    cudf.Series(renumber_map_current_partition, name="map"),
+                    cudf.Series(label_hop_offsets_array_current_partition, name="label_hop_offsets"),
+                    results_p.weight,
+                    results_p.edge_id,
+                    results_p.edge_type,
+                    cudf.Series(renumber_map_offsets_array_current_partition, name='renumber_map_offsets'),
+                ]
+            )
+
+            end_batch_id = start_batch_id + len(batch_ids_current_partition) - 1
+            full_output_path = os.path.join(
+                output_path, f"batch={start_batch_id:010d}-{end_batch_id:010d}.parquet"
+            )
+
+            results_p.to_parquet(
+                full_output_path, compression=None, index=False, force_nullable_schema=True
+            )
 
     def write_minibatches(self, minibatch_dict):
         if ("majors" in minibatch_dict) and ("minors" in minibatch_dict):

From 9e393a017e163b7112f278d9beaeb68cb08b9c29 Mon Sep 17 00:00:00 2001
From: Alexandria Barghi <abarghi@nvidia.com>
Date: Mon, 1 Apr 2024 19:12:44 -0700
Subject: [PATCH 09/33] dist sampler io

---
 .../gnn/data_loading/bulk_sampler_io.py       |  9 +-
 .../cugraph/gnn/data_loading/dist_sampler.py  | 93 +++++++++++--------
 2 files changed, 62 insertions(+), 40 deletions(-)

diff --git a/python/cugraph/cugraph/gnn/data_loading/bulk_sampler_io.py b/python/cugraph/cugraph/gnn/data_loading/bulk_sampler_io.py
index 194df7d2f75..24b97d281a8 100644
--- a/python/cugraph/cugraph/gnn/data_loading/bulk_sampler_io.py
+++ b/python/cugraph/cugraph/gnn/data_loading/bulk_sampler_io.py
@@ -19,7 +19,7 @@
 
 from pandas import isna
 
-from typing import Union, Optional, List
+from typing import Union, Optional, List, Dict
 
 
 def create_df_from_disjoint_series(series_list: List[cudf.Series]):
@@ -32,6 +32,13 @@ def create_df_from_disjoint_series(series_list: List[cudf.Series]):
     return df
 
 
+def create_df_from_disjoint_arrays(array_dict: Dict[cupy.array]):
+    for k in list(array_dict.keys()):
+        array_dict[k] = cudf.Series(array_dict[k], name=k)
+    
+    return create_df_from_disjoint_series(list(array_dict.values()))
+
+
 def _write_samples_to_parquet_csr(
     results: cudf.DataFrame,
     offsets: cudf.DataFrame,
diff --git a/python/cugraph/cugraph/gnn/data_loading/dist_sampler.py b/python/cugraph/cugraph/gnn/data_loading/dist_sampler.py
index 68bb0539360..2d6649018eb 100644
--- a/python/cugraph/cugraph/gnn/data_loading/dist_sampler.py
+++ b/python/cugraph/cugraph/gnn/data_loading/dist_sampler.py
@@ -11,6 +11,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import os
+from math import ceil
+
 import pylibcugraph
 import numpy as np
 import cupy
@@ -20,7 +23,7 @@
 from cugraph.utilities import import_optional
 from cugraph.gnn import cugraph_comms_get_raft_handle
 
-from math import ceil
+from cugraph.gnn.data_loading.bulk_sampler_io import create_df_from_disjoint_arrays
 
 # PyTorch is NOT optional but this is required for container builds.
 torch = import_optional("torch")
@@ -46,71 +49,83 @@ def _directory(self):
     def _batches_per_partition(self):
         return self.__batches_per_partition
     
-    def __write_minibatches_coo(self):
-        label_hop_offsets_array = offsets.offsets.dropna().values
-        batch_id_array = offsets.batch_id.dropna().values
-        renumber_map_offsets_array = offsets.renumber_map_offsets.dropna().values
+    def __write_minibatches_coo(self, minibatch_dict):
+        has_edge_ids = minibatch_dict['edge_id'] is not None
+        has_edge_types = minibatch_dict['edge_type'] is not None
+        has_weights = minibatch_dict['weight'] is not None
 
-        # Offsets is always in order, so the last batch id is always the highest
-        print(offsets_array, batch_id_array)
-        max_batch_id = batch_id_array[-1]
-        results.dropna(axis=1, how="all", inplace=True)
+        if minibatch_dict['renumber_map'] is None:
+            raise ValueError("Distributed sampling without renumbering is not supported")
 
+        fanout_length = (len(minibatch_dict['label_hop_offsets']) - 1) // len(minibatch_dict['batch_id'])
 
-        for p in range(0, int(ceil(len(batch_id_array) / batches_per_partition))):
-            partition_start = p * (batches_per_partition)
-            partition_end = (p + 1) * (batches_per_partition)
+        for p in range(0, int(ceil(len(minibatch_dict['batch_id']) / self.__batches_per_partition))):
+            partition_start = p * (self.__batches_per_partition)
+            partition_end = (p + 1) * (self.__batches_per_partition)
 
-            label_hop_offsets_array_current_partition = label_hop_offsets_array[
+            label_hop_offsets_array_p = minibatch_dict['label_hop_offsets'][
                 partition_start * fanout_length : partition_end * fanout_length + 1
             ]
 
-            batch_ids_current_partition = batch_id_array[partition_start:partition_end]
-            start_batch_id = batch_ids_current_partition[0]
-
-            start_ix, end_ix = label_hop_offsets_array_current_partition[[0, -1]]
-            results_p = results.iloc[start_ix:end_ix].reset_index(drop=True)
+            batch_id_array_p = minibatch_dict['batch_id'][partition_start:partition_end]
+            start_batch_id = batch_id_array_p[0]
 
-            if renumber_map is None:
-                raise ValueError("Bulk sampling without renumbering is no longer supported")
+            start_ix, end_ix = label_hop_offsets_array_p[[0, -1]]
+            majors_array_p = minibatch_dict["majors"][start_ix:end_ix]
+            minors_array_p = minibatch_dict["minors"][start_ix:end_ix]
+            edge_id_array_p = (
+                minibatch_dict["edge_id"][start_ix:end_ix] if has_edge_ids
+                else cupy.array([], dtype='int64')
+            )
+            edge_type_array_p = (
+                minibatch_dict["edge_type"][start_ix:end_ix] if has_edge_types
+                else cupy.array([], dtype='int32')
+            )
+            weight_array_p = (
+                minibatch_dict["weight"][start_ix:end_ix] if has_weights
+                else cupy.array([], dtype='float32')
+            )
             
             # create the renumber map offsets
-            renumber_map_offsets_array_current_partition = renumber_map_offsets_array[
+            renumber_map_offsets_array_p = minibatch_dict['renumber_map_offsets'][
                 partition_start : partition_end + 1
             ]
 
-            renumber_map_start_ix, renumber_map_end_ix = renumber_map_offsets_array_current_partition[[0,-1]]
+            renumber_map_start_ix, renumber_map_end_ix = renumber_map_offsets_array_p[[0,-1]]
 
-            renumber_map_current_partition = renumber_map.renumber_map.values[
+            renumber_map_array_p = minibatch_dict['renumber_map'][
                 renumber_map_start_ix:renumber_map_end_ix
             ]
 
-            results_current_partition = create_df_from_disjoint_series(
-                [
-                    results_p.majors,
-                    results_p.minors,
-                    cudf.Series(renumber_map_current_partition, name="map"),
-                    cudf.Series(label_hop_offsets_array_current_partition, name="label_hop_offsets"),
-                    results_p.weight,
-                    results_p.edge_id,
-                    results_p.edge_type,
-                    cudf.Series(renumber_map_offsets_array_current_partition, name='renumber_map_offsets'),
-                ]
+            results_dataframe_p = create_df_from_disjoint_arrays(
+                {
+                    'majors': majors_array_p,
+                    'minors': minors_array_p,
+                    'map': renumber_map_array_p,
+                    'label_hop_offsets': label_hop_offsets_array_p,
+                    'weight': weight_array_p,
+                    'edge_id': edge_id_array_p,
+                    'edge_type': edge_type_array_p,
+                    'renumber_map_offsets': renumber_map_offsets_array_p,
+                }
             )
 
-            end_batch_id = start_batch_id + len(batch_ids_current_partition) - 1
+            end_batch_id = start_batch_id + len(batch_id_array_p) - 1
             full_output_path = os.path.join(
-                output_path, f"batch={start_batch_id:010d}-{end_batch_id:010d}.parquet"
+                self.__directory, f"batch={start_batch_id:010d}-{end_batch_id:010d}.parquet"
             )
 
-            results_p.to_parquet(
+            results_dataframe_p.to_parquet(
                 full_output_path, compression=None, index=False, force_nullable_schema=True
             )
+        
+    def __write_minibatches_csr(self, minibatch_dict):
+        raise NotImplementedError("CSR format currently not supported for distributed sampling")
 
     def write_minibatches(self, minibatch_dict):
-        if ("majors" in minibatch_dict) and ("minors" in minibatch_dict):
+        if (minibatch_dict['majors'] is not None) and (minibatch_dict['minors'] is not None):
             self.__write_minibatches_coo(minibatch_dict)
-        elif "major_offsets" in minibatch_dict and "minors" in minibatch_dict:
+        elif (minibatch_dict["major_offsets"] is not None) and (minibatch_dict['minors'] is not None):
             self.__write_minibatches_csr(minibatch_dict)
         else:
             raise ValueError("invalid columns")

From b35ad1f187fa6710b172fbf6aabd10b596b6119f Mon Sep 17 00:00:00 2001
From: Alexandria Barghi <abarghi@nvidia.com>
Date: Tue, 2 Apr 2024 13:39:26 -0700
Subject: [PATCH 10/33] dist sampling io

---
 .../examples/cugraph_dist_sampling.py         | 105 +++++++++++++++
 python/cugraph/cugraph/gnn/__init__.py        |   5 +
 python/cugraph/cugraph/gnn/comms/__init__.py  |   7 +
 .../cugraph/gnn/data_loading/__init__.py      |   5 +
 .../gnn/data_loading/bulk_sampler_io.py       |   2 +-
 .../cugraph/gnn/data_loading/dist_sampler.py  | 122 +++++++++++++-----
 6 files changed, 210 insertions(+), 36 deletions(-)
 create mode 100644 python/cugraph-pyg/cugraph_pyg/examples/cugraph_dist_sampling.py

diff --git a/python/cugraph-pyg/cugraph_pyg/examples/cugraph_dist_sampling.py b/python/cugraph-pyg/cugraph_pyg/examples/cugraph_dist_sampling.py
new file mode 100644
index 00000000000..10033304e91
--- /dev/null
+++ b/python/cugraph-pyg/cugraph_pyg/examples/cugraph_dist_sampling.py
@@ -0,0 +1,105 @@
+# Copyright (c) 2024, NVIDIA CORPORATION.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# This example shows how to use cuGraph nccl-only comms, pylibcuGraph,
+# and PyTorch DDP to run a multi-GPU sampling workflow.  Most users of the
+# GNN packages will not interact with cuGraph directly.  This example
+# is intented for users who want to extend cuGraph within a DDP workflow.
+
+import os
+
+import tempfile
+import numpy as np
+import torch
+import torch.multiprocessing as tmp
+import torch.distributed as dist
+
+import cudf
+
+from cugraph.gnn import (
+    cugraph_comms_init,
+    cugraph_comms_shutdown,
+    cugraph_comms_create_unique_id,
+    cugraph_comms_get_raft_handle,
+    DistSampleWriter,
+    UniformNeighborSampler
+)
+
+from pylibcugraph import MGGraph, ResourceHandle, GraphProperties
+
+from ogb.nodeproppred import NodePropPredDataset
+
+
+def init_pytorch(rank, world_size):
+    os.environ["MASTER_ADDR"] = "localhost"
+    os.environ["MASTER_PORT"] = "12355"
+    dist.init_process_group("nccl", rank=rank, world_size=world_size)
+
+
+def sample(rank: int, world_size: int, uid, edgelist, directory):
+    init_pytorch(rank, world_size)
+
+    device = rank
+    cugraph_comms_init(rank, world_size, uid, device)
+
+    print(f"rank {rank} initialized cugraph")
+
+    src = cudf.Series(np.array_split(edgelist[0], world_size)[rank])
+    dst = cudf.Series(np.array_split(edgelist[1], world_size)[rank])
+
+    seeds = cudf.Series(np.arange(rank * 50, (rank + 1) * 50))
+    handle = ResourceHandle(cugraph_comms_get_raft_handle().getHandle())
+
+    print("constructing graph")
+    G = MGGraph(
+        handle,
+        GraphProperties(is_multigraph=True, is_symmetric=False),
+        [src],
+        [dst],
+    )
+    print("graph constructed")
+
+    sample_writer = DistSampleWriter(
+        directory=directory,
+        batches_per_partition=2
+    )
+    sampler = UniformNeighborSampler(
+        G,
+        sample_writer,
+        fanout=[5,5],
+    )
+
+    sampler.sample_from_nodes(seeds, batch_size=16, random_state=62)
+
+    dist.barrier()
+    cugraph_comms_shutdown()
+    print(f"rank {rank} shut down cugraph")
+
+
+def main():
+    world_size = torch.cuda.device_count()
+    uid = cugraph_comms_create_unique_id()
+
+    dataset = NodePropPredDataset("ogbn-products")
+    el = dataset[0][0]["edge_index"].astype("int64")
+
+    with tempfile.TemporaryDirectory() as directory:
+        tmp.spawn(
+            sample,
+            args=(world_size, uid, el, '.'),
+            nprocs=world_size,
+        )
+
+
+if __name__ == "__main__":
+    main()
diff --git a/python/cugraph/cugraph/gnn/__init__.py b/python/cugraph/cugraph/gnn/__init__.py
index 20fefc7de8a..2f0bc2c0bd5 100644
--- a/python/cugraph/cugraph/gnn/__init__.py
+++ b/python/cugraph/cugraph/gnn/__init__.py
@@ -13,6 +13,11 @@
 
 from .feature_storage.feat_storage import FeatureStore
 from .data_loading.bulk_sampler import BulkSampler
+from .data_loading.dist_sampler import (
+    DistSampler,
+    DistSampleWriter,
+    UniformNeighborSampler
+)
 from .comms.cugraph_nccl_comms import (
     cugraph_comms_init,
     cugraph_comms_shutdown,
diff --git a/python/cugraph/cugraph/gnn/comms/__init__.py b/python/cugraph/cugraph/gnn/comms/__init__.py
index aeae6078111..4b40de85abb 100644
--- a/python/cugraph/cugraph/gnn/comms/__init__.py
+++ b/python/cugraph/cugraph/gnn/comms/__init__.py
@@ -10,3 +10,10 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+
+from .cugraph_nccl_comms import (
+    cugraph_comms_init,
+    cugraph_comms_shutdown,
+    cugraph_comms_create_unique_id,
+    cugraph_comms_get_raft_handle,
+)
\ No newline at end of file
diff --git a/python/cugraph/cugraph/gnn/data_loading/__init__.py b/python/cugraph/cugraph/gnn/data_loading/__init__.py
index 4b725fba75a..4eb4bf3de9e 100644
--- a/python/cugraph/cugraph/gnn/data_loading/__init__.py
+++ b/python/cugraph/cugraph/gnn/data_loading/__init__.py
@@ -12,3 +12,8 @@
 # limitations under the License.
 
 from cugraph.gnn.data_loading.bulk_sampler import BulkSampler
+from cugraph.gnn.data_loading.dist_sampler import (
+    DistSampler,
+    DistSampleWriter,
+    UniformNeighborSampler
+)
\ No newline at end of file
diff --git a/python/cugraph/cugraph/gnn/data_loading/bulk_sampler_io.py b/python/cugraph/cugraph/gnn/data_loading/bulk_sampler_io.py
index 24b97d281a8..a109f8fac93 100644
--- a/python/cugraph/cugraph/gnn/data_loading/bulk_sampler_io.py
+++ b/python/cugraph/cugraph/gnn/data_loading/bulk_sampler_io.py
@@ -32,7 +32,7 @@ def create_df_from_disjoint_series(series_list: List[cudf.Series]):
     return df
 
 
-def create_df_from_disjoint_arrays(array_dict: Dict[cupy.array]):
+def create_df_from_disjoint_arrays(array_dict: Dict[str, cupy.array]):
     for k in list(array_dict.keys()):
         array_dict[k] = cudf.Series(array_dict[k], name=k)
     
diff --git a/python/cugraph/cugraph/gnn/data_loading/dist_sampler.py b/python/cugraph/cugraph/gnn/data_loading/dist_sampler.py
index 2d6649018eb..537e38cf780 100644
--- a/python/cugraph/cugraph/gnn/data_loading/dist_sampler.py
+++ b/python/cugraph/cugraph/gnn/data_loading/dist_sampler.py
@@ -12,6 +12,7 @@
 # limitations under the License.
 
 import os
+import warnings
 from math import ceil
 
 import pylibcugraph
@@ -21,7 +22,7 @@
 
 from typing import Union, List
 from cugraph.utilities import import_optional
-from cugraph.gnn import cugraph_comms_get_raft_handle
+from cugraph.gnn.comms import cugraph_comms_get_raft_handle
 
 from cugraph.gnn.data_loading.bulk_sampler_io import create_df_from_disjoint_arrays
 
@@ -32,7 +33,10 @@
 
 
 class DistSampleWriter:
-    def __init__(self, format: str, directory: str, batches_per_partition: int):
+    def __init__(self, directory: str, *, batches_per_partition: int=256, format: str="parquet"):
+        if format != "parquet":
+            raise ValueError("Invalid format (currently supported: 'parquet')")
+
         self.__format = format
         self.__directory = directory
         self.__batches_per_partition = batches_per_partition
@@ -54,10 +58,12 @@ def __write_minibatches_coo(self, minibatch_dict):
         has_edge_types = minibatch_dict['edge_type'] is not None
         has_weights = minibatch_dict['weight'] is not None
 
+        print(minibatch_dict)
         if minibatch_dict['renumber_map'] is None:
             raise ValueError("Distributed sampling without renumbering is not supported")
 
         fanout_length = (len(minibatch_dict['label_hop_offsets']) - 1) // len(minibatch_dict['batch_id'])
+        rank_batch_offset = minibatch_dict['batch_id'][0]
 
         for p in range(0, int(ceil(len(minibatch_dict['batch_id']) / self.__batches_per_partition))):
             partition_start = p * (self.__batches_per_partition)
@@ -68,7 +74,7 @@ def __write_minibatches_coo(self, minibatch_dict):
             ]
 
             batch_id_array_p = minibatch_dict['batch_id'][partition_start:partition_end]
-            start_batch_id = batch_id_array_p[0]
+            start_batch_id = batch_id_array_p[0] - rank_batch_offset
 
             start_ix, end_ix = label_hop_offsets_array_p[[0, -1]]
             majors_array_p = minibatch_dict["majors"][start_ix:end_ix]
@@ -111,9 +117,16 @@ def __write_minibatches_coo(self, minibatch_dict):
             )
 
             end_batch_id = start_batch_id + len(batch_id_array_p) - 1
-            full_output_path = os.path.join(
-                self.__directory, f"batch={start_batch_id:010d}-{end_batch_id:010d}.parquet"
-            )
+            if 'rank' in minibatch_dict:
+                rank = minibatch_dict['rank']
+                full_output_path = os.path.join(
+                    self.__directory, f"batch={rank:05d}{start_batch_id:08d}-{rank:05d}{end_batch_id:08d}.parquet"
+                )
+            else:
+                full_output_path = os.path.join(
+                    self.__directory, f"batch={start_batch_id:010d}-{end_batch_id:010d}.parquet"
+                )
+            
 
             results_dataframe_p.to_parquet(
                 full_output_path, compression=None, index=False, force_nullable_schema=True
@@ -137,29 +150,45 @@ def __init__(
         graph: Union[pylibcugraph.SGGraph, pylibcugraph.MGGraph],
         writer: DistSampleWriter,
         local_seeds_per_call: int = 32768,
-        rank: int = 0,
     ):
         self.__graph = graph
         self.__writer = writer
         self.__local_seeds_per_call = local_seeds_per_call
-        self.__rank = rank
 
     def sample_batches(
         self, seeds: TensorType, batch_ids: TensorType, random_state: int = 0
     ):
         raise NotImplementedError("Must be implemented by subclass")
 
-    def sample_from_nodes(self, nodes: TensorType, batch_size: int, random_state: int):
+    def sample_from_nodes(self, nodes: TensorType, *, batch_size: int=16, random_state: int=62):
         batches_per_call = self._local_seeds_per_call // batch_size
         actual_seeds_per_call = batches_per_call * batch_size
-        num_calls = int(ceil(len(nodes) / actual_seeds_per_call))
 
-        nodes = torch.split(torch.as_tensor(nodes, device="cuda"), num_calls)
+        num_seeds = len(nodes)
+        nodes = torch.split(torch.as_tensor(nodes, device="cuda"), actual_seeds_per_call)
+
+        if self.is_multi_gpu:
+            rank = torch.distributed.get_rank()
+            world_size = torch.distributed.get_world_size()
+
+            t = torch.empty((world_size,), dtype=torch.int64, device='cuda')
+            local_size = torch.tensor([int(ceil(num_seeds / batch_size))], dtype=torch.int64, device='cuda')
+            
+            torch.distributed.all_gather_into_tensor(t, local_size)
+            if (t != local_size).any() and rank == 0:
+                warnings.warn(
+                    "Not all ranks received the same number of batches. "
+                    "This might cause your training loop to hang due to uneven inputs."
+                )
+
+            batch_id_start = t.cumsum(dim=0)[rank] - t[0]
+        else:
+            batch_id_start = 0
 
         for i, current_seeds in enumerate(nodes):
             current_batches = torch.arange(
-                i * batches_per_call,
-                (i + 1) * batches_per_call,
+                batch_id_start + i * batches_per_call,
+                batch_id_start + (i + 1) * batches_per_call,
                 device="cuda",
                 dtype=torch.int32,
             )
@@ -182,67 +211,90 @@ def is_multi_gpu(self):
     @property
     def _local_seeds_per_call(self):
         return self.__local_seeds_per_call
-
+    
     @property
-    def rank(self):
-        return self.__rank
+    def _graph(self):
+        return self.__graph
 
 
 class UniformNeighborSampler(DistSampler):
     def __init__(
         self,
         graph: Union[pylibcugraph.SGGraph, pylibcugraph.MGGraph],
-        fanout: List[int],
-        prior_sources_behavior: str,
-        deduplicate_sources: bool,
-        compression: str,
-        compress_per_hop: bool,
+        writer: DistSampleWriter,
+        *,
+        local_seeds_per_call:int = 32768,
+        fanout: List[int] = [-1],
+        prior_sources_behavior: str = 'exclude',
+        deduplicate_sources: bool = True,
+        compression: str = "COO",
+        compress_per_hop: bool = False,
+        with_replacement: bool = False,
     ):
-        super(graph)
+        super().__init__(graph, writer, local_seeds_per_call=local_seeds_per_call)
         self.__fanout = fanout
         self.__prior_sources_behavior = prior_sources_behavior
         self.__deduplicate_sources = deduplicate_sources
         self.__compress_per_hop = compress_per_hop
         self.__compression = compression
+        self.__with_replacement = with_replacement
 
     def sample_batches(
         self, seeds: TensorType, batch_ids: TensorType, random_state: int = 0
     ):
+        # FIXME allow skipping of the synchronization logic with a boolean
+        # flag that assumes all ranks have the same number of batches.
         if self.is_multi_gpu:
+            rank = torch.distributed.get_rank()
+            world_size = torch.distributed.get_world_size()
             handle = pylibcugraph.ResourceHandle(
                 cugraph_comms_get_raft_handle().getHandle()
             )
-            label_to_output_comm_rank = torch.full(
-                (len(seeds),), self.rank, dtype=torch.int32, device="cuda"
+            
+            local_label_list = torch.unique(batch_ids)
+            local_label_to_output_comm_rank = torch.full(
+                (len(local_label_list),), rank, dtype=torch.int32, device="cuda"
             )
-            label_list = torch.unique(batch_ids)
+
+            num_batches = torch.tensor([len(local_label_list)], device='cuda', dtype=torch.int64)
+            torch.distributed.all_reduce(num_batches, op=torch.distributed.ReduceOp.SUM)
+
+            label_list = torch.empty((num_batches,), device='cuda', dtype=torch.int32)
+            w1 = torch.distributed.all_gather_into_tensor(label_list, local_label_list, async_op=True)
+
+            label_to_output_comm_rank = torch.empty((num_batches,), device='cuda', dtype=torch.int32)
+            w2 = torch.distributed.all_gather_into_tensor(label_to_output_comm_rank, local_label_to_output_comm_rank, async_op=True)
+
+            w1.wait()
+            w2.wait()
 
             sampling_results_dict = pylibcugraph.uniform_neighbor_sample(
                 handle,
-                self.__graph,
-                start_list=seeds,
-                batch_id_list=batch_ids,
-                label_list=label_list,
-                label_to_output_comm_rank=label_to_output_comm_rank,
+                self._graph,
+                start_list=cupy.asarray(seeds),
+                batch_id_list=cupy.asarray(batch_ids),
+                label_list=cupy.asarray(label_list),
+                label_to_output_comm_rank=cupy.asarray(label_to_output_comm_rank),
                 h_fan_out=np.array(self.__fanout, dtype="int32"),
                 with_replacement=self.__with_replacement,
                 do_expensive_check=False,
                 with_edge_properties=True,
-                random_state=random_state,
+                random_state=random_state + rank,
                 prior_sources_behavior=self.__prior_sources_behavior,
                 deduplicate_sources=self.__deduplicate_sources,
                 return_hops=True,
-                renumber=self.__renumber,
+                renumber=True,
                 compression=self.__compression,
                 compress_per_hop=self.__compress_per_hop,
                 return_dict=True,
             )
+            sampling_results_dict['rank'] = rank
         else:
             sampling_results_dict = pylibcugraph.uniform_neighbor_sample(
                 pylibcugraph.ResourceHandle(),
                 self.__graph,
-                start_list=seeds,
-                batch_id_list=batch_ids,
+                start_list=cupy.asarray(seeds),
+                batch_id_list=cupy.asarray(batch_ids),
                 h_fan_out=np.array(self.__fanout, dtype="int32"),
                 with_replacement=self.__with_replacement,
                 do_expensive_check=False,
@@ -251,7 +303,7 @@ def sample_batches(
                 prior_sources_behavior=self.__prior_sources_behavior,
                 deduplicate_sources=self.__deduplicate_sources,
                 return_hops=self.__return_hops,
-                renumber=self.__renumber,
+                renumber=True,
                 compression=self.__compression,
                 compress_per_hop=self.__compress_per_hop,
                 return_dict=True,

From 9bc944b489c91dbade9202069a47d0c860f4b059 Mon Sep 17 00:00:00 2001
From: Alexandria Barghi <abarghi@nvidia.com>
Date: Tue, 2 Apr 2024 14:34:00 -0700
Subject: [PATCH 11/33] cleanup

---
 .../cugraph_pyg/examples/cugraph_dist_sampling.py     | 11 ++++++++++-
 .../cugraph/cugraph/gnn/data_loading/dist_sampler.py  |  3 +--
 2 files changed, 11 insertions(+), 3 deletions(-)

diff --git a/python/cugraph-pyg/cugraph_pyg/examples/cugraph_dist_sampling.py b/python/cugraph-pyg/cugraph_pyg/examples/cugraph_dist_sampling.py
index 10033304e91..29366c404df 100644
--- a/python/cugraph-pyg/cugraph_pyg/examples/cugraph_dist_sampling.py
+++ b/python/cugraph-pyg/cugraph_pyg/examples/cugraph_dist_sampling.py
@@ -17,8 +17,9 @@
 # is intented for users who want to extend cuGraph within a DDP workflow.
 
 import os
-
+import re
 import tempfile
+
 import numpy as np
 import torch
 import torch.multiprocessing as tmp
@@ -100,6 +101,14 @@ def main():
             nprocs=world_size,
         )
 
+        print("Printing samples...")
+        for file in os.listdir(directory):
+            m=re.match(r'batch=([0-9]+)\.([0-9]+)\-([0-9]+)\.([0-9]+)\.parquet', file)
+            rank, start, _, end = int(m[1]), int(m[2]), int(m[3]), int(m[4])
+            print(f'File: {file} (batches {start} to {end} for rank {rank})')
+            print(cudf.read_parquet(os.path.join(directory, file)))
+            print('\n')
+
 
 if __name__ == "__main__":
     main()
diff --git a/python/cugraph/cugraph/gnn/data_loading/dist_sampler.py b/python/cugraph/cugraph/gnn/data_loading/dist_sampler.py
index 537e38cf780..c3948e73da8 100644
--- a/python/cugraph/cugraph/gnn/data_loading/dist_sampler.py
+++ b/python/cugraph/cugraph/gnn/data_loading/dist_sampler.py
@@ -58,7 +58,6 @@ def __write_minibatches_coo(self, minibatch_dict):
         has_edge_types = minibatch_dict['edge_type'] is not None
         has_weights = minibatch_dict['weight'] is not None
 
-        print(minibatch_dict)
         if minibatch_dict['renumber_map'] is None:
             raise ValueError("Distributed sampling without renumbering is not supported")
 
@@ -120,7 +119,7 @@ def __write_minibatches_coo(self, minibatch_dict):
             if 'rank' in minibatch_dict:
                 rank = minibatch_dict['rank']
                 full_output_path = os.path.join(
-                    self.__directory, f"batch={rank:05d}{start_batch_id:08d}-{rank:05d}{end_batch_id:08d}.parquet"
+                    self.__directory, f"batch={rank:05d}.{start_batch_id:08d}-{rank:05d}.{end_batch_id:08d}.parquet"
                 )
             else:
                 full_output_path = os.path.join(

From 5e9135b1596606b00c51d9ff63818d6949f59b58 Mon Sep 17 00:00:00 2001
From: Alexandria Barghi <abarghi@nvidia.com>
Date: Tue, 2 Apr 2024 14:53:41 -0700
Subject: [PATCH 12/33] style

---
 .../examples/cugraph_dist_sampling.py         |  17 +-
 python/cugraph/cugraph/gnn/__init__.py        |   2 +-
 python/cugraph/cugraph/gnn/comms/__init__.py  |   2 +-
 .../cugraph/gnn/data_loading/__init__.py      |   6 +-
 .../gnn/data_loading/bulk_sampler_io.py       |   2 +-
 .../cugraph/gnn/data_loading/dist_sampler.py  | 155 +++++++++++-------
 6 files changed, 112 insertions(+), 72 deletions(-)

diff --git a/python/cugraph-pyg/cugraph_pyg/examples/cugraph_dist_sampling.py b/python/cugraph-pyg/cugraph_pyg/examples/cugraph_dist_sampling.py
index 29366c404df..c66d649658f 100644
--- a/python/cugraph-pyg/cugraph_pyg/examples/cugraph_dist_sampling.py
+++ b/python/cugraph-pyg/cugraph_pyg/examples/cugraph_dist_sampling.py
@@ -33,7 +33,7 @@
     cugraph_comms_create_unique_id,
     cugraph_comms_get_raft_handle,
     DistSampleWriter,
-    UniformNeighborSampler
+    UniformNeighborSampler,
 )
 
 from pylibcugraph import MGGraph, ResourceHandle, GraphProperties
@@ -70,14 +70,11 @@ def sample(rank: int, world_size: int, uid, edgelist, directory):
     )
     print("graph constructed")
 
-    sample_writer = DistSampleWriter(
-        directory=directory,
-        batches_per_partition=2
-    )
+    sample_writer = DistSampleWriter(directory=directory, batches_per_partition=2)
     sampler = UniformNeighborSampler(
         G,
         sample_writer,
-        fanout=[5,5],
+        fanout=[5, 5],
     )
 
     sampler.sample_from_nodes(seeds, batch_size=16, random_state=62)
@@ -97,17 +94,17 @@ def main():
     with tempfile.TemporaryDirectory() as directory:
         tmp.spawn(
             sample,
-            args=(world_size, uid, el, '.'),
+            args=(world_size, uid, el, "."),
             nprocs=world_size,
         )
 
         print("Printing samples...")
         for file in os.listdir(directory):
-            m=re.match(r'batch=([0-9]+)\.([0-9]+)\-([0-9]+)\.([0-9]+)\.parquet', file)
+            m = re.match(r"batch=([0-9]+)\.([0-9]+)\-([0-9]+)\.([0-9]+)\.parquet", file)
             rank, start, _, end = int(m[1]), int(m[2]), int(m[3]), int(m[4])
-            print(f'File: {file} (batches {start} to {end} for rank {rank})')
+            print(f"File: {file} (batches {start} to {end} for rank {rank})")
             print(cudf.read_parquet(os.path.join(directory, file)))
-            print('\n')
+            print("\n")
 
 
 if __name__ == "__main__":
diff --git a/python/cugraph/cugraph/gnn/__init__.py b/python/cugraph/cugraph/gnn/__init__.py
index 2f0bc2c0bd5..1f4d98f0230 100644
--- a/python/cugraph/cugraph/gnn/__init__.py
+++ b/python/cugraph/cugraph/gnn/__init__.py
@@ -16,7 +16,7 @@
 from .data_loading.dist_sampler import (
     DistSampler,
     DistSampleWriter,
-    UniformNeighborSampler
+    UniformNeighborSampler,
 )
 from .comms.cugraph_nccl_comms import (
     cugraph_comms_init,
diff --git a/python/cugraph/cugraph/gnn/comms/__init__.py b/python/cugraph/cugraph/gnn/comms/__init__.py
index 4b40de85abb..b842dd0927d 100644
--- a/python/cugraph/cugraph/gnn/comms/__init__.py
+++ b/python/cugraph/cugraph/gnn/comms/__init__.py
@@ -16,4 +16,4 @@
     cugraph_comms_shutdown,
     cugraph_comms_create_unique_id,
     cugraph_comms_get_raft_handle,
-)
\ No newline at end of file
+)
diff --git a/python/cugraph/cugraph/gnn/data_loading/__init__.py b/python/cugraph/cugraph/gnn/data_loading/__init__.py
index 4eb4bf3de9e..a50f6085e9a 100644
--- a/python/cugraph/cugraph/gnn/data_loading/__init__.py
+++ b/python/cugraph/cugraph/gnn/data_loading/__init__.py
@@ -1,4 +1,4 @@
-# Copyright (c) 2023, NVIDIA CORPORATION.
+# Copyright (c) 2023-2024, NVIDIA CORPORATION.
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
@@ -15,5 +15,5 @@
 from cugraph.gnn.data_loading.dist_sampler import (
     DistSampler,
     DistSampleWriter,
-    UniformNeighborSampler
-)
\ No newline at end of file
+    UniformNeighborSampler,
+)
diff --git a/python/cugraph/cugraph/gnn/data_loading/bulk_sampler_io.py b/python/cugraph/cugraph/gnn/data_loading/bulk_sampler_io.py
index a109f8fac93..6abbd82647b 100644
--- a/python/cugraph/cugraph/gnn/data_loading/bulk_sampler_io.py
+++ b/python/cugraph/cugraph/gnn/data_loading/bulk_sampler_io.py
@@ -35,7 +35,7 @@ def create_df_from_disjoint_series(series_list: List[cudf.Series]):
 def create_df_from_disjoint_arrays(array_dict: Dict[str, cupy.array]):
     for k in list(array_dict.keys()):
         array_dict[k] = cudf.Series(array_dict[k], name=k)
-    
+
     return create_df_from_disjoint_series(list(array_dict.values()))
 
 
diff --git a/python/cugraph/cugraph/gnn/data_loading/dist_sampler.py b/python/cugraph/cugraph/gnn/data_loading/dist_sampler.py
index c3948e73da8..42e7d95c44d 100644
--- a/python/cugraph/cugraph/gnn/data_loading/dist_sampler.py
+++ b/python/cugraph/cugraph/gnn/data_loading/dist_sampler.py
@@ -33,7 +33,13 @@
 
 
 class DistSampleWriter:
-    def __init__(self, directory: str, *, batches_per_partition: int=256, format: str="parquet"):
+    def __init__(
+        self,
+        directory: str,
+        *,
+        batches_per_partition: int = 256,
+        format: str = "parquet",
+    ):
         if format != "parquet":
             raise ValueError("Invalid format (currently supported: 'parquet')")
 
@@ -52,92 +58,114 @@ def _directory(self):
     @property
     def _batches_per_partition(self):
         return self.__batches_per_partition
-    
+
     def __write_minibatches_coo(self, minibatch_dict):
-        has_edge_ids = minibatch_dict['edge_id'] is not None
-        has_edge_types = minibatch_dict['edge_type'] is not None
-        has_weights = minibatch_dict['weight'] is not None
+        has_edge_ids = minibatch_dict["edge_id"] is not None
+        has_edge_types = minibatch_dict["edge_type"] is not None
+        has_weights = minibatch_dict["weight"] is not None
 
-        if minibatch_dict['renumber_map'] is None:
-            raise ValueError("Distributed sampling without renumbering is not supported")
+        if minibatch_dict["renumber_map"] is None:
+            raise ValueError(
+                "Distributed sampling without renumbering is not supported"
+            )
 
-        fanout_length = (len(minibatch_dict['label_hop_offsets']) - 1) // len(minibatch_dict['batch_id'])
-        rank_batch_offset = minibatch_dict['batch_id'][0]
+        fanout_length = (len(minibatch_dict["label_hop_offsets"]) - 1) // len(
+            minibatch_dict["batch_id"]
+        )
+        rank_batch_offset = minibatch_dict["batch_id"][0]
 
-        for p in range(0, int(ceil(len(minibatch_dict['batch_id']) / self.__batches_per_partition))):
+        for p in range(
+            0, int(ceil(len(minibatch_dict["batch_id"]) / self.__batches_per_partition))
+        ):
             partition_start = p * (self.__batches_per_partition)
             partition_end = (p + 1) * (self.__batches_per_partition)
 
-            label_hop_offsets_array_p = minibatch_dict['label_hop_offsets'][
+            label_hop_offsets_array_p = minibatch_dict["label_hop_offsets"][
                 partition_start * fanout_length : partition_end * fanout_length + 1
             ]
 
-            batch_id_array_p = minibatch_dict['batch_id'][partition_start:partition_end]
+            batch_id_array_p = minibatch_dict["batch_id"][partition_start:partition_end]
             start_batch_id = batch_id_array_p[0] - rank_batch_offset
 
             start_ix, end_ix = label_hop_offsets_array_p[[0, -1]]
             majors_array_p = minibatch_dict["majors"][start_ix:end_ix]
             minors_array_p = minibatch_dict["minors"][start_ix:end_ix]
             edge_id_array_p = (
-                minibatch_dict["edge_id"][start_ix:end_ix] if has_edge_ids
-                else cupy.array([], dtype='int64')
+                minibatch_dict["edge_id"][start_ix:end_ix]
+                if has_edge_ids
+                else cupy.array([], dtype="int64")
             )
             edge_type_array_p = (
-                minibatch_dict["edge_type"][start_ix:end_ix] if has_edge_types
-                else cupy.array([], dtype='int32')
+                minibatch_dict["edge_type"][start_ix:end_ix]
+                if has_edge_types
+                else cupy.array([], dtype="int32")
             )
             weight_array_p = (
-                minibatch_dict["weight"][start_ix:end_ix] if has_weights
-                else cupy.array([], dtype='float32')
+                minibatch_dict["weight"][start_ix:end_ix]
+                if has_weights
+                else cupy.array([], dtype="float32")
             )
-            
+
             # create the renumber map offsets
-            renumber_map_offsets_array_p = minibatch_dict['renumber_map_offsets'][
+            renumber_map_offsets_array_p = minibatch_dict["renumber_map_offsets"][
                 partition_start : partition_end + 1
             ]
 
-            renumber_map_start_ix, renumber_map_end_ix = renumber_map_offsets_array_p[[0,-1]]
+            renumber_map_start_ix, renumber_map_end_ix = renumber_map_offsets_array_p[
+                [0, -1]
+            ]
 
-            renumber_map_array_p = minibatch_dict['renumber_map'][
+            renumber_map_array_p = minibatch_dict["renumber_map"][
                 renumber_map_start_ix:renumber_map_end_ix
             ]
 
             results_dataframe_p = create_df_from_disjoint_arrays(
                 {
-                    'majors': majors_array_p,
-                    'minors': minors_array_p,
-                    'map': renumber_map_array_p,
-                    'label_hop_offsets': label_hop_offsets_array_p,
-                    'weight': weight_array_p,
-                    'edge_id': edge_id_array_p,
-                    'edge_type': edge_type_array_p,
-                    'renumber_map_offsets': renumber_map_offsets_array_p,
+                    "majors": majors_array_p,
+                    "minors": minors_array_p,
+                    "map": renumber_map_array_p,
+                    "label_hop_offsets": label_hop_offsets_array_p,
+                    "weight": weight_array_p,
+                    "edge_id": edge_id_array_p,
+                    "edge_type": edge_type_array_p,
+                    "renumber_map_offsets": renumber_map_offsets_array_p,
                 }
             )
 
             end_batch_id = start_batch_id + len(batch_id_array_p) - 1
-            if 'rank' in minibatch_dict:
-                rank = minibatch_dict['rank']
+            if "rank" in minibatch_dict:
+                rank = minibatch_dict["rank"]
                 full_output_path = os.path.join(
-                    self.__directory, f"batch={rank:05d}.{start_batch_id:08d}-{rank:05d}.{end_batch_id:08d}.parquet"
+                    self.__directory,
+                    f"batch={rank:05d}.{start_batch_id:08d}-"
+                    f"{rank:05d}.{end_batch_id:08d}.parquet",
                 )
             else:
                 full_output_path = os.path.join(
-                    self.__directory, f"batch={start_batch_id:010d}-{end_batch_id:010d}.parquet"
+                    self.__directory,
+                    f"batch={start_batch_id:010d}-{end_batch_id:010d}.parquet",
                 )
-            
 
             results_dataframe_p.to_parquet(
-                full_output_path, compression=None, index=False, force_nullable_schema=True
+                full_output_path,
+                compression=None,
+                index=False,
+                force_nullable_schema=True,
             )
-        
+
     def __write_minibatches_csr(self, minibatch_dict):
-        raise NotImplementedError("CSR format currently not supported for distributed sampling")
+        raise NotImplementedError(
+            "CSR format currently not supported for distributed sampling"
+        )
 
     def write_minibatches(self, minibatch_dict):
-        if (minibatch_dict['majors'] is not None) and (minibatch_dict['minors'] is not None):
+        if (minibatch_dict["majors"] is not None) and (
+            minibatch_dict["minors"] is not None
+        ):
             self.__write_minibatches_coo(minibatch_dict)
-        elif (minibatch_dict["major_offsets"] is not None) and (minibatch_dict['minors'] is not None):
+        elif (minibatch_dict["major_offsets"] is not None) and (
+            minibatch_dict["minors"] is not None
+        ):
             self.__write_minibatches_csr(minibatch_dict)
         else:
             raise ValueError("invalid columns")
@@ -159,20 +187,26 @@ def sample_batches(
     ):
         raise NotImplementedError("Must be implemented by subclass")
 
-    def sample_from_nodes(self, nodes: TensorType, *, batch_size: int=16, random_state: int=62):
+    def sample_from_nodes(
+        self, nodes: TensorType, *, batch_size: int = 16, random_state: int = 62
+    ):
         batches_per_call = self._local_seeds_per_call // batch_size
         actual_seeds_per_call = batches_per_call * batch_size
 
         num_seeds = len(nodes)
-        nodes = torch.split(torch.as_tensor(nodes, device="cuda"), actual_seeds_per_call)
+        nodes = torch.split(
+            torch.as_tensor(nodes, device="cuda"), actual_seeds_per_call
+        )
 
         if self.is_multi_gpu:
             rank = torch.distributed.get_rank()
             world_size = torch.distributed.get_world_size()
 
-            t = torch.empty((world_size,), dtype=torch.int64, device='cuda')
-            local_size = torch.tensor([int(ceil(num_seeds / batch_size))], dtype=torch.int64, device='cuda')
-            
+            t = torch.empty((world_size,), dtype=torch.int64, device="cuda")
+            local_size = torch.tensor(
+                [int(ceil(num_seeds / batch_size))], dtype=torch.int64, device="cuda"
+            )
+
             torch.distributed.all_gather_into_tensor(t, local_size)
             if (t != local_size).any() and rank == 0:
                 warnings.warn(
@@ -210,7 +244,7 @@ def is_multi_gpu(self):
     @property
     def _local_seeds_per_call(self):
         return self.__local_seeds_per_call
-    
+
     @property
     def _graph(self):
         return self.__graph
@@ -222,9 +256,9 @@ def __init__(
         graph: Union[pylibcugraph.SGGraph, pylibcugraph.MGGraph],
         writer: DistSampleWriter,
         *,
-        local_seeds_per_call:int = 32768,
+        local_seeds_per_call: int = 32768,
         fanout: List[int] = [-1],
-        prior_sources_behavior: str = 'exclude',
+        prior_sources_behavior: str = "exclude",
         deduplicate_sources: bool = True,
         compression: str = "COO",
         compress_per_hop: bool = False,
@@ -245,24 +279,33 @@ def sample_batches(
         # flag that assumes all ranks have the same number of batches.
         if self.is_multi_gpu:
             rank = torch.distributed.get_rank()
-            world_size = torch.distributed.get_world_size()
             handle = pylibcugraph.ResourceHandle(
                 cugraph_comms_get_raft_handle().getHandle()
             )
-            
+
             local_label_list = torch.unique(batch_ids)
             local_label_to_output_comm_rank = torch.full(
                 (len(local_label_list),), rank, dtype=torch.int32, device="cuda"
             )
 
-            num_batches = torch.tensor([len(local_label_list)], device='cuda', dtype=torch.int64)
+            num_batches = torch.tensor(
+                [len(local_label_list)], device="cuda", dtype=torch.int64
+            )
             torch.distributed.all_reduce(num_batches, op=torch.distributed.ReduceOp.SUM)
 
-            label_list = torch.empty((num_batches,), device='cuda', dtype=torch.int32)
-            w1 = torch.distributed.all_gather_into_tensor(label_list, local_label_list, async_op=True)
+            label_list = torch.empty((num_batches,), device="cuda", dtype=torch.int32)
+            w1 = torch.distributed.all_gather_into_tensor(
+                label_list, local_label_list, async_op=True
+            )
 
-            label_to_output_comm_rank = torch.empty((num_batches,), device='cuda', dtype=torch.int32)
-            w2 = torch.distributed.all_gather_into_tensor(label_to_output_comm_rank, local_label_to_output_comm_rank, async_op=True)
+            label_to_output_comm_rank = torch.empty(
+                (num_batches,), device="cuda", dtype=torch.int32
+            )
+            w2 = torch.distributed.all_gather_into_tensor(
+                label_to_output_comm_rank,
+                local_label_to_output_comm_rank,
+                async_op=True,
+            )
 
             w1.wait()
             w2.wait()
@@ -287,7 +330,7 @@ def sample_batches(
                 compress_per_hop=self.__compress_per_hop,
                 return_dict=True,
             )
-            sampling_results_dict['rank'] = rank
+            sampling_results_dict["rank"] = rank
         else:
             sampling_results_dict = pylibcugraph.uniform_neighbor_sample(
                 pylibcugraph.ResourceHandle(),

From 059327832bf3e6fc06e4f229e898dc798870f792 Mon Sep 17 00:00:00 2001
From: Alexandria Barghi <abarghi@nvidia.com>
Date: Tue, 2 Apr 2024 15:07:22 -0700
Subject: [PATCH 13/33] sg example

---
 ...ampling.py => cugraph_dist_sampling_mg.py} |  0
 .../examples/cugraph_dist_sampling_sg.py      | 82 +++++++++++++++++++
 .../cugraph/gnn/data_loading/dist_sampler.py  | 23 ++----
 3 files changed, 91 insertions(+), 14 deletions(-)
 rename python/cugraph-pyg/cugraph_pyg/examples/{cugraph_dist_sampling.py => cugraph_dist_sampling_mg.py} (100%)
 create mode 100644 python/cugraph-pyg/cugraph_pyg/examples/cugraph_dist_sampling_sg.py

diff --git a/python/cugraph-pyg/cugraph_pyg/examples/cugraph_dist_sampling.py b/python/cugraph-pyg/cugraph_pyg/examples/cugraph_dist_sampling_mg.py
similarity index 100%
rename from python/cugraph-pyg/cugraph_pyg/examples/cugraph_dist_sampling.py
rename to python/cugraph-pyg/cugraph_pyg/examples/cugraph_dist_sampling_mg.py
diff --git a/python/cugraph-pyg/cugraph_pyg/examples/cugraph_dist_sampling_sg.py b/python/cugraph-pyg/cugraph_pyg/examples/cugraph_dist_sampling_sg.py
new file mode 100644
index 00000000000..119e2aa5199
--- /dev/null
+++ b/python/cugraph-pyg/cugraph_pyg/examples/cugraph_dist_sampling_sg.py
@@ -0,0 +1,82 @@
+# Copyright (c) 2024, NVIDIA CORPORATION.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# This example shows how to use cuGraph nccl-only comms, pylibcuGraph,
+# and PyTorch DDP to run a multi-GPU sampling workflow.  Most users of the
+# GNN packages will not interact with cuGraph directly.  This example
+# is intented for users who want to extend cuGraph within a DDP workflow.
+
+import os
+import re
+import tempfile
+
+import numpy as np
+import torch
+import torch.multiprocessing as tmp
+import torch.distributed as dist
+
+import cudf
+
+from cugraph.gnn import (
+    DistSampleWriter,
+    UniformNeighborSampler,
+)
+
+from pylibcugraph import SGGraph, ResourceHandle, GraphProperties
+
+from ogb.nodeproppred import NodePropPredDataset
+
+
+def sample(edgelist, directory):
+    src = cudf.Series(edgelist[0])
+    dst = cudf.Series(edgelist[1])
+
+    seeds = cudf.Series(np.arange(0, 50))
+
+    print("constructing graph")
+    G = SGGraph(
+        ResourceHandle(),
+        GraphProperties(is_multigraph=True, is_symmetric=False),
+        src,
+        dst,
+    )
+    print("graph constructed")
+
+    sample_writer = DistSampleWriter(directory=directory, batches_per_partition=2)
+    sampler = UniformNeighborSampler(
+        G,
+        sample_writer,
+        fanout=[5, 5],
+    )
+
+    sampler.sample_from_nodes(seeds, batch_size=16, random_state=62)
+
+
+def main():
+    dataset = NodePropPredDataset("ogbn-products")
+    el = dataset[0][0]["edge_index"].astype("int64")
+
+    with tempfile.TemporaryDirectory() as directory:
+        sample(el, directory)
+
+        print("Printing samples...")
+        for file in os.listdir(directory):
+            m = re.match(r"batch=([0-9]+)\.([0-9]+)\-([0-9]+)\.([0-9]+)\.parquet", file)
+            rank, start, _, end = int(m[1]), int(m[2]), int(m[3]), int(m[4])
+            print(f"File: {file} (batches {start} to {end} for rank {rank})")
+            print(cudf.read_parquet(os.path.join(directory, file)))
+            print("\n")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/python/cugraph/cugraph/gnn/data_loading/dist_sampler.py b/python/cugraph/cugraph/gnn/data_loading/dist_sampler.py
index 42e7d95c44d..226f76ff2da 100644
--- a/python/cugraph/cugraph/gnn/data_loading/dist_sampler.py
+++ b/python/cugraph/cugraph/gnn/data_loading/dist_sampler.py
@@ -133,18 +133,13 @@ def __write_minibatches_coo(self, minibatch_dict):
             )
 
             end_batch_id = start_batch_id + len(batch_id_array_p) - 1
-            if "rank" in minibatch_dict:
-                rank = minibatch_dict["rank"]
-                full_output_path = os.path.join(
-                    self.__directory,
-                    f"batch={rank:05d}.{start_batch_id:08d}-"
-                    f"{rank:05d}.{end_batch_id:08d}.parquet",
-                )
-            else:
-                full_output_path = os.path.join(
-                    self.__directory,
-                    f"batch={start_batch_id:010d}-{end_batch_id:010d}.parquet",
-                )
+            rank = minibatch_dict["rank"] if "rank" in minibatch_dict else 0
+            
+            full_output_path = os.path.join(
+                self.__directory,
+                f"batch={rank:05d}.{start_batch_id:08d}-"
+                f"{rank:05d}.{end_batch_id:08d}.parquet",
+            )
 
             results_dataframe_p.to_parquet(
                 full_output_path,
@@ -334,7 +329,7 @@ def sample_batches(
         else:
             sampling_results_dict = pylibcugraph.uniform_neighbor_sample(
                 pylibcugraph.ResourceHandle(),
-                self.__graph,
+                self._graph,
                 start_list=cupy.asarray(seeds),
                 batch_id_list=cupy.asarray(batch_ids),
                 h_fan_out=np.array(self.__fanout, dtype="int32"),
@@ -344,7 +339,7 @@ def sample_batches(
                 random_state=random_state,
                 prior_sources_behavior=self.__prior_sources_behavior,
                 deduplicate_sources=self.__deduplicate_sources,
-                return_hops=self.__return_hops,
+                return_hops=True,
                 renumber=True,
                 compression=self.__compression,
                 compress_per_hop=self.__compress_per_hop,

From b44ea3b4b2e95ae8a1edaf6adc6c63c7beb1cc0e Mon Sep 17 00:00:00 2001
From: Alexandria Barghi <abarghi@nvidia.com>
Date: Tue, 2 Apr 2024 15:10:10 -0700
Subject: [PATCH 14/33] cleanup:

---
 .../cugraph_pyg/examples/cugraph_dist_sampling_sg.py          | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/python/cugraph-pyg/cugraph_pyg/examples/cugraph_dist_sampling_sg.py b/python/cugraph-pyg/cugraph_pyg/examples/cugraph_dist_sampling_sg.py
index 119e2aa5199..fac58efac01 100644
--- a/python/cugraph-pyg/cugraph_pyg/examples/cugraph_dist_sampling_sg.py
+++ b/python/cugraph-pyg/cugraph_pyg/examples/cugraph_dist_sampling_sg.py
@@ -12,9 +12,9 @@
 # limitations under the License.
 
 # This example shows how to use cuGraph nccl-only comms, pylibcuGraph,
-# and PyTorch DDP to run a multi-GPU sampling workflow.  Most users of the
+# and PyTorch to run a single-GPU sampling workflow.  Most users of the
 # GNN packages will not interact with cuGraph directly.  This example
-# is intented for users who want to extend cuGraph within a DDP workflow.
+# is intented for users who want to extend cuGraph within a PyTorch workflow.
 
 import os
 import re

From e7af04526a889edfe1df396d00b4a7a618f7d72c Mon Sep 17 00:00:00 2001
From: Alexandria Barghi <abarghi@nvidia.com>
Date: Tue, 2 Apr 2024 15:10:45 -0700
Subject: [PATCH 15/33] cleanup imports

---
 .../cugraph_pyg/examples/cugraph_dist_sampling_sg.py           | 3 ---
 python/cugraph/cugraph/gnn/data_loading/dist_sampler.py        | 2 +-
 2 files changed, 1 insertion(+), 4 deletions(-)

diff --git a/python/cugraph-pyg/cugraph_pyg/examples/cugraph_dist_sampling_sg.py b/python/cugraph-pyg/cugraph_pyg/examples/cugraph_dist_sampling_sg.py
index fac58efac01..f02aa62e2ec 100644
--- a/python/cugraph-pyg/cugraph_pyg/examples/cugraph_dist_sampling_sg.py
+++ b/python/cugraph-pyg/cugraph_pyg/examples/cugraph_dist_sampling_sg.py
@@ -21,9 +21,6 @@
 import tempfile
 
 import numpy as np
-import torch
-import torch.multiprocessing as tmp
-import torch.distributed as dist
 
 import cudf
 
diff --git a/python/cugraph/cugraph/gnn/data_loading/dist_sampler.py b/python/cugraph/cugraph/gnn/data_loading/dist_sampler.py
index 226f76ff2da..3cc9b840768 100644
--- a/python/cugraph/cugraph/gnn/data_loading/dist_sampler.py
+++ b/python/cugraph/cugraph/gnn/data_loading/dist_sampler.py
@@ -134,7 +134,7 @@ def __write_minibatches_coo(self, minibatch_dict):
 
             end_batch_id = start_batch_id + len(batch_id_array_p) - 1
             rank = minibatch_dict["rank"] if "rank" in minibatch_dict else 0
-            
+
             full_output_path = os.path.join(
                 self.__directory,
                 f"batch={rank:05d}.{start_batch_id:08d}-"

From 06dfdd51f292f1c24075dd8b41a40e43b6beb8ae Mon Sep 17 00:00:00 2001
From: Alexandria Barghi <abarghi@nvidia.com>
Date: Wed, 3 Apr 2024 11:01:36 -0700
Subject: [PATCH 16/33] set seeds per rank

---
 .../cugraph_pyg/examples/cugraph_dist_sampling_mg.py           | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/python/cugraph-pyg/cugraph_pyg/examples/cugraph_dist_sampling_mg.py b/python/cugraph-pyg/cugraph_pyg/examples/cugraph_dist_sampling_mg.py
index c66d649658f..29a6cc2b464 100644
--- a/python/cugraph-pyg/cugraph_pyg/examples/cugraph_dist_sampling_mg.py
+++ b/python/cugraph-pyg/cugraph_pyg/examples/cugraph_dist_sampling_mg.py
@@ -58,7 +58,8 @@ def sample(rank: int, world_size: int, uid, edgelist, directory):
     src = cudf.Series(np.array_split(edgelist[0], world_size)[rank])
     dst = cudf.Series(np.array_split(edgelist[1], world_size)[rank])
 
-    seeds = cudf.Series(np.arange(rank * 50, (rank + 1) * 50))
+    seeds_per_rank = 50
+    seeds = cudf.Series(np.arange(rank * seeds_per_rank, (rank + 1) * seeds_per_rank))
     handle = ResourceHandle(cugraph_comms_get_raft_handle().getHandle())
 
     print("constructing graph")

From 4cd2f1042eb1bceee2a4b9c8b38e22666cf0675a Mon Sep 17 00:00:00 2001
From: Alexandria Barghi <abarghi@nvidia.com>
Date: Wed, 3 Apr 2024 11:02:10 -0700
Subject: [PATCH 17/33] set seeds per rank for sg

---
 .../cugraph_pyg/examples/cugraph_dist_sampling_sg.py           | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/python/cugraph-pyg/cugraph_pyg/examples/cugraph_dist_sampling_sg.py b/python/cugraph-pyg/cugraph_pyg/examples/cugraph_dist_sampling_sg.py
index f02aa62e2ec..8366ff44233 100644
--- a/python/cugraph-pyg/cugraph_pyg/examples/cugraph_dist_sampling_sg.py
+++ b/python/cugraph-pyg/cugraph_pyg/examples/cugraph_dist_sampling_sg.py
@@ -38,7 +38,8 @@ def sample(edgelist, directory):
     src = cudf.Series(edgelist[0])
     dst = cudf.Series(edgelist[1])
 
-    seeds = cudf.Series(np.arange(0, 50))
+    seeds_per_rank = 50
+    seeds = cudf.Series(np.arange(0, seeds_per_rank))
 
     print("constructing graph")
     G = SGGraph(

From 4dfae1fd1cc0d56458b2c9d9ee17247ff3502541 Mon Sep 17 00:00:00 2001
From: Alexandria Barghi <abarghi@nvidia.com>
Date: Wed, 3 Apr 2024 11:32:08 -0700
Subject: [PATCH 18/33] rename nodes to nodes_call_groups

---
 python/cugraph/cugraph/gnn/data_loading/dist_sampler.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/python/cugraph/cugraph/gnn/data_loading/dist_sampler.py b/python/cugraph/cugraph/gnn/data_loading/dist_sampler.py
index 3cc9b840768..00170c229e1 100644
--- a/python/cugraph/cugraph/gnn/data_loading/dist_sampler.py
+++ b/python/cugraph/cugraph/gnn/data_loading/dist_sampler.py
@@ -189,7 +189,7 @@ def sample_from_nodes(
         actual_seeds_per_call = batches_per_call * batch_size
 
         num_seeds = len(nodes)
-        nodes = torch.split(
+        nodes_call_groups = torch.split(
             torch.as_tensor(nodes, device="cuda"), actual_seeds_per_call
         )
 
@@ -213,7 +213,7 @@ def sample_from_nodes(
         else:
             batch_id_start = 0
 
-        for i, current_seeds in enumerate(nodes):
+        for i, current_seeds in enumerate(nodes_call_groups):
             current_batches = torch.arange(
                 batch_id_start + i * batches_per_call,
                 batch_id_start + (i + 1) * batches_per_call,

From 983a6845ab669596a973453a8f249dd0d68dcc3a Mon Sep 17 00:00:00 2001
From: Alexandria Barghi <abarghi@nvidia.com>
Date: Wed, 3 Apr 2024 11:40:20 -0700
Subject: [PATCH 19/33] docstring, type annotations

---
 .../cugraph/gnn/data_loading/dist_sampler.py  | 37 ++++++++++++++++++-
 1 file changed, 35 insertions(+), 2 deletions(-)

diff --git a/python/cugraph/cugraph/gnn/data_loading/dist_sampler.py b/python/cugraph/cugraph/gnn/data_loading/dist_sampler.py
index 00170c229e1..4bf3965d851 100644
--- a/python/cugraph/cugraph/gnn/data_loading/dist_sampler.py
+++ b/python/cugraph/cugraph/gnn/data_loading/dist_sampler.py
@@ -20,7 +20,7 @@
 import cupy
 import cudf
 
-from typing import Union, List
+from typing import Union, List, Dict
 from cugraph.utilities import import_optional
 from cugraph.gnn.comms import cugraph_comms_get_raft_handle
 
@@ -179,12 +179,45 @@ def __init__(
 
     def sample_batches(
         self, seeds: TensorType, batch_ids: TensorType, random_state: int = 0
-    ):
+    ) -> Dict[str, TensorType]:
+        """
+        For a single call group of seeds and associated batch ids, performs
+        sampling.
+
+        Parameters
+        ----------
+        seeds: TensorType
+            Input seeds for a single call group (node ids).
+        batch_ids: TensorType
+            The batch id for each seed.
+        random_state: int
+            The random seed to use for sampling.
+        
+        Returns
+        -------
+        A dictionary containing the sampling outputs (majors, minors, map, etc.)
+        """
         raise NotImplementedError("Must be implemented by subclass")
 
     def sample_from_nodes(
         self, nodes: TensorType, *, batch_size: int = 16, random_state: int = 62
     ):
+        """
+        Performs node-based sampling.  Accepts a list of seed nodes, and batch size.
+        Splits the seed list into batches, then divides the batches into call groups
+        based on the number of seeds per call this sampler was set to use.  Then calls
+        sample_batches for each call group and writes the result using the writer
+        associated with this sampler.
+
+        Parameters
+        ----------
+        nodes: TensorType
+            Input seeds (node ids).
+        batch_size: int
+            The size of each batch.
+        random_state: int
+            The random seed to use for sampling.
+        """
         batches_per_call = self._local_seeds_per_call // batch_size
         actual_seeds_per_call = batches_per_call * batch_size
 

From 03c27c9db9a3fe48dff25815af2d771c2daaf253 Mon Sep 17 00:00:00 2001
From: Alexandria Barghi <abarghi@nvidia.com>
Date: Wed, 3 Apr 2024 12:13:42 -0700
Subject: [PATCH 20/33] new functions and docstring

---
 .../cugraph/gnn/data_loading/dist_sampler.py  | 151 +++++++++++++-----
 1 file changed, 110 insertions(+), 41 deletions(-)

diff --git a/python/cugraph/cugraph/gnn/data_loading/dist_sampler.py b/python/cugraph/cugraph/gnn/data_loading/dist_sampler.py
index 4bf3965d851..573258c4d6a 100644
--- a/python/cugraph/cugraph/gnn/data_loading/dist_sampler.py
+++ b/python/cugraph/cugraph/gnn/data_loading/dist_sampler.py
@@ -178,7 +178,7 @@ def __init__(
         self.__local_seeds_per_call = local_seeds_per_call
 
     def sample_batches(
-        self, seeds: TensorType, batch_ids: TensorType, random_state: int = 0
+        self, seeds: TensorType, batch_ids: TensorType, random_state: int = 0, assume_equal_input_size: bool=False
     ) -> Dict[str, TensorType]:
         """
         For a single call group of seeds and associated batch ids, performs
@@ -192,6 +192,10 @@ def sample_batches(
             The batch id for each seed.
         random_state: int
             The random seed to use for sampling.
+        assume_equal_input_size: bool
+            If True, will assume all ranks have the same number of inputs,
+            and will skip the synchronization/gather steps to check for
+            and handle uneven inputs.
         
         Returns
         -------
@@ -199,8 +203,49 @@ def sample_batches(
         """
         raise NotImplementedError("Must be implemented by subclass")
 
+    def get_start_batch_offset(self, local_num_batches:int, assume_equal_input_size:bool=False) -> int:
+        """
+        Gets the starting batch offset to ensure each rank's set of batch ids is
+        disjoint.
+        
+        Parameters
+        ----------
+        local_num_batches: int
+            The number of batches for this rank.
+        assume_equal_input_size: bool
+            Whether to assume all ranks have the same number of batches.
+        
+        Returns
+        -------
+        The starting batch offset (int).
+
+        """
+        rank = torch.distributed.get_rank()
+        world_size = torch.distributed.get_world_size()
+        
+        if self.is_multi_gpu:
+            if assume_equal_input_size:
+                t = torch.full((world_size,), local_num_batches, dtype=torch.int64, device='cpu')
+            else:
+                t = torch.empty((world_size,), dtype=torch.int64, device="cuda")
+                local_size = torch.tensor(
+                    [local_num_batches], dtype=torch.int64, device="cuda"
+                )
+
+                torch.distributed.all_gather_into_tensor(t, local_size)
+                if (t != local_size).any() and rank == 0:
+                    warnings.warn(
+                        "Not all ranks received the same number of batches. "
+                        "This might cause your training loop to hang due to uneven inputs."
+                    )
+
+                return t.cumsum(dim=0)[rank] - t[0]
+        else:
+            return 0
+
+
     def sample_from_nodes(
-        self, nodes: TensorType, *, batch_size: int = 16, random_state: int = 62
+        self, nodes: TensorType, *, batch_size: int = 16, random_state: int = 62, assume_equal_input_size:bool=False
     ):
         """
         Performs node-based sampling.  Accepts a list of seed nodes, and batch size.
@@ -225,26 +270,9 @@ def sample_from_nodes(
         nodes_call_groups = torch.split(
             torch.as_tensor(nodes, device="cuda"), actual_seeds_per_call
         )
-
-        if self.is_multi_gpu:
-            rank = torch.distributed.get_rank()
-            world_size = torch.distributed.get_world_size()
-
-            t = torch.empty((world_size,), dtype=torch.int64, device="cuda")
-            local_size = torch.tensor(
-                [int(ceil(num_seeds / batch_size))], dtype=torch.int64, device="cuda"
-            )
-
-            torch.distributed.all_gather_into_tensor(t, local_size)
-            if (t != local_size).any() and rank == 0:
-                warnings.warn(
-                    "Not all ranks received the same number of batches. "
-                    "This might cause your training loop to hang due to uneven inputs."
-                )
-
-            batch_id_start = t.cumsum(dim=0)[rank] - t[0]
-        else:
-            batch_id_start = 0
+        
+        local_num_batches = int(ceil(num_seeds / batch_size))
+        batch_id_start = self.get_batch_start_offset(local_num_batches, assume_equal_input_size=assume_equal_input_size)
 
         for i, current_seeds in enumerate(nodes_call_groups):
             current_batches = torch.arange(
@@ -300,32 +328,58 @@ def __init__(
         self.__compression = compression
         self.__with_replacement = with_replacement
 
-    def sample_batches(
-        self, seeds: TensorType, batch_ids: TensorType, random_state: int = 0
-    ):
-        # FIXME allow skipping of the synchronization logic with a boolean
-        # flag that assumes all ranks have the same number of batches.
-        if self.is_multi_gpu:
-            rank = torch.distributed.get_rank()
-            handle = pylibcugraph.ResourceHandle(
-                cugraph_comms_get_raft_handle().getHandle()
-            )
+    def get_label_list_and_output_rank(self, local_label_list: TensorType, assume_equal_input_size: bool=False):
+        """
+        Computes the label list and output rank mapping for the list of labels (batch ids).
 
-            local_label_list = torch.unique(batch_ids)
-            local_label_to_output_comm_rank = torch.full(
-                (len(local_label_list),), rank, dtype=torch.int32, device="cuda"
-            )
+        Parameters
+        ----------
+        local_label_list: TensorType
+            The list of unique labels on this rank.
+        assume_equal_input_size: bool
+            If True, assumes that all ranks have the same number of inputs (batches)
+            and skips some synchronization/gathering accordingly.
+        
+        Returns
+        -------
+        label_list: TensorType
+            The global label list containing all labels used across ranks.
+        label_to_output_comm_rank: TensorType
+            The global mapping of labels to ranks.
+        """
+        rank = torch.distributed.get_rank()
+        world_size = torch.distributed.get_world_size()
 
+        if assume_equal_input_size:
+            num_batches = len(local_label_list) * world_size
+        else:
             num_batches = torch.tensor(
                 [len(local_label_list)], device="cuda", dtype=torch.int64
             )
             torch.distributed.all_reduce(num_batches, op=torch.distributed.ReduceOp.SUM)
 
-            label_list = torch.empty((num_batches,), device="cuda", dtype=torch.int32)
-            w1 = torch.distributed.all_gather_into_tensor(
-                label_list, local_label_list, async_op=True
-            )
+        # Can't avoid the all gather here even with equal input size, since we don't know
+        # which labels the other ranks are using.
+        label_list = torch.empty((num_batches,), device="cuda", dtype=torch.int32)
+        w1 = torch.distributed.all_gather_into_tensor(
+            label_list, local_label_list, async_op=True
+        )
 
+        if assume_equal_input_size:
+            label_to_output_comm_rank = torch.concat([
+                torch.full(
+                    (len(local_label_list),),
+                    r,
+                    dtype=torch.int32,
+                    device="cuda"
+                )
+                for r in range(world_size)
+            ])
+            w2 = None
+        else:
+            local_label_to_output_comm_rank = torch.full(
+                (len(local_label_list),), rank, dtype=torch.int32, device="cuda"
+            )
             label_to_output_comm_rank = torch.empty(
                 (num_batches,), device="cuda", dtype=torch.int32
             )
@@ -335,9 +389,24 @@ def sample_batches(
                 async_op=True,
             )
 
-            w1.wait()
+        w1.wait()
+        if w2 is not None:
             w2.wait()
 
+        return label_list, label_to_output_comm_rank
+
+
+    def sample_batches(
+        self, seeds: TensorType, batch_ids: TensorType, random_state: int = 0, assume_equal_input_size: bool=False
+    ):
+        if self.is_multi_gpu:
+            handle = pylibcugraph.ResourceHandle(
+                cugraph_comms_get_raft_handle().getHandle()
+            )
+
+            local_label_list = torch.unique(batch_ids)
+            label_list, label_to_output_comm_rank = self.get_label_list_and_output_rank(local_label_list, assume_equal_input_size=assume_equal_input_size)
+
             sampling_results_dict = pylibcugraph.uniform_neighbor_sample(
                 handle,
                 self._graph,

From b9cd5296fe49afb32038f9308c41f76e97ac766d Mon Sep 17 00:00:00 2001
From: Alexandria Barghi <abarghi@nvidia.com>
Date: Wed, 3 Apr 2024 12:17:12 -0700
Subject: [PATCH 21/33] save resource handle

---
 .../cugraph/gnn/data_loading/dist_sampler.py  | 20 ++++++++++++++-----
 1 file changed, 15 insertions(+), 5 deletions(-)

diff --git a/python/cugraph/cugraph/gnn/data_loading/dist_sampler.py b/python/cugraph/cugraph/gnn/data_loading/dist_sampler.py
index 573258c4d6a..ecfcad65e6d 100644
--- a/python/cugraph/cugraph/gnn/data_loading/dist_sampler.py
+++ b/python/cugraph/cugraph/gnn/data_loading/dist_sampler.py
@@ -176,6 +176,7 @@ def __init__(
         self.__graph = graph
         self.__writer = writer
         self.__local_seeds_per_call = local_seeds_per_call
+        self.__handle = None
 
     def sample_batches(
         self, seeds: TensorType, batch_ids: TensorType, random_state: int = 0, assume_equal_input_size: bool=False
@@ -305,6 +306,17 @@ def _local_seeds_per_call(self):
     def _graph(self):
         return self.__graph
 
+    @property
+    def _resource_handle(self):
+        if self.__handle is None:
+            if self.is_multi_gpu:
+                self.__handle = pylibcugraph.ResourceHandle(
+                    cugraph_comms_get_raft_handle().getHandle()
+                )
+            else:
+                self.__handle = pylibcugraph.ResourceHandle()
+        return self.__handle
+
 
 class UniformNeighborSampler(DistSampler):
     def __init__(
@@ -400,15 +412,13 @@ def sample_batches(
         self, seeds: TensorType, batch_ids: TensorType, random_state: int = 0, assume_equal_input_size: bool=False
     ):
         if self.is_multi_gpu:
-            handle = pylibcugraph.ResourceHandle(
-                cugraph_comms_get_raft_handle().getHandle()
-            )
+            rank = torch.distributed.get_rank()
 
             local_label_list = torch.unique(batch_ids)
             label_list, label_to_output_comm_rank = self.get_label_list_and_output_rank(local_label_list, assume_equal_input_size=assume_equal_input_size)
 
             sampling_results_dict = pylibcugraph.uniform_neighbor_sample(
-                handle,
+                self._resource_handle,
                 self._graph,
                 start_list=cupy.asarray(seeds),
                 batch_id_list=cupy.asarray(batch_ids),
@@ -430,7 +440,7 @@ def sample_batches(
             sampling_results_dict["rank"] = rank
         else:
             sampling_results_dict = pylibcugraph.uniform_neighbor_sample(
-                pylibcugraph.ResourceHandle(),
+                self._resource_handle,
                 self._graph,
                 start_list=cupy.asarray(seeds),
                 batch_id_list=cupy.asarray(batch_ids),

From 30ab3247b5646069a133b6a6996c194929db3330 Mon Sep 17 00:00:00 2001
From: Alexandria Barghi <abarghi@nvidia.com>
Date: Fri, 5 Apr 2024 16:40:15 -0700
Subject: [PATCH 22/33] speed improvements, testing

---
 .../cugraph/gnn/data_loading/dist_sampler.py  |  35 ++---
 .../tests/sampling/test_dist_sampler.py       | 100 ++++++++++++
 .../tests/sampling/test_dist_sampler_mg.py    | 143 ++++++++++++++++++
 3 files changed, 261 insertions(+), 17 deletions(-)
 create mode 100644 python/cugraph/cugraph/tests/sampling/test_dist_sampler.py
 create mode 100644 python/cugraph/cugraph/tests/sampling/test_dist_sampler_mg.py

diff --git a/python/cugraph/cugraph/gnn/data_loading/dist_sampler.py b/python/cugraph/cugraph/gnn/data_loading/dist_sampler.py
index ecfcad65e6d..8119bf9cd7d 100644
--- a/python/cugraph/cugraph/gnn/data_loading/dist_sampler.py
+++ b/python/cugraph/cugraph/gnn/data_loading/dist_sampler.py
@@ -220,13 +220,13 @@ def get_start_batch_offset(self, local_num_batches:int, assume_equal_input_size:
         -------
         The starting batch offset (int).
 
-        """
-        rank = torch.distributed.get_rank()
-        world_size = torch.distributed.get_world_size()
-        
+        """   
         if self.is_multi_gpu:
+            rank = torch.distributed.get_rank()
+            world_size = torch.distributed.get_world_size()
+
             if assume_equal_input_size:
-                t = torch.full((world_size,), local_num_batches, dtype=torch.int64, device='cpu')
+                t = torch.full((world_size,), local_num_batches, dtype=torch.int64, device='cuda')
             else:
                 t = torch.empty((world_size,), dtype=torch.int64, device="cuda")
                 local_size = torch.tensor(
@@ -240,7 +240,7 @@ def get_start_batch_offset(self, local_num_batches:int, assume_equal_input_size:
                         "This might cause your training loop to hang due to uneven inputs."
                     )
 
-                return t.cumsum(dim=0)[rank] - t[0]
+            return t.cumsum(dim=0)[rank] - t[0]
         else:
             return 0
 
@@ -273,7 +273,7 @@ def sample_from_nodes(
         )
         
         local_num_batches = int(ceil(num_seeds / batch_size))
-        batch_id_start = self.get_batch_start_offset(local_num_batches, assume_equal_input_size=assume_equal_input_size)
+        batch_id_start = self.get_start_batch_offset(local_num_batches, assume_equal_input_size=assume_equal_input_size)
 
         for i, current_seeds in enumerate(nodes_call_groups):
             current_batches = torch.arange(
@@ -291,6 +291,7 @@ def sample_from_nodes(
                 seeds=current_seeds,
                 batch_ids=current_batches,
                 random_state=random_state,
+                assume_equal_input_size=assume_equal_input_size
             )
             self.__writer.write_minibatches(minibatch_dict)
 
@@ -364,18 +365,18 @@ def get_label_list_and_output_rank(self, local_label_list: TensorType, assume_eq
 
         if assume_equal_input_size:
             num_batches = len(local_label_list) * world_size
+            label_list = torch.arange(0, num_batches, device='cuda', dtype=torch.int32)
+            w1 = None
         else:
             num_batches = torch.tensor(
                 [len(local_label_list)], device="cuda", dtype=torch.int64
             )
             torch.distributed.all_reduce(num_batches, op=torch.distributed.ReduceOp.SUM)
-
-        # Can't avoid the all gather here even with equal input size, since we don't know
-        # which labels the other ranks are using.
-        label_list = torch.empty((num_batches,), device="cuda", dtype=torch.int32)
-        w1 = torch.distributed.all_gather_into_tensor(
-            label_list, local_label_list, async_op=True
-        )
+            
+            label_list = torch.empty((num_batches,), device="cuda", dtype=torch.int32)
+            w1 = torch.distributed.all_gather_into_tensor(
+                label_list, local_label_list, async_op=True
+            )
 
         if assume_equal_input_size:
             label_to_output_comm_rank = torch.concat([
@@ -401,16 +402,16 @@ def get_label_list_and_output_rank(self, local_label_list: TensorType, assume_eq
                 async_op=True,
             )
 
-        w1.wait()
+        if w1 is not None:
+            w1.wait()
         if w2 is not None:
             w2.wait()
 
         return label_list, label_to_output_comm_rank
 
-
     def sample_batches(
         self, seeds: TensorType, batch_ids: TensorType, random_state: int = 0, assume_equal_input_size: bool=False
-    ):
+    ) -> Dict[str, TensorType]:
         if self.is_multi_gpu:
             rank = torch.distributed.get_rank()
 
diff --git a/python/cugraph/cugraph/tests/sampling/test_dist_sampler.py b/python/cugraph/cugraph/tests/sampling/test_dist_sampler.py
new file mode 100644
index 00000000000..9f20769782e
--- /dev/null
+++ b/python/cugraph/cugraph/tests/sampling/test_dist_sampler.py
@@ -0,0 +1,100 @@
+# Copyright (c) 2024, NVIDIA CORPORATION.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import pytest
+import os
+import shutil
+
+import cupy
+import cudf
+
+from cugraph.datasets import karate
+from cugraph.gnn import (
+    UniformNeighborSampler,
+    DistSampleWriter
+)
+from pylibcugraph import (
+    SGGraph,
+    ResourceHandle,
+    GraphProperties
+)
+
+from cugraph.utilities.utils import create_directory_with_overwrite
+
+@pytest.fixture
+def karate_graph():
+    el = karate.get_edgelist().reset_index().rename(columns={"index": "eid"})
+    G = SGGraph(
+        ResourceHandle(),
+        GraphProperties(is_multigraph=True, is_symmetric=False),
+        el.src.astype('int64'),
+        el.dst.astype('int64'),
+        edge_id_array=el.eid,
+    )
+
+    return G
+
+@pytest.mark.sg
+@pytest.mark.parametrize("equal_input_size", [True, False])
+@pytest.mark.parametrize("fanout", [[2,2],[4,4],[4,2,1]])
+@pytest.mark.parametrize("batch_size", [1, 2, 4])
+def test_dist_sampler_simple(scratch_dir, karate_graph, batch_size, fanout, equal_input_size):
+    G = karate_graph
+
+    samples_path = os.path.join(scratch_dir, "test_bulk_sampler_simple")
+    create_directory_with_overwrite(samples_path)
+
+    writer = DistSampleWriter(
+        samples_path
+    )
+
+    sampler = UniformNeighborSampler(
+        G,
+        writer,
+        fanout = fanout
+    )
+
+    seeds = cupy.array([0, 5, 10, 15], dtype='int64')
+
+    sampler.sample_from_nodes(
+        seeds,
+        batch_size=batch_size,
+        assume_equal_input_size=equal_input_size
+    )
+
+    recovered_samples = cudf.read_parquet(samples_path)
+    original_el = karate.get_edgelist()
+
+    for b in range(len(seeds) // batch_size):
+        el_start = recovered_samples.label_hop_offsets.iloc[b * len(fanout)]
+        el_end = recovered_samples.label_hop_offsets.iloc[(b+1) * len(fanout)]
+        src = recovered_samples.majors.iloc[el_start:el_end]
+        dst = recovered_samples.minors.iloc[el_start:el_end]
+        edge_id = recovered_samples.edge_id.iloc[el_start:el_end]
+        
+        map_start = recovered_samples.renumber_map_offsets[b]
+        map_end = recovered_samples.renumber_map_offsets[b+1]
+        renumber_map = recovered_samples["map"].iloc[map_start:map_end]
+
+        src = renumber_map.iloc[src.values]
+        dst = renumber_map.iloc[dst.values]
+        
+        for i in range(len(edge_id)):
+            assert(
+                original_el.src.iloc[edge_id.iloc[i]] == src.iloc[i]
+            )
+            assert(
+                original_el.dst.iloc[edge_id.iloc[i]] == dst.iloc[i]
+            )
+
+    shutil.rmtree(samples_path)
\ No newline at end of file
diff --git a/python/cugraph/cugraph/tests/sampling/test_dist_sampler_mg.py b/python/cugraph/cugraph/tests/sampling/test_dist_sampler_mg.py
new file mode 100644
index 00000000000..bcfe74dfbc3
--- /dev/null
+++ b/python/cugraph/cugraph/tests/sampling/test_dist_sampler_mg.py
@@ -0,0 +1,143 @@
+# Copyright (c) 2024, NVIDIA CORPORATION.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import pytest
+import os
+import shutil
+
+import cupy
+import cudf
+
+from cugraph.datasets import karate
+from cugraph.gnn import (
+    UniformNeighborSampler,
+    DistSampleWriter,
+    cugraph_comms_create_unique_id,
+    cugraph_comms_get_raft_handle,
+    cugraph_comms_init,
+    cugraph_comms_shutdown,
+)
+from pylibcugraph import (
+    MGGraph,
+    ResourceHandle,
+    GraphProperties
+)
+
+from cugraph.utilities.utils import (
+    create_directory_with_overwrite,
+    import_optional,
+    MissingModule
+)
+
+torch = import_optional("torch")
+
+def karate_mg_graph(rank, world_size):
+    el = karate.get_edgelist().reset_index().rename(columns={"index": "eid"})
+    split = cupy.array_split(cupy.arange(len(el)), world_size)[rank]
+    el = el.iloc[split]
+
+    G = MGGraph(
+        ResourceHandle(cugraph_comms_get_raft_handle().getHandle()),
+        GraphProperties(is_multigraph=True, is_symmetric=False),
+        [el.src.astype('int64')],
+        [el.dst.astype('int64')],
+        edge_id_array=[el.eid],
+    )
+
+    return G
+
+def init_pytorch(rank, world_size):
+    os.environ["MASTER_ADDR"] = "localhost"
+    os.environ["MASTER_PORT"] = "12355"
+    torch.distributed.init_process_group("nccl", rank=rank, world_size=world_size)
+
+def run_test_dist_sampler_simple(rank, world_size, uid, samples_path, batch_size, seeds_per_rank, fanout, equal_input_size):
+    init_pytorch(rank, world_size)
+    cugraph_comms_init(rank, world_size, uid, device=rank)
+
+    G = karate_mg_graph(rank, world_size)
+
+    writer = DistSampleWriter(
+        samples_path
+    )
+
+    sampler = UniformNeighborSampler(
+        G,
+        writer,
+        fanout = fanout
+    )
+
+    seeds = cupy.random.randint(0, 34, seeds_per_rank, dtype='int64')
+
+    from time import perf_counter
+    start_time = perf_counter()
+    sampler.sample_from_nodes(
+        seeds,
+        batch_size=batch_size,
+        assume_equal_input_size=equal_input_size
+    )
+    end_time = perf_counter()
+
+    print('time:', end_time - start_time)
+    
+    cugraph_comms_shutdown()
+
+@pytest.mark.mg
+@pytest.mark.parametrize("equal_input_size", [True, False])
+@pytest.mark.parametrize("fanout", [[4,4],[4,2,1]])
+@pytest.mark.parametrize("batch_size", [1, 4])
+@pytest.mark.parametrize("seeds_per_rank", [1, 8])
+@pytest.mark.skipif(isinstance(torch, MissingModule), reason="torch not installed")
+def test_dist_sampler_simple(scratch_dir, batch_size, seeds_per_rank, fanout, equal_input_size):
+    uid = cugraph_comms_create_unique_id()
+
+    samples_path = os.path.join(scratch_dir, "test_bulk_sampler_mg_simple")
+    create_directory_with_overwrite(samples_path)
+
+    world_size = torch.cuda.device_count()
+    torch.multiprocessing.spawn(
+        run_test_dist_sampler_simple,
+        args=(world_size, uid, samples_path, batch_size, seeds_per_rank, fanout, equal_input_size),
+        nprocs=world_size
+    )
+
+
+    for file in os.listdir(samples_path):
+        recovered_samples = cudf.read_parquet(
+            os.path.join(samples_path, file)
+        )
+        original_el = karate.get_edgelist()
+
+        for b in range(len(recovered_samples.renumber_map_offsets.dropna()) - 1):
+            el_start = int(recovered_samples.label_hop_offsets.iloc[b * len(fanout)])
+            el_end = int(recovered_samples.label_hop_offsets.iloc[(b+1) * len(fanout)])
+            src = recovered_samples.majors.iloc[el_start:el_end]
+            dst = recovered_samples.minors.iloc[el_start:el_end]
+            edge_id = recovered_samples.edge_id.iloc[el_start:el_end]
+            
+            map_start = recovered_samples.renumber_map_offsets[b]
+            map_end = recovered_samples.renumber_map_offsets[b+1]
+            renumber_map = recovered_samples["map"].iloc[map_start:map_end]
+
+            src = renumber_map.iloc[src.values]
+            dst = renumber_map.iloc[dst.values]
+            
+            for i in range(len(edge_id)):
+                assert(
+                    original_el.src.iloc[edge_id.iloc[i]] == src.iloc[i]
+                )
+                assert(
+                    original_el.dst.iloc[edge_id.iloc[i]] == dst.iloc[i]
+                )
+
+    shutil.rmtree(samples_path)
\ No newline at end of file

From e1d0b10fe46ad76a8c2dace5b9970088b28ccb38 Mon Sep 17 00:00:00 2001
From: Alexandria Barghi <abarghi@nvidia.com>
Date: Tue, 9 Apr 2024 07:39:42 -0700
Subject: [PATCH 23/33] fix sizing

---
 .../cugraph/gnn/data_loading/dist_sampler.py  | 41 +++-------
 .../tests/sampling/test_dist_sampler_mg.py    | 81 +++++++++++++++++++
 2 files changed, 94 insertions(+), 28 deletions(-)

diff --git a/python/cugraph/cugraph/gnn/data_loading/dist_sampler.py b/python/cugraph/cugraph/gnn/data_loading/dist_sampler.py
index 8119bf9cd7d..9c76bdd4eb9 100644
--- a/python/cugraph/cugraph/gnn/data_loading/dist_sampler.py
+++ b/python/cugraph/cugraph/gnn/data_loading/dist_sampler.py
@@ -240,7 +240,7 @@ def get_start_batch_offset(self, local_num_batches:int, assume_equal_input_size:
                         "This might cause your training loop to hang due to uneven inputs."
                     )
 
-            return t.cumsum(dim=0)[rank] - t[0]
+            return 0 if rank == 0 else t.cumsum(dim=0)[rank - 1]
         else:
             return 0
 
@@ -366,19 +366,7 @@ def get_label_list_and_output_rank(self, local_label_list: TensorType, assume_eq
         if assume_equal_input_size:
             num_batches = len(local_label_list) * world_size
             label_list = torch.arange(0, num_batches, device='cuda', dtype=torch.int32)
-            w1 = None
-        else:
-            num_batches = torch.tensor(
-                [len(local_label_list)], device="cuda", dtype=torch.int64
-            )
-            torch.distributed.all_reduce(num_batches, op=torch.distributed.ReduceOp.SUM)
             
-            label_list = torch.empty((num_batches,), device="cuda", dtype=torch.int32)
-            w1 = torch.distributed.all_gather_into_tensor(
-                label_list, local_label_list, async_op=True
-            )
-
-        if assume_equal_input_size:
             label_to_output_comm_rank = torch.concat([
                 torch.full(
                     (len(local_label_list),),
@@ -388,24 +376,21 @@ def get_label_list_and_output_rank(self, local_label_list: TensorType, assume_eq
                 )
                 for r in range(world_size)
             ])
-            w2 = None
         else:
-            local_label_to_output_comm_rank = torch.full(
-                (len(local_label_list),), rank, dtype=torch.int32, device="cuda"
-            )
-            label_to_output_comm_rank = torch.empty(
-                (num_batches,), device="cuda", dtype=torch.int32
-            )
-            w2 = torch.distributed.all_gather_into_tensor(
-                label_to_output_comm_rank,
-                local_label_to_output_comm_rank,
-                async_op=True,
+            num_batches = torch.tensor(
+                [len(local_label_list)], device="cuda", dtype=torch.int64
             )
+            num_batches_all_ranks = torch.empty((world_size,), device='cuda', dtype=torch.int64)
+            torch.distributed.all_gather_into_tensor(num_batches_all_ranks, num_batches)
+            
+            label_list = torch.arange(0, num_batches_all_ranks.sum(), device='cuda', dtype=torch.int32)
 
-        if w1 is not None:
-            w1.wait()
-        if w2 is not None:
-            w2.wait()
+            label_to_output_comm_rank = torch.concat([
+                torch.full(
+                    (num_batches_r,), r, device="cuda", dtype=torch.int32
+                )
+                for r, num_batches_r in enumerate(num_batches_all_ranks)
+            ])
 
         return label_list, label_to_output_comm_rank
 
diff --git a/python/cugraph/cugraph/tests/sampling/test_dist_sampler_mg.py b/python/cugraph/cugraph/tests/sampling/test_dist_sampler_mg.py
index bcfe74dfbc3..3bfde0dfe6f 100644
--- a/python/cugraph/cugraph/tests/sampling/test_dist_sampler_mg.py
+++ b/python/cugraph/cugraph/tests/sampling/test_dist_sampler_mg.py
@@ -98,6 +98,7 @@ def run_test_dist_sampler_simple(rank, world_size, uid, samples_path, batch_size
 @pytest.mark.parametrize("batch_size", [1, 4])
 @pytest.mark.parametrize("seeds_per_rank", [1, 8])
 @pytest.mark.skipif(isinstance(torch, MissingModule), reason="torch not installed")
+@pytest.mark.skip(reason='asdf')
 def test_dist_sampler_simple(scratch_dir, batch_size, seeds_per_rank, fanout, equal_input_size):
     uid = cugraph_comms_create_unique_id()
 
@@ -112,6 +113,86 @@ def test_dist_sampler_simple(scratch_dir, batch_size, seeds_per_rank, fanout, eq
     )
 
 
+    for file in os.listdir(samples_path):
+        recovered_samples = cudf.read_parquet(
+            os.path.join(samples_path, file)
+        )
+        original_el = karate.get_edgelist()
+
+        for b in range(len(recovered_samples.renumber_map_offsets.dropna()) - 1):
+            el_start = int(recovered_samples.label_hop_offsets.iloc[b * len(fanout)])
+            el_end = int(recovered_samples.label_hop_offsets.iloc[(b+1) * len(fanout)])
+            src = recovered_samples.majors.iloc[el_start:el_end]
+            dst = recovered_samples.minors.iloc[el_start:el_end]
+            edge_id = recovered_samples.edge_id.iloc[el_start:el_end]
+            
+            map_start = recovered_samples.renumber_map_offsets[b]
+            map_end = recovered_samples.renumber_map_offsets[b+1]
+            renumber_map = recovered_samples["map"].iloc[map_start:map_end]
+
+            src = renumber_map.iloc[src.values]
+            dst = renumber_map.iloc[dst.values]
+            
+            for i in range(len(edge_id)):
+                assert(
+                    original_el.src.iloc[edge_id.iloc[i]] == src.iloc[i]
+                )
+                assert(
+                    original_el.dst.iloc[edge_id.iloc[i]] == dst.iloc[i]
+                )
+
+    shutil.rmtree(samples_path)
+
+def run_test_dist_sampler_uneven(rank, world_size, uid, samples_path, batch_size, fanout):
+    init_pytorch(rank, world_size)
+    cugraph_comms_init(rank, world_size, uid, device=rank)
+
+    G = karate_mg_graph(rank, world_size)
+
+    writer = DistSampleWriter(
+        samples_path
+    )
+
+    sampler = UniformNeighborSampler(
+        G,
+        writer,
+        fanout = fanout
+    )
+
+    num_seeds = 8 + rank
+    seeds = cupy.random.randint(0, 34, num_seeds, dtype='int64')
+
+    from time import perf_counter
+    start_time = perf_counter()
+    sampler.sample_from_nodes(
+        seeds,
+        batch_size=batch_size,
+        assume_equal_input_size=False
+    )
+    end_time = perf_counter()
+
+    print('time:', end_time - start_time)
+    
+    cugraph_comms_shutdown()
+
+@pytest.mark.mg
+@pytest.mark.parametrize("fanout", [[4,4],[4,2,1]])
+@pytest.mark.parametrize("batch_size", [1, 4])
+@pytest.mark.skipif(isinstance(torch, MissingModule), reason="torch not installed")
+def test_dist_sampler_uneven(scratch_dir, batch_size, fanout):
+    uid = cugraph_comms_create_unique_id()
+
+    samples_path = os.path.join(scratch_dir, "test_bulk_sampler_mg_uneven")
+    create_directory_with_overwrite(samples_path)
+
+    world_size = torch.cuda.device_count()
+    torch.multiprocessing.spawn(
+        run_test_dist_sampler_uneven,
+        args=(world_size, uid, samples_path, batch_size, fanout),
+        nprocs=world_size
+    )
+
+
     for file in os.listdir(samples_path):
         recovered_samples = cudf.read_parquet(
             os.path.join(samples_path, file)

From 6bf4f03eed80c81a44c4e0660cf8ff4ab041842f Mon Sep 17 00:00:00 2001
From: Alexandria Barghi <abarghi@nvidia.com>
Date: Fri, 12 Apr 2024 11:11:10 -0700
Subject: [PATCH 24/33] performance improvements, debug, cleanup

---
 .../cugraph/gnn/data_loading/dist_sampler.py  | 220 +++++++++++-------
 .../tests/sampling/test_dist_sampler_mg.py    | 148 ++++++------
 2 files changed, 210 insertions(+), 158 deletions(-)

diff --git a/python/cugraph/cugraph/gnn/data_loading/dist_sampler.py b/python/cugraph/cugraph/gnn/data_loading/dist_sampler.py
index 9c76bdd4eb9..1204ca04317 100644
--- a/python/cugraph/cugraph/gnn/data_loading/dist_sampler.py
+++ b/python/cugraph/cugraph/gnn/data_loading/dist_sampler.py
@@ -20,7 +20,7 @@
 import cupy
 import cudf
 
-from typing import Union, List, Dict
+from typing import Union, List, Dict, Tuple
 from cugraph.utilities import import_optional
 from cugraph.gnn.comms import cugraph_comms_get_raft_handle
 
@@ -172,14 +172,21 @@ def __init__(
         graph: Union[pylibcugraph.SGGraph, pylibcugraph.MGGraph],
         writer: DistSampleWriter,
         local_seeds_per_call: int = 32768,
+        retain_original_seeds: bool = False,  # TODO See #4329, needs C API
     ):
         self.__graph = graph
         self.__writer = writer
         self.__local_seeds_per_call = local_seeds_per_call
         self.__handle = None
+        self.__retain_original_seeds = retain_original_seeds
 
     def sample_batches(
-        self, seeds: TensorType, batch_ids: TensorType, random_state: int = 0, assume_equal_input_size: bool=False
+        self,
+        seeds: TensorType,
+        batch_ids: TensorType,
+        random_state: int = 0,
+        assume_equal_input_size: bool = False,
+        local_label_list: TensorType = None,
     ) -> Dict[str, TensorType]:
         """
         For a single call group of seeds and associated batch ids, performs
@@ -197,36 +204,106 @@ def sample_batches(
             If True, will assume all ranks have the same number of inputs,
             and will skip the synchronization/gather steps to check for
             and handle uneven inputs.
-        
+        local_label_list: TensorType
+            Optional. The list of batch ids (also called labels) on this rank.
+            If not provided, this will be calculated automatically.
+
         Returns
         -------
         A dictionary containing the sampling outputs (majors, minors, map, etc.)
         """
         raise NotImplementedError("Must be implemented by subclass")
 
-    def get_start_batch_offset(self, local_num_batches:int, assume_equal_input_size:bool=False) -> int:
+    def get_label_list_and_output_rank(
+        self, local_label_list: TensorType, assume_equal_input_size: bool = False
+    ):
+        """
+        Computes the label list and output rank mapping for
+        the list of labels (batch ids).
+        Subclasses may override this as needed depending on their
+        memory and compute constraints.
+
+        Parameters
+        ----------
+        local_label_list: TensorType
+            The list of unique labels on this rank.
+        assume_equal_input_size: bool
+            If True, assumes that all ranks have the same number of inputs (batches)
+            and skips some synchronization/gathering accordingly.
+
+        Returns
+        -------
+        label_list: TensorType
+            The global label list containing all labels used across ranks.
+        label_to_output_comm_rank: TensorType
+            The global mapping of labels to ranks.
+        """
+        world_size = torch.distributed.get_world_size()
+
+        if assume_equal_input_size:
+            num_batches = len(local_label_list) * world_size
+            label_list = torch.arange(0, num_batches, device="cuda", dtype=torch.int32)
+
+            label_to_output_comm_rank = torch.concat(
+                [
+                    torch.full(
+                        (len(local_label_list),), r, dtype=torch.int32, device="cuda"
+                    )
+                    for r in range(world_size)
+                ]
+            )
+        else:
+            num_batches = torch.tensor(
+                [len(local_label_list)], device="cuda", dtype=torch.int64
+            )
+            num_batches_all_ranks = torch.empty(
+                (world_size,), device="cuda", dtype=torch.int64
+            )
+            torch.distributed.all_gather_into_tensor(num_batches_all_ranks, num_batches)
+
+            label_list = torch.arange(
+                0, num_batches_all_ranks.sum(), device="cuda", dtype=torch.int32
+            )
+
+            label_to_output_comm_rank = torch.concat(
+                [
+                    torch.full((num_batches_r,), r, device="cuda", dtype=torch.int32)
+                    for r, num_batches_r in enumerate(num_batches_all_ranks)
+                ]
+            )
+
+        return label_list, label_to_output_comm_rank
+
+    def get_start_batch_offset(
+        self, local_num_batches: int, assume_equal_input_size: bool = False
+    ) -> Tuple[int, bool]:
         """
         Gets the starting batch offset to ensure each rank's set of batch ids is
         disjoint.
-        
+
         Parameters
         ----------
         local_num_batches: int
             The number of batches for this rank.
         assume_equal_input_size: bool
             Whether to assume all ranks have the same number of batches.
-        
+
         Returns
         -------
-        The starting batch offset (int).
+        Tuple[int, bool]
+            The starting batch offset (int)
+            and whether the input sizes on each rank are equal (bool).
 
-        """   
+        """
+        input_size_is_equal = True
         if self.is_multi_gpu:
             rank = torch.distributed.get_rank()
             world_size = torch.distributed.get_world_size()
 
             if assume_equal_input_size:
-                t = torch.full((world_size,), local_num_batches, dtype=torch.int64, device='cuda')
+                t = torch.full(
+                    (world_size,), local_num_batches, dtype=torch.int64, device="cuda"
+                )
             else:
                 t = torch.empty((world_size,), dtype=torch.int64, device="cuda")
                 local_size = torch.tensor(
@@ -234,26 +311,33 @@ def get_start_batch_offset(self, local_num_batches:int, assume_equal_input_size:
                 )
 
                 torch.distributed.all_gather_into_tensor(t, local_size)
-                if (t != local_size).any() and rank == 0:
-                    warnings.warn(
-                        "Not all ranks received the same number of batches. "
-                        "This might cause your training loop to hang due to uneven inputs."
-                    )
-
-            return 0 if rank == 0 else t.cumsum(dim=0)[rank - 1]
+                if (t != local_size).any():
+                    input_size_is_equal = False
+                    if rank == 0:
+                        warnings.warn(
+                            "Not all ranks received the same number of batches. "
+                            "This might cause your training loop to hang "
+                            "due to uneven inputs."
+                        )
+
+            return (0 if rank == 0 else t.cumsum(dim=0)[rank - 1], input_size_is_equal)
         else:
-            return 0
-
+            return 0, input_size_is_equal
 
     def sample_from_nodes(
-        self, nodes: TensorType, *, batch_size: int = 16, random_state: int = 62, assume_equal_input_size:bool=False
+        self,
+        nodes: TensorType,
+        *,
+        batch_size: int = 16,
+        random_state: int = 62,
+        assume_equal_input_size: bool = False,
     ):
         """
         Performs node-based sampling.  Accepts a list of seed nodes, and batch size.
         Splits the seed list into batches, then divides the batches into call groups
-        based on the number of seeds per call this sampler was set to use.  Then calls
-        sample_batches for each call group and writes the result using the writer
-        associated with this sampler.
+        based on the number of seeds per call this sampler was set to use.
+        Then calls sample_batches for each call group and writes the result using
+        the writer associated with this sampler.
 
         Parameters
         ----------
@@ -271,19 +355,21 @@ def sample_from_nodes(
         nodes_call_groups = torch.split(
             torch.as_tensor(nodes, device="cuda"), actual_seeds_per_call
         )
-        
+
         local_num_batches = int(ceil(num_seeds / batch_size))
-        batch_id_start = self.get_start_batch_offset(local_num_batches, assume_equal_input_size=assume_equal_input_size)
+        batch_id_start, input_size_is_equal = self.get_start_batch_offset(
+            local_num_batches, assume_equal_input_size=assume_equal_input_size
+        )
 
         for i, current_seeds in enumerate(nodes_call_groups):
-            current_batches = torch.arange(
+            batch_label_list = torch.arange(
                 batch_id_start + i * batches_per_call,
                 batch_id_start + (i + 1) * batches_per_call,
                 device="cuda",
                 dtype=torch.int32,
             )
 
-            current_batches = current_batches.repeat_interleave(batch_size)[
+            current_batches = batch_label_list.repeat_interleave(batch_size)[
                 : len(current_seeds)
             ]
 
@@ -291,7 +377,8 @@ def sample_from_nodes(
                 seeds=current_seeds,
                 batch_ids=current_batches,
                 random_state=random_state,
-                assume_equal_input_size=assume_equal_input_size
+                assume_equal_input_size=input_size_is_equal,
+                local_label_list=batch_label_list,
             )
             self.__writer.write_minibatches(minibatch_dict)
 
@@ -318,6 +405,10 @@ def _resource_handle(self):
                 self.__handle = pylibcugraph.ResourceHandle()
         return self.__handle
 
+    @property
+    def _retain_original_seeds(self):
+        return self.__retain_original_seeds
+
 
 class UniformNeighborSampler(DistSampler):
     def __init__(
@@ -341,67 +432,30 @@ def __init__(
         self.__compression = compression
         self.__with_replacement = with_replacement
 
-    def get_label_list_and_output_rank(self, local_label_list: TensorType, assume_equal_input_size: bool=False):
-        """
-        Computes the label list and output rank mapping for the list of labels (batch ids).
-
-        Parameters
-        ----------
-        local_label_list: TensorType
-            The list of unique labels on this rank.
-        assume_equal_input_size: bool
-            If True, assumes that all ranks have the same number of inputs (batches)
-            and skips some synchronization/gathering accordingly.
-        
-        Returns
-        -------
-        label_list: TensorType
-            The global label list containing all labels used across ranks.
-        label_to_output_comm_rank: TensorType
-            The global mapping of labels to ranks.
-        """
-        rank = torch.distributed.get_rank()
-        world_size = torch.distributed.get_world_size()
-
-        if assume_equal_input_size:
-            num_batches = len(local_label_list) * world_size
-            label_list = torch.arange(0, num_batches, device='cuda', dtype=torch.int32)
-            
-            label_to_output_comm_rank = torch.concat([
-                torch.full(
-                    (len(local_label_list),),
-                    r,
-                    dtype=torch.int32,
-                    device="cuda"
-                )
-                for r in range(world_size)
-            ])
-        else:
-            num_batches = torch.tensor(
-                [len(local_label_list)], device="cuda", dtype=torch.int64
-            )
-            num_batches_all_ranks = torch.empty((world_size,), device='cuda', dtype=torch.int64)
-            torch.distributed.all_gather_into_tensor(num_batches_all_ranks, num_batches)
-            
-            label_list = torch.arange(0, num_batches_all_ranks.sum(), device='cuda', dtype=torch.int32)
-
-            label_to_output_comm_rank = torch.concat([
-                torch.full(
-                    (num_batches_r,), r, device="cuda", dtype=torch.int32
-                )
-                for r, num_batches_r in enumerate(num_batches_all_ranks)
-            ])
-
-        return label_list, label_to_output_comm_rank
-
     def sample_batches(
-        self, seeds: TensorType, batch_ids: TensorType, random_state: int = 0, assume_equal_input_size: bool=False
+        self,
+        seeds: TensorType,
+        batch_ids: TensorType,
+        random_state: int = 0,
+        assume_equal_input_size: bool = False,
+        local_label_list: TensorType = None,
     ) -> Dict[str, TensorType]:
         if self.is_multi_gpu:
             rank = torch.distributed.get_rank()
 
-            local_label_list = torch.unique(batch_ids)
-            label_list, label_to_output_comm_rank = self.get_label_list_and_output_rank(local_label_list, assume_equal_input_size=assume_equal_input_size)
+            if local_label_list is None:
+                local_label_list = torch.unique(batch_ids)
+            label_list, label_to_output_comm_rank = self.get_label_list_and_output_rank(
+                local_label_list, assume_equal_input_size=assume_equal_input_size
+            )
+
+            # TODO add calculation of seed vertex label offsets
+            if self._retain_original_seeds:
+                warnings.warn(
+                    "The 'retain_original_seeds` parameter is currently ignored "
+                    "since seed retention is not implemented yet."
+                )
+                pass
 
             sampling_results_dict = pylibcugraph.uniform_neighbor_sample(
                 self._resource_handle,
diff --git a/python/cugraph/cugraph/tests/sampling/test_dist_sampler_mg.py b/python/cugraph/cugraph/tests/sampling/test_dist_sampler_mg.py
index 3bfde0dfe6f..3d35b9c71a6 100644
--- a/python/cugraph/cugraph/tests/sampling/test_dist_sampler_mg.py
+++ b/python/cugraph/cugraph/tests/sampling/test_dist_sampler_mg.py
@@ -27,20 +27,17 @@
     cugraph_comms_init,
     cugraph_comms_shutdown,
 )
-from pylibcugraph import (
-    MGGraph,
-    ResourceHandle,
-    GraphProperties
-)
+from pylibcugraph import MGGraph, ResourceHandle, GraphProperties
 
 from cugraph.utilities.utils import (
     create_directory_with_overwrite,
     import_optional,
-    MissingModule
+    MissingModule,
 )
 
 torch = import_optional("torch")
 
+
 def karate_mg_graph(rank, world_size):
     el = karate.get_edgelist().reset_index().rename(columns={"index": "eid"})
     split = cupy.array_split(cupy.arange(len(el)), world_size)[rank]
@@ -49,57 +46,63 @@ def karate_mg_graph(rank, world_size):
     G = MGGraph(
         ResourceHandle(cugraph_comms_get_raft_handle().getHandle()),
         GraphProperties(is_multigraph=True, is_symmetric=False),
-        [el.src.astype('int64')],
-        [el.dst.astype('int64')],
+        [el.src.astype("int64")],
+        [el.dst.astype("int64")],
         edge_id_array=[el.eid],
     )
 
     return G
 
+
 def init_pytorch(rank, world_size):
     os.environ["MASTER_ADDR"] = "localhost"
     os.environ["MASTER_PORT"] = "12355"
     torch.distributed.init_process_group("nccl", rank=rank, world_size=world_size)
 
-def run_test_dist_sampler_simple(rank, world_size, uid, samples_path, batch_size, seeds_per_rank, fanout, equal_input_size):
+
+def run_test_dist_sampler_simple(
+    rank,
+    world_size,
+    uid,
+    samples_path,
+    batch_size,
+    seeds_per_rank,
+    fanout,
+    equal_input_size,
+):
     init_pytorch(rank, world_size)
     cugraph_comms_init(rank, world_size, uid, device=rank)
 
     G = karate_mg_graph(rank, world_size)
 
-    writer = DistSampleWriter(
-        samples_path
-    )
+    writer = DistSampleWriter(samples_path)
 
-    sampler = UniformNeighborSampler(
-        G,
-        writer,
-        fanout = fanout
-    )
+    sampler = UniformNeighborSampler(G, writer, fanout=fanout)
 
-    seeds = cupy.random.randint(0, 34, seeds_per_rank, dtype='int64')
+    seeds = cupy.random.randint(0, 34, seeds_per_rank, dtype="int64")
 
     from time import perf_counter
+
     start_time = perf_counter()
     sampler.sample_from_nodes(
-        seeds,
-        batch_size=batch_size,
-        assume_equal_input_size=equal_input_size
+        seeds, batch_size=batch_size, assume_equal_input_size=equal_input_size
     )
     end_time = perf_counter()
 
-    print('time:', end_time - start_time)
-    
+    print("time:", end_time - start_time)
+
     cugraph_comms_shutdown()
 
+
 @pytest.mark.mg
 @pytest.mark.parametrize("equal_input_size", [True, False])
-@pytest.mark.parametrize("fanout", [[4,4],[4,2,1]])
+@pytest.mark.parametrize("fanout", [[4, 4], [4, 2, 1]])
 @pytest.mark.parametrize("batch_size", [1, 4])
 @pytest.mark.parametrize("seeds_per_rank", [1, 8])
 @pytest.mark.skipif(isinstance(torch, MissingModule), reason="torch not installed")
-@pytest.mark.skip(reason='asdf')
-def test_dist_sampler_simple(scratch_dir, batch_size, seeds_per_rank, fanout, equal_input_size):
+def test_dist_sampler_simple(
+    scratch_dir, batch_size, seeds_per_rank, fanout, equal_input_size
+):
     uid = cugraph_comms_create_unique_id()
 
     samples_path = os.path.join(scratch_dir, "test_bulk_sampler_mg_simple")
@@ -108,75 +111,75 @@ def test_dist_sampler_simple(scratch_dir, batch_size, seeds_per_rank, fanout, eq
     world_size = torch.cuda.device_count()
     torch.multiprocessing.spawn(
         run_test_dist_sampler_simple,
-        args=(world_size, uid, samples_path, batch_size, seeds_per_rank, fanout, equal_input_size),
-        nprocs=world_size
+        args=(
+            world_size,
+            uid,
+            samples_path,
+            batch_size,
+            seeds_per_rank,
+            fanout,
+            equal_input_size,
+        ),
+        nprocs=world_size,
     )
 
-
     for file in os.listdir(samples_path):
-        recovered_samples = cudf.read_parquet(
-            os.path.join(samples_path, file)
-        )
+        recovered_samples = cudf.read_parquet(os.path.join(samples_path, file))
         original_el = karate.get_edgelist()
 
         for b in range(len(recovered_samples.renumber_map_offsets.dropna()) - 1):
             el_start = int(recovered_samples.label_hop_offsets.iloc[b * len(fanout)])
-            el_end = int(recovered_samples.label_hop_offsets.iloc[(b+1) * len(fanout)])
+            el_end = int(
+                recovered_samples.label_hop_offsets.iloc[(b + 1) * len(fanout)]
+            )
             src = recovered_samples.majors.iloc[el_start:el_end]
             dst = recovered_samples.minors.iloc[el_start:el_end]
             edge_id = recovered_samples.edge_id.iloc[el_start:el_end]
-            
+
             map_start = recovered_samples.renumber_map_offsets[b]
-            map_end = recovered_samples.renumber_map_offsets[b+1]
+            map_end = recovered_samples.renumber_map_offsets[b + 1]
             renumber_map = recovered_samples["map"].iloc[map_start:map_end]
 
             src = renumber_map.iloc[src.values]
             dst = renumber_map.iloc[dst.values]
-            
+
             for i in range(len(edge_id)):
-                assert(
-                    original_el.src.iloc[edge_id.iloc[i]] == src.iloc[i]
-                )
-                assert(
-                    original_el.dst.iloc[edge_id.iloc[i]] == dst.iloc[i]
-                )
+                assert original_el.src.iloc[edge_id.iloc[i]] == src.iloc[i]
+                assert original_el.dst.iloc[edge_id.iloc[i]] == dst.iloc[i]
 
     shutil.rmtree(samples_path)
 
-def run_test_dist_sampler_uneven(rank, world_size, uid, samples_path, batch_size, fanout):
+
+def run_test_dist_sampler_uneven(
+    rank, world_size, uid, samples_path, batch_size, fanout
+):
     init_pytorch(rank, world_size)
     cugraph_comms_init(rank, world_size, uid, device=rank)
 
     G = karate_mg_graph(rank, world_size)
 
-    writer = DistSampleWriter(
-        samples_path
-    )
+    writer = DistSampleWriter(samples_path)
 
-    sampler = UniformNeighborSampler(
-        G,
-        writer,
-        fanout = fanout
-    )
+    sampler = UniformNeighborSampler(G, writer, fanout=fanout)
 
     num_seeds = 8 + rank
-    seeds = cupy.random.randint(0, 34, num_seeds, dtype='int64')
+    seeds = cupy.random.randint(0, 34, num_seeds, dtype="int64")
 
     from time import perf_counter
+
     start_time = perf_counter()
     sampler.sample_from_nodes(
-        seeds,
-        batch_size=batch_size,
-        assume_equal_input_size=False
+        seeds, batch_size=batch_size, assume_equal_input_size=False
     )
     end_time = perf_counter()
 
-    print('time:', end_time - start_time)
-    
+    print("time:", end_time - start_time)
+
     cugraph_comms_shutdown()
 
+
 @pytest.mark.mg
-@pytest.mark.parametrize("fanout", [[4,4],[4,2,1]])
+@pytest.mark.parametrize("fanout", [[4, 4], [4, 2, 1]])
 @pytest.mark.parametrize("batch_size", [1, 4])
 @pytest.mark.skipif(isinstance(torch, MissingModule), reason="torch not installed")
 def test_dist_sampler_uneven(scratch_dir, batch_size, fanout):
@@ -189,36 +192,31 @@ def test_dist_sampler_uneven(scratch_dir, batch_size, fanout):
     torch.multiprocessing.spawn(
         run_test_dist_sampler_uneven,
         args=(world_size, uid, samples_path, batch_size, fanout),
-        nprocs=world_size
+        nprocs=world_size,
     )
 
-
     for file in os.listdir(samples_path):
-        recovered_samples = cudf.read_parquet(
-            os.path.join(samples_path, file)
-        )
+        recovered_samples = cudf.read_parquet(os.path.join(samples_path, file))
         original_el = karate.get_edgelist()
 
         for b in range(len(recovered_samples.renumber_map_offsets.dropna()) - 1):
             el_start = int(recovered_samples.label_hop_offsets.iloc[b * len(fanout)])
-            el_end = int(recovered_samples.label_hop_offsets.iloc[(b+1) * len(fanout)])
+            el_end = int(
+                recovered_samples.label_hop_offsets.iloc[(b + 1) * len(fanout)]
+            )
             src = recovered_samples.majors.iloc[el_start:el_end]
             dst = recovered_samples.minors.iloc[el_start:el_end]
             edge_id = recovered_samples.edge_id.iloc[el_start:el_end]
-            
+
             map_start = recovered_samples.renumber_map_offsets[b]
-            map_end = recovered_samples.renumber_map_offsets[b+1]
+            map_end = recovered_samples.renumber_map_offsets[b + 1]
             renumber_map = recovered_samples["map"].iloc[map_start:map_end]
 
             src = renumber_map.iloc[src.values]
             dst = renumber_map.iloc[dst.values]
-            
+
             for i in range(len(edge_id)):
-                assert(
-                    original_el.src.iloc[edge_id.iloc[i]] == src.iloc[i]
-                )
-                assert(
-                    original_el.dst.iloc[edge_id.iloc[i]] == dst.iloc[i]
-                )
-
-    shutil.rmtree(samples_path)
\ No newline at end of file
+                assert original_el.src.iloc[edge_id.iloc[i]] == src.iloc[i]
+                assert original_el.dst.iloc[edge_id.iloc[i]] == dst.iloc[i]
+
+    shutil.rmtree(samples_path)

From eb94b72f0f9ff03fc4c86d411fa959f158118a91 Mon Sep 17 00:00:00 2001
From: Alexandria Barghi <abarghi@nvidia.com>
Date: Fri, 12 Apr 2024 14:05:12 -0700
Subject: [PATCH 25/33] fix bugs, cleanup

---
 .../cugraph/gnn/data_loading/dist_sampler.py  | 112 +++++++++++++++---
 .../tests/sampling/test_dist_sampler_mg.py    |  22 ++--
 2 files changed, 109 insertions(+), 25 deletions(-)

diff --git a/python/cugraph/cugraph/gnn/data_loading/dist_sampler.py b/python/cugraph/cugraph/gnn/data_loading/dist_sampler.py
index 1204ca04317..34e6df3411d 100644
--- a/python/cugraph/cugraph/gnn/data_loading/dist_sampler.py
+++ b/python/cugraph/cugraph/gnn/data_loading/dist_sampler.py
@@ -40,6 +40,19 @@ def __init__(
         batches_per_partition: int = 256,
         format: str = "parquet",
     ):
+        """
+        Parameters
+        ----------
+        directory: str (required)
+            The directory where samples will be written.  This
+            writer can only write to disk.
+        batches_per_partition: int (optional, default=256)
+            The number of batches to write in a single file.
+        format: str (optional, default='parquet')
+            The file format of the output files containing the
+            sampled minibatches.  Currently, only parquet format
+            is supported.
+        """
         if format != "parquet":
             raise ValueError("Invalid format (currently supported: 'parquet')")
 
@@ -69,6 +82,10 @@ def __write_minibatches_coo(self, minibatch_dict):
                 "Distributed sampling without renumbering is not supported"
             )
 
+        # Quit if there are no batches to write.
+        if len(minibatch_dict["batch_id"]) == 0:
+            return
+
         fanout_length = (len(minibatch_dict["label_hop_offsets"]) - 1) // len(
             minibatch_dict["batch_id"]
         )
@@ -174,6 +191,28 @@ def __init__(
         local_seeds_per_call: int = 32768,
         retain_original_seeds: bool = False,  # TODO See #4329, needs C API
     ):
+        """
+        Parameters
+        ----------
+        graph: SGGraph or MGGraph (required)
+            The pylibcugraph graph object that will be sampled.
+        writer: DistSampleWriter (required)
+            The writer responsible for writing samples to disk
+            or, in the future, device or host memory.
+        local_seeds_per_call: int (optional, default=32768)
+            The number of seeds on this rank this sampler will
+            process in a single sampling call.  Batches will
+            get split into multiple sampling calls based on
+            this parameter.  This parameter must
+            be the same across all ranks.  The total number
+            of seeds processed per sampling call is this
+            parameter times the world size.
+        retain_original_seeds: bool (optional, default=False)
+            Whether to retain the original seeds even if they
+            do not appear in the output minibatch.  This will
+            affect the output renumber map and CSR/CSC graph
+            if applicable.
+        """
         self.__graph = graph
         self.__writer = writer
         self.__local_seeds_per_call = local_seeds_per_call
@@ -186,7 +225,6 @@ def sample_batches(
         batch_ids: TensorType,
         random_state: int = 0,
         assume_equal_input_size: bool = False,
-        local_label_list: TensorType = None,
     ) -> Dict[str, TensorType]:
         """
         For a single call group of seeds and associated batch ids, performs
@@ -204,9 +242,6 @@ def sample_batches(
             If True, will assume all ranks have the same number of inputs,
             and will skip the synchronization/gather steps to check for
             and handle uneven inputs.
-        local_label_list: TensorType
-            Optional. The list of batch ids (also called labels) on this rank.
-            If not provided, this will be calculated automatically.
 
         Returns
         -------
@@ -242,7 +277,10 @@ def get_label_list_and_output_rank(
 
         if assume_equal_input_size:
             num_batches = len(local_label_list) * world_size
-            label_list = torch.arange(0, num_batches, device="cuda", dtype=torch.int32)
+            label_list = torch.empty((num_batches,), dtype=torch.int32, device="cuda")
+            w = torch.distributed.all_gather_into_tensor(
+                label_list, local_label_list, async_op=True
+            )
 
             label_to_output_comm_rank = torch.concat(
                 [
@@ -261,8 +299,12 @@ def get_label_list_and_output_rank(
             )
             torch.distributed.all_gather_into_tensor(num_batches_all_ranks, num_batches)
 
-            label_list = torch.arange(
-                0, num_batches_all_ranks.sum(), device="cuda", dtype=torch.int32
+            label_list = [
+                torch.empty((n,), dtype=torch.int32, device="cuda")
+                for n in num_batches_all_ranks
+            ]
+            w = torch.distributed.all_gather(
+                label_list, local_label_list, async_op=True
             )
 
             label_to_output_comm_rank = torch.concat(
@@ -272,6 +314,9 @@ def get_label_list_and_output_rank(
                 ]
             )
 
+        w.wait()
+        if isinstance(label_list, list):
+            label_list = torch.concat(label_list)
         return label_list, label_to_output_comm_rank
 
     def get_start_batch_offset(
@@ -348,37 +393,63 @@ def sample_from_nodes(
         random_state: int
             The random seed to use for sampling.
         """
+        nodes = torch.as_tensor(nodes, device="cuda")
+
         batches_per_call = self._local_seeds_per_call // batch_size
         actual_seeds_per_call = batches_per_call * batch_size
 
+        # Split the input seeds into call groups.  Each call group
+        # corresponds to one sampling call.  A call group contains
+        # many batches.
         num_seeds = len(nodes)
-        nodes_call_groups = torch.split(
-            torch.as_tensor(nodes, device="cuda"), actual_seeds_per_call
-        )
+        nodes_call_groups = torch.split(nodes, actual_seeds_per_call)
 
         local_num_batches = int(ceil(num_seeds / batch_size))
         batch_id_start, input_size_is_equal = self.get_start_batch_offset(
             local_num_batches, assume_equal_input_size=assume_equal_input_size
         )
 
+        # Need to add empties to the list of call groups to handle the case
+        # where not all nodes have the same number of call groups.  This
+        # prevents a hang since we need all ranks to make the same number
+        # of calls.
+        if not input_size_is_equal:
+            num_call_groups = torch.tensor(
+                [len(nodes_call_groups)], device="cuda", dtype=torch.int32
+            )
+            torch.distributed.all_reduce(
+                num_call_groups, op=torch.distributed.ReduceOp.MAX
+            )
+            nodes_call_groups = list(nodes_call_groups) + (
+                [torch.tensor([], dtype=nodes.dtype, device="cuda")]
+                * (int(num_call_groups) - len(nodes_call_groups))
+            )
+
+        # Make a call to sample_batches for each call group
         for i, current_seeds in enumerate(nodes_call_groups):
-            batch_label_list = torch.arange(
+            current_batches = torch.arange(
                 batch_id_start + i * batches_per_call,
                 batch_id_start + (i + 1) * batches_per_call,
                 device="cuda",
                 dtype=torch.int32,
             )
 
-            current_batches = batch_label_list.repeat_interleave(batch_size)[
+            current_batches = current_batches.repeat_interleave(batch_size)[
                 : len(current_seeds)
             ]
 
+            # Handle the case where not all ranks have the same number of call groups,
+            # in which case there will be some empty groups that get submitted on the
+            # ranks with fewer call groups.
+            label_start, label_end = (
+                current_batches[[0, -1]] if len(current_batches) > 0 else (0, -1)
+            )
+
             minibatch_dict = self.sample_batches(
                 seeds=current_seeds,
                 batch_ids=current_batches,
                 random_state=random_state,
                 assume_equal_input_size=input_size_is_equal,
-                local_label_list=batch_label_list,
             )
             self.__writer.write_minibatches(minibatch_dict)
 
@@ -417,6 +488,7 @@ def __init__(
         writer: DistSampleWriter,
         *,
         local_seeds_per_call: int = 32768,
+        retain_original_seeds: bool = False,
         fanout: List[int] = [-1],
         prior_sources_behavior: str = "exclude",
         deduplicate_sources: bool = True,
@@ -424,7 +496,12 @@ def __init__(
         compress_per_hop: bool = False,
         with_replacement: bool = False,
     ):
-        super().__init__(graph, writer, local_seeds_per_call=local_seeds_per_call)
+        super().__init__(
+            graph,
+            writer,
+            local_seeds_per_call=local_seeds_per_call,
+            retain_original_seeds=retain_original_seeds,
+        )
         self.__fanout = fanout
         self.__prior_sources_behavior = prior_sources_behavior
         self.__deduplicate_sources = deduplicate_sources
@@ -438,13 +515,13 @@ def sample_batches(
         batch_ids: TensorType,
         random_state: int = 0,
         assume_equal_input_size: bool = False,
-        local_label_list: TensorType = None,
     ) -> Dict[str, TensorType]:
         if self.is_multi_gpu:
             rank = torch.distributed.get_rank()
 
-            if local_label_list is None:
-                local_label_list = torch.unique(batch_ids)
+            batch_ids = batch_ids.to(device="cuda", dtype=torch.int32)
+            local_label_list = torch.unique(batch_ids)
+
             label_list, label_to_output_comm_rank = self.get_label_list_and_output_rank(
                 local_label_list, assume_equal_input_size=assume_equal_input_size
             )
@@ -455,7 +532,6 @@ def sample_batches(
                     "The 'retain_original_seeds` parameter is currently ignored "
                     "since seed retention is not implemented yet."
                 )
-                pass
 
             sampling_results_dict = pylibcugraph.uniform_neighbor_sample(
                 self._resource_handle,
diff --git a/python/cugraph/cugraph/tests/sampling/test_dist_sampler_mg.py b/python/cugraph/cugraph/tests/sampling/test_dist_sampler_mg.py
index 3d35b9c71a6..bf65e46c516 100644
--- a/python/cugraph/cugraph/tests/sampling/test_dist_sampler_mg.py
+++ b/python/cugraph/cugraph/tests/sampling/test_dist_sampler_mg.py
@@ -69,6 +69,7 @@ def run_test_dist_sampler_simple(
     seeds_per_rank,
     fanout,
     equal_input_size,
+    seeds_per_call,
 ):
     init_pytorch(rank, world_size)
     cugraph_comms_init(rank, world_size, uid, device=rank)
@@ -77,7 +78,9 @@ def run_test_dist_sampler_simple(
 
     writer = DistSampleWriter(samples_path)
 
-    sampler = UniformNeighborSampler(G, writer, fanout=fanout)
+    sampler = UniformNeighborSampler(
+        G, writer, fanout=fanout, local_seeds_per_call=seeds_per_call
+    )
 
     seeds = cupy.random.randint(0, 34, seeds_per_rank, dtype="int64")
 
@@ -98,10 +101,11 @@ def run_test_dist_sampler_simple(
 @pytest.mark.parametrize("equal_input_size", [True, False])
 @pytest.mark.parametrize("fanout", [[4, 4], [4, 2, 1]])
 @pytest.mark.parametrize("batch_size", [1, 4])
-@pytest.mark.parametrize("seeds_per_rank", [1, 8])
+@pytest.mark.parametrize("seeds_per_rank", [8, 1])
+@pytest.mark.parametrize("seeds_per_call", [4, 8])
 @pytest.mark.skipif(isinstance(torch, MissingModule), reason="torch not installed")
 def test_dist_sampler_simple(
-    scratch_dir, batch_size, seeds_per_rank, fanout, equal_input_size
+    scratch_dir, batch_size, seeds_per_rank, fanout, equal_input_size, seeds_per_call
 ):
     uid = cugraph_comms_create_unique_id()
 
@@ -119,6 +123,7 @@ def test_dist_sampler_simple(
             seeds_per_rank,
             fanout,
             equal_input_size,
+            seeds_per_call,
         ),
         nprocs=world_size,
     )
@@ -151,7 +156,7 @@ def test_dist_sampler_simple(
 
 
 def run_test_dist_sampler_uneven(
-    rank, world_size, uid, samples_path, batch_size, fanout
+    rank, world_size, uid, samples_path, batch_size, fanout, seeds_per_call
 ):
     init_pytorch(rank, world_size)
     cugraph_comms_init(rank, world_size, uid, device=rank)
@@ -160,7 +165,9 @@ def run_test_dist_sampler_uneven(
 
     writer = DistSampleWriter(samples_path)
 
-    sampler = UniformNeighborSampler(G, writer, fanout=fanout)
+    sampler = UniformNeighborSampler(
+        G, writer, fanout=fanout, local_seeds_per_call=seeds_per_call
+    )
 
     num_seeds = 8 + rank
     seeds = cupy.random.randint(0, 34, num_seeds, dtype="int64")
@@ -181,8 +188,9 @@ def run_test_dist_sampler_uneven(
 @pytest.mark.mg
 @pytest.mark.parametrize("fanout", [[4, 4], [4, 2, 1]])
 @pytest.mark.parametrize("batch_size", [1, 4])
+@pytest.mark.parametrize("seeds_per_call", [4, 8, 16])
 @pytest.mark.skipif(isinstance(torch, MissingModule), reason="torch not installed")
-def test_dist_sampler_uneven(scratch_dir, batch_size, fanout):
+def test_dist_sampler_uneven(scratch_dir, batch_size, fanout, seeds_per_call):
     uid = cugraph_comms_create_unique_id()
 
     samples_path = os.path.join(scratch_dir, "test_bulk_sampler_mg_uneven")
@@ -191,7 +199,7 @@ def test_dist_sampler_uneven(scratch_dir, batch_size, fanout):
     world_size = torch.cuda.device_count()
     torch.multiprocessing.spawn(
         run_test_dist_sampler_uneven,
-        args=(world_size, uid, samples_path, batch_size, fanout),
+        args=(world_size, uid, samples_path, batch_size, fanout, seeds_per_call),
         nprocs=world_size,
     )
 

From 6814a6546fcd5c37200c658f71c045252542ca4f Mon Sep 17 00:00:00 2001
From: Alexandria Barghi <abarghi@nvidia.com>
Date: Fri, 12 Apr 2024 14:22:32 -0700
Subject: [PATCH 26/33] add yes prompt

---
 ci/run_cugraph_pyg_pytests.sh | 2 +-
 ci/test_wheel_cugraph-pyg.sh  | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/ci/run_cugraph_pyg_pytests.sh b/ci/run_cugraph_pyg_pytests.sh
index 0acc8aa462a..3a3e5d10908 100755
--- a/ci/run_cugraph_pyg_pytests.sh
+++ b/ci/run_cugraph_pyg_pytests.sh
@@ -11,5 +11,5 @@ pytest --cache-clear --ignore=tests/mg "$@" .
 # Test examples
 for e in "$(pwd)"/examples/*.py; do
   rapids-logger "running example $e"
-  python $e
+  yes | python $e
 done
diff --git a/ci/test_wheel_cugraph-pyg.sh b/ci/test_wheel_cugraph-pyg.sh
index ad615f0b3ff..29f5c466837 100755
--- a/ci/test_wheel_cugraph-pyg.sh
+++ b/ci/test_wheel_cugraph-pyg.sh
@@ -52,6 +52,6 @@ python -m pytest \
 # Test examples
 for e in "$(pwd)"/examples/*.py; do
   rapids-logger "running example $e"
-  python $e
+  yes | python $e
 done
 popd

From f255b617d2246b8cc315a83c75b9e07e74c0a8d0 Mon Sep 17 00:00:00 2001
From: Alexandria Barghi <abarghi@nvidia.com>
Date: Fri, 12 Apr 2024 14:27:18 -0700
Subject: [PATCH 27/33] style

---
 .../tests/sampling/test_dist_sampler.py       | 60 +++++++------------
 1 file changed, 23 insertions(+), 37 deletions(-)

diff --git a/python/cugraph/cugraph/tests/sampling/test_dist_sampler.py b/python/cugraph/cugraph/tests/sampling/test_dist_sampler.py
index 9f20769782e..4c10fbbc3e6 100644
--- a/python/cugraph/cugraph/tests/sampling/test_dist_sampler.py
+++ b/python/cugraph/cugraph/tests/sampling/test_dist_sampler.py
@@ -19,57 +19,47 @@
 import cudf
 
 from cugraph.datasets import karate
-from cugraph.gnn import (
-    UniformNeighborSampler,
-    DistSampleWriter
-)
-from pylibcugraph import (
-    SGGraph,
-    ResourceHandle,
-    GraphProperties
-)
+from cugraph.gnn import UniformNeighborSampler, DistSampleWriter
+
+from pylibcugraph import SGGraph, ResourceHandle, GraphProperties
 
 from cugraph.utilities.utils import create_directory_with_overwrite
 
+
 @pytest.fixture
 def karate_graph():
     el = karate.get_edgelist().reset_index().rename(columns={"index": "eid"})
     G = SGGraph(
         ResourceHandle(),
         GraphProperties(is_multigraph=True, is_symmetric=False),
-        el.src.astype('int64'),
-        el.dst.astype('int64'),
+        el.src.astype("int64"),
+        el.dst.astype("int64"),
         edge_id_array=el.eid,
     )
 
     return G
 
+
 @pytest.mark.sg
 @pytest.mark.parametrize("equal_input_size", [True, False])
-@pytest.mark.parametrize("fanout", [[2,2],[4,4],[4,2,1]])
+@pytest.mark.parametrize("fanout", [[2, 2], [4, 4], [4, 2, 1]])
 @pytest.mark.parametrize("batch_size", [1, 2, 4])
-def test_dist_sampler_simple(scratch_dir, karate_graph, batch_size, fanout, equal_input_size):
+def test_dist_sampler_simple(
+    scratch_dir, karate_graph, batch_size, fanout, equal_input_size
+):
     G = karate_graph
 
     samples_path = os.path.join(scratch_dir, "test_bulk_sampler_simple")
     create_directory_with_overwrite(samples_path)
 
-    writer = DistSampleWriter(
-        samples_path
-    )
+    writer = DistSampleWriter(samples_path)
 
-    sampler = UniformNeighborSampler(
-        G,
-        writer,
-        fanout = fanout
-    )
+    sampler = UniformNeighborSampler(G, writer, fanout=fanout)
 
-    seeds = cupy.array([0, 5, 10, 15], dtype='int64')
+    seeds = cupy.array([0, 5, 10, 15], dtype="int64")
 
     sampler.sample_from_nodes(
-        seeds,
-        batch_size=batch_size,
-        assume_equal_input_size=equal_input_size
+        seeds, batch_size=batch_size, assume_equal_input_size=equal_input_size
     )
 
     recovered_samples = cudf.read_parquet(samples_path)
@@ -77,24 +67,20 @@ def test_dist_sampler_simple(scratch_dir, karate_graph, batch_size, fanout, equa
 
     for b in range(len(seeds) // batch_size):
         el_start = recovered_samples.label_hop_offsets.iloc[b * len(fanout)]
-        el_end = recovered_samples.label_hop_offsets.iloc[(b+1) * len(fanout)]
+        el_end = recovered_samples.label_hop_offsets.iloc[(b + 1) * len(fanout)]
         src = recovered_samples.majors.iloc[el_start:el_end]
         dst = recovered_samples.minors.iloc[el_start:el_end]
         edge_id = recovered_samples.edge_id.iloc[el_start:el_end]
-        
+
         map_start = recovered_samples.renumber_map_offsets[b]
-        map_end = recovered_samples.renumber_map_offsets[b+1]
+        map_end = recovered_samples.renumber_map_offsets[b + 1]
         renumber_map = recovered_samples["map"].iloc[map_start:map_end]
 
         src = renumber_map.iloc[src.values]
         dst = renumber_map.iloc[dst.values]
-        
+
         for i in range(len(edge_id)):
-            assert(
-                original_el.src.iloc[edge_id.iloc[i]] == src.iloc[i]
-            )
-            assert(
-                original_el.dst.iloc[edge_id.iloc[i]] == dst.iloc[i]
-            )
-
-    shutil.rmtree(samples_path)
\ No newline at end of file
+            assert original_el.src.iloc[edge_id.iloc[i]] == src.iloc[i]
+            assert original_el.dst.iloc[edge_id.iloc[i]] == dst.iloc[i]
+
+    shutil.rmtree(samples_path)

From 9f985b538705dde6bcd904dbacb70f3a27013bed Mon Sep 17 00:00:00 2001
From: Alex Barghi <105237337+alexbarghi-nv@users.noreply.github.com>
Date: Sun, 14 Apr 2024 16:25:45 -0400
Subject: [PATCH 28/33] forwardref

Co-authored-by: Rick Ratzel <3039903+rlratzel@users.noreply.github.com>
---
 python/cugraph/cugraph/gnn/data_loading/dist_sampler.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/python/cugraph/cugraph/gnn/data_loading/dist_sampler.py b/python/cugraph/cugraph/gnn/data_loading/dist_sampler.py
index 34e6df3411d..e57e195a4b8 100644
--- a/python/cugraph/cugraph/gnn/data_loading/dist_sampler.py
+++ b/python/cugraph/cugraph/gnn/data_loading/dist_sampler.py
@@ -29,7 +29,7 @@
 # PyTorch is NOT optional but this is required for container builds.
 torch = import_optional("torch")
 
-TensorType = Union[torch.Tensor, cupy.ndarray, cudf.Series]
+TensorType = Union["torch.Tensor", cupy.ndarray, cudf.Series]
 
 
 class DistSampleWriter:

From 414e30d9f24a46df694b84f382dec71df5a14cb4 Mon Sep 17 00:00:00 2001
From: Alexandria Barghi <abarghi@nvidia.com>
Date: Mon, 15 Apr 2024 07:41:12 -0700
Subject: [PATCH 29/33] add skip if torch not installed

---
 .../cugraph/cugraph/tests/sampling/test_dist_sampler.py  | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/python/cugraph/cugraph/tests/sampling/test_dist_sampler.py b/python/cugraph/cugraph/tests/sampling/test_dist_sampler.py
index 4c10fbbc3e6..a86eacb9851 100644
--- a/python/cugraph/cugraph/tests/sampling/test_dist_sampler.py
+++ b/python/cugraph/cugraph/tests/sampling/test_dist_sampler.py
@@ -23,7 +23,13 @@
 
 from pylibcugraph import SGGraph, ResourceHandle, GraphProperties
 
-from cugraph.utilities.utils import create_directory_with_overwrite
+from cugraph.utilities.utils import (
+    create_directory_with_overwrite,
+    import_optional,
+    MissingModule
+)
+
+torch = import_optional('torch')
 
 
 @pytest.fixture
@@ -44,6 +50,7 @@ def karate_graph():
 @pytest.mark.parametrize("equal_input_size", [True, False])
 @pytest.mark.parametrize("fanout", [[2, 2], [4, 4], [4, 2, 1]])
 @pytest.mark.parametrize("batch_size", [1, 2, 4])
+@pytest.mark.skipif(isinstance(torch, MissingModule), reason="torch not available")
 def test_dist_sampler_simple(
     scratch_dir, karate_graph, batch_size, fanout, equal_input_size
 ):

From d747dffe094be32f46ae527b6814feb73fe87a91 Mon Sep 17 00:00:00 2001
From: Alexandria Barghi <abarghi@nvidia.com>
Date: Mon, 15 Apr 2024 07:42:03 -0700
Subject: [PATCH 30/33] style

---
 python/cugraph/cugraph/tests/sampling/test_dist_sampler.py | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/python/cugraph/cugraph/tests/sampling/test_dist_sampler.py b/python/cugraph/cugraph/tests/sampling/test_dist_sampler.py
index a86eacb9851..02676774a02 100644
--- a/python/cugraph/cugraph/tests/sampling/test_dist_sampler.py
+++ b/python/cugraph/cugraph/tests/sampling/test_dist_sampler.py
@@ -26,10 +26,11 @@
 from cugraph.utilities.utils import (
     create_directory_with_overwrite,
     import_optional,
-    MissingModule
+    MissingModule,
 )
 
-torch = import_optional('torch')
+
+torch = import_optional("torch")
 
 
 @pytest.fixture

From 7f5abfff754dbf8356aab3cde1f0de8af16a464b Mon Sep 17 00:00:00 2001
From: Alexandria Barghi <abarghi@nvidia.com>
Date: Mon, 15 Apr 2024 10:41:01 -0700
Subject: [PATCH 31/33] switch to yes || true

---
 ci/run_cugraph_pyg_pytests.sh                   |   2 +-
 .../batch=00000.00000000-00000.00000001.parquet | Bin 0 -> 15730 bytes
 .../batch=00000.00000002-00000.00000003.parquet | Bin 0 -> 11472 bytes
 .../batch=00001.00000000-00001.00000001.parquet | Bin 0 -> 15534 bytes
 .../batch=00001.00000002-00001.00000003.parquet | Bin 0 -> 11531 bytes
 .../batch=00002.00000000-00002.00000001.parquet | Bin 0 -> 15474 bytes
 .../batch=00002.00000002-00002.00000003.parquet | Bin 0 -> 11590 bytes
 .../batch=00003.00000000-00003.00000001.parquet | Bin 0 -> 15867 bytes
 .../batch=00003.00000002-00003.00000003.parquet | Bin 0 -> 11235 bytes
 .../batch=00004.00000000-00004.00000001.parquet | Bin 0 -> 15748 bytes
 .../batch=00004.00000002-00004.00000003.parquet | Bin 0 -> 11540 bytes
 .../batch=00005.00000000-00005.00000001.parquet | Bin 0 -> 15585 bytes
 .../batch=00005.00000002-00005.00000003.parquet | Bin 0 -> 11085 bytes
 .../batch=00006.00000000-00006.00000001.parquet | Bin 0 -> 15857 bytes
 .../batch=00006.00000002-00006.00000003.parquet | Bin 0 -> 11648 bytes
 .../batch=00007.00000000-00007.00000001.parquet | Bin 0 -> 15724 bytes
 .../batch=00007.00000002-00007.00000003.parquet | Bin 0 -> 11598 bytes
 17 files changed, 1 insertion(+), 1 deletion(-)
 create mode 100644 python/cugraph-pyg/cugraph_pyg/batch=00000.00000000-00000.00000001.parquet
 create mode 100644 python/cugraph-pyg/cugraph_pyg/batch=00000.00000002-00000.00000003.parquet
 create mode 100644 python/cugraph-pyg/cugraph_pyg/batch=00001.00000000-00001.00000001.parquet
 create mode 100644 python/cugraph-pyg/cugraph_pyg/batch=00001.00000002-00001.00000003.parquet
 create mode 100644 python/cugraph-pyg/cugraph_pyg/batch=00002.00000000-00002.00000001.parquet
 create mode 100644 python/cugraph-pyg/cugraph_pyg/batch=00002.00000002-00002.00000003.parquet
 create mode 100644 python/cugraph-pyg/cugraph_pyg/batch=00003.00000000-00003.00000001.parquet
 create mode 100644 python/cugraph-pyg/cugraph_pyg/batch=00003.00000002-00003.00000003.parquet
 create mode 100644 python/cugraph-pyg/cugraph_pyg/batch=00004.00000000-00004.00000001.parquet
 create mode 100644 python/cugraph-pyg/cugraph_pyg/batch=00004.00000002-00004.00000003.parquet
 create mode 100644 python/cugraph-pyg/cugraph_pyg/batch=00005.00000000-00005.00000001.parquet
 create mode 100644 python/cugraph-pyg/cugraph_pyg/batch=00005.00000002-00005.00000003.parquet
 create mode 100644 python/cugraph-pyg/cugraph_pyg/batch=00006.00000000-00006.00000001.parquet
 create mode 100644 python/cugraph-pyg/cugraph_pyg/batch=00006.00000002-00006.00000003.parquet
 create mode 100644 python/cugraph-pyg/cugraph_pyg/batch=00007.00000000-00007.00000001.parquet
 create mode 100644 python/cugraph-pyg/cugraph_pyg/batch=00007.00000002-00007.00000003.parquet

diff --git a/ci/run_cugraph_pyg_pytests.sh b/ci/run_cugraph_pyg_pytests.sh
index 3a3e5d10908..88642e6ceb6 100755
--- a/ci/run_cugraph_pyg_pytests.sh
+++ b/ci/run_cugraph_pyg_pytests.sh
@@ -11,5 +11,5 @@ pytest --cache-clear --ignore=tests/mg "$@" .
 # Test examples
 for e in "$(pwd)"/examples/*.py; do
   rapids-logger "running example $e"
-  yes | python $e
+  (yes || true) | python $e
 done
diff --git a/python/cugraph-pyg/cugraph_pyg/batch=00000.00000000-00000.00000001.parquet b/python/cugraph-pyg/cugraph_pyg/batch=00000.00000000-00000.00000001.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..33511421c24cf9ec0fc396e42e594454758a59c8
GIT binary patch
literal 15730
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

literal 0
HcmV?d00001

diff --git a/python/cugraph-pyg/cugraph_pyg/batch=00000.00000002-00000.00000003.parquet b/python/cugraph-pyg/cugraph_pyg/batch=00000.00000002-00000.00000003.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..2496cfcc3e0c89b5aeed8bffc60bbcb245f73f15
GIT binary patch
literal 11472
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

literal 0
HcmV?d00001

diff --git a/python/cugraph-pyg/cugraph_pyg/batch=00001.00000000-00001.00000001.parquet b/python/cugraph-pyg/cugraph_pyg/batch=00001.00000000-00001.00000001.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..d6290c1f4253354f2be030562df62ce7460311cb
GIT binary patch
literal 15534
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
YJ9~S>Inve8H-ALs(*2m9^nWV<54QTr=l}o!

literal 0
HcmV?d00001

diff --git a/python/cugraph-pyg/cugraph_pyg/batch=00001.00000002-00001.00000003.parquet b/python/cugraph-pyg/cugraph_pyg/batch=00001.00000002-00001.00000003.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..e61e92d23ac9711c70da30ada9025a37af1d128a
GIT binary patch
literal 11531
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
PAH@OvW*|cUzd`>8k;p9y

literal 0
HcmV?d00001

diff --git a/python/cugraph-pyg/cugraph_pyg/batch=00002.00000000-00002.00000001.parquet b/python/cugraph-pyg/cugraph_pyg/batch=00002.00000000-00002.00000001.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..cef6b4a74dd2fb63841831e06f86de813e4c08de
GIT binary patch
literal 15474
zcmciJ2~>^w{|E5fqVl9@xtCJ3Xh9`X)+{NNM6@Vdib`o;B$TqGh)DKO)*AZ~V_$}{
zge-|HWogDf$TowS|LwltcQ)pC{^x&w=kIjRtM}*oeV*su+kL*vy@yx-;hn|G;`C<H
zpTXi23SwoEsI>_Htf@KGr!G{3>e9iq9o41*RGqe<(o4zyxzW+ojy9#kX%E_)_M(2Y
zE$vR7Xfvun`%_=qoO;o2RE`gS89*(l0UbsK>Pp?I7Hva^(3Z3n71MsykQ&o2G?41i
zzEqX^)6UeEj-oxO8kNu{RFT?K9cn}!=vdm7cA`qugbt-6sS35CX4I0lrvs@Yb*83t
z5bZ$6(2mrTYEo}%L;Fw<I)aKt;uR{=A1m=kP3gU%B9=bj#^>}=Q$bZQ7FrAa1UErL
z=qn5sx(SYgmS7>M3;IG6VWiMTXeM+JnhH*WiqJ{uBUlSIg1w+5hy*jCv(Qm!DGU(0
z2=0Q9pe76v6oq!eP{B*^6Z{2FK|vTTxC%Xm9%^<%3t^zr$#IL^+G%GCMnWq=N9Zkx
z1zlmdFh+0?Yy|^BPcRj{1!ZBFU@2${?FC<9te`3c2v))%p{-ypXbYnR6TwiB2!TR(
zK@dEIUP5zWgy14{{r`9lg6ug6{RQX$*5g<E<MB)XCX0GXe+G-!t2T~T2Y6%0)1LG-
z|DKu5yO`zU$`aOXXb#(p=>XQ{_v=R1r?M`g9qB}>O8<F(m$1H)s!;iT@4&o`*ICN^
zk$Ew*h@N6yK7Q6SFQ8ZDnf=$(2-dGqPu727mX9;TSeK7Ci`X8)dMxvM`i9EKrO(VG
z+5Z~zKgVTrwpUPNN<{s6+y}aa4av+=bUW*(sC*m_VY?ga@^M*{Ih$@}zoT?5?Zoz{
z%o@z{ab1CVEWONr1<Y3T73(g{<y1Z|%wj&qenrgln5$_h>+*5@2=jinM>5wkZ=mHg
ziS5=@KF@?Occ8zszcF3K`VHoz%t7=P>)n}Sn7cB6Pp4BK8bIaqm=|*_?Mz$K**vc;
zT|zIjU7)F~zonJbo$WoSDgBA<GpP~l3z>7NgifJK?59oT^X{)~KS;CKE?-}@WuC$I
z>2wRVrZsdsJxQlh`TFc6&!^A&C+b4`v3(A6JUz?02J=kjXu5}WF>`+^Ur#(>`#RQF
z)1|EMV)mu_RF&-mndR%2O{`y{E7+dGoKEMm9!S;bBeqx3{j6s)e@C0p;cVZ`e4R$q
z7`AVqGpHhMPj%V<0^Py-UFHNjn6{v$?6;3uhq;LPBC~X=ll{wQ-b%};Hrw0L06K*2
z+06H7A)U|m<ur~u)AQ`Nk$E)pVCFe=F6(yGpY@$|JnOfqFKter(}nDx#QYnbOueW#
z`*mXuW42(Hug{k=zoWybK=;xvJia$`p8R~&miA)%apoVG6X^tcf{vrg?C(Kmu|Ax>
zq;a$*`{~jitgoO>tot#yrCD?z+q*MAqlv6<qou4LqLW!Kq^>ld?LJh_S^jc{{ZeTg
z+K=tW>0#E>n42&+rRmg;4q(4_%m<hYXe-u7&^p#Fnb*>ATETXEszZ(FVfr)ufyX6N
z2iAk>G}gy5pJSG88)W}BGp}P#V76jj#Jrncp?-8F`xP^vW`07a(Gr@%elM6;)2=j<
zcB0MMUx|4yvpRKV{RHzW=7;n=>+`57>t@Ws)Q}Eh`*+M8nENoN(F^kabPW6LVcyN`
z$lQ@xk9h~PC!J4&=qUC(NUzci>dk)Rm^aZithZnuO8e4qwujMf^5bY9)^nIWm`BhF
zte>V@^a$H0()F~G?O&Kpm~EIB(;w*}wj0n(^bFfC(qpXOWbVa0o=&27*xrm;levs8
zWBq&PoivYH()Kiin$b`i#q&&|*XTgDk70IXp3Qup`5f)dx(RbG^GN2QbTsSBm>Z})
z>ywxtQ|adhv$do@-}v01>5L)A{mTq|yL+}C&~J8cn@W9ktMAQTzgpfpCSXpg_3mLo
zwk_w}6&co?vF%@0wYU0|_2iYkOGdB#(8cxBl5(~C77HuW^{ofpG0%Icvd4E}oWa!%
zhI&T?t6bgKMHBMRWLcHgT-HlH)WLL1*rejiKRmdT5hfTva|wtU<LFUfSySZle#N7P
z%L=>qze}uk8CWOD+}a}hvfl1xJ8RBqzgc_aLBKW3sQoIFp3GeO^ttZbJ^L;=ho8(a
z&|iMNIQa40^^uj$yIJlv%X*S_uFX!b>E7k8-8-0VxisSKj)0Tt?^1hJyO&lCI$(S;
z(rx*gT`jtgZ<!UVmok1u#QL1m%Q}y{7Va=D+iIIfr<ONow|HDI&MDk!vw=-T>8>6o
z%{s=^wYly8bVOL;k?FDHCu~cuuiDeg>5Reqy!oL`LsRD5=s)X<b7I92li~IjJC-YZ
zJ4HX-TfWil<l!}1cGH!@7VfaR(fPBDhFy%cijS`7rL*lgC$G*EhF{P;YFJSsPK*{U
zYHg73t)V^a>ax@GM{5~B$qrt+O}pML##^-6e?`rpd3&c`cvBj4V1N1acdg&Q?X_F9
zQT)KdQt9V`KRWfze=((vMvc?DTTU&DH@RMkm*j2QV;9|XUP0N^iF365CM9)jt9<66
zerZOCj^m3at$)sHdAgr%Rlat^&13duO1<B`8)5#~JGYP3_R7~w94#-bJN|0#*2KIY
zTim!Zb6Y@FzQ1RI?c{+@XIh^6Ezfm{@}kh%N#(D9+nuR9;Oq&Tb!S_cjp(lLkZ|zw
zo5H%v%=lUEXI`|?IHhGd=fr}udvo+Q9FF~d&Ass%E_J?#S2m<qyzB6E^B&i^R&8!B
zwr;PYW3~8Ek4p`OtIns@J9o_$<+-*AIQD+K(O~0~#WSv3*UwtLBj`t!;x`G#LAupt
zWuh}hc^7JOr)3>XDo9?tJi@)OVU4QA%kz^vXY|Vnifh*^DEnjF?4x#u4yW}?t@ag`
zRzDfAv~8&NO8u)(!`3TFmbzqn#jcO-`^9d&Mb_nmgDbBnwQhcYR+ClA_EGykZ0^)$
z#@_ZL^#dCAt=yimeb36t*^-@SXAElZdFyH213Qx^CBtot?=AVXqGNsH#({l$CZB#j
z@sjbrtvzy$4J5&W#muh7eJq~2o9x!HU;5TvtR>m=^M%V%xoSn4wU1QF4s_^W)~cUj
z(fn4!wR(wlHaOHSyF2-AFNw?5CO)bw@)d07?Z|XIX?1ItR!(xj^){<-3e`VLER!@<
zT`LDHt{-t}Q||%q7Ci61zp&}JIbQmc^qbz;R_vS6G49fWz55I7ueaVl-=eT^(<ft>
zT}h*!ij}(F-Z#(2QxbL0@9^GXeR9q|HMrM5-Z>((-=uW2{#zbwne*aYGoL$6ZfHk!
z&VQ!ctGp!b(waGkUYl$XAKx&zXL?T;6Ro?CUcGWSeBq)>=&Okh!BZc;@HbTX&hJQK
zVb1<O@h|U9*=nk|VwU-__czrV2Nvn5@?)a(M>eX6@M&b@&gs1L(?}`u#b!ujU+F*j
zU@4z`<dcPbQi?z~k$muyF9xDmkESs+mdY2U@yrQy0asBW!%(>I3pa5!w2U3yr=UJ6
z6^5^cn~%ZbXK>9Mn9tF+i3p?ZS*{Mexf;DQ5p_qd7L2)ys$GtH?ONFDEFAa+s;DZ;
zF0j}K?ivNp9fk=<p#B{=?IGOu9=_JWGU<MInCS`&=D;DZq2!9P>^hRZ*k(p7g`$n{
zz-gG$rtz;R5<TlK`)iAe&NP)}*ZUeW6&x|0eq0Qz1Dea~%htl9b#R}VmaJY94p)8F
zmgV7&Ix^EkV09(jrmQQgSD%D#N5!)IWV%G=%HWnVr>uuHC-AXCVMuFPeQF8RDmRej
ztIZ8%YIwqiCvdcW8(BTk2iudY?nbg4Py@Ru8O!pO3fQ%ei7a0m0YCV|q6g4E*;LkU
z<ZC8#H(qYhL%zI^XartXk+_+xo2Ua<B}2LEHfV+VF&p@(3tVgmKlF!6uCS{cG~wzs
z$Q!wyyP;=%-#c>GT^NM+=Db03X)$lmP~LzBywM)>1{=s5ER6TbH0qXx^9@-H)$?Fk
zKI<Fdg?-S2tF6HYkyoF9Ex5W%yM)}N3Rd2Ly?=rqo<qe~Fqu}pMqct6Zc<c`{i3b`
z`*2k}vL*7+wy?7i{K#G0V(!k)TBEMt8Cp5OVw%HMbsj&(7~_rhEk1A)KUJz5fgH$B
z9g?_eFX685DR*5j($O!6tNceZk<~I`L^fQ`)p_5=$dmZ#r_y@l2JW8E>_XP!r*C1W
zkWX<ptXPh`ovz_(U7Nd&YOZ2`t3toG)o}V9xa22T`3y$AhDz_?5s{+o^;c;EA8SD0
z<}gniJ~U*#E&N1#7$dux!B*{IcN^%_34WqpeUWWE;V@s=KM2}~!Uth6Fc!MSL(R$X
z;}obn4GvF(7BirE2F-+Rvf%O!aMxz|!wwj^3szJ>%}a366}aL$^sa(VH=#Sn`7iaz
zFJHi}FQM%RnEER`@ClZvVc<C|f%)yAlLZ{-2j7i?rGZd94sOYS7iL4rCivwkR8qwJ
zF^cwbL_T>C4!QwrYoPjTX!I5~{|p_BF(CFRg&N19&QKNE`=(?Ed~p(*pN84b;J9Dm
zay<;F>DF+3EHqmLTP=m#3!&OAIQv&Pzd7bN4|n)>1r!RP-8Gn{f%z}BE!;E!ehh-g
zqG9?xxNZ^Lya&ctLUR>C_WXAG!KE2+<ZsYZPhHl&cOn#4!F#pv&^s765EDpx04xlL
z%~nD0XHfkOyzPg1dq@DZNroF9!K3uNDJCQbYZw~}opNFSRq*p^IMWpKd}JSZas)h{
z3sdexv-hwe9uwWRBABuj8tsBg`(d~{)(aN`;M)`^DS}?FV96k?Cw7j6=^LTPE_mY*
zJaGnUpNCUl!V*iYJKRq~y)r1_dPLG4>yW#7@YH7L^aE6{gBs1SPVumUv7Mox9h^P{
zdiucS3DAB%%vl6$_QUs=VZs}D{R7O6!#c=Ez8<PT-dqEhK830xtdFv_V1+-tlLS*2
z!Zpibcnd5%oW(F%0)sli-(6w9V7NLAnofn)_0ahh%y<o5n(E2k&)FWZ`y^&s5QXeJ
z3;OSeI}gIbw{W^H)_HT&U}P~&{~jishKK9m5M`_bqr~vHmau*{TvZF(T40^HstEQz
z2eV#64STE?@2rPEo`JO$u=F-m5n(;KTnt-;L-oyY<6gK>6YI^NCc%dN@W~~3tqMAS
zfg@~<WUpWT5a{C%U#7qnIk3le=z9|SUxN|Vu++p@)c9}iIJhDV-i?62$HUU8Fyb_P
ztY#uRE;s-djfE34U~D$rasuAI19vtvl^r*xEganix_QH&{o&d1@OcRAI|-&n!ERe&
zy9$`0+fH`gHh%EqHE7<!OjfV=gQv#8L|IiNN}`i#GMz$G=u|q5PN%6fjn1IyG=t8h
zv*@_?_@%4|^!0;B=fJzF3bJ4JHHD!%FpA$selSIj8xAFNp@^Sq|G-aw`)x)2Bfr&(
z=eIx~>QKM<JABG@nHTq)-*G+mgNdT-aTHs@ps`RR7;XrMWnA|daNX154C-|^U_cFA
zUkevKh4<)|d?nd+jN-8lsF>VDmc7=%TL&<&S1rW+oU#E{&A>c-DFa?vjrr6|2lHmV
z1o{TRqG;&#Bj!sNEzEP*#$n!?r;qu_sS}Lz#=O(i7Z&Maep%xOi{`<mr{FIJm_O7#
zph+s!PQ!d~;2P}T661ExFL0JE#^-LcF+Psi3`bdF+^RLfxZ@uWT{2-%0>+u^X&6Ty
zO~Cl@V7#&H^{eN7_i`oflPv@A{&&I4DKf+`FN(+IM7+&KrJZDliyn7{^SVQY-tf>M
zIC3P^9tF3Lg;C?+Oxija*=GW@NPzcv<0bLN`#uBpF<EfpJh+}JE<)~?58D(&qwTQy
zF1T$E9I+Sb9EC|IV81Ic{5t&oKJ4)jZvOzUeu82}1=%le)!{UL%lVf6B0>F(88kMB
z1^gBw!WB7=`@J6g)?_w48-ez;$uNia^QHyJ@A#>|cnPv+5iI4tE^IrpJMZ%W+~>{X
zw@*0-*q`4X74h2=#R}97xzD@Cecqw#s4uR8k6*&TpW(p|u&Wa8<1`hxQGm|sFsT`A
zr2{+Y!wnYDk^478TjYT>zz$j25ngnKSKQ$7q3}!q%oztCaUbV23He4ee8GL3dNQ(0
z3JjeN%Ti$+_jS(P&-LWEc97Q0N54Zk@YmI_PYJBu1Jz4m5I?88NFQ;(m&X0xK^nvT
z-i~S<H;ntdg>}fS#TXx@AL+{8hjtFonxE@c^*}c32TOfm5%+H&gOUBh;k`K6GZ}hJ
zg}r9Lv{~?{94O>M%|-D13V5mnCT@p2EiryS=m1Ua;YD}2Zwj1y82)-6+GSy!PpOA)
z5)4qkIm00tu=7Uvu@+|3!OG{b>lfI?4fDgRM3}P$UcU=3sA0ZXrU9cZ;EUc+qXcfe
z2hAKXuQ+<ah6L!82<<ZAvAJ+qF8q%3(af#LrJR3m=VBhJ-UinlfDg;z%X{!Oeb5c_
zm1qboOomA-;hGlM&+V{;S35vUC-@)&7EFWc88B}F+}8y2;OwDr<#6a60*{A5wK&*2
z6Q*Xv)~Dfu^RP;S`81+6_k%;=azB_d4O*7N)t}(KFYuNd=3j?YIOP^B`w0$y3~SXe
zFE{T47Yu<ny`c3NSRMs~mO$TC(5e{b+=8v1!5PotE-TFIp7t<w92^`1^QOW!*|1>=
zjNcC*ABB|_aM?TfA{Og{PYa<zGacD|JxBx2Y6m;?gcg~w^c?hk1|1c!o)}^X2YbOo
zVbD7qX6C~0%HjRb(B2U1kA*Yfg>*P$C%jk9dIP-O66+K#Ll|oc?FYb@!(jF(s2dC8
z(%|BJD13m<1F!(OmJiD|z&F3ZnMzog_^gKo<?wMW+@gbh;P1|`#2*I4!t|-|w*ye^
z5H!CH%b&qzpWzzrCr9<bx+~8e9?pQ<3SstHn5cvOVqhLDtAaTXpyzWK@fo_PVBNNL
zIE-8el}cd~em@acg`80b{XfD_0@iyz1~6kVoazOW3t&Pm?EMU?SYv(oxf`tahdcA2
zo(k5Dm(yV7GB~~vsvm<nXQAjkG#4Am-nUJipz3_MtpLv14{ub$tas2<-B{H4Z?hT9
zvW5-r@Pa2)9R|xMLfcKyemA^+3x0S59UI^hv5D;bDK1by2F_aoXB0rmMtFEHv_AyB
zZorg!cv9O`c0NO6nAZ<xMZ>B&FzP9cux%&nUl9W9kHGImSby(OhC5Z@Ekju80i|D~
z28)CL`Xy=;>G_n}KF09acy2G*1w^8|3i!oZ5gt*3(o;BzoxVDS>R(QAg@^LP+{Q0&
zHN~2LJ*4qmA2t6k4T^dNZYl}mCx%1?iCc)o%4UkKRHA|+V&W6zAw2qzpcEApi?UW^
zP;f|O;KZ2Nz?jg`gpfpb*NqQ}PKpW+i4T-^{j*7}@wCYy;b9XKalC5Cgs_mn@ChQZ
zqO_^0EG4GIhKM8|HT4Yia?C{rVr4xuWfeX7!x1+&N$RwvKjy{F%+(AWM3!oScnw9Z
zF#RL_?O55P$FX-jBzHW_S9qE~)|MT7jW6rB4i-r--1uy9<iaG$!X)$4V|zQ;SgOfC
zn`osrfmfHpYc?MC^-F`3WGYB970j<*Q|RsRQqxjR{`dd4tAF#A#F;`Rq2@QQOV9I0
zdLH?k;;Zwh>6tY?9KP&0vWujP`LQbLk<vHI-yXF5@9}51SAXlKh?D*Khx)VQ`Wy1|
zNh)qANdHJ8J%d&%u|d%jf)ZM7RhwoK9z7vsO5pgI$fT&~1e2adqsCYnnIHzr+Cu(O
zmBnc$(Lqrm((WdBJDNxj3Jnj5oDleR9Ty91d;>Ke5FVZA(6zC@^sN}1@^v{XBr#}0
zP-2j@Z*)>*WU7_XUoIwl!+hgnf7Jh*7YmC0#+6X~-(ALC{#5_dbNcFD{raNc?DAiH
z2;UkOzJ3({*6Y9cKrje>ed#~z|F~FaWK2+^U6;lq{{D6v_-Dg^dht2XeSO8hH2mX|
z|MLF*U;VBB7)k%-g0g!=`dq%g<hP!q^pYt5^BKx+;rNiC#F%*LT{O)kGCVjwC_bg}
z?u$(cijR*;ZoK~Fkobh~nCQl8=dL!kHeF1l_nQ3De`)Mu)5WH<Nvf!oczn`?P$RY&
db&($9U}I~mmm^(Oee*|jLb{LilKyYw{{hZ8<jVj6

literal 0
HcmV?d00001

diff --git a/python/cugraph-pyg/cugraph_pyg/batch=00002.00000002-00002.00000003.parquet b/python/cugraph-pyg/cugraph_pyg/batch=00002.00000002-00002.00000003.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..56f2664132148ce2e74ef3f06be65c92a9833f13
GIT binary patch
literal 11590
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
b9}^SRxN%^~R``}*j(6R^)c0`zKdAo$s`p0)

literal 0
HcmV?d00001

diff --git a/python/cugraph-pyg/cugraph_pyg/batch=00003.00000000-00003.00000001.parquet b/python/cugraph-pyg/cugraph_pyg/batch=00003.00000000-00003.00000001.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..dd64920dc1e7f32439a922f9632ca40884ea9c16
GIT binary patch
literal 15867
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
AdjJ3c

literal 0
HcmV?d00001

diff --git a/python/cugraph-pyg/cugraph_pyg/batch=00003.00000002-00003.00000003.parquet b/python/cugraph-pyg/cugraph_pyg/batch=00003.00000002-00003.00000003.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..e15e83be3712e52e97006e714c7f2f22ae8d5df9
GIT binary patch
literal 11235
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

literal 0
HcmV?d00001

diff --git a/python/cugraph-pyg/cugraph_pyg/batch=00004.00000000-00004.00000001.parquet b/python/cugraph-pyg/cugraph_pyg/batch=00004.00000000-00004.00000001.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..8c0cee03ea57da2be2ce74e6c67c954237e79e40
GIT binary patch
literal 15748
zcmdVhc{tU1-v{tx$?_`{9Z^DuBuTcUw9z7k)F_cip-i?A+C`g|nKtbUN?F>JNZUx!
z-e^*^Y1dw~kDBH=&ij34=C1DhdY<dL|9M>Jx?jCN-|z4DJL`8jXKpX&;WlDraZ)qs
z&0SogAXXNMnv3w)jq1=&)RgMduCzPVqaIX^no}p*gSMsKbQo<$J*gJ;qP?j*Z9}_I
zXWEgrq&C!#8qp5afZ9@hI-IK0&eV-6(b3eOYEui^pGu!<*`JsWr2VKRHKwjqpsKVf
zwWhsjd)k`XQ3)MPeP|OphT79sv>hEn`%*`0MOEks>Ofs+PijU3sV`Nansfk_6Tp9%
z(2-Pwj-o%%KGcvZ(iU_m9Yn<<@iG<Z%~G7CCH-uuh@}sx@wH9TQcx9s5WEC`p@Yy_
z=pzggx(b3|D%cASLJPr17$)clB4LbRAt(xM1S_G5;3B9A5}}9CN-!2Qh0%hcU@P<!
zdI}>1Wud#^As7iwh1NnRK}oO?+6%6Np3qG&5ZVb&g0r9^3>FlGfr6@_Av6=*1xG<F
z_z439ePM`TEm#V}g)V}f5Ga@ly@dXPuAnYx3jsn)p}Alp_zGHrn=n%7EsPR|3T*{*
zp`*}O@D@D(zu$l9>rvq(y}64IsWy&PWBHmLrp@@~`Fd<v&GtyPUu53LEFWvsndM{7
zHRi9!o~^7$@jORpN7h@>_0*hJv7Z*RKx63%w#&z!jjV5Ey&JQ9ObTJWj;>*Qe>#u#
znY5lBq|a$S`>&#(Ss%eXkglZH*)AV*HnT1td$QO*h4ldHMBB6dcRG#r&h#<sI?P{>
zy=z&&LSxx~B6BhGcKU|O$L!zO?-lFq=w|B4b~PHrdM=fZfghRsQfu}%q?Oc{E}+@$
ze~QY-;&`^p$K-j;8SK}VS(_HnPV^TlAH#PtkE56Ae7c+N<N2ph5$hA^9J-wCsm#~u
z9oA>lEi{Q<piihHkJG2}Ii`^9i&%fpe4BX^UCH`%dX0wBpV%*jN~nCUDq;SW{r59B
zXYNLIs3O}7sUJN}`%*pjk7HJ%9;`2><y4RDiF7aPmdpca4eQ3t70hFqJ2A`GW^SzO
zvVN2fWnI2zTfy9&?aP?A)5A1|+E61J%Htww7VCC&3{7Qw6Xv$eEt#F^A=ZnTbC?%1
zt1+9?P}ZxNdoVjOFQhfB_h3H6JfFD@J<Ix4=81GN?LtdvbM|*;K2FEc)@-k!)zpM`
zWIqGu^~{r~e9fxCb{p19nKv-6W6q`?)Q{~gnB{BS8LS)72)2)>Q|T(U4`cq5c^k8Q
z?fNt8t6AT}yoS26K9G4d^AY-#^-atU^jA8U?Z;>${Xo-bF#8)ZYcijs{?vueVZZLo
z-pmd33_Za1Va&ssx6q?>E89oYrSv@8{h8%^g3HX)*?x;!u%1r))239q^pX7)QCl7t
z&YZ)%iFpunK64-DOe&^R*&f7fK`&4@w)bPUqGhxV9YW90Odj_K4QJh(-l1Knz<xWJ
zA21(dE@eJXzfe=QFQGrOzKtfZ-jBH{^Eu|F%<GtwnJ?0ltm`u0WwxYuS-(j$=+D%c
z{p5SOg{=Qbb7=(owWf=x9Svc>1<b$ET6&W0SC}PKzNdS}tjd1lncvC#u|9)7Vtp^O
zGEJv1*nWdrQ58CZI?x|@TqW}os=|5<^8`AWbxr2|v@7d*%x263n5WU1tlwi!V&1{r
zfjN$O19J+qoB;mAgg&GPXcUjz#XO4n5_2>Sr0#4#%bY-Gu|AuY)7xzKr7!7jdV>7|
z=}^{B)1IuaVD@4zW8TAjlX)baMMu$FbT0e<z}$!Wu)dS|6!R|nmUTrslJ#Wf7PKAf
zpP28{<*d6fUuC{QgIVuM&1f{+kJB`2$aV$h0_J6OEp5;CgEWtZ(cbhI_J2($vtC3m
z(JC6xem~Jcv=`f@-$~4EA-#R)I|=pKOI|l~zvrRt6IZ)A*!NDIUH1WJjC2y7Jg>CY
z-#I|P{(61P<o(;8MHZia(W)@pD6+-EUbW=|4=*-2(W#Bb$4kK@`(3ytGD$l+STkO0
zS=+L%9mo5KJ?-rir)w=Xa1Nchw^P{0WyQ`-Jhz@otGgQ4qar+apkMhj??UbP(uy~B
z>Pdl%I*#$RthKmcHYh`3u8n$j;2qCl1JWK<xBB#XRBCm^U_HTgWOkm_y^8MBHrI$_
zyM5X&Y>AZY>8uoHSg|*C%cEUkj=P6HEe(%;IYUw1>dEKbkH?G?&Tq`jYMH)#e5Z{1
zT*;bsiNVX(UiP`^x@=ozX$z%M`qQ$!%9nIMw_sq{?c&2b-pBPHv}JH%YR0XK{>fjm
zHC$CDi&~kFet#l)Ld)=D%}vKOb1oWYb>)in1^)#z9u&?Vdt>uEpGP{H6E!T~#%<6^
zn(yg2V3LpR_}ANZubWy@>G*k%d&d3Vx_kRA9&%)h;mF8~n$bZ`#<pB=GIdt?BeOXX
z%_|ePYBkgk8rABY#YErz{->*2_kGg&)rPFGTbpXVZt8jFMc2#gKV2QyM&Bu*N3-ny
ziF?JpkMwwz_3ZwnC8FfHo~rg!jm=6QrvGBQE30Ga=*sC+wkC~g5z$W5rof@2oBmIg
zGs0s&JLpsvFLOWc?0@gphv=Qg{f~^g(e7Z4{^TJ;GyTehqI=qNLbE*FmcH=LOmbNn
zar#kmnC{gBSyn4F4)4CQCvDCB8}rn67`gRtF?(Ox(@RY>PgzUK#EH+f7H1Zpk7-e}
zr#LpPnf~G2=zA|8RByaC)8JjD=;|WVw6-I=`I?(->k{QYpyb_zJ)tim5{$Rr9~+~4
zN#jV6rb<!IvaOEC9!8`*H}rTq>aj}dtxc`>>FFJNfB$$!(L<HxcXupq7orrguT^5h
z>kD-ymtB377vv9edSHAgeth@+Z?DfCQK`@;zx5TX(xu@ZeU+LfpVhWsf5m%oo^e_C
z<;%^}H`Oi<9yxWnW>!UUrSH_#^|=}MKbd;=jhSxfpL4|P%r%4c_t$ExgzVHeGa1{z
z)yX&g7Oouj;MkMXzL!pR^;6&P{H)uBtEX2_{>l9D`zD6d3$)yF_ct67xy%VsKIl2`
z$4j<>8NHQS-ED8Fcx(N8JGZ7oQ|4wT+uWa=)3W4d>UK@#?y3PtQ$2k1Z<eJDwW!zK
zcd(UGzE1BW1A?D9SxxFUAmq&M>YE3R^3NXEj;>U)z35Oodr*VPC<VJUCbQBWC}p`P
z^nGMqc4fuKGucx%tU40?^vIR6(`&0fgwBfSdGPSEB)hf=U2}c9K0hB|9hULVs5;3j
zr;}O!le+5i%bVw1EwZzkU#j-Ndh<N7QBwLuyM>qBUoD#N8FoNjFX%#!ay$2*H#r?O
zsVaJS^wr2Q;)YH)5(=kYv&kRYu|>LS^Q=kdt1bkZ_mJcWK5c&8T2?V<n}4ZF{5j3v
zwpA_O-BH=zJ-L-}R&CCbK|}hK6~1c`@3H8SbX55*L3)#oDk6N-*+e?>eAHA>63M3w
z`4U(@Mah>+@}<`W4pkTFuT;K8l}~;0C5n8>E1&x1OBDH*tBS{`DB~ZA+@tjCf&7+Z
z`t2deL&Kos0{DSziP-hX9k>_iS&BUR6uid=V8T0SdKYz{$1s6w*%Wh(!H-A7PTX@I
z;+Sv7?_l;_L3`(qP-7q_w}6rG!F>3B6HF<BN{8XLUtqUVXjBHXZoyO=CD|SO91C|%
zgTtrciTcv3@ud@qOtxXsbu>gxmiO7J%hdLOt+&AAyW!h&f~<YRz-BV5Tw!`SRPxb~
z)yH{i%Cz_as^>s2v6ig9$qjb!f*W2#oxa+#_Pnk-GOM1$GfJ&wIX4`(e+%cH)|1sQ
zZo}etV;OW)#2caXfRU`-@+vG`XDrLJ3fswyy)2Qr<SNwbW+Kb=3t`DexL4U!R$pNN
zC%1!TzraL1ouWZ_7@~(_S$9#LE=<GS5<SOdM6+#CpWy%p^@8p$aB6=TF%aIOt=*87
z++mFm^yeCHA@`DN=`Q*@5d8{*;L35(D;S=b2v;Y;FSKSZa%C#?S_%V}!#5kD<7W75
z3mmc?dgQ{J`{3B4a7{Th<N$GiD%YUya38*S0(U%vW^bT5*La<|2bd+`bEL&R+HDQw
zkJN%|vB#ZJ@6J7NgA=mD03PoNUkAY8AQ&_b)^INx9f7=?YqeAK62JRe&OJm8_YPlD
z(Er^sxN-$tyBe0RhiV((DyqdbqdE2Eo@#GC`bqd*WIujK<$D<QoKl$0y@1kr<jypm
zYs#fHsQcfAi|)Z+XihEire{#^1+@7cj`{*s{)D%b6=g4wO*1%J7Z%fr#>gq=@I*&=
z(E?uY1eaLDKkeaqM|h??yxR*pxk8fwm>Ul3BVlzkd@vbmC&1map?NBdp#4@L2d#qL
zHp2;d@DEzE8+pu8sKaqM<0P{6Dfs0MOuPrT+=ng?;fSZOt`6RQ1FL_BhM!^a7dTHz
zN%s6kXuxPq_;Yi3qc!}^2)bFp%x>^}Z@9!8rc8n>sq;$Y`ZX}K7``ciqb|dfccK0Z
z81@FXXr(N>e`<r_AO6s?4Bj~f<Er5qR}7pl)8Uy+n6?eh-wRJ%gwt$QWamHU1hd@W
z#vr(C3hX-@9$OCmS3=Dbu&0Kq>^wud!n9Oqdk{vK!0jT;i<9+XsU<w%3aci={N?c1
zy|AnR#@4`*V=;f`PKJGEz?#J{q8vVc0F%Bzb5+c@rsi<3CH&G09`J${Ghy~IIQR|>
zv2QASoO2@Kqz$n7aX7si?tcsyJ%s@ln9rYghaNw|v~+0p85Xy|d|w|3%{M~5U*MA^
znD=k4g{q(6g-)0#Kc+*UY`FG3%)161@4_}J&1H|HtrINm39a(r>Rr&{Av~pnF9izp
z;XDbvYzzOK2E&&@hZQh+8#FG0{mY=sU3je)COc!Da?KSc?SLyT!2z$}kM;1bI@U2G
zIze#}Y*1+_dtCENVc276WrhXB+YYeE2Cf+a&n|#|negCtIJOqf(Za$b+Z_HB20uo?
z4l|(gLD=>zjK2!)pTOZS;8Y!~x9ZzM-MLU>KfF)@Csf1Bs#uqO?gPt*!Q(#A<|JHK
z2Gt(HmZti$=i^BLv<ie8i{P6AD0vIjJ7QraIK#||@F7*1f?Qh(4IV+mI%v}XgVox|
zt~+}ybjgPPhv4tO!*|+PSDw^|#S+-r2YQZyvD@LQT`;T&7FEIyx8V-8wzBKi+rw!A
za8o=~ybeQZ;pTU6mI}Uv>faYW@P@m?U|k~oa|WEa9_~zsiQA$3S=e(R*2fioaP%x_
zm;<YeVboJ-^$hwc8q4ngaR=D6H*6CL_awl{YoKZdY<Uwde+q5>gq<DQi5mYZ2ExJ7
za8(IB(N-dBk8pvjhQT8vVC+)3WCgTd2S*%%olD@}a(J?hiR^rb(_wlpd|eLbK7e^%
zrm}t`<6%i6e7X=OZh-wR!fIJ>k?0z|PH)hg^cJn5x9J^vm)@iI=>z(Z*3w5b0n?YL
zC8i(IN4(ucpN!GLaVYFE2Ts}pB`2ZUNBFD(+Vi(Db29~5LCoJ`to)FN^EZaPNaUJ0
z*l#gB$aUkfm&ls+P(@Wyc0O;e7adz8kG6xEeW8&D{NN4kbD;^>Vdhl(SJc~7K=qGs
z`z|Hfb?zl&9T9&Y>ww?J;EDP}1@moD9_By40vJ&bXGdec>yZa_*KnRwz<jpf9)8fm
zd}V8laevn}jPsr5VO+nghw*v4GRD=eRv0g1*1%aJjD!BoVEh~?Da3d;>I8H+fpN>n
z2IJDTNNAFR@u9B+KG#K=_?+&31nXYIvm1?N&&TEh_~8xI@s`NyMJM3T>UjTmNro-E
z;QhTd8ww@Rq8e5jx0fC7E&E@QC>T$-sEY5yv3OcUzvAwT>TS`n#17u;0p|^ZDjx75
zPk1E|xgm`0lc45IsJsxSt%SGIV8v=^xd!^Jht8Yf06Js`vPlkfDS%xH;qS%J>JU78
z7;ZTZQ_5iXvoNv(9;5}AkYlQ#0tbS8esEo%qQ2k-T>lbor<0oFb5pDX1B_r_2{h*S
zPyQCjovh%WG@1L}=KOCiOdZj_!Wl}2KsUN-IP!5{XcY=a$bZ9_guE{nI!=N8Xig&X
z<79Z8`{1(+kY_E088l!yauRLIeR3^bx(@AW+%FeyLf*&ULd&@yu04SI+#+aj3@TrS
z^Z6T4A%9CQ;(oXHL$v?&6wZ1M8{WcjeqZ-a3*$<(4t%K(<J&^-4$z|ud`R=VA|LGr
z*Ytq>+~8Pu=sp6b`M{ojFmwz&$^GuaiOB9zP{Mug^(5q#^I&&=pO}%xewna53)*al
zJ#(P23uffQj{M&7INiy8@2b;iuRjO9IPPApWc?~Mxe43df*RZp_o1sFqyFI)RC)_N
zIetHHKwiZCa90V&^D0w#t}pyF1djEDeTKs%UpQ$zY?2CVmq1<acQ<lhn;)$#``}H8
zfh`xp)IHGZI&`@Q=e~g%9WmhfjesL2L#G6|EgKqMg;gq;hZefRGw!gnADli1&M9U4
z@9+lquiXqVf1Pa)V=UlQM`(Ep?x1CtkvAz}K#t=ALEQ{FG!h=T1`P}`FBbQNTjF5+
zba;Iyw7UgkYoN0j`%h61STqnG4S~wZaA6Akv<9jig{F658xiJTQ%6|p110gW*HYMY
zHB94vHsK-i#n<o;0rU1SUD(tRs?UOT8{ql<aI6L9_XA_#gsIST8ch2c-p_+|<uLXf
zd{GT;zCbS%tPgH>g-=Jr-!kF3qijD5uT(+TYtZ8sTw#Ru#rwn1>=u0Fk9}`J0Q881
zG4tX3#c*IN>|fgl!<=ZiJq5lx15@9_%}SWCH)y~NUwC0O>jBUr3Od!n1<6?VOjrkB
zm}332%?XZ~Mi;`|?XWl(e#nDX?Xh0+b%oKMu-$ODZz6oW2->8<rd2Rk5$mkqC&Ov+
zFlrZ!EQ9GCu>M-pA7)I3O5EqJ%S3kA1)~nZJ7w^|W2o{5UQxul&5--x*w)CpUEoz;
zSda=&l|z@aFkQepZ}bn)bs-#I4KIqYfO@3~%k1E?M7VV$+;t2#Gr{`sraMfT0#D9{
zLl(lF7hu+P7}5?Khw>$`_&q$`8|%zI^Wm%o@ZvHUoDTyeScldI!WZ11HVa3-xC~Zq
zflKzlX8U2@5$L0eb?c#)&~6A!oeO&}hHZX=uXn=}%Eq#BJj@K1kAj7p;fGRKbO-LM
zg)f`76E*(bGk}6ITtN45pZanp>VtCN?K0@5ERh|rs|u&lqOQm%CqT!?u(g$mtp94-
z-5t4LBy3m&i&w(o1yH#VF0F!{pF{h8rn2*O_J-!%x7Md1-&_i>6hZGZF!Lj{6StQg
zpJxT7KmLvrkNf(kUnQeD3`>oDy<`W7L|jpctQAq<H^(CBDO|)Z-<(4AAE)3VOmsvE
zhe{986l?zTkj922t;TcxUmFzlHx5#X9X~N7B1qg^Bvx*(sHYMU^kY;^tUQE8{uPuW
zf}&Aw5gs%yBs_3pRCHieXlQIm9J{xS35lE%F)kz~P}=qHCbh=XCWM4dm>7rSRYQU&
zgan2Ki^Pi3CUsegn;IP=(oNFRH_%^VCNdB!>$g`{(U;#HabuHiwYKzTmfg%u&A>rq
zt`^8AR}a%N(!U%lyZ1PDqlfNB53>qSvpd?dgYPP!|Mw0SNiW>^XmMmif^I{C+2_EX
z4r=CV^4DHZ&6`)3!fQ4j_U%)HlgwApov&c_zDl8|!+TA0HTmoR@2>vcXA)-$)eSZK
zTrE9MgY-P|H^n#SQPXeVcz5`;<49XwTeExDq(@5MEdO$+<*&!z-Bw-yXE#Nh?C%%q
z?~dhvb=0l9t{{DpMEVALD$zla!9lTld1})oVUfWhiGkyz!ly(;#!7k^j~-)bEI|yE
zwS|0DmBs0j$e@T2X?F?UjuPoXp<yB6!GYh_ak0S0H&EjNVUckT_Kp3eZ^h`T-<Bgn
z;(~&M;)0}oBd3Ii&$KlD$HioCnD1Qdulj%UVnNa0xe|*1yUV!AAL@U4Oy7J~zrE;p
zyZjgL!uN)SZ|}vw>-Ar}BN&9fz4YJpuPzoE9u*X4XWMwhzrLLY{@w7Oo_r2;-(K+_
z4PRaI-@JeSSFiP7Bk8}npzJdueJtNz@_Ua_dP$VOeuT1*a7;*0TvUwoQ#4%?9yTr}
zC}wKor!RVHP)tlzLgV%0Lt<jXq9PlsHuhH5R<;u9XH9<Te>B=!*;?61W{UL0<EI3N
f8neaNR(gzsm9@2g<0|XBH&Kan-{&R$|6l(P=D{0)

literal 0
HcmV?d00001

diff --git a/python/cugraph-pyg/cugraph_pyg/batch=00004.00000002-00004.00000003.parquet b/python/cugraph-pyg/cugraph_pyg/batch=00004.00000002-00004.00000003.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..6a7c93e9ab5225cbeeee803f237cc2fa7c88ee2a
GIT binary patch
literal 11540
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
Hf9U@L9s4hU

literal 0
HcmV?d00001

diff --git a/python/cugraph-pyg/cugraph_pyg/batch=00005.00000000-00005.00000001.parquet b/python/cugraph-pyg/cugraph_pyg/batch=00005.00000000-00005.00000001.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..b50bd6027818990f02c8826cd7da2b0ce6b94265
GIT binary patch
literal 15585
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
OQK@7<)?4zQoBszy9mWy>

literal 0
HcmV?d00001

diff --git a/python/cugraph-pyg/cugraph_pyg/batch=00005.00000002-00005.00000003.parquet b/python/cugraph-pyg/cugraph_pyg/batch=00005.00000002-00005.00000003.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..5bea4f3fff31c91575cb46c5cb774175954ecf1b
GIT binary patch
literal 11085
zcmb{22UJwo-UaZ1p$rFU>L4H@T|h*NU_%526a^{viUSNyniM;V6+?)<qSz2HsIkXx
zEU^$ZvByfRi5m4KUt;2W(Y!Y^d*5i(y!F1d!kV>y?Eg8p%$<ABIfKT9CHN@~l;=z}
zuW02yJ*9z6mLS8ADIH7)&^T&DZK(zAM4hQV4WqrNC+$H8(!R6>wWM~m1C6JxXf!pa
z?P+UjLS1QF+Kqb9p0o}1qA}EwhERKIOr2;W>PMq!XF80!P#@ZaO6c*It~7u~&~{Wo
zn^Hl;X+IiEhtNnmln$aDX?NP3x=|(dr`FVp_NHBE5Ott(YDR-;AT^{m)SLR!KC~rm
zM%`&++MjA}ZQV~ORmzlS<eHbavP_|Q28@)N8(Mo#WePoG;V1ls5HVt?h!=+P+KW%e
z?7tPHXf8SmJ>e<(2peH68jGG{u<#WfM1<%e28sk>B$|ls!d+O2XfZ&z3J+l-e1yFS
z7lVYgXerEuv#=9=g_CG2T8MtaOGJuxB1puE-ojQi6=6alyhW_&CEP@Se3;MJZG*h6
zg@foOI*C9LBFu%OXe}CvDA7!~$S-@%J$dg(g~C86g-lqA&SHp=3kwk{^hFoZRkZo@
zyAZ8Jd!c&=+9y6p^NLnJHqt)vvv@_MC%Y?exzAXiM5QPF8S_pmJ@L{AaG!O}1=anu
z<^C2^X=E75Je#g!e@o_1nJ>~YtS@DjMwVZhr_v|%7#%^!(Ei*{81rLl!@7cQVO<)r
z2C@Dn>uJnt=0?oY$Tpw(Cfna0>C|lhiS2#qSSpQx+u3gg>&eXaR2m`ovHcr*ovxwA
z>~F^`jiipOuV%eHZNa)U!kV-GJq>5OH1bL#vNYmGu-$>?aJyvMk@bVj(g>Z)>`H&2
z(n$A!c__F4h4~O|&-zK`b#y<?XZydHL+EkZjO{C^HGRl-dm7AoIddkJW`ebB??9c{
zo=O{0X@>Zbxs1M~ZK<65F{ejaU(cLJD_P&fJd=4V^Ah?A>yw$gF*{Oe#;RcMOs~>m
zw4B@L(3Lcs?KRBTn8!1ZW^TzGOQo6WJGPIcK5U=E97`v#K7`qXxiekHdNs2fjbwc|
zb2aleW?MR)^-jz~rGE5VI)m-SQl@KZQ?|P?r%-7o&0xDUqxN7P&VGe-EbG5B526LM
zg6*NSg!K)~(##&moK0KP?(9E@`8jiQ`Z4_n{h6Mk^XUt^ko)<V4xxM5{t0szx`TB)
zW<xrP-e&tO<_XMiuYgq2c5Ls(96$x@i|7K@Ynj98D%K~_0_sbx+3y1y$ohJz&fJbJ
zVf`cKTg-yFF}=+C6>3HG*nWa}CbI`~DRWO6L`&KJHQhi5O8uD^Q)vZkz;-XzS2J&B
zZqB@uPG)@=a}4u5I+*o6%p;f|F&EJ(bTixK%&%w_-Ac`9FiqihMl_K1rOX$Yx6@qK
z4Vk4CY#y^d+n3XGtS2xxFps0V=vnH;ekC-Kb$8}PbQ<l#_TOj_oy&F?W*>TlE~HJU
z2m3S1T$!b^DSydlhazSd+LiSH8pV19b2{@4<}hYYdYAPiTFLqs%qyvi{*#8VUlkoq
zH_|E8f&EjNr&A?OqW#%#9&;O-#kv`DI&&oRc;+3<Yv^*;4e0;TiEQsn(^wCsy;(1#
zcUYG(pJu*9o3Nfq3uzraz<$%{dD@5V@pK~V3+PnVH!;tqHq@JTXTNCrAss;1(T(h1
zPc!IKdYC3qe{N?*TTxTCk7JIZ7IYcC$9{w9M|1%7rTy5y4|7Y}jMlQ<oq0Fi!nzan
zqt3LB{XV4LtQXVISwBM)S^tVTi@An*E^SQzO}nw5<{N8`iRSg5Z>%O$))w!2b*bZO
zZ>NgkPcD7CW}a)9m(ko~FRv-*hq{=)Sf>Bo$r#_INhyz)t-t!Mmz}(6KmQ+&Iepc`
zxF|59)+1iE=keNri>dD3n*!y|N1SY0natXr=9qqG+2?gp!OtI56x=(tse^;J%c0*q
z+V-3=zfI-cw9|Em^_q9DS-0!Rh*fnieJ3kN?pS*)b6{ou?QIk8i1r8UGR_Zaoi`+@
zCboI}$<$1bOj-7z6JxFk>zGM{9PV|BHqZRb>h}kWDk=g3T8w$<Q)F~_$fkU=&mY^X
zmksOMr+P@@!qEfH%o~|iZ8>Oc+tLv=p-)p^$hWlHTI&Az^W<}3mm|u{78hUp!k{9l
z-|j2!UP<Y{Ebg*EwX<+W+o3jw-6jT_OgI<#;Q0EmJ5e6{{Fht)wmopO+m^}-*Hbl>
z^*yb9O~Z=^|5~!>vT^m^*oNwi=&5DR_Ut@(A|=K9^pb_eBYL?W-{ZTn^Y4?o9jG_^
z!oOg_k&rgm>b`5WyVN{=Yr3^z)ac>&50%ZnaN91gRPEK+u=BIH>f{MN3F%XNPm9^#
z5Og|Pk!gA0n=!!-%^y`wb<1?>Idu7^=KIUH1|L+UJzTl_;J}HKFYMT?zow5@k3~mH
ze!g~K{izpMWbu!3uU++AXIr^)j>DZqhq;Xxjm$4!Xc8R}_p;;sZ+D&Fa`b57#~-@P
z+qbM=E1%IvEiQ+pJ6aUCxO_`~uASF9<=)V<Gqd6kMg3ycDKXw@TCVlWwcBO~edU#T
z=*ab&UME*|I2RK(?{<No@rr;i8Zu4{?BZr9AAMn}+o{VV2OFkZPVKAE+;W=R?9&j<
zOLv>e@P`p&P5r*Ho)&3UCe8ZxygOS^2P&=V9hs%4NP2pt*+rU-q*b{z8%m>rG<!+2
z$#FkC7J4!828Y+xGmytFgH8DuCx4He%&&F*xg0tciW3{a;bAYAA^vLAk8@Zv{sMWL
zmA-CA&09i?!7xY#mzTnRHBeOtUz~y~>S2K~)-h3=F>fqsjP-`47j$T1q&trK2)tFS
zz3MWVZ6%D6Yd<8Jtld{ouN3Rp5E;hJa5XGg2wj^r()Hgv5H?x^e_Cp$tN+y1T<7O|
zVL*X}E`Kr#>xW5K;9Ae7y1Hj8rOxM%;nZQ)y8KFx@$|MgbZL!w#C!=Hwa8Z2Z}cTQ
zo%3J84pZ>GA}PdPSN|*yh7X4QhqTbuKm802I0sM1V&2c(0}o!uxNaHfsOvx3&`IZQ
zGkEa;yf@cbS08j6rn_Sum3SWxpXRD--_7N=0jG<_p1QJ3!TYbGBl5;DIJPIe!uxWE
z3b|`CY)FUx*|5F{ju{6Bb9xS(gzQ)h^-EwZ4fz1Mp3}v@E7-mgKBj#(AeVBQ>aZEv
z_Y;`52mW*fwmS+<Ic*u7MP6_b)?S7iZo(CJ;m;3Yk4Ny%bEx+M+RF8Gzic*!Pv}4{
zJKLM1{sXPz0Fc%Zb$K|f<JTDnE}t^Eyou*B<W(~I*=E4VeE5uB;Ig(mmuC@^(O$)6
z<kJ%5Zly4IHXOiZ+V5O;cUp~lmnyiR8m_K|XEs2`UGVX47{PI5`yJ$}dvNee7-FKY
zyH4Q({$>iVo53_&SVEupBKx(2@<=$a2ds#K0SRzA9oZK-WhAW6fUC3Nx+$<f$FrAo
z!~)dAmcrjxz|fWO1jjx9oyb4Zt-FxD_P|RAV22|x?JTsp3On6{@ekqs$1wLP9Q_>L
zqz=C#_prdYx~&=99|hONLeoJoI1MIbK)XEnnBFTwel{7dS`2%=gsL4Fw;w)&r)@B9
zcUlPZ7r{@q!8GkZENFhtJHp^LFf$N3B*9l{a7#M0m<TschLcO7-%_}@7FKSBVY}ho
z!|?E3xcWO-Sc3VZunaz{hBr3Ct%u?C%P`kdp*!!GwQ!A*i7x-c6P^fwG5ui9GI(}1
z9RDfIJPCd7!zy#kSLTth-U;*6#U$uH3YL5W``m@|e}oSdn7<rXz%HE6o*hSiaS<+5
zn(5A0Zw%~G46pBo)on4~HA;XJ%VEM+c<XBzWsCW+Z!h>{9^AJ8Zaf5k{1V2QTI!A)
zZVkKm!Hh^K&xOxRVA@PrxC0K}4|m>xu|L55bcQ}Artap@%>wqbgSGwP_C#1d4o>Ka
z?-f;1@S9TDY%cV_2{%4~jSVpGXLW}cN5b<nVeATc<2nq|$NFHn0X)zM?ic}c5@D}o
z7``3u{uBmYgxLb?ikNP&Y9*W@!#bnA9PSH(%M)0i1w$)g%$KY`h4oFbF8SUOws3{t
zq{Al#ux=JSKO3G~0nLuWtEO1bTyTM#JfZgh`0WNbwE@~q!n$YrWcXnNd|`$4kA52%
zH4IKkf**YZLu#SvbLeS+_0pCI7#0m1;^6(`FzOL3wy@XTkAab}W<RvL3^(0?i*Lhc
zcj1d4V567N(hKV@i)gs_BrLxRn?Hx8zrYvaSeJ!vh1;8AA$7AQybuJJMZi7-p)41g
z6~W+QIP(m2k95TQnFRZn!JjK&>3W!c0M?&_2k*jZjh$rLpV-c@zAp?J0QU`t$)n)%
z`|!+kXWe$wH^I-Ex#;p17uX>mjvE83C&GvZxbGn}_rdz|Y!q}zg|8OF*mdxO8t7UJ
zm+yj?ly17?)^&jKo#CoDxMe8x($jU5wWg<f;FlglVIkKkTeiz}9hHX+bylv!I5r^*
z_wSXH@H>I~V81J@LU&m#h6~wU+-|Z<I89kWD;$3#&F+nCxCjnf0zX;<O>1G+ez=+I
zz?ae+;P<wd={W!Kli+CnIkBGWu?PIKjZ;&s3nnDOvvXikHGHrQ8hj0JCEz-=90HFI
zh5uXt4fbFjP5v75p{EJvnTM-zz4GT^oE~P0@#+ly=Wygv+hOD07)M&fz`d2Q$_m%{
z%W{klIX<|cCQD#LZ(Mg5D@WZ08e54At@*m1q)dAA%ewZ1k+=MpvFs4eTxM#3OIpg0
zY(70kHM{7h?Dozsj5WL1%3Y}0b=~Vt%$4SEZldj2rqKTN;Q!m8Z@aRmQ9*LLI$Nc*
zlqn6|^lgl?RhhZ@1yab!`6I})Re2~|WvP<XS&8Ynd5O8HsRimnc5j-m&MC@HQs*aX
zy1s5wXm>kSospJai0zHlDQW7&j1-wtU(;lwONHa})H3Tbg{{49xx36>X<+MSU}P(u
zj#ArXecwX!a(`j!uCNc1c_@bA+RAKjTOj>uTiw}X+e4w&heF+NM!G+-&~3aE_wai+
zmT3;GeYe=MA;h{N#Jw&qILO^YAwA<Z3hA#gn#1y#+Rfg*G}y^3J?mL|?z89W1qYQV
zJQULBZ=;azlt1t0y;l-@O0`aPpEFOhpBb9{NH>LzLb_eJABC-(_H=mJv8BJYzx&VH
zEj2gGpH5o(JYILJng3=teeCS@2lcw+)jv8~Pg|g;`H*C`_BKX&s+<&6fz3w6MCXj0
z6!o~o<lL;H?3@DUPL4x|dpkNKChFSMZ&h`1qH~TaTdnEtjN8#!vr%e>Ix8jd-8v4I
zsJ(%-8)W1Z2DQ`n*W8ME<KHc3s|!^rszQ~fZ%$EGR<XC^8wb<fFz-3oAN9ZUV5+?L
z90|q$?J!Z&Tm5hE>78fw-Gjcj%inkk?;950J&V8U^*5df2BCKk{ks0v!BVqwRfPfm
z+AaQkJ4L>3_-_}V1Kqnve52v5L;l76`#*iwe~hGmaX{TOqIoax9`b$fQFBO?-+qU>
zM>t=tD$LE-JVg_ovoezMRr%w!PhZ}6RepZ%Sncu0sPhXla&xp*zji*pKK{;{XH7cv
u8;$-x{yu)r#WEXZa#2dEBU>E(HQNOF`1;zGYi8f~zGT|(+i{xzNc$hN;qGMs

literal 0
HcmV?d00001

diff --git a/python/cugraph-pyg/cugraph_pyg/batch=00006.00000000-00006.00000001.parquet b/python/cugraph-pyg/cugraph_pyg/batch=00006.00000000-00006.00000001.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..84fa5ecf44c427eb57ced9fa8b8b436626ae473c
GIT binary patch
literal 15857
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
C9s-d7

literal 0
HcmV?d00001

diff --git a/python/cugraph-pyg/cugraph_pyg/batch=00006.00000002-00006.00000003.parquet b/python/cugraph-pyg/cugraph_pyg/batch=00006.00000002-00006.00000003.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..79eb113837b9eb9f07e4ed3a860cbd846fcfeb57
GIT binary patch
literal 11648
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

literal 0
HcmV?d00001

diff --git a/python/cugraph-pyg/cugraph_pyg/batch=00007.00000000-00007.00000001.parquet b/python/cugraph-pyg/cugraph_pyg/batch=00007.00000000-00007.00000001.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..c339f26bba917fec6672f5f215326994edc62aa8
GIT binary patch
literal 15724
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
a#@52pQg@+bmGr}3QK@8KIaKohS^p1+w)<`X

literal 0
HcmV?d00001

diff --git a/python/cugraph-pyg/cugraph_pyg/batch=00007.00000002-00007.00000003.parquet b/python/cugraph-pyg/cugraph_pyg/batch=00007.00000002-00007.00000003.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..269856a705bf7b7ab8ad742d808274d2879c669d
GIT binary patch
literal 11598
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
ZJUl(^3iPk&SN<q=>wozT)BiuI{|jsCL9+k=

literal 0
HcmV?d00001


From 71ea76e929d9f82c1c2e65d69303cfb479bacd3a Mon Sep 17 00:00:00 2001
From: Alexandria Barghi <abarghi@nvidia.com>
Date: Mon, 15 Apr 2024 10:41:54 -0700
Subject: [PATCH 32/33] remove parquet files

---
 .../batch=00000.00000000-00000.00000001.parquet | Bin 15730 -> 0 bytes
 .../batch=00000.00000002-00000.00000003.parquet | Bin 11472 -> 0 bytes
 .../batch=00001.00000000-00001.00000001.parquet | Bin 15534 -> 0 bytes
 .../batch=00001.00000002-00001.00000003.parquet | Bin 11531 -> 0 bytes
 .../batch=00002.00000000-00002.00000001.parquet | Bin 15474 -> 0 bytes
 .../batch=00002.00000002-00002.00000003.parquet | Bin 11590 -> 0 bytes
 .../batch=00003.00000000-00003.00000001.parquet | Bin 15867 -> 0 bytes
 .../batch=00003.00000002-00003.00000003.parquet | Bin 11235 -> 0 bytes
 .../batch=00004.00000000-00004.00000001.parquet | Bin 15748 -> 0 bytes
 .../batch=00004.00000002-00004.00000003.parquet | Bin 11540 -> 0 bytes
 .../batch=00005.00000000-00005.00000001.parquet | Bin 15585 -> 0 bytes
 .../batch=00005.00000002-00005.00000003.parquet | Bin 11085 -> 0 bytes
 .../batch=00006.00000000-00006.00000001.parquet | Bin 15857 -> 0 bytes
 .../batch=00006.00000002-00006.00000003.parquet | Bin 11648 -> 0 bytes
 .../batch=00007.00000000-00007.00000001.parquet | Bin 15724 -> 0 bytes
 .../batch=00007.00000002-00007.00000003.parquet | Bin 11598 -> 0 bytes
 16 files changed, 0 insertions(+), 0 deletions(-)
 delete mode 100644 python/cugraph-pyg/cugraph_pyg/batch=00000.00000000-00000.00000001.parquet
 delete mode 100644 python/cugraph-pyg/cugraph_pyg/batch=00000.00000002-00000.00000003.parquet
 delete mode 100644 python/cugraph-pyg/cugraph_pyg/batch=00001.00000000-00001.00000001.parquet
 delete mode 100644 python/cugraph-pyg/cugraph_pyg/batch=00001.00000002-00001.00000003.parquet
 delete mode 100644 python/cugraph-pyg/cugraph_pyg/batch=00002.00000000-00002.00000001.parquet
 delete mode 100644 python/cugraph-pyg/cugraph_pyg/batch=00002.00000002-00002.00000003.parquet
 delete mode 100644 python/cugraph-pyg/cugraph_pyg/batch=00003.00000000-00003.00000001.parquet
 delete mode 100644 python/cugraph-pyg/cugraph_pyg/batch=00003.00000002-00003.00000003.parquet
 delete mode 100644 python/cugraph-pyg/cugraph_pyg/batch=00004.00000000-00004.00000001.parquet
 delete mode 100644 python/cugraph-pyg/cugraph_pyg/batch=00004.00000002-00004.00000003.parquet
 delete mode 100644 python/cugraph-pyg/cugraph_pyg/batch=00005.00000000-00005.00000001.parquet
 delete mode 100644 python/cugraph-pyg/cugraph_pyg/batch=00005.00000002-00005.00000003.parquet
 delete mode 100644 python/cugraph-pyg/cugraph_pyg/batch=00006.00000000-00006.00000001.parquet
 delete mode 100644 python/cugraph-pyg/cugraph_pyg/batch=00006.00000002-00006.00000003.parquet
 delete mode 100644 python/cugraph-pyg/cugraph_pyg/batch=00007.00000000-00007.00000001.parquet
 delete mode 100644 python/cugraph-pyg/cugraph_pyg/batch=00007.00000002-00007.00000003.parquet

diff --git a/python/cugraph-pyg/cugraph_pyg/batch=00000.00000000-00000.00000001.parquet b/python/cugraph-pyg/cugraph_pyg/batch=00000.00000000-00000.00000001.parquet
deleted file mode 100644
index 33511421c24cf9ec0fc396e42e594454758a59c8..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 15730
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

diff --git a/python/cugraph-pyg/cugraph_pyg/batch=00000.00000002-00000.00000003.parquet b/python/cugraph-pyg/cugraph_pyg/batch=00000.00000002-00000.00000003.parquet
deleted file mode 100644
index 2496cfcc3e0c89b5aeed8bffc60bbcb245f73f15..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 11472
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

diff --git a/python/cugraph-pyg/cugraph_pyg/batch=00001.00000000-00001.00000001.parquet b/python/cugraph-pyg/cugraph_pyg/batch=00001.00000000-00001.00000001.parquet
deleted file mode 100644
index d6290c1f4253354f2be030562df62ce7460311cb..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 15534
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
YJ9~S>Inve8H-ALs(*2m9^nWV<54QTr=l}o!

diff --git a/python/cugraph-pyg/cugraph_pyg/batch=00001.00000002-00001.00000003.parquet b/python/cugraph-pyg/cugraph_pyg/batch=00001.00000002-00001.00000003.parquet
deleted file mode 100644
index e61e92d23ac9711c70da30ada9025a37af1d128a..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 11531
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
PAH@OvW*|cUzd`>8k;p9y

diff --git a/python/cugraph-pyg/cugraph_pyg/batch=00002.00000000-00002.00000001.parquet b/python/cugraph-pyg/cugraph_pyg/batch=00002.00000000-00002.00000001.parquet
deleted file mode 100644
index cef6b4a74dd2fb63841831e06f86de813e4c08de..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 15474
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

diff --git a/python/cugraph-pyg/cugraph_pyg/batch=00002.00000002-00002.00000003.parquet b/python/cugraph-pyg/cugraph_pyg/batch=00002.00000002-00002.00000003.parquet
deleted file mode 100644
index 56f2664132148ce2e74ef3f06be65c92a9833f13..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 11590
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
b9}^SRxN%^~R``}*j(6R^)c0`zKdAo$s`p0)

diff --git a/python/cugraph-pyg/cugraph_pyg/batch=00003.00000000-00003.00000001.parquet b/python/cugraph-pyg/cugraph_pyg/batch=00003.00000000-00003.00000001.parquet
deleted file mode 100644
index dd64920dc1e7f32439a922f9632ca40884ea9c16..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 15867
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
AdjJ3c

diff --git a/python/cugraph-pyg/cugraph_pyg/batch=00003.00000002-00003.00000003.parquet b/python/cugraph-pyg/cugraph_pyg/batch=00003.00000002-00003.00000003.parquet
deleted file mode 100644
index e15e83be3712e52e97006e714c7f2f22ae8d5df9..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 11235
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

diff --git a/python/cugraph-pyg/cugraph_pyg/batch=00004.00000000-00004.00000001.parquet b/python/cugraph-pyg/cugraph_pyg/batch=00004.00000000-00004.00000001.parquet
deleted file mode 100644
index 8c0cee03ea57da2be2ce74e6c67c954237e79e40..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 15748
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

diff --git a/python/cugraph-pyg/cugraph_pyg/batch=00004.00000002-00004.00000003.parquet b/python/cugraph-pyg/cugraph_pyg/batch=00004.00000002-00004.00000003.parquet
deleted file mode 100644
index 6a7c93e9ab5225cbeeee803f237cc2fa7c88ee2a..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 11540
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
Hf9U@L9s4hU

diff --git a/python/cugraph-pyg/cugraph_pyg/batch=00005.00000000-00005.00000001.parquet b/python/cugraph-pyg/cugraph_pyg/batch=00005.00000000-00005.00000001.parquet
deleted file mode 100644
index b50bd6027818990f02c8826cd7da2b0ce6b94265..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 15585
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
OQK@7<)?4zQoBszy9mWy>

diff --git a/python/cugraph-pyg/cugraph_pyg/batch=00005.00000002-00005.00000003.parquet b/python/cugraph-pyg/cugraph_pyg/batch=00005.00000002-00005.00000003.parquet
deleted file mode 100644
index 5bea4f3fff31c91575cb46c5cb774175954ecf1b..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 11085
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

diff --git a/python/cugraph-pyg/cugraph_pyg/batch=00006.00000000-00006.00000001.parquet b/python/cugraph-pyg/cugraph_pyg/batch=00006.00000000-00006.00000001.parquet
deleted file mode 100644
index 84fa5ecf44c427eb57ced9fa8b8b436626ae473c..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 15857
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
C9s-d7

diff --git a/python/cugraph-pyg/cugraph_pyg/batch=00006.00000002-00006.00000003.parquet b/python/cugraph-pyg/cugraph_pyg/batch=00006.00000002-00006.00000003.parquet
deleted file mode 100644
index 79eb113837b9eb9f07e4ed3a860cbd846fcfeb57..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 11648
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

diff --git a/python/cugraph-pyg/cugraph_pyg/batch=00007.00000000-00007.00000001.parquet b/python/cugraph-pyg/cugraph_pyg/batch=00007.00000000-00007.00000001.parquet
deleted file mode 100644
index c339f26bba917fec6672f5f215326994edc62aa8..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 15724
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
a#@52pQg@+bmGr}3QK@8KIaKohS^p1+w)<`X

diff --git a/python/cugraph-pyg/cugraph_pyg/batch=00007.00000002-00007.00000003.parquet b/python/cugraph-pyg/cugraph_pyg/batch=00007.00000002-00007.00000003.parquet
deleted file mode 100644
index 269856a705bf7b7ab8ad742d808274d2879c669d..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 11598
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
ZJUl(^3iPk&SN<q=>wozT)BiuI{|jsCL9+k=


From dd9ed2d3eccdda6e5e66469775beda74f6a11d3a Mon Sep 17 00:00:00 2001
From: Alexandria Barghi <abarghi@nvidia.com>
Date: Mon, 15 Apr 2024 10:43:26 -0700
Subject: [PATCH 33/33] yes || true in other script

---
 ci/test_wheel_cugraph-pyg.sh | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/ci/test_wheel_cugraph-pyg.sh b/ci/test_wheel_cugraph-pyg.sh
index 29f5c466837..e98bf4ab56b 100755
--- a/ci/test_wheel_cugraph-pyg.sh
+++ b/ci/test_wheel_cugraph-pyg.sh
@@ -52,6 +52,6 @@ python -m pytest \
 # Test examples
 for e in "$(pwd)"/examples/*.py; do
   rapids-logger "running example $e"
-  yes | python $e
+  (yes || true) | python $e
 done
 popd