Refactor stream compaction APIs

cpp/CMakeLists.txt

@@ -400,10 +400,12 @@ add_library(
   src/sort/stable_sort_column.cu
   src/sort/stable_sort.cu
   src/stream_compaction/apply_boolean_mask.cu
+  src/stream_compaction/distinct.cu
   src/stream_compaction/distinct_count.cu
-  src/stream_compaction/drop_duplicates.cu
   src/stream_compaction/drop_nans.cu
   src/stream_compaction/drop_nulls.cu
+  src/stream_compaction/unique.cu
+  src/stream_compaction/unique_count.cu
   src/strings/attributes.cu
   src/strings/capitalize.cu
   src/strings/case.cu

cpp/benchmarks/CMakeLists.txt

@@ -144,7 +144,9 @@ ConfigureBench(APPLY_BOOLEAN_MASK_BENCH stream_compaction/apply_boolean_mask.cpp
 
 # ##################################################################################################
 # * stream_compaction benchmark -------------------------------------------------------------------
-ConfigureNVBench(STREAM_COMPACTION_BENCH stream_compaction/drop_duplicates.cpp)
+ConfigureNVBench(
+  STREAM_COMPACTION_BENCH stream_compaction/distinct.cpp stream_compaction/unique.cpp
+)
 
 # ##################################################################################################
 # * join benchmark --------------------------------------------------------------------------------

cpp/benchmarks/stream_compaction/distinct.cpp

@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) 2020-2022, 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 <cudf/column/column_view.hpp>
+#include <cudf/detail/stream_compaction.hpp>
+#include <cudf/types.hpp>
+#include <cudf_test/base_fixture.hpp>
+#include <cudf_test/column_wrapper.hpp>
+
+#include <fixture/rmm_pool_raii.hpp>
+
+#include <nvbench/nvbench.cuh>
+
+#include <memory>
+#include <random>
+
+NVBENCH_DECLARE_TYPE_STRINGS(cudf::timestamp_ms, "cudf::timestamp_ms", "cudf::timestamp_ms");
+
+template <typename Type>
+void nvbench_distinct(nvbench::state& state, nvbench::type_list<Type>)
+{
+  cudf::rmm_pool_raii pool_raii;
+
+  auto const num_rows = state.get_int64("NumRows");
+
+  cudf::test::UniformRandomGenerator<long> rand_gen(0, 100);
+  auto elements = cudf::detail::make_counting_transform_iterator(
+    0, [&rand_gen](auto row) { return rand_gen.generate(); });
+  auto valids =
+    cudf::detail::make_counting_transform_iterator(0, [](auto i) { return i % 100 != 0; });
+  cudf::test::fixed_width_column_wrapper<Type, long> values(elements, elements + num_rows, valids);
+
+  auto input_column = cudf::column_view(values);
+  auto input_table  = cudf::table_view({input_column, input_column, input_column, input_column});
+
+  state.exec(nvbench::exec_tag::sync, [&](nvbench::launch& launch) {
+    rmm::cuda_stream_view stream_view{launch.get_stream()};
+    auto result = cudf::detail::distinct(input_table, {0}, cudf::null_equality::EQUAL, stream_view);
+  });
+}
+
+using data_type = nvbench::type_list<bool, int8_t, int32_t, int64_t, float, cudf::timestamp_ms>;
+
+NVBENCH_BENCH_TYPES(nvbench_distinct, NVBENCH_TYPE_AXES(data_type))
+  .set_name("distinct")
+  .set_type_axes_names({"Type"})
+  .add_int64_axis("NumRows", {10'000, 100'000, 1'000'000, 10'000'000});

cpp/benchmarks/stream_compaction/drop_duplicates.cpp → cpp/benchmarks/stream_compaction/unique.cpp

@@ -47,8 +47,7 @@ NVBENCH_DECLARE_ENUM_TYPE_STRINGS(
 NVBENCH_DECLARE_TYPE_STRINGS(cudf::timestamp_ms, "cudf::timestamp_ms", "cudf::timestamp_ms");
 
 template <typename Type, cudf::duplicate_keep_option Keep>
-void nvbench_drop_duplicates(nvbench::state& state,
-                             nvbench::type_list<Type, nvbench::enum_type<Keep>>)
+void nvbench_unique(nvbench::state& state, nvbench::type_list<Type, nvbench::enum_type<Keep>>)
 {
   if constexpr (not std::is_same_v<Type, int32_t> and
                 Keep != cudf::duplicate_keep_option::KEEP_FIRST) {
@@ -62,41 +61,17 @@ void nvbench_drop_duplicates(nvbench::state& state,
   cudf::test::UniformRandomGenerator<long> rand_gen(0, 100);
   auto elements = cudf::detail::make_counting_transform_iterator(
     0, [&rand_gen](auto row) { return rand_gen.generate(); });
-  auto valids = cudf::detail::make_counting_transform_iterator(
-    0, [](auto i) { return i % 100 == 0 ? false : true; });
+  auto valids =
+    cudf::detail::make_counting_transform_iterator(0, [](auto i) { return i % 100 != 0; });
   cudf::test::fixed_width_column_wrapper<Type, long> values(elements, elements + num_rows, valids);
 
   auto input_column = cudf::column_view(values);
   auto input_table  = cudf::table_view({input_column, input_column, input_column, input_column});
 
   state.exec(nvbench::exec_tag::sync, [&](nvbench::launch& launch) {
     rmm::cuda_stream_view stream_view{launch.get_stream()};
-    auto result = cudf::detail::drop_duplicates(
-      input_table, {0}, Keep, cudf::null_equality::EQUAL, cudf::null_order::BEFORE, stream_view);
-  });
-}
-
-template <typename Type>
-void nvbench_unordered_drop_duplicates(nvbench::state& state, nvbench::type_list<Type>)
-{
-  cudf::rmm_pool_raii pool_raii;
-
-  auto const num_rows = state.get_int64("NumRows");
-
-  cudf::test::UniformRandomGenerator<long> rand_gen(0, 100);
-  auto elements = cudf::detail::make_counting_transform_iterator(
-    0, [&rand_gen](auto row) { return rand_gen.generate(); });
-  auto valids = cudf::detail::make_counting_transform_iterator(
-    0, [](auto i) { return i % 100 == 0 ? false : true; });
-  cudf::test::fixed_width_column_wrapper<Type, long> values(elements, elements + num_rows, valids);
-
-  auto input_column = cudf::column_view(values);
-  auto input_table  = cudf::table_view({input_column, input_column, input_column, input_column});
-
-  state.exec(nvbench::exec_tag::sync, [&](nvbench::launch& launch) {
-    rmm::cuda_stream_view stream_view{launch.get_stream()};
-    auto result = cudf::detail::unordered_drop_duplicates(
-      input_table, {0}, cudf::null_equality::EQUAL, stream_view);
+    auto result =
+      cudf::detail::unique(input_table, {0}, Keep, cudf::null_equality::EQUAL, stream_view);
   });
 }
 
@@ -105,12 +80,7 @@ using keep_option = nvbench::enum_type_list<cudf::duplicate_keep_option::KEEP_FI
                                             cudf::duplicate_keep_option::KEEP_LAST,
                                             cudf::duplicate_keep_option::KEEP_NONE>;
 
-NVBENCH_BENCH_TYPES(nvbench_drop_duplicates, NVBENCH_TYPE_AXES(data_type, keep_option))
-  .set_name("drop_duplicates")
+NVBENCH_BENCH_TYPES(nvbench_unique, NVBENCH_TYPE_AXES(data_type, keep_option))
+  .set_name("unique")
   .set_type_axes_names({"Type", "KeepOption"})
   .add_int64_axis("NumRows", {10'000, 100'000, 1'000'000, 10'000'000});
-
-NVBENCH_BENCH_TYPES(nvbench_unordered_drop_duplicates, NVBENCH_TYPE_AXES(data_type))
-  .set_name("unordered_drop_duplicates")
-  .set_type_axes_names({"Type"})
-  .add_int64_axis("NumRows", {10'000, 100'000, 1'000'000, 10'000'000});

cpp/include/cudf/detail/stream_compaction.hpp

@@ -62,68 +62,67 @@ std::unique_ptr<table> apply_boolean_mask(
   rmm::mr::device_memory_resource* mr = rmm::mr::get_current_device_resource());
 
 /**
- * @copydoc cudf::drop_duplicates
+ * @copydoc cudf::unique
  *
  * @param[in] stream CUDA stream used for device memory operations and kernel launches.
  */
-std::unique_ptr<table> drop_duplicates(
+std::unique_ptr<table> unique(
   table_view const& input,
   std::vector<size_type> const& keys,
   duplicate_keep_option keep,
   null_equality nulls_equal           = null_equality::EQUAL,
-  null_order null_precedence          = null_order::BEFORE,
   rmm::cuda_stream_view stream        = rmm::cuda_stream_default,
   rmm::mr::device_memory_resource* mr = rmm::mr::get_current_device_resource());
 
 /**
- * @copydoc cudf::unordered_drop_duplicates
+ * @copydoc cudf::distinct
  *
  * @param[in] stream CUDA stream used for device memory operations and kernel launches.
  */
-std::unique_ptr<table> unordered_drop_duplicates(
+std::unique_ptr<table> distinct(
   table_view const& input,
   std::vector<size_type> const& keys,
   null_equality nulls_equal           = null_equality::EQUAL,
   rmm::cuda_stream_view stream        = rmm::cuda_stream_default,
   rmm::mr::device_memory_resource* mr = rmm::mr::get_current_device_resource());
 
 /**
- * @copydoc cudf::distinct_count(column_view const&, null_policy, nan_policy)
+ * @copydoc cudf::unique_count(column_view const&, null_policy, nan_policy)
  *
  * @param[in] stream CUDA stream used for device memory operations and kernel launches.
  */
-cudf::size_type distinct_count(column_view const& input,
-                               null_policy null_handling,
-                               nan_policy nan_handling,
-                               rmm::cuda_stream_view stream = rmm::cuda_stream_default);
+cudf::size_type unique_count(column_view const& input,
+                             null_policy null_handling,
+                             nan_policy nan_handling,
+                             rmm::cuda_stream_view stream = rmm::cuda_stream_default);
 
 /**
- * @copydoc cudf::distinct_count(table_view const&, null_equality)
+ * @copydoc cudf::unique_count(table_view const&, null_equality)
  *
  * @param[in] stream CUDA stream used for device memory operations and kernel launches.
  */
-cudf::size_type distinct_count(table_view const& input,
-                               null_equality nulls_equal    = null_equality::EQUAL,
-                               rmm::cuda_stream_view stream = rmm::cuda_stream_default);
+cudf::size_type unique_count(table_view const& input,
+                             null_equality nulls_equal    = null_equality::EQUAL,
+                             rmm::cuda_stream_view stream = rmm::cuda_stream_default);
 
 /**
- * @copydoc cudf::unordered_distinct_count(column_view const&, null_policy, nan_policy)
+ * @copydoc cudf::distinct_count(column_view const&, null_policy, nan_policy)
  *
  * @param[in] stream CUDA stream used for device memory operations and kernel launches.
  */
-cudf::size_type unordered_distinct_count(column_view const& input,
-                                         null_policy null_handling,
-                                         nan_policy nan_handling,
-                                         rmm::cuda_stream_view stream = rmm::cuda_stream_default);
+cudf::size_type distinct_count(column_view const& input,
+                               null_policy null_handling,
+                               nan_policy nan_handling,
+                               rmm::cuda_stream_view stream = rmm::cuda_stream_default);
 
 /**
- * @copydoc cudf::unordered_distinct_count(table_view const&, null_equality)
+ * @copydoc cudf::distinct_count(table_view const&, null_equality)
  *
  * @param[in] stream CUDA stream used for device memory operations and kernel launches.
  */
-cudf::size_type unordered_distinct_count(table_view const& input,
-                                         null_equality nulls_equal    = null_equality::EQUAL,
-                                         rmm::cuda_stream_view stream = rmm::cuda_stream_default);
+cudf::size_type distinct_count(table_view const& input,
+                               null_equality nulls_equal    = null_equality::EQUAL,
+                               rmm::cuda_stream_view stream = rmm::cuda_stream_default);
 
 }  // namespace detail
 }  // namespace cudf