Add degrees to C API

cpp/CMakeLists.txt

@@ -411,6 +411,8 @@ endif()
 add_library(cugraph_c
         src/c_api/resource_handle.cpp
         src/c_api/array.cpp
+        src/c_api/degrees.cpp
+        src/c_api/degrees_result.cpp
         src/c_api/error.cpp
         src/c_api/graph_sg.cpp
         src/c_api/graph_mg.cpp

cpp/include/cugraph_c/graph_functions.h

@@ -1,5 +1,5 @@
 /*
- * 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.
@@ -229,6 +229,70 @@ cugraph_error_code_t cugraph_allgather(const cugraph_resource_handle_t* handle,
                                        cugraph_induced_subgraph_result_t** result,
                                        cugraph_error_t** error);
 
+/**
+ * @brief       Opaque degree result type
+ */
+typedef struct {
+  int32_t align_;
+} cugraph_degrees_result_t;
+
+/**
+ * @brief      Compute degrees
+ *
+ * Compute the degrees for the vertices in the graph.
+ *
+ * @param [in]  handle              Handle for accessing resources.
+ * @param [in]  graph               Pointer to graph
+ * @param [in]  do_expensive_check  A flag to run expensive checks for input arguments (if set to
+ * true)
+ * @param [out] result              Opaque pointer to gathered edgelist result
+ * @param [out] error               Pointer to an error object storing details of any error.  Will
+ *                                  be populated if error code is not CUGRAPH_SUCCESS
+ * @return error code
+ */
+cugraph_error_code_t cugraph_degrees(const cugraph_resource_handle_t* handle,
+                                     cugraph_graph_t* graph,
+                                     bool_t do_expensive_check,
+                                     cugraph_degrees_result_t** result,
+                                     cugraph_error_t** error);
+
+/**
+ * @brief       Get the vertex ids
+ *
+ * @param [in]     degrees_result   Opaque pointer to degree result
+ * @return type erased array view of vertex ids
+ */
+cugraph_type_erased_device_array_view_t* cugraph_degrees_result_get_vertices(
+  cugraph_degrees_result_t* degrees_result);
+
+/**
+ * @brief       Get the in degrees
+ *
+ * @param [in]     degrees_result   Opaque pointer to degree result
+ * @return type erased array view of vertex ids
+ */
+cugraph_type_erased_device_array_view_t* cugraph_degrees_result_get_in_degrees(
+  cugraph_degrees_result_t* degrees_result);
+
+/**
+ * @brief       Get the out degrees
+ *
+ * If the graph is symmetric, in degrees and out degrees will be equal (and
+ * will be stored in the same memory).
+ *
+ * @param [in]     degrees_result   Opaque pointer to degree result
+ * @return type erased array view of vertex ids
+ */
+cugraph_type_erased_device_array_view_t* cugraph_degrees_result_get_out_degrees(
+  cugraph_degrees_result_t* degrees_result);
+
+/**
+ * @brief     Free degree result
+ *
+ * @param [in]    degrees_result   Opaque pointer to degree result
+ */
+void cugraph_degrees_result_free(cugraph_degrees_result_t* degrees_result);
+
 #ifdef __cplusplus
 }
 #endif

cpp/src/c_api/degrees.cpp

@@ -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.
+ */
+
+#include <cugraph_c/algorithms.h>
+
+#include <cugraph/algorithms.hpp>
+#include <cugraph/detail/utility_wrappers.hpp>
+#include <cugraph/graph_functions.hpp>
+
+#include <c_api/abstract_functor.hpp>
+#include <c_api/degrees_result.hpp>
+#include <c_api/graph.hpp>
+#include <c_api/resource_handle.hpp>
+#include <c_api/utils.hpp>
+
+#include <optional>
+
+namespace {
+
+struct degrees_functor : public cugraph::c_api::abstract_functor {
+  raft::handle_t const& handle_;
+  cugraph::c_api::cugraph_graph_t* graph_{};
+  bool do_expensive_check_{};
+  cugraph::c_api::cugraph_degrees_result_t* result_{};
+
+  degrees_functor(cugraph_resource_handle_t const* handle,
+                  cugraph_graph_t* graph,
+                  bool do_expensive_check)
+    : abstract_functor(),
+      handle_(*reinterpret_cast<cugraph::c_api::cugraph_resource_handle_t const*>(handle)->handle_),
+      graph_(reinterpret_cast<cugraph::c_api::cugraph_graph_t*>(graph)),
+      do_expensive_check_(do_expensive_check)
+  {
+  }
+
+  template <typename vertex_t,
+            typename edge_t,
+            typename weight_t,
+            typename edge_type_type_t,
+            bool store_transposed,
+            bool multi_gpu>
+  void operator()()
+  {
+    // FIXME: Think about how to handle SG vice MG
+    if constexpr (!cugraph::is_candidate<vertex_t, edge_t, weight_t>::value) {
+      unsupported();
+    } else {
+      auto graph =
+        reinterpret_cast<cugraph::graph_t<vertex_t, edge_t, store_transposed, multi_gpu>*>(
+          graph_->graph_);
+
+      auto graph_view = graph->view();
+
+      auto number_map = reinterpret_cast<rmm::device_uvector<vertex_t>*>(graph_->number_map_);
+
+      rmm::device_uvector<edge_t> in_degrees(0, handle_.get_stream());
+      rmm::device_uvector<edge_t> out_degrees(0, handle_.get_stream());
+
+      in_degrees = graph_view.compute_in_degrees(handle_);
+      if (!graph_view.is_symmetric()) { out_degrees = graph_view.compute_out_degrees(handle_); }
+
+      rmm::device_uvector<vertex_t> vertex_ids(graph_view.local_vertex_partition_range_size(),
+                                               handle_.get_stream());
+      raft::copy(vertex_ids.data(), number_map->data(), vertex_ids.size(), handle_.get_stream());
+
+      result_ = new cugraph::c_api::cugraph_degrees_result_t{
+        new cugraph::c_api::cugraph_type_erased_device_array_t(vertex_ids, graph_->vertex_type_),
+        new cugraph::c_api::cugraph_type_erased_device_array_t(in_degrees, graph_->edge_type_),
+        graph_view.is_symmetric() ? nullptr
+                                  : new cugraph::c_api::cugraph_type_erased_device_array_t(
+                                      out_degrees, graph_->edge_type_)};
+    }
+  }
+};
+
+}  // namespace
+
+extern "C" cugraph_error_code_t cugraph_degrees(const cugraph_resource_handle_t* handle,
+                                                cugraph_graph_t* graph,
+                                                bool_t do_expensive_check,
+                                                cugraph_degrees_result_t** result,
+                                                cugraph_error_t** error)
+{
+  degrees_functor functor(handle, graph, do_expensive_check);
+
+  return cugraph::c_api::run_algorithm(graph, functor, result, error);
+}

cpp/src/c_api/degrees_result.cpp

@@ -0,0 +1,59 @@
+/*
+ * 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.
+ */
+
+#include "c_api/degrees_result.hpp"
+
+#include <cugraph_c/graph_functions.h>
+
+extern "C" cugraph_type_erased_device_array_view_t* cugraph_degrees_result_get_vertices(
+  cugraph_degrees_result_t* degrees_result)
+{
+  auto internal_pointer =
+    reinterpret_cast<cugraph::c_api::cugraph_degrees_result_t*>(degrees_result);
+  return reinterpret_cast<cugraph_type_erased_device_array_view_t*>(
+    internal_pointer->vertex_ids_->view());
+}
+
+extern "C" cugraph_type_erased_device_array_view_t* cugraph_degrees_result_get_in_degrees(
+  cugraph_degrees_result_t* degrees_result)
+{
+  auto internal_pointer =
+    reinterpret_cast<cugraph::c_api::cugraph_degrees_result_t*>(degrees_result);
+  return reinterpret_cast<cugraph_type_erased_device_array_view_t*>(
+    internal_pointer->in_degrees_->view());
+}
+
+extern "C" cugraph_type_erased_device_array_view_t* cugraph_degrees_result_get_out_degrees(
+  cugraph_degrees_result_t* degrees_result)
+{
+  auto internal_pointer =
+    reinterpret_cast<cugraph::c_api::cugraph_degrees_result_t*>(degrees_result);
+  return internal_pointer->out_degrees_ == nullptr
+           ? reinterpret_cast<cugraph_type_erased_device_array_view_t*>(
+               internal_pointer->in_degrees_->view())
+           : reinterpret_cast<cugraph_type_erased_device_array_view_t*>(
+               internal_pointer->out_degrees_->view());
+}
+
+extern "C" void cugraph_degrees_result_free(cugraph_degrees_result_t* degrees_result)
+{
+  auto internal_pointer =
+    reinterpret_cast<cugraph::c_api::cugraph_degrees_result_t*>(degrees_result);
+  delete internal_pointer->vertex_ids_;
+  delete internal_pointer->in_degrees_;
+  delete internal_pointer->out_degrees_;
+  delete internal_pointer;
+}

cpp/src/c_api/degrees_result.hpp

@@ -0,0 +1,31 @@
+/*
+ * 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.
+ */
+
+#pragma once
+
+#include "c_api/array.hpp"
+
+namespace cugraph {
+namespace c_api {
+
+struct cugraph_degrees_result_t {
+  cugraph_type_erased_device_array_t* vertex_ids_{};
+  cugraph_type_erased_device_array_t* in_degrees_{};
+  cugraph_type_erased_device_array_t* out_degrees_{};
+};
+
+}  // namespace c_api
+}  // namespace cugraph

cpp/tests/CMakeLists.txt

@@ -683,6 +683,7 @@ if(BUILD_CUGRAPH_MG_TESTS)
     ConfigureCTestMG(MG_CAPI_SIMILARITY_TEST c_api/mg_similarity_test.c)
     ConfigureCTestMG(MG_CAPI_K_CORE_TEST c_api/mg_k_core_test.c)
     ConfigureCTestMG(MG_CAPI_INDUCED_SUBGRAPH_TEST c_api/mg_induced_subgraph_test.c)
+    ConfigureCTestMG(MG_CAPI_DEGREES c_api/mg_degrees_test.c)
     ConfigureCTestMG(MG_CAPI_EGONET_TEST c_api/mg_egonet_test.c)
     ConfigureCTestMG(MG_CAPI_TWO_HOP_NEIGHBORS_TEST c_api/mg_two_hop_neighbors_test.c)
 
@@ -750,6 +751,7 @@ ConfigureCTest(CAPI_CORE_NUMBER_TEST c_api/core_number_test.c)
 ConfigureCTest(CAPI_SIMILARITY_TEST c_api/similarity_test.c)
 ConfigureCTest(CAPI_K_CORE_TEST c_api/k_core_test.c)
 ConfigureCTest(CAPI_INDUCED_SUBGRAPH_TEST c_api/induced_subgraph_test.c)
+ConfigureCTest(CAPI_DEGREES c_api/degrees_test.c)
 ConfigureCTest(CAPI_EGONET_TEST c_api/egonet_test.c)
 ConfigureCTest(CAPI_TWO_HOP_NEIGHBORS_TEST c_api/two_hop_neighbors_test.c)
 ConfigureCTest(CAPI_LEGACY_K_TRUSS_TEST c_api/legacy_k_truss_test.c)