Update strings benchmarks to use alloc_size column/table function (#18822)

Fixes the strings benchmarks to use `alloc_size()` member function instead of `chars_size()` which did not account for reading the offsets or the bitmask.

Reference #13735

Authors:
  - David Wendt (https://github.com/davidwendt)

Approvers:
  - Vukasin Milovanovic (https://github.com/vuule)
  - Nghia Truong (https://github.com/ttnghia)

URL: #18822

Author: davidwendt

cpp/benchmarks/string/case.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2021-2024, NVIDIA CORPORATION.
+ * Copyright (c) 2021-2025, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -34,6 +34,7 @@ void bench_case(nvbench::state& state)
   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") {
@@ -46,23 +47,22 @@ void bench_case(nvbench::state& state)
       ascii_profile);
     auto ascii_data = ascii_column->view();
 
-    col_view = cudf::column_view(col_view.type(),
+    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()});
-
+                                       {input.offsets()});
+    col_size       = ascii_column->alloc_size();
     ascii_contents = ascii_column->release();
   }
   auto input = cudf::strings_column_view(col_view);
 
   state.set_cuda_stream(nvbench::make_cuda_stream_view(cudf::get_default_stream().value()));
 
-  state.add_element_count(input.chars_size(cudf::get_default_stream()), "chars_size");
-  state.add_global_memory_reads<nvbench::int8_t>(input.chars_size(cudf::get_default_stream()));
-  state.add_global_memory_writes<nvbench::int8_t>(input.chars_size(cudf::get_default_stream()));
+  state.add_global_memory_reads<nvbench::int8_t>(col_size);
+  state.add_global_memory_writes<nvbench::int8_t>(col_size);
 
   state.exec(nvbench::exec_tag::sync,
              [&](nvbench::launch& launch) { auto result = cudf::strings::to_lower(input); });

cpp/benchmarks/string/char_types.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023-2024, NVIDIA CORPORATION.
+ * Copyright (c) 2023-2025, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -38,12 +38,12 @@ static void bench_char_types(nvbench::state& state)
 
   state.set_cuda_stream(nvbench::make_cuda_stream_view(cudf::get_default_stream().value()));
   // gather some throughput statistics as well
-  auto chars_size = input.chars_size(cudf::get_default_stream());
-  state.add_global_memory_reads<nvbench::int8_t>(chars_size);  // all bytes are read;
+  auto data_size = table->alloc_size();
+  state.add_global_memory_reads<nvbench::int8_t>(data_size);  // all bytes are read;
   if (api_type == "all") {
     state.add_global_memory_writes<nvbench::int8_t>(num_rows);  // output is a bool8 per row
   } else {
-    state.add_global_memory_writes<nvbench::int8_t>(chars_size);
+    state.add_global_memory_writes<nvbench::int8_t>(data_size);
   }
 
   state.exec(nvbench::exec_tag::sync, [&](nvbench::launch& launch) {

cpp/benchmarks/string/combine.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2021-2024, NVIDIA CORPORATION.
+ * Copyright (c) 2021-2025, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -38,10 +38,9 @@ static void bench_combine(nvbench::state& state)
 
   auto stream = cudf::get_default_stream();
   state.set_cuda_stream(nvbench::make_cuda_stream_view(stream.value()));
-  auto chars_size =
-    input1.chars_size(stream) + input2.chars_size(stream) + (num_rows * separator.size());
-  state.add_global_memory_reads<nvbench::int8_t>(chars_size);  // all bytes are read;
-  state.add_global_memory_writes<nvbench::int8_t>(chars_size);
+  auto const data_size = table->alloc_size();
+  state.add_global_memory_reads<nvbench::int8_t>(data_size);  // all bytes are read;
+  state.add_global_memory_writes<nvbench::int8_t>(data_size + (num_rows * separator.size()));
 
   state.exec(nvbench::exec_tag::sync, [&](nvbench::launch& launch) {
     auto result = cudf::strings::concatenate(table->view(), separator);

cpp/benchmarks/string/contains.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2021-2024, NVIDIA CORPORATION.
+ * Copyright (c) 2021-2025, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -40,9 +40,7 @@ static void bench_contains(nvbench::state& state)
   auto pattern = patterns[pattern_index];
   auto program = cudf::strings::regex_program::create(pattern);
 
-  auto chars_size = input.chars_size(cudf::get_default_stream());
-  state.add_element_count(chars_size, "chars_size");
-  state.add_global_memory_reads<nvbench::int8_t>(chars_size);
+  state.add_global_memory_reads<nvbench::int8_t>(col->alloc_size());
   state.add_global_memory_writes<nvbench::int32_t>(input.size());
 
   state.exec(nvbench::exec_tag::sync,

cpp/benchmarks/string/convert_datetime.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2021-2024, NVIDIA CORPORATION.
+ * Copyright (c) 2021-2025, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -54,12 +54,12 @@ void bench_convert_datetime(nvbench::state& state, nvbench::type_list<DataType>)
 
   if (from_ts) {
     state.add_global_memory_reads<DataType>(num_rows);
-    state.add_global_memory_writes<int8_t>(sv.chars_size(stream));
+    state.add_global_memory_writes<int8_t>(s_col->alloc_size());
     state.exec(nvbench::exec_tag::sync, [&](nvbench::launch& launch) {
       cudf::strings::from_timestamps(ts_col->view(), format);
     });
   } else {
-    state.add_global_memory_reads<int8_t>(sv.chars_size(stream));
+    state.add_global_memory_reads<int8_t>(s_col->alloc_size());
     state.add_global_memory_writes<DataType>(num_rows);
     state.exec(nvbench::exec_tag::sync, [&](nvbench::launch& launch) {
       cudf::strings::to_timestamps(sv, data_type, format);

cpp/benchmarks/string/convert_durations.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020-2024, NVIDIA CORPORATION.
+ * Copyright (c) 2020-2025, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -58,7 +58,7 @@ void bench_convert_duration(nvbench::state& state, nvbench::type_list<DataType>)
   } else {
     auto source = cudf::strings::from_durations(input, format);
     auto view   = cudf::strings_column_view(source->view());
-    state.add_global_memory_reads<int8_t>(view.chars_size(stream));
+    state.add_global_memory_reads<int8_t>(source->alloc_size());
     state.add_global_memory_writes<DataType>(num_rows);
     state.exec(nvbench::exec_tag::sync, [&](nvbench::launch& launch) {
       cudf::strings::to_durations(view, data_type, format);

cpp/benchmarks/string/convert_fixed_point.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2021-2024, NVIDIA CORPORATION.
+ * Copyright (c) 2021-2025, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -45,11 +45,11 @@ void bench_convert_fixed_point(nvbench::state& state, nvbench::type_list<DataTyp
 
   if (from_num) {
     state.add_global_memory_reads<int8_t>(num_rows * cudf::size_of(data_type));
-    state.add_global_memory_writes<int8_t>(sv.chars_size(stream));
+    state.add_global_memory_writes<int8_t>(strings_col->alloc_size());
     state.exec(nvbench::exec_tag::sync,
                [&](nvbench::launch& launch) { cudf::strings::to_fixed_point(sv, data_type); });
   } else {
-    state.add_global_memory_reads<int8_t>(sv.chars_size(stream));
+    state.add_global_memory_reads<int8_t>(strings_col->alloc_size());
     state.add_global_memory_writes<int8_t>(num_rows * cudf::size_of(data_type));
     state.exec(nvbench::exec_tag::sync,
                [&](nvbench::launch& launch) { cudf::strings::from_fixed_point(fp_col->view()); });

cpp/benchmarks/string/convert_numerics.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2021-2024, NVIDIA CORPORATION.
+ * Copyright (c) 2021-2025, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -55,7 +55,7 @@ void bench_convert_number(nvbench::state& state, nvbench::type_list<NumericType>
 
   if (from_num) {
     state.add_global_memory_reads<NumericType>(num_rows);
-    state.add_global_memory_writes<int8_t>(sv.chars_size(stream));
+    state.add_global_memory_writes<int8_t>(strings_col->alloc_size());
     state.exec(nvbench::exec_tag::sync, [&](nvbench::launch& launch) {
       if constexpr (std::is_floating_point_v<NumericType>) {
         cudf::strings::to_floats(sv, data_type);
@@ -64,7 +64,7 @@ void bench_convert_number(nvbench::state& state, nvbench::type_list<NumericType>
       }
     });
   } else {
-    state.add_global_memory_reads<int8_t>(sv.chars_size(stream));
+    state.add_global_memory_reads<int8_t>(strings_col->alloc_size());
     state.add_global_memory_writes<NumericType>(num_rows);
     state.exec(nvbench::exec_tag::sync, [&](nvbench::launch& launch) {
       if constexpr (std::is_floating_point_v<NumericType>)

cpp/benchmarks/string/copy.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2024, NVIDIA CORPORATION.
+ * Copyright (c) 2024-2025, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -46,21 +46,21 @@ static void bench_copy(nvbench::state& state)
   if (api == "gather") {
     auto result =
       cudf::gather(source->view(), map_view, cudf::out_of_bounds_policy::NULLIFY, stream);
-    auto chars_size = cudf::strings_column_view(result->view().column(0)).chars_size(stream);
-    state.add_global_memory_reads<nvbench::int8_t>(chars_size +
+    auto data_size = result->alloc_size();
+    state.add_global_memory_reads<nvbench::int8_t>(data_size +
                                                    (map_view.size() * sizeof(cudf::size_type)));
-    state.add_global_memory_writes<nvbench::int8_t>(chars_size);
+    state.add_global_memory_writes<nvbench::int8_t>(data_size);
     state.exec(nvbench::exec_tag::sync, [&](nvbench::launch& launch) {
       cudf::gather(source->view(), map_view, cudf::out_of_bounds_policy::NULLIFY, stream);
     });
   } else if (api == "scatter") {
     auto const target =
       create_random_table({cudf::type_id::STRING}, row_count{num_rows}, table_profile);
-    auto result     = cudf::scatter(source->view(), map_view, target->view(), stream);
-    auto chars_size = cudf::strings_column_view(result->view().column(0)).chars_size(stream);
-    state.add_global_memory_reads<nvbench::int8_t>(chars_size +
+    auto result    = cudf::scatter(source->view(), map_view, target->view(), stream);
+    auto data_size = result->alloc_size();
+    state.add_global_memory_reads<nvbench::int8_t>(data_size +
                                                    (map_view.size() * sizeof(cudf::size_type)));
-    state.add_global_memory_writes<nvbench::int8_t>(chars_size);
+    state.add_global_memory_writes<nvbench::int8_t>(data_size);
     state.exec(nvbench::exec_tag::sync, [&](nvbench::launch& launch) {
       cudf::scatter(source->view(), map_view, target->view(), stream);
     });

cpp/benchmarks/string/copy_if_else.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2024, NVIDIA CORPORATION.
+ * Copyright (c) 2024-2025, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -43,9 +43,9 @@ static void bench_copy(nvbench::state& state)
   auto const left_right = booleans->view().column(0);
 
   state.set_cuda_stream(nvbench::make_cuda_stream_view(cudf::get_default_stream().value()));
-  auto chars_size = cudf::strings_column_view(target).chars_size(cudf::get_default_stream());
-  state.add_global_memory_reads<nvbench::int8_t>(chars_size);   // all bytes are read;
-  state.add_global_memory_writes<nvbench::int8_t>(chars_size);  // both columns are similar size
+  auto data_size = target_table->alloc_size();
+  state.add_global_memory_reads<nvbench::int8_t>(data_size);   // all bytes are read;
+  state.add_global_memory_writes<nvbench::int8_t>(data_size);  // both columns are similar size
 
   state.exec(nvbench::exec_tag::sync, [&](nvbench::launch& launch) {
     [[maybe_unused]] auto result = cudf::copy_if_else(source, target, left_right);