Add make_initialized_edge_(src|dst_)property utility functions. (#5441)

```
fill_edge_property(handle, graph_view, input)
```

fills the un-maksed edge values to `input`. If we want to fill the entire edge values (both masked and un-masked) with `graph_view` with an attached edge mask, we need to copy a `graph_view` object; clear the edge mask; and call the `fill_edge_property` function with the copy. This is cumbersome and possibly bug inducing.

`make_initialized_edge_property` function is added as a utility function. Here, this factory creates an `edge_property_t` object and fills the entire edge property buffer to the user provided `input` value.

`make_initialized_edge_src|dst_property` functions are added as well for consistency.

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

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

URL: #5441

Author: seunghwak

cpp/src/centrality/betweenness_centrality_impl.cuh

@@ -10,6 +10,7 @@
 #include "prims/extract_transform_if_e.cuh"
 #include "prims/extract_transform_if_v_frontier_outgoing_e.cuh"
 #include "prims/fill_edge_property.cuh"
+#include "prims/make_initialized_edge_property.cuh"
 #include "prims/per_v_transform_reduce_incoming_outgoing_e.cuh"
 #include "prims/transform_e.cuh"
 #include "prims/transform_reduce_if_v_frontier_outgoing_e_by_dst.cuh"
@@ -1502,17 +1503,8 @@ edge_property_t<edge_t, weight_t> edge_betweenness_centrality(
                     "Invalid input argument: sources have invalid vertex IDs.");
   }
 
-  edge_property_t<edge_t, weight_t> centralities(handle, graph_view);
-
-  if (graph_view.has_edge_mask()) {
-    auto unmasked_graph_view = graph_view;
-    unmasked_graph_view.clear_edge_mask();
-    fill_edge_property(
-      handle, unmasked_graph_view, centralities.mutable_view(), weight_t{0}, do_expensive_check);
-  } else {
-    fill_edge_property(
-      handle, graph_view, centralities.mutable_view(), weight_t{0}, do_expensive_check);
-  }
+  auto centralities =
+    make_initialized_edge_property(handle, graph_view, weight_t{0.0}, do_expensive_check);
 
   size_t num_sources = cuda::std::distance(vertices_begin, vertices_end);
   std::vector<size_t> source_offsets{{0, num_sources}};

cpp/src/community/approx_weighted_matching_impl.cuh

@@ -6,6 +6,7 @@
 
 #include "detail/shuffle_wrappers.hpp"
 #include "prims/fill_edge_property.cuh"
+#include "prims/make_initialized_edge_property.cuh"
 #include "prims/reduce_op.cuh"
 #include "prims/transform_e.cuh"
 #include "prims/transform_reduce_e_by_src_dst_key.cuh"
@@ -38,18 +39,10 @@ std::tuple<rmm::device_uvector<vertex_t>, weight_t> approximate_weighted_matchin
                   "need to be symmetric");
 
   auto current_graph_view = graph_view;
-  if (current_graph_view.has_edge_mask()) { current_graph_view.clear_edge_mask(); }
 
-  cugraph::edge_property_t<edge_t, bool> edge_masks_even(handle, current_graph_view);
-  cugraph::fill_edge_property(
-    handle, current_graph_view, edge_masks_even.mutable_view(), bool{false});
-  cugraph::edge_property_t<edge_t, bool> edge_masks_odd(handle, current_graph_view);
-  cugraph::fill_edge_property(
-    handle, current_graph_view, edge_masks_odd.mutable_view(), bool{false});
+  auto edge_masks_even = make_initialized_edge_property(handle, current_graph_view, false);
+  auto edge_masks_odd  = make_initialized_edge_property(handle, current_graph_view, false);
 
-  if (graph_view.has_edge_mask()) {
-    current_graph_view.attach_edge_mask(*(graph_view.edge_mask_view()));
-  }
   // Mask out self-loop
   cugraph::transform_e(
     handle,

cpp/src/community/edge_triangle_count_impl.cuh

@@ -8,6 +8,7 @@
 #include "detail/graph_partition_utils.cuh"
 #include "prims/edge_bucket.cuh"
 #include "prims/fill_edge_property.cuh"
+#include "prims/make_initialized_edge_property.cuh"
 #include "prims/per_v_pair_dst_nbr_intersection.cuh"
 #include "prims/transform_e.cuh"
 
@@ -338,12 +339,7 @@ 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, 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});
-  }
+  auto counts = make_initialized_edge_property(handle, cur_graph_view, edge_t{0});
 
   cugraph::edge_bucket_t<vertex_t, edge_t, true, multi_gpu, true> valid_edges(
     handle, false /* multigraph */);

cpp/src/community/k_truss_impl.cuh

@@ -7,6 +7,7 @@
 #include "prims/edge_bucket.cuh"
 #include "prims/extract_transform_if_e.cuh"
 #include "prims/fill_edge_property.cuh"
+#include "prims/make_initialized_edge_property.cuh"
 #include "prims/per_v_pair_dst_nbr_intersection.cuh"
 #include "prims/transform_e.cuh"
 #include "prims/transform_reduce_dst_nbr_intersection_of_e_endpoints_by_v.cuh"
@@ -179,10 +180,8 @@ k_truss(raft::handle_t const& handle,
 
   // 2. Exclude self-loops and edges that do not belong to (k-1)-core
 
-  auto cur_graph_view          = graph_view;
-  auto unmasked_cur_graph_view = cur_graph_view;
+  auto cur_graph_view = graph_view;
 
-  if (unmasked_cur_graph_view.has_edge_mask()) { unmasked_cur_graph_view.clear_edge_mask(); }
   // mask for self-loops and edges not part of k-1 core
   cugraph::edge_property_t<edge_t, bool> undirected_mask(handle);
   {
@@ -191,9 +190,7 @@ k_truss(raft::handle_t const& handle,
     if (cur_graph_view.count_self_loops(handle) > edge_t{0}) {
       // 2.1. Exclude self-loops
 
-      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);
+      auto self_loop_edge_mask = make_initialized_edge_property(handle, cur_graph_view, false);
 
       transform_e(handle,
                   cur_graph_view,
@@ -238,9 +235,8 @@ k_truss(raft::handle_t const& handle,
                                in_k_minus_1_core_flags.begin(),
                                edge_dst_in_k_minus_1_cores.mutable_view());
 
-      cugraph::edge_property_t<edge_t, bool> in_k_minus_1_core_edge_mask(handle, cur_graph_view);
-      cugraph::fill_edge_property(
-        handle, unmasked_cur_graph_view, in_k_minus_1_core_edge_mask.mutable_view(), false);
+      auto in_k_minus_1_core_edge_mask =
+        make_initialized_edge_property(handle, cur_graph_view, false);
 
       transform_e(
         handle,
@@ -265,17 +261,14 @@ k_truss(raft::handle_t const& handle,
   edge_src_property_t<vertex_t, edge_t> edge_src_out_degrees(handle, cur_graph_view);
   edge_dst_property_t<vertex_t, edge_t> edge_dst_out_degrees(handle, cur_graph_view);
 
-  cugraph::edge_property_t<edge_t, bool> dodg_mask(handle, cur_graph_view);
+  auto dodg_mask = make_initialized_edge_property(handle, cur_graph_view, false);
   {
     auto out_degrees = cur_graph_view.compute_out_degrees(handle);
     update_edge_src_property(
       handle, cur_graph_view, out_degrees.begin(), edge_src_out_degrees.mutable_view());
     update_edge_dst_property(
       handle, cur_graph_view, out_degrees.begin(), edge_dst_out_degrees.mutable_view());
 
-    cugraph::fill_edge_property(
-      handle, unmasked_cur_graph_view, dodg_mask.mutable_view(), bool{false});
-
     cugraph::transform_e(
       handle,
       cur_graph_view,

cpp/src/community/triangle_count_impl.cuh

@@ -7,6 +7,7 @@
 #include "detail/shuffle_wrappers.hpp"
 #include "prims/extract_transform_if_e.cuh"
 #include "prims/fill_edge_property.cuh"
+#include "prims/make_initialized_edge_property.cuh"
 #include "prims/transform_e.cuh"
 #include "prims/transform_reduce_dst_nbr_intersection_of_e_endpoints_by_v.cuh"
 #include "prims/update_edge_src_dst_property.cuh"
@@ -182,18 +183,13 @@ void triangle_count(raft::handle_t const& handle,
 
   auto cur_graph_view = graph_view;
 
-  auto unmasked_cur_graph_view = cur_graph_view;
-  if (unmasked_cur_graph_view.has_edge_mask()) { unmasked_cur_graph_view.clear_edge_mask(); }
-
   // 2. Mask out the edges that has source or destination that cannot be reached from vertices
   // within two hop (if vertices.has_value() is true).
 
   cugraph::edge_property_t<edge_t, bool> edge_mask(handle);
 
   if (vertices) {
-    cugraph::edge_property_t<edge_t, bool> within_two_hop_edge_mask(handle, cur_graph_view);
-    cugraph::fill_edge_property(
-      handle, unmasked_cur_graph_view, within_two_hop_edge_mask.mutable_view(), false);
+    auto within_two_hop_edge_mask = make_initialized_edge_property(handle, cur_graph_view, false);
 
     rmm::device_uvector<vertex_t> unique_vertices((*vertices).size(), handle.get_stream());
     thrust::copy(
@@ -353,9 +349,7 @@ 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);
+    auto self_loop_edge_mask = make_initialized_edge_property(handle, cur_graph_view, false);
 
     transform_e(handle,
                 cur_graph_view,
@@ -374,9 +368,7 @@ void triangle_count(raft::handle_t const& handle,
   // 4. Find 2-core and exclude edges that do not belong to 2-core add masking support).
 
   {
-    cugraph::edge_property_t<edge_t, bool> in_two_core_edge_mask(handle, cur_graph_view);
-    cugraph::fill_edge_property(
-      handle, unmasked_cur_graph_view, in_two_core_edge_mask.mutable_view(), false);
+    auto in_two_core_edge_mask = make_initialized_edge_property(handle, cur_graph_view, false);
 
     rmm::device_uvector<edge_t> core_numbers(cur_graph_view.number_of_vertices(),
                                              handle.get_stream());

cpp/src/components/vertex_coloring_impl.cuh

@@ -1,10 +1,11 @@
 /*
- * SPDX-FileCopyrightText: Copyright (c) 2024-2025, NVIDIA CORPORATION.
+ * SPDX-FileCopyrightText: Copyright (c) 2024-2026, NVIDIA CORPORATION.
  * SPDX-License-Identifier: Apache-2.0
  */
 #pragma once
 
 #include "prims/fill_edge_property.cuh"
+#include "prims/make_initialized_edge_property.cuh"
 #include "prims/transform_e.cuh"
 #include "prims/update_edge_src_dst_property.cuh"
 
@@ -29,13 +30,8 @@ rmm::device_uvector<vertex_t> vertex_coloring(
   graph_view_t current_graph_view(graph_view);
 
   // edge mask
-  cugraph::edge_property_t<edge_t, bool> edge_masks_even(handle, current_graph_view);
-  cugraph::fill_edge_property(
-    handle, current_graph_view, edge_masks_even.mutable_view(), bool{false});
-
-  cugraph::edge_property_t<edge_t, bool> edge_masks_odd(handle, current_graph_view);
-  cugraph::fill_edge_property(
-    handle, current_graph_view, edge_masks_odd.mutable_view(), bool{false});
+  auto edge_masks_even = make_initialized_edge_property(handle, current_graph_view, false);
+  auto edge_masks_odd  = make_initialized_edge_property(handle, current_graph_view, false);
 
   cugraph::transform_e(
     handle,

cpp/src/components/weakly_connected_components_impl.cuh

@@ -6,6 +6,7 @@
 
 #include "prims/fill_edge_property.cuh"
 #include "prims/fill_edge_src_dst_property.cuh"
+#include "prims/make_initialized_edge_property.cuh"
 #include "prims/transform_e.cuh"
 #include "prims/transform_reduce_if_v_frontier_outgoing_e_by_dst.cuh"
 #include "prims/update_edge_src_dst_property.cuh"
@@ -457,15 +458,7 @@ void weakly_connected_components_impl(raft::handle_t const& handle,
         handle, level_graph_view, visited.begin(), edge_src_visited.mutable_view());
       {
         auto tmp_graph_view = level_graph_view;
-        edge_property_t<edge_t, bool> edge_mask(handle, level_graph_view);
-        if (tmp_graph_view.has_edge_mask()) {
-          tmp_graph_view.clear_edge_mask();
-          cugraph::fill_edge_property(handle,
-                                      tmp_graph_view,
-                                      edge_mask.mutable_view(),
-                                      false);  // if level_graph_view has an attached edge mask,
-                                               // masked out values of edge_mask won't be updated.
-        }
+        auto edge_mask      = make_initialized_edge_property(handle, level_graph_view, false);
         transform_e(handle,
                     level_graph_view,
                     edge_src_visited.view(),
@@ -477,6 +470,7 @@ void weakly_connected_components_impl(raft::handle_t const& handle,
                                !src_visited;
                       }),
                     edge_mask.mutable_view());
+        if (tmp_graph_view.has_edge_mask()) { tmp_graph_view.clear_edge_mask(); }
         tmp_graph_view.attach_edge_mask(edge_mask.view());
         std::tie(std::get<0>(edge_buffer),
                  std::get<1>(edge_buffer),

cpp/src/cores/core_number_impl.cuh

@@ -6,6 +6,7 @@
 
 #include "prims/fill_edge_property.cuh"
 #include "prims/fill_edge_src_dst_property.cuh"
+#include "prims/make_initialized_edge_property.cuh"
 #include "prims/reduce_v.cuh"
 #include "prims/transform_e.cuh"
 #include "prims/transform_reduce_if_v_frontier_outgoing_e_by_dst.cuh"
@@ -81,19 +82,16 @@ void core_number(raft::handle_t const& handle,
   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);
-
+    self_loop_edge_mask = make_initialized_edge_property(handle, cur_graph_view, false);
     transform_e(handle,
-                graph_view,
+                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());
-
+    if (cur_graph_view.has_edge_mask()) { cur_graph_view.clear_edge_mask(); }
     cur_graph_view.attach_edge_mask(self_loop_edge_mask->view());
   }
 

cpp/src/prims/make_initialized_edge_property.cuh

@@ -0,0 +1,56 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+#pragma once
+
+#include "prims/fill_edge_property.cuh"
+
+#include <cugraph/edge_property.hpp>
+#include <cugraph/graph_view.hpp>
+
+#include <raft/core/handle.hpp>
+
+namespace cugraph {
+
+/**
+ * @brief Create an edge property and fill the entire buffer with the given value.
+ *
+ * Create an edge property object for @p graph_view and initialize the edge property values to @p
+ * input. Note that the entire edge buffer is initialized to the provided @p
+ * input (ignoring the edge mask if @p graph_view has an attached edge mask); this contrasts
+ * with the fill_edge_property function which only fills the edge values for un-masked edges if @p
+ * graph_view has an attached edge mask.
+ *
+ * @tparam GraphViewType Type of the passed non-owning graph object.
+ * @tparam T Type of the edge property values.
+ * @param handle RAFT handle object to encapsulate resources (e.g. CUDA stream, communicator, and
+ * handles to various CUDA libraries) to run graph algorithms.
+ * @param graph_view Non-owning graph object.
+ * @param input Edge property values will be set to @p input.
+ * @param do_expensive_check A flag to run expensive checks for input arguments (if set to `true`).
+ * @return edge_property_t<typename GraphViewType::edge_type, T> with all entries set to @p input.
+ */
+template <typename GraphViewType, typename T>
+edge_property_t<typename GraphViewType::edge_type, T> make_initialized_edge_property(
+  raft::handle_t const& handle,
+  GraphViewType const& graph_view,
+  T input,
+  bool do_expensive_check = false)
+{
+  using edge_t = typename GraphViewType::edge_type;
+
+  edge_property_t<edge_t, T> edge_prop(handle, graph_view);
+  if (graph_view.has_edge_mask()) {
+    auto graph_view_copy = graph_view;
+    graph_view_copy.clear_edge_mask();
+    fill_edge_property(
+      handle, graph_view_copy, edge_prop.mutable_view(), input, do_expensive_check);
+  } else {
+    fill_edge_property(handle, graph_view, edge_prop.mutable_view(), input, do_expensive_check);
+  }
+
+  return edge_prop;
+}
+
+}  // namespace cugraph