support heterogenous fanout type

cpp/CMakeLists.txt

@@ -188,6 +188,7 @@ set(CUGRAPH_SOURCES
  src/detail/groupby_and_count_mg_v64_e64.cu
  src/detail/collect_comm_wrapper_mg_v32_e32.cu
  src/detail/collect_comm_wrapper_mg_v64_e64.cu
+ src/sampling/detail/conversion_utilities.cu
  src/sampling/random_walks_mg_v64_e64.cu
  src/sampling/random_walks_mg_v32_e32.cu
  src/sampling/random_walks_mg_v32_e64.cu
@@ -326,12 +327,12 @@ set(CUGRAPH_SOURCES
  src/sampling/detail/shuffle_and_organize_output_mg_v64_e64.cu
  src/sampling/detail/shuffle_and_organize_output_mg_v32_e32.cu
  src/sampling/detail/shuffle_and_organize_output_mg_v32_e64.cu
- src/sampling/neighbor_sampling_mg_v32_e64.cpp
- src/sampling/neighbor_sampling_mg_v32_e32.cpp
- src/sampling/neighbor_sampling_mg_v64_e64.cpp
- src/sampling/neighbor_sampling_sg_v32_e64.cpp
- src/sampling/neighbor_sampling_sg_v32_e32.cpp
- src/sampling/neighbor_sampling_sg_v64_e64.cpp
+ src/sampling/neighbor_sampling_mg_v32_e64.cu
+ src/sampling/neighbor_sampling_mg_v32_e32.cu
+ src/sampling/neighbor_sampling_mg_v64_e64.cu
+ src/sampling/neighbor_sampling_sg_v32_e64.cu
+ src/sampling/neighbor_sampling_sg_v32_e32.cu
+ src/sampling/neighbor_sampling_sg_v64_e64.cu
  src/sampling/negative_sampling_sg_v32_e64.cu
  src/sampling/negative_sampling_sg_v32_e32.cu
  src/sampling/negative_sampling_sg_v64_e64.cu

cpp/include/cugraph/detail/shuffle_wrappers.hpp

@@ -142,6 +142,29 @@ shuffle_ext_vertex_value_pairs_to_local_gpu_by_vertex_partitioning(
  rmm::device_uvector<vertex_t>&& vertices,
  rmm::device_uvector<value_t>&& values);
 
+/**
+ * @brief Shuffle external (i.e. before renumbering) vertex & values pairs to their local GPU based
+ * on vertex partitioning.
+ *
+ * @tparam vertex_t Type of vertex identifiers. Needs to be an integral type.
+ * @tparam value_t Type of values.
+ *
+ * @param[in] handle RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator,
+ * and handles to various CUDA libraries) to run graph algorithms.
+ * @param[in] vertices Vertices to shuffle.
+ * @param[in] values_0 First values to shuffle.
+ * @param[in] values_1 Second values to shuffle.
+ *
+ * @return Tuple of vectors storing shuffled vertex & value pairs.
+ */
+template <typename vertex_t, typename value0_t, typename value1_t>
+std::tuple<rmm::device_uvector<vertex_t>, rmm::device_uvector<value0_t>, rmm::device_uvector<value1_t>>
+shuffle_ext_vertex_values_pairs_to_local_gpu_by_vertex_partitioning(
+ raft::handle_t const& handle,
+ rmm::device_uvector<vertex_t>&& vertices,
+ rmm::device_uvector<value0_t>&& values_0,
+ rmm::device_uvector<value1_t>&& values_1);
+
 /**
  * @brief Permute a range.
  *

cpp/include/cugraph/detail/utility_wrappers.hpp

@@ -65,6 +65,22 @@ void uniform_random_fill(rmm::cuda_stream_view const& stream_view,
 template <typename value_t>
 void scalar_fill(raft::handle_t const& handle, value_t* d_value, size_t size, value_t value);
 
+
+/**
+ * @brief Increment the values of a buffer by a constant value
+ *
+ * @tparam value_t type of the value to operate on
+ *
+ * @param [in] handle RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator,
+ * and handles to various CUDA libraries) to run graph algorithms.
+ * @param[out] d_value device array to update
+ * @param[in] size number of elements in array
+ * @param[in] value value to be added to each element of the buffer
+ *
+ */
+template <typename value_t>
+void transform_increment(raft::handle_t const& handle, value_t* d_value, size_t size, size_t value);
+
 /**
  * @brief Fill a buffer with a sequence of values
  *

cpp/src/c_api/array.hpp

@@ -125,6 +125,27 @@ struct cugraph_type_erased_host_array_t {
  std::copy(vec.begin(), vec.end(), reinterpret_cast<T*>(data_.get()));
  }
 
+ cugraph_type_erased_host_array_t(cugraph_type_erased_host_array_view_t const* view_p)
+ : data_(std::make_unique<std::byte[]>(view_p->num_bytes_)),
+ size_(view_p->size_),
+ num_bytes_(view_p->num_bytes_),
+ type_(view_p->type_)
+ {
+ std::copy(view_p->data_, view_p->data_ + num_bytes_, data_.get());
+ }
+
+ template <typename T>
+ T* as_type()
+ {
+ return reinterpret_cast<T*>(data_.get());
+ }
+
+ template <typename T>
+ T const* as_type() const
+ {
+ return reinterpret_cast<T const*>(data_.get());
+ }
+
  auto view()
  {
  return new cugraph_type_erased_host_array_view_t{data_.get(), size_, num_bytes_, type_};

cpp/src/c_api/graph_functions.cpp

@@ -84,7 +84,7 @@ struct create_vertex_pairs_functor : public cugraph::c_api::abstract_functor {
  std::nullopt,
  std::nullopt);
  }
-
+ // FIXME: use std::tuple (template) instead.
  result_ = new cugraph::c_api::cugraph_vertex_pairs_t{
  new cugraph::c_api::cugraph_type_erased_device_array_t(first_copy, graph_->vertex_type_),
  new cugraph::c_api::cugraph_type_erased_device_array_t(second_copy, graph_->vertex_type_)};