Merge branch 'main' into mlir/pr11-strings-nonstring-ops

Author: brandon-b-miller

.github/workflows/issue-release-scheduled.yml

@@ -7,6 +7,7 @@ on:
 
 jobs:
   sync-release-fields:
+    if: github.repository == 'NVIDIA/cudf'
     runs-on: ubuntu-latest
     permissions:
       issues: write

cpp/benchmarks/common/generate_input.hpp

@@ -605,7 +605,11 @@ std::unique_ptr<cudf::column> create_string_column(cudf::size_type num_rows,
                                                    int32_t hit_rate);
 
 /**
- * @brief Generates an string column filled with ASCII characters only
+ * @brief Generates a string column filled with ASCII characters only
+ *
+ * Only the string length distribution and null probability of the profile are used.
+ * The cardinality and average run length settings are ignored, so every row is
+ * generated independently.
  *
  * @param profile Data profile for the output column
  * @param num_rows Number of rows in the output column

cpp/benchmarks/io/parquet/experimental/hybrid_scan/dict_page_filter.cpp

@@ -13,30 +13,39 @@
 #include <cudf/io/parquet.hpp>
 #include <cudf/io/parquet_io_utils.hpp>
 #include <cudf/io/text/byte_range_info.hpp>
+#include <cudf/scalar/scalar.hpp>
 #include <cudf/utilities/default_stream.hpp>
+#include <cudf/utilities/traits.hpp>
+#include <cudf/utilities/type_dispatcher.hpp>
+#include <cudf/wrappers/durations.hpp>
 
 #include <nvbench/nvbench.cuh>
 
+#include <algorithm>
+#include <limits>
 #include <numeric>
 
+namespace {
+
 constexpr cudf::size_type num_cols = 8;
 
-void BM_filter_string_row_groups_with_dicts_common(nvbench::state& state,
-                                                   data_profile const& table_profile,
-                                                   cudf::ast::operation const& filter_expr,
-                                                   double average_str_length,
-                                                   cudf::size_type cardinality)
+void filter_row_groups_with_dicts_common(nvbench::state& state,
+                                         cudf::type_id dtype,
+                                         data_profile const& table_profile,
+                                         cudf::ast::literal const& literal)
 {
   auto const num_row_groups = static_cast<cudf::size_type>(state.get_int64("num_row_groups"));
+  auto const cardinality    = static_cast<cudf::size_type>(state.get_int64("cardinality"));
+  auto const is_inline_eval = static_cast<bool>(state.get_int64("is_inline"));
   auto constexpr rows_per_row_group = 5'000;  //< Chosen such that it is not ignored by the writer
   auto const num_rows               = num_row_groups * rows_per_row_group;
 
   std::vector<char> parquet_buffer;
 
   // Write table to parquet
   {
-    auto const table = create_random_table(
-      cycle_dtypes({cudf::type_id::STRING}, num_cols), row_count{num_rows}, table_profile);
+    auto const table =
+      create_random_table(cycle_dtypes({dtype}, num_cols), row_count{num_rows}, table_profile);
 
     cudf::io::parquet_writer_options write_opts =
       cudf::io::parquet_writer_options::builder(cudf::io::sink_info(&parquet_buffer), table->view())
@@ -47,6 +56,17 @@ void BM_filter_string_row_groups_with_dicts_common(nvbench::state& state,
     cudf::io::write_parquet(write_opts);
   }
 
+  auto col_ref = cudf::ast::column_name_reference("_col0");
+  auto expr1   = cudf::ast::operation(cudf::ast::ast_operator::EQUAL, col_ref, literal);
+  auto expr2   = cudf::ast::operation(cudf::ast::ast_operator::NOT_EQUAL, col_ref, literal);
+  auto expr3   = cudf::ast::operation(cudf::ast::ast_operator::EQUAL, col_ref, literal);
+
+  auto filter_expr_few_literals =
+    cudf::ast::operation(cudf::ast::ast_operator::LOGICAL_AND, expr1, expr2);
+  auto filter_expr_many_literals =
+    cudf::ast::operation(cudf::ast::ast_operator::LOGICAL_OR, filter_expr_few_literals, expr3);
+  auto const& filter_expr = is_inline_eval ? filter_expr_few_literals : filter_expr_many_literals;
+
   auto const stream    = cudf::get_default_stream();
   auto const read_opts = cudf::io::parquet_reader_options::builder().filter(filter_expr).build();
 
@@ -76,6 +96,13 @@ void BM_filter_string_row_groups_with_dicts_common(nvbench::state& state,
   auto input_row_group_indices = reader->all_row_groups(read_opts);
   auto dict_page_byte_ranges   = std::vector<cudf::io::text::byte_range_info>{};
 
+  // Upper bound on the dictionary entries. Real dictionaries are smaller because the generator
+  // repeats each value it draws for a run of rows, and may draw the same value again
+  auto const num_dict_entries =
+    static_cast<std::size_t>(std::min(cardinality, rows_per_row_group) * num_row_groups);
+
+  state.add_element_count(num_dict_entries, "num_dict_entries");
+
   auto mem_stats_logger = cudf::memory_stats_logger();
 
   state.exec(
@@ -106,12 +133,8 @@ void BM_filter_string_row_groups_with_dicts_common(nvbench::state& state,
       timer.stop();
     });
 
-  auto const time = state.get_summary("nv/cold/time/gpu/mean").get_float64("value");
   state.add_buffer_size(
     mem_stats_logger.peak_memory_usage(), "peak_memory_usage", "peak_memory_usage");
-  state.add_element_count(
-    static_cast<double>(cardinality * num_row_groups * average_str_length) / time,
-    "strings_per_second");
   auto const total_dict_data_size =
     std::accumulate(dict_page_byte_ranges.begin(),
                     dict_page_byte_ranges.end(),
@@ -120,44 +143,86 @@ void BM_filter_string_row_groups_with_dicts_common(nvbench::state& state,
   state.add_buffer_size(total_dict_data_size, "total_dict_data_size", "total_dict_data_size");
 }
 
-void BM_filter_string_rowgroups_with_dicts(nvbench::state& state)
+}  // namespace
+
+void BM_hybrid_scan_dict_page_pruning_string(nvbench::state& state)
 {
-  auto const min_length     = static_cast<cudf::size_type>(state.get_int64("min_length"));
-  auto const max_length     = static_cast<cudf::size_type>(state.get_int64("max_length"));
-  auto const cardinality    = static_cast<cudf::size_type>(state.get_int64("cardinality"));
-  auto const is_inline_eval = static_cast<bool>(state.get_int64("is_inline"));
+  auto const min_length  = static_cast<cudf::size_type>(state.get_int64("min_length"));
+  auto const max_length  = static_cast<cudf::size_type>(state.get_int64("max_length"));
+  auto const cardinality = static_cast<cudf::size_type>(state.get_int64("cardinality"));
 
   auto table_profile =
     data_profile_builder()
       .distribution(cudf::type_id::STRING, distribution_id::NORMAL, min_length, max_length)
       .cardinality(cardinality);
 
-  auto col_ref = cudf::ast::column_name_reference("_col0");
-  auto scalar  = cudf::string_scalar("000010000");
-  auto literal = cudf::ast::literal(scalar);
-  auto expr1   = cudf::ast::operation(cudf::ast::ast_operator::EQUAL, col_ref, literal);
-  auto expr2   = cudf::ast::operation(cudf::ast::ast_operator::NOT_EQUAL, col_ref, literal);
-  auto expr3   = cudf::ast::operation(cudf::ast::ast_operator::EQUAL, col_ref, literal);
+  auto filter_value = cudf::string_scalar("000010000");
+  filter_row_groups_with_dicts_common(
+    state, cudf::type_id::STRING, table_profile, cudf::ast::literal(filter_value));
+}
 
-  auto filter_expr_few_literals =
-    cudf::ast::operation(cudf::ast::ast_operator::LOGICAL_AND, expr1, expr2);
+template <cudf::type_id DType>
+void BM_hybrid_scan_dict_page_pruning_fixed_width(nvbench::state& state,
+                                                  nvbench::type_list<nvbench::enum_type<DType>>)
+{
+  using T = cudf::id_to_type<DType>;
+  static_assert(cudf::is_numeric<T>() or cudf::is_chrono<T>(),
+                "Filter literals are only generated for numeric and chrono types");
+
+  auto const cardinality = static_cast<cudf::size_type>(state.get_int64("cardinality"));
+
+  // Timestamps span 1970 to 2020 as the generator overflows past 2262
+  // Durations span 24 days to fit
+  auto constexpr max_value = [] {
+    if constexpr (cudf::is_timestamp<T>()) {
+      return cuda::std::chrono::duration_cast<typename T::duration>(cudf::duration_D{50 * 365})
+        .count();
+    } else if constexpr (cudf::is_duration<T>()) {
+      return cuda::std::chrono::duration_cast<T>(cudf::duration_D{24}).count();
+    } else {
+      return std::numeric_limits<T>::max();
+    }
+  }();
 
-  auto filter_expr_many_literals =
-    cudf::ast::operation(cudf::ast::ast_operator::LOGICAL_OR, filter_expr_few_literals, expr3);
+  auto table_profile =
+    data_profile_builder()
+      .distribution(DType, distribution_id::UNIFORM, decltype(max_value){0}, max_value)
+      .cardinality(cardinality);
 
-  return BM_filter_string_row_groups_with_dicts_common(
-    state,
-    table_profile,
-    is_inline_eval ? filter_expr_few_literals : filter_expr_many_literals,
-    (static_cast<double>(min_length) + static_cast<double>(max_length)) / 2,
-    cardinality);
+  // The literal lies inside the value range, so min/max statistics cannot prune any row group
+  auto filter_value = [&] {
+    if constexpr (cudf::is_timestamp<T>()) {
+      return cudf::timestamp_scalar<T>(T{typename T::duration{max_value / 2}});
+    } else if constexpr (cudf::is_duration<T>()) {
+      return cudf::duration_scalar<T>(T{max_value / 2});
+    } else {
+      return cudf::numeric_scalar<T>(static_cast<T>(max_value / 2));
+    }
+  }();
+  filter_row_groups_with_dicts_common(
+    state, DType, table_profile, cudf::ast::literal(filter_value));
 }
 
-NVBENCH_BENCH(BM_filter_string_rowgroups_with_dicts)
-  .set_name("hybrid_scan_filter_string_rowgroups_with_dicts")
+NVBENCH_BENCH(BM_hybrid_scan_dict_page_pruning_string)
+  .set_name("hybrid_scan_dict_page_pruning_string")
   .set_min_samples(4)
   .add_int64_axis("num_row_groups", {32, 64, 128})
   .add_int64_axis("min_length", {4})
   .add_int64_axis("max_length", {64, 128})
   .add_int64_axis("cardinality", {1'000, 10'000})
   .add_int64_axis("is_inline", {true, false});
+
+using dict_fixed_width_dtypes = nvbench::enum_type_list<cudf::type_id::INT8,
+                                                        cudf::type_id::FLOAT32,
+                                                        cudf::type_id::FLOAT64,
+                                                        cudf::type_id::DURATION_MILLISECONDS,
+                                                        cudf::type_id::TIMESTAMP_MICROSECONDS>;
+
+NVBENCH_BENCH_TYPES(BM_hybrid_scan_dict_page_pruning_fixed_width,
+                    NVBENCH_TYPE_AXES(dict_fixed_width_dtypes))
+  .set_name("hybrid_scan_dict_page_pruning_fixed_width")
+  .set_type_axes_names({"dtype"})
+  .set_min_samples(4)
+  .add_int64_axis("num_row_groups", {32, 64, 128})
+  .add_int64_axis("cardinality", {1'000, 10'000})
+  .add_int64_axis("is_inline", {true, false});

cpp/benchmarks/io/parquet/experimental/hybrid_scan/hybrid_scan_composer.cpp

@@ -47,7 +47,7 @@ std::unique_ptr<hybrid_scan_reader> setup_reader(cudf::io::datasource& datasourc
 
 std::vector<cudf::size_type> apply_row_group_filters(
   cudf::io::datasource& datasource,
-  hybrid_scan_reader const& reader,
+  hybrid_scan_reader& reader,
   cudf::host_span<cudf::size_type> input_row_group_indices,
   std::unordered_set<hybrid_scan_filter_type> const& filters,
   cudf::io::parquet_reader_options const& options,
@@ -126,7 +126,7 @@ std::vector<cudf::size_type> apply_row_group_filters(
 
 std::unique_ptr<cudf::table> single_step_materialize(
   cudf::io::datasource& datasource,
-  hybrid_scan_reader const& reader,
+  hybrid_scan_reader& reader,
   cudf::host_span<cudf::size_type> current_row_group_indices,
   cudf::io::parquet_reader_options const& options,
   cuda::stream_ref stream,
@@ -162,7 +162,7 @@ std::unique_ptr<cudf::table> hybrid_scan(cudf::io::parquet_reader_options const&
 
   // Setup reader and page index
   auto reader           = setup_reader(datasource_ref, options);
-  auto const reader_ref = std::cref(*reader);
+  auto const reader_ref = std::ref(*reader);
 
   // Start with all row groups
   auto row_group_indices         = reader->all_row_groups(options);

cpp/benchmarks/io/parquet/experimental/hybrid_scan/page_stats_row_mask.cpp

@@ -287,7 +287,7 @@ void BM_page_stats_row_mask(nvbench::state& state)
 
   auto const filter  = make_filter_expression(expr_depth, dtypes);
   auto const options = cudf::io::parquet_reader_options::builder().filter(filter.root()).build();
-  auto const reader = cudf::io::parquet::experimental::hybrid_scan_multifile{footer_spans, options};
+  auto reader = cudf::io::parquet::experimental::hybrid_scan_multifile{footer_spans, options};
 
   // Setup page indexes for page-statistics filtering
   {

cpp/benchmarks/string/case.cpp

@@ -21,33 +21,11 @@ void bench_case(nvbench::state& state)
 
   data_profile const profile = data_profile_builder().distribution(
     cudf::type_id::STRING, distribution_id::NORMAL, min_width, max_width);
-  auto const column = create_random_column(cudf::type_id::STRING, row_count{num_rows}, profile);
-
-  auto col_view = column->view();
-  auto col_size = column->alloc_size();
-
-  cudf::column::contents ascii_contents;
-  if (encoding == "ascii") {
-    data_profile ascii_profile = data_profile_builder().no_validity().distribution(
-      cudf::type_id::INT8, distribution_id::UNIFORM, 32, 126);  // nice ASCII range
-    auto input        = cudf::strings_column_view(col_view);
-    auto ascii_column = create_random_column(
-      cudf::type_id::INT8,
-      row_count{static_cast<cudf::size_type>(input.chars_size(cudf::get_default_stream()))},
-      ascii_profile);
-    auto ascii_data = ascii_column->view();
-
-    col_view       = cudf::column_view(col_view.type(),
-                                 col_view.size(),
-                                 ascii_data.data<char>(),
-                                 col_view.null_mask(),
-                                 col_view.null_count(),
-                                 0,
-                                       {input.offsets()});
-    col_size       = ascii_column->alloc_size();
-    ascii_contents = ascii_column->release();
-  }
-  auto input = cudf::strings_column_view(col_view);
+  auto const column   = encoding == "ascii"
+                          ? create_ascii_string_column(profile, num_rows)
+                          : create_random_column(cudf::type_id::STRING, row_count{num_rows}, profile);
+  auto const input    = cudf::strings_column_view(column->view());
+  auto const col_size = column->alloc_size();
 
   state.set_cuda_stream(nvbench::make_cuda_stream_view(cudf::get_default_stream().get()));
 

cpp/benchmarks/text/edit_distance.cpp

@@ -6,15 +6,10 @@
 #include <benchmarks/common/generate_input.hpp>
 #include <benchmarks/common/memory_stats.hpp>
 
-#include <cudf/aggregation.hpp>
-#include <cudf/copying.hpp>
-#include <cudf/reduction.hpp>
 #include <cudf/strings/strings_column_view.hpp>
 
 #include <nvtext/edit_distance.hpp>
 
-#include <rmm/device_buffer.hpp>
-
 #include <nvbench/nvbench.cuh>
 
 static void bench_edit_distance_utf8(nvbench::state& state)
@@ -28,7 +23,7 @@ static void bench_edit_distance_utf8(nvbench::state& state)
   auto const strings_table = create_random_table(
     {cudf::type_id::STRING, cudf::type_id::STRING}, row_count{num_rows}, strings_profile);
   auto input1 = strings_table->get_column(0);
-  auto input2 = strings_table->get_column(0);
+  auto input2 = strings_table->get_column(1);
   auto sv1    = cudf::strings_column_view(input1.view());
   auto sv2    = cudf::strings_column_view(input2.view());
 
@@ -51,59 +46,16 @@ static void bench_edit_distance_ascii(nvbench::state& state)
   auto const min_width = static_cast<cudf::size_type>(state.get_int64("min_width"));
   auto const max_width = static_cast<cudf::size_type>(state.get_int64("max_width"));
 
-  auto const max_size     = static_cast<int64_t>(num_rows) * static_cast<int64_t>(max_width);
-  auto const offsets_type = max_size >= std::numeric_limits<cudf::size_type>::max()
-                              ? cudf::type_id::INT64
-                              : cudf::type_id::INT32;
-
-  data_profile profile = data_profile_builder().no_validity().cardinality(0).distribution(
-    offsets_type, distribution_id::NORMAL, min_width, max_width);
-  data_profile ascii_profile = data_profile_builder().no_validity().cardinality(0).distribution(
-    cudf::type_id::INT8, distribution_id::UNIFORM, 32, 126);  // nice ASCII range
-
-  auto offsets    = create_random_column(offsets_type, row_count{num_rows + 1}, profile);
-  offsets         = cudf::scan(offsets->view(),
-                       *cudf::make_sum_aggregation<cudf::scan_aggregation>(),
-                       cudf::scan_type::EXCLUSIVE);
-  auto chars_size = offsets_type == cudf::type_id::INT64
-                      ? dynamic_cast<cudf::numeric_scalar<int64_t>*>(
-                          cudf::get_element(offsets->view(), num_rows).get())
-                          ->value()
-                      : static_cast<int64_t>(dynamic_cast<cudf::numeric_scalar<int32_t>*>(
-                                               cudf::get_element(offsets->view(), num_rows).get())
-                                               ->value());
-  if (chars_size > std::numeric_limits<int32_t>::max()) {
-    // to be fixed with create_ascii_string_column utility in PR 20354
-    state.skip("chars size too large for this benchmark");
-    return;
-  }
-
-  auto ascii_data1 = create_random_column(
-    cudf::type_id::INT8, row_count{static_cast<cudf::size_type>(chars_size)}, ascii_profile);
-  auto ascii_data2 = create_random_column(
-    cudf::type_id::INT8, row_count{static_cast<cudf::size_type>(chars_size)}, ascii_profile);
-
-  auto input1 = cudf::column_view(cudf::data_type{cudf::type_id::STRING},
-                                  num_rows,
-                                  ascii_data1->view().data<char>(),
-                                  nullptr,
-                                  0,
-                                  0,
-                                  {offsets->view()});
-  auto input2 = cudf::column_view(cudf::data_type{cudf::type_id::STRING},
-                                  num_rows,
-                                  ascii_data2->view().data<char>(),
-                                  nullptr,
-                                  0,
-                                  0,
-                                  {offsets->view()});
+  data_profile const strings_profile = data_profile_builder().no_validity().distribution(
+    cudf::type_id::STRING, distribution_id::NORMAL, min_width, max_width);
+  auto const input1 = create_ascii_string_column(strings_profile, num_rows, 1);
+  auto const input2 = create_ascii_string_column(strings_profile, num_rows, 2);
+  auto sv1          = cudf::strings_column_view(input1->view());
+  auto sv2          = cudf::strings_column_view(input2->view());
 
   state.set_cuda_stream(nvbench::make_cuda_stream_view(cudf::get_default_stream().get()));
 
-  auto sv1          = cudf::strings_column_view(input1);
-  auto sv2          = cudf::strings_column_view(input2);
-  auto offsets_size = offsets->alloc_size();
-  state.add_global_memory_reads<nvbench::int8_t>(chars_size + 2 * offsets_size);
+  state.add_global_memory_reads<nvbench::int8_t>(input1->alloc_size() + input2->alloc_size());
   // output are integers (one per row)
   state.add_global_memory_writes<nvbench::int32_t>(num_rows);