Resolve inconsistencies in algorithms that do not support self-loops & multi-edges. (rapidsai#5109)

Core number, K-Core, K-Truss, Triangle Count, and Edge Triangle Count do not support graphs with self-loops and multi-edges.

But they have been inconsistent in handling graphs with self-loops and multi-edges.

Core number throws an exception if the input graph has a self-loop but other algorithms ignores (by edge masking) self-loops in computing.

Most algorithms throws an exception if the input graph is a multi-graph but edge triangle count does not check for this.

In C++ tests, some tests include graphs with self-loops but some tests don't (drop_self_loops is set to true in graph generation).

We can simply check whether the input graph is a multi graph or not by just calling is_multigraph() (even though this does not necessarily mean the input graph actually has multi-edges) and this PR updates cugraph to consistently throw an exception if graph_view.is_multigraph() returns true.

Regarding self-loops, we mask out self-loops if count_self_loops() returns a non-zero value.

In C++ tests, we consistently set drop_self_loops to false; so we can test input graphs with self-loops.

Marked as breaking as some functions' expected behavior changes (e.g. core_number no longer throws an exception if the input graph has self-loops).

Authors:
  - Seunghwa Kang (https://github.com/seunghwak)

Approvers:
  - Chuck Hastings (https://github.com/ChuckHastings)
  - Joseph Nke (https://github.com/jnke2016)

URL: rapidsai#5109

Author: seunghwak

cpp/include/cugraph/algorithms.hpp

@@ -436,7 +436,6 @@ enum class cugraph_cc_t {
  * @ingroup components_cpp
  * @brief      Compute connected components.
  *
- * The weak version (for undirected graphs, only) was imported from cuML.
  * This implementation comes from [1] and solves component labeling problem in
  * parallel on CSR-indexes based upon the vertex degree and adjacency graph.
  *
@@ -1782,8 +1781,8 @@ enum class k_core_degree_type_t { IN = 0, OUT = 1, INOUT = 2 };
 .* @ingroup core_cpp
  * @brief   Compute core numbers of individual vertices from K-Core decomposition.
  *
- * The input graph should not have self-loops nor multi-edges. Currently, only undirected graphs are
- * supported.
+ * This algorithms does not support multi-graphs. Self-loops are excluded in computing core
+nuumbers.
  *
  * @tparam vertex_t Type of vertex identifiers. Needs to be an integral type.
  * @tparam edge_t Type of edge identifiers. Needs to be an integral type.
@@ -1814,7 +1813,9 @@ void core_number(raft::handle_t const& handle,
 .* @ingroup core_cpp
  * @brief   Extract K-Core of a graph
  *
- * @throws     cugraph::logic_error when an error occurs.
+ * This function internally calls core_number (if @p core_numbers.has_value() is false). core_number
+does not support multi-graphs. Self-loops are excluded in computing core nuumbers. Note that the
+extracted K-Core can still include self-loops.
  *
  * @tparam vertex_t Type of vertex identifiers. Needs to be an integral type.
  * @tparam edge_t Type of edge identifiers. Needs to be an integral type.
@@ -1851,6 +1852,9 @@ k_core(raft::handle_t const& handle,
  * Compute triangle counts for the entire set of vertices (if @p vertices is std::nullopt) or the
  * given vertices (@p vertices.has_value() is true).
  *
+ * This algorithms does not support multi-graphs. Self-loops are excluded in computing triangle
+ * counts.
+ *
  * @tparam vertex_t Type of vertex identifiers. Needs to be an integral type.
  * @tparam edge_t Type of edge identifiers. Needs to be an integral type.
  * @tparam multi_gpu Flag indicating whether template instantiation should target single-GPU (false)
@@ -1876,6 +1880,9 @@ void triangle_count(raft::handle_t const& handle,
  * @brief Compute edge triangle counts.
  *
  * Compute edge triangle counts for the entire set of edges.
+ *
+ * This algorithms does not support multi-graphs. Self-loops are excluded in computing edge triangle
+counts (they will have a triangle count of 0).
  *
  * @tparam vertex_t Type of vertex identifiers. Needs to be an integral type.
  * @tparam edge_t Type of edge identifiers. Needs to be an integral type.
@@ -1900,6 +1907,8 @@ edge_property_t<edge_t, edge_t> edge_triangle_count(
  *
  * Extract the K-Truss subgraph of a graph
  *
+ * This algorithms does not support multi-graphs. Self-loops are excluded in computing K-Truss.
+ *
  * @tparam vertex_t Type of vertex identifiers. Needs to be an integral type.
  * @tparam edge_t Type of edge identifiers. Needs to be an integral type.
  * @tparam multi_gpu Flag indicating whether template instantiation should target single-GPU (false)

cpp/src/community/edge_triangle_count_impl.cuh

@@ -18,6 +18,7 @@
 
 #include "detail/graph_partition_utils.cuh"
 #include "prims/edge_bucket.cuh"
+#include "prims/fill_edge_property.cuh"
 #include "prims/per_v_pair_dst_nbr_intersection.cuh"
 #include "prims/transform_e.cuh"
 
@@ -130,11 +131,37 @@ edge_property_t<edge_t, edge_t> edge_triangle_count_impl(
   bool do_expensive_check)
 {
   using weight_t = float;
+
+  CUGRAPH_EXPECTS(
+    !graph_view.is_multigraph(),
+    "Invalid input argument: edge triangle count currently does not support multi-graphs.");
+
+  // Exclude self-loops
+
+  std::optional<cugraph::edge_property_t<edge_t, bool>> self_loop_edge_mask{std::nullopt};
+  auto cur_graph_view = graph_view;
+  if (cur_graph_view.count_self_loops(handle) > edge_t{0}) {
+    self_loop_edge_mask = cugraph::edge_property_t<edge_t, bool>(handle, cur_graph_view);
+    if (cur_graph_view.has_edge_mask()) { cur_graph_view.clear_edge_mask(); }
+    cugraph::fill_edge_property(handle, cur_graph_view, self_loop_edge_mask->mutable_view(), false);
+
+    transform_e(handle,
+                graph_view,
+                edge_src_dummy_property_t{}.view(),
+                edge_dst_dummy_property_t{}.view(),
+                edge_dummy_property_t{}.view(),
+                cuda::proclaim_return_type<bool>(
+                  [] __device__(auto src, auto dst, auto, auto, auto) { return src != dst; }),
+                self_loop_edge_mask->mutable_view());
+
+    cur_graph_view.attach_edge_mask(self_loop_edge_mask->view());
+  }
+
   rmm::device_uvector<vertex_t> edgelist_srcs(0, handle.get_stream());
   rmm::device_uvector<vertex_t> edgelist_dsts(0, handle.get_stream());
   std::tie(edgelist_srcs, edgelist_dsts, std::ignore, std::ignore, std::ignore) =
     decompress_to_edgelist<vertex_t, edge_t, weight_t, int32_t>(
-      handle, graph_view, std::nullopt, std::nullopt, std::nullopt, std::nullopt);
+      handle, cur_graph_view, std::nullopt, std::nullopt, std::nullopt, std::nullopt);
 
   auto edge_first = thrust::make_zip_iterator(edgelist_srcs.begin(), edgelist_dsts.begin());
 
@@ -162,7 +189,7 @@ edge_property_t<edge_t, edge_t> edge_triangle_count_impl(
     // Perform 'nbr_intersection' in chunks to reduce peak memory.
     auto [intersection_offsets, intersection_indices] =
       per_v_pair_dst_nbr_intersection(handle,
-                                      graph_view,
+                                      cur_graph_view,
                                       edge_first + prev_chunk_size,
                                       edge_first + prev_chunk_size + chunk_size,
                                       do_expensive_check);
@@ -272,7 +299,7 @@ edge_property_t<edge_t, edge_t> edge_triangle_count_impl(
           std::nullopt,
           std::nullopt,
           std::nullopt,
-          graph_view.vertex_partition_range_lasts());
+          cur_graph_view.vertex_partition_range_lasts());
 
       thrust::for_each(
         handle.get_thrust_policy(),
@@ -335,16 +362,19 @@ edge_property_t<edge_t, edge_t> edge_triangle_count_impl(
     prev_chunk_size += chunk_size;
   }
 
-  cugraph::edge_property_t<edge_t, edge_t> counts(handle, graph_view);
+  cugraph::edge_property_t<edge_t, edge_t> counts(handle, cur_graph_view);
+  {
+    auto unmasked_graph_view = cur_graph_view;
+    if (unmasked_graph_view.has_edge_mask()) { unmasked_graph_view.clear_edge_mask(); }
+    cugraph::fill_edge_property(handle, unmasked_graph_view, counts.mutable_view(), edge_t{0});
+  }
 
   cugraph::edge_bucket_t<vertex_t, void, true, multi_gpu, true> valid_edges(handle);
   valid_edges.insert(edgelist_srcs.begin(), edgelist_srcs.end(), edgelist_dsts.begin());
 
-  auto cur_graph_view = graph_view;
-
   cugraph::transform_e(
     handle,
-    graph_view,
+    cur_graph_view,
     valid_edges,
     cugraph::edge_src_dummy_property_t{}.view(),
     cugraph::edge_dst_dummy_property_t{}.view(),

cpp/src/community/triangle_count_impl.cuh

@@ -358,19 +358,19 @@ void triangle_count(raft::handle_t const& handle,
 
   // 3. Exclude self-loops
 
-  {
+  if (cur_graph_view.count_self_loops(handle) > edge_t{0}) {
     cugraph::edge_property_t<edge_t, bool> self_loop_edge_mask(handle, cur_graph_view);
     cugraph::fill_edge_property(
       handle, unmasked_cur_graph_view, self_loop_edge_mask.mutable_view(), false);
 
-    transform_e(
-      handle,
-      cur_graph_view,
-      edge_src_dummy_property_t{}.view(),
-      edge_dst_dummy_property_t{}.view(),
-      edge_dummy_property_t{}.view(),
-      [] __device__(auto src, auto dst, auto, auto, auto) { return src != dst; },
-      self_loop_edge_mask.mutable_view());
+    transform_e(handle,
+                cur_graph_view,
+                edge_src_dummy_property_t{}.view(),
+                edge_dst_dummy_property_t{}.view(),
+                edge_dummy_property_t{}.view(),
+                cuda::proclaim_return_type<bool>(
+                  [] __device__(auto src, auto dst, auto, auto, auto) { return src != dst; }),
+                self_loop_edge_mask.mutable_view());
 
     edge_mask = std::move(self_loop_edge_mask);
     if (cur_graph_view.has_edge_mask()) { cur_graph_view.clear_edge_mask(); }