forked 0.16 <- release 0.16

.gitignore

@@ -63,6 +63,7 @@ datasets/*
 !datasets/cyber.csv
 !datasets/karate-data.csv
 !datasets/karate_undirected.csv
+!datasets/karate-disjoint.csv
 !datasets/netscience.csv
 
 

CHANGELOG.md

@@ -1,12 +1,15 @@
 # cuGraph 0.16.0 (Date TBD)
 
 ## New Features
+- PR 1098 Add new graph classes to support 2D partitioning
 
 ## Improvements
 - PR 1081 MNMG Renumbering - sort partitions by degree
 - PR 1115 Replace deprecated rmm::mr::get_default_resource with rmm::mr::get_current_device_resource
+- PR #1129 Refactored test to use common dataset and added additional doc pages
 
 ## Bug Fixes
+- PR #1131 Show style checker errors with set +e
 
 # cuGraph 0.15.0 (26 Aug 2020)
 
@@ -100,6 +103,8 @@
 - PR #1087 Updated benchmarks README to better describe how to get plugin, added rapids-pytest-benchmark plugin to conda dev environments
 - PR #1101 Removed unnecessary device-to-host copy which caused a performance regression
 - PR #1106 Added new release.ipynb to notebook test skip list
+- PR #1125 Patch Thrust to workaround `CUDA_CUB_RET_IF_FAIL` macro clearing CUDA errors
+
 
 # cuGraph 0.14.0 (03 Jun 2020)
 

README.md

@@ -6,7 +6,7 @@ The [RAPIDS](https://rapids.ai) cuGraph library is a collection of GPU accelerat
 
  For more project details, see [rapids.ai](https://rapids.ai/).
 
-**NOTE:** For the latest stable [README.md](https://github.com/rapidsai/cudf/blob/main/README.md) ensure you are on the latest branch.
+**NOTE:** For the latest stable [README.md](https://github.com/rapidsai/cugraph/blob/main/README.md) ensure you are on the latest branch.
 
 
 

ci/checks/style.sh

@@ -11,6 +11,9 @@
 # captured for returning a final status code. This allows all style check to
 # take place to provide a more comprehensive list of style violations.
 set -o pipefail
+# CI does `set -e` then sources this file, so we override that so we can output
+# the results from the various style checkers
+set +e
 ERRORCODE=0
 PATH=/conda/bin:$PATH
 

cpp/CMakeLists.txt

@@ -214,6 +214,7 @@ FetchContent_Declare(
     GIT_REPOSITORY https://github.com/thrust/thrust.git
     GIT_TAG        1.9.10
     GIT_SHALLOW    true
+    PATCH_COMMAND COMMAND patch -p1 < "${CMAKE_CURRENT_SOURCE_DIR}/cmake/thrust-ret-if-fail.patch"
 )
 
 FetchContent_GetProperties(thrust)
@@ -356,6 +357,8 @@ add_library(cugraph SHARED
     src/components/connectivity.cu
     src/centrality/katz_centrality.cu
     src/centrality/betweenness_centrality.cu
+    src/experimental/graph.cu
+    src/experimental/graph_view.cu
 )
 
 #

cpp/cmake/thrust-ret-if-fail.patch

@@ -0,0 +1,16 @@
+diff --git a/thrust/system/cuda/detail/core/util.h b/thrust/system/cuda/detail/core/util.h
+index a2c87772..ea4ed640 100644
+--- a/thrust/system/cuda/detail/core/util.h
++++ b/thrust/system/cuda/detail/core/util.h
+@@ -652,7 +652,10 @@ namespace core {
+   }
+
+ #define CUDA_CUB_RET_IF_FAIL(e) \
+-  if (cub::Debug((e), __FILE__, __LINE__)) return e;
++  {                             \
++    auto const error = (e);     \
++    if (cub::Debug(error, __FILE__, __LINE__)) return error; \
++  }
+
+   // uninitialized
+   // -------

cpp/include/experimental/detail/graph_utils.cuh

@@ -0,0 +1,129 @@
+/*
+ * Copyright (c) 2020, 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 <experimental/graph_view.hpp>
+
+#include <rmm/thrust_rmm_allocator.h>
+#include <raft/handle.hpp>
+#include <rmm/device_uvector.hpp>
+
+#include <thrust/sort.h>
+#include <thrust/transform.h>
+
+#include <algorithm>
+#include <vector>
+
+namespace cugraph {
+namespace experimental {
+namespace detail {
+
+// compute the numbers of nonzeros in rows (of the graph adjacency matrix, if store_transposed =
+// false) or columns (of the graph adjacency matrix, if store_transposed = true)
+template <typename vertex_t, typename edge_t>
+rmm::device_uvector<edge_t> compute_major_degree(
+  raft::handle_t const &handle,
+  std::vector<edge_t const *> const &adj_matrix_partition_offsets,
+  partition_t<vertex_t> const &partition)
+{
+  auto &comm_p_row           = handle.get_subcomm(comm_p_row_key);
+  auto const comm_p_row_rank = comm_p_row.get_rank();
+  auto const comm_p_row_size = comm_p_row.get_size();
+  auto &comm_p_col           = handle.get_subcomm(comm_p_col_key);
+  auto const comm_p_col_rank = comm_p_col.get_rank();
+  auto const comm_p_col_size = comm_p_col.get_size();
+
+  rmm::device_uvector<edge_t> local_degrees(0, handle.get_stream());
+  rmm::device_uvector<edge_t> degrees(0, handle.get_stream());
+
+  vertex_t max_num_local_degrees{0};
+  for (int i = 0; i < comm_p_col_size; ++i) {
+    auto vertex_partition_idx =
+      partition.is_hypergraph_partitioned()
+        ? static_cast<size_t>(comm_p_row_size) * static_cast<size_t>(i) +
+            static_cast<size_t>(comm_p_row_rank)
+        : static_cast<size_t>(comm_p_col_size) * static_cast<size_t>(comm_p_row_rank) +
+            static_cast<size_t>(i);
+    vertex_t major_first{};
+    vertex_t major_last{};
+    std::tie(major_first, major_last) = partition.get_vertex_partition_range(vertex_partition_idx);
+    max_num_local_degrees             = std::max(max_num_local_degrees, major_last - major_first);
+    if (i == comm_p_col_rank) { degrees.resize(major_last - major_first, handle.get_stream()); }
+  }
+  local_degrees.resize(max_num_local_degrees, handle.get_stream());
+  for (int i = 0; i < comm_p_col_size; ++i) {
+    auto vertex_partition_idx =
+      partition.is_hypergraph_partitioned()
+        ? static_cast<size_t>(comm_p_row_size) * static_cast<size_t>(i) +
+            static_cast<size_t>(comm_p_row_rank)
+        : static_cast<size_t>(comm_p_col_size) * static_cast<size_t>(comm_p_row_rank) +
+            static_cast<size_t>(i);
+    vertex_t major_first{};
+    vertex_t major_last{};
+    std::tie(major_first, major_last) = partition.get_vertex_partition_range(vertex_partition_idx);
+    auto p_offsets                    = partition.is_hypergraph_partitioned()
+                       ? adj_matrix_partition_offsets[i]
+                       : adj_matrix_partition_offsets[0] +
+                           (major_first - partition.get_vertex_partition_range_first(
+                                            comm_p_col_size * comm_p_row_rank));
+    thrust::transform(rmm::exec_policy(handle.get_stream())->on(handle.get_stream()),
+                      thrust::make_counting_iterator(vertex_t{0}),
+                      thrust::make_counting_iterator(major_last - major_first),
+                      local_degrees.data(),
+                      [p_offsets] __device__(auto i) { return p_offsets[i + 1] - p_offsets[i]; });
+    comm_p_row.reduce(local_degrees.data(),
+                      i == comm_p_col_rank ? degrees.data() : static_cast<edge_t *>(nullptr),
+                      degrees.size(),
+                      raft::comms::op_t::SUM,
+                      comm_p_col_rank,
+                      handle.get_stream());
+  }
+
+  auto status = handle.get_comms().sync_stream(
+    handle.get_stream());  // this is neessary as local_degrees will become out-of-scope once this
+                           // function returns.
+  CUGRAPH_EXPECTS(status == raft::comms::status_t::SUCCESS, "sync_stream() failure.");
+
+  return degrees;
+}
+
+// compute the numbers of nonzeros in rows (of the graph adjacency matrix, if store_transposed =
+// false) or columns (of the graph adjacency matrix, if store_transposed = true)
+template <typename vertex_t, typename edge_t>
+rmm::device_uvector<edge_t> compute_major_degree(
+  raft::handle_t const &handle,
+  std::vector<rmm::device_uvector<edge_t>> const &adj_matrix_partition_offsets,
+  partition_t<vertex_t> const &partition)
+{
+  // we can avoid creating this temporary with "if constexpr" supported from C++17
+  std::vector<edge_t const *> tmp_offsets(adj_matrix_partition_offsets.size(), nullptr);
+  std::transform(adj_matrix_partition_offsets.begin(),
+                 adj_matrix_partition_offsets.end(),
+                 tmp_offsets.begin(),
+                 [](auto const &offsets) { return offsets.data(); });
+  return compute_major_degree(handle, tmp_offsets, partition);
+}
+
+template <typename vertex_t, typename edge_t>
+struct degree_from_offsets_t {
+  edge_t const *offsets{nullptr};
+
+  __device__ edge_t operator()(vertex_t v) { return offsets[v + 1] - offsets[v]; }
+};
+
+}  // namespace detail
+}  // namespace experimental
+}  // namespace cugraph