diff --git a/cpp/benchmarks/bitmask/bitmask_and.cpp b/cpp/benchmarks/bitmask/bitmask_and.cpp index 6f36ef4b1605..00c11e200c05 100644 --- a/cpp/benchmarks/bitmask/bitmask_and.cpp +++ b/cpp/benchmarks/bitmask/bitmask_and.cpp @@ -44,12 +44,12 @@ auto setup_masks(nvbench::state& state) std::exclusive_scan(segments.begin(), segments.end(), segments.begin(), 0); // Create masks - std::vector masks; + std::vector> masks; std::vector mask_pointers; masks.reserve(num_masks); std::generate_n(std::back_inserter(masks), num_masks, [mask_size_bits, seed, &mask_pointers]() { auto mask_pair = create_random_null_mask(mask_size_bits, null_probability, seed); - mask_pointers.push_back(static_cast(mask_pair.first.data())); + mask_pointers.push_back(reinterpret_cast(mask_pair.first.data())); return std::move(mask_pair.first); }); diff --git a/cpp/benchmarks/bitmask/set_null_mask.cpp b/cpp/benchmarks/bitmask/set_null_mask.cpp index f8259736f41a..1b0114bbb02e 100644 --- a/cpp/benchmarks/bitmask/set_null_mask.cpp +++ b/cpp/benchmarks/bitmask/set_null_mask.cpp @@ -39,11 +39,14 @@ auto generate_test_data(cudf::size_type num_masks, auto valids = thrust::host_vector(num_masks, true); - std::vector masks(num_masks); - std::vector masks_ptr(num_masks); + std::vector> masks; + masks.reserve(num_masks); + std::vector masks_ptr; + masks_ptr.reserve(num_masks); for (cudf::size_type i = 0; i < num_masks; ++i) { - masks[i] = cudf::create_null_mask(mask_size, cudf::mask_state::UNINITIALIZED); - masks_ptr[i] = static_cast(masks[i].data()); + auto& last = + masks.emplace_back(cudf::create_null_mask(mask_size, cudf::mask_state::UNINITIALIZED)); + masks_ptr.emplace_back(reinterpret_cast(last.data())); } return std::make_tuple(std::move(begin_bits), @@ -57,19 +60,20 @@ auto generate_test_data(cudf::size_type num_masks, void BM_setnullmask(nvbench::state& state) { - auto const mask_size = static_cast(state.get_int64("mask_size")); - rmm::device_buffer mask = cudf::create_null_mask(mask_size, cudf::mask_state::UNINITIALIZED); + auto const mask_size = static_cast(state.get_int64("mask_size")); + cuda::device_buffer mask = + cudf::create_null_mask(mask_size, cudf::mask_state::UNINITIALIZED); auto begin = 0, end = mask_size; state.set_cuda_stream(nvbench::make_cuda_stream_view(cudf::get_default_stream().get())); auto const mem_stats_logger = cudf::memory_stats_logger(); - state.exec(nvbench::exec_tag::sync | nvbench::exec_tag::timer, - [&](nvbench::launch& launch, auto& timer) { - timer.start(); - cudf::set_null_mask(static_cast(mask.data()), begin, end, true); - timer.stop(); - }); + state.exec( + nvbench::exec_tag::sync | nvbench::exec_tag::timer, [&](nvbench::launch& launch, auto& timer) { + timer.start(); + cudf::set_null_mask(reinterpret_cast(mask.data()), begin, end, true); + timer.stop(); + }); state.add_buffer_size( mem_stats_logger.peak_memory_usage(), "peak_memory_usage", "peak_memory_usage"); diff --git a/cpp/benchmarks/common/generate_input.cu b/cpp/benchmarks/common/generate_input.cu index 36cdb711768a..46792688751c 100644 --- a/cpp/benchmarks/common/generate_input.cu +++ b/cpp/benchmarks/common/generate_input.cu @@ -516,7 +516,9 @@ std::unique_ptr create_random_utf8_string_column(data_profile cons auto [result_bitmask, null_count] = profile.get_null_probability().has_value() ? cudf::bools_to_mask(cudf::device_span(null_mask), stream) - : std::pair{std::make_unique(), 0}; + : std::pair{std::make_unique>( + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)), + 0}; return cudf::make_strings_column(num_rows, std::move(offsets), @@ -621,7 +623,9 @@ std::unique_ptr create_random_column(data_profile const& profile, auto [result_bitmask, null_count] = profile.get_null_probability().has_value() ? cudf::bools_to_mask(cudf::device_span(null_mask)) - : std::pair{std::make_unique(), 0}; + : std::pair{std::make_unique>( + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)), + 0}; return std::make_unique( dtype, num_rows, data.release(), std::move(*result_bitmask.release()), null_count); @@ -700,7 +704,9 @@ std::unique_ptr create_random_column(data_profi return cudf::bools_to_mask(cudf::device_span(valids), cudf::get_default_stream()); } - return std::pair{std::make_unique(), 0}; + return std::pair{std::make_unique>( + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)), + 0}; }(); // Adopt remaining children as evenly as possible @@ -785,15 +791,19 @@ std::unique_ptr create_random_column(data_profile thrust::device_pointer_cast(offsets.end())[-1] = current_child_column->size(); // Always include all elements - auto offsets_column = std::make_unique(cudf::data_type{cudf::type_id::INT32}, - current_num_rows + 1, - offsets.release(), - rmm::device_buffer{}, - 0); + auto offsets_column = + std::make_unique(cudf::data_type{cudf::type_id::INT32}, + current_num_rows + 1, + offsets.release(), + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), + 0); - auto [null_mask, null_count] = profile.get_null_probability().has_value() - ? cudf::bools_to_mask(cudf::device_span(valids)) - : std::pair{std::make_unique(), 0}; + auto [null_mask, null_count] = + profile.get_null_probability().has_value() + ? cudf::bools_to_mask(cudf::device_span(valids)) + : std::pair{std::make_unique>( + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)), + 0}; list_column = cudf::make_lists_column(current_num_rows, std::move(offsets_column), @@ -869,8 +879,12 @@ std::unique_ptr create_distinct_rows_column( auto child_column = cudf::sequence(num_rows, *zero); for (int lvl = dist_params.max_depth; lvl > 0; --lvl) { auto offsets_column = cudf::sequence(num_rows + 1, *zero); - auto list_column = cudf::make_lists_column( - num_rows, std::move(offsets_column), std::move(child_column), 0, rmm::device_buffer{}); + auto list_column = + cudf::make_lists_column(num_rows, + std::move(offsets_column), + std::move(child_column), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); if (auto const cv = list_column->view(); cudf::has_nonempty_nulls(cv, cudf::get_default_stream())) { list_column = cudf::purge_nonempty_nulls( @@ -900,8 +914,8 @@ std::unique_ptr create_distinct_rows_column( children.push_back(cudf::sequence(num_rows, *cudf::make_fixed_width_scalar(0))); for (int lvl = dist_params.max_depth; lvl > 1; --lvl) { std::vector> parents; - parents.push_back( - cudf::create_structs_hierarchy(num_rows, std::move(children), 0, rmm::device_buffer{})); + parents.push_back(cudf::create_structs_hierarchy( + num_rows, std::move(children), 0, cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED))); std::swap(parents, children); } auto const null_count = col->null_count(); @@ -1065,10 +1079,12 @@ std::unique_ptr create_string_column(cudf::size_type num_rows, return std::move(table->release().front()); } -std::pair create_random_null_mask( +std::pair, cudf::size_type> create_random_null_mask( cudf::size_type size, std::optional null_probability, unsigned seed) { - if (not null_probability.has_value()) { return {rmm::device_buffer{}, 0}; } + if (not null_probability.has_value()) { + return {cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), 0}; + } CUDF_EXPECTS(*null_probability >= 0.0 and *null_probability <= 1.0, "Null probability must be within the range [0.0, 1.0]"); if (*null_probability == 0.0f) { diff --git a/cpp/benchmarks/common/generate_input.hpp b/cpp/benchmarks/common/generate_input.hpp index b513cec263bb..67d18930db11 100644 --- a/cpp/benchmarks/common/generate_input.hpp +++ b/cpp/benchmarks/common/generate_input.hpp @@ -666,5 +666,5 @@ std::vector mix_dtypes(std::pair co * @param seed Optional, seed for the pseudo-random engine * @return null mask device buffer with random null mask data and null count */ -std::pair create_random_null_mask( +std::pair, cudf::size_type> create_random_null_mask( cudf::size_type size, std::optional null_probability = std::nullopt, unsigned seed = 1); diff --git a/cpp/benchmarks/common/ndsh_data_generator/random_column_generator.cu b/cpp/benchmarks/common/ndsh_data_generator/random_column_generator.cu index afc3ded6e88a..e0d2aa73057c 100644 --- a/cpp/benchmarks/common/ndsh_data_generator/random_column_generator.cu +++ b/cpp/benchmarks/common/ndsh_data_generator/random_column_generator.cu @@ -99,8 +99,11 @@ std::unique_ptr generate_random_string_column(cudf::size_type lowe num_rows, random_string_generator(chars.data())); - return cudf::make_strings_column( - num_rows, std::move(offsets_column), chars.release(), 0, rmm::device_buffer{}); + return cudf::make_strings_column(num_rows, + std::move(offsets_column), + chars.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); } template diff --git a/cpp/benchmarks/copying/copy_if_else.cpp b/cpp/benchmarks/copying/copy_if_else.cpp index 298fd2019af1..6da26c527012 100644 --- a/cpp/benchmarks/copying/copy_if_else.cpp +++ b/cpp/benchmarks/copying/copy_if_else.cpp @@ -24,9 +24,9 @@ static void bench_copy_if_else(nvbench::state& state, nvbench::type_listget_column(0).set_null_mask(rmm::device_buffer{}, 0); - input->get_column(1).set_null_mask(rmm::device_buffer{}, 0); - input->get_column(2).set_null_mask(rmm::device_buffer{}, 0); + input->get_column(0).set_null_mask(cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), 0); + input->get_column(1).set_null_mask(cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), 0); + input->get_column(2).set_null_mask(cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), 0); } cudf::column_view lhs(input->view().column(0)); diff --git a/cpp/benchmarks/groupby/group_struct_values.cpp b/cpp/benchmarks/groupby/group_struct_values.cpp index ec7ca44cc54c..4f5694d9efb6 100644 --- a/cpp/benchmarks/groupby/group_struct_values.cpp +++ b/cpp/benchmarks/groupby/group_struct_values.cpp @@ -41,7 +41,10 @@ static void bench_groupby_min_struct(nvbench::state& state) auto const keys_view = data_cols.front()->view(); auto const values = - cudf::make_structs_column(keys_view.size(), std::move(data_cols), 0, rmm::device_buffer()); + cudf::make_structs_column(keys_view.size(), + std::move(data_cols), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); auto gb_obj = cudf::groupby::groupby(cudf::table_view({keys_view})); auto requests = std::vector(); @@ -71,7 +74,10 @@ static void bench_groupby_min_struct_scan(nvbench::state& state) auto const keys_view = data_cols.front()->view(); auto const values = - cudf::make_structs_column(keys_view.size(), std::move(data_cols), 0, rmm::device_buffer()); + cudf::make_structs_column(keys_view.size(), + std::move(data_cols), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); auto requests = std::vector(); requests.emplace_back(cudf::groupby::scan_request()); diff --git a/cpp/benchmarks/io/parquet/experimental/variant/extract.cpp b/cpp/benchmarks/io/parquet/experimental/variant/extract.cpp index 13f335b8f27c..c3d67decff50 100644 --- a/cpp/benchmarks/io/parquet/experimental/variant/extract.cpp +++ b/cpp/benchmarks/io/parquet/experimental/variant/extract.cpp @@ -288,21 +288,35 @@ std::unique_ptr build_variant_column(std::span( - cudf::data_type{cudf::type_id::INT32}, n + 1, std::move(d_offsets), rmm::device_buffer{}, 0); - auto data_col = std::make_unique(cudf::data_type{cudf::type_id::UINT8}, - static_cast(flat.size()), - std::move(d_data), - rmm::device_buffer{}, - 0); - - return cudf::make_lists_column(n, std::move(off_col), std::move(data_col), 0, {}); + auto off_col = + std::make_unique(cudf::data_type{cudf::type_id::INT32}, + n + 1, + std::move(d_offsets), + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), + 0); + auto data_col = + std::make_unique(cudf::data_type{cudf::type_id::UINT8}, + static_cast(flat.size()), + std::move(d_data), + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), + 0); + + return cudf::make_lists_column(n, + std::move(off_col), + std::move(data_col), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); }; std::vector> children; children.emplace_back(build_list_col(meta_rows)); children.emplace_back(build_list_col(val_rows)); - return cudf::make_structs_column(n, std::move(children), 0, {}, stream, mr); + return cudf::make_structs_column(n, + std::move(children), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), + stream, + mr); } // Keys for the shared metadata dictionary: a=0, b=1, ... plus "z" for miss rows. diff --git a/cpp/benchmarks/json/json.cu b/cpp/benchmarks/json/json.cu index a7e6243793f7..0fefcda46b78 100644 --- a/cpp/benchmarks/json/json.cu +++ b/cpp/benchmarks/json/json.cu @@ -162,7 +162,11 @@ auto build_json_string_column(int desired_bytes, int num_rows) desired_bytes, num_rows, {*d_books, *d_bicycles}, *d_book_pct, *d_misc_order, *d_store_order}; auto [offsets, chars] = cudf::strings::detail::make_strings_children( jb, num_rows, cudf::get_default_stream(), cudf::get_current_device_resource_ref()); - return cudf::make_strings_column(num_rows, std::move(offsets), chars.release(), 0, {}); + return cudf::make_strings_column(num_rows, + std::move(offsets), + chars.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); } static std::string queries[] = {"$", diff --git a/cpp/benchmarks/quantiles/tdigest.cpp b/cpp/benchmarks/quantiles/tdigest.cpp index 9009dc4baf42..73cc52971627 100644 --- a/cpp/benchmarks/quantiles/tdigest.cpp +++ b/cpp/benchmarks/quantiles/tdigest.cpp @@ -50,8 +50,11 @@ void bm_tdigest_merge(nvbench::state& state) return i * tdigest_size; })); cudf::test::fixed_width_column_wrapper offsets(offset_iter, offset_iter + num_tdigests + 1); - auto list_col = - cudf::make_lists_column(num_tdigests, offsets.release(), inner_struct.release(), 0, {}); + auto list_col = cudf::make_lists_column(num_tdigests, + offsets.release(), + inner_struct.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); // min and max columns auto min_iter = cuda::make_constant_iterator(base_value); diff --git a/cpp/benchmarks/replace/clamp.cpp b/cpp/benchmarks/replace/clamp.cpp index 9326bc10a47d..f278d2aa4390 100644 --- a/cpp/benchmarks/replace/clamp.cpp +++ b/cpp/benchmarks/replace/clamp.cpp @@ -25,7 +25,8 @@ void bench_clamp(nvbench::state& state, nvbench::type_list) auto const dtype = cudf::type_to_id(); auto const input = create_random_column(dtype, row_count{n_rows}); - if (!include_nulls) input->set_null_mask(rmm::device_buffer{}, 0); + if (!include_nulls) + input->set_null_mask(cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), 0); auto [low_scalar, high_scalar] = cudf::minmax(*input); diff --git a/cpp/benchmarks/replace/nans.cpp b/cpp/benchmarks/replace/nans.cpp index d8d77ab54f65..e1289daa8917 100644 --- a/cpp/benchmarks/replace/nans.cpp +++ b/cpp/benchmarks/replace/nans.cpp @@ -25,7 +25,8 @@ void bench_replace_nans(nvbench::state& state, nvbench::type_list) auto const dtype = cudf::type_to_id(); auto const input = create_random_column(dtype, row_count{n_rows}); - if (!include_nulls) input->set_null_mask(rmm::device_buffer{}, 0); + if (!include_nulls) + input->set_null_mask(cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), 0); auto zero = cudf::make_fixed_width_scalar(0); diff --git a/cpp/benchmarks/rolling/rolling_sum.cpp b/cpp/benchmarks/rolling/rolling_sum.cpp index 28938c105aa9..74fe21ab1963 100644 --- a/cpp/benchmarks/rolling/rolling_sum.cpp +++ b/cpp/benchmarks/rolling/rolling_sum.cpp @@ -73,7 +73,7 @@ void bench_row_variable_rolling_sum(nvbench::state& state, nvbench::type_list(cudf::data_type(cudf::type_to_id()), num_rows, std::move(buf), - rmm::device_buffer{}, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), 0); }(); @@ -89,7 +89,7 @@ void bench_row_variable_rolling_sum(nvbench::state& state, nvbench::type_list(cudf::data_type(cudf::type_to_id()), num_rows, std::move(buf), - rmm::device_buffer{}, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), 0); }(); diff --git a/cpp/examples/parquet_inspect/parquet_inspect_utils.cpp b/cpp/examples/parquet_inspect/parquet_inspect_utils.cpp index 82681d82d087..89b4bf91749f 100644 --- a/cpp/examples/parquet_inspect/parquet_inspect_utils.cpp +++ b/cpp/examples/parquet_inspect/parquet_inspect_utils.cpp @@ -123,7 +123,7 @@ auto make_index_column(cudf::size_type num_rows, cuda::stream_ref stream) return std::make_unique(cudf::data_type{cudf::type_to_id()}, num_rows, std::move(buffer), - rmm::device_buffer{}, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), 0); } @@ -144,7 +144,7 @@ auto make_column(cudf::host_span host_data, cuda::stream_ref stream) return std::make_unique(cudf::data_type{cudf::type_to_id()}, host_data.size(), std::move(device_buffer), - rmm::device_buffer{}, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), 0); } @@ -180,14 +180,14 @@ auto make_page_data_list_column(cudf::host_span data, std::make_unique(cudf::data_type{cudf::type_to_id()}, num_pages_this_column, std::move(page_data_buffer), - rmm::device_buffer{}, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), 0); return cudf::make_lists_column(num_row_groups, std::move(offsets_column), std::move(page_data_column), 0, - rmm::device_buffer{}); + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); } } // namespace @@ -287,21 +287,24 @@ void write_rowgroup_metadata(cudf::io::parquet::FileMetaData const& metadata, rmm::device_buffer(row_group_byte_offsets.data(), num_row_groups * sizeof(int64_t), stream); stream.sync(); - columns.emplace_back(std::make_unique(cudf::data_type{cudf::type_to_id()}, - num_row_groups, - std::move(row_offsets_buffer), - rmm::device_buffer{}, - 0)); - columns.emplace_back(std::make_unique(cudf::data_type{cudf::type_to_id()}, - num_row_groups, - std::move(row_counts_buffer), - rmm::device_buffer{}, - 0)); - columns.emplace_back(std::make_unique(cudf::data_type{cudf::type_to_id()}, - num_row_groups, - std::move(byte_offsets_buffer), - rmm::device_buffer{}, - 0)); + columns.emplace_back( + std::make_unique(cudf::data_type{cudf::type_to_id()}, + num_row_groups, + std::move(row_offsets_buffer), + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), + 0)); + columns.emplace_back( + std::make_unique(cudf::data_type{cudf::type_to_id()}, + num_row_groups, + std::move(row_counts_buffer), + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), + 0)); + columns.emplace_back( + std::make_unique(cudf::data_type{cudf::type_to_id()}, + num_row_groups, + std::move(byte_offsets_buffer), + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), + 0)); auto table = std::make_unique(std::move(columns)); diff --git a/cpp/examples/strings/custom_optimized.cu b/cpp/examples/strings/custom_optimized.cu index 81d8ed50a781..b31d441d9476 100644 --- a/cpp/examples/strings/custom_optimized.cu +++ b/cpp/examples/strings/custom_optimized.cu @@ -143,11 +143,15 @@ std::unique_ptr redact_strings(cudf::column_view const& names, *d_names, *d_visibilities, offsets.data(), chars.data()); // create column from offsets vector (move only) - auto offsets_column = std::make_unique(std::move(offsets), rmm::device_buffer{}, 0); + auto offsets_column = std::make_unique( + std::move(offsets), cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), 0); // create column for chars vector (no copy is performed) - auto result = cudf::make_strings_column( - names.size(), std::move(offsets_column), chars.release(), 0, rmm::device_buffer{}); + auto result = cudf::make_strings_column(names.size(), + std::move(offsets_column), + chars.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); // wait for all of the above to finish stream.sync(); diff --git a/cpp/include/cudf/binaryop.hpp b/cpp/include/cudf/binaryop.hpp index 8a49d6f15c71..5f0096548371 100644 --- a/cpp/include/cudf/binaryop.hpp +++ b/cpp/include/cudf/binaryop.hpp @@ -317,7 +317,7 @@ bool is_supported_operation(data_type out, data_type lhs, data_type rhs, binary_ * @param mr Device memory resource used to allocate the returned valid mask * @return Computed validity mask */ -std::pair scalar_col_valid_mask_and( +std::pair, size_type> scalar_col_valid_mask_and( column_view const& col, scalar const& s, cuda::stream_ref stream = cudf::get_default_stream(), diff --git a/cpp/include/cudf/column/column.hpp b/cpp/include/cudf/column/column.hpp index a2617e12416c..7021906c2545 100644 --- a/cpp/include/cudf/column/column.hpp +++ b/cpp/include/cudf/column/column.hpp @@ -73,7 +73,9 @@ class column { * @param null_count The count of null elements. */ template () or cudf::is_chrono())> - column(rmm::device_uvector&& other, rmm::device_buffer&& null_mask, size_type null_count) + column(rmm::device_uvector&& other, + cuda::device_buffer&& null_mask, + size_type null_count) : _type{cudf::data_type{cudf::type_to_id()}}, _size{[&]() { CUDF_EXPECTS( @@ -103,7 +105,7 @@ class column { * @param null_count Optional, the count of null elements. * @param children Optional, vector of child columns */ - template + template > column(data_type dtype, size_type size, B1&& data, @@ -166,7 +168,7 @@ class column { * `new_null_count` is 0. * @param new_null_count The count of null elements. */ - void set_null_mask(rmm::device_buffer&& new_null_mask, size_type new_null_count); + void set_null_mask(cuda::device_buffer&& new_null_mask, size_type new_null_count); /** * @brief Sets the column's null value indicator bitmask to `new_null_mask`. @@ -180,7 +182,7 @@ class column { * @param stream The stream on which to perform the allocation and copy. Uses the default CUDF * stream if none is specified. */ - void set_null_mask(rmm::device_buffer const& new_null_mask, + void set_null_mask(cuda::device_buffer const& new_null_mask, size_type new_null_count, cuda::stream_ref stream = cudf::get_default_stream()); @@ -247,9 +249,9 @@ class column { * Returned by `column::release()`. */ struct contents { - std::unique_ptr data; ///< data device memory buffer - std::unique_ptr null_mask; ///< null mask device memory buffer - std::vector> children; ///< child columns + std::unique_ptr data; ///< data device memory buffer + std::unique_ptr> null_mask; ///< null mask device memory buffer + std::vector> children; ///< child columns }; /** @@ -324,9 +326,10 @@ class column { cudf::size_type _size{}; ///< The number of elements in the column rmm::device_buffer _data{}; ///< Dense, contiguous, type erased device memory ///< buffer containing the column elements - rmm::device_buffer _null_mask{}; ///< Bitmask used to represent null values. - ///< May be empty if `null_count() == 0` - mutable cudf::size_type _null_count{}; ///< The number of null elements + cuda::device_buffer _null_mask = cudf::create_null_mask( + 0, cudf::mask_state::UNALLOCATED); ///< Bitmask used to represent null values. + ///< May be empty if `null_count() == 0` + mutable cudf::size_type _null_count{}; ///< The number of null elements std::vector> _children{}; ///< Depending on element type, child ///< columns may contain additional data }; diff --git a/cpp/include/cudf/column/column_factories.hpp b/cpp/include/cudf/column/column_factories.hpp index 55b86ec34ec4..f3cad6e1679f 100644 --- a/cpp/include/cudf/column/column_factories.hpp +++ b/cpp/include/cudf/column/column_factories.hpp @@ -442,7 +442,7 @@ std::unique_ptr make_strings_column(size_type num_strings, std::unique_ptr offsets_column, rmm::device_buffer&& chars_buffer, size_type null_count, - rmm::device_buffer&& null_mask); + cuda::device_buffer&& null_mask); /** * @brief Construct a LIST type column given offsets column, child column, null mask and null @@ -501,7 +501,7 @@ std::unique_ptr make_lists_column(size_type num_rows, std::unique_ptr offsets_column, std::unique_ptr child_column, size_type null_count, - rmm::device_buffer&& null_mask); + cuda::device_buffer&& null_mask); /** * @brief Create an empty LIST column @@ -540,7 +540,7 @@ std::unique_ptr make_structs_column( size_type num_rows, std::vector>&& child_columns, size_type null_count, - rmm::device_buffer&& null_mask, + cuda::device_buffer&& null_mask, cuda::stream_ref stream = cudf::get_default_stream(), rmm::device_async_resource_ref mr = cudf::get_current_device_resource_ref()); @@ -574,7 +574,7 @@ std::unique_ptr create_structs_hierarchy( size_type num_rows, std::vector>&& child_columns, size_type null_count, - rmm::device_buffer&& null_mask, + cuda::device_buffer&& null_mask, cuda::stream_ref stream = cudf::get_default_stream(), rmm::device_async_resource_ref mr = cudf::get_current_device_resource_ref()); diff --git a/cpp/include/cudf/concatenate.hpp b/cpp/include/cudf/concatenate.hpp index e9beada299a6..e3d618df5c68 100644 --- a/cpp/include/cudf/concatenate.hpp +++ b/cpp/include/cudf/concatenate.hpp @@ -11,6 +11,7 @@ #include #include +#include #include #include @@ -39,7 +40,7 @@ namespace CUDF_EXPORT cudf { * @param stream CUDA stream used for device memory operations and kernel launches * @return Bitmasks of all the column views in the views vector */ -rmm::device_buffer concatenate_masks( +cuda::device_buffer concatenate_masks( std::span views, cuda::stream_ref stream = cudf::get_default_stream(), rmm::device_async_resource_ref mr = cudf::get_current_device_resource_ref()); diff --git a/cpp/include/cudf/detail/concatenate_masks.hpp b/cpp/include/cudf/detail/concatenate_masks.hpp index 74c75f5dee55..574b2401cc47 100644 --- a/cpp/include/cudf/detail/concatenate_masks.hpp +++ b/cpp/include/cudf/detail/concatenate_masks.hpp @@ -11,6 +11,7 @@ #include +#include #include #include @@ -55,9 +56,9 @@ size_type concatenate_masks(host_span views, * * @param stream CUDA stream used for device memory operations and kernel launches. */ -rmm::device_buffer concatenate_masks(std::span views, - cuda::stream_ref stream, - rmm::device_async_resource_ref mr); +cuda::device_buffer concatenate_masks(std::span views, + cuda::stream_ref stream, + rmm::device_async_resource_ref mr); } // namespace detail } // namespace cudf diff --git a/cpp/include/cudf/detail/gather.cuh b/cpp/include/cudf/detail/gather.cuh index d8e4a64da313..aa84a9abf1c8 100644 --- a/cpp/include/cudf/detail/gather.cuh +++ b/cpp/include/cudf/detail/gather.cuh @@ -357,11 +357,12 @@ struct column_gatherer_impl { lists::detail::gather_list_nested(list.get_sliced_child(stream), gd, stream, output_mr); // return the final column - return make_lists_column(gather_map_size, - std::move(gd.offsets), - std::move(child), - 0, - rmm::device_buffer{0, stream, output_mr}); + return make_lists_column( + gather_map_size, + std::move(gd.offsets), + std::move(child), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED, stream, output_mr)); } // it's a leaf. do a regular gather @@ -369,11 +370,12 @@ struct column_gatherer_impl { lists::detail::gather_list_leaf(list.get_sliced_child(stream), gd, stream, output_mr); // assemble final column - return make_lists_column(gather_map_size, - std::move(gd.offsets), - std::move(child), - 0, - rmm::device_buffer{0, stream, output_mr}); + return make_lists_column( + gather_map_size, + std::move(gd.offsets), + std::move(child), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED, stream, output_mr)); } }; @@ -494,7 +496,10 @@ struct column_gatherer_impl { gather_map_size, std::move(output_struct_members), 0, - rmm::device_buffer{0, stream, output_mr}, // Null mask will be fixed up in cudf::gather(). + cudf::create_null_mask(0, + cudf::mask_state::UNALLOCATED, + stream, + output_mr), // Null mask will be fixed up in cudf::gather(). stream, output_mr); } diff --git a/cpp/include/cudf/detail/null_mask.cuh b/cpp/include/cudf/detail/null_mask.cuh index 57ed28632811..a86002fe7d93 100644 --- a/cpp/include/cudf/detail/null_mask.cuh +++ b/cpp/include/cudf/detail/null_mask.cuh @@ -253,29 +253,31 @@ rmm::device_uvector inplace_segmented_bitmask_binop( * @param stream CUDA stream used for device memory operations and kernel launches */ template -std::pair bitmask_binop(Binop op, - host_span masks, - host_span masks_begin_bits, - size_type mask_size_bits, - cuda::stream_ref stream, - rmm::device_async_resource_ref mr) +std::pair, size_type> bitmask_binop( + Binop op, + host_span masks, + host_span masks_begin_bits, + size_type mask_size_bits, + cuda::stream_ref stream, + rmm::device_async_resource_ref mr) { - auto dest_mask = rmm::device_buffer{bitmask_allocation_size_bytes(mask_size_bits), stream, mr}; + auto dest_mask = + cudf::create_null_mask(mask_size_bits, cudf::mask_state::UNINITIALIZED, stream, mr); auto null_count = - mask_size_bits - - inplace_bitmask_binop(op, - device_span(static_cast(dest_mask.data()), - num_bitmask_words(mask_size_bits)), - masks, - masks_begin_bits, - mask_size_bits, - stream); + mask_size_bits - inplace_bitmask_binop( + op, + device_span(reinterpret_cast(dest_mask.data()), + num_bitmask_words(mask_size_bits)), + masks, + masks_begin_bits, + mask_size_bits, + stream); return std::pair(std::move(dest_mask), null_count); } template -std::pair>, std::vector> +std::pair>>, std::vector> segmented_bitmask_binop(Binop op, host_span masks, host_span masks_begin_bits, @@ -296,14 +298,15 @@ segmented_bitmask_binop(Binop op, "At least one segment needs to be passed for bitwise operations"); auto const num_segments = segment_offsets.size() - 1; - std::vector> h_destination_masks; + std::vector>> h_destination_masks; h_destination_masks.reserve(num_segments); std::vector h_destination_masks_ptrs; h_destination_masks_ptrs.reserve(num_segments); for (size_t i = 0; i < segment_offsets.size() - 1; i++) { - h_destination_masks.push_back(std::make_unique(num_bytes, stream, mr)); + h_destination_masks.push_back(std::make_unique>( + cudf::create_null_mask(num_bytes * CHAR_BIT, cudf::mask_state::UNINITIALIZED, stream, mr))); h_destination_masks_ptrs.push_back( - static_cast(h_destination_masks.back()->data())); + reinterpret_cast(h_destination_masks.back()->data())); } auto destination_masks = cudf::detail::make_device_uvector_async( h_destination_masks_ptrs, stream, cudf::get_current_device_resource_ref()); @@ -804,7 +807,7 @@ std::vector segmented_null_count(bitmask_type const* bitmask, * @return A pair containing the reduced null mask and number of nulls. */ template -std::pair segmented_null_mask_reduction( +std::pair, size_type> segmented_null_mask_reduction( bitmask_type const* bitmask, OffsetIterator first_bit_indices_begin, OffsetIterator first_bit_indices_end, diff --git a/cpp/include/cudf/detail/null_mask.hpp b/cpp/include/cudf/detail/null_mask.hpp index cf4f8130af25..bff736ed6bb8 100644 --- a/cpp/include/cudf/detail/null_mask.hpp +++ b/cpp/include/cudf/detail/null_mask.hpp @@ -23,10 +23,10 @@ namespace detail { * * @param stream CUDA stream used for device memory operations and kernel launches. */ -rmm::device_buffer create_null_mask(size_type size, - mask_state state, - cuda::stream_ref stream, - rmm::device_async_resource_ref mr); +cuda::device_buffer create_null_mask(size_type size, + mask_state state, + cuda::stream_ref stream, + rmm::device_async_resource_ref mr); /** * @copydoc cudf::set_null_mask(bitmask_type*, size_type, size_type, bool) @@ -162,20 +162,20 @@ std::vector segmented_null_count(bitmask_type const* bitmask, * * @param stream CUDA stream used for device memory operations and kernel launches. */ -rmm::device_buffer copy_bitmask(bitmask_type const* mask, - size_type begin_bit, - size_type end_bit, - cuda::stream_ref stream, - rmm::device_async_resource_ref mr); +cuda::device_buffer copy_bitmask(bitmask_type const* mask, + size_type begin_bit, + size_type end_bit, + cuda::stream_ref stream, + rmm::device_async_resource_ref mr); /** * @copydoc cudf::copy_bitmask(column_view const& view, rmm::device_async_resource_ref) * * @param stream CUDA stream used for device memory operations and kernel launches. */ -rmm::device_buffer copy_bitmask(column_view const& view, - cuda::stream_ref stream, - rmm::device_async_resource_ref mr); +cuda::device_buffer copy_bitmask(column_view const& view, + cuda::stream_ref stream, + rmm::device_async_resource_ref mr); /** * @copydoc bitmask_and(host_span, host_span const, @@ -183,25 +183,26 @@ rmm::device_buffer copy_bitmask(column_view const& view, * * @param stream CUDA stream used for device memory operations and kernel launches */ -std::pair bitmask_and(host_span masks, - host_span masks_begin_bits, - size_type mask_size_bits, - cuda::stream_ref stream, - rmm::device_async_resource_ref mr); +std::pair, size_type> bitmask_and( + host_span masks, + host_span masks_begin_bits, + size_type mask_size_bits, + cuda::stream_ref stream, + rmm::device_async_resource_ref mr); /** * @copydoc cudf::bitmask_and * * @param[in] stream CUDA stream used for device memory operations and kernel launches. */ -std::pair bitmask_and(table_view const& view, - cuda::stream_ref stream, - rmm::device_async_resource_ref mr); +std::pair, size_type> bitmask_and(table_view const& view, + cuda::stream_ref stream, + rmm::device_async_resource_ref mr); /** * @copydoc cudf::segmented_bitmask_and */ -std::pair>, std::vector> +std::pair>>, std::vector> segmented_bitmask_and(host_span colviews, host_span segment_offsets, cuda::stream_ref stream, @@ -210,7 +211,7 @@ segmented_bitmask_and(host_span colviews, /** * @copydoc cudf::segmented_bitmask_and */ -std::pair>, std::vector> +std::pair>>, std::vector> segmented_bitmask_and(host_span masks, host_span segment_offsets, size_type mask_size_bits, @@ -221,9 +222,9 @@ segmented_bitmask_and(host_span masks, * * @param[in] stream CUDA stream used for device memory operations and kernel launches. */ -std::pair bitmask_or(table_view const& view, - cuda::stream_ref stream, - rmm::device_async_resource_ref mr); +std::pair, size_type> bitmask_or(table_view const& view, + cuda::stream_ref stream, + rmm::device_async_resource_ref mr); /** * @brief Performs a bitwise AND of the specified bitmasks, diff --git a/cpp/include/cudf/detail/row_operator/preprocessed_table.cuh b/cpp/include/cudf/detail/row_operator/preprocessed_table.cuh index ba85a2b0578a..da21369efa2a 100644 --- a/cpp/include/cudf/detail/row_operator/preprocessed_table.cuh +++ b/cpp/include/cudf/detail/row_operator/preprocessed_table.cuh @@ -7,10 +7,10 @@ #include -#include #include #include +#include #include #include @@ -78,7 +78,7 @@ struct preprocessed_table { rmm::device_async_resource_ref>; preprocessed_table(table_device_view_owner&& table, - std::vector&& null_buffers, + std::vector>&& null_buffers, std::vector>&& tmp_columns) : _t(std::move(table)), _null_buffers(std::move(null_buffers)), @@ -87,7 +87,7 @@ struct preprocessed_table { } table_device_view_owner _t; - std::vector _null_buffers; + std::vector> _null_buffers; std::vector> _tmp_columns; }; diff --git a/cpp/include/cudf/detail/scatter.cuh b/cpp/include/cudf/detail/scatter.cuh index 32e33a9b2f5f..d6a8a03b941b 100644 --- a/cpp/include/cudf/detail/scatter.cuh +++ b/cpp/include/cudf/detail/scatter.cuh @@ -306,12 +306,13 @@ struct column_scatterer_impl { // Need to put the result column in a vector to call `gather_bitmask`. std::vector> result; - result.emplace_back(cudf::make_structs_column(target.size(), - std::move(output_struct_members), - 0, - rmm::device_buffer{0, stream, mr}, - stream, - mr)); + result.emplace_back(cudf::make_structs_column( + target.size(), + std::move(output_struct_members), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED, stream, mr), + stream, + mr)); // Only gather bitmask from the target column for the rows that have not been scattered onto // The bitmask from the source column will be gathered at the top level `scatter()` call. diff --git a/cpp/include/cudf/detail/structs/utilities.hpp b/cpp/include/cudf/detail/structs/utilities.hpp index e41efb48f135..c10018935bbd 100644 --- a/cpp/include/cudf/detail/structs/utilities.hpp +++ b/cpp/include/cudf/detail/structs/utilities.hpp @@ -32,7 +32,7 @@ struct temporary_nullable_data { /** * @brief Store the newly generated null masks (if any). */ - std::vector new_null_masks; + std::vector> new_null_masks; /** * @brief Store the newly generated columns with new null masks (if any). diff --git a/cpp/include/cudf/detail/transform.hpp b/cpp/include/cudf/detail/transform.hpp index 11406c69a345..c0d2674dcb46 100644 --- a/cpp/include/cudf/detail/transform.hpp +++ b/cpp/include/cudf/detail/transform.hpp @@ -31,7 +31,7 @@ std::unique_ptr compute_column(table_view const& table, * * @param stream CUDA stream used for device memory operations and kernel launches. */ -std::pair, cudf::size_type> bools_to_mask( +std::pair>, cudf::size_type> bools_to_mask( column_view const& input, cuda::stream_ref stream, rmm::device_async_resource_ref mr); /** diff --git a/cpp/include/cudf/detail/valid_if.cuh b/cpp/include/cudf/detail/valid_if.cuh index 486c3d080ef7..3dbc9be002c8 100644 --- a/cpp/include/cudf/detail/valid_if.cuh +++ b/cpp/include/cudf/detail/valid_if.cuh @@ -64,7 +64,7 @@ CUDF_KERNEL void valid_if_kernel( * * Bit `i` in the output mask will be set if `p(*(begin+i)) == true`. * - * If `distance(begin,end) == 0`, returns an empty `rmm::device_buffer`. + * If `distance(begin,end) == 0`, returns an empty `cuda::device_buffer`. * * @throws cudf::logic_error if `(begin > end)` * @@ -76,11 +76,11 @@ CUDF_KERNEL void valid_if_kernel( * @return A pair containing a `device_buffer` with the new bitmask and its null count */ template -std::pair valid_if(InputIterator begin, - InputIterator end, - Predicate p, - cuda::stream_ref stream, - cudf::memory_resources resources) +std::pair, size_type> valid_if(InputIterator begin, + InputIterator end, + Predicate p, + cuda::stream_ref stream, + cudf::memory_resources resources) { CUDF_EXPECTS(begin <= end, "Invalid range."); @@ -97,7 +97,7 @@ std::pair valid_if(InputIterator begin, grid_1d grid{size, block_size}; valid_if_kernel<<>>( - static_cast(null_mask.data()), begin, size, p, valid_count.data()); + reinterpret_cast(null_mask.data()), begin, size, p, valid_count.data()); null_count = size - valid_count.value(stream); } diff --git a/cpp/include/cudf/dictionary/dictionary_factories.hpp b/cpp/include/cudf/dictionary/dictionary_factories.hpp index bd336c866d8c..2a5a43c421ad 100644 --- a/cpp/include/cudf/dictionary/dictionary_factories.hpp +++ b/cpp/include/cudf/dictionary/dictionary_factories.hpp @@ -76,7 +76,7 @@ std::unique_ptr make_dictionary_column( */ std::unique_ptr make_dictionary_column(std::unique_ptr keys_column, std::unique_ptr indices_column, - rmm::device_buffer&& null_mask, + cuda::device_buffer&& null_mask, size_type null_count); /** diff --git a/cpp/include/cudf/lists/detail/scatter.cuh b/cpp/include/cudf/lists/detail/scatter.cuh index 48d39f054ee0..8ee613641609 100644 --- a/cpp/include/cudf/lists/detail/scatter.cuh +++ b/cpp/include/cudf/lists/detail/scatter.cuh @@ -120,8 +120,9 @@ std::unique_ptr scatter_impl(rmm::device_uvector cons std::vector> children; children.emplace_back(std::move(offsets_column)); children.emplace_back(std::move(child_column)); - auto null_mask = target.has_nulls() ? cudf::detail::copy_bitmask(target, stream, mr) - : rmm::device_buffer{0, stream, mr}; + auto null_mask = target.has_nulls() + ? cudf::detail::copy_bitmask(target, stream, mr) + : cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED, stream, mr); // The output column from this function only has null masks copied from the target columns. // That is still not a correct final null mask for the scatter result. @@ -224,11 +225,11 @@ std::unique_ptr scatter(scalar const& slr, auto const num_rows = target.size(); if (num_rows == 0) { return cudf::empty_like(target); } - auto lv = static_cast(&slr); - bool slr_valid = slr.is_valid(stream); - rmm::device_buffer null_mask = slr_valid - ? cudf::create_null_mask(1, mask_state::UNALLOCATED, stream, mr) - : cudf::create_null_mask(1, mask_state::ALL_NULL, stream, mr); + auto lv = static_cast(&slr); + bool slr_valid = slr.is_valid(stream); + cuda::device_buffer null_mask = + slr_valid ? cudf::create_null_mask(1, mask_state::UNALLOCATED, stream, mr) + : cudf::create_null_mask(1, mask_state::ALL_NULL, stream, mr); auto offset_column = make_numeric_column(data_type{type_id::INT32}, 2, mask_state::UNALLOCATED, stream, mr); thrust::sequence(rmm::exec_policy_nosync(stream, cudf::get_current_device_resource_ref()), @@ -239,7 +240,7 @@ std::unique_ptr scatter(scalar const& slr, auto wrapped = column_view(data_type{type_id::LIST}, 1, nullptr, - static_cast(null_mask.data()), + reinterpret_cast(null_mask.data()), slr_valid ? 0 : 1, 0, {offset_column->view(), lv->view()}); diff --git a/cpp/include/cudf/null_mask.hpp b/cpp/include/cudf/null_mask.hpp index f8d627b8ff0b..cff77fea1c3e 100644 --- a/cpp/include/cudf/null_mask.hpp +++ b/cpp/include/cudf/null_mask.hpp @@ -10,8 +10,7 @@ #include #include -#include - +#include #include #include @@ -82,7 +81,7 @@ size_type num_bitmask_words(size_type number_of_bits); * @return A `device_buffer` for use as a null bitmask * satisfying the desired size and state */ -rmm::device_buffer create_null_mask( +cuda::device_buffer create_null_mask( size_type size, mask_state state, cuda::stream_ref stream = cudf::get_default_stream(), @@ -166,7 +165,7 @@ void set_null_masks_unsafe(cudf::host_span bitmasks, * @return A `device_buffer` containing the bits * `[begin_bit, end_bit)` from `mask`. */ -rmm::device_buffer copy_bitmask( +cuda::device_buffer copy_bitmask( bitmask_type const* mask, size_type begin_bit, size_type end_bit, @@ -185,7 +184,7 @@ rmm::device_buffer copy_bitmask( * @return A `device_buffer` containing the bits * `[view.offset(), view.offset() + view.size())` from `view`'s bitmask. */ -rmm::device_buffer copy_bitmask( +cuda::device_buffer copy_bitmask( column_view const& view, cuda::stream_ref stream = cudf::get_default_stream(), rmm::device_async_resource_ref mr = cudf::get_current_device_resource_ref()); @@ -202,7 +201,7 @@ rmm::device_buffer copy_bitmask( * @param mr Device memory resource used to allocate the returned device_buffer * @return A pair of resulting bitmask and count of unset bits */ -std::pair bitmask_and( +std::pair, size_type> bitmask_and( table_view const& view, cuda::stream_ref stream = cudf::get_default_stream(), rmm::device_async_resource_ref mr = cudf::get_current_device_resource_ref()); @@ -219,7 +218,7 @@ std::pair bitmask_and( * @param mr Device memory resource used to allocate the returned device_buffer * @return A pair of resulting bitmask of size mask_size and the count of unset bits */ -std::pair bitmask_and( +std::pair, size_type> bitmask_and( host_span masks, host_span begin_bits, size_type mask_size, @@ -250,7 +249,7 @@ std::pair bitmask_and( * @param mr Device memory resource used to allocate the returned device_buffer * @return A pair of vectors containing resulting bitmask and count of unset bits for each segment */ -std::pair>, std::vector> +std::pair>>, std::vector> segmented_bitmask_and(host_span colviews, host_span segment_offsets, cuda::stream_ref stream = cudf::get_default_stream(), @@ -280,7 +279,7 @@ segmented_bitmask_and(host_span colviews, * @param mr Device memory resource used to allocate the returned device_buffer * @return A pair of vectors containing resulting bitmask and count of unset bits for each segment */ -std::pair>, std::vector> +std::pair>>, std::vector> segmented_bitmask_and(host_span masks, host_span segment_offsets, size_type mask_size_bits, @@ -299,7 +298,7 @@ segmented_bitmask_and(host_span masks, * @param mr Device memory resource used to allocate the returned device_buffer * @return A pair of resulting bitmask and count of unset bits */ -std::pair bitmask_or( +std::pair, size_type> bitmask_or( table_view const& view, cuda::stream_ref stream = cudf::get_default_stream(), rmm::device_async_resource_ref mr = cudf::get_current_device_resource_ref()); diff --git a/cpp/include/cudf/strings/detail/copy_if_else.cuh b/cpp/include/cudf/strings/detail/copy_if_else.cuh index 9e842a8d1889..112c74fdc3db 100644 --- a/cpp/include/cudf/strings/detail/copy_if_else.cuh +++ b/cpp/include/cudf/strings/detail/copy_if_else.cuh @@ -63,7 +63,7 @@ std::unique_ptr copy_if_else(StringIterLeft lhs_begin, }, stream, mr); - if (null_count == 0) { null_mask = rmm::device_buffer{}; } + if (null_count == 0) { null_mask = cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED); } // build vector of strings rmm::device_uvector indices(strings_count, stream); diff --git a/cpp/include/cudf/strings/detail/gather.cuh b/cpp/include/cudf/strings/detail/gather.cuh index 5ca1f3375633..575a0e2b8286 100644 --- a/cpp/include/cudf/strings/detail/gather.cuh +++ b/cpp/include/cudf/strings/detail/gather.cuh @@ -338,7 +338,7 @@ std::unique_ptr gather(strings_column_view const& strings, std::move(out_offsets_column), out_chars_data.release(), 0, // caller sets these - rmm::device_buffer{}); + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); } /** diff --git a/cpp/include/cudf/strings/detail/strings_column_factories.cuh b/cpp/include/cudf/strings/detail/strings_column_factories.cuh index ad44a46365cf..4c676bda6cb1 100644 --- a/cpp/include/cudf/strings/detail/strings_column_factories.cuh +++ b/cpp/include/cudf/strings/detail/strings_column_factories.cuh @@ -64,8 +64,9 @@ std::unique_ptr make_strings_column(IndexPairIterator begin, auto validator = [] __device__(string_index_pair const item) { return item.first != nullptr; }; auto new_nulls = cudf::detail::valid_if(begin, end, validator, stream, mr); auto const null_count = new_nulls.second; - auto null_mask = - (null_count > 0) ? std::move(new_nulls.first) : rmm::device_buffer{0, stream, mr}; + auto null_mask = (null_count > 0) + ? std::move(new_nulls.first) + : cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED, stream, mr); // build chars column auto chars_data = diff --git a/cpp/include/cudf/transform.hpp b/cpp/include/cudf/transform.hpp index 31ff816fe269..eb467ee9b6fb 100644 --- a/cpp/include/cudf/transform.hpp +++ b/cpp/include/cudf/transform.hpp @@ -11,6 +11,8 @@ #include #include +#include + #include #include #include @@ -406,7 +408,7 @@ std::unique_ptr transform_lto( * @return A pair containing a `device_buffer` with the new bitmask and its * null count obtained by replacing `NaN` in `input` with null. */ -[[deprecated]] std::pair, size_type> nans_to_nulls( +[[deprecated]] std::pair>, size_type> nans_to_nulls( column_view const& input, cuda::stream_ref stream = cudf::get_default_stream(), rmm::device_async_resource_ref mr = cudf::get_current_device_resource_ref()); @@ -518,7 +520,7 @@ std::unique_ptr
compute_table_jit( * null count obtained from input considering `true` represent `valid`/`1` and * `false` represent `invalid`/`0`. */ -std::pair, cudf::size_type> bools_to_mask( +std::pair>, cudf::size_type> bools_to_mask( column_view const& input, cuda::stream_ref stream = cudf::get_default_stream(), rmm::device_async_resource_ref mr = cudf::get_current_device_resource_ref()); diff --git a/cpp/include/cudf_test/column_wrapper.hpp b/cpp/include/cudf_test/column_wrapper.hpp index e39a94806af4..005a9b51280b 100644 --- a/cpp/include/cudf_test/column_wrapper.hpp +++ b/cpp/include/cudf_test/column_wrapper.hpp @@ -288,21 +288,23 @@ std::pair, cudf::size_type> make_null_mask_vector(Vali * @param end The end of the validity indicator sequence * @param stream CUDA stream used for device memory operations * @param mr Memory resources used to allocate the returned buffer - * @return rmm::device_buffer Contains a bitmask where bits are set for every + * @return cuda::device_buffer Contains a bitmask where bits are set for every * element in `[begin,end)` that evaluated to `true`. */ template -std::pair make_null_mask( +std::pair, cudf::size_type> make_null_mask( ValidityIterator begin, ValidityIterator end, cuda::stream_ref stream = cudf::test::get_default_stream(), cudf::memory_resources mr = cudf::get_current_device_resource_ref()) { auto [null_mask, null_count] = make_null_mask_vector(begin, end); - rmm::device_buffer d_mask{null_mask.data(), - cudf::bitmask_allocation_size_bytes(cudf::distance(begin, end)), - stream, - mr.get_output_mr()}; + auto const* data = reinterpret_cast(null_mask.data()); + cuda::device_buffer d_mask{ + stream, + mr.get_output_mr(), + data, + data + cudf::bitmask_allocation_size_bytes(cudf::distance(begin, end))}; stream.sync(); // wait for async H2D before host source is destroyed return {std::move(d_mask), null_count}; } @@ -390,7 +392,7 @@ class fixed_width_column_wrapper : public detail::column_wrapper { new cudf::column{cudf::data_type{cudf::type_to_id()}, size, detail::make_elements(begin, end, stream, mr), - rmm::device_buffer{}, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), 0}); } @@ -625,7 +627,11 @@ class fixed_point_column_wrapper : public detail::column_wrapper { auto const id = type_to_id>(); auto const data_type = cudf::data_type{id, static_cast(scale)}; rmm::device_buffer data{elements.data(), size * sizeof(Rep), stream, mr.get_output_mr()}; - wrapped.reset(new cudf::column{data_type, size, std::move(data), rmm::device_buffer{}, 0}); + wrapped.reset(new cudf::column{data_type, + size, + std::move(data), + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), + 0}); stream.sync(); // wait for async H2D before host source is destroyed } @@ -848,10 +854,13 @@ class strings_column_wrapper : public detail::column_wrapper { auto d_chars = cudf::detail::make_device_uvector_async(chars, stream, mr.get_output_mr()); auto d_offsets = std::make_unique( cudf::detail::make_device_uvector(offsets, stream, mr.get_output_mr()), - rmm::device_buffer{}, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), 0); - wrapped = - cudf::make_strings_column(num_strings, std::move(d_offsets), d_chars.release(), 0, {}); + wrapped = cudf::make_strings_column(num_strings, + std::move(d_offsets), + d_chars.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); } /** @@ -897,16 +906,15 @@ class strings_column_wrapper : public detail::column_wrapper { wrapped = cudf::make_empty_column(cudf::type_id::STRING); return; } - auto [chars, offsets] = detail::make_chars_and_offsets(begin, end, v); - auto [null_mask, null_count] = detail::make_null_mask_vector(v, v + num_strings); + auto [chars, offsets] = detail::make_chars_and_offsets(begin, end, v); auto d_chars = cudf::detail::make_device_uvector_async(chars, stream, mr.get_output_mr()); auto d_offsets = std::make_unique( cudf::detail::make_device_uvector_async(offsets, stream, mr.get_output_mr()), - rmm::device_buffer{}, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), 0); - auto d_bitmask = cudf::detail::make_device_uvector(null_mask, stream, mr.get_output_mr()); - wrapped = cudf::make_strings_column( - num_strings, std::move(d_offsets), d_chars.release(), null_count, d_bitmask.release()); + auto [d_bitmask, null_count] = detail::make_null_mask(v, v + num_strings, stream, mr); + wrapped = cudf::make_strings_column( + num_strings, std::move(d_offsets), d_chars.release(), null_count, std::move(d_bitmask)); } /** @@ -1783,7 +1791,7 @@ class lists_column_wrapper : public detail::column_wrapper { offsets.release(), values.release(), valid ? 0 : 1, - valid ? rmm::device_buffer{} + valid ? cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED) : cudf::create_null_mask(1, cudf::mask_state::ALL_NULL, stream, mr.get_output_mr())); } @@ -1801,7 +1809,7 @@ class lists_column_wrapper : public detail::column_wrapper { std::unique_ptr&& offsets, std::unique_ptr&& values, size_type null_count, - rmm::device_buffer&& null_mask) + cuda::device_buffer&& null_mask) { // construct the list column wrapped = make_lists_column( @@ -1883,7 +1891,10 @@ class lists_column_wrapper : public detail::column_wrapper { depth = expected_depth + 1; auto [null_mask, null_count] = [&] { - if (v.size() <= 0) return std::make_pair(rmm::device_buffer{}, cudf::size_type{0}); + if (v.size() <= 0) { + return std::make_pair(cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), + cudf::size_type{0}); + } return cudf::test::detail::make_null_mask(v.begin(), v.end(), stream, mr); }(); @@ -1922,8 +1933,11 @@ class lists_column_wrapper : public detail::column_wrapper { depth = 0; size_type num_elements = offsets->size() == 0 ? 0 : offsets->size() - 1; - wrapped = - make_lists_column(num_elements, std::move(offsets), std::move(c), 0, rmm::device_buffer{}); + wrapped = make_lists_column(num_elements, + std::move(offsets), + std::move(c), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); } /** @@ -2204,7 +2218,10 @@ class structs_column_wrapper : public detail::column_wrapper { "Validity buffer must have as many elements as rows in the struct column."); auto [null_mask, null_count] = [&] { - if (validity.size() <= 0) return std::make_pair(rmm::device_buffer{}, cudf::size_type{0}); + if (validity.size() <= 0) { + return std::make_pair(cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), + cudf::size_type{0}); + } return cudf::test::detail::make_null_mask(validity.begin(), validity.end(), stream, mr); }(); diff --git a/cpp/include/cudf_test/nanoarrow_utils.hpp b/cpp/include/cudf_test/nanoarrow_utils.hpp index 8194cabf2810..51855161e221 100644 --- a/cpp/include/cudf_test/nanoarrow_utils.hpp +++ b/cpp/include/cudf_test/nanoarrow_utils.hpp @@ -194,10 +194,11 @@ void populate_from_col(ArrowArray* arr, ArrowArrayBuffer(arr, 1), ArrowBufferDeallocator( [](ArrowBufferAllocator* alloc, uint8_t*, int64_t) { - auto buf = reinterpret_cast*>(alloc->private_data); + auto buf = + reinterpret_cast>*>(alloc->private_data); delete buf; }, - new std::unique_ptr(std::move(bitmask.first))))); + new std::unique_ptr>(std::move(bitmask.first))))); ArrowArrayBuffer(arr, 1)->size_bytes = cudf::bitmask_allocation_size_bytes(view.size()); ArrowArrayBuffer(arr, 1)->data = ptr; } diff --git a/cpp/libcudf_streaming/benchmarks/bench_partition.cpp b/cpp/libcudf_streaming/benchmarks/bench_partition.cpp index 6fdcb03c068f..022aa75bd407 100644 --- a/cpp/libcudf_streaming/benchmarks/bench_partition.cpp +++ b/cpp/libcudf_streaming/benchmarks/bench_partition.cpp @@ -28,7 +28,7 @@ std::unique_ptr create_int_table(cudf::size_type num_rows, cuda::st { auto data = rmm::device_buffer(rapidsmpf::safe_cast(num_rows) * sizeof(std::int32_t), stream); - auto validity = rmm::device_buffer(0, stream); // No nulls + auto validity = cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED, stream); // No nulls auto column = std::make_unique( cudf::data_type{cudf::type_id::INT32}, num_rows, std::move(data), std::move(validity), 0); diff --git a/cpp/libcudf_streaming/benchmarks/utils/random_data.cu b/cpp/libcudf_streaming/benchmarks/utils/random_data.cu index a11e2e74b942..3c2e2b5c6146 100644 --- a/cpp/libcudf_streaming/benchmarks/utils/random_data.cu +++ b/cpp/libcudf_streaming/benchmarks/utils/random_data.cu @@ -56,7 +56,8 @@ std::unique_ptr random_column(cudf::size_type nrows, { auto vec = random_device_vector(rapidsmpf::safe_cast(nrows), min_val, max_val, stream, mr); - return std::make_unique(std::move(vec), rmm::device_buffer{0, stream, mr}, 0); + return std::make_unique( + std::move(vec), cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED, stream, mr), 0); } cudf::table random_table(cudf::size_type ncolumns, diff --git a/cpp/libcudf_streaming/tests/streaming/test_channel_metadata.cpp b/cpp/libcudf_streaming/tests/streaming/test_channel_metadata.cpp index 1f35c41972ab..20941ebb1fef 100644 --- a/cpp/libcudf_streaming/tests/streaming/test_channel_metadata.cpp +++ b/cpp/libcudf_streaming/tests/streaming/test_channel_metadata.cpp @@ -169,11 +169,12 @@ class StreamingChannelMetadataGPU : public ::testing::Test { { rmm::device_buffer buf(vals.data(), vals.size() * sizeof(int32_t), stream); stream.sync(); - auto col = std::make_unique(cudf::data_type{cudf::type_id::INT32}, - static_cast(vals.size()), - std::move(buf), - rmm::device_buffer{}, - 0); + auto col = + std::make_unique(cudf::data_type{cudf::type_id::INT32}, + static_cast(vals.size()), + std::move(buf), + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), + 0); std::vector> cols; cols.push_back(std::move(col)); return std::make_shared(std::make_unique(std::move(cols)), stream); diff --git a/cpp/src/binaryop/binaryop.cpp b/cpp/src/binaryop/binaryop.cpp index fd972555a642..5f48188d0d50 100644 --- a/cpp/src/binaryop/binaryop.cpp +++ b/cpp/src/binaryop/binaryop.cpp @@ -55,13 +55,14 @@ bool is_supported_operation(data_type out, data_type lhs, data_type rhs, binary_ /** * @brief Computes output valid mask for op between a column and a scalar */ -std::pair scalar_col_valid_mask_and( +std::pair, size_type> scalar_col_valid_mask_and( column_view const& col, scalar const& s, cuda::stream_ref stream, rmm::device_async_resource_ref mr) { - if (col.is_empty()) return std::pair(rmm::device_buffer{0, stream, mr}, 0); + if (col.is_empty()) + return std::pair(cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED, stream, mr), 0); if (not s.is_valid(stream)) { return std::pair(cudf::detail::create_null_mask(col.size(), mask_state::ALL_NULL, stream, mr), @@ -69,7 +70,7 @@ std::pair scalar_col_valid_mask_and( } else if (s.is_valid(stream) and col.nullable()) { return std::pair(cudf::detail::copy_bitmask(col, stream, mr), col.null_count()); } else { - return std::pair(rmm::device_buffer{0, stream, mr}, 0); + return std::pair(cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED, stream, mr), 0); } } diff --git a/cpp/src/binaryop/compiled/binary_ops.cu b/cpp/src/binaryop/compiled/binary_ops.cu index 0e639d90e95d..30822fd8582d 100644 --- a/cpp/src/binaryop/compiled/binary_ops.cu +++ b/cpp/src/binaryop/compiled/binary_ops.cu @@ -53,7 +53,7 @@ struct scalar_as_column_view { // Null scalar needs a single-element null mask (kept alive by an auxiliary column) as its // validity (bool) cannot be reinterpreted as `bitmask_type` without reading out of bounds. auto null_mask = cudf::detail::create_null_mask(1, cudf::mask_state::ALL_NULL, stream, mr); - auto const* null_mask_ptr = static_cast(null_mask.data()); + auto const* null_mask_ptr = reinterpret_cast(null_mask.data()); auto aux_col = std::make_unique( data_type{type_id::INT8}, 0, rmm::device_buffer{}, std::move(null_mask), 1); auto col_v = column_view(s.type(), 1, h_scalar_type_view.data(), null_mask_ptr, 1); @@ -89,7 +89,7 @@ scalar_as_column_view::return_type scalar_as_column_view::operator()(null_mask.data()); + auto const* null_mask_ptr = reinterpret_cast(null_mask.data()); auto col_v = cudf::column_view( s.type(), 1, h_scalar_type_view.data(), null_mask_ptr, 1, 0, {offsets_column->view()}); std::vector> children; diff --git a/cpp/src/bitmask/null_mask.cu b/cpp/src/bitmask/null_mask.cu index 6eb9314cbf18..c5713edab8b8 100644 --- a/cpp/src/bitmask/null_mask.cu +++ b/cpp/src/bitmask/null_mask.cu @@ -65,21 +65,21 @@ size_type num_bitmask_words(size_type number_of_bits) namespace detail { // Create a device_buffer for a null mask -rmm::device_buffer create_null_mask(size_type size, - mask_state state, - cuda::stream_ref stream, - rmm::device_async_resource_ref mr) +cuda::device_buffer create_null_mask(size_type size, + mask_state state, + cuda::stream_ref stream, + rmm::device_async_resource_ref mr) { size_type mask_size{0}; if (state != mask_state::UNALLOCATED) { mask_size = bitmask_allocation_size_bytes(size); } - rmm::device_buffer mask(mask_size, stream, mr); + cuda::device_buffer mask(stream, mr, mask_size, cuda::no_init); - if (state != mask_state::UNINITIALIZED) { + if (mask_size > 0 && state != mask_state::UNINITIALIZED) { uint8_t fill_value = (state == mask_state::ALL_VALID) ? 0xff : 0x00; CUDF_CUDA_TRY(cudaMemsetAsync( - static_cast(mask.data()), fill_value, mask_size, stream.get())); + reinterpret_cast(mask.data()), fill_value, mask_size, stream.get())); } return mask; @@ -273,10 +273,10 @@ void set_null_mask(bitmask_type* bitmask, } // namespace detail // Create a device_buffer for a null mask -rmm::device_buffer create_null_mask(size_type size, - mask_state state, - cuda::stream_ref stream, - rmm::device_async_resource_ref mr) +cuda::device_buffer create_null_mask(size_type size, + mask_state state, + cuda::stream_ref stream, + rmm::device_async_resource_ref mr) { CUDF_FUNC_RANGE(); return detail::create_null_mask(size, state, stream, mr); @@ -354,35 +354,41 @@ CUDF_KERNEL void copy_offset_bitmask(bitmask_type* __restrict__ destination, } // namespace // Create a bitmask from a specific range -rmm::device_buffer copy_bitmask(bitmask_type const* mask, - size_type begin_bit, - size_type end_bit, - cuda::stream_ref stream, - rmm::device_async_resource_ref mr) +cuda::device_buffer copy_bitmask(bitmask_type const* mask, + size_type begin_bit, + size_type end_bit, + cuda::stream_ref stream, + rmm::device_async_resource_ref mr) { CUDF_EXPECTS(begin_bit >= 0 and begin_bit <= end_bit, "Invalid bit range."); - rmm::device_buffer dest_mask{}; + auto dest_mask = cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED, stream, mr); auto num_bytes = bitmask_allocation_size_bytes(end_bit - begin_bit); if ((mask == nullptr) || (num_bytes == 0)) { return dest_mask; } if (begin_bit == 0) { - dest_mask = rmm::device_buffer{static_cast(mask), num_bytes, stream, mr}; + auto const data = reinterpret_cast(mask); + dest_mask = cuda::device_buffer{stream, mr, data, data + num_bytes}; } else { auto number_of_mask_words = num_bitmask_words(end_bit - begin_bit); - dest_mask = rmm::device_buffer{num_bytes, stream, mr}; + dest_mask = + cudf::create_null_mask(end_bit - begin_bit, cudf::mask_state::UNINITIALIZED, stream, mr); cudf::detail::grid_1d config(number_of_mask_words, 256); copy_offset_bitmask<<>>( - static_cast(dest_mask.data()), mask, begin_bit, end_bit, number_of_mask_words); + reinterpret_cast(dest_mask.data()), + mask, + begin_bit, + end_bit, + number_of_mask_words); CUDF_CHECK_CUDA(stream.get()); } return dest_mask; } // Create a bitmask from a column view -rmm::device_buffer copy_bitmask(column_view const& view, - cuda::stream_ref stream, - rmm::device_async_resource_ref mr) +cuda::device_buffer copy_bitmask(column_view const& view, + cuda::stream_ref stream, + rmm::device_async_resource_ref mr) { - rmm::device_buffer null_mask{0, stream, mr}; + auto null_mask = cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED, stream, mr); if (view.nullable()) { null_mask = copy_bitmask(view.null_mask(), view.offset(), view.offset() + view.size(), stream, mr); @@ -605,11 +611,12 @@ cudf::size_type inplace_bitmask_and(device_span dest_mask, } // Bitwise AND of the masks -std::pair bitmask_and(host_span masks, - host_span begin_bits, - size_type mask_size, - cuda::stream_ref stream, - rmm::device_async_resource_ref mr) +std::pair, size_type> bitmask_and( + host_span masks, + host_span begin_bits, + size_type mask_size, + cuda::stream_ref stream, + rmm::device_async_resource_ref mr) { return bitmask_binop( [] __device__(bitmask_type left, bitmask_type right) { return left & right; }, @@ -621,11 +628,11 @@ std::pair bitmask_and(host_span bitmask_and(table_view const& view, - cuda::stream_ref stream, - rmm::device_async_resource_ref mr) +std::pair, size_type> bitmask_and(table_view const& view, + cuda::stream_ref stream, + rmm::device_async_resource_ref mr) { - rmm::device_buffer null_mask{0, stream, mr}; + auto null_mask = cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED, stream, mr); if (view.num_rows() == 0 or view.num_columns() == 0) { return std::pair(std::move(null_mask), 0); } @@ -656,7 +663,7 @@ std::pair bitmask_and(table_view const& view, constexpr bitmask_type all_set_mask = ~bitmask_type{0}; // Returns the bitwise AND of the null masks of all columns in the same segment of the input masks -std::pair>, std::vector> +std::pair>>, std::vector> segmented_bitmask_and(host_span colviews, host_span segment_offsets, cuda::stream_ref stream, @@ -686,7 +693,7 @@ segmented_bitmask_and(host_span colviews, mr); } -std::pair>, std::vector> +std::pair>>, std::vector> segmented_bitmask_and(host_span masks, host_span segment_offsets, size_type mask_size_bits, @@ -709,11 +716,11 @@ segmented_bitmask_and(host_span masks, } // Returns the bitwise OR of the null masks of all columns in the table view -std::pair bitmask_or(table_view const& view, - cuda::stream_ref stream, - rmm::device_async_resource_ref mr) +std::pair, size_type> bitmask_or(table_view const& view, + cuda::stream_ref stream, + rmm::device_async_resource_ref mr) { - rmm::device_buffer null_mask{0, stream, mr}; + auto null_mask = cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED, stream, mr); if (view.num_rows() == 0 or view.num_columns() == 0) { return std::pair(std::move(null_mask), 0); } @@ -821,44 +828,45 @@ size_type index_of_first_set_bit(bitmask_type const* bitmask, } // namespace detail // Create a bitmask from a specific range -rmm::device_buffer copy_bitmask(bitmask_type const* mask, - size_type begin_bit, - size_type end_bit, - cuda::stream_ref stream, - rmm::device_async_resource_ref mr) +cuda::device_buffer copy_bitmask(bitmask_type const* mask, + size_type begin_bit, + size_type end_bit, + cuda::stream_ref stream, + rmm::device_async_resource_ref mr) { CUDF_FUNC_RANGE(); return detail::copy_bitmask(mask, begin_bit, end_bit, stream, mr); } // Create a bitmask from a column view -rmm::device_buffer copy_bitmask(column_view const& view, - cuda::stream_ref stream, - rmm::device_async_resource_ref mr) +cuda::device_buffer copy_bitmask(column_view const& view, + cuda::stream_ref stream, + rmm::device_async_resource_ref mr) { CUDF_FUNC_RANGE(); return detail::copy_bitmask(view, stream, mr); } -std::pair bitmask_and(table_view const& view, - cuda::stream_ref stream, - rmm::device_async_resource_ref mr) +std::pair, size_type> bitmask_and(table_view const& view, + cuda::stream_ref stream, + rmm::device_async_resource_ref mr) { CUDF_FUNC_RANGE(); return detail::bitmask_and(view, stream, mr); } -std::pair bitmask_and(host_span masks, - host_span begin_bits, - size_type mask_size, - cuda::stream_ref stream, - rmm::device_async_resource_ref mr) +std::pair, size_type> bitmask_and( + host_span masks, + host_span begin_bits, + size_type mask_size, + cuda::stream_ref stream, + rmm::device_async_resource_ref mr) { CUDF_FUNC_RANGE(); return detail::bitmask_and(masks, begin_bits, mask_size, stream, mr); } -std::pair>, std::vector> +std::pair>>, std::vector> segmented_bitmask_and(host_span colviews, host_span segment_offsets, cuda::stream_ref stream, @@ -868,7 +876,7 @@ segmented_bitmask_and(host_span colviews, return detail::segmented_bitmask_and(colviews, segment_offsets, stream, mr); } -std::pair>, std::vector> +std::pair>>, std::vector> segmented_bitmask_and(host_span masks, host_span segment_offsets, size_type mask_size_bits, @@ -879,9 +887,9 @@ segmented_bitmask_and(host_span masks, return detail::segmented_bitmask_and(masks, segment_offsets, mask_size_bits, stream, mr); } -std::pair bitmask_or(table_view const& view, - cuda::stream_ref stream, - rmm::device_async_resource_ref mr) +std::pair, size_type> bitmask_or(table_view const& view, + cuda::stream_ref stream, + rmm::device_async_resource_ref mr) { CUDF_FUNC_RANGE(); return detail::bitmask_or(view, stream, mr); diff --git a/cpp/src/column/column.cu b/cpp/src/column/column.cu index 9cb305fca0cb..7a2a65c4a995 100644 --- a/cpp/src/column/column.cu +++ b/cpp/src/column/column.cu @@ -41,7 +41,8 @@ column::column(column const& other, cuda::stream_ref stream, rmm::device_async_r : _type{other._type}, _size{other._size}, _data{other._data, stream, mr}, - _null_mask{other._null_mask, stream, mr}, + _null_mask{cudf::detail::copy_bitmask( + reinterpret_cast(other._null_mask.data()), 0, other.size(), stream, mr)}, _null_count{other._null_count} { _children.reserve(other.num_children()); @@ -71,7 +72,7 @@ column::contents column::release() noexcept _null_count = 0; _type = data_type{type_id::EMPTY}; return column::contents{std::make_unique(std::move(_data)), - std::make_unique(std::move(_null_mask)), + std::make_unique>(std::move(_null_mask)), std::move(_children)}; } @@ -97,7 +98,7 @@ column_view column::view() const return column_view{type(), size(), _data.data(), - static_cast(_null_mask.data()), + reinterpret_cast(_null_mask.data()), null_count(), 0, child_views}; @@ -118,13 +119,13 @@ mutable_column_view column::mutable_view() return mutable_column_view{type(), size(), _data.data(), - static_cast(_null_mask.data()), + reinterpret_cast(_null_mask.data()), _null_count, 0, child_views}; } -void column::set_null_mask(rmm::device_buffer&& new_null_mask, size_type new_null_count) +void column::set_null_mask(cuda::device_buffer&& new_null_mask, size_type new_null_count) { if (new_null_count > 0) { CUDF_EXPECTS(new_null_mask.size() >= cudf::bitmask_allocation_size_bytes(this->size()), @@ -135,7 +136,7 @@ void column::set_null_mask(rmm::device_buffer&& new_null_mask, size_type new_nul _null_count = new_null_count; } -void column::set_null_mask(rmm::device_buffer const& new_null_mask, +void column::set_null_mask(cuda::device_buffer const& new_null_mask, size_type new_null_count, cuda::stream_ref stream) { @@ -144,7 +145,8 @@ void column::set_null_mask(rmm::device_buffer const& new_null_mask, "Column with null values must be nullable and the null mask \ buffer size should match the size of the column."); } - _null_mask = rmm::device_buffer{new_null_mask, stream}; // copy + _null_mask = cuda::device_buffer{ + stream, cudf::get_current_device_resource_ref(), new_null_mask}; // copy _null_count = new_null_count; } diff --git a/cpp/src/column/column_factories.cpp b/cpp/src/column/column_factories.cpp index c7bb0d3d5471..593e799fc7ee 100644 --- a/cpp/src/column/column_factories.cpp +++ b/cpp/src/column/column_factories.cpp @@ -52,7 +52,8 @@ std::unique_ptr make_empty_column(data_type type) CUDF_EXPECTS(type.id() == type_id::EMPTY || !cudf::is_nested(type), "make_empty_column is invalid to call on nested types", cudf::data_type_error); - return std::make_unique(type, 0, rmm::device_buffer{}, rmm::device_buffer{}, 0); + return std::make_unique( + type, 0, rmm::device_buffer{}, cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), 0); } // Empty column of specified type id @@ -175,7 +176,7 @@ std::unique_ptr make_dictionary_from_scalar(scalar const& s, size, stream, mr), - rmm::device_buffer{0, stream, mr}, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED, stream, mr), 0); } diff --git a/cpp/src/column/column_factories.cu b/cpp/src/column/column_factories.cu index 086947447648..59909459a3f0 100644 --- a/cpp/src/column/column_factories.cu +++ b/cpp/src/column/column_factories.cu @@ -3,6 +3,8 @@ * SPDX-License-Identifier: Apache-2.0 */ +#include "cudf/utilities/default_stream.hpp" + #include #include #include @@ -111,7 +113,7 @@ std::unique_ptr column_from_scalar_dispatch::operator()release()), is_valid ? 0 : size, is_valid - ? rmm::device_buffer{} + ? cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED) : detail::create_null_mask(size, mask_state::ALL_NULL, stream, mr), stream, mr); diff --git a/cpp/src/copying/concatenate.cu b/cpp/src/copying/concatenate.cu index 42977e306feb..ca51c89535b8 100644 --- a/cpp/src/copying/concatenate.cu +++ b/cpp/src/copying/concatenate.cu @@ -527,8 +527,11 @@ std::unique_ptr concatenate(std::span columns_to_conc columns_to_concat.begin(), columns_to_concat.end(), 0, [](auto a, auto const& b) { return a + b.size(); }); - return std::make_unique( - data_type(type_id::EMPTY), length, rmm::device_buffer{}, rmm::device_buffer{}, length); + return std::make_unique(data_type(type_id::EMPTY), + length, + rmm::device_buffer{}, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), + length); } return type_dispatcher( columns_to_concat.front().type(), concatenate_dispatch{views_as_host_span, stream, mr}); @@ -577,9 +580,9 @@ std::unique_ptr
concatenate(std::span tables_to_concat, return std::make_unique
(std::move(concat_columns)); } -rmm::device_buffer concatenate_masks(std::span views, - cuda::stream_ref stream, - rmm::device_async_resource_ref mr) +cuda::device_buffer concatenate_masks(std::span views, + cuda::stream_ref stream, + rmm::device_async_resource_ref mr) { bool const has_nulls = std::any_of(views.begin(), views.end(), [](column_view const col) { return col.has_nulls(); }); @@ -589,24 +592,24 @@ rmm::device_buffer concatenate_masks(std::span views, return accumulator + v.size(); }); - rmm::device_buffer null_mask = + cuda::device_buffer null_mask = cudf::detail::create_null_mask(total_element_count, mask_state::UNINITIALIZED, stream, mr); detail::concatenate_masks(host_span{views.data(), views.size()}, - static_cast(null_mask.data()), + reinterpret_cast(null_mask.data()), stream); return null_mask; } // no nulls, so return an empty device buffer - return rmm::device_buffer{0, stream, mr}; + return cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED, stream, mr); } } // namespace detail -rmm::device_buffer concatenate_masks(std::span views, - cuda::stream_ref stream, - rmm::device_async_resource_ref mr) +cuda::device_buffer concatenate_masks(std::span views, + cuda::stream_ref stream, + rmm::device_async_resource_ref mr) { CUDF_FUNC_RANGE(); return detail::concatenate_masks(views, stream, mr); diff --git a/cpp/src/copying/copy.cpp b/cpp/src/copying/copy.cpp index 9763ec2da222..fc5a2c48dd8a 100644 --- a/cpp/src/copying/copy.cpp +++ b/cpp/src/copying/copy.cpp @@ -141,8 +141,12 @@ std::unique_ptr empty_like(column_view const& input) std::back_inserter(children), [](column_view const& col) { return empty_like(col); }); - return std::make_unique( - input.type(), 0, rmm::device_buffer{}, rmm::device_buffer{}, 0, std::move(children)); + return std::make_unique(input.type(), + 0, + rmm::device_buffer{}, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), + 0, + std::move(children)); } /* diff --git a/cpp/src/copying/copy_range.cu b/cpp/src/copying/copy_range.cu index 0dd75c59b164..daafc50978df 100644 --- a/cpp/src/copying/copy_range.cu +++ b/cpp/src/copying/copy_range.cu @@ -156,7 +156,7 @@ std::unique_ptr out_of_place_copy_range_dispatch::operator()type(), dict_target.size(), target_indices->mutable_view().head(), - static_cast(target_contents.null_mask->data()), + reinterpret_cast(target_contents.null_mask->data()), dict_target.null_count()); cudf::type_dispatcher(new_indices.type(), in_place_copy_range_dispatch{source_indices, new_indices}, @@ -164,13 +164,13 @@ std::unique_ptr out_of_place_copy_range_dispatch::operator()(new_indices.type(), - new_indices.size(), - std::move(*(target_indices->release().data.release())), - rmm::device_buffer{0, stream, mr}, - 0); + auto null_count = new_indices.null_count(); + auto indices_column = std::make_unique( + new_indices.type(), + new_indices.size(), + std::move(*(target_indices->release().data.release())), + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED, stream, mr), + 0); // take the keys from the matched column allocated using mr auto keys_column(std::move(target_contents.children.back())); diff --git a/cpp/src/copying/scatter.cu b/cpp/src/copying/scatter.cu index 9fbeabd96135..87352d288e74 100644 --- a/cpp/src/copying/scatter.cu +++ b/cpp/src/copying/scatter.cu @@ -260,7 +260,7 @@ struct column_scalar_scatterer_impl { std::vector> fields(fields_iter_begin, fields_iter_begin + n_fields); // Compute null mask - rmm::device_buffer null_mask = + cuda::device_buffer null_mask = target.nullable() ? detail::copy_bitmask(target, stream, mr) : detail::create_null_mask(target.size(), mask_state::UNALLOCATED, stream, mr); diff --git a/cpp/src/copying/shift.cu b/cpp/src/copying/shift.cu index 7e7504248340..4494cf2c46b3 100644 --- a/cpp/src/copying/shift.cu +++ b/cpp/src/copying/shift.cu @@ -38,11 +38,12 @@ inline bool __device__ out_of_bounds(size_type size, size_type idx) return idx < 0 || idx >= size; } -std::pair create_null_mask(column_device_view const& input, - size_type offset, - scalar const& fill_value, - cuda::stream_ref stream, - rmm::device_async_resource_ref mr) +std::pair, size_type> create_null_mask( + column_device_view const& input, + size_type offset, + scalar const& fill_value, + cuda::stream_ref stream, + rmm::device_async_resource_ref mr) { auto const size = input.size(); auto func_validity = diff --git a/cpp/src/datetime/timezone.cpp b/cpp/src/datetime/timezone.cpp index c08aa9349d7c..78f01e870fd1 100644 --- a/cpp/src/datetime/timezone.cpp +++ b/cpp/src/datetime/timezone.cpp @@ -571,10 +571,10 @@ std::unique_ptr
make_timezone_transition_table(std::optional> tz_table_columns; - tz_table_columns.emplace_back( - std::make_unique(std::move(d_ttimes), rmm::device_buffer{}, 0)); - tz_table_columns.emplace_back( - std::make_unique(std::move(d_offsets), rmm::device_buffer{}, 0)); + tz_table_columns.emplace_back(std::make_unique( + std::move(d_ttimes), cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), 0)); + tz_table_columns.emplace_back(std::make_unique( + std::move(d_offsets), cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), 0)); // Need to finish copies before transition_times and offsets go out of scope cudf::detail::sync_stream(stream); diff --git a/cpp/src/dictionary/add_keys.cu b/cpp/src/dictionary/add_keys.cu index 017ca6e86301..0ce86db292fd 100644 --- a/cpp/src/dictionary/add_keys.cu +++ b/cpp/src/dictionary/add_keys.cu @@ -48,7 +48,7 @@ std::unique_ptr add_keys(dictionary_column_view const& input, : std::make_unique(old_keys, stream, mr); // this leaves the indices untouched so just copy them auto indices_column = std::make_unique(input.get_indices_annotated(), stream, mr); - indices_column->set_null_mask(rmm::device_buffer{}, 0); + indices_column->set_null_mask(cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), 0); return make_dictionary_column(std::move(keys_column), std::move(indices_column), cudf::detail::copy_bitmask(input.parent(), stream, mr), diff --git a/cpp/src/dictionary/dictionary_factories.cu b/cpp/src/dictionary/dictionary_factories.cu index af733284b20a..f27533181c31 100644 --- a/cpp/src/dictionary/dictionary_factories.cu +++ b/cpp/src/dictionary/dictionary_factories.cu @@ -51,7 +51,7 @@ std::unique_ptr make_dictionary_column(column_view const& keys_column, auto keys_copy = std::make_unique(keys_column, stream, mr); auto indices_copy = type_dispatcher(indices_column.type(), dispatch_create_indices{}, indices_column, stream, mr); - rmm::device_buffer null_mask{0, stream, mr}; + auto null_mask = cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED, stream, mr); auto null_count = indices_column.null_count(); if (null_count) null_mask = detail::copy_bitmask(indices_column, stream, mr); @@ -68,7 +68,7 @@ std::unique_ptr make_dictionary_column(column_view const& keys_column, std::unique_ptr make_dictionary_column(std::unique_ptr keys_column, std::unique_ptr indices_column, - rmm::device_buffer&& null_mask, + cuda::device_buffer&& null_mask, size_type null_count) { CUDF_EXPECTS(!keys_column->has_nulls(), "keys column must not have nulls", std::invalid_argument); @@ -130,8 +130,11 @@ std::unique_ptr make_dictionary_column(std::unique_ptr keys, auto indices_column = [&] { // If the types match, then just commandeer the column's data buffer. if (new_type_id == indices_type.id()) { - return std::make_unique( - indices_type, indices_size, std::move(*(contents.data.release())), rmm::device_buffer{}, 0); + return std::make_unique(indices_type, + indices_size, + std::move(*(contents.data.release())), + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), + 0); } // If the new type does not match, then convert the data. cudf::column_view cast_view{indices_type, indices_size, contents.data->data(), nullptr, 0}; diff --git a/cpp/src/dictionary/encode.cu b/cpp/src/dictionary/encode.cu index e9d5e89ef494..4577da583ab8 100644 --- a/cpp/src/dictionary/encode.cu +++ b/cpp/src/dictionary/encode.cu @@ -73,8 +73,10 @@ std::unique_ptr encode(column_view const& input, auto indices_column = cudf::make_numeric_column( indices_type, input.size(), cudf::mask_state::UNALLOCATED, stream, output_mr); if (input.is_empty()) { - return make_dictionary_column( - make_empty_column(input.type()), std::move(indices_column), rmm::device_buffer{}, 0); + return make_dictionary_column(make_empty_column(input.type()), + std::move(indices_column), + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), + 0); } using encode_probe_t = cuco::linear_probing< diff --git a/cpp/src/dictionary/remove_keys.cu b/cpp/src/dictionary/remove_keys.cu index 654f2726be74..a504ce24e46a 100644 --- a/cpp/src/dictionary/remove_keys.cu +++ b/cpp/src/dictionary/remove_keys.cu @@ -123,7 +123,7 @@ std::unique_ptr remove_keys_fn(dictionary_column_view const& dictionary_ mr) ->release(); std::unique_ptr indices_column(std::move(table_indices.front())); - indices_column->set_null_mask(rmm::device_buffer{}, 0); + indices_column->set_null_mask(cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), 0); // compute new nulls -- merge the existing nulls with the newly created ones (value<0) auto const offset = dictionary_column.offset(); @@ -138,8 +138,9 @@ std::unique_ptr remove_keys_fn(dictionary_column_view const& dictionary_ }, stream, mr); - rmm::device_buffer new_null_mask = - (new_nulls.second > 0) ? std::move(new_nulls.first) : rmm::device_buffer{0, stream, mr}; + cuda::device_buffer new_null_mask = + (new_nulls.second > 0) ? std::move(new_nulls.first) + : cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED, stream, mr); // create column with keys_column and indices_column return make_dictionary_column( diff --git a/cpp/src/dictionary/replace.cu b/cpp/src/dictionary/replace.cu index f4697b167909..835a6aa652c4 100644 --- a/cpp/src/dictionary/replace.cu +++ b/cpp/src/dictionary/replace.cu @@ -134,7 +134,8 @@ std::unique_ptr replace_nulls(dictionary_column_view const& input, cudf::detail::indexalator_factory::make_input_optional_iterator(*scalar_index, stream), stream, mr); - new_indices->set_null_mask(rmm::device_buffer{0, stream, mr}, 0); + new_indices->set_null_mask(cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED, stream, mr), + 0); return make_dictionary_column( std::move(input_matched->release().children.back()), std::move(new_indices), stream, mr); diff --git a/cpp/src/dictionary/set_keys.cu b/cpp/src/dictionary/set_keys.cu index 78d106153657..dc9a8c47cacc 100644 --- a/cpp/src/dictionary/set_keys.cu +++ b/cpp/src/dictionary/set_keys.cu @@ -67,7 +67,8 @@ struct apply_indices_map_fn { struct remap_result { std::unique_ptr indices; - rmm::device_buffer null_mask; + cuda::device_buffer null_mask = + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED); cudf::size_type null_count; }; diff --git a/cpp/src/groupby/common/utils.cpp b/cpp/src/groupby/common/utils.cpp index a1d91e78b93a..a747e3db87d7 100644 --- a/cpp/src/groupby/common/utils.cpp +++ b/cpp/src/groupby/common/utils.cpp @@ -11,24 +11,29 @@ namespace cudf::groupby::detail { -std::pair compute_row_bitmask(table_view const& keys, - cuda::stream_ref stream) +std::pair, bitmask_type const*> compute_row_bitmask( + table_view const& keys, cuda::stream_ref stream) { auto const mr = cudf::get_current_device_resource_ref(); if (keys.num_columns() == 0 || !cudf::has_nulls(keys)) { - return {rmm::device_buffer{0, stream, mr}, nullptr}; + return {cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED, stream, mr), nullptr}; } // Single-column fast path: reuse the column's null mask directly. if (keys.num_columns() == 1) { auto const& col = keys.column(0); - if (col.offset() == 0) { return {rmm::device_buffer{0, stream, mr}, col.null_mask()}; } + if (col.offset() == 0) { + return {cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED, stream, mr), + col.null_mask()}; + } auto buf = cudf::copy_bitmask(col, stream, mr); - auto ptr = static_cast(buf.data()); + auto ptr = reinterpret_cast(buf.data()); return {std::move(buf), ptr}; } auto [buf, null_count] = cudf::bitmask_and(keys, stream, mr); - if (null_count == 0) { return {rmm::device_buffer{0, stream, mr}, nullptr}; } - return {std::move(buf), static_cast(buf.data())}; + if (null_count == 0) { + return {cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED, stream, mr), nullptr}; + } + return {std::move(buf), reinterpret_cast(buf.data())}; } } // namespace cudf::groupby::detail diff --git a/cpp/src/groupby/common/utils.hpp b/cpp/src/groupby/common/utils.hpp index a88258a9376c..bb4dd135077c 100644 --- a/cpp/src/groupby/common/utils.hpp +++ b/cpp/src/groupby/common/utils.hpp @@ -59,8 +59,8 @@ inline std::vector extract_results(std::span compute_row_bitmask(table_view const& keys, - cuda::stream_ref stream); +std::pair, bitmask_type const*> compute_row_bitmask( + table_view const& keys, cuda::stream_ref stream); /// Whether the given aggregation kind is supported by hash-based groupby. constexpr bool is_hash_aggregation(aggregation::Kind k) diff --git a/cpp/src/groupby/groupby.cu b/cpp/src/groupby/groupby.cu index 9e30aa62d266..faf45be3bd97 100644 --- a/cpp/src/groupby/groupby.cu +++ b/cpp/src/groupby/groupby.cu @@ -98,7 +98,11 @@ struct empty_column_constructor { if constexpr (k == aggregation::Kind::COLLECT_LIST || k == aggregation::Kind::COLLECT_SET || k == aggregation::Kind::TOP_K) { - return make_lists_column(0, make_empty_column(type_id::INT32), empty_like(values), 0, {}); + return make_lists_column(0, + make_empty_column(type_id::INT32), + empty_like(values), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); } if constexpr (k == aggregation::Kind::HISTOGRAM) { @@ -106,7 +110,7 @@ struct empty_column_constructor { make_empty_column(type_id::INT32), cudf::reduction::detail::make_empty_histogram_like(values), 0, - {}); + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); } if constexpr (k == aggregation::Kind::MERGE_HISTOGRAM) { return empty_like(values); } @@ -116,7 +120,12 @@ struct empty_column_constructor { std::vector> children; children.push_back(make_empty_column(values.type())); children.push_back(make_empty_column(cudf::data_type{cudf::type_id::BOOL8})); - return make_structs_column(0, std::move(children), 0, {}, stream, mr); + return make_structs_column(0, + std::move(children), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), + stream, + mr); } if constexpr (k == aggregation::Kind::RANK) { diff --git a/cpp/src/groupby/hash/compute_groupby.cu b/cpp/src/groupby/hash/compute_groupby.cu index c06aaa6aa2f8..e11f0853d19e 100644 --- a/cpp/src/groupby/hash/compute_groupby.cu +++ b/cpp/src/groupby/hash/compute_groupby.cu @@ -62,8 +62,8 @@ std::unique_ptr
compute_groupby(table_view const& keys, [[maybe_unused]] auto [row_bitmask_data, row_bitmask] = skip_rows_with_nulls ? cudf::groupby::detail::compute_row_bitmask(keys, stream) - : std::pair{ - rmm::device_buffer{0, stream, cudf::get_current_device_resource_ref()}, nullptr}; + : std::pair, bitmask_type const*>{ + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED, stream), nullptr}; auto const cached_hashes = [&]() -> rmm::device_uvector { auto const num_columns = diff --git a/cpp/src/groupby/hash/output_utils.cu b/cpp/src/groupby/hash/output_utils.cu index 0f8e0d9265de..71013041c8d2 100644 --- a/cpp/src/groupby/hash/output_utils.cu +++ b/cpp/src/groupby/hash/output_utils.cu @@ -95,11 +95,11 @@ struct result_column_creator { return children; }; - auto [null_mask, null_count] = [&]() -> std::pair { + auto [null_mask, null_count] = [&]() -> std::pair, size_type> { if (output_size > 0 && nullable) { return {create_null_mask(output_size, mask_state::ALL_NULL, stream, mr), output_size}; } - return {rmm::device_buffer{}, 0}; + return {cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), 0}; }(); return create_structs_hierarchy(output_size, make_children(output_size), diff --git a/cpp/src/groupby/sort/group_collect.cu b/cpp/src/groupby/sort/group_collect.cu index fa344d9a7748..69aacee1ea26 100644 --- a/cpp/src/groupby/sort/group_collect.cu +++ b/cpp/src/groupby/sort/group_collect.cu @@ -52,7 +52,8 @@ std::pair, std::unique_ptr> purge_null_entries( cudf::detail::copy_if(table_view{{values}}, not_null_pred, stream, mr)->release(); auto null_purged_values = std::move(null_purged_entries.front()); - null_purged_values->set_null_mask(rmm::device_buffer{0, stream, mr}, 0); + null_purged_values->set_null_mask( + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED, stream, mr), 0); // Recalculate offsets after null entries are purged. rmm::device_uvector null_purged_sizes(num_groups, stream); @@ -107,7 +108,7 @@ std::unique_ptr group_collect(column_view const& values, std::move(offsets_column), std::move(child_column), 0, - rmm::device_buffer{0, stream, mr}); + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED, stream, mr)); } } // namespace detail } // namespace groupby diff --git a/cpp/src/groupby/sort/group_histogram.cu b/cpp/src/groupby/sort/group_histogram.cu index 4cc4274f1169..0b8d08100cfb 100644 --- a/cpp/src/groupby/sort/group_histogram.cu +++ b/cpp/src/groupby/sort/group_histogram.cu @@ -9,6 +9,7 @@ #include #include #include +#include #include #include #include @@ -65,11 +66,15 @@ std::unique_ptr build_histogram(column_view const& values, auto out_structs = make_structs_column(static_cast(distinct_indices->size()), std::move(struct_children), 0, - {}, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), stream, mr); - return make_lists_column(num_groups, std::move(out_offsets), std::move(out_structs), 0, {}); + return make_lists_column(num_groups, + std::move(out_offsets), + std::move(out_structs), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); } } // namespace diff --git a/cpp/src/groupby/sort/group_merge_lists.cu b/cpp/src/groupby/sort/group_merge_lists.cu index 9c48c765cd06..3633b9ef713a 100644 --- a/cpp/src/groupby/sort/group_merge_lists.cu +++ b/cpp/src/groupby/sort/group_merge_lists.cu @@ -50,8 +50,11 @@ std::unique_ptr group_merge_lists(column_view const& values, auto child_column = std::make_unique(lists_column_view(values).get_sliced_child(stream), stream, mr); - return make_lists_column( - num_groups, std::move(offsets_column), std::move(child_column), 0, rmm::device_buffer{}); + return make_lists_column(num_groups, + std::move(offsets_column), + std::move(child_column), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); } } // namespace detail diff --git a/cpp/src/groupby/sort/group_merge_m2.cu b/cpp/src/groupby/sort/group_merge_m2.cu index c01dd53fe011..1a0e807a4941 100644 --- a/cpp/src/groupby/sort/group_merge_m2.cu +++ b/cpp/src/groupby/sort/group_merge_m2.cu @@ -110,8 +110,12 @@ std::unique_ptr merge_m2(column_view const& values, out_columns.emplace_back(std::move(result_counts)); out_columns.emplace_back(std::move(result_means)); out_columns.emplace_back(std::move(result_M2s)); - return make_structs_column( - num_groups, std::move(out_columns), 0, rmm::device_buffer{0, stream, mr}, stream, mr); + return make_structs_column(num_groups, + std::move(out_columns), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED, stream, mr), + stream, + mr); } } // namespace diff --git a/cpp/src/groupby/sort/group_nth_element.cu b/cpp/src/groupby/sort/group_nth_element.cu index 40f438c042d6..2c15b981f5d2 100644 --- a/cpp/src/groupby/sort/group_nth_element.cu +++ b/cpp/src/groupby/sort/group_nth_element.cu @@ -121,7 +121,9 @@ std::unique_ptr group_nth_element(column_view const& values, cudf::negative_index_policy::NOT_ALLOWED, stream, mr); - if (!output_table->get_column(0).has_nulls()) output_table->get_column(0).set_null_mask({}, 0); + if (!output_table->get_column(0).has_nulls()) + output_table->get_column(0).set_null_mask( + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), 0); return std::make_unique(std::move(output_table->get_column(0))); } } // namespace detail diff --git a/cpp/src/groupby/sort/group_sum_overflow.cu b/cpp/src/groupby/sort/group_sum_overflow.cu index 9e1e22b40b0a..88b39630e7c8 100644 --- a/cpp/src/groupby/sort/group_sum_overflow.cu +++ b/cpp/src/groupby/sort/group_sum_overflow.cu @@ -80,8 +80,10 @@ struct group_sum_overflow_fn { // A group's struct entry is null only when every row in the group is null (mirrors group_sum): // reduce per-row validity with logical-or, then build the mask from the per-group result. - auto [null_mask, null_count] = [&]() -> std::pair { - if (!values.has_nulls()) { return {rmm::device_buffer{}, size_type{0}}; } + auto [null_mask, null_count] = [&]() -> std::pair, size_type> { + if (!values.has_nulls()) { + return {cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), size_type{0}}; + } rmm::device_uvector group_valid( num_groups, stream, cudf::get_current_device_resource_ref()); thrust::reduce_by_key( diff --git a/cpp/src/groupby/streaming_groupby/common.cuh b/cpp/src/groupby/streaming_groupby/common.cuh index 100837863792..abf6c989e276 100644 --- a/cpp/src/groupby/streaming_groupby/common.cuh +++ b/cpp/src/groupby/streaming_groupby/common.cuh @@ -22,6 +22,7 @@ #include #include +#include #include #include #include @@ -316,7 +317,7 @@ struct streaming_groupby::impl { struct batch_insert_result { rmm::device_uvector target_indices; size_type new_insertions; - rmm::device_buffer bitmask_buffer; + cuda::device_buffer bitmask_buffer; }; batch_insert_result probe_and_insert(table_view const& batch_keys, cuda::stream_ref stream); diff --git a/cpp/src/groupby/streaming_groupby/insert.cuh b/cpp/src/groupby/streaming_groupby/insert.cuh index 9df90ecfcb93..9733d1601054 100644 --- a/cpp/src/groupby/streaming_groupby/insert.cuh +++ b/cpp/src/groupby/streaming_groupby/insert.cuh @@ -45,7 +45,8 @@ streaming_groupby::impl::batch_insert_result streaming_groupby::impl::probe_and_ auto [bitmask_buffer, batch_bitmask] = skip_rows_with_nulls ? detail::compute_row_bitmask(batch_keys, stream) - : std::pair{rmm::device_buffer{0, stream}, nullptr}; + : std::pair, bitmask_type const*>{ + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED, stream), nullptr}; // Precompute batch hash values. Caching is faster than inlining the row hasher rmm::device_uvector batch_hash_cache(batch_size, stream, temp_mr); diff --git a/cpp/src/hash/md5_hash.cu b/cpp/src/hash/md5_hash.cu index 0db455ad05b3..e3589c2cce8c 100644 --- a/cpp/src/hash/md5_hash.cu +++ b/cpp/src/hash/md5_hash.cu @@ -335,7 +335,11 @@ std::unique_ptr md5(table_view const& input, } }); - return make_strings_column(input.num_rows(), std::move(offsets_column), chars.release(), 0, {}); + return make_strings_column(input.num_rows(), + std::move(offsets_column), + chars.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); } } // namespace detail diff --git a/cpp/src/hash/sha_hash.cuh b/cpp/src/hash/sha_hash.cuh index e2189f9fbf07..e14b52f68429 100644 --- a/cpp/src/hash/sha_hash.cuh +++ b/cpp/src/hash/sha_hash.cuh @@ -534,7 +534,11 @@ std::unique_ptr sha_hash(table_view const& input, hasher.finalize(); }); - return make_strings_column(input.num_rows(), std::move(offsets_column), chars.release(), 0, {}); + return make_strings_column(input.num_rows(), + std::move(offsets_column), + chars.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); } } // namespace detail diff --git a/cpp/src/interop/from_arrow_host.cu b/cpp/src/interop/from_arrow_host.cu index ff729d9423c7..4a5df50a54df 100644 --- a/cpp/src/interop/from_arrow_host.cu +++ b/cpp/src/interop/from_arrow_host.cu @@ -93,14 +93,20 @@ CUDF_KERNEL void copy_shifted_bitmask(bitmask_type* __restrict__ destination, } // copies the bitmask to device and automatically applies the offset -std::pair, size_type> get_mask_buffer( +std::pair>, size_type> get_mask_buffer( ArrowArray const* input, cuda::stream_ref stream, rmm::device_async_resource_ref mr) { - if (input->length == 0) { return {std::make_unique(0, stream, mr), 0}; } + if (input->length == 0) { + return {std::make_unique>( + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED, stream, mr)), + 0}; + } auto bitmap = static_cast(input->buffers[validity_buffer_idx]); if (bitmap == nullptr || input->null_count == 0) { - return {std::make_unique(0, stream, mr), 0}; + return {std::make_unique>( + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED, stream, mr)), + 0}; } constexpr auto bits_in_byte = static_cast(size_in_bits()); @@ -127,7 +133,10 @@ std::pair, size_type> get_mask_buffer( auto const null_count = mask_words > 0 ? cudf::detail::count_unset_bits(mask.data(), 0, num_rows, stream) : 0; - return {std::make_unique(std::move(mask.release())), null_count}; + auto const mask_bytes = reinterpret_cast(mask.data()); + return {std::make_unique>(cudf::detail::copy_bitmask( + reinterpret_cast(mask_bytes), 0, num_rows, stream, mr)), + null_count}; } std::unique_ptr get_column_copy(ArrowSchemaView const* schema, @@ -224,9 +233,11 @@ std::unique_ptr dispatch_copy_from_arrow_host::operator()length == 0) { return make_empty_column(type_id::STRING); } - auto [mask, null_count] = !skip_mask - ? get_mask_buffer(input, stream, mr) - : std::pair{std::make_unique(0, stream, mr), 0}; + auto [mask, null_count] = + !skip_mask ? get_mask_buffer(input, stream, mr) + : std::pair{std::make_unique>( + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED, stream, mr)), + 0}; return string_column_from_arrow_host(schema, input, std::move(mask), null_count, stream, mr); } @@ -281,7 +292,9 @@ std::unique_ptr dispatch_copy_from_arrow_host::operator()(0, stream, mr), 0}; + : std::pair{std::make_unique>( + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED, stream, mr)), + 0}; return make_structs_column( input->length, std::move(child_columns), null_count, std::move(*out_mask), stream, mr); @@ -346,7 +359,9 @@ std::unique_ptr dispatch_copy_from_arrow_host::operator()(0, stream, mr), 0}; + : std::pair{std::make_unique>( + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED, stream, mr)), + 0}; return make_lists_column(static_cast(input->length), std::move(offsets_column), @@ -387,7 +402,7 @@ std::unique_ptr get_column_copy(ArrowSchemaView const* schema, return std::make_unique(data_type(type_id::EMPTY), input->length, rmm::device_buffer{}, - rmm::device_buffer{}, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), input->length); } diff --git a/cpp/src/interop/from_arrow_host.hpp b/cpp/src/interop/from_arrow_host.hpp index b7efa896bc06..855174496f3b 100644 --- a/cpp/src/interop/from_arrow_host.hpp +++ b/cpp/src/interop/from_arrow_host.hpp @@ -9,6 +9,7 @@ #include #include +#include #include #include @@ -28,12 +29,13 @@ namespace detail { * @param stream CUDA stream used for device memory operations * @param mr Device memory resource to use for all device memory allocations */ -std::unique_ptr string_column_from_arrow_host(ArrowSchemaView const* schema, - ArrowArray const* input, - std::unique_ptr&& mask, - size_type null_count, - cuda::stream_ref stream, - rmm::device_async_resource_ref mr); +std::unique_ptr string_column_from_arrow_host( + ArrowSchemaView const* schema, + ArrowArray const* input, + std::unique_ptr>&& mask, + size_type null_count, + cuda::stream_ref stream, + rmm::device_async_resource_ref mr); /** * @brief Create offsets column for list or strings column diff --git a/cpp/src/interop/from_arrow_host_strings.cu b/cpp/src/interop/from_arrow_host_strings.cu index fbc6869c84d2..a77df4b9dcd4 100644 --- a/cpp/src/interop/from_arrow_host_strings.cu +++ b/cpp/src/interop/from_arrow_host_strings.cu @@ -45,7 +45,7 @@ constexpr int chars_buffer_idx = 2; std::unique_ptr from_arrow_string(ArrowSchemaView const* schema, ArrowArray const* input, - std::unique_ptr&& mask, + std::unique_ptr>&& mask, size_type null_count, cuda::stream_ref stream, rmm::device_async_resource_ref mr) @@ -65,11 +65,12 @@ std::unique_ptr from_arrow_string(ArrowSchemaView const* schema, constexpr int stringview_vector_idx = 1; -std::unique_ptr from_arrow_stringview(ArrowSchemaView const* schema, - ArrowArray const* input, - std::unique_ptr&& mask, - cuda::stream_ref stream, - rmm::device_async_resource_ref mr) +std::unique_ptr from_arrow_stringview( + ArrowSchemaView const* schema, + ArrowArray const* input, + std::unique_ptr>&& mask, + cuda::stream_ref stream, + rmm::device_async_resource_ref mr) { ArrowArrayView view; NANOARROW_THROW_NOT_OK(ArrowArrayViewInitFromSchema(&view, schema->schema, nullptr)); @@ -93,7 +94,7 @@ std::unique_ptr from_arrow_stringview(ArrowSchemaView const* schema, auto d_variadic_ptrs = cudf::detail::make_device_uvector_async( variadic_ptrs, stream, cudf::get_current_device_resource_ref()); auto d_ptrs = d_variadic_ptrs.data(); - auto d_mask = static_cast(mask->data()); + auto d_mask = reinterpret_cast(mask->data()); using string_index_pair = cudf::strings::detail::string_index_pair; @@ -120,12 +121,13 @@ std::unique_ptr from_arrow_stringview(ArrowSchemaView const* schema, } // namespace -std::unique_ptr string_column_from_arrow_host(ArrowSchemaView const* schema, - ArrowArray const* input, - std::unique_ptr&& mask, - size_type null_count, - cuda::stream_ref stream, - rmm::device_async_resource_ref mr) +std::unique_ptr string_column_from_arrow_host( + ArrowSchemaView const* schema, + ArrowArray const* input, + std::unique_ptr>&& mask, + size_type null_count, + cuda::stream_ref stream, + rmm::device_async_resource_ref mr) { return schema->type == NANOARROW_TYPE_STRING_VIEW ? from_arrow_stringview(schema, input, std::move(mask), stream, mr) diff --git a/cpp/src/interop/from_arrow_stream.cu b/cpp/src/interop/from_arrow_stream.cu index 1c15c68aa1ab..01a1fe5e1b4e 100644 --- a/cpp/src/interop/from_arrow_stream.cu +++ b/cpp/src/interop/from_arrow_stream.cu @@ -10,6 +10,7 @@ #include #include #include +#include #include #include @@ -39,15 +40,18 @@ std::unique_ptr make_empty_column_from_schema(ArrowSchema const* schema, auto const type{arrow_to_cudf_type(&schema_view)}; switch (type.id()) { case type_id::EMPTY: { - return std::make_unique( - data_type(type_id::EMPTY), 0, rmm::device_buffer{}, rmm::device_buffer{}, 0); + return std::make_unique(data_type(type_id::EMPTY), + 0, + rmm::device_buffer{}, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), + 0); } case type_id::LIST: { return cudf::make_lists_column(0, cudf::make_empty_column(data_type{type_id::INT32}), make_empty_column_from_schema(schema->children[0], stream, mr), 0, - {}); + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); } case type_id::STRUCT: { std::vector> child_columns; @@ -57,7 +61,12 @@ std::unique_ptr make_empty_column_from_schema(ArrowSchema const* schema, schema->children + schema->n_children, std::back_inserter(child_columns), [&](auto const& child) { return make_empty_column_from_schema(child, stream, mr); }); - return cudf::make_structs_column(0, std::move(child_columns), 0, {}, stream, mr); + return cudf::make_structs_column(0, + std::move(child_columns), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), + stream, + mr); } default: { return cudf::make_empty_column(type); diff --git a/cpp/src/interop/to_arrow_host.cu b/cpp/src/interop/to_arrow_host.cu index 2b20f217922a..f26e451473c1 100644 --- a/cpp/src/interop/to_arrow_host.cu +++ b/cpp/src/interop/to_arrow_host.cu @@ -87,7 +87,8 @@ struct dispatch_to_arrow_host { enable_hugepage(&bitmap->buffer); CUDF_CUDA_TRY(cudf::detail::memcpy_async( bitmap->buffer.data, - (column.offset() > 0) ? cudf::detail::copy_bitmask(column, stream, mr).data() + (column.offset() > 0) ? reinterpret_cast( + cudf::detail::copy_bitmask(column, stream, mr).data()) : column.null_mask(), bitmap->buffer.size_bytes, stream)); diff --git a/cpp/src/io/csv/durations.cu b/cpp/src/io/csv/durations.cu index f4ae0a7aa50f..cc82f9ec25b1 100644 --- a/cpp/src/io/csv/durations.cu +++ b/cpp/src/io/csv/durations.cu @@ -171,7 +171,7 @@ struct dispatch_from_durations_fn { auto d_column = *column; // copy null mask - rmm::device_buffer null_mask = cudf::detail::copy_bitmask(durations, stream, mr); + cuda::device_buffer null_mask = cudf::detail::copy_bitmask(durations, stream, mr); // build offsets column auto offsets_transformer_itr = diff --git a/cpp/src/io/json/host_tree_algorithms.cu b/cpp/src/io/json/host_tree_algorithms.cu index 3d750e5d4338..8e2b5d2843ae 100644 --- a/cpp/src/io/json/host_tree_algorithms.cu +++ b/cpp/src/io/json/host_tree_algorithms.cu @@ -112,7 +112,7 @@ std::vector copy_strings_to_host_sync( d_offset_length_it, num_strings, data_type{type_id::STRING}, - rmm::device_buffer{}, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), 0, options_view, stream, @@ -1014,7 +1014,7 @@ void scatter_offsets(tree_meta_t const& tree, columns_data[col_id] = json_column_data{col.string_offsets.data(), col.string_lengths.data(), col.child_offsets.data(), - static_cast(col.validity.data())}; + reinterpret_cast(col.validity.data())}; } auto d_ignore_vals = cudf::detail::make_device_uvector_async( diff --git a/cpp/src/io/json/json_column.cu b/cpp/src/io/json/json_column.cu index 8d62eef09fc2..978d9b99cbd3 100644 --- a/cpp/src/io/json/json_column.cu +++ b/cpp/src/io/json/json_column.cu @@ -296,11 +296,12 @@ std::pair, std::vector> device_json_co CUDF_EXPECTS(json_col.validity.size() >= bitmask_allocation_size_bytes(json_col.num_rows), "valid_count is too small"); }; - auto make_validity = [stream, validity_size_check]( - device_json_column& json_col) -> std::pair { + auto make_validity = + [stream, validity_size_check]( + device_json_column& json_col) -> std::pair, size_type> { validity_size_check(json_col); auto null_count = cudf::detail::null_count( - static_cast(json_col.validity.data()), 0, json_col.num_rows, stream); + reinterpret_cast(json_col.validity.data()), 0, json_col.num_rows, stream); // full null_mask is always required for parse_data return {std::move(json_col.validity), null_count}; // Note: json_col modified here, moves this memory @@ -386,7 +387,9 @@ std::pair, std::vector> device_json_co // This is to match the existing JSON reader's behaviour: // - Non-string columns will always be returned as nullable // - String columns will be returned as nullable, iff there's at least one null entry - if (col->null_count() == 0) { col->set_null_mask(rmm::device_buffer{0, stream, mr}, 0); } + if (col->null_count() == 0) { + col->set_null_mask(cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED, stream, mr), 0); + } // For string columns return ["offsets"] schema if (target_type.id() == type_id::STRING) { @@ -455,11 +458,12 @@ std::pair, std::vector> device_json_co // If child is not present, set the null mask correctly, but offsets are zero, and children // are empty. Note: json_col modified here, reuse the memory - auto offsets_column = std::make_unique(data_type{type_id::INT32}, - num_rows + 1, - json_col.child_offsets.release(), - rmm::device_buffer{}, - 0); + auto offsets_column = + std::make_unique(data_type{type_id::INT32}, + num_rows + 1, + json_col.child_offsets.release(), + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), + 0); // Create children column auto child_schema_element = get_list_child_schema(); auto [child_column, names] = [&]() { @@ -491,7 +495,8 @@ std::pair, std::vector> device_json_co std::move(offsets_column), std::move(child_column), null_count, - null_count == 0 ? rmm::device_buffer{0, stream, mr} : std::move(result_bitmask)); + null_count == 0 ? cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED, stream, mr) + : std::move(result_bitmask)); // Since some rows in child column may need to be nullified due to mixed types, we cannot // skip the purge_nonempty_nulls call. if (auto const output_cv = ret_col->view(); diff --git a/cpp/src/io/json/json_tree.cu b/cpp/src/io/json/json_tree.cu index 4c9ff693c573..210151ec3a1e 100644 --- a/cpp/src/io/json/json_tree.cu +++ b/cpp/src/io/json/json_tree.cu @@ -549,7 +549,7 @@ std::pair> remapped_field_nodes_after_uni offset_length_it, num_keys, data_type{type_id::STRING}, - rmm::device_buffer{}, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), 0, opt, stream, diff --git a/cpp/src/io/json/nested_json.hpp b/cpp/src/io/json/nested_json.hpp index 4804d8cdf492..36766df4a1d4 100644 --- a/cpp/src/io/json/nested_json.hpp +++ b/cpp/src/io/json/nested_json.hpp @@ -11,6 +11,8 @@ #include #include +#include + #include #include #include @@ -152,7 +154,8 @@ struct device_json_column { rmm::device_uvector child_offsets; // Validity bitmap - rmm::device_buffer validity; + cuda::device_buffer validity = + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED); // Map of child columns, if applicable. // Following "element" as the default child column's name of a list column @@ -189,7 +192,7 @@ struct device_json_column { : string_offsets(0, stream), string_lengths(0, stream), child_offsets(0, stream, mr), - validity(0, stream, mr) + validity(stream, mr) { } }; diff --git a/cpp/src/io/json/nested_json_gpu.cu b/cpp/src/io/json/nested_json_gpu.cu index d2dc75d10c02..d921076403c4 100644 --- a/cpp/src/io/json/nested_json_gpu.cu +++ b/cpp/src/io/json/nested_json_gpu.cu @@ -2102,13 +2102,15 @@ std::pair, std::vector> json_column_to CUDF_FUNC_RANGE(); auto make_validity = - [stream, mr](json_column const& json_col) -> std::pair { + [stream, + mr](json_column const& json_col) -> std::pair, size_type> { auto const null_count = json_col.current_offset - json_col.valid_count; - if (null_count == 0) { return {rmm::device_buffer{}, null_count}; } - return {rmm::device_buffer{json_col.validity.data(), - bitmask_allocation_size_bytes(json_col.current_offset), - stream, - mr}, + if (null_count == 0) { + return {cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), null_count}; + } + auto const data = reinterpret_cast(json_col.validity.data()); + return {cudf::detail::copy_bitmask( + reinterpret_cast(data), 0, json_col.current_offset, stream, mr), null_count}; }; @@ -2175,7 +2177,9 @@ std::pair, std::vector> json_column_to // This is to match the existing JSON reader's behaviour: // - Non-string columns will always be returned as nullable // - String columns will be returned as nullable, iff there's at least one null entry - if (col->null_count() == 0) { col->set_null_mask(rmm::device_buffer{0, stream, mr}, 0); } + if (col->null_count() == 0) { + col->set_null_mask(cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED, stream, mr), 0); + } // For string columns return ["offsets"] schema if (target_type.id() == type_id::STRING) { @@ -2219,8 +2223,12 @@ std::pair, std::vector> json_column_to rmm::device_uvector d_offsets = cudf::detail::make_device_uvector_async(json_col.child_offsets, stream, mr); - auto offsets_column = std::make_unique( - data_type{type_id::INT32}, num_rows, d_offsets.release(), rmm::device_buffer{}, 0); + auto offsets_column = + std::make_unique(data_type{type_id::INT32}, + num_rows, + d_offsets.release(), + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), + 0); // Create children column auto [child_column, names] = json_col.child_columns.empty() diff --git a/cpp/src/io/json/parser_features.cpp b/cpp/src/io/json/parser_features.cpp index 0f138da3e3da..b4b82272a55c 100644 --- a/cpp/src/io/json/parser_features.cpp +++ b/cpp/src/io/json/parser_features.cpp @@ -84,7 +84,7 @@ struct empty_column_functor { return std::make_unique(cudf::data_type{type_id::LIST}, 0, rmm::device_buffer{}, - rmm::device_buffer{}, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), 0, std::move(child_columns)); } @@ -97,7 +97,12 @@ struct empty_column_functor { child_columns.push_back(cudf::type_dispatcher( schema.child_types.at(child_name).type, *this, schema.child_types.at(child_name))); } - return make_structs_column(0, std::move(child_columns), 0, {}, stream, mr); + return make_structs_column(0, + std::move(child_columns), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), + stream, + mr); } }; @@ -118,13 +123,15 @@ struct allnull_column_functor { { auto offsets_buff = cudf::detail::make_zeroed_device_uvector_async(size + 1, stream, mr); - return std::make_unique(std::move(offsets_buff), rmm::device_buffer{}, 0); + return std::make_unique( + std::move(offsets_buff), cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), 0); } [[nodiscard]] auto make_zeroed_indices(size_type size) const { auto indices_buff = cudf::detail::make_zeroed_device_uvector_async(size, stream, mr); - return std::make_unique(std::move(indices_buff), rmm::device_buffer{}, 0); + return std::make_unique( + std::move(indices_buff), cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), 0); } public: diff --git a/cpp/src/io/json/write_json.cpp b/cpp/src/io/json/write_json.cpp index 096378e9c4b7..14c9cb9f63bd 100644 --- a/cpp/src/io/json/write_json.cpp +++ b/cpp/src/io/json/write_json.cpp @@ -57,10 +57,13 @@ std::unique_ptr make_strings_column_from_host(host_span( cudf::detail::make_device_uvector(offsets, stream, cudf::get_current_device_resource_ref()), - rmm::device_buffer{}, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), 0); - return cudf::make_strings_column( - host_strings.size(), std::move(d_offsets), d_chars.release(), 0, {}); + return cudf::make_strings_column(host_strings.size(), + std::move(d_offsets), + d_chars.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); } std::unique_ptr make_column_names_column(host_span column_names, diff --git a/cpp/src/io/json/write_json.cu b/cpp/src/io/json/write_json.cu index 3a9e9bd2e247..41de79852681 100644 --- a/cpp/src/io/json/write_json.cu +++ b/cpp/src/io/json/write_json.cu @@ -158,7 +158,7 @@ struct escape_strings_fn { std::unique_ptr make_strings_column(size_type size, size_type null_count, - rmm::device_buffer null_mask, + cuda::device_buffer null_mask, cuda::stream_ref stream, rmm::device_async_resource_ref mr) { @@ -178,7 +178,7 @@ struct escape_strings_fn { std::unique_ptr make_escaped_json_strings(column_device_view const& d_column, size_type size, size_type null_count, - rmm::device_buffer null_mask, + cuda::device_buffer null_mask, bool append_colon, bool escaped_utf8, cuda::stream_ref stream, @@ -378,10 +378,11 @@ std::unique_ptr struct_to_strings(table_view const& strings_columns, auto chars_data = joined_col->release().data; return make_strings_column( num_rows, - std::make_unique(std::move(row_string_offsets), rmm::device_buffer{}, 0), + std::make_unique( + std::move(row_string_offsets), cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), 0), std::move(chars_data.release()[0]), 0, - {}); + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); } struct scatter_fn { @@ -533,7 +534,8 @@ std::unique_ptr join_list_of_strings(lists_column_view const& lists_stri auto chars_data = joined_col->release().data; return make_strings_column( num_lists, - std::make_unique(std::move(row_string_offsets), rmm::device_buffer{}, 0), + std::make_unique( + std::move(row_string_offsets), cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), 0), std::move(chars_data.release()[0]), lists_strings.null_count(), cudf::detail::copy_bitmask(lists_strings.parent(), stream, mr)); diff --git a/cpp/src/io/json/write_json.hpp b/cpp/src/io/json/write_json.hpp index f73ac32bd239..83e75be7faea 100644 --- a/cpp/src/io/json/write_json.hpp +++ b/cpp/src/io/json/write_json.hpp @@ -10,8 +10,7 @@ #include #include -#include - +#include #include #include @@ -28,7 +27,7 @@ namespace io::json::detail { std::unique_ptr make_escaped_json_strings(column_device_view const& d_column, size_type size, size_type null_count, - rmm::device_buffer null_mask, + cuda::device_buffer null_mask, bool append_colon, bool escaped_utf8, cuda::stream_ref stream, diff --git a/cpp/src/io/orc/reader_impl_decode.cu b/cpp/src/io/orc/reader_impl_decode.cu index d6181389e1cd..863ce3ccd04b 100644 --- a/cpp/src/io/orc/reader_impl_decode.cu +++ b/cpp/src/io/orc/reader_impl_decode.cu @@ -316,7 +316,7 @@ void update_null_mask(cudf::detail::hostdevice_2dvector& chunks, auto merged_null_mask = cudf::detail::create_null_mask( parent_mask_len, mask_state::ALL_NULL, cuda::stream_ref(stream), mr); - auto merged_mask = static_cast(merged_null_mask.data()); + auto merged_mask = reinterpret_cast(merged_null_mask.data()); uint32_t* dst_idx_ptr = dst_idx.data(); // Copy child valid bits from child column to valid indexes, this will merge both child // and parent null masks @@ -333,9 +333,8 @@ void update_null_mask(cudf::detail::hostdevice_2dvector& chunks, } else { // Since child column doesn't have a mask, copy parent null mask - auto mask_size = bitmask_allocation_size_bytes(parent_mask_len); out_buffers[col_idx].set_null_mask( - rmm::device_buffer(static_cast(parent_valid_map_base), mask_size, stream, mr)); + cudf::detail::copy_bitmask(parent_valid_map_base, 0, parent_mask_len, stream, mr)); } } } diff --git a/cpp/src/io/orc/reader_impl_helpers.cpp b/cpp/src/io/orc/reader_impl_helpers.cpp index 53fd40654b38..458b257080e9 100644 --- a/cpp/src/io/orc/reader_impl_helpers.cpp +++ b/cpp/src/io/orc/reader_impl_helpers.cpp @@ -38,7 +38,7 @@ std::unique_ptr create_empty_column(size_type orc_col_id, schema_info.children.back(), stream), 0, - rmm::device_buffer{0, stream}); + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED, stream)); } case MAP: { schema_info.children.emplace_back("offsets"); @@ -57,16 +57,17 @@ std::unique_ptr create_empty_column(size_type orc_col_id, stream)); children_schema[idx].name = get_map_child_col_name(idx); } - return make_lists_column(0, - make_empty_column(type_id::INT32), - make_structs_column(0, - std::move(child_columns), - 0, - rmm::device_buffer{0, stream}, - stream, - cudf::get_current_device_resource_ref()), - 0, - rmm::device_buffer{0, stream}); + return make_lists_column( + 0, + make_empty_column(type_id::INT32), + make_structs_column(0, + std::move(child_columns), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED, stream), + stream, + cudf::get_current_device_resource_ref()), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED, stream)); } case STRUCT: { @@ -84,7 +85,7 @@ std::unique_ptr create_empty_column(size_type orc_col_id, return make_structs_column(0, std::move(child_columns), 0, - rmm::device_buffer{0, stream}, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED, stream), stream, cudf::get_current_device_resource_ref()); } diff --git a/cpp/src/io/parquet/bloom_filter_reader.cu b/cpp/src/io/parquet/bloom_filter_reader.cu index d758c6b71590..c1c292d0a7a6 100644 --- a/cpp/src/io/parquet/bloom_filter_reader.cu +++ b/cpp/src/io/parquet/bloom_filter_reader.cu @@ -143,7 +143,7 @@ struct bloom_filter_caster { cudf::data_type{cudf::type_id::BOOL8}, static_cast(total_row_groups), std::move(results), - rmm::device_buffer{0, stream, cudf::get_current_device_resource_ref()}, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED, stream), 0); } diff --git a/cpp/src/io/parquet/experimental/deletion_vectors_helpers.cu b/cpp/src/io/parquet/experimental/deletion_vectors_helpers.cu index 4a061ad22d86..ab98aa99e9e9 100644 --- a/cpp/src/io/parquet/experimental/deletion_vectors_helpers.cu +++ b/cpp/src/io/parquet/experimental/deletion_vectors_helpers.cu @@ -76,11 +76,12 @@ std::unique_ptr compute_row_index_column( row_indices_iter, row_indices_iter + num_rows, start_row.value_or(size_t{0})); - return std::make_unique(cudf::data_type{cudf::type_id::UINT64}, - num_rows, - std::move(row_indices), - rmm::device_buffer{0, stream, mr}, - 0); + return std::make_unique( + cudf::data_type{cudf::type_id::UINT64}, + num_rows, + std::move(row_indices), + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED, stream, mr), + 0); } auto row_group_span_offsets = @@ -133,11 +134,12 @@ std::unique_ptr compute_row_index_column( row_indices_iter); stream.sync(); - return std::make_unique(cudf::data_type{cudf::type_id::UINT64}, - num_rows, - std::move(row_indices), - rmm::device_buffer{0, stream, mr}, - 0); + return std::make_unique( + cudf::data_type{cudf::type_id::UINT64}, + num_rows, + std::move(row_indices), + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED, stream, mr), + 0); } std::unique_ptr compute_partial_row_index_column( diff --git a/cpp/src/io/parquet/experimental/dictionary_page_filter.cu b/cpp/src/io/parquet/experimental/dictionary_page_filter.cu index 66aa588d2bdf..edb37d2e3601 100644 --- a/cpp/src/io/parquet/experimental/dictionary_page_filter.cu +++ b/cpp/src/io/parquet/experimental/dictionary_page_filter.cu @@ -981,7 +981,7 @@ struct dictionary_caster { cudf::data_type{cudf::type_id::BOOL8}, static_cast(total_row_groups), std::move(result_buffer), - rmm::device_buffer{0, stream, mr}, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED, stream, mr), 0); }); return columns; diff --git a/cpp/src/io/parquet/experimental/page_index_filter.cu b/cpp/src/io/parquet/experimental/page_index_filter.cu index aad523b8dc9f..2931811c3b4d 100644 --- a/cpp/src/io/parquet/experimental/page_index_filter.cu +++ b/cpp/src/io/parquet/experimental/page_index_filter.cu @@ -77,14 +77,14 @@ struct page_stats_caster : public stats_caster_base { * @return A pair containing the output data buffer and nullmask */ template - [[nodiscard]] std::pair build_data_and_nullmask( - mutable_column_view input_column, - bitmask_type const* page_nullmask, - cudf::device_span page_indices, - cudf::host_span page_row_offsets, - cudf::data_type dtype, - cuda::stream_ref stream, - rmm::device_async_resource_ref mr) const + [[nodiscard]] std::pair> + build_data_and_nullmask(mutable_column_view input_column, + bitmask_type const* page_nullmask, + cudf::device_span page_indices, + cudf::host_span page_row_offsets, + cudf::data_type dtype, + cuda::stream_ref stream, + rmm::device_async_resource_ref mr) const requires(not cudf::is_compound()) { // Total number of pages in the column @@ -101,7 +101,7 @@ struct page_stats_caster : public stats_caster_base { reinterpret_cast(output_data.data())); // Buffer for output bitmask - auto output_nullmask = rmm::device_buffer{0, stream, mr}; + auto output_nullmask = cudf::create_null_mask(0, mask_state::UNALLOCATED, stream, mr); if (input_column.null_count()) { // Set all bits in output nullmask to valid output_nullmask = cudf::create_null_mask(total_rows, mask_state::ALL_VALID, stream, mr); @@ -110,7 +110,7 @@ struct page_stats_caster : public stats_caster_base { cuda::counting_iterator{total_pages}, [&](auto const page_idx) { if (not bit_is_set(page_nullmask, page_idx)) { - cudf::set_null_mask(static_cast(output_nullmask.data()), + cudf::set_null_mask(reinterpret_cast(output_nullmask.data()), page_row_offsets[page_idx], page_row_offsets[page_idx + 1], false, @@ -178,7 +178,7 @@ struct page_stats_caster : public stats_caster_base { * @return A pair containing the output data buffer and nullmask */ [[nodiscard]] std:: - tuple, rmm::device_buffer> + tuple, cuda::device_buffer> build_string_data_and_nullmask(cudf::host_span host_strings, cudf::host_span host_chars, bitmask_type const* host_page_nullmask, @@ -220,7 +220,7 @@ struct page_stats_caster : public stats_caster_base { auto const input_nullmask = host_page_nullmask; // Buffer for row-level strings nullmask (output) - auto output_nullmask = rmm::device_buffer{0, stream, mr}; + auto output_nullmask = cudf::create_null_mask(0, mask_state::UNALLOCATED, stream, mr); if (host_null_count) { // Set all bits in output nullmask to valid output_nullmask = cudf::create_null_mask(total_rows, mask_state::ALL_VALID, stream, mr); @@ -229,7 +229,7 @@ struct page_stats_caster : public stats_caster_base { cuda::counting_iterator{total_pages}, [&](auto const page_idx) { if (not bit_is_set(input_nullmask, page_idx)) { - cudf::set_null_mask(static_cast(output_nullmask.data()), + cudf::set_null_mask(reinterpret_cast(output_nullmask.data()), page_row_offsets[page_idx], page_row_offsets[page_idx + 1], false, @@ -515,22 +515,28 @@ struct page_stats_caster : public stats_caster_base { : 0; // Return min, max and is_null device strings columns - return { - cudf::make_strings_column( - total_rows, - std::make_unique(std::move(min_offsets), rmm::device_buffer{0, stream, mr}, 0), - std::move(min_data), - min_nulls, - std::move(min_nullmask)), - cudf::make_strings_column( - total_rows, - std::make_unique(std::move(max_offsets), rmm::device_buffer{0, stream, mr}, 0), - std::move(max_data), - max_nulls, - std::move(max_nullmask)), - has_is_null_operator ? std::make_optional(build_is_null_device_column( - is_null.value(), page_indices, page_row_offsets, stream, mr)) - : std::nullopt}; + return {cudf::make_strings_column( + total_rows, + std::make_unique( + std::move(min_offsets), + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED, stream, mr), + 0), + std::move(min_data), + min_nulls, + std::move(min_nullmask)), + cudf::make_strings_column( + total_rows, + std::make_unique( + std::move(max_offsets), + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED, stream, mr), + 0), + std::move(max_data), + max_nulls, + std::move(max_nullmask)), + has_is_null_operator + ? std::make_optional(build_is_null_device_column( + is_null.value(), page_indices, page_row_offsets, stream, mr)) + : std::nullopt}; } } } @@ -943,27 +949,27 @@ std::unique_ptr aggregate_reader_metadata::build_row_mask_with_pag if (not stats_columns_mask[col_idx] or (cudf::is_compound(dtype) && dtype.id() != cudf::type_id::STRING)) { // Placeholder for unsupported types and non-participating columns - page_stats_columns.push_back(cudf::make_numeric_column( - data_type{cudf::type_id::BOOL8}, - total_rows, - rmm::device_buffer{0, stream, cudf::get_current_device_resource_ref()}, - 0, - stream, - cudf::get_current_device_resource_ref())); - page_stats_columns.push_back(cudf::make_numeric_column( - data_type{cudf::type_id::BOOL8}, - total_rows, - rmm::device_buffer{0, stream, cudf::get_current_device_resource_ref()}, - 0, - stream, - cudf::get_current_device_resource_ref())); - page_stats_columns.push_back(cudf::make_numeric_column( - data_type{cudf::type_id::BOOL8}, - total_rows, - rmm::device_buffer{0, stream, cudf::get_current_device_resource_ref()}, - 0, - stream, - cudf::get_current_device_resource_ref())); + page_stats_columns.push_back( + cudf::make_numeric_column(data_type{cudf::type_id::BOOL8}, + total_rows, + cudf::create_null_mask(0, mask_state::UNALLOCATED, stream), + 0, + stream, + cudf::get_current_device_resource_ref())); + page_stats_columns.push_back( + cudf::make_numeric_column(data_type{cudf::type_id::BOOL8}, + total_rows, + cudf::create_null_mask(0, mask_state::UNALLOCATED, stream), + 0, + stream, + cudf::get_current_device_resource_ref())); + page_stats_columns.push_back( + cudf::make_numeric_column(data_type{cudf::type_id::BOOL8}, + total_rows, + cudf::create_null_mask(0, mask_state::UNALLOCATED, stream), + 0, + stream, + cudf::get_current_device_resource_ref())); return; } auto [min_col, max_col, is_null_col] = cudf::type_dispatcher( diff --git a/cpp/src/io/parquet/experimental/variant_extract.cu b/cpp/src/io/parquet/experimental/variant_extract.cu index f68610b74924..e3cc8f5ad3d1 100644 --- a/cpp/src/io/parquet/experimental/variant_extract.cu +++ b/cpp/src/io/parquet/experimental/variant_extract.cu @@ -1132,7 +1132,8 @@ struct cast_variant_fn { size_type num_rows; data_type desired_type; bitmask_type* d_null_mask; - rmm::device_buffer null_mask; + cuda::device_buffer null_mask{ + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)}; cuda::stream_ref stream; rmm::device_async_resource_ref mr; // In-out status tracking; null when no status was requested. @@ -1155,7 +1156,9 @@ struct cast_variant_fn { return std::make_unique(desired_type, num_rows, std::move(data), - null_count > 0 ? std::move(null_mask) : rmm::device_buffer{}, + null_count > 0 + ? std::move(null_mask) + : cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), null_count); } @@ -1177,7 +1180,9 @@ struct cast_variant_fn { return std::make_unique(desired_type, num_rows, std::move(data), - null_count > 0 ? std::move(null_mask) : rmm::device_buffer{}, + null_count > 0 + ? std::move(null_mask) + : cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), null_count); } @@ -1218,7 +1223,9 @@ struct cast_variant_fn { return std::make_unique(desired_type, num_rows, std::move(data), - null_count > 0 ? std::move(null_mask) : rmm::device_buffer{}, + null_count > 0 + ? std::move(null_mask) + : cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), null_count); } @@ -1236,7 +1243,9 @@ struct cast_variant_fn { std::move(offsets_column), chars.release(), null_count, - null_count > 0 ? std::move(null_mask) : rmm::device_buffer{}); + null_count > 0 + ? std::move(null_mask) + : cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); } template @@ -1302,17 +1311,21 @@ std::unique_ptr build_path_column(cudf::host_span ste } host_offsets[depth] = host_chars.size(); - auto d_offsets = cudf::detail::make_device_uvector_async(host_offsets, stream, mr); - auto offsets_col = std::make_unique(data_type{type_id::INT32}, - static_cast(host_offsets.size()), - d_offsets.release(), - rmm::device_buffer{}, - 0); + auto d_offsets = cudf::detail::make_device_uvector_async(host_offsets, stream, mr); + auto offsets_col = + std::make_unique(data_type{type_id::INT32}, + static_cast(host_offsets.size()), + d_offsets.release(), + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), + 0); auto d_chars = cudf::detail::make_device_uvector( host_span{host_chars.data(), host_chars.size()}, stream, mr); - return cudf::make_strings_column( - depth, std::move(offsets_col), d_chars.release(), 0, rmm::device_buffer{}); + return cudf::make_strings_column(depth, + std::move(offsets_col), + d_chars.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); } } // namespace @@ -1351,8 +1364,11 @@ std::unique_ptr get_variant_field(column_view const& variant_column, } if (num_rows == 0) { - return cudf::make_lists_column( - 0, make_empty_column(type_id::INT32), make_empty_column(type_id::UINT8), 0, {}); + return cudf::make_lists_column(0, + make_empty_column(type_id::INT32), + make_empty_column(type_id::UINT8), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); } auto const temp_mr = cudf::get_current_device_resource_ref(); @@ -1377,7 +1393,7 @@ std::unique_ptr get_variant_field(column_view const& variant_column, variant_column.nullable() ? cudf::detail::copy_bitmask(variant_column, stream, mr) : cudf::create_null_mask(variant_column.size(), mask_state::ALL_VALID, stream, mr); - auto* d_null_mask = static_cast(null_mask.data()); + auto* d_null_mask = reinterpret_cast(null_mask.data()); auto grid = cudf::detail::grid_1d{num_rows, block_size}; @@ -1429,7 +1445,9 @@ std::unique_ptr get_variant_field(column_view const& variant_column, std::move(offsets_column), std::move(val_child), null_count, - null_count > 0 ? std::move(null_mask) : rmm::device_buffer{}); + null_count > 0 + ? std::move(null_mask) + : cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); } std::unique_ptr cast_variant(column_view const& values, @@ -1478,7 +1496,7 @@ std::unique_ptr cast_variant(column_view const& values, auto null_mask = values.nullable() ? cudf::detail::copy_bitmask(values, stream, mr) : cudf::create_null_mask(num_rows, mask_state::ALL_VALID, stream, mr); - auto* d_null_mask = static_cast(null_mask.data()); + auto* d_null_mask = reinterpret_cast(null_mask.data()); return cudf::type_dispatcher( desired_type, @@ -1507,7 +1525,7 @@ std::unique_ptr get_variant_type_id(column_view const& values, auto null_mask = values.nullable() ? cudf::detail::copy_bitmask(values, stream, mr) : cudf::create_null_mask(num_rows, mask_state::ALL_VALID, stream, mr); - auto* d_null_mask = static_cast(null_mask.data()); + auto* d_null_mask = reinterpret_cast(null_mask.data()); rmm::device_buffer data{static_cast(num_rows) * sizeof(uint8_t), stream, mr}; @@ -1528,7 +1546,9 @@ std::unique_ptr get_variant_type_id(column_view const& values, return std::make_unique(data_type{type_id::UINT8}, num_rows, std::move(data), - null_count > 0 ? std::move(null_mask) : rmm::device_buffer{}, + null_count > 0 + ? std::move(null_mask) + : cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), null_count); } diff --git a/cpp/src/io/parquet/predicate_pushdown.cpp b/cpp/src/io/parquet/predicate_pushdown.cpp index 14c3644abf80..f4fddc9aa5ce 100644 --- a/cpp/src/io/parquet/predicate_pushdown.cpp +++ b/cpp/src/io/parquet/predicate_pushdown.cpp @@ -106,24 +106,27 @@ std::optional>> aggregate_reader_metadata::ap if (not stats_columns_mask[col_idx] or (cudf::is_compound(dtype) && dtype.id() != cudf::type_id::STRING)) { // Placeholder for unsupported types and non-participating columns - columns.push_back(cudf::make_numeric_column(data_type{cudf::type_id::BOOL8}, - total_row_groups, - rmm::device_buffer{0, stream, mr}, - 0, - stream, - mr)); - columns.push_back(cudf::make_numeric_column(data_type{cudf::type_id::BOOL8}, - total_row_groups, - rmm::device_buffer{0, stream, mr}, - 0, - stream, - mr)); - columns.push_back(cudf::make_numeric_column(data_type{cudf::type_id::BOOL8}, - total_row_groups, - rmm::device_buffer{0, stream, mr}, - 0, - stream, - mr)); + columns.push_back(cudf::make_numeric_column( + data_type{cudf::type_id::BOOL8}, + total_row_groups, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED, stream, mr), + 0, + stream, + mr)); + columns.push_back(cudf::make_numeric_column( + data_type{cudf::type_id::BOOL8}, + total_row_groups, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED, stream, mr), + 0, + stream, + mr)); + columns.push_back(cudf::make_numeric_column( + data_type{cudf::type_id::BOOL8}, + total_row_groups, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED, stream, mr), + 0, + stream, + mr)); continue; } // Map each filter column's zeroth-source schema index into every source's schema tree. diff --git a/cpp/src/io/parquet/stats_filter_helpers.hpp b/cpp/src/io/parquet/stats_filter_helpers.hpp index 7183fcda2380..fa3d4749ab72 100644 --- a/cpp/src/io/parquet/stats_filter_helpers.hpp +++ b/cpp/src/io/parquet/stats_filter_helpers.hpp @@ -10,6 +10,7 @@ #include #include #include +#include #include #include #include @@ -280,19 +281,26 @@ class stats_caster_base { { if constexpr (std::is_same_v) { auto [d_chars, d_offsets, _] = make_strings_children(val, chars, stream, mr); - auto null_mask_buffer = rmm::device_buffer{ - null_mask.data(), cudf::bitmask_allocation_size_bytes(val.size()), stream, mr}; + auto null_mask_buffer = + cudf::create_null_mask(val.size(), cudf::mask_state::UNINITIALIZED, stream, mr); + CUDF_CUDA_TRY(cudf::detail::memcpy_async( + null_mask_buffer.data(), null_mask.data(), null_mask_buffer.size(), stream)); stream.sync(); return cudf::make_strings_column( val.size(), - std::make_unique(std::move(d_offsets), rmm::device_buffer{0, stream, mr}, 0), + std::make_unique( + std::move(d_offsets), + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED, stream, mr), + 0), d_chars.release(), null_count, std::move(null_mask_buffer)); } - auto data = cudf::detail::make_device_uvector_async(val, stream, mr); - auto null_mask_buffer = rmm::device_buffer{ - null_mask.data(), cudf::bitmask_allocation_size_bytes(val.size()), stream, mr}; + auto data = cudf::detail::make_device_uvector_async(val, stream, mr); + auto null_mask_buffer = + cudf::create_null_mask(val.size(), cudf::mask_state::UNINITIALIZED, stream, mr); + CUDF_CUDA_TRY(cudf::detail::memcpy_async( + null_mask_buffer.data(), null_mask.data(), null_mask_buffer.size(), stream)); stream.sync(); return std::make_unique( dtype, val.size(), data.release(), std::move(null_mask_buffer), null_count); diff --git a/cpp/src/io/parquet/synthetic_column_helpers.cu b/cpp/src/io/parquet/synthetic_column_helpers.cu index c656bac8dcee..7720247e724e 100644 --- a/cpp/src/io/parquet/synthetic_column_helpers.cu +++ b/cpp/src/io/parquet/synthetic_column_helpers.cu @@ -97,7 +97,9 @@ std::unique_ptr synthesize_row_index_column( } return std::make_unique( - std::move(col_data), rmm::device_buffer{0, stream, mr.get_output_mr()}, 0); + std::move(col_data), + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED, stream, mr.get_output_mr()), + 0); } std::unique_ptr synthesize_source_index_column( @@ -141,7 +143,9 @@ std::unique_ptr synthesize_source_index_column( } return std::make_unique( - std::move(col_data), rmm::device_buffer{0, stream, mr.get_output_mr()}, 0); + std::move(col_data), + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED, stream, mr.get_output_mr()), + 0); } std::unique_ptr synthesize_row_group_index_column( diff --git a/cpp/src/io/text/multibyte_split.cu b/cpp/src/io/text/multibyte_split.cu index f2d9de7224ff..9747adb9fae5 100644 --- a/cpp/src/io/text/multibyte_split.cu +++ b/cpp/src/io/text/multibyte_split.cu @@ -562,7 +562,11 @@ std::unique_ptr multibyte_split(cudf::io::text::data_chunk_source })); return cudf::strings::detail::make_strings_column(it, it + string_count, stream, mr); } else { - return cudf::make_strings_column(string_count, std::move(offsets), chars.release(), 0, {}); + return cudf::make_strings_column(string_count, + std::move(offsets), + chars.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); } } diff --git a/cpp/src/io/utilities/column_buffer.cpp b/cpp/src/io/utilities/column_buffer.cpp index d7aa318710b3..6482cf2f892a 100644 --- a/cpp/src/io/utilities/column_buffer.cpp +++ b/cpp/src/io/utilities/column_buffer.cpp @@ -215,8 +215,12 @@ std::unique_ptr make_column(column_buffer_base& buffer, "Cannot convert strings column to lists column due to size_type limit", std::overflow_error); - auto uint8_col = std::make_unique( - data_type{type_id::UINT8}, char_size, std::move(*data), rmm::device_buffer{}, 0); + auto uint8_col = + std::make_unique(data_type{type_id::UINT8}, + char_size, + std::move(*data), + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), + 0); if (schema_info != nullptr) { schema_info->children.emplace_back("offsets"); @@ -248,8 +252,12 @@ std::unique_ptr make_column(column_buffer_base& buffer, case type_id::LIST: { // make offsets column - auto offsets = std::make_unique( - data_type{type_id::INT32}, buffer.size, std::move(buffer._data), rmm::device_buffer{}, 0); + auto offsets = + std::make_unique(data_type{type_id::INT32}, + buffer.size, + std::move(buffer._data), + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), + 0); column_name_info* child_info = nullptr; if (schema_info != nullptr) { @@ -342,7 +350,11 @@ std::unique_ptr empty_like(column_buffer_base& buffer, schema_info->is_binary = true; } return make_lists_column( - 0, std::move(offsets), std::move(child), 0, rmm::device_buffer{0, stream, mr}); + 0, + std::move(offsets), + std::move(child), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED, stream, mr)); } return cudf::make_empty_column(buffer.type); } @@ -365,7 +377,11 @@ std::unique_ptr empty_like(column_buffer_base& buffer, // make the final list column return make_lists_column( - 0, std::move(offsets), std::move(child), 0, rmm::device_buffer{0, stream, mr}); + 0, + std::move(offsets), + std::move(child), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED, stream, mr)); } break; case type_id::STRUCT: { @@ -385,7 +401,12 @@ std::unique_ptr empty_like(column_buffer_base& buffer, }); return make_structs_column( - 0, std::move(output_children), 0, rmm::device_buffer{0, stream, mr}, stream, mr); + 0, + std::move(output_children), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED, stream, mr), + stream, + mr); } break; default: return cudf::make_empty_column(buffer.type); diff --git a/cpp/src/io/utilities/column_buffer.hpp b/cpp/src/io/utilities/column_buffer.hpp index fec442a2c83f..caa3b3d5c6ff 100644 --- a/cpp/src/io/utilities/column_buffer.hpp +++ b/cpp/src/io/utilities/column_buffer.hpp @@ -128,12 +128,12 @@ class column_buffer_base { // input column, including same type, nullability, name, and user_data. static string_policy empty_like(string_policy const& input); - void set_null_mask(rmm::device_buffer&& mask) { _null_mask = std::move(mask); } + void set_null_mask(cuda::device_buffer&& mask) { _null_mask = std::move(mask); } template auto null_mask() { - return static_cast(_null_mask.data()); + return reinterpret_cast(_null_mask.data()); } auto null_mask_size() { return _null_mask.size(); } auto& null_count() { return _null_count; } @@ -152,7 +152,8 @@ class column_buffer_base { protected: rmm::device_buffer _data{}; - rmm::device_buffer _null_mask{}; + cuda::device_buffer _null_mask = + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED); size_type _null_count{0}; rmm::device_async_resource_ref _mr{cudf::get_current_device_resource_ref()}; diff --git a/cpp/src/io/utilities/column_buffer_strings.cu b/cpp/src/io/utilities/column_buffer_strings.cu index 40c088966e3c..26e93c5b85e8 100644 --- a/cpp/src/io/utilities/column_buffer_strings.cu +++ b/cpp/src/io/utilities/column_buffer_strings.cu @@ -32,8 +32,12 @@ std::unique_ptr cudf::io::detail::inline_column_buffer::make_string_colu size, std::move(offsets_col), std::move(_string_data), null_count(), std::move(_null_mask)); } else { // no need for copies, just transfer ownership of the data_buffers to the columns - auto offsets_col = std::make_unique( - data_type{type_id::INT32}, size + 1, std::move(_data), rmm::device_buffer{}, 0); + auto offsets_col = + std::make_unique(data_type{type_id::INT32}, + size + 1, + std::move(_data), + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), + 0); return make_strings_column( size, std::move(offsets_col), std::move(_string_data), null_count(), std::move(_null_mask)); } diff --git a/cpp/src/io/utilities/data_casting.cu b/cpp/src/io/utilities/data_casting.cu index 111048e8e9fe..467821df5ff1 100644 --- a/cpp/src/io/utilities/data_casting.cu +++ b/cpp/src/io/utilities/data_casting.cu @@ -791,7 +791,7 @@ struct to_string_view_pair { template static std::unique_ptr parse_string(string_view_pair_it str_tuples, size_type col_size, - rmm::device_buffer&& null_mask, + cuda::device_buffer&& null_mask, cudf::detail::device_scalar& d_null_count, cudf::io::parse_options_view const& options, cuda::stream_ref stream, @@ -811,8 +811,12 @@ static std::unique_ptr parse_string(string_view_pair_it str_tuples, auto d_sizes = sizes.data(); auto null_count_data = d_null_count.data(); - auto single_thread_fn = string_parse{ - str_tuples, static_cast(null_mask.data()), null_count_data, options, d_sizes}; + auto single_thread_fn = + string_parse{str_tuples, + reinterpret_cast(null_mask.data()), + null_count_data, + options, + d_sizes}; thrust::for_each_n(rmm::exec_policy_nosync(stream, cudf::get_current_device_resource_ref()), cuda::counting_iterator{0}, col_size, @@ -831,7 +835,7 @@ static std::unique_ptr parse_string(string_view_pair_it str_tuples, str_tuples, col_size, str_counter.data(), - static_cast(null_mask.data()), + reinterpret_cast(null_mask.data()), null_count_data, options, d_sizes, @@ -848,7 +852,7 @@ static std::unique_ptr parse_string(string_view_pair_it str_tuples, str_tuples, col_size, str_counter.data(), - static_cast(null_mask.data()), + reinterpret_cast(null_mask.data()), null_count_data, options, d_sizes, @@ -879,7 +883,7 @@ static std::unique_ptr parse_string(string_view_pair_it str_tuples, str_tuples, col_size, str_counter.data(), - static_cast(null_mask.data()), + reinterpret_cast(null_mask.data()), null_count_data, options, d_sizes, @@ -896,7 +900,7 @@ static std::unique_ptr parse_string(string_view_pair_it str_tuples, str_tuples, col_size, str_counter.data(), - static_cast(null_mask.data()), + reinterpret_cast(null_mask.data()), null_count_data, options, d_sizes, @@ -917,7 +921,7 @@ std::unique_ptr parse_data( cuda::zip_iterator offset_length_begin, size_type col_size, data_type col_type, - rmm::device_buffer&& null_mask, + cuda::device_buffer&& null_mask, size_type null_count, cudf::io::parse_options_view const& options, cuda::stream_ref stream, @@ -929,7 +933,7 @@ std::unique_ptr parse_data( auto d_null_count = cudf::detail::device_scalar( null_count, stream, cudf::get_current_device_resource_ref()); auto null_count_data = d_null_count.data(); - if (null_mask.is_empty()) { + if (null_mask.empty()) { null_mask = cudf::create_null_mask(col_size, mask_state::ALL_VALID, stream, mr); } diff --git a/cpp/src/io/utilities/string_parsing.hpp b/cpp/src/io/utilities/string_parsing.hpp index 86e1c453f7d3..542cf313fad5 100644 --- a/cpp/src/io/utilities/string_parsing.hpp +++ b/cpp/src/io/utilities/string_parsing.hpp @@ -11,6 +11,7 @@ #include #include +#include #include #include #include @@ -143,7 +144,7 @@ CUDF_EXPORT std::unique_ptr parse_data( cuda::zip_iterator offset_length_begin, size_type col_size, data_type col_type, - rmm::device_buffer&& null_mask, + cuda::device_buffer&& null_mask, size_type null_count, cudf::io::parse_options_view const& options, cuda::stream_ref stream, diff --git a/cpp/src/join/filtered_join/filtered_join.cu b/cpp/src/join/filtered_join/filtered_join.cu index 9c814c2294a3..a9da76adcd89 100644 --- a/cpp/src/join/filtered_join/filtered_join.cu +++ b/cpp/src/join/filtered_join/filtered_join.cu @@ -13,11 +13,11 @@ #include #include #include +#include #include #include #include -#include #include #include #include @@ -39,11 +39,11 @@ namespace detail { /** * @brief Returns a validity mask for rows without nulls at any nested level, or null when unused. */ -std::pair make_filtered_join_row_bitmask( +std::pair, bitmask_type const*> make_filtered_join_row_bitmask( table_view const& input, null_equality nulls_equal, cuda::stream_ref stream) { if (nulls_equal == null_equality::EQUAL || !has_nested_nulls(input)) { - return std::pair(rmm::device_buffer{0, stream}, nullptr); + return std::pair(cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED, stream), nullptr); } auto const nullable_columns = get_nullable_columns(input); @@ -54,11 +54,12 @@ std::pair make_filtered_join_row_bitmas cudf::detail::bitmask_and( table_view{nullable_columns}, stream, cudf::get_current_device_resource_ref()) .first; - auto const row_bitmask_ptr = static_cast(row_bitmask.data()); + auto const row_bitmask_ptr = reinterpret_cast(row_bitmask.data()); return std::pair(std::move(row_bitmask), row_bitmask_ptr); } - return std::pair(rmm::device_buffer{0, stream}, nullable_columns.front().null_mask()); + return std::pair(cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED, stream), + nullable_columns.front().null_mask()); } namespace { diff --git a/cpp/src/join/filtered_join/filtered_join_common.cuh b/cpp/src/join/filtered_join/filtered_join_common.cuh index 555fbb08d6fa..166d7cb6566e 100644 --- a/cpp/src/join/filtered_join/filtered_join_common.cuh +++ b/cpp/src/join/filtered_join/filtered_join_common.cuh @@ -13,9 +13,8 @@ #include #include -#include - #include +#include #include #include #include @@ -37,7 +36,7 @@ struct precomputed_hash { hash_value_type const* _hashes; }; -std::pair make_filtered_join_row_bitmask( +std::pair, bitmask_type const*> make_filtered_join_row_bitmask( table_view const& input, null_equality nulls_equal, cuda::stream_ref stream); class filtered_join_row_is_valid { diff --git a/cpp/src/join/hash_join/hash_join.cu b/cpp/src/join/hash_join/hash_join.cu index de27a204dfe5..440e8357a350 100644 --- a/cpp/src/join/hash_join/hash_join.cu +++ b/cpp/src/join/hash_join/hash_join.cu @@ -108,7 +108,7 @@ hash_join::hash_join(cudf::table_view const& right, auto const temp_mr = cudf::get_current_device_resource_ref(); auto const row_bitmask = cudf::detail::bitmask_and(right, stream, temp_mr).first; auto const valid_rows = _nulls_equal == null_equality::UNEQUAL - ? static_cast(row_bitmask.data()) + ? reinterpret_cast(row_bitmask.data()) : nullptr; rmm::device_uvector build_positions(right.num_rows(), stream, temp_mr); auto build = [&](auto equality, auto hasher) { diff --git a/cpp/src/join/hash_join/match_context.cu b/cpp/src/join/hash_join/match_context.cu index 1bdf16728007..570b8afc123b 100644 --- a/cpp/src/join/hash_join/match_context.cu +++ b/cpp/src/join/hash_join/match_context.cu @@ -43,7 +43,7 @@ std::unique_ptr> hash_join::make_match_co auto const temp_mr = cudf::get_current_device_resource_ref(); auto const row_bitmask = cudf::detail::bitmask_and(left, stream, temp_mr).first; auto const valid_rows = _nulls_equal == null_equality::UNEQUAL - ? static_cast(row_bitmask.data()) + ? reinterpret_cast(row_bitmask.data()) : nullptr; auto count_matches = [&](auto equality, auto hasher) { diff --git a/cpp/src/join/hash_join/partitioned_join_retrieve.cu b/cpp/src/join/hash_join/partitioned_join_retrieve.cu index f214eb5d6215..ccce88a7e527 100644 --- a/cpp/src/join/hash_join/partitioned_join_retrieve.cu +++ b/cpp/src/join/hash_join/partitioned_join_retrieve.cu @@ -102,7 +102,7 @@ hash_join::partitioned_join_retrieve(join_kind join, rmm::device_uvector probe_slots(partition_size, stream, temp_mr); auto const row_bitmask = cudf::detail::bitmask_and(left_partition_view, stream, temp_mr).first; auto const valid_rows = _nulls_equal == null_equality::UNEQUAL - ? static_cast(row_bitmask.data()) + ? reinterpret_cast(row_bitmask.data()) : nullptr; auto save_slots = [&](auto equality, auto hasher) { if (join == join_kind::INNER_JOIN) { diff --git a/cpp/src/join/hash_join/retrieve_impl.cuh b/cpp/src/join/hash_join/retrieve_impl.cuh index c03bc4d67c28..75877df85d47 100644 --- a/cpp/src/join/hash_join/retrieve_impl.cuh +++ b/cpp/src/join/hash_join/retrieve_impl.cuh @@ -80,7 +80,7 @@ hash_join::join_retrieve(cudf::table_view const& left, auto matched_build_rows = cudf::detail::device_scalar(0, stream, temp_mr); auto const row_bitmask = cudf::detail::bitmask_and(left, stream, temp_mr).first; auto const valid_rows = _nulls_equal == null_equality::UNEQUAL - ? static_cast(row_bitmask.data()) + ? reinterpret_cast(row_bitmask.data()) : nullptr; auto count_matches = [&](auto equality, auto hasher) { diff --git a/cpp/src/join/hash_join/size_impl.cuh b/cpp/src/join/hash_join/size_impl.cuh index 5b900bcf2cb5..978347d0052d 100644 --- a/cpp/src/join/hash_join/size_impl.cuh +++ b/cpp/src/join/hash_join/size_impl.cuh @@ -45,7 +45,7 @@ std::size_t hash_join::join_size(cudf::table_view const& left, cudf::detail::make_zeroed_device_uvector_async(left.num_rows(), stream, temp_mr); auto const row_bitmask = cudf::detail::bitmask_and(left, stream, temp_mr).first; auto const valid_rows = _nulls_equal == null_equality::UNEQUAL - ? static_cast(row_bitmask.data()) + ? reinterpret_cast(row_bitmask.data()) : nullptr; auto count_matches = [&](auto equality, auto hasher) { @@ -94,7 +94,7 @@ std::size_t hash_join::join_size(cudf::table_view const& left, auto matched_build_rows = cudf::detail::device_scalar(0, stream, temp_mr); auto const row_bitmask = cudf::detail::bitmask_and(left, stream, temp_mr).first; auto const valid_rows = _nulls_equal == null_equality::UNEQUAL - ? static_cast(row_bitmask.data()) + ? reinterpret_cast(row_bitmask.data()) : nullptr; auto count_matches = [&](auto equality, auto hasher) { diff --git a/cpp/src/join/key_remapping.cu b/cpp/src/join/key_remapping.cu index 62e49e8f4354..dd7208849936 100644 --- a/cpp/src/join/key_remapping.cu +++ b/cpp/src/join/key_remapping.cu @@ -315,7 +315,7 @@ class key_remap_table : public key_remap_table_interface { auto const row_bitmask = skip_nulls ? cudf::detail::bitmask_and(_right, stream, cudf::get_current_device_resource_ref()).first - : rmm::device_buffer{}; + : cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED); auto const bitmask_ptr = skip_nulls ? reinterpret_cast(row_bitmask.data()) : nullptr; @@ -667,8 +667,11 @@ std::unique_ptr remap_keys_internal(detail::key_remapping_impl con not_found_sentinel); auto const row_count = static_cast(indices->size()); - return std::make_unique( - cudf::data_type{cudf::type_id::INT32}, row_count, indices->release(), rmm::device_buffer{}, 0); + return std::make_unique(cudf::data_type{cudf::type_id::INT32}, + row_count, + indices->release(), + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), + 0); } } // namespace diff --git a/cpp/src/join/mark_join.cu b/cpp/src/join/mark_join.cu index 947bada5361f..b662a5e6c118 100644 --- a/cpp/src/join/mark_join.cu +++ b/cpp/src/join/mark_join.cu @@ -38,8 +38,8 @@ namespace cudf { namespace detail { namespace { -std::pair build_row_bitmask(table_view const& input, - cuda::stream_ref stream) +std::pair, bitmask_type const*> build_row_bitmask( + table_view const& input, cuda::stream_ref stream) { auto const nullable_columns = get_nullable_columns(input); CUDF_EXPECTS(nullable_columns.size() > 0, @@ -49,11 +49,12 @@ std::pair build_row_bitmask(table_view if (nullable_columns.size() > 1) { auto row_bitmask = cudf::detail::bitmask_and(table_view{nullable_columns}, stream, temp_mr).first; - auto const row_bitmask_ptr = static_cast(row_bitmask.data()); + auto const row_bitmask_ptr = reinterpret_cast(row_bitmask.data()); return std::pair(std::move(row_bitmask), row_bitmask_ptr); } - return std::pair(rmm::device_buffer{0, stream, temp_mr}, nullable_columns.front().null_mask()); + return std::pair(cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED, stream, temp_mr), + nullable_columns.front().null_mask()); } struct row_is_null { @@ -505,7 +506,8 @@ std::unique_ptr> mark_join::mark_probe_and_ auto const num_buckets = static_cast(storage_ref.num_buckets()); auto const right_has_nulls = has_nested_nulls(right); - rmm::device_buffer right_bitmask_buffer(0, stream, temp_mr); + auto right_bitmask_buffer = + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED, stream, temp_mr); bitmask_type const* right_bitmask_ptr = nullptr; if (right_has_nulls && _nulls_equal == null_equality::UNEQUAL) { auto bitmask_buffer_and_ptr = build_row_bitmask(right, stream); @@ -623,7 +625,8 @@ mark_join::mark_join(cudf::table_view const& left, cudf::has_nested_nulls(_left) && _nulls_equal == null_equality::UNEQUAL; auto const temp_mr = cudf::get_current_device_resource_ref(); - rmm::device_buffer row_bitmask_buffer(0, stream, temp_mr); + auto row_bitmask_buffer = + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED, stream, temp_mr); bitmask_type const* row_bitmask_ptr = nullptr; if (has_null_left_keys) { auto bitmask_buffer_and_ptr = build_row_bitmask(_left, stream); diff --git a/cpp/src/join/mixed_join_semi.cu b/cpp/src/join/mixed_join_semi.cu index b4957429e8d2..e6f1d808f74d 100644 --- a/cpp/src/join/mixed_join_semi.cu +++ b/cpp/src/join/mixed_join_semi.cu @@ -163,7 +163,7 @@ std::unique_ptr> mixed_join_semi( } else { cuda::counting_iterator stencil(0); auto const [row_bitmask, _] = cudf::detail::bitmask_and(right, stream, temp_mr); - row_is_valid pred{static_cast(row_bitmask.data())}; + row_is_valid pred{reinterpret_cast(row_bitmask.data())}; // insert valid rows row_set.insert_if_async(iter, iter + right_num_rows, stencil, pred, stream.get()); diff --git a/cpp/src/join/sort_merge_join.cu b/cpp/src/join/sort_merge_join.cu index cb403a9d77c3..4a24d3a58bf4 100644 --- a/cpp/src/join/sort_merge_join.cu +++ b/cpp/src/join/sort_merge_join.cu @@ -545,7 +545,7 @@ void sort_merge_join::preprocessed_table::populate_nonnull_filter(cuda::stream_r // If the table has no nullable top-level columns, then we need to create // an all-valid bitmask that is passed to subsequent operations. This bitmask // is updated if any of the nested struct/list children columns have nulls. - if (validity_mask.is_empty()) + if (validity_mask.empty()) validity_mask = cudf::create_null_mask(table.num_rows(), mask_state::ALL_VALID, stream, temp_mr); @@ -584,8 +584,8 @@ void sort_merge_join::preprocessed_table::populate_nonnull_filter(cuda::stream_r rmm::exec_policy_nosync(stream, cudf::get_current_device_resource_ref()), cuda::counting_iterator{0}, cuda::counting_iterator{0} + subset_size, - list_nonnull_filter{static_cast(validity_mask.data()), - static_cast(reduced_validity_mask.data()), + list_nonnull_filter{reinterpret_cast(validity_mask.data()), + reinterpret_cast(reduced_validity_mask.data()), child_positions, static_cast(subset_offset)}); } else if (col.type().id() == type_id::STRUCT) { @@ -628,12 +628,12 @@ void sort_merge_join::preprocessed_table::populate_nonnull_filter(cuda::stream_r // Process all children of the struct column for (auto it = col.child_begin(); it != col.child_end(); it++) { auto& child = *it; - and_bitmasks(and_bitmasks, static_cast(validity_mask.data()), child); + and_bitmasks(and_bitmasks, reinterpret_cast(validity_mask.data()), child); } } } this->_num_nulls = - null_count(static_cast(validity_mask.data()), 0, table.num_rows(), stream); + null_count(reinterpret_cast(validity_mask.data()), 0, table.num_rows(), stream); this->_validity_mask = std::move(validity_mask); } @@ -731,7 +731,7 @@ rmm::device_uvector sort_merge_join::preprocessed_table::map_table_to cuda::counting_iterator{_table_view.num_rows()}, cuda::counting_iterator{0}, table_mapping.begin(), - is_row_valid{static_cast(_validity_mask.value().data())}, + is_row_valid{reinterpret_cast(_validity_mask.value().data())}, stream); return table_mapping; } @@ -869,7 +869,7 @@ sort_merge_join::left_join(table_view const& left, preprocessed_left_indices->size() + static_cast(num_filtered_nulls); auto const validity_mask = - static_cast(preprocessed_left._validity_mask.value().data()); + reinterpret_cast(preprocessed_left._validity_mask.value().data()); rmm::device_uvector null_left_indices{static_cast(num_filtered_nulls), stream, cudf::get_current_device_resource_ref()}; diff --git a/cpp/src/join/sort_merge_join.hpp b/cpp/src/join/sort_merge_join.hpp index 2924548386c9..6425ff527fb3 100644 --- a/cpp/src/join/sort_merge_join.hpp +++ b/cpp/src/join/sort_merge_join.hpp @@ -13,9 +13,9 @@ #include #include -#include #include +#include #include #include @@ -120,7 +120,7 @@ class sort_merge_join { ///< rows of the unprocessed table view if null equality is set ///< to false, otherwise equal to the unprocessed table view - std::optional _validity_mask = + std::optional> _validity_mask = std::nullopt; ///< Optional validity mask for null_equality::UNEQUAL case std::optional _num_nulls = std::nullopt; ///< Optional count of nulls for null_equality::UNEQUAL case diff --git a/cpp/src/join/streaming_hash_join.cu b/cpp/src/join/streaming_hash_join.cu index 6ec7921a3ba9..377fc3c910af 100644 --- a/cpp/src/join/streaming_hash_join.cu +++ b/cpp/src/join/streaming_hash_join.cu @@ -357,7 +357,7 @@ class streaming_hash_join_impl { auto preprocessed = row::equality::preprocessed_table::create(keys, stream, mr.get_output_mr()); auto const batch_rows = keys.num_rows(); - auto row_bitmask = [&]() -> std::optional { + auto row_bitmask = [&]() -> std::optional> { if (batch_rows > 0 && compare_nulls == null_equality::UNEQUAL && nullable(keys)) { return cudf::detail::bitmask_and(keys, stream, mr.get_temporary_mr()).first; } diff --git a/cpp/src/json/json_path.cu b/cpp/src/json/json_path.cu index ff74c2167dde..9aeba95edc30 100644 --- a/cpp/src/json/json_path.cu +++ b/cpp/src/json/json_path.cu @@ -1026,7 +1026,7 @@ std::unique_ptr get_json_object(cudf::strings_column_view const& c // potential optimization : if we know that all outputs are valid, we could skip creating // the validity mask altogether - rmm::device_buffer validity = + cuda::device_buffer validity = cudf::detail::create_null_mask(col.size(), mask_state::UNINITIALIZED, stream, mr); // compute results @@ -1040,7 +1040,7 @@ std::unique_ptr get_json_object(cudf::strings_column_view const& c sizes.data(), d_offsets, chars.data(), - static_cast(validity.data()), + reinterpret_cast(validity.data()), d_valid_count.data(), options); CUDF_CUDA_TRY(cudaGetLastError()); diff --git a/cpp/src/lists/combine/concatenate_list_elements.cu b/cpp/src/lists/combine/concatenate_list_elements.cu index 927706969f63..1e30716c351b 100644 --- a/cpp/src/lists/combine/concatenate_list_elements.cu +++ b/cpp/src/lists/combine/concatenate_list_elements.cu @@ -96,7 +96,9 @@ std::unique_ptr concatenate_lists_ignore_null(column_view const& input, std::move(out_offsets), std::move(out_entries), null_count, - null_count > 0 ? std::move(null_mask) : rmm::device_buffer{}); + null_count > 0 + ? std::move(null_mask) + : cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); } /** @@ -215,11 +217,12 @@ std::unique_ptr concatenate_lists_nullifying_rows(column_view const& inp auto [null_mask, null_count] = cudf::detail::valid_if( list_validities.begin(), list_validities.end(), cuda::std::identity{}, stream, mr); - return make_lists_column(num_rows, - std::move(list_offsets), - std::move(list_entries), - null_count, - null_count ? std::move(null_mask) : rmm::device_buffer{}); + return make_lists_column( + num_rows, + std::move(list_offsets), + std::move(list_entries), + null_count, + null_count ? std::move(null_mask) : cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); } } // namespace diff --git a/cpp/src/lists/combine/concatenate_rows.cu b/cpp/src/lists/combine/concatenate_rows.cu index eff1c2b6377d..a6dfa2edbca5 100644 --- a/cpp/src/lists/combine/concatenate_rows.cu +++ b/cpp/src/lists/combine/concatenate_rows.cu @@ -59,7 +59,7 @@ namespace { * We can do this by recomputing a new offsets column that does this regrouping. * */ -std::tuple, rmm::device_buffer, size_type> +std::tuple, cuda::device_buffer, size_type> generate_regrouped_offsets_and_null_mask(table_device_view const& input, bool build_null_mask, concatenate_null_policy null_policy, @@ -125,7 +125,8 @@ generate_regrouped_offsets_and_null_mask(table_device_view const& input, auto [null_mask, null_count] = [&]() { // if the input doesn't contain nulls, no work to do if (!build_null_mask) { - return std::pair{rmm::device_buffer{}, 0}; + return std::pair, size_type>{ + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), 0}; } // row is null if -all- input rows are null diff --git a/cpp/src/lists/copying/concatenate.cu b/cpp/src/lists/copying/concatenate.cu index f2fc6d002410..9947fa3c85cf 100644 --- a/cpp/src/lists/copying/concatenate.cu +++ b/cpp/src/lists/copying/concatenate.cu @@ -115,9 +115,9 @@ std::unique_ptr concatenate(host_span columns, // if any of the input columns have nulls, construct the output mask bool const has_nulls = std::any_of(columns.begin(), columns.end(), [](auto const& col) { return col.has_nulls(); }); - rmm::device_buffer null_mask = cudf::detail::create_null_mask( + cuda::device_buffer null_mask = cudf::detail::create_null_mask( total_list_count, has_nulls ? mask_state::UNINITIALIZED : mask_state::UNALLOCATED, stream, mr); - auto null_mask_data = static_cast(null_mask.data()); + auto null_mask_data = reinterpret_cast(null_mask.data()); auto const null_count = has_nulls ? cudf::detail::concatenate_masks(columns, null_mask_data, stream) : size_type{0}; diff --git a/cpp/src/lists/copying/copying.cu b/cpp/src/lists/copying/copying.cu index 4d598f514ebc..0e5e66a022d0 100644 --- a/cpp/src/lists/copying/copying.cu +++ b/cpp/src/lists/copying/copying.cu @@ -53,11 +53,12 @@ std::unique_ptr copy_slice(lists_column_view const& lists, offsets_data + end + 1, // size of offsets column is 1 greater than slice length out_offsets.data(), [start_offset] __device__(cudf::size_type i) { return i - start_offset; }); - auto offsets = std::make_unique(cudf::data_type{cudf::type_id::INT32}, - offsets_count, - out_offsets.release(), - rmm::device_buffer{}, - 0); + auto offsets = + std::make_unique(cudf::data_type{cudf::type_id::INT32}, + offsets_count, + out_offsets.release(), + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), + 0); // Compute the child column of the result. // If the child of this lists column is itself a lists column, we call copy_slice() on it. @@ -75,7 +76,7 @@ std::unique_ptr copy_slice(lists_column_view const& lists, auto null_mask = cudf::detail::copy_bitmask(lists.null_mask(), start, end, stream, mr); auto null_count = cudf::detail::null_count( - static_cast(null_mask.data()), 0, end - start, stream); + reinterpret_cast(null_mask.data()), 0, end - start, stream); return make_lists_column( lists_count, std::move(offsets), std::move(child), null_count, std::move(null_mask)); diff --git a/cpp/src/lists/copying/gather.cu b/cpp/src/lists/copying/gather.cu index 270a96bab11a..44b60e0e4b63 100644 --- a/cpp/src/lists/copying/gather.cu +++ b/cpp/src/lists/copying/gather.cu @@ -98,7 +98,9 @@ std::unique_ptr gather_list_leaf(column_view const& column, mr); auto leaf_column = std::move(gather_table->release().front()); - if (column.null_count() == 0) { leaf_column->set_null_mask(rmm::device_buffer{}, 0); } + if (column.null_count() == 0) { + leaf_column->set_null_mask(cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), 0); + } return leaf_column; } @@ -120,7 +122,7 @@ std::unique_ptr gather_list_nested(cudf::lists_column_view const& list, if (gather_map_size == 0) { return empty_like(list.parent()); } // gather the bitmask, if relevant - rmm::device_buffer null_mask{0, stream, mr}; + auto null_mask = cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED, stream, mr); size_type null_count = list.null_count(); if (null_count > 0) { auto list_cdv = column_device_view::create(list.parent(), stream); diff --git a/cpp/src/lists/copying/scatter_helper.cu b/cpp/src/lists/copying/scatter_helper.cu index 160a7bb23a94..95338490f399 100644 --- a/cpp/src/lists/copying/scatter_helper.cu +++ b/cpp/src/lists/copying/scatter_helper.cu @@ -34,9 +34,10 @@ namespace detail { * @param num_child_rows Number of rows in child column * @param stream CUDA stream used for device memory operations and kernel launches * @param mr Device memory resource used to allocate child column's null mask - * @return std::pair Child column's null mask and null row count + * @return std::pair, size_type> Child column's null mask and null + * row count */ -std::pair construct_child_nullmask( +std::pair, size_type> construct_child_nullmask( rmm::device_uvector const& parent_list_vector, column_view const& parent_list_offsets, cudf::lists_column_device_view const& source_lists, @@ -165,7 +166,7 @@ struct list_child_constructor { source_lists_column_view.child().nullable() || target_lists_column_view.child().nullable() ? construct_child_nullmask( list_vector, list_offsets, source_lists, target_lists, num_child_rows, stream, mr) - : std::pair(rmm::device_buffer{}, 0); + : std::pair(cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), 0); auto child_column = cudf::make_fixed_width_column(source_lists_column_view.child().type(), num_child_rows, @@ -346,7 +347,7 @@ struct list_child_constructor { source_lists_column_view.child().nullable() || target_lists_column_view.child().nullable() ? construct_child_nullmask( list_vector, list_offsets, source_lists, target_lists, num_child_rows, stream, mr) - : std::pair(rmm::device_buffer{}, 0); + : std::pair(cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), 0); return cudf::make_lists_column(num_child_rows, std::move(child_offsets), @@ -437,7 +438,7 @@ struct list_child_constructor { source_lists_column_view.child().nullable() || target_lists_column_view.child().nullable() ? construct_child_nullmask( list_vector, list_offsets, source_lists, target_lists, num_child_rows, stream, mr) - : std::pair(rmm::device_buffer{}, 0); + : std::pair(cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), 0); return cudf::make_structs_column(num_child_rows, std::move(child_columns), diff --git a/cpp/src/lists/explode.cu b/cpp/src/lists/explode.cu index ef83718b7c6f..3bd093d36e6f 100644 --- a/cpp/src/lists/explode.cu +++ b/cpp/src/lists/explode.cu @@ -77,14 +77,16 @@ std::unique_ptr
build_table( if (position_array) { size_type position_size = position_array->size(); // build the null mask for position based on invalid entries in gather map - auto nullmask = explode_col_gather_map ? valid_if( - explode_col_gather_map->begin(), - explode_col_gather_map->end(), - [] __device__(auto i) { return i != InvalidIndex; }, - stream, - mr) - : std::pair{ - rmm::device_buffer(0, stream), size_type{0}}; + auto nullmask = + explode_col_gather_map + ? valid_if( + explode_col_gather_map->begin(), + explode_col_gather_map->end(), + [] __device__(auto i) { return i != InvalidIndex; }, + stream, + mr) + : std::pair, size_type>{ + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED, stream), size_type{0}}; columns.insert(columns.begin() + explode_column_idx, std::make_unique(data_type(type_to_id()), diff --git a/cpp/src/lists/extract.cu b/cpp/src/lists/extract.cu index 9d3ffddda15d..f0d90640b62c 100644 --- a/cpp/src/lists/extract.cu +++ b/cpp/src/lists/extract.cu @@ -131,11 +131,12 @@ std::unique_ptr extract_list_element_impl(lists_column_view lists_column // 2. If indices = {4, 3, 2, 1, null}, // index_lists_column = { {4}, {3}, {2}, {1}, {MAX_SIZE_TYPE} }. - auto const index_lists_column = make_lists_column(num_lists, - make_index_offsets(num_lists, stream), - make_index_child(index, num_lists, stream), - 0, - {}); + auto const index_lists_column = + make_lists_column(num_lists, + make_index_offsets(num_lists, stream), + make_index_child(index, num_lists, stream), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); // We want the output of `segmented_gather` to be a lists column in which each list has exactly // one element, even for the null lists. diff --git a/cpp/src/lists/interleave_columns.cu b/cpp/src/lists/interleave_columns.cu index 8daaa3a3dfc1..2fba2e44f994 100644 --- a/cpp/src/lists/interleave_columns.cu +++ b/cpp/src/lists/interleave_columns.cu @@ -363,17 +363,21 @@ std::unique_ptr interleave_columns(table_view const& input, mr); if (not has_null_mask) { - return make_lists_column( - num_output_lists, std::move(list_offsets), std::move(list_entries), 0, rmm::device_buffer{}); + return make_lists_column(num_output_lists, + std::move(list_offsets), + std::move(list_entries), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); } auto [null_mask, null_count] = cudf::detail::valid_if( list_validities.begin(), list_validities.end(), cuda::std::identity{}, stream, mr); - return make_lists_column(num_output_lists, - std::move(list_offsets), - std::move(list_entries), - null_count, - null_count ? std::move(null_mask) : rmm::device_buffer{}); + return make_lists_column( + num_output_lists, + std::move(list_offsets), + std::move(list_entries), + null_count, + null_count ? std::move(null_mask) : cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); } } // namespace detail diff --git a/cpp/src/lists/lists_column_factories.cu b/cpp/src/lists/lists_column_factories.cu index bb384d0e09a4..b05603d9a476 100644 --- a/cpp/src/lists/lists_column_factories.cu +++ b/cpp/src/lists/lists_column_factories.cu @@ -55,7 +55,7 @@ std::unique_ptr make_lists_column_from_scalar(list_scalar const& v auto one_row_col_view = column_view(data_type{type_id::LIST}, 1, nullptr, - static_cast(null_mask.data()), + reinterpret_cast(null_mask.data()), null_count, 0, children_views); @@ -74,7 +74,11 @@ std::unique_ptr make_empty_lists_column(data_type child_type) { auto offsets = make_empty_column(data_type(type_id::INT32)); auto child = make_empty_column(child_type); - return make_lists_column(0, std::move(offsets), std::move(child), 0, rmm::device_buffer{}); + return make_lists_column(0, + std::move(offsets), + std::move(child), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); } std::unique_ptr make_all_nulls_lists_column(size_type size, @@ -85,7 +89,8 @@ std::unique_ptr make_all_nulls_lists_column(size_type size, auto offsets = [&] { auto offsets_buff = cudf::detail::make_zeroed_device_uvector_async(size + 1, stream, mr); - return std::make_unique(std::move(offsets_buff), rmm::device_buffer{}, 0); + return std::make_unique( + std::move(offsets_buff), cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), 0); }(); auto child = make_empty_column(child_type); auto null_mask = cudf::detail::create_null_mask(size, mask_state::ALL_NULL, stream, mr); @@ -107,7 +112,7 @@ std::unique_ptr make_lists_column(size_type num_rows, std::unique_ptr offsets_column, std::unique_ptr child_column, size_type null_count, - rmm::device_buffer&& null_mask) + cuda::device_buffer&& null_mask) { if (null_count > 0) { CUDF_EXPECTS(null_mask.size() > 0, "Column with nulls must be nullable."); } CUDF_EXPECTS( diff --git a/cpp/src/lists/sequences.cu b/cpp/src/lists/sequences.cu index 5b35211c5839..93295fa24ea8 100644 --- a/cpp/src/lists/sequences.cu +++ b/cpp/src/lists/sequences.cu @@ -168,8 +168,11 @@ std::unique_ptr sequences(column_view const& starts, stream, mr); - return make_lists_column( - n_lists, std::move(list_offsets), std::move(child), 0, rmm::device_buffer(0, stream, mr)); + return make_lists_column(n_lists, + std::move(list_offsets), + std::move(child), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED, stream, mr)); } } // anonymous namespace diff --git a/cpp/src/merge/merge.cu b/cpp/src/merge/merge.cu index e52b22b0f38c..e4902a15bf8a 100644 --- a/cpp/src/merge/merge.cu +++ b/cpp/src/merge/merge.cu @@ -504,14 +504,14 @@ std::unique_ptr column_merger::operator()( auto const merged_size = lcol.size() + rcol.size(); // materialize the output buffer - rmm::device_buffer validity = + cuda::device_buffer validity = lcol.has_nulls() || rcol.has_nulls() ? detail::create_null_mask(merged_size, mask_state::UNINITIALIZED, stream, mr) - : rmm::device_buffer{}; + : cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED); if (lcol.has_nulls() || rcol.has_nulls()) { materialize_bitmask(lcol, rcol, - static_cast(validity.data()), + reinterpret_cast(validity.data()), merged_size, row_order_.data(), stream); diff --git a/cpp/src/partitioning/partitioning.cu b/cpp/src/partitioning/partitioning.cu index f7feca6edc45..b5696d21d0cd 100644 --- a/cpp/src/partitioning/partitioning.cu +++ b/cpp/src/partitioning/partitioning.cu @@ -426,8 +426,11 @@ struct copy_block_partitions_dispatcher { grid_size, stream); - return std::make_unique( - input.type(), input.size(), std::move(output), rmm::device_buffer{}, 0); + return std::make_unique(input.type(), + input.size(), + std::move(output), + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), + 0); } template ())> diff --git a/cpp/src/quantiles/tdigest/tdigest.cu b/cpp/src/quantiles/tdigest/tdigest.cu index 283f66bbaf80..3cf89f19dc47 100644 --- a/cpp/src/quantiles/tdigest/tdigest.cu +++ b/cpp/src/quantiles/tdigest/tdigest.cu @@ -221,7 +221,8 @@ std::unique_ptr compute_approx_percentiles(tdigest_column_view const& in }, stream, mr) - : std::pair{rmm::device_buffer{}, 0}; + : std::pair, size_type>{ + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), 0}; }(); auto result = cudf::make_fixed_width_column( @@ -269,18 +270,31 @@ std::unique_ptr make_tdigest_column(size_type num_rows, inner_children.push_back(std::move(centroid_means)); inner_children.push_back(std::move(centroid_weights)); auto tdigest_data = - cudf::make_structs_column(centroids_size, std::move(inner_children), 0, {}, stream, mr); + cudf::make_structs_column(centroids_size, + std::move(inner_children), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), + stream, + mr); // grouped into lists - auto tdigest = - cudf::make_lists_column(num_rows, std::move(tdigest_offsets), std::move(tdigest_data), 0, {}); + auto tdigest = cudf::make_lists_column(num_rows, + std::move(tdigest_offsets), + std::move(tdigest_data), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); // create the final column std::vector> children; children.push_back(std::move(tdigest)); children.push_back(std::move(min_values)); children.push_back(std::move(max_values)); - return make_structs_column(num_rows, std::move(children), 0, {}, stream, mr); + return make_structs_column(num_rows, + std::move(children), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), + stream, + mr); } std::unique_ptr make_empty_tdigests_column(size_type num_rows, @@ -383,7 +397,8 @@ std::unique_ptr percentile_approx(tdigest_column_view const& input, tdigest_is_empty + tdv.size(), 0); if (null_count == 0) { - return std::pair{rmm::device_buffer{}, null_count}; + return std::pair, size_type>{ + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), null_count}; } return cudf::detail::valid_if( tdigest_is_empty, tdigest_is_empty + tdv.size(), cuda::std::logical_not{}, stream, mr); diff --git a/cpp/src/quantiles/tdigest/tdigest_aggregation.cu b/cpp/src/quantiles/tdigest/tdigest_aggregation.cu index ded66b749262..27d9657b9644 100644 --- a/cpp/src/quantiles/tdigest/tdigest_aggregation.cu +++ b/cpp/src/quantiles/tdigest/tdigest_aggregation.cu @@ -1070,7 +1070,9 @@ std::unique_ptr compute_tdigests(int delta, auto offsets = [&]() { if (cinfo.requires_rescan) { compute_cluster_starts(cinfo, stream); } return std::make_unique( - std::move(cinfo.cluster_start), rmm::device_buffer{0, stream, mr}, 0); + std::move(cinfo.cluster_start), + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED, stream, mr), + 0); }(); // create final tdigest column diff --git a/cpp/src/reductions/approx_distinct_count.cu b/cpp/src/reductions/approx_distinct_count.cu index 2c1f217a1502..51a8416bc085 100644 --- a/cpp/src/reductions/approx_distinct_count.cu +++ b/cpp/src/reductions/approx_distinct_count.cu @@ -247,7 +247,8 @@ void approx_distinct_count::add(table_view const& input, cuda::stream_re ref.add_async(hash_iter, hash_iter + num_rows, stream); } else { auto const row_bitmask = cudf::detail::bitmask_and(input, stream, temp_mr).first; - auto const pred = row_is_valid{static_cast(row_bitmask.data())}; + auto const pred = + row_is_valid{reinterpret_cast(row_bitmask.data())}; ref.add_if_async(hash_iter, hash_iter + num_rows, stencil, pred, stream); } } else { @@ -257,7 +258,7 @@ void approx_distinct_count::add(table_view const& input, cuda::stream_re ref.add_if_async(hash_iter, hash_iter + num_rows, stencil, pred, stream); } else { auto const row_bitmask = cudf::detail::bitmask_and(input, stream, temp_mr).first; - auto const bitmask_ptr = static_cast(row_bitmask.data()); + auto const bitmask_ptr = reinterpret_cast(row_bitmask.data()); auto const pred = check_nans_predicate{*d_table, bitmask_ptr}; ref.add_if_async(hash_iter, hash_iter + num_rows, stencil, pred, stream); } diff --git a/cpp/src/reductions/collect_ops.cu b/cpp/src/reductions/collect_ops.cu index 818d2ddd6e32..f02f5cb14bd0 100644 --- a/cpp/src/reductions/collect_ops.cu +++ b/cpp/src/reductions/collect_ops.cu @@ -42,7 +42,8 @@ std::unique_ptr collect_list(column_view const& col, auto filter = cudf::detail::validity_accessor(*d_view); auto null_purged_table = cudf::detail::copy_if(table_view{{col}}, filter, stream, mr); column* null_purged_col = null_purged_table->release().front().release(); - null_purged_col->set_null_mask(rmm::device_buffer{0, stream, mr}, 0); + null_purged_col->set_null_mask( + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED, stream, mr), 0); return std::make_unique(std::move(*null_purged_col), true, stream, mr); } else { return make_list_scalar(col, stream, mr); diff --git a/cpp/src/reductions/distinct_count.cu b/cpp/src/reductions/distinct_count.cu index a4a8cf5c9481..026771dad6cd 100644 --- a/cpp/src/reductions/distinct_count.cu +++ b/cpp/src/reductions/distinct_count.cu @@ -170,7 +170,7 @@ cudf::size_type distinct_count(table_view const& keys, // zero. So, it is only when null_count is not zero that we need // to do a filtered insertion. if (null_count > 0) { - row_validity pred{static_cast(row_bitmask.data())}; + row_validity pred{reinterpret_cast(row_bitmask.data())}; return key_set.insert_if(iter, iter + num_rows, stencil, pred, stream.get()) + 1; } } diff --git a/cpp/src/reductions/histogram.cu b/cpp/src/reductions/histogram.cu index 380f21e8f65e..fb56f9fa5839 100644 --- a/cpp/src/reductions/histogram.cu +++ b/cpp/src/reductions/histogram.cu @@ -10,6 +10,7 @@ #include #include #include +#include #include #include #include @@ -75,8 +76,13 @@ auto gather_histogram(table_view const& input, std::vector> struct_children; struct_children.emplace_back(std::move(distinct_rows->release().front())); struct_children.emplace_back(std::move(distinct_counts)); - auto output_structs = make_structs_column( - static_cast(distinct_indices.size()), std::move(struct_children), 0, {}, stream, mr); + auto output_structs = + make_structs_column(static_cast(distinct_indices.size()), + std::move(struct_children), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), + stream, + mr); return std::make_unique( std::move(*output_structs.release()), true, stream, mr); @@ -92,7 +98,7 @@ std::unique_ptr make_empty_histogram_like(column_view const& values) return std::make_unique(data_type{type_id::STRUCT}, 0, rmm::device_buffer{}, - rmm::device_buffer{}, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), 0, std::move(struct_children)); } diff --git a/cpp/src/reductions/scan/ewm.cu b/cpp/src/reductions/scan/ewm.cu index 171ede513fe4..2a24947be955 100644 --- a/cpp/src/reductions/scan/ewm.cu +++ b/cpp/src/reductions/scan/ewm.cu @@ -310,7 +310,7 @@ struct ewma_functor { return std::make_unique(cudf::data_type(cudf::type_to_id()), input.size(), result.release(), - rmm::device_buffer{}, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), 0); } }; diff --git a/cpp/src/reductions/scan/scan.cuh b/cpp/src/reductions/scan/scan.cuh index 24837c6c0884..4ca917008d25 100644 --- a/cpp/src/reductions/scan/scan.cuh +++ b/cpp/src/reductions/scan/scan.cuh @@ -20,10 +20,10 @@ namespace cudf { namespace detail { // logical-and scan of the null mask of the input view -std::pair mask_scan(column_view const& input_view, - scan_type inclusive, - cuda::stream_ref stream, - rmm::device_async_resource_ref mr); +std::pair, size_type> mask_scan(column_view const& input_view, + scan_type inclusive, + cuda::stream_ref stream, + rmm::device_async_resource_ref mr); // exponentially weighted moving average of the input std::unique_ptr exponentially_weighted_moving_average(column_view const& input, diff --git a/cpp/src/reductions/scan/scan_exclusive.cu b/cpp/src/reductions/scan/scan_exclusive.cu index 17000ec41c1a..5b7ba872f822 100644 --- a/cpp/src/reductions/scan/scan_exclusive.cu +++ b/cpp/src/reductions/scan/scan_exclusive.cu @@ -93,11 +93,11 @@ std::unique_ptr scan_exclusive(column_view const& input, } else if (input.nullable()) { return mask_scan(input, scan_type::EXCLUSIVE, stream, mr); } - return std::make_pair(rmm::device_buffer{}, size_type{0}); + return std::make_pair(cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), size_type{0}); }(); auto output = scan_agg_dispatch( - input, agg, static_cast(mask.data()), stream, mr); + input, agg, reinterpret_cast(mask.data()), stream, mr); output->set_null_mask(std::move(mask), null_count); return output; diff --git a/cpp/src/reductions/scan/scan_inclusive.cu b/cpp/src/reductions/scan/scan_inclusive.cu index fd5b8c01b684..2dd357f2cca5 100644 --- a/cpp/src/reductions/scan/scan_inclusive.cu +++ b/cpp/src/reductions/scan/scan_inclusive.cu @@ -33,12 +33,12 @@ namespace cudf { namespace detail { // logical-and scan of the null mask of the input view -std::pair mask_scan(column_view const& input_view, - scan_type inclusive, - cuda::stream_ref stream, - rmm::device_async_resource_ref mr) +std::pair, size_type> mask_scan(column_view const& input_view, + scan_type inclusive, + cuda::stream_ref stream, + rmm::device_async_resource_ref mr) { - rmm::device_buffer mask = + cuda::device_buffer mask = detail::create_null_mask(input_view.size(), mask_state::UNINITIALIZED, stream, mr); auto d_input = column_device_view::create(input_view, stream); auto valid_itr = detail::make_validity_iterator(*d_input); @@ -54,9 +54,12 @@ std::pair mask_scan(column_view const& input_view return std::min(input_view.size(), first_null + exclusive_offset); }(); - set_null_mask(static_cast(mask.data()), 0, first_null_position, true, stream); - set_null_mask( - static_cast(mask.data()), first_null_position, input_view.size(), false, stream); + set_null_mask(reinterpret_cast(mask.data()), 0, first_null_position, true, stream); + set_null_mask(reinterpret_cast(mask.data()), + first_null_position, + input_view.size(), + false, + stream); return {std::move(mask), input_view.size() - first_null_position}; } @@ -207,11 +210,11 @@ std::unique_ptr scan_inclusive(column_view const& input, } else if (input.nullable()) { return mask_scan(input, scan_type::INCLUSIVE, stream, mr); } - return std::make_pair(rmm::device_buffer{}, size_type{0}); + return std::make_pair(cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), size_type{0}); }(); auto output = scan_agg_dispatch( - input, agg, static_cast(mask.data()), stream, mr); + input, agg, reinterpret_cast(mask.data()), stream, mr); // Use the null mask produced by the op for EWM if (agg.kind != aggregation::EWMA) { output->set_null_mask(std::move(mask), null_count); } diff --git a/cpp/src/reshape/byte_cast.cu b/cpp/src/reshape/byte_cast.cu index 97c5892cce7d..ad1f07db240e 100644 --- a/cpp/src/reshape/byte_cast.cu +++ b/cpp/src/reshape/byte_cast.cu @@ -128,8 +128,12 @@ struct byte_list_conversion_fn(input, stream, mr)->release(); - auto uint8_col = std::make_unique( - output_type, num_chars, std::move(*(col_content.data)), rmm::device_buffer{}, 0); + auto uint8_col = + std::make_unique(output_type, + num_chars, + std::move(*(col_content.data)), + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), + 0); auto offsets_col = std::move(col_content.children[strings_column_view::offsets_column_index]); if (offsets_col->type().id() != type_id::INT32) { diff --git a/cpp/src/reshape/interleave_columns.cu b/cpp/src/reshape/interleave_columns.cu index 80c395213068..054d0a75aa62 100644 --- a/cpp/src/reshape/interleave_columns.cu +++ b/cpp/src/reshape/interleave_columns.cu @@ -124,7 +124,9 @@ struct interleave_columns_impl(validity.data()), 1, std::move(col), stream, mr); + reinterpret_cast(validity.data()), 1, std::move(col), stream, mr); } return table{std::move(data_cols)}; diff --git a/cpp/src/search/contains_table_impl.cu b/cpp/src/search/contains_table_impl.cu index a4733f0ec52a..1f5ab9ed5280 100644 --- a/cpp/src/search/contains_table_impl.cu +++ b/cpp/src/search/contains_table_impl.cu @@ -19,8 +19,8 @@ namespace cudf::detail { * @param stream CUDA stream used for device memory operations and kernel launches * @return A pair of pointer to the output bitmask and the buffer containing the bitmask */ -std::pair build_row_bitmask(table_view const& input, - cuda::stream_ref stream) +std::pair, bitmask_type const*> build_row_bitmask( + table_view const& input, cuda::stream_ref stream) { auto const nullable_columns = get_nullable_columns(input); CUDF_EXPECTS(nullable_columns.size() > 0, @@ -33,11 +33,12 @@ std::pair build_row_bitmask(table_view cudf::detail::bitmask_and( table_view{nullable_columns}, stream, cudf::get_current_device_resource_ref()) .first; - auto const row_bitmask_ptr = static_cast(row_bitmask.data()); + auto const row_bitmask_ptr = reinterpret_cast(row_bitmask.data()); return std::pair(std::move(row_bitmask), row_bitmask_ptr); } - return std::pair(rmm::device_buffer{0, stream}, nullable_columns.front().null_mask()); + return std::pair(cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED, stream), + nullable_columns.front().null_mask()); } } // namespace cudf::detail diff --git a/cpp/src/search/contains_table_impl.cuh b/cpp/src/search/contains_table_impl.cuh index 7599c8a41fc8..2c5788069581 100644 --- a/cpp/src/search/contains_table_impl.cuh +++ b/cpp/src/search/contains_table_impl.cuh @@ -93,8 +93,8 @@ struct comparator_adapter { * @param stream CUDA stream used for device memory operations and kernel launches * @return A pair of pointer to the output bitmask and the buffer containing the bitmask */ -std::pair build_row_bitmask(table_view const& input, - cuda::stream_ref stream); +std::pair, bitmask_type const*> build_row_bitmask( + table_view const& input, cuda::stream_ref stream); /** * @brief Helper function to perform the contains operation using a hash set diff --git a/cpp/src/sort/segmented_top_k.cu b/cpp/src/sort/segmented_top_k.cu index 96dcb606a16a..21c56b674a8b 100644 --- a/cpp/src/sort/segmented_top_k.cu +++ b/cpp/src/sort/segmented_top_k.cu @@ -122,8 +122,11 @@ std::unique_ptr segmented_top_k_order(column_view const& col, -1); auto const num_rows = static_cast(offsets->size() - 1); - return make_lists_column( - num_rows, std::move(offsets), std::move(result), 0, rmm::device_buffer{}); + return make_lists_column(num_rows, + std::move(offsets), + std::move(result), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); } std::unique_ptr segmented_top_k(column_view const& col, @@ -148,8 +151,11 @@ std::unique_ptr segmented_top_k(column_view const& col, mr); auto offsets = std::move(ordered->release().children.front()); auto const num_rows = static_cast(offsets->size() - 1); - return make_lists_column( - num_rows, std::move(offsets), std::move(result->release().front()), 0, rmm::device_buffer{}); + return make_lists_column(num_rows, + std::move(offsets), + std::move(result->release().front()), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); } } // namespace detail diff --git a/cpp/src/sort/top_k.cu b/cpp/src/sort/top_k.cu index 6937034f85ea..f3ed74406c27 100644 --- a/cpp/src/sort/top_k.cu +++ b/cpp/src/sort/top_k.cu @@ -72,7 +72,8 @@ struct dispatch_topk_fn { tmp.data(), tmp_size, keys_in, keys_out, vals_in, vals_out, size, k, env)); } - return std::make_unique(std::move(indices), rmm::device_buffer{}, 0); + return std::make_unique( + std::move(indices), cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), 0); } template diff --git a/cpp/src/stream_compaction/distinct.cu b/cpp/src/stream_compaction/distinct.cu index 07a348b12c4a..47c78f3f1828 100644 --- a/cpp/src/stream_compaction/distinct.cu +++ b/cpp/src/stream_compaction/distinct.cu @@ -191,7 +191,8 @@ std::unique_ptr distinct_indices(table_view const& input, { CUDF_FUNC_RANGE(); auto indices = detail::distinct_indices(input, keep, nulls_equal, nans_equal, stream, mr); - return std::make_unique(std::move(indices), rmm::device_buffer{}, 0); + return std::make_unique( + std::move(indices), cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), 0); } } // namespace cudf diff --git a/cpp/src/strings/char_types/char_types.cu b/cpp/src/strings/char_types/char_types.cu index a60ca863c9d8..89a7a0ab95fb 100644 --- a/cpp/src/strings/char_types/char_types.cu +++ b/cpp/src/strings/char_types/char_types.cu @@ -188,7 +188,8 @@ std::unique_ptr filter_characters_of_type(strings_column_view const& str d_replacement}; // copy null mask from input column - rmm::device_buffer null_mask = cudf::detail::copy_bitmask(strings.parent(), stream, mr); + cuda::device_buffer null_mask = + cudf::detail::copy_bitmask(strings.parent(), stream, mr); // this utility calls filterer to build the offsets and chars columns auto [offsets_column, chars] = make_strings_children(filterer, strings_count, stream, mr); diff --git a/cpp/src/strings/combine/join.cu b/cpp/src/strings/combine/join.cu index 7d0ad215743f..62ff2a725dbb 100644 --- a/cpp/src/strings/combine/join.cu +++ b/cpp/src/strings/combine/join.cu @@ -167,7 +167,7 @@ std::unique_ptr join_strings(strings_column_view const& input, static_cast(input.null_count() == input.size() && !narep.is_valid(stream)); auto null_mask = null_count ? cudf::detail::create_null_mask(1, cudf::mask_state::ALL_NULL, stream, mr) - : rmm::device_buffer{0, stream, mr}; + : cudf::detail::create_null_mask(0, cudf::mask_state::UNALLOCATED, stream, mr); // perhaps this return a string_scalar instead of a single-row column return make_strings_column( diff --git a/cpp/src/strings/convert/convert_booleans.cu b/cpp/src/strings/convert/convert_booleans.cu index 9264a2302b48..45fc5b3b0484 100644 --- a/cpp/src/strings/convert/convert_booleans.cu +++ b/cpp/src/strings/convert/convert_booleans.cu @@ -127,7 +127,7 @@ std::unique_ptr from_booleans(column_view const& booleans, auto d_column = *column; // copy null mask - rmm::device_buffer null_mask = cudf::detail::copy_bitmask(booleans, stream, mr); + cuda::device_buffer null_mask = cudf::detail::copy_bitmask(booleans, stream, mr); auto [offsets, chars] = make_strings_children(from_booleans_fn{d_column, d_true, d_false}, strings_count, stream, mr); diff --git a/cpp/src/strings/convert/convert_durations.cu b/cpp/src/strings/convert/convert_durations.cu index 5cea800f63c0..38c72aad7b0c 100644 --- a/cpp/src/strings/convert/convert_durations.cu +++ b/cpp/src/strings/convert/convert_durations.cu @@ -403,7 +403,7 @@ struct dispatch_from_durations_fn { auto d_column = *column; // copy null mask - rmm::device_buffer null_mask = cudf::detail::copy_bitmask(durations, stream, mr); + cuda::device_buffer null_mask = cudf::detail::copy_bitmask(durations, stream, mr); auto [offsets, chars] = make_strings_children(from_durations_fn{d_column, d_format_items, compiler.items_count()}, diff --git a/cpp/src/strings/convert/convert_floats.cu b/cpp/src/strings/convert/convert_floats.cu index cc8e19f94646..4d06a8f9456d 100644 --- a/cpp/src/strings/convert/convert_floats.cu +++ b/cpp/src/strings/convert/convert_floats.cu @@ -394,7 +394,7 @@ struct dispatch_from_floats_fn { auto d_column = *column; // copy the null mask - rmm::device_buffer null_mask = cudf::detail::copy_bitmask(floats, stream, mr); + cuda::device_buffer null_mask = cudf::detail::copy_bitmask(floats, stream, mr); auto [offsets, chars] = make_strings_children(from_floats_fn{d_column}, strings_count, stream, mr); diff --git a/cpp/src/strings/convert/convert_integers.cu b/cpp/src/strings/convert/convert_integers.cu index 2b9258ab9ea8..9e7bb608e2ed 100644 --- a/cpp/src/strings/convert/convert_integers.cu +++ b/cpp/src/strings/convert/convert_integers.cu @@ -354,7 +354,7 @@ struct dispatch_from_integers_fn { auto d_column = *column; // copy the null mask - rmm::device_buffer null_mask = cudf::detail::copy_bitmask(integers, stream, mr); + cuda::device_buffer null_mask = cudf::detail::copy_bitmask(integers, stream, mr); auto [offsets, chars] = make_strings_children(from_integers_fn{d_column}, strings_count, stream, mr); diff --git a/cpp/src/strings/convert/convert_lists.cu b/cpp/src/strings/convert/convert_lists.cu index 8beeb4d196f3..e97d17f44cb2 100644 --- a/cpp/src/strings/convert/convert_lists.cu +++ b/cpp/src/strings/convert/convert_lists.cu @@ -213,8 +213,11 @@ std::unique_ptr format_list_column(lists_column_view const& input, stream, mr); - return make_strings_column( - input.size(), std::move(offsets_column), chars.release(), 0, rmm::device_buffer{}); + return make_strings_column(input.size(), + std::move(offsets_column), + chars.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); } } // namespace detail diff --git a/cpp/src/strings/convert/convert_urls.cu b/cpp/src/strings/convert/convert_urls.cu index 8106be1918c3..e56832a1683b 100644 --- a/cpp/src/strings/convert/convert_urls.cu +++ b/cpp/src/strings/convert/convert_urls.cu @@ -409,7 +409,8 @@ std::unique_ptr url_decode(strings_column_view const& strings, CUDF_CUDA_TRY(cudaGetLastError()); // copy null mask - rmm::device_buffer null_mask = cudf::detail::copy_bitmask(strings.parent(), stream, mr); + cuda::device_buffer null_mask = + cudf::detail::copy_bitmask(strings.parent(), stream, mr); return make_strings_column(strings_count, std::move(offsets_column), diff --git a/cpp/src/strings/copying/concatenate.cu b/cpp/src/strings/copying/concatenate.cu index c340da0d5f83..09e339628e44 100644 --- a/cpp/src/strings/copying/concatenate.cu +++ b/cpp/src/strings/copying/concatenate.cu @@ -227,7 +227,7 @@ std::unique_ptr concatenate(host_span columns, auto itr_new_offsets = cudf::detail::offsetalator_factory::make_output_iterator(offsets_column->mutable_view()); - rmm::device_buffer null_mask{0, stream, mr}; + auto null_mask = cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED, stream, mr); size_type null_count{}; if (has_nulls) { null_mask = diff --git a/cpp/src/strings/copying/copy_range.cu b/cpp/src/strings/copying/copy_range.cu index 098865c45a98..d1f8db7870cb 100644 --- a/cpp/src/strings/copying/copy_range.cu +++ b/cpp/src/strings/copying/copy_range.cu @@ -66,7 +66,7 @@ std::unique_ptr copy_range(strings_column_view const& source, // create null mask auto [null_mask, null_count] = [&] { if (!target.parent().nullable() && !source.parent().nullable()) { - return std::pair(rmm::device_buffer{}, 0); + return std::pair(cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), 0); } return cudf::detail::valid_if( cuda::counting_iterator{0}, diff --git a/cpp/src/strings/copying/copying.cu b/cpp/src/strings/copying/copying.cu index b58528ae4f75..ea0cc16aa1c9 100644 --- a/cpp/src/strings/copying/copying.cu +++ b/cpp/src/strings/copying/copying.cu @@ -68,7 +68,7 @@ std::unique_ptr copy_slice(strings_column_view const& input, input.null_mask(), offsets_offset, offsets_offset + strings_count, stream, mr); auto null_count = cudf::detail::null_count( - static_cast(null_mask.data()), 0, strings_count, stream); + reinterpret_cast(null_mask.data()), 0, strings_count, stream); return make_strings_column(strings_count, std::move(offsets_column), diff --git a/cpp/src/strings/copying/shift.cu b/cpp/src/strings/copying/shift.cu index b716b6924f13..3137c987801c 100644 --- a/cpp/src/strings/copying/shift.cu +++ b/cpp/src/strings/copying/shift.cu @@ -115,8 +115,11 @@ std::unique_ptr shift(strings_column_view const& input, shift_chars_fn{*d_input, d_fill_str, shift_offset}); // caller sets the null-mask - return make_strings_column( - input.size(), std::move(offsets_column), chars.release(), 0, rmm::device_buffer{}); + return make_strings_column(input.size(), + std::move(offsets_column), + chars.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); } } // namespace cudf::strings::detail diff --git a/cpp/src/strings/replace/replace.cu b/cpp/src/strings/replace/replace.cu index b866c5faed6e..975f93fb7c95 100644 --- a/cpp/src/strings/replace/replace.cu +++ b/cpp/src/strings/replace/replace.cu @@ -463,7 +463,11 @@ std::unique_ptr replace_string_parallel(strings_column_view const& input stream, mr); - return make_strings_column(input.size(), std::move(offsets_column), chars.release(), 0, {}); + return make_strings_column(input.size(), + std::move(offsets_column), + chars.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); } } // namespace @@ -526,11 +530,11 @@ std::unique_ptr replace(strings_column_view const& input, auto const views = std::vector{input.parent(), targets.parent(), repls.parent()}; return cudf::detail::bitmask_and(table_view{views}, stream, mr); } else { - return std::pair{rmm::device_buffer{}, 0}; + return std::pair{cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), 0}; } }(); auto const d_valid_mask = - has_any_nulls ? static_cast(null_mask.data()) : nullptr; + has_any_nulls ? reinterpret_cast(null_mask.data()) : nullptr; auto d_targets = column_device_view::create(targets.parent(), stream); auto d_repls = column_device_view::create(repls.parent(), stream); diff --git a/cpp/src/strings/replace/replace_nulls.cu b/cpp/src/strings/replace/replace_nulls.cu index 02880822b0f4..9756ca2cf210 100644 --- a/cpp/src/strings/replace/replace_nulls.cu +++ b/cpp/src/strings/replace/replace_nulls.cu @@ -63,8 +63,11 @@ std::unique_ptr replace_nulls(strings_column_view const& input, memcpy(d_chars + d_offsets[idx], d_str.data(), d_str.size_bytes()); }); - return make_strings_column( - strings_count, std::move(offsets_column), chars.release(), 0, rmm::device_buffer{}); + return make_strings_column(strings_count, + std::move(offsets_column), + chars.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); } } // namespace detail diff --git a/cpp/src/strings/search/find.cu b/cpp/src/strings/search/find.cu index 4eaaa9d69798..03a9dae956f0 100644 --- a/cpp/src/strings/search/find.cu +++ b/cpp/src/strings/search/find.cu @@ -263,8 +263,12 @@ std::unique_ptr find(strings_column_view const& input, CUDF_EXPECTS(input.size() == target.size(), "input and target columns must be the same size"); // create output column - auto results = make_numeric_column( - data_type{type_to_id()}, input.size(), rmm::device_buffer{}, 0, stream, mr); + auto results = make_numeric_column(data_type{type_to_id()}, + input.size(), + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), + 0, + stream, + mr); // if input is empty or all-null then we are done if (input.size() == input.null_count()) { return results; } diff --git a/cpp/src/strings/search/find_multiple.cu b/cpp/src/strings/search/find_multiple.cu index f9e3580f0542..a45c5b5bdda9 100644 --- a/cpp/src/strings/search/find_multiple.cu +++ b/cpp/src/strings/search/find_multiple.cu @@ -50,8 +50,13 @@ std::unique_ptr find_multiple(strings_column_view const& input, auto const total_count = static_cast(total_elements); // create output column - auto results = make_numeric_column( - data_type{type_id::INT32}, total_count, rmm::device_buffer{0, stream, mr}, 0, stream, mr); + auto results = + make_numeric_column(data_type{type_id::INT32}, + total_count, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED, stream, mr), + 0, + stream, + mr); // fill output column with position values thrust::transform(rmm::exec_policy_nosync(stream, cudf::get_current_device_resource_ref()), @@ -73,8 +78,11 @@ std::unique_ptr find_multiple(strings_column_view const& input, numeric_scalar(targets_count, true, stream, cudf::get_current_device_resource_ref()), stream, mr); - return make_lists_column( - strings_count, std::move(offsets), std::move(results), 0, rmm::device_buffer{0, stream, mr}); + return make_lists_column(strings_count, + std::move(offsets), + std::move(results), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED, stream, mr)); } } // namespace detail diff --git a/cpp/src/strings/strings_column_factories.cu b/cpp/src/strings/strings_column_factories.cu index e8476aa9043c..3b5cf1b5aa33 100644 --- a/cpp/src/strings/strings_column_factories.cu +++ b/cpp/src/strings/strings_column_factories.cu @@ -84,7 +84,7 @@ std::vector> make_strings_column_batch( auto [offsets_cols, d_chars_sizes] = make_offsets_child_column_batch_async(input, stream, mr); - std::vector null_masks; + std::vector> null_masks; null_masks.reserve(num_columns); rmm::device_uvector d_valid_counts(num_columns, stream, mr); @@ -173,7 +173,8 @@ std::vector> make_strings_column_batch( std::move(offsets_cols[idx]), chars_data.release(), null_count, - null_count ? std::move(null_masks[idx]) : rmm::device_buffer{0, stream, mr}); + null_count ? std::move(null_masks[idx]) + : cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED, stream, mr)); } return output; @@ -231,7 +232,7 @@ std::unique_ptr make_strings_column(size_type num_strings, std::unique_ptr offsets_column, rmm::device_buffer&& chars_buffer, size_type null_count, - rmm::device_buffer&& null_mask) + cuda::device_buffer&& null_mask) { CUDF_FUNC_RANGE(); @@ -254,7 +255,7 @@ std::unique_ptr make_strings_column(size_type num_strings, std::unique_ptr make_strings_column(size_type num_strings, rmm::device_uvector&& offsets, rmm::device_uvector&& chars, - rmm::device_buffer&& null_mask, + cuda::device_buffer&& null_mask, size_type null_count) { CUDF_FUNC_RANGE(); @@ -271,7 +272,7 @@ std::unique_ptr make_strings_column(size_type num_strings, data_type{type_id::INT32}, offsets_size, offsets.release(), - rmm::device_buffer(), + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), 0); auto children = std::vector>(); diff --git a/cpp/src/strings/wrap.cu b/cpp/src/strings/wrap.cu index 96e8c659e1a1..83afa3159ed9 100644 --- a/cpp/src/strings/wrap.cu +++ b/cpp/src/strings/wrap.cu @@ -97,7 +97,8 @@ std::unique_ptr wrap(strings_column_view const& strings, size_type null_count = strings.null_count(); // copy null mask - rmm::device_buffer null_mask = cudf::detail::copy_bitmask(strings.parent(), stream, mr); + cuda::device_buffer null_mask = + cudf::detail::copy_bitmask(strings.parent(), stream, mr); // build offsets column auto offsets_column = std::make_unique(strings.offsets(), stream, mr); // makes a copy diff --git a/cpp/src/structs/copying/concatenate.cu b/cpp/src/structs/copying/concatenate.cu index 6a8371e84c58..e2802ee13bda 100644 --- a/cpp/src/structs/copying/concatenate.cu +++ b/cpp/src/structs/copying/concatenate.cu @@ -53,12 +53,12 @@ std::unique_ptr concatenate(host_span columns, // if any of the input columns have nulls, construct the output mask bool const has_nulls = std::any_of(columns.begin(), columns.end(), [](auto const& col) { return col.has_nulls(); }); - rmm::device_buffer null_mask = + cuda::device_buffer null_mask = create_null_mask(total_length, has_nulls ? mask_state::UNINITIALIZED : mask_state::UNALLOCATED, stream, cudf::get_current_device_resource_ref()); - auto null_mask_data = static_cast(null_mask.data()); + auto null_mask_data = reinterpret_cast(null_mask.data()); auto const null_count = has_nulls ? cudf::detail::concatenate_masks(columns, null_mask_data, stream) : size_type{0}; diff --git a/cpp/src/structs/scan/scan_inclusive.cu b/cpp/src/structs/scan/scan_inclusive.cu index 3e011ed66ff2..94eabf89b2ab 100644 --- a/cpp/src/structs/scan/scan_inclusive.cu +++ b/cpp/src/structs/scan/scan_inclusive.cu @@ -63,8 +63,12 @@ std::unique_ptr scan_inclusive(column_view const& input, ->release(); // Don't need to set a null mask because that will be handled at the caller. - return make_structs_column( - input.size(), std::move(scanned_children), 0, rmm::device_buffer{0, stream, mr}, stream, mr); + return make_structs_column(input.size(), + std::move(scanned_children), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED, stream, mr), + stream, + mr); } template std::unique_ptr scan_inclusive(column_view const& input_view, diff --git a/cpp/src/structs/structs_column_factories.cu b/cpp/src/structs/structs_column_factories.cu index b2d8ceb04bb8..628baf3997f7 100644 --- a/cpp/src/structs/structs_column_factories.cu +++ b/cpp/src/structs/structs_column_factories.cu @@ -19,11 +19,11 @@ std::unique_ptr make_structs_column( size_type num_rows, std::vector>&& child_columns, size_type null_count, - rmm::device_buffer&& null_mask, + cuda::device_buffer&& null_mask, cuda::stream_ref stream, rmm::device_async_resource_ref mr) { - CUDF_EXPECTS(null_count <= 0 || !null_mask.is_empty(), + CUDF_EXPECTS(null_count <= 0 || null_mask.size() > 0, "Struct column with nulls must be nullable."); CUDF_EXPECTS(std::all_of(child_columns.begin(), @@ -31,10 +31,10 @@ std::unique_ptr make_structs_column( [&](auto const& child_col) { return num_rows == child_col->size(); }), "Child columns must have the same number of rows as the Struct column."); - if (!null_mask.is_empty()) { + if (null_mask.size() > 0) { for (auto& child : child_columns) { child = structs::detail::superimpose_and_sanitize_nulls( - static_cast(null_mask.data()), + reinterpret_cast(null_mask.data()), null_count, std::move(child), stream, @@ -55,14 +55,14 @@ std::unique_ptr create_structs_hierarchy( size_type num_rows, std::vector>&& child_columns, size_type null_count, - rmm::device_buffer&& null_mask, + cuda::device_buffer&& null_mask, cuda::stream_ref stream, rmm::device_async_resource_ref mr) { - CUDF_EXPECTS(null_count <= 0 || !null_mask.is_empty(), + CUDF_EXPECTS(null_count <= 0 || null_mask.size() > 0, "Struct column with nulls must be nullable."); - CUDF_EXPECTS(null_mask.is_empty() || null_mask.size() == bitmask_allocation_size_bytes(num_rows), + CUDF_EXPECTS(null_mask.size() == 0 || null_mask.size() == bitmask_allocation_size_bytes(num_rows), "Number of bits in null_mask should equal number of rows in input columns"); CUDF_EXPECTS(std::all_of(child_columns.begin(), diff --git a/cpp/src/structs/utilities.cu b/cpp/src/structs/utilities.cu index b66a174778cd..e52376acf570 100644 --- a/cpp/src/structs/utilities.cu +++ b/cpp/src/structs/utilities.cu @@ -267,7 +267,7 @@ std::unique_ptr superimpose_nulls(bitmask_type const* null_mask, "Child columns must have the same number of rows as the Struct column."); for (auto& child : content.children) { - child = superimpose_nulls(static_cast(content.null_mask->data()), + child = superimpose_nulls(reinterpret_cast(content.null_mask->data()), new_null_count, std::move(child), stream, @@ -551,10 +551,10 @@ std::vector> enforce_null_consistency( // Helper struct to store and manipulate struct column properties struct contents { - size_type null_count = 0; // Number of null values in the struct - std::unique_ptr null_mask = nullptr; // Null mask buffer for the struct - size_type num_children = 0; // Number of child columns in this struct - size_type num_elements = 0; // Number of rows in the struct + size_type null_count = 0; // Number of null values + std::unique_ptr> null_mask = nullptr; // Null mask buffer + size_type num_children = 0; // Number of child columns + size_type num_elements = 0; // Number of rows }; std::vector struct_contents; // Store properties of each struct column @@ -576,7 +576,7 @@ std::vector> enforce_null_consistency( struct_root_masks.insert( struct_root_masks.end(), col_contents.children.size(), - static_cast(struct_contents.back().null_mask->data())); + reinterpret_cast(struct_contents.back().null_mask->data())); // Add all child columns from this struct for (auto& child : col_contents.children) { diff --git a/cpp/src/text/detokenize.cu b/cpp/src/text/detokenize.cu index 13082eeac197..4e7b0a48676f 100644 --- a/cpp/src/text/detokenize.cu +++ b/cpp/src/text/detokenize.cu @@ -154,8 +154,11 @@ std::unique_ptr detokenize(cudf::strings_column_view const& string mr); // make the output strings column from the offsets and chars column - return cudf::make_strings_column( - output_count, std::move(offsets_column), chars.release(), 0, rmm::device_buffer{}); + return cudf::make_strings_column(output_count, + std::move(offsets_column), + chars.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); } } // namespace detail diff --git a/cpp/src/text/edit_distance.cu b/cpp/src/text/edit_distance.cu index 12b5a5b1a1e4..28fbd88c4fb9 100644 --- a/cpp/src/text/edit_distance.cu +++ b/cpp/src/text/edit_distance.cu @@ -266,7 +266,12 @@ std::unique_ptr edit_distance(cudf::strings_column_view const& inp auto d_buffer = compute_buffer.data(); auto results = cudf::make_fixed_width_column( - output_type, input.size(), rmm::device_buffer{0, stream, mr}, 0, stream, mr); + output_type, + input.size(), + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED, stream, mr), + 0, + stream, + mr); auto d_results = results->mutable_view().data(); constexpr auto block_size = 256L; diff --git a/cpp/src/text/generate_ngrams.cu b/cpp/src/text/generate_ngrams.cu index 4569fde45e83..8d9b6b6b3443 100644 --- a/cpp/src/text/generate_ngrams.cu +++ b/cpp/src/text/generate_ngrams.cu @@ -141,8 +141,11 @@ std::unique_ptr generate_ngrams(cudf::strings_column_view const& s ngram_generator_fn{d_strings, ngrams, d_separator}, ngrams_count, stream, mr); // make the output strings column from the offsets and chars column - return cudf::make_strings_column( - ngrams_count, std::move(offsets_column), chars.release(), 0, rmm::device_buffer{}); + return cudf::make_strings_column(ngrams_count, + std::move(offsets_column), + chars.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); } } // namespace detail @@ -287,11 +290,17 @@ std::unique_ptr generate_character_ngrams(cudf::strings_column_vie auto [offsets_column, chars] = cudf::strings::detail::make_strings_children(generator, input.size(), total_ngrams, stream, mr); - auto output = cudf::make_strings_column( - total_ngrams, std::move(offsets_column), chars.release(), 0, rmm::device_buffer{}); - - return make_lists_column( - input.size(), std::move(offsets), std::move(output), 0, rmm::device_buffer{}); + auto output = cudf::make_strings_column(total_ngrams, + std::move(offsets_column), + chars.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); + + return make_lists_column(input.size(), + std::move(offsets), + std::move(output), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); } namespace { @@ -393,8 +402,11 @@ std::unique_ptr hash_character_ngrams(cudf::strings_column_view co *d_strings, ngrams, seed, d_offsets, d_hashes); CUDF_CUDA_TRY(cudaGetLastError()); - return make_lists_column( - input.size(), std::move(offsets), std::move(hashes), 0, rmm::device_buffer{}); + return make_lists_column(input.size(), + std::move(offsets), + std::move(hashes), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); } } // namespace detail diff --git a/cpp/src/text/minhash.cu b/cpp/src/text/minhash.cu index 388e2ecd94e4..e4393f9c42fc 100644 --- a/cpp/src/text/minhash.cu +++ b/cpp/src/text/minhash.cu @@ -614,7 +614,8 @@ std::unique_ptr build_list_result(cudf::column_view const& input, auto const size = cudf::numeric_scalar( seeds_size, true, stream, cudf::get_current_device_resource_ref()); auto offsets = cudf::detail::sequence(input.size() + 1, zero, size, stream, mr); - hashes->set_null_mask(rmm::device_buffer{}, 0); // children have no nulls + hashes->set_null_mask(cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), + 0); // children have no nulls // build the lists column from the offsets and the hashes auto result = make_lists_column(input.size(), diff --git a/cpp/src/text/ngrams_tokenize.cu b/cpp/src/text/ngrams_tokenize.cu index f50cb675966f..af091d12cb93 100644 --- a/cpp/src/text/ngrams_tokenize.cu +++ b/cpp/src/text/ngrams_tokenize.cu @@ -224,8 +224,11 @@ std::unique_ptr ngrams_tokenize(cudf::strings_column_view const& s auto offsets_column = std::get<0>(cudf::strings::detail::make_offsets_child_column( ngram_sizes.begin(), ngram_sizes.end(), stream, mr)); // create the output strings column - return make_strings_column( - total_ngrams, std::move(offsets_column), chars.release(), 0, rmm::device_buffer{}); + return make_strings_column(total_ngrams, + std::move(offsets_column), + chars.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); } } // namespace detail diff --git a/cpp/src/text/tokenize.cu b/cpp/src/text/tokenize.cu index a87a51b17aa6..111d62012555 100644 --- a/cpp/src/text/tokenize.cu +++ b/cpp/src/text/tokenize.cu @@ -219,8 +219,12 @@ std::unique_ptr character_tokenize(cudf::strings_column_view const d_chars + chars_bytes, output_chars.data()); - auto output_strings = cudf::make_strings_column( - num_characters, std::move(offsets_column), output_chars.release(), 0, rmm::device_buffer{}); + auto output_strings = + cudf::make_strings_column(num_characters, + std::move(offsets_column), + output_chars.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); return cudf::make_lists_column(strings_count, std::move(list_offsets), std::move(output_strings), diff --git a/cpp/src/text/vocabulary_tokenize.cu b/cpp/src/text/vocabulary_tokenize.cu index 88d8b3ab766d..c06af479d456 100644 --- a/cpp/src/text/vocabulary_tokenize.cu +++ b/cpp/src/text/vocabulary_tokenize.cu @@ -432,8 +432,8 @@ std::unique_ptr tokenize_with_vocabulary(cudf::strings_column_view }, stream); - auto tmp_offsets = - std::make_unique(std::move(d_tmp_offsets), rmm::device_buffer{}, 0); + auto tmp_offsets = std::make_unique( + std::move(d_tmp_offsets), cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), 0); auto const tmp_input = cudf::column_view( input.parent().type(), total_count, d_input_chars, nullptr, 0, 0, {tmp_offsets->view()}); diff --git a/cpp/src/transform/bools_to_mask.cu b/cpp/src/transform/bools_to_mask.cu index 6b35591a415a..ee61586443e6 100644 --- a/cpp/src/transform/bools_to_mask.cu +++ b/cpp/src/transform/bools_to_mask.cu @@ -20,12 +20,16 @@ namespace cudf { namespace detail { -std::pair, cudf::size_type> bools_to_mask( +std::pair>, cudf::size_type> bools_to_mask( column_view const& input, cuda::stream_ref stream, rmm::device_async_resource_ref mr) { CUDF_EXPECTS(input.type().id() == type_id::BOOL8, "Input is not of type bool"); - if (input.is_empty()) { return std::pair(std::make_unique(), 0); } + if (input.is_empty()) { + return std::pair(std::make_unique>( + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)), + 0); + } auto input_device_view_ptr = column_device_view::create(input, stream); auto input_device_view = *input_device_view_ptr; @@ -36,18 +40,20 @@ std::pair, cudf::size_type> bools_to_mask( auto mask = detail::valid_if(input_begin, input_begin + input.size(), pred, stream, mr); - return std::pair(std::make_unique(std::move(mask.first)), mask.second); + return std::pair(std::make_unique>(std::move(mask.first)), + mask.second); } else { auto mask = detail::valid_if( input_device_view.begin(), input_device_view.end(), pred, stream, mr); - return std::pair(std::make_unique(std::move(mask.first)), mask.second); + return std::pair(std::make_unique>(std::move(mask.first)), + mask.second); } } } // namespace detail -std::pair, cudf::size_type> bools_to_mask( +std::pair>, cudf::size_type> bools_to_mask( column_view const& input, cuda::stream_ref stream, rmm::device_async_resource_ref mr) { CUDF_FUNC_RANGE(); diff --git a/cpp/src/transform/nans_to_nulls.cu b/cpp/src/transform/nans_to_nulls.cu index 4da8521e7e24..f4c4e75895fe 100644 --- a/cpp/src/transform/nans_to_nulls.cu +++ b/cpp/src/transform/nans_to_nulls.cu @@ -24,7 +24,7 @@ namespace cudf { namespace detail { struct dispatch_nan_to_null { template - std::pair, cudf::size_type> operator()( + std::pair>, cudf::size_type> operator()( column_view const& input, cuda::stream_ref stream, rmm::device_async_resource_ref mr) requires(std::is_floating_point_v) { @@ -42,11 +42,12 @@ struct dispatch_nan_to_null { stream, mr); - return std::pair(std::make_unique(std::move(mask.first)), mask.second); + return std::pair(std::make_unique>(std::move(mask.first)), + mask.second); } template - std::pair, cudf::size_type> operator()( + std::pair>, cudf::size_type> operator()( column_view const& input, cuda::stream_ref stream, rmm::device_async_resource_ref mr) requires(!std::is_floating_point_v) { @@ -54,13 +55,17 @@ struct dispatch_nan_to_null { } }; -std::pair, cudf::size_type> nans_to_nulls( +std::pair>, cudf::size_type> nans_to_nulls( column_view const& input, cuda::stream_ref stream, rmm::device_async_resource_ref mr) { CUDF_EXPECTS(cudf::is_floating_point(input.type()), "Input must be a floating point type", std::invalid_argument); - if (input.is_empty()) { return std::pair(std::make_unique(), 0); } + if (input.is_empty()) { + return std::pair(std::make_unique>( + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)), + 0); + } return cudf::type_dispatcher(input.type(), dispatch_nan_to_null{}, input, stream, mr); } @@ -107,7 +112,7 @@ std::unique_ptr column_nans_to_nulls(column_view const& input, } } // namespace detail -std::pair, cudf::size_type> nans_to_nulls( +std::pair>, cudf::size_type> nans_to_nulls( column_view const& input, cuda::stream_ref stream, rmm::device_async_resource_ref mr) { CUDF_FUNC_RANGE(); diff --git a/cpp/src/transform/transform.cu b/cpp/src/transform/transform.cu index 0cdfdf74bd02..7092e6f6d6b1 100644 --- a/cpp/src/transform/transform.cu +++ b/cpp/src/transform/transform.cu @@ -59,7 +59,7 @@ struct fixed_width_column { static auto make(data_type type, size_type size, - rmm::device_buffer null_mask, + cuda::device_buffer null_mask, size_type null_count, cuda::stream_ref stream, rmm::device_async_resource_ref mr) @@ -97,11 +97,12 @@ struct mutable_string_views_column_view { struct string_views_column { rmm::device_buffer _data; size_type _size{0}; - rmm::device_buffer _null_mask{}; + cuda::device_buffer _null_mask = + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED); size_type _null_count{0}; static auto make(size_type size, - rmm::device_buffer null_mask, + cuda::device_buffer null_mask, size_type null_count, cuda::stream_ref stream, rmm::device_async_resource_ref mr) @@ -115,16 +116,16 @@ struct string_views_column { return mutable_string_views_column_view{ const_cast(_data.data()), _size, - static_cast(const_cast(_null_mask.data())), + reinterpret_cast(_null_mask.data()), 0, _null_count}; } void set_null_count(size_type count) { _null_count = count; } - bool nullable() const { return !_null_mask.is_empty(); } + bool nullable() const { return _null_mask.size() != 0; } - bitmask_type* null_mask() { return static_cast(_null_mask.data()); } + bitmask_type* null_mask() { return reinterpret_cast(_null_mask.data()); } }; struct mutable_strings_column_view { @@ -142,7 +143,7 @@ struct mutable_strings_column { static auto make(size_type size, rmm::device_buffer chars, std::unique_ptr offsets, - rmm::device_buffer null_mask, + cuda::device_buffer null_mask, size_type null_count) { return mutable_strings_column{make_strings_column( @@ -994,7 +995,7 @@ rmm::device_uvector make_chars_buffer(column_view const& offsets_view, } std::unique_ptr make_strings_column(device_span strings, - rmm::device_buffer null_mask, + cuda::device_buffer null_mask, size_type null_count, cuda::stream_ref stream, rmm::device_async_resource_ref mr) @@ -1003,7 +1004,7 @@ std::unique_ptr make_strings_column(device_span strin auto size = static_cast(strings.size()); if (size == 0) return make_empty_column(type_id::STRING); - auto stencil = static_cast(null_mask.data()); + auto stencil = reinterpret_cast(null_mask.data()); // build offsets column from the strings sizes auto sizes = detail::make_counting_transform_iterator( diff --git a/cpp/src/unary/cast_ops.cu b/cpp/src/unary/cast_ops.cu index b11f2d77069a..f4939f4007e0 100644 --- a/cpp/src/unary/cast_ops.cu +++ b/cpp/src/unary/cast_ops.cu @@ -284,8 +284,11 @@ struct dispatch_unary_cast_to { using DeviceT = device_storage_type_t; auto const size = input.size(); - auto output = std::make_unique( - type, size, rmm::device_buffer{size * sizeof(DeviceT), stream, mr}, rmm::device_buffer{}, 0); + auto output = std::make_unique(type, + size, + rmm::device_buffer{size * sizeof(DeviceT), stream, mr}, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), + 0); mutable_column_view output_mutable = *output; diff --git a/cpp/src/unary/math_ops.cu b/cpp/src/unary/math_ops.cu index e294e9b00715..11b07e9abaab 100644 --- a/cpp/src/unary/math_ops.cu +++ b/cpp/src/unary/math_ops.cu @@ -334,7 +334,7 @@ std::unique_ptr unary_op_with(column_view const& input, template std::unique_ptr transform_fn(InputIterator begin, InputIterator end, - rmm::device_buffer&& null_mask, + cuda::device_buffer&& null_mask, size_type null_count, cuda::stream_ref stream, rmm::device_async_resource_ref mr) @@ -344,7 +344,7 @@ std::unique_ptr transform_fn(InputIterator begin, std::unique_ptr output = make_fixed_width_column(data_type{type_to_id()}, size, - std::forward(null_mask), + std::forward>(null_mask), null_count, stream, mr); diff --git a/cpp/tests/bitmask/bitmask_tests.cpp b/cpp/tests/bitmask/bitmask_tests.cpp index f3fa9ef0100c..29eff39d992c 100644 --- a/cpp/tests/bitmask/bitmask_tests.cpp +++ b/cpp/tests/bitmask/bitmask_tests.cpp @@ -387,9 +387,9 @@ struct CopyBitmaskTest : public cudf::test::BaseFixture, cudf::test::UniformRand CopyBitmaskTest() : cudf::test::UniformRandomGenerator{0, 1} {} }; -void cleanEndWord(rmm::device_buffer& mask, int begin_bit, int end_bit) +void cleanEndWord(cuda::device_buffer& mask, int begin_bit, int end_bit) { - auto ptr = static_cast(mask.data()); + auto ptr = reinterpret_cast(mask.data()); auto number_of_mask_words = cudf::num_bitmask_words(static_cast(end_bit - begin_bit)); auto number_of_bits = end_bit - begin_bit; @@ -443,7 +443,7 @@ TEST_F(CopyBitmaskTest, TestZeroOffset) validity_bit.begin() + begin_bit, validity_bit.begin() + end_bit)); auto splice_mask = cudf::copy_bitmask( - static_cast(input_mask.data()), begin_bit, end_bit); + reinterpret_cast(input_mask.data()), begin_bit, end_bit); cleanEndWord(splice_mask, begin_bit, end_bit); auto number_of_bits = end_bit - begin_bit; @@ -466,7 +466,7 @@ TEST_F(CopyBitmaskTest, TestNonZeroOffset) validity_bit.begin() + begin_bit, validity_bit.begin() + end_bit)); auto splice_mask = cudf::copy_bitmask( - static_cast(input_mask.data()), begin_bit, end_bit); + reinterpret_cast(input_mask.data()), begin_bit, end_bit); cleanEndWord(splice_mask, begin_bit, end_bit); auto number_of_bits = end_bit - begin_bit; @@ -485,7 +485,8 @@ TEST_F(CopyBitmaskTest, TestCopyColumnViewVectorContiguous) auto [gold_mask, null_count] = cudf::test::detail::make_null_mask(validity_bit.begin(), validity_bit.end()); - rmm::device_buffer copy_mask{gold_mask, cudf::get_default_stream()}; + auto copy_mask = cudf::copy_bitmask( + reinterpret_cast(gold_mask.data()), 0, num_elements); cudf::column original{t, num_elements, rmm::device_buffer{num_elements * sizeof(int), cudf::get_default_stream()}, @@ -509,8 +510,8 @@ TEST_F(CopyBitmaskTest, TestCopyColumnViewVectorContiguous) 760, 760, num_elements}; - std::vector views = cudf::slice(original, indices); - rmm::device_buffer concatenated_bitmask = cudf::concatenate_masks(views); + std::vector views = cudf::slice(original, indices); + cuda::device_buffer concatenated_bitmask = cudf::concatenate_masks(views); cleanEndWord(concatenated_bitmask, 0, num_elements); CUDF_TEST_EXPECT_EQUAL_BUFFERS( concatenated_bitmask.data(), gold_mask.data(), cudf::num_bitmask_words(num_elements)); @@ -541,7 +542,7 @@ TEST_F(CopyBitmaskTest, TestCopyColumnViewVectorDiscontiguous) null_count); views.push_back(cols.back()); } - rmm::device_buffer concatenated_bitmask = cudf::concatenate_masks(views); + cuda::device_buffer concatenated_bitmask = cudf::concatenate_masks(views); cleanEndWord(concatenated_bitmask, 0, num_elements); CUDF_TEST_EXPECT_EQUAL_BUFFERS( concatenated_bitmask.data(), gold_mask.data(), cudf::num_bitmask_words(num_elements)); diff --git a/cpp/tests/bitmask/set_nullmask_tests.cu b/cpp/tests/bitmask/set_nullmask_tests.cu index c51b44418ce4..052e08c85f36 100644 --- a/cpp/tests/bitmask/set_nullmask_tests.cu +++ b/cpp/tests/bitmask/set_nullmask_tests.cu @@ -55,10 +55,10 @@ struct SetBitmaskTest : public cudf::test::BaseFixture { { thrust::host_vector expected(end - begin, valid); // TEST - rmm::device_buffer mask = create_null_mask(size, cudf::mask_state::UNINITIALIZED); + cuda::device_buffer mask = create_null_mask(size, cudf::mask_state::UNINITIALIZED); // valid ? cudf::mask_state::ALL_NULL : cudf::mask_state::ALL_VALID); - cudf::set_null_mask(static_cast(mask.data()), begin, end, valid); - expect_bitmask_equal(static_cast(mask.data()), begin, expected); + cudf::set_null_mask(reinterpret_cast(mask.data()), begin, end, valid); + expect_bitmask_equal(reinterpret_cast(mask.data()), begin, expected); } void test_null_partition(cudf::size_type size, cudf::size_type middle, bool valid) @@ -69,10 +69,10 @@ struct SetBitmaskTest : public cudf::test::BaseFixture { return (!valid) ^ (i < middle); }); // TEST - rmm::device_buffer mask = create_null_mask(size, cudf::mask_state::UNINITIALIZED); - cudf::set_null_mask(static_cast(mask.data()), 0, middle, valid); - cudf::set_null_mask(static_cast(mask.data()), middle, size, !valid); - expect_bitmask_equal(static_cast(mask.data()), 0, expected); + cuda::device_buffer mask = create_null_mask(size, cudf::mask_state::UNINITIALIZED); + cudf::set_null_mask(reinterpret_cast(mask.data()), 0, middle, valid); + cudf::set_null_mask(reinterpret_cast(mask.data()), middle, size, !valid); + expect_bitmask_equal(reinterpret_cast(mask.data()), 0, expected); } void test_null_partition_bulk_unsafe(cudf::size_type size, cudf::size_type middle, bool valid) @@ -86,11 +86,11 @@ struct SetBitmaskTest : public cudf::test::BaseFixture { expected2[i] = (valid) ^ (i < middle); }); // TEST - rmm::device_buffer mask1 = create_null_mask(size, cudf::mask_state::UNINITIALIZED); - rmm::device_buffer mask2 = create_null_mask(size, cudf::mask_state::UNINITIALIZED); + cuda::device_buffer mask1 = create_null_mask(size, cudf::mask_state::UNINITIALIZED); + cuda::device_buffer mask2 = create_null_mask(size, cudf::mask_state::UNINITIALIZED); - std::vector masks{static_cast(mask1.data()), - static_cast(mask2.data())}; + std::vector masks{reinterpret_cast(mask1.data()), + reinterpret_cast(mask2.data())}; // Set first halves of bitmasks std::vector begins{0, 0}; @@ -109,8 +109,8 @@ struct SetBitmaskTest : public cudf::test::BaseFixture { masks, begins, ends, cudf::host_span{valids.data(), valids.size()}); // Verify bitmasks - expect_bitmask_equal(static_cast(mask1.data()), 0, expected1); - expect_bitmask_equal(static_cast(mask2.data()), 0, expected2); + expect_bitmask_equal(reinterpret_cast(mask1.data()), 0, expected1); + expect_bitmask_equal(reinterpret_cast(mask2.data()), 0, expected2); } void test_null_partition_bulk_safe(cudf::size_type size, cudf::size_type middle, bool valid) @@ -121,19 +121,19 @@ struct SetBitmaskTest : public cudf::test::BaseFixture { return (!valid) ^ (i < middle); }); - rmm::device_buffer mask = create_null_mask(size, cudf::mask_state::UNINITIALIZED); + cuda::device_buffer mask = create_null_mask(size, cudf::mask_state::UNINITIALIZED); std::vector begins{0, middle}; std::vector ends{middle, size}; - std::vector masks{static_cast(mask.data()), - static_cast(mask.data())}; + std::vector masks{reinterpret_cast(mask.data()), + reinterpret_cast(mask.data())}; auto valids = cudf::detail::make_host_vector(masks.size(), cudf::get_default_stream()); valids[0] = valid; valids[1] = !valid; cudf::set_null_masks_safe(masks, begins, ends, valids); // Verify bitmasks - expect_bitmask_equal(static_cast(mask.data()), 0, expected); + expect_bitmask_equal(reinterpret_cast(mask.data()), 0, expected); } }; diff --git a/cpp/tests/column/column_test.cpp b/cpp/tests/column/column_test.cpp index d7aade39aef4..31a6636d33f4 100644 --- a/cpp/tests/column/column_test.cpp +++ b/cpp/tests/column/column_test.cpp @@ -37,7 +37,7 @@ struct TypedColumnTest : public cudf::test::BaseFixture { TypedColumnTest(cuda::stream_ref stream = cudf::get_default_stream()) : data{_num_elements * sizeof(T), stream}, - mask{cudf::bitmask_allocation_size_bytes(_num_elements), stream} + mask{cudf::create_null_mask(_num_elements, cudf::mask_state::UNINITIALIZED, stream)} { std::vector h_data(std::max(data.size(), mask.size())); std::iota(h_data.begin(), h_data.end(), 0); @@ -54,9 +54,11 @@ struct TypedColumnTest : public cudf::test::BaseFixture { std::uniform_int_distribution distribution{200, 1000}; cudf::size_type _num_elements{distribution(generator)}; rmm::device_buffer data{}; - rmm::device_buffer mask{}; - rmm::device_buffer all_valid_mask{create_null_mask(num_elements(), cudf::mask_state::ALL_VALID)}; - rmm::device_buffer all_null_mask{create_null_mask(num_elements(), cudf::mask_state::ALL_NULL)}; + cuda::device_buffer mask = cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED); + cuda::device_buffer all_valid_mask = + create_null_mask(num_elements(), cudf::mask_state::ALL_VALID); + cuda::device_buffer all_null_mask = + create_null_mask(num_elements(), cudf::mask_state::ALL_NULL); }; TYPED_TEST_SUITE(TypedColumnTest, cudf::test::Types); @@ -87,8 +89,11 @@ void verify_column_views(cudf::column col) TYPED_TEST(TypedColumnTest, DefaultNullCountNoMask) { - cudf::column col{ - this->type(), this->num_elements(), std::move(this->data), rmm::device_buffer{}, 0}; + cudf::column col{this->type(), + this->num_elements(), + std::move(this->data), + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), + 0}; EXPECT_FALSE(col.nullable()); EXPECT_FALSE(col.has_nulls()); EXPECT_EQ(0, col.null_count()); @@ -96,8 +101,11 @@ TYPED_TEST(TypedColumnTest, DefaultNullCountNoMask) TYPED_TEST(TypedColumnTest, DefaultNullCountEmptyMask) { - cudf::column col{ - this->type(), this->num_elements(), std::move(this->data), rmm::device_buffer{}, 0}; + cudf::column col{this->type(), + this->num_elements(), + std::move(this->data), + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), + 0}; EXPECT_FALSE(col.nullable()); EXPECT_FALSE(col.has_nulls()); EXPECT_EQ(0, col.null_count()); @@ -147,24 +155,33 @@ TYPED_TEST(TypedColumnTest, ExplicitNullCountAllNull) TYPED_TEST(TypedColumnTest, SetNullCountNoMask) { - cudf::column col{ - this->type(), this->num_elements(), std::move(this->data), rmm::device_buffer{}, 0}; + cudf::column col{this->type(), + this->num_elements(), + std::move(this->data), + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), + 0}; EXPECT_THROW(col.set_null_count(1), cudf::logic_error); } TYPED_TEST(TypedColumnTest, SetEmptyNullMaskNonZeroNullCount) { - cudf::column col{ - this->type(), this->num_elements(), std::move(this->data), rmm::device_buffer{}, 0}; - rmm::device_buffer empty_null_mask{}; + cudf::column col{this->type(), + this->num_elements(), + std::move(this->data), + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), + 0}; + auto empty_null_mask = cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED); EXPECT_THROW(col.set_null_mask(std::move(empty_null_mask), this->num_elements()), cudf::logic_error); } TYPED_TEST(TypedColumnTest, SetInvalidSizeNullMaskNonZeroNullCount) { - cudf::column col{ - this->type(), this->num_elements(), std::move(this->data), rmm::device_buffer{}, 0}; + cudf::column col{this->type(), + this->num_elements(), + std::move(this->data), + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), + 0}; auto invalid_size_null_mask = create_null_mask(std::min(this->num_elements() - 50, 0), cudf::mask_state::ALL_VALID); EXPECT_THROW( @@ -174,8 +191,11 @@ TYPED_TEST(TypedColumnTest, SetInvalidSizeNullMaskNonZeroNullCount) TYPED_TEST(TypedColumnTest, SetNullCountEmptyMask) { - cudf::column col{ - this->type(), this->num_elements(), std::move(this->data), rmm::device_buffer{}, 0}; + cudf::column col{this->type(), + this->num_elements(), + std::move(this->data), + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), + 0}; EXPECT_THROW(col.set_null_count(1), cudf::logic_error); } @@ -218,8 +238,11 @@ TYPED_TEST(TypedColumnTest, ResetNullCountAllValid) TYPED_TEST(TypedColumnTest, CopyDataNoMask) { - cudf::column col{ - this->type(), this->num_elements(), std::move(this->data), rmm::device_buffer{}, 0}; + cudf::column col{this->type(), + this->num_elements(), + std::move(this->data), + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), + 0}; EXPECT_EQ(this->type(), col.type()); EXPECT_FALSE(col.nullable()); EXPECT_EQ(0, col.null_count()); @@ -237,8 +260,11 @@ TYPED_TEST(TypedColumnTest, CopyDataNoMask) TYPED_TEST(TypedColumnTest, MoveDataNoMask) { void* original_data = this->data.data(); - cudf::column col{ - this->type(), this->num_elements(), std::move(this->data), rmm::device_buffer{}, 0}; + cudf::column col{this->type(), + this->num_elements(), + std::move(this->data), + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), + 0}; EXPECT_EQ(this->type(), col.type()); EXPECT_FALSE(col.nullable()); EXPECT_EQ(0, col.null_count()); @@ -254,11 +280,14 @@ TYPED_TEST(TypedColumnTest, MoveDataNoMask) TYPED_TEST(TypedColumnTest, CopyDataAndMask) { - cudf::column col{this->type(), - this->num_elements(), - rmm::device_buffer{this->data, cudf::get_default_stream()}, - rmm::device_buffer{this->all_valid_mask, cudf::get_default_stream()}, - 0}; + cudf::column col{ + this->type(), + this->num_elements(), + rmm::device_buffer{this->data, cudf::get_default_stream()}, + cudf::copy_bitmask(reinterpret_cast(this->all_valid_mask.data()), + 0, + this->num_elements()), + 0}; EXPECT_EQ(this->type(), col.type()); EXPECT_TRUE(col.nullable()); EXPECT_EQ(0, col.null_count()); @@ -270,7 +299,8 @@ TYPED_TEST(TypedColumnTest, CopyDataAndMask) // Verify deep copy cudf::column_view v = col; EXPECT_NE(v.head(), this->data.data()); - EXPECT_NE(v.null_mask(), this->all_valid_mask.data()); + EXPECT_NE(v.null_mask(), + reinterpret_cast(this->all_valid_mask.data())); CUDF_TEST_EXPECT_EQUAL_BUFFERS(v.head(), this->data.data(), this->data.size()); CUDF_TEST_EXPECT_EQUAL_BUFFERS(v.null_mask(), this->all_valid_mask.data(), this->mask.size()); } @@ -297,8 +327,11 @@ TYPED_TEST(TypedColumnTest, MoveDataAndMask) TYPED_TEST(TypedColumnTest, CopyConstructorNoMask) { - cudf::column original{ - this->type(), this->num_elements(), std::move(this->data), rmm::device_buffer{}, 0}; + cudf::column original{this->type(), + this->num_elements(), + std::move(this->data), + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), + 0}; cudf::column copy{original}; verify_column_views(copy); CUDF_TEST_EXPECT_COLUMNS_EQUAL(original, copy); @@ -326,8 +359,11 @@ TYPED_TEST(TypedColumnTest, CopyConstructorWithMask) TYPED_TEST(TypedColumnTest, MoveConstructorNoMask) { - cudf::column original{ - this->type(), this->num_elements(), std::move(this->data), rmm::device_buffer{}, 0}; + cudf::column original{this->type(), + this->num_elements(), + std::move(this->data), + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), + 0}; auto original_data = original.view().head(); @@ -369,7 +405,8 @@ TYPED_TEST(TypedColumnTest, DeviceUvectorConstructorNoMask) auto original = cudf::detail::make_device_uvector_async( data, cudf::get_default_stream(), cudf::get_current_device_resource_ref()); auto original_data = original.data(); - cudf::column moved_to{std::move(original), rmm::device_buffer{}, 0}; + cudf::column moved_to{ + std::move(original), cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), 0}; verify_column_views(moved_to); // Verify move @@ -385,7 +422,7 @@ TYPED_TEST(TypedColumnTest, DeviceUvectorConstructorWithMask) auto original = cudf::detail::make_device_uvector_async( data, cudf::get_default_stream(), cudf::get_current_device_resource_ref()); auto original_data = original.data(); - auto original_mask = this->all_valid_mask.data(); + auto original_mask = reinterpret_cast(this->all_valid_mask.data()); cudf::column moved_to{std::move(original), std::move(this->all_valid_mask), 0}; verify_column_views(moved_to); @@ -403,20 +440,27 @@ TYPED_TEST(TypedColumnTest, ConstructWithChildren) cudf::data_type{cudf::type_id::INT8}, 42, rmm::device_buffer{this->data, cudf::get_default_stream()}, - rmm::device_buffer{this->all_valid_mask, cudf::get_default_stream()}, + cudf::copy_bitmask(reinterpret_cast(this->all_valid_mask.data()), + 0, + this->num_elements()), 0)); children.emplace_back(std::make_unique( cudf::data_type{cudf::type_id::FLOAT64}, 314, rmm::device_buffer{this->data, cudf::get_default_stream()}, - rmm::device_buffer{this->all_valid_mask, cudf::get_default_stream()}, + cudf::copy_bitmask(reinterpret_cast(this->all_valid_mask.data()), + 0, + this->num_elements()), 0)); - cudf::column col{this->type(), - this->num_elements(), - rmm::device_buffer{this->data, cudf::get_default_stream()}, - rmm::device_buffer{this->all_valid_mask, cudf::get_default_stream()}, - 0, - std::move(children)}; + cudf::column col{ + this->type(), + this->num_elements(), + rmm::device_buffer{this->data, cudf::get_default_stream()}, + cudf::copy_bitmask(reinterpret_cast(this->all_valid_mask.data()), + 0, + this->num_elements()), + 0, + std::move(children)}; verify_column_views(col); EXPECT_EQ(2, col.num_children()); @@ -435,7 +479,7 @@ TYPED_TEST(TypedColumnTest, ReleaseNoChildren) cudf::column::contents contents = col.release(); EXPECT_EQ(original_data, contents.data->data()); - EXPECT_EQ(original_mask, contents.null_mask->data()); + EXPECT_EQ(original_mask, reinterpret_cast(contents.null_mask->data())); EXPECT_EQ(0u, contents.children.size()); EXPECT_EQ(0, col.size()); EXPECT_EQ(0, col.null_count()); @@ -450,27 +494,34 @@ TYPED_TEST(TypedColumnTest, ReleaseWithChildren) this->type(), this->num_elements(), rmm::device_buffer{this->data, cudf::get_default_stream()}, - rmm::device_buffer{this->all_valid_mask, cudf::get_default_stream()}, + cudf::copy_bitmask(reinterpret_cast(this->all_valid_mask.data()), + 0, + this->num_elements()), 0)); children.emplace_back(std::make_unique( this->type(), this->num_elements(), rmm::device_buffer{this->data, cudf::get_default_stream()}, - rmm::device_buffer{this->all_valid_mask, cudf::get_default_stream()}, + cudf::copy_bitmask(reinterpret_cast(this->all_valid_mask.data()), + 0, + this->num_elements()), 0)); - cudf::column col{this->type(), - this->num_elements(), - rmm::device_buffer{this->data, cudf::get_default_stream()}, - rmm::device_buffer{this->all_valid_mask, cudf::get_default_stream()}, - 0, - std::move(children)}; + cudf::column col{ + this->type(), + this->num_elements(), + rmm::device_buffer{this->data, cudf::get_default_stream()}, + cudf::copy_bitmask(reinterpret_cast(this->all_valid_mask.data()), + 0, + this->num_elements()), + 0, + std::move(children)}; auto original_data = col.view().head(); auto original_mask = col.view().null_mask(); cudf::column::contents contents = col.release(); EXPECT_EQ(original_data, contents.data->data()); - EXPECT_EQ(original_mask, contents.null_mask->data()); + EXPECT_EQ(original_mask, reinterpret_cast(contents.null_mask->data())); EXPECT_EQ(2u, contents.children.size()); EXPECT_EQ(0, col.size()); EXPECT_EQ(0, col.null_count()); @@ -651,8 +702,7 @@ TEST_F(RebindStreamColumnTest, RebindStreamPreservesNestedStructData) auto d_ints = cudf::detail::make_device_uvector_async( h_ints, stream_a, cudf::get_current_device_resource_ref()); - auto null_mask = cudf::create_null_mask( - num_rows, cudf::mask_state::ALL_VALID, stream_a, cudf::get_current_device_resource_ref()); + auto null_mask = cudf::create_null_mask(num_rows, cudf::mask_state::ALL_VALID, stream_a); stream_a.synchronize(); diff --git a/cpp/tests/column/compound_test.cu b/cpp/tests/column/compound_test.cu index 032c1ebd6b3f..1c307603fbf4 100644 --- a/cpp/tests/column/compound_test.cu +++ b/cpp/tests/column/compound_test.cu @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: Copyright (c) 2019-2026, NVIDIA CORPORATION. + * SPDX-FileCopyrightText: Copyright (c) 2019-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. * SPDX-License-Identifier: Apache-2.0 */ @@ -88,12 +88,13 @@ TEST_F(CompoundColumnTest, ChildrenLevel1) children.emplace_back(std::move(child2)); children.emplace_back(std::move(child3)); - auto parent = std::make_unique(cudf::data_type{cudf::type_id::STRING}, - 100, - rmm::device_buffer{}, - rmm::device_buffer{}, - 0, - std::move(children)); + auto parent = + std::make_unique(cudf::data_type{cudf::type_id::STRING}, + 100, + rmm::device_buffer{}, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), + 0, + std::move(children)); { auto column = cudf::column_device_view::create(parent->view()); @@ -170,28 +171,31 @@ TEST_F(CompoundColumnTest, ChildrenLevel2) gchildren2.emplace_back(std::move(gchild22)); gchildren2.emplace_back(std::move(gchild23)); - auto children1 = std::make_unique(cudf::data_type{cudf::type_id::STRING}, - 100, - rmm::device_buffer{}, - rmm::device_buffer{}, - 0, - std::move(gchildren1)); - auto children2 = std::make_unique(cudf::data_type{cudf::type_id::STRING}, - 100, - rmm::device_buffer{}, - rmm::device_buffer{}, - 0, - std::move(gchildren2)); + auto children1 = + std::make_unique(cudf::data_type{cudf::type_id::STRING}, + 100, + rmm::device_buffer{}, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), + 0, + std::move(gchildren1)); + auto children2 = + std::make_unique(cudf::data_type{cudf::type_id::STRING}, + 100, + rmm::device_buffer{}, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), + 0, + std::move(gchildren2)); std::vector> children; children.emplace_back(std::move(children1)); children.emplace_back(std::move(children2)); - auto parent = std::make_unique(cudf::data_type{cudf::type_id::STRING}, - 100, - rmm::device_buffer{}, - rmm::device_buffer{}, - 0, - std::move(children)); + auto parent = + std::make_unique(cudf::data_type{cudf::type_id::STRING}, + 100, + rmm::device_buffer{}, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), + 0, + std::move(children)); { auto column = cudf::column_device_view::create(parent->view()); diff --git a/cpp/tests/column/factories_test.cpp b/cpp/tests/column/factories_test.cpp index 3e5384a38bb4..4e8940abc2a6 100644 --- a/cpp/tests/column/factories_test.cpp +++ b/cpp/tests/column/factories_test.cpp @@ -116,8 +116,8 @@ TYPED_TEST(NumericFactoryTest, AllNullMask) TYPED_TEST(NumericFactoryTest, NullMaskAsParm) { - rmm::device_buffer null_mask{create_null_mask(this->size(), cudf::mask_state::ALL_NULL)}; - auto column = cudf::make_numeric_column(cudf::data_type{cudf::type_to_id()}, + auto null_mask = create_null_mask(this->size(), cudf::mask_state::ALL_NULL); + auto column = cudf::make_numeric_column(cudf::data_type{cudf::type_to_id()}, this->size(), std::move(null_mask), this->size()); @@ -131,8 +131,10 @@ TYPED_TEST(NumericFactoryTest, NullMaskAsParm) TYPED_TEST(NumericFactoryTest, NullMaskAsEmptyParm) { - auto column = cudf::make_numeric_column( - cudf::data_type{cudf::type_to_id()}, this->size(), rmm::device_buffer{}, 0); + auto column = cudf::make_numeric_column(cudf::data_type{cudf::type_to_id()}, + this->size(), + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), + 0); EXPECT_EQ(column->type(), cudf::data_type{cudf::type_to_id()}); EXPECT_EQ(column->size(), this->size()); EXPECT_EQ(0, column->null_count()); @@ -259,8 +261,8 @@ TYPED_TEST(FixedWidthFactoryTest, AllNullMask) TYPED_TEST(FixedWidthFactoryTest, NullMaskAsParm) { - rmm::device_buffer null_mask{create_null_mask(this->size(), cudf::mask_state::ALL_NULL)}; - auto column = cudf::make_fixed_width_column(cudf::data_type{cudf::type_to_id()}, + auto null_mask = create_null_mask(this->size(), cudf::mask_state::ALL_NULL); + auto column = cudf::make_fixed_width_column(cudf::data_type{cudf::type_to_id()}, this->size(), std::move(null_mask), this->size()); @@ -274,8 +276,11 @@ TYPED_TEST(FixedWidthFactoryTest, NullMaskAsParm) TYPED_TEST(FixedWidthFactoryTest, NullMaskAsEmptyParm) { - auto column = cudf::make_fixed_width_column( - cudf::data_type{cudf::type_to_id()}, this->size(), rmm::device_buffer{}, 0); + auto column = + cudf::make_fixed_width_column(cudf::data_type{cudf::type_to_id()}, + this->size(), + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), + 0); EXPECT_EQ(column->type(), cudf::data_type{cudf::type_to_id()}); EXPECT_EQ(column->size(), this->size()); EXPECT_EQ(0, column->null_count()); @@ -456,7 +461,7 @@ TYPED_TEST(ListsDictionaryLeafTest, FromNested) DCW leaf({1, 3, -1, 1, 3, 1, 3, -1, 1, 3}, {1, 1, 0, 1, 1, 1, 1, 0, 1, 1}); offset_t offsets{0, 3, 3, 6, 6, 10}; auto mask = cudf::create_null_mask(5, cudf::mask_state::ALL_VALID); - cudf::set_null_mask(static_cast(mask.data()), 1, 2, false); + cudf::set_null_mask(reinterpret_cast(mask.data()), 1, 2, false); auto data = cudf::make_lists_column(5, offsets.release(), leaf.release(), 0, std::move(mask)); auto s = cudf::make_list_scalar(*data); @@ -468,9 +473,9 @@ TYPED_TEST(ListsDictionaryLeafTest, FromNested) {1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1}); offset_t offsets2{0, 3, 3, 6, 6, 10, 13, 13, 16, 16, 20, 23, 23, 26, 26, 30}; auto mask2 = cudf::create_null_mask(15, cudf::mask_state::ALL_VALID); - cudf::set_null_mask(static_cast(mask2.data()), 1, 2, false); - cudf::set_null_mask(static_cast(mask2.data()), 6, 7, false); - cudf::set_null_mask(static_cast(mask2.data()), 11, 12, false); + cudf::set_null_mask(reinterpret_cast(mask2.data()), 1, 2, false); + cudf::set_null_mask(reinterpret_cast(mask2.data()), 6, 7, false); + cudf::set_null_mask(reinterpret_cast(mask2.data()), 11, 12, false); auto nested = [&] { auto tmp = cudf::make_lists_column(15, offsets2.release(), leaf2.release(), 3, std::move(mask2)); @@ -586,7 +591,7 @@ TYPED_TEST(ListsStructsLeafTest, FromNested) LCWinner_t({LCWinner_t{}, LCWinner_t{42}}, valid_t{1, 1}.begin()), valid_t{0, 1}.begin()); auto mask = cudf::create_null_mask(3, cudf::mask_state::ALL_VALID); - cudf::set_null_mask(static_cast(mask.data()), 0, 1, false); + cudf::set_null_mask(reinterpret_cast(mask.data()), 0, 1, false); auto data = cudf::make_lists_column(3, offset_t{0, 0, 1, 2}.release(), leaf.release(), 1, std::move(mask)); auto s = cudf::make_list_scalar(*data); @@ -602,9 +607,9 @@ TYPED_TEST(ListsStructsLeafTest, FromNested) valid_t{1, 1, 1, 1, 1, 1}.begin()), valid_t{0, 1, 0, 1, 0, 1}.begin()); auto mask2 = cudf::create_null_mask(9, cudf::mask_state::ALL_VALID); - cudf::set_null_mask(static_cast(mask2.data()), 0, 1, false); - cudf::set_null_mask(static_cast(mask2.data()), 3, 4, false); - cudf::set_null_mask(static_cast(mask2.data()), 6, 7, false); + cudf::set_null_mask(reinterpret_cast(mask2.data()), 0, 1, false); + cudf::set_null_mask(reinterpret_cast(mask2.data()), 3, 4, false); + cudf::set_null_mask(reinterpret_cast(mask2.data()), 6, 7, false); auto data2 = [&] { auto tmp = cudf::make_lists_column( 9, offset_t{0, 0, 1, 2, 2, 3, 4, 4, 5, 6}.release(), leaf2.release(), 3, std::move(mask2)); diff --git a/cpp/tests/copying/concatenate_tests.cpp b/cpp/tests/copying/concatenate_tests.cpp index e4cd60821187..023b5358e748 100644 --- a/cpp/tests/copying/concatenate_tests.cpp +++ b/cpp/tests/copying/concatenate_tests.cpp @@ -48,10 +48,10 @@ struct TypedColumnTest : public cudf::test::BaseFixture { TypedColumnTest(cuda::stream_ref stream = cudf::get_default_stream()) : data{_num_elements * sizeof(T), stream}, - mask{cudf::bitmask_allocation_size_bytes(_num_elements), stream} + mask{cudf::create_null_mask(_num_elements, cudf::mask_state::UNINITIALIZED, stream)} { auto typed_data = static_cast(data.data()); - auto typed_mask = static_cast(mask.data()); + auto typed_mask = mask.data(); std::vector h_data(data.size()); std::iota(h_data.begin(), h_data.end(), char{0}); std::vector h_mask(mask.size()); @@ -60,7 +60,8 @@ struct TypedColumnTest : public cudf::test::BaseFixture { cudaMemcpyAsync(typed_data, h_data.data(), data.size(), cudaMemcpyDefault, stream.get())); CUDF_CUDA_TRY( cudaMemcpyAsync(typed_mask, h_mask.data(), mask.size(), cudaMemcpyDefault, stream.get())); - _null_count = cudf::null_count(static_cast(mask.data()), 0, _num_elements); + _null_count = + cudf::null_count(reinterpret_cast(mask.data()), 0, _num_elements); stream.sync(); } @@ -72,10 +73,12 @@ struct TypedColumnTest : public cudf::test::BaseFixture { std::uniform_int_distribution distribution{200, 1000}; cudf::size_type _num_elements{distribution(generator)}; rmm::device_buffer data{}; - rmm::device_buffer mask{}; + cuda::device_buffer mask = cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED); cudf::size_type _null_count{}; - rmm::device_buffer all_valid_mask{create_null_mask(num_elements(), cudf::mask_state::ALL_VALID)}; - rmm::device_buffer all_null_mask{create_null_mask(num_elements(), cudf::mask_state::ALL_NULL)}; + cuda::device_buffer all_valid_mask = + create_null_mask(num_elements(), cudf::mask_state::ALL_VALID); + cuda::device_buffer all_null_mask = + create_null_mask(num_elements(), cudf::mask_state::ALL_NULL); }; TYPED_TEST_SUITE(TypedColumnTest, cudf::test::Types); @@ -384,8 +387,11 @@ TEST_F(OverflowTest, OverflowTest) // try and concatenate 6 string columns of with 1 billion chars in each auto offsets = cudf::test::fixed_width_column_wrapper{0, size}; auto many_chars = rmm::device_uvector(size, cudf::get_default_stream()); - auto col = cudf::make_strings_column( - 1, offsets.release(), many_chars.release(), 0, rmm::device_buffer{}); + auto col = cudf::make_strings_column(1, + offsets.release(), + many_chars.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); cudf::table_view tbl({*col}); EXPECT_THROW(cudf::concatenate(std::vector({tbl, tbl, tbl, tbl, tbl, tbl})), @@ -400,8 +406,11 @@ TEST_F(OverflowTest, OverflowTest) auto many_offsets = cudf::make_fixed_width_column(cudf::data_type{cudf::type_id::INT32}, size + 1); auto chars = rmm::device_uvector(3, cudf::get_default_stream()); - auto col = cudf::make_strings_column( - size, std::move(many_offsets), chars.release(), 0, rmm::device_buffer{}); + auto col = cudf::make_strings_column(size, + std::move(many_offsets), + chars.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); cudf::table_view tbl({*col}); EXPECT_THROW(cudf::concatenate(std::vector({tbl, tbl, tbl, tbl, tbl, tbl})), @@ -419,13 +428,16 @@ TEST_F(OverflowTest, OverflowTest) cudf::make_fixed_width_column(cudf::data_type{cudf::type_id::INT8}, inner_size)); children.push_back( cudf::make_fixed_width_column(cudf::data_type{cudf::type_id::INT8}, inner_size)); - auto struct_col = - cudf::make_structs_column(inner_size, std::move(children), 0, rmm::device_buffer{}); + auto struct_col = cudf::make_structs_column( + inner_size, std::move(children), 0, cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); // list auto offsets = cudf::test::fixed_width_column_wrapper{0, inner_size}; - auto col = - cudf::make_lists_column(1, offsets.release(), std::move(struct_col), 0, rmm::device_buffer{}); + auto col = cudf::make_lists_column(1, + offsets.release(), + std::move(struct_col), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); cudf::table_view tbl({*col}); auto tables = @@ -444,13 +456,18 @@ TEST_F(OverflowTest, OverflowTest) auto many_chars = cudf::make_fixed_width_column(cudf::data_type{cudf::type_id::INT8}, inner_size); auto list_col = - cudf::make_lists_column(3, offsets.release(), std::move(many_chars), 0, rmm::device_buffer{}); + cudf::make_lists_column(3, + offsets.release(), + std::move(many_chars), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); // struct std::vector> children; children.push_back(cudf::make_fixed_width_column(cudf::data_type{cudf::type_id::INT32}, size)); children.push_back(std::move(list_col)); - auto col = cudf::make_structs_column(size, std::move(children), 0, rmm::device_buffer{}); + auto col = cudf::make_structs_column( + size, std::move(children), 0, cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); cudf::table_view tbl({*col}); auto tables = @@ -486,7 +503,8 @@ TEST_F(OverflowTest, Presliced) // try and concatenate 4 char columns of size ~1/2 billion each std::vector> children; children.push_back(cudf::make_fixed_width_column(cudf::data_type{cudf::type_id::INT8}, size)); - auto struct_col = cudf::make_structs_column(size, std::move(children), 0, rmm::device_buffer{}); + auto struct_col = cudf::make_structs_column( + size, std::move(children), 0, cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); auto sliced = cudf::split(*struct_col, {511 * 1024 * 1024}); @@ -511,8 +529,11 @@ TEST_F(OverflowTest, Presliced) 0, [](cudf::size_type index) { return index * string_size; }); cudf::test::fixed_width_column_wrapper offsets(offset_gen, offset_gen + num_rows + 1); auto many_chars = rmm::device_uvector(total_chars_size, cudf::get_default_stream()); - auto col = cudf::make_strings_column( - num_rows, offsets.release(), many_chars.release(), 0, rmm::device_buffer{}); + auto col = cudf::make_strings_column(num_rows, + offsets.release(), + many_chars.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); auto sliced = cudf::split(*col, {(num_rows / 2) - 1}); @@ -537,8 +558,11 @@ TEST_F(OverflowTest, Presliced) cudf::numeric_scalar(0), cudf::numeric_scalar(string_size)); auto many_chars = rmm::device_uvector(total_chars_size, cudf::get_default_stream()); - auto col = cudf::make_strings_column( - num_rows, std::move(offsets), many_chars.release(), 0, rmm::device_buffer{}); + auto col = cudf::make_strings_column(num_rows, + std::move(offsets), + many_chars.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); // should pass (with 2 rows to spare) // leaving this disabled as it typically runs out of memory on a T4 @@ -575,15 +599,18 @@ TEST_F(OverflowTest, Presliced) cudf::make_fixed_width_column(cudf::data_type{cudf::type_id::INT8}, inner_size)); children.push_back( cudf::make_fixed_width_column(cudf::data_type{cudf::type_id::INT8}, inner_size)); - auto struct_col = - cudf::make_structs_column(inner_size, std::move(children), 0, rmm::device_buffer{}); + auto struct_col = cudf::make_structs_column( + inner_size, std::move(children), 0, cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); // list constexpr cudf::size_type list_size = inner_size / 4; auto offsets = cudf::test::fixed_width_column_wrapper{ 0, list_size, list_size * 2, list_size * 3, inner_size}; - auto col = - cudf::make_lists_column(4, offsets.release(), std::move(struct_col), 0, rmm::device_buffer{}); + auto col = cudf::make_lists_column(4, + offsets.release(), + std::move(struct_col), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); auto sliced = cudf::split(*col, {2}); cudf::table_view tbl({sliced[1]}); @@ -603,16 +630,19 @@ TEST_F(OverflowTest, Presliced) cudf::make_fixed_width_column(cudf::data_type{cudf::type_id::INT8}, inner_size)); children.push_back( cudf::make_fixed_width_column(cudf::data_type{cudf::type_id::INT8}, inner_size)); - auto struct_col = - cudf::make_structs_column(inner_size, std::move(children), 0, rmm::device_buffer{}); + auto struct_col = cudf::make_structs_column( + inner_size, std::move(children), 0, cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); // try and concatenate 4 struct columns of with ~1/2 billion elements in each auto offsets = cudf::sequence(num_rows + 1, cudf::numeric_scalar(0), cudf::numeric_scalar(list_size)); - auto col = cudf::make_lists_column( - num_rows, std::move(offsets), std::move(struct_col), 0, rmm::device_buffer{}); + auto col = cudf::make_lists_column(num_rows, + std::move(offsets), + std::move(struct_col), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); // should pass (with 2 rows to spare) // leaving this disabled as it typically runs out of memory on a T4 @@ -650,16 +680,20 @@ TEST_F(OverflowTest, Presliced) 0, list_size, (list_size * 2) - 1, list_size * 3, inner_size}; auto many_chars = cudf::make_fixed_width_column(cudf::data_type{cudf::type_id::INT8}, inner_size); - auto list_col = cudf::make_lists_column( - num_rows, offsets.release(), std::move(many_chars), 0, rmm::device_buffer{}); + auto list_col = + cudf::make_lists_column(num_rows, + offsets.release(), + std::move(many_chars), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); // struct std::vector> children; children.push_back( cudf::make_fixed_width_column(cudf::data_type{cudf::type_id::INT8}, num_rows)); children.push_back(std::move(list_col)); - auto struct_col = - cudf::make_structs_column(num_rows, std::move(children), 0, rmm::device_buffer{}); + auto struct_col = cudf::make_structs_column( + num_rows, std::move(children), 0, cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); auto sliced = cudf::split(*struct_col, {2}); @@ -701,8 +735,11 @@ TEST_F(OverflowTest, BigColumnsSmallSlices) cudf::numeric_scalar(0), cudf::numeric_scalar(string_size)); auto many_chars = rmm::device_uvector(inner_size, cudf::get_default_stream()); - auto col = cudf::make_strings_column( - num_rows, std::move(offsets), many_chars.release(), 0, rmm::device_buffer{}); + auto col = cudf::make_strings_column(num_rows, + std::move(offsets), + many_chars.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); auto sliced = cudf::slice(*col, {16, 32}); @@ -724,8 +761,11 @@ TEST_F(OverflowTest, BigColumnsSmallSlices) cudf::numeric_scalar(list_size)); auto many_chars = cudf::make_fixed_width_column(cudf::data_type{cudf::type_id::INT8}, inner_size); - auto col = cudf::make_lists_column( - num_rows, std::move(offsets), std::move(many_chars), 0, rmm::device_buffer{}); + auto col = cudf::make_lists_column(num_rows, + std::move(offsets), + std::move(many_chars), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); auto sliced = cudf::slice(*col, {16, 32}); @@ -747,16 +787,20 @@ TEST_F(OverflowTest, BigColumnsSmallSlices) cudf::numeric_scalar(list_size)); auto many_chars = cudf::make_fixed_width_column(cudf::data_type{cudf::type_id::INT8}, inner_size); - auto list_col = cudf::make_lists_column( - num_rows, std::move(offsets), std::move(many_chars), 0, rmm::device_buffer{}); + auto list_col = + cudf::make_lists_column(num_rows, + std::move(offsets), + std::move(many_chars), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); // struct std::vector> children; children.push_back( cudf::make_fixed_width_column(cudf::data_type{cudf::type_id::INT8}, num_rows)); children.push_back(std::move(list_col)); - auto struct_col = - cudf::make_structs_column(num_rows, std::move(children), 0, rmm::device_buffer{}); + auto struct_col = cudf::make_structs_column( + num_rows, std::move(children), 0, cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); auto sliced = cudf::slice(*struct_col, {16, 32}); @@ -836,11 +880,16 @@ TEST_F(StructsColumnTest, ConcatenateStructs) TEST_F(StructsColumnTest, ConcatenateEmptyStructs) { - auto expected = cudf::make_structs_column(10, {}, 0, rmm::device_buffer()); - auto first = cudf::make_structs_column(5, {}, 0, rmm::device_buffer()); - auto second = cudf::make_structs_column(2, {}, 0, rmm::device_buffer()); - auto third = cudf::make_structs_column(0, {}, 0, rmm::device_buffer()); - auto fourth = cudf::make_structs_column(3, {}, 0, rmm::device_buffer()); + auto expected = + cudf::make_structs_column(10, {}, 0, cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); + auto first = + cudf::make_structs_column(5, {}, 0, cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); + auto second = + cudf::make_structs_column(2, {}, 0, cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); + auto third = + cudf::make_structs_column(0, {}, 0, cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); + auto fourth = + cudf::make_structs_column(3, {}, 0, cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); // concatenate auto result = cudf::concatenate(std::vector({*first, *second, *third, *fourth})); @@ -905,7 +954,8 @@ TEST_F(StructsColumnTest, ConcatenateSplitStructs) expected_children.push_back(cudf::concatenate(expected_names)); expected_children.push_back(cudf::concatenate(expected_ages)); expected_children.push_back(cudf::concatenate(expected_is_human)); - auto expected = make_structs_column(7, std::move(expected_children), 0, rmm::device_buffer{}); + auto expected = make_structs_column( + 7, std::move(expected_children), 0, cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); // concatenate as structs std::vector src; @@ -981,7 +1031,8 @@ TEST_F(StructsColumnTest, ConcatenateStructsNested) cudf::concatenate(std::vector({inner_structs[0], inner_structs[1]}))); expected_children.push_back( cudf::concatenate(std::vector({inner_lists[0], inner_lists[1]}))); - auto expected = make_structs_column(11, std::move(expected_children), 0, rmm::device_buffer{}); + auto expected = make_structs_column( + 11, std::move(expected_children), 0, cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); // concatenate as structs std::vector src; @@ -1534,8 +1585,11 @@ TEST_F(ListsColumnTest, ListOfStructs) {inner_structs[0], inner_structs[1], inner_structs[2], inner_structs[3]}); auto expected_child = cudf::concatenate(struct_views); cudf::test::fixed_width_column_wrapper offsets_w{0, 1, 1, 1, 1, 4, 6, 6, 6, 10, 11}; - auto expected = - make_lists_column(10, offsets_w.release(), std::move(expected_child), 0, rmm::device_buffer{}); + auto expected = make_lists_column(10, + offsets_w.release(), + std::move(expected_child), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); // lists std::vector> offsets; @@ -1548,8 +1602,11 @@ TEST_F(ListsColumnTest, ListOfStructs) std::vector> src; for (size_t idx = 0; idx < inner_structs.size(); idx++) { int size = static_cast(offsets[idx]).size() - 1; - src.push_back(make_lists_column( - size, offsets[idx].release(), inner_structs[idx].release(), 0, rmm::device_buffer{})); + src.push_back(make_lists_column(size, + offsets[idx].release(), + inner_structs[idx].release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED))); } // concatenate @@ -1756,7 +1813,7 @@ TEST_F(EmptyColumnTest, SimpleTest) columns.emplace_back(cudf::data_type(cudf::type_id::EMPTY), num_rows, rmm::device_buffer{}, - rmm::device_buffer{}, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), 0); } @@ -1782,11 +1839,12 @@ TEST_F(TableOfEmptyColumnsTest, SimpleTest) for (auto i = 0; i < num_copies; ++i) { std::vector> columns; for (auto j = 0; j < num_columns; ++j) { - columns.push_back(std::make_unique(cudf::data_type(cudf::type_id::EMPTY), - num_rows, - rmm::device_buffer{}, - rmm::device_buffer{}, - 0)); + columns.push_back( + std::make_unique(cudf::data_type(cudf::type_id::EMPTY), + num_rows, + rmm::device_buffer{}, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), + 0)); } tables.emplace_back(std::move(columns)); } diff --git a/cpp/tests/copying/gather_struct_tests.cpp b/cpp/tests/copying/gather_struct_tests.cpp index e3b0dd9bee07..d82a04a735c7 100644 --- a/cpp/tests/copying/gather_struct_tests.cpp +++ b/cpp/tests/copying/gather_struct_tests.cpp @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: Copyright (c) 2020-2024, NVIDIA CORPORATION. + * SPDX-FileCopyrightText: Copyright (c) 2020-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. * SPDX-License-Identifier: Apache-2.0 */ @@ -370,9 +370,13 @@ TYPED_TEST(TypedStructGatherTest, TestGatherStructOfListOfStructs) auto const struct_of_list_of_structs = [&] { auto numeric_column = numerics{{5, 10, 15, 20, 25, 30, 35, 45, 50, 55, 60, 65, 70, 75}}; - auto structs_column = structs{{numeric_column}}.release(); - auto list_of_structs_column = cudf::make_lists_column( - 7, offsets{0, 2, 4, 6, 8, 10, 12, 14}.release(), std::move(structs_column), 0, {}); + auto structs_column = structs{{numeric_column}}.release(); + auto list_of_structs_column = + cudf::make_lists_column(7, + offsets{0, 2, 4, 6, 8, 10, 12, 14}.release(), + std::move(structs_column), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); std::vector> vector_of_columns; vector_of_columns.push_back(std::move(list_of_structs_column)); @@ -388,8 +392,12 @@ TYPED_TEST(TypedStructGatherTest, TestGatherStructOfListOfStructs) auto expected_gather_result = [&] { auto expected_numeric_col = numerics{{70, 75, 50, 55, 35, 45, 25, 30, 15, 20}}; auto expected_struct_col = structs{{expected_numeric_col}}.release(); - auto expected_list_of_structs_column = cudf::make_lists_column( - 5, offsets{0, 2, 4, 6, 8, 10}.release(), std::move(expected_struct_col), 0, {}); + auto expected_list_of_structs_column = + cudf::make_lists_column(5, + offsets{0, 2, 4, 6, 8, 10}.release(), + std::move(expected_struct_col), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); std::vector> expected_vector_of_columns; expected_vector_of_columns.push_back(std::move(expected_list_of_structs_column)); return structs{std::move(expected_vector_of_columns), {false, true, true, true, true}}; diff --git a/cpp/tests/copying/get_value_tests.cpp b/cpp/tests/copying/get_value_tests.cpp index f2e9107ca452..b5bf0c539784 100644 --- a/cpp/tests/copying/get_value_tests.cpp +++ b/cpp/tests/copying/get_value_tests.cpp @@ -315,7 +315,11 @@ TYPED_TEST(ListGetFixedWidthValueTest, NestedGetNull) auto typed_s = static_cast(s.get()); auto expected_data = - cudf::make_lists_column(0, offset_t{}.release(), FCW{}.release(), 0, rmm::device_buffer{}); + cudf::make_lists_column(0, + offset_t{}.release(), + FCW{}.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); EXPECT_FALSE(s->is_valid()); // Test preserve column hierarchy @@ -468,7 +472,11 @@ TEST_F(ListGetStringValueTest, NestedGetNull) auto typed_s = static_cast(s.get()); auto expected_data = - cudf::make_lists_column(0, offset_t{}.release(), StringCW{}.release(), 0, rmm::device_buffer{}); + cudf::make_lists_column(0, + offset_t{}.release(), + StringCW{}.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); EXPECT_FALSE(s->is_valid()); CUDF_TEST_EXPECT_COLUMNS_EQUIVALENT(*expected_data, typed_s->view()); @@ -499,14 +507,15 @@ struct ListGetStructValueTest : public cudf::test::BaseFixture { auto d_null_mask = cudf::create_null_mask( num_lists, null_count == 0 ? cudf::mask_state::UNALLOCATED : cudf::mask_state::ALL_NULL); if (null_count > 0) { - std::for_each(cuda::counting_iterator{0}, - cuda::counting_iterator{num_lists}, - [&](auto i) { - if (*(null_mask.begin() + i)) { - cudf::set_null_mask( - static_cast(d_null_mask.data()), i, i + 1, true); - } - }); + std::for_each( + cuda::counting_iterator{0}, + cuda::counting_iterator{num_lists}, + [&](auto i) { + if (*(null_mask.begin() + i)) { + cudf::set_null_mask( + reinterpret_cast(d_null_mask.data()), i, i + 1, true); + } + }); } return cudf::make_lists_column( num_lists, offsets.release(), std::move(child), null_count, std::move(d_null_mask)); @@ -767,7 +776,11 @@ TYPED_TEST(ListGetStructValueTest, NestedGetNull) auto nested = this->make_test_structs_column({}, {}, {}, valid_t{}.begin()); auto expected_data = - cudf::make_lists_column(0, offset_t{}.release(), nested.release(), 0, rmm::device_buffer{}); + cudf::make_lists_column(0, + offset_t{}.release(), + nested.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); EXPECT_FALSE(s->is_valid()); CUDF_TEST_EXPECT_COLUMNS_EQUIVALENT(*expected_data, typed_s->view()); diff --git a/cpp/tests/copying/pack_tests.cpp b/cpp/tests/copying/pack_tests.cpp index 9f701ac1245d..d2d483080603 100644 --- a/cpp/tests/copying/pack_tests.cpp +++ b/cpp/tests/copying/pack_tests.cpp @@ -445,8 +445,11 @@ TEST_F(PackUnpackTest, NestedEmpty) { auto empty_string = cudf::make_empty_column(cudf::data_type{cudf::type_id::STRING}); auto offsets = cudf::test::fixed_width_column_wrapper({0, 0}); - auto list = cudf::make_lists_column( - 1, offsets.release(), std::move(empty_string), 0, rmm::device_buffer{}); + auto list = cudf::make_lists_column(1, + offsets.release(), + std::move(empty_string), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); cudf::table_view src_table({static_cast(*list)}); this->run_test(src_table); @@ -458,8 +461,11 @@ TEST_F(PackUnpackTest, NestedEmpty) cudf::test::strings_column_wrapper str{"abc"}; auto empty_string = cudf::empty_like(str); auto offsets = cudf::test::fixed_width_column_wrapper({0, 0}); - auto list = cudf::make_lists_column( - 1, offsets.release(), std::move(empty_string), 0, rmm::device_buffer{}); + auto list = cudf::make_lists_column(1, + offsets.release(), + std::move(empty_string), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); cudf::table_view src_table({static_cast(*list)}); this->run_test(src_table); @@ -471,8 +477,11 @@ TEST_F(PackUnpackTest, NestedEmpty) cudf::test::lists_column_wrapper listw{{1.0f, 2.0f}, {3.0f, 4.0f}}; auto empty_list = cudf::empty_like(listw); auto offsets = cudf::test::fixed_width_column_wrapper({0, 0}); - auto list = - cudf::make_lists_column(1, offsets.release(), std::move(empty_list), 0, rmm::device_buffer{}); + auto list = cudf::make_lists_column(1, + offsets.release(), + std::move(empty_list), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); cudf::table_view src_table({static_cast(*list)}); this->run_test(src_table); @@ -484,8 +493,11 @@ TEST_F(PackUnpackTest, NestedEmpty) cudf::test::lists_column_wrapper listw{{1.0f, 2.0f}, {3.0f, 4.0f}}; auto empty_list = cudf::empty_like(listw); auto offsets = cudf::test::fixed_width_column_wrapper({0, 0}); - auto list = - cudf::make_lists_column(1, offsets.release(), std::move(empty_list), 0, rmm::device_buffer{}); + auto list = cudf::make_lists_column(1, + offsets.release(), + std::move(empty_list), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); cudf::table_view src_table({static_cast(*list)}); this->run_test(src_table); @@ -499,8 +511,11 @@ TEST_F(PackUnpackTest, NestedEmpty) auto struct_column = cudf::test::structs_column_wrapper({ints, floats}); auto empty_struct = cudf::empty_like(struct_column); auto offsets = cudf::test::fixed_width_column_wrapper({0, 0}); - auto list = cudf::make_lists_column( - 1, offsets.release(), std::move(empty_struct), 0, rmm::device_buffer{}); + auto list = cudf::make_lists_column(1, + offsets.release(), + std::move(empty_struct), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); cudf::table_view src_table({static_cast(*list)}); this->run_test(src_table); @@ -531,8 +546,10 @@ TEST_F(PackUnpackTest, NestedSliced) children.push_back(std::make_unique(col2)); children.push_back(std::make_unique(col0)); children.push_back(std::make_unique(col1)); - auto col3 = cudf::make_structs_column( - static_cast(col0).size(), std::move(children), 0, rmm::device_buffer{}); + auto col3 = cudf::make_structs_column(static_cast(col0).size(), + std::move(children), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); cudf::table_view t({col0, col1, col2, *col3}); this->run_test(t); diff --git a/cpp/tests/copying/scatter_list_scalar_tests.cpp b/cpp/tests/copying/scatter_list_scalar_tests.cpp index b0b56f084a65..5b235d81f9b9 100644 --- a/cpp/tests/copying/scatter_list_scalar_tests.cpp +++ b/cpp/tests/copying/scatter_list_scalar_tests.cpp @@ -311,8 +311,11 @@ TYPED_TEST(ScatterListOfStructScalarTest, Basic) mask_vector{1, 0, 1, 1, 0, 1}.begin()), {1, 1, 0, 0, 1, 1}); offset_t offsets{0, 2, 2, 3, 6}; - auto col = - cudf::make_lists_column(4, offsets.release(), child.release(), 0, rmm::device_buffer{}); + auto col = cudf::make_lists_column(4, + offsets.release(), + child.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); size_column scatter_map{1, 3}; @@ -324,8 +327,11 @@ TYPED_TEST(ScatterListOfStructScalarTest, Basic) mask_vector{1, 0, 1, 0, 1, 1, 1, 0, 1}.begin()), {1, 1, 1, 1, 0, 0, 1, 1, 0}); offset_t ex_offsets{0, 2, 5, 6, 9}; - auto expected = - cudf::make_lists_column(4, ex_offsets.release(), ex_child.release(), 0, rmm::device_buffer{}); + auto expected = cudf::make_lists_column(4, + ex_offsets.release(), + ex_child.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); auto result = single_scalar_scatter(*col, *slr, scatter_map); CUDF_TEST_EXPECT_COLUMNS_EQUIVALENT(*result, *expected); @@ -346,8 +352,11 @@ TYPED_TEST(ScatterListOfStructScalarTest, EmptyValidScalar) mask_vector{1, 0, 1, 1, 0, 1}.begin()), {1, 1, 0, 0, 1, 1}); offset_t offsets{0, 2, 2, 3, 6}; - auto col = - cudf::make_lists_column(4, offsets.release(), child.release(), 0, rmm::device_buffer{}); + auto col = cudf::make_lists_column(4, + offsets.release(), + child.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); size_column scatter_map{0, 2}; @@ -357,8 +366,11 @@ TYPED_TEST(ScatterListOfStructScalarTest, EmptyValidScalar) LCW({LCW{20, 20}, LCW{}, LCW{30, 30}}, mask_vector{1, 0, 1}.begin()), {0, 1, 1}); offset_t ex_offsets{0, 0, 0, 0, 3}; - auto expected = - cudf::make_lists_column(4, ex_offsets.release(), ex_child.release(), 0, rmm::device_buffer{}); + auto expected = cudf::make_lists_column(4, + ex_offsets.release(), + ex_child.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); auto result = single_scalar_scatter(*col, *slr, scatter_map); CUDF_TEST_EXPECT_COLUMNS_EQUIVALENT(*result, *expected); @@ -379,8 +391,11 @@ TYPED_TEST(ScatterListOfStructScalarTest, NullScalar) mask_vector{1, 0, 1, 1, 0, 1}.begin()), {1, 1, 1, 0, 1, 1}); offset_t offsets{0, 2, 2, 3, 6}; - auto col = - cudf::make_lists_column(4, offsets.release(), child.release(), 0, rmm::device_buffer{}); + auto col = cudf::make_lists_column(4, + offsets.release(), + child.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); size_column scatter_map{3, 1, 0}; @@ -388,7 +403,7 @@ TYPED_TEST(ScatterListOfStructScalarTest, NullScalar) offset_t ex_offsets{0, 0, 0, 1, 1}; auto null_mask = cudf::create_null_mask(4, cudf::mask_state::ALL_NULL); - cudf::set_null_mask(static_cast(null_mask.data()), 2, 3, true); + cudf::set_null_mask(reinterpret_cast(null_mask.data()), 2, 3, true); auto expected = cudf::make_lists_column(4, ex_offsets.release(), ex_child.release(), 3, std::move(null_mask)); @@ -416,7 +431,7 @@ TYPED_TEST(ScatterListOfStructScalarTest, NullableTargetRow) {1, 1, 1, 0, 1, 1}); offset_t offsets{0, 2, 2, 3, 6}; auto null_mask = cudf::create_null_mask(4, cudf::mask_state::ALL_VALID); - cudf::set_null_mask(static_cast(null_mask.data()), 1, 3, false); + cudf::set_null_mask(reinterpret_cast(null_mask.data()), 1, 3, false); auto col = cudf::make_lists_column(4, offsets.release(), child.release(), 2, std::move(null_mask)); @@ -432,7 +447,7 @@ TYPED_TEST(ScatterListOfStructScalarTest, NullableTargetRow) offset_t ex_offsets{0, 2, 2, 5, 8}; auto ex_null_mask = cudf::create_null_mask(4, cudf::mask_state::ALL_VALID); - cudf::set_null_mask(static_cast(ex_null_mask.data()), 1, 2, false); + cudf::set_null_mask(reinterpret_cast(ex_null_mask.data()), 1, 2, false); auto expected = cudf::make_lists_column( 4, ex_offsets.release(), ex_child.release(), 1, std::move(ex_null_mask)); diff --git a/cpp/tests/copying/scatter_list_tests.cpp b/cpp/tests/copying/scatter_list_tests.cpp index 083e5fecf680..cba9cb964062 100644 --- a/cpp/tests/copying/scatter_list_tests.cpp +++ b/cpp/tests/copying/scatter_list_tests.cpp @@ -11,6 +11,7 @@ #include #include +#include #include #include @@ -89,7 +90,7 @@ TYPED_TEST(TypedScatterListsTest, EmptyListsOfFixedWidth) cudf::test::fixed_width_column_wrapper{0, 4, 7, 7}.release(), src_child.release(), 0, - {}); + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); auto target_list_column = cudf::test::lists_column_wrapper{ {0, 0}, {1, 1}, {2, 2}, {3, 3}, {4, 4}, {5, 5}, {6, 6}}; @@ -107,7 +108,7 @@ TYPED_TEST(TypedScatterListsTest, EmptyListsOfFixedWidth) cudf::test::fixed_width_column_wrapper{0, 3, 5, 9, 11, 13, 13, 15}.release(), expected_child_ints.release(), 0, - {}); + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); CUDF_TEST_EXPECT_COLUMNS_EQUIVALENT(expected_lists_column->view(), ret->get_column(0)); } @@ -125,7 +126,7 @@ TYPED_TEST(TypedScatterListsTest, EmptyListsOfNullableFixedWidth) cudf::test::fixed_width_column_wrapper{0, 4, 7, 7}.release(), src_child.release(), 0, - {}); + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); auto target_list_column = cudf::test::lists_column_wrapper{ {0, 0}, {1, 1}, {2, 2}, {3, 3}, {4, 4}, {5, 5}, {6, 6}}; @@ -143,7 +144,7 @@ TYPED_TEST(TypedScatterListsTest, EmptyListsOfNullableFixedWidth) cudf::test::fixed_width_column_wrapper{0, 3, 5, 9, 11, 13, 13, 15}.release(), expected_child_ints.release(), 0, - {}); + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); CUDF_TEST_EXPECT_COLUMNS_EQUIVALENT(expected_lists_column->view(), ret->get_column(0)); } @@ -228,7 +229,7 @@ TEST_F(ScatterListsTest, ListsOfNullableStrings) cudf::test::fixed_width_column_wrapper{0, 5, 7}.release(), src_strings_column.release(), 0, - {}); + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); auto target_list_column = cudf::test::lists_column_wrapper{{"zero"}, {"one", "one"}, @@ -266,7 +267,7 @@ TEST_F(ScatterListsTest, ListsOfNullableStrings) cudf::test::fixed_width_column_wrapper{0, 2, 4, 9, 11, 13, 15}.release(), expected_strings.release(), 0, - {}); + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); CUDF_TEST_EXPECT_COLUMNS_EQUIVALENT(expected_lists->view(), ret->get_column(0)); } @@ -282,7 +283,7 @@ TEST_F(ScatterListsTest, EmptyListsOfNullableStrings) cudf::test::fixed_width_column_wrapper{0, 5, 5, 7}.release(), src_strings_column.release(), 0, - {}); + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); auto target_list_column = cudf::test::lists_column_wrapper{{"zero"}, {"one", "one"}, @@ -318,7 +319,7 @@ TEST_F(ScatterListsTest, EmptyListsOfNullableStrings) cudf::test::fixed_width_column_wrapper{0, 2, 4, 9, 11, 11, 13}.release(), expected_strings.release(), 0, - {}); + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); CUDF_TEST_EXPECT_COLUMNS_EQUIVALENT(expected_lists->view(), ret->get_column(0)); } @@ -492,7 +493,11 @@ TYPED_TEST(TypedScatterListsTest, ListsOfStructs) auto source_structs = cudf::test::structs_column_wrapper{{source_numerics, source_strings}}; auto source_lists = - cudf::make_lists_column(2, offsets_column{0, 4, 7}.release(), source_structs.release(), 0, {}); + cudf::make_lists_column(2, + offsets_column{0, 4, 7}.release(), + source_structs.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); // clang-format off auto target_ints = numerics_column{ @@ -516,8 +521,12 @@ TYPED_TEST(TypedScatterListsTest, ListsOfStructs) auto target_structs = cudf::test::structs_column_wrapper{{target_ints, target_strings}}; - auto target_lists = cudf::make_lists_column( - 6, offsets_column{0, 2, 4, 6, 8, 10, 12}.release(), target_structs.release(), 0, {}); + auto target_lists = + cudf::make_lists_column(6, + offsets_column{0, 2, 4, 6, 8, 10, 12}.release(), + target_structs.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); auto scatter_map = offsets_column{2, 0}; @@ -545,8 +554,12 @@ TYPED_TEST(TypedScatterListsTest, ListsOfStructs) auto expected_structs = cudf::test::structs_column_wrapper{{expected_numerics, expected_strings}}; - auto expected_lists = cudf::make_lists_column( - 6, offsets_column{0, 3, 5, 9, 11, 13, 15}.release(), expected_structs.release(), 0, {}); + auto expected_lists = + cudf::make_lists_column(6, + offsets_column{0, 3, 5, 9, 11, 13, 15}.release(), + expected_structs.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); CUDF_TEST_EXPECT_COLUMNS_EQUIVALENT(expected_lists->view(), scatter_result->get_column(0)); } @@ -578,7 +591,11 @@ TYPED_TEST(TypedScatterListsTest, ListsOfStructsWithNullMembers) auto source_structs = cudf::test::structs_column_wrapper{{source_numerics, source_strings}}; auto source_lists = - cudf::make_lists_column(2, offsets_column{0, 4, 7}.release(), source_structs.release(), 0, {}); + cudf::make_lists_column(2, + offsets_column{0, 4, 7}.release(), + source_structs.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); // clang-format off auto target_ints = numerics_column{ @@ -602,8 +619,12 @@ TYPED_TEST(TypedScatterListsTest, ListsOfStructsWithNullMembers) auto target_structs = cudf::test::structs_column_wrapper{{target_ints, target_strings}}; - auto target_lists = cudf::make_lists_column( - 6, offsets_column{0, 2, 4, 6, 8, 10, 12}.release(), target_structs.release(), 0, {}); + auto target_lists = + cudf::make_lists_column(6, + offsets_column{0, 2, 4, 6, 8, 10, 12}.release(), + target_structs.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); // clang-format on auto scatter_map = offsets_column{2, 0}; @@ -640,8 +661,12 @@ TYPED_TEST(TypedScatterListsTest, ListsOfStructsWithNullMembers) auto expected_structs = cudf::test::structs_column_wrapper{{expected_numerics, expected_strings}}; - auto expected_lists = cudf::make_lists_column( - 6, offsets_column{0, 3, 5, 9, 11, 13, 15}.release(), expected_structs.release(), 0, {}); + auto expected_lists = + cudf::make_lists_column(6, + offsets_column{0, 3, 5, 9, 11, 13, 15}.release(), + expected_structs.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); CUDF_TEST_EXPECT_COLUMNS_EQUIVALENT(expected_lists->view(), scatter_result->get_column(0)); } @@ -674,7 +699,11 @@ TYPED_TEST(TypedScatterListsTest, ListsOfNullStructs) cudf::test::iterators::null_at(1)}; auto source_lists = - cudf::make_lists_column(2, offsets_column{0, 4, 7}.release(), source_structs.release(), 0, {}); + cudf::make_lists_column(2, + offsets_column{0, 4, 7}.release(), + source_structs.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); // clang-format off auto target_ints = numerics_column{ @@ -698,8 +727,12 @@ TYPED_TEST(TypedScatterListsTest, ListsOfNullStructs) auto target_structs = cudf::test::structs_column_wrapper{{target_ints, target_strings}}; - auto target_lists = cudf::make_lists_column( - 6, offsets_column{0, 2, 4, 6, 8, 10, 12}.release(), target_structs.release(), 0, {}); + auto target_lists = + cudf::make_lists_column(6, + offsets_column{0, 2, 4, 6, 8, 10, 12}.release(), + target_structs.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); auto scatter_map = offsets_column{2, 0}; @@ -736,8 +769,12 @@ TYPED_TEST(TypedScatterListsTest, ListsOfNullStructs) auto expected_structs = cudf::test::structs_column_wrapper{{expected_numerics, expected_strings}, cudf::test::iterators::null_at(6)}; - auto expected_lists = cudf::make_lists_column( - 6, offsets_column{0, 3, 5, 9, 11, 13, 15}.release(), expected_structs.release(), 0, {}); + auto expected_lists = + cudf::make_lists_column(6, + offsets_column{0, 3, 5, 9, 11, 13, 15}.release(), + expected_structs.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); CUDF_TEST_EXPECT_COLUMNS_EQUIVALENT(expected_lists->view(), scatter_result->get_column(0)); } @@ -769,8 +806,12 @@ TYPED_TEST(TypedScatterListsTest, EmptyListsOfStructs) auto source_structs = cudf::test::structs_column_wrapper{{source_numerics, source_strings}, cudf::test::iterators::null_at(1)}; - auto source_lists = cudf::make_lists_column( - 3, offsets_column{0, 4, 7, 7}.release(), source_structs.release(), 0, {}); + auto source_lists = + cudf::make_lists_column(3, + offsets_column{0, 4, 7, 7}.release(), + source_structs.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); // clang-format off auto target_ints = numerics_column{ @@ -794,8 +835,12 @@ TYPED_TEST(TypedScatterListsTest, EmptyListsOfStructs) auto target_structs = cudf::test::structs_column_wrapper{{target_ints, target_strings}}; - auto target_lists = cudf::make_lists_column( - 6, offsets_column{0, 2, 4, 6, 8, 10, 12}.release(), target_structs.release(), 0, {}); + auto target_lists = + cudf::make_lists_column(6, + offsets_column{0, 2, 4, 6, 8, 10, 12}.release(), + target_structs.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); auto scatter_map = offsets_column{2, 0, 4}; @@ -830,8 +875,12 @@ TYPED_TEST(TypedScatterListsTest, EmptyListsOfStructs) auto expected_structs = cudf::test::structs_column_wrapper{{expected_numerics, expected_strings}, cudf::test::iterators::null_at(6)}; - auto expected_lists = cudf::make_lists_column( - 6, offsets_column{0, 3, 5, 9, 11, 11, 13}.release(), expected_structs.release(), 0, {}); + auto expected_lists = + cudf::make_lists_column(6, + offsets_column{0, 3, 5, 9, 11, 11, 13}.release(), + expected_structs.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); CUDF_TEST_EXPECT_COLUMNS_EQUIVALENT(expected_lists->view(), scatter_result->get_column(0)); } @@ -894,8 +943,12 @@ TYPED_TEST(TypedScatterListsTest, NullListsOfStructs) auto target_structs = cudf::test::structs_column_wrapper{{target_ints, target_strings}}; - auto target_lists = cudf::make_lists_column( - 6, offsets_column{0, 2, 4, 6, 8, 10, 12}.release(), target_structs.release(), 0, {}); + auto target_lists = + cudf::make_lists_column(6, + offsets_column{0, 2, 4, 6, 8, 10, 12}.release(), + target_structs.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); auto scatter_map = offsets_column{2, 0, 4}; diff --git a/cpp/tests/copying/slice_tests.cuh b/cpp/tests/copying/slice_tests.cuh index 143f0d5c881e..efd6be9646e2 100644 --- a/cpp/tests/copying/slice_tests.cuh +++ b/cpp/tests/copying/slice_tests.cuh @@ -229,7 +229,11 @@ inline std::unique_ptr make_long_offsets_string_column() cudf::test::fixed_width_column_wrapper long_offsets{ 0, 20, 40, 60, 80, 100, 500, 600, 700, 1000, 1010}; - auto str = cudf::make_strings_column(10, long_offsets.release(), std::move(d_chars), 0, {}); + auto str = cudf::make_strings_column(10, + long_offsets.release(), + std::move(d_chars), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); cudf::strings_column_view scv(*str); CUDF_EXPECTS(scv.offsets().type().id() == cudf::type_id::INT64, "Unexpected short offset type"); @@ -269,7 +273,11 @@ inline std::unique_ptr make_long_offsets_and_chars_string_column() block_d - 1000, block_d + (block_size / 2), static_cast(d_chars.size())}; - auto str = cudf::make_strings_column(10, long_offsets.release(), std::move(d_chars), 0, {}); + auto str = cudf::make_strings_column(10, + long_offsets.release(), + std::move(d_chars), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); cudf::strings_column_view scv(*str); CUDF_EXPECTS(scv.offsets().type().id() == cudf::type_id::INT64, "Unexpected short offset type"); diff --git a/cpp/tests/copying/split_tests.cpp b/cpp/tests/copying/split_tests.cpp index 5ed63291e56b..3cb9f573b46d 100644 --- a/cpp/tests/copying/split_tests.cpp +++ b/cpp/tests/copying/split_tests.cpp @@ -21,6 +21,7 @@ #include #include #include +#include #include #include @@ -959,9 +960,11 @@ void split_structs_no_children(SplitFunc Split, CompareFunc Compare, bool split { // no nulls { - auto struct_column = cudf::make_structs_column(4, {}, 0, rmm::device_buffer{}); + auto struct_column = + cudf::make_structs_column(4, {}, 0, cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); if (split) { - auto expected = cudf::make_structs_column(2, {}, 0, rmm::device_buffer{}); + auto expected = cudf::make_structs_column( + 2, {}, 0, cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); // split std::vector splits{2}; @@ -1006,10 +1009,13 @@ void split_structs_no_children(SplitFunc Split, CompareFunc Compare, bool split // no nulls, empty output column { - auto struct_column = cudf::make_structs_column(4, {}, 0, rmm::device_buffer{}); + auto struct_column = + cudf::make_structs_column(4, {}, 0, cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); if (split) { - auto expected0 = cudf::make_structs_column(4, {}, 0, rmm::device_buffer{}); - auto expected1 = cudf::make_structs_column(0, {}, 0, rmm::device_buffer{}); + auto expected0 = cudf::make_structs_column( + 4, {}, 0, cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); + auto expected1 = cudf::make_structs_column( + 0, {}, 0, cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); // split std::vector splits{4}; @@ -1038,7 +1044,8 @@ void split_structs_no_children(SplitFunc Split, CompareFunc Compare, bool split cudf::test::detail::make_null_mask(expected_validity0.begin(), expected_validity0.end()); auto expected0 = cudf::make_structs_column(4, {}, null_count, std::move(null_mask)); - auto expected1 = cudf::make_structs_column(0, {}, 0, rmm::device_buffer{}); + auto expected1 = cudf::make_structs_column( + 0, {}, 0, cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); // split std::vector splits{4}; @@ -1857,7 +1864,11 @@ TEST_F(ContiguousSplitUntypedTest, OffsetAlignment) cudf::test::fixed_width_column_wrapper long_offsets{ 0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 48}; auto long_str = - cudf::make_strings_column(12, long_offsets.release(), std::move(*contents.data), 0, {}); + cudf::make_strings_column(12, + long_offsets.release(), + std::move(*contents.data), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); cudf::strings_column_view scv(*long_str); CUDF_EXPECTS(scv.offsets().type().id() == cudf::type_id::INT64, "Unexpected short offset type"); @@ -2190,8 +2201,10 @@ TEST_F(ContiguousSplitTableCornerCases, PreSplitTable) children.push_back(std::make_unique(col2)); children.push_back(std::make_unique(col0)); children.push_back(std::make_unique(col1)); - auto col3 = cudf::make_structs_column( - static_cast(col0).size(), std::move(children), 0, rmm::device_buffer{}); + auto col3 = cudf::make_structs_column(static_cast(col0).size(), + std::move(children), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); cudf::table_view t({col0, col1, col2, *col3}); auto pre_split = cudf::split(t, {1}); @@ -2300,8 +2313,11 @@ TEST_F(ContiguousSplitTableCornerCases, PreSplitList) 11, 12, 13, 14, 15, 16, 17, 18, 19, 20}; cudf::test::structs_column_wrapper data({floats}); - auto list = - cudf::make_lists_column(8, offsets.release(), data.release(), 0, rmm::device_buffer{}); + auto list = cudf::make_lists_column(8, + offsets.release(), + data.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); auto pre_split = cudf::split(*list, {2}); @@ -2360,8 +2376,11 @@ TEST_F(ContiguousSplitTableCornerCases, PreSplitStructs) cudf::test::fixed_width_column_wrapper floats{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20}; cudf::test::structs_column_wrapper data({floats}); - auto list = - cudf::make_lists_column(8, offsets.release(), data.release(), 0, rmm::device_buffer{}); + auto list = cudf::make_lists_column(8, + offsets.release(), + data.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); cudf::test::strings_column_wrapper strings{"a", "bb", "ccc", "dddd", "", "e", "ff", "ggg"}; std::vector> struct_children; @@ -2389,8 +2408,11 @@ TEST_F(ContiguousSplitTableCornerCases, NestedEmpty) { auto empty_string = cudf::make_empty_column(cudf::data_type{cudf::type_id::STRING}); auto offsets = cudf::test::fixed_width_column_wrapper({0, 0}); - auto list = cudf::make_lists_column( - 1, offsets.release(), std::move(empty_string), 0, rmm::device_buffer{}); + auto list = cudf::make_lists_column(1, + offsets.release(), + std::move(empty_string), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); cudf::table_view src_table({static_cast(*list)}); @@ -2409,8 +2431,11 @@ TEST_F(ContiguousSplitTableCornerCases, NestedEmpty) cudf::test::strings_column_wrapper str{"abc"}; auto empty_string = cudf::empty_like(str); auto offsets = cudf::test::fixed_width_column_wrapper({0, 0}); - auto list = cudf::make_lists_column( - 1, offsets.release(), std::move(empty_string), 0, rmm::device_buffer{}); + auto list = cudf::make_lists_column(1, + offsets.release(), + std::move(empty_string), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); cudf::table_view src_table({static_cast(*list)}); @@ -2429,8 +2454,11 @@ TEST_F(ContiguousSplitTableCornerCases, NestedEmpty) cudf::test::lists_column_wrapper listw{{1.0f, 2.0f}, {3.0f, 4.0f}}; auto empty_list = cudf::empty_like(listw); auto offsets = cudf::test::fixed_width_column_wrapper({0, 0}); - auto list = - cudf::make_lists_column(1, offsets.release(), std::move(empty_list), 0, rmm::device_buffer{}); + auto list = cudf::make_lists_column(1, + offsets.release(), + std::move(empty_list), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); cudf::table_view src_table({static_cast(*list)}); @@ -2449,8 +2477,11 @@ TEST_F(ContiguousSplitTableCornerCases, NestedEmpty) cudf::test::lists_column_wrapper listw{{1.0f, 2.0f}, {3.0f, 4.0f}}; auto empty_list = cudf::empty_like(listw); auto offsets = cudf::test::fixed_width_column_wrapper({0, 0}); - auto list = - cudf::make_lists_column(1, offsets.release(), std::move(empty_list), 0, rmm::device_buffer{}); + auto list = cudf::make_lists_column(1, + offsets.release(), + std::move(empty_list), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); cudf::table_view src_table({static_cast(*list)}); @@ -2471,8 +2502,11 @@ TEST_F(ContiguousSplitTableCornerCases, NestedEmpty) auto struct_column = cudf::test::structs_column_wrapper({ints, floats}); auto empty_struct = cudf::empty_like(struct_column); auto offsets = cudf::test::fixed_width_column_wrapper({0, 0}); - auto list = cudf::make_lists_column( - 1, offsets.release(), std::move(empty_struct), 0, rmm::device_buffer{}); + auto list = cudf::make_lists_column(1, + offsets.release(), + std::move(empty_struct), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); cudf::table_view src_table({static_cast(*list)}); @@ -2838,7 +2872,11 @@ TEST_F(ContiguousSplitNestedTypesTest, ListOfDictionary) {"aa", "bb", "cc", "dd", "aa", "bb", "cc", "dd", "aa"}, {1, 1, 0, 1, 1, 1, 1, 1, 1}}; cudf::test::fixed_width_column_wrapper offsets{0, 2, 2, 5, 9}; auto const list = - cudf::make_lists_column(4, offsets.release(), keys.release(), 0, rmm::device_buffer{}); + cudf::make_lists_column(4, + offsets.release(), + keys.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); split_and_verify_dictionaries(cudf::table_view({*list}), {2}, [](cudf::table_view const& t) { return cudf::table_view( {cudf::lists_column_view(t.column(0)).get_sliced_child(cudf::get_default_stream())}); @@ -2910,7 +2948,11 @@ TEST_F(ContiguousSplitLongStrings, LongOffsetsNested) cudf::test::structs_column_wrapper st(std::move(children)); cudf::test::fixed_width_column_wrapper offsets{0, 3, 5, 7, 9, 10}; - auto list = make_lists_column(5, offsets.release(), st.release(), 0, {}); + auto list = make_lists_column(5, + offsets.release(), + st.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); cudf::table_view tbl({*list}); std::vector splits{2, 3}; @@ -2939,8 +2981,11 @@ TEST_F(ContiguousSplitLongStrings, DISABLED_LongOffsetsAndChars) TEST_F(ContiguousSplitLongStrings, DISABLED_LongOffsetsAndCharsNested) { cudf::test::fixed_width_column_wrapper offsets{0, 3, 5, 7, 9, 10}; - auto list = - make_lists_column(5, offsets.release(), make_long_offsets_and_chars_string_column(), 0, {}); + auto list = make_lists_column(5, + offsets.release(), + make_long_offsets_and_chars_string_column(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); cudf::table_view tbl({*list}); std::vector splits{2, 3}; diff --git a/cpp/tests/copying/utility_tests.cpp b/cpp/tests/copying/utility_tests.cpp index 45cf58cab6ae..592d4ff7fd1f 100644 --- a/cpp/tests/copying/utility_tests.cpp +++ b/cpp/tests/copying/utility_tests.cpp @@ -72,8 +72,10 @@ TYPED_TEST_SUITE(EmptyLikeScalarTest, cudf::test::FixedWidthTypes); TYPED_TEST(EmptyLikeScalarTest, FixedWidth) { // make a column - auto input = make_fixed_width_column( - cudf::data_type{cudf::type_to_id()}, 1, rmm::device_buffer{}, 0); + auto input = make_fixed_width_column(cudf::data_type{cudf::type_to_id()}, + 1, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), + 0); // get a scalar out of it std::unique_ptr sc = cudf::get_element(*input, 0); diff --git a/cpp/tests/datetime/datetime_ops_test.cpp b/cpp/tests/datetime/datetime_ops_test.cpp index 639754a74159..f891dd84c6cc 100644 --- a/cpp/tests/datetime/datetime_ops_test.cpp +++ b/cpp/tests/datetime/datetime_ops_test.cpp @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: Copyright (c) 2019-2024, NVIDIA CORPORATION. + * SPDX-FileCopyrightText: Copyright (c) 2019-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. * SPDX-License-Identifier: Apache-2.0 */ @@ -39,7 +39,8 @@ TYPED_TEST(NonTimestampTest, TestThrowsOnNonTimestamp) using namespace cuda::std::chrono; cudf::data_type dtype{cudf::type_to_id()}; - cudf::column col{dtype, 0, rmm::device_buffer{}, rmm::device_buffer{}, 0}; + cudf::column col{ + dtype, 0, rmm::device_buffer{}, cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), 0}; EXPECT_THROW(extract_datetime_component(col, cudf::datetime::datetime_component::YEAR), cudf::logic_error); @@ -252,8 +253,16 @@ TYPED_TEST(TypedDatetimeOpsTest, TestEmptyColumns) auto int16s_dtype = cudf::data_type{cudf::type_to_id()}; auto timestamps_dtype = cudf::data_type{cudf::type_to_id()}; - cudf::column int16s{int16s_dtype, 0, rmm::device_buffer{}, rmm::device_buffer{}, 0}; - cudf::column timestamps{timestamps_dtype, 0, rmm::device_buffer{}, rmm::device_buffer{}, 0}; + cudf::column int16s{int16s_dtype, + 0, + rmm::device_buffer{}, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), + 0}; + cudf::column timestamps{timestamps_dtype, + 0, + rmm::device_buffer{}, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), + 0}; CUDF_TEST_EXPECT_COLUMNS_EQUAL( *extract_datetime_component(timestamps, cudf::datetime::datetime_component::YEAR), int16s); diff --git a/cpp/tests/dictionary/factories_test.cpp b/cpp/tests/dictionary/factories_test.cpp index 4aa5db548b56..9cc69b8fb0ad 100644 --- a/cpp/tests/dictionary/factories_test.cpp +++ b/cpp/tests/dictionary/factories_test.cpp @@ -50,8 +50,8 @@ TEST_F(DictionaryFactoriesTest, CreateFromColumns) std::vector h_values{1, 2, 3, 1, 2, 3, 0}; cudf::test::fixed_width_column_wrapper values(h_values.begin(), h_values.end()); - auto dictionary = - cudf::make_dictionary_column(keys.release(), values.release(), rmm::device_buffer{}, 0); + auto dictionary = cudf::make_dictionary_column( + keys.release(), values.release(), cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), 0); cudf::dictionary_column_view view(dictionary->view()); cudf::test::strings_column_wrapper keys_expected(h_keys.begin(), h_keys.end()); @@ -66,8 +66,8 @@ TEST_F(DictionaryFactoriesTest, ColumnsWithNulls) cudf::test::fixed_width_column_wrapper keys(h_keys.begin(), h_keys.end()); std::vector h_values{1, 2, 3, 1, 2, 3, 0}; cudf::test::fixed_width_column_wrapper values(h_values.begin(), h_values.end()); - auto size = static_cast(h_values.size()); - rmm::device_buffer null_mask = create_null_mask(size, cudf::mask_state::ALL_NULL); + auto size = static_cast(h_values.size()); + cuda::device_buffer null_mask = create_null_mask(size, cudf::mask_state::ALL_NULL); auto dictionary = cudf::make_dictionary_column(keys.release(), values.release(), std::move(null_mask), size); cudf::dictionary_column_view view(dictionary->view()); @@ -87,8 +87,8 @@ TEST_F(DictionaryFactoriesTest, DuplicateKeys) std::vector h_values{1, 2, 3, 1, 2, 3, 0}; cudf::test::fixed_width_column_wrapper values(h_values.begin(), h_values.end()); - auto dictionary = - cudf::make_dictionary_column(keys.release(), values.release(), rmm::device_buffer{}, 0); + auto dictionary = cudf::make_dictionary_column( + keys.release(), values.release(), cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), 0); cudf::dictionary_column_view view(dictionary->view()); auto keys_expected = cudf::test::strings_column_wrapper(h_keys.begin(), h_keys.end()); @@ -112,7 +112,10 @@ TEST_F(DictionaryFactoriesTest, IndicesWithNulls) cudf::test::fixed_width_column_wrapper indices{{5, 4, 3, 2, 1, 0}, {true, true, true, false, true, false}}; EXPECT_THROW( - cudf::make_dictionary_column(keys.release(), indices.release(), rmm::device_buffer{}, 0), + cudf::make_dictionary_column(keys.release(), + indices.release(), + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), + 0), std::invalid_argument); } @@ -122,6 +125,9 @@ TEST_F(DictionaryFactoriesTest, InvalidIndices) cudf::test::fixed_width_column_wrapper indices{5, 4, 3, 2, 1, 0}; EXPECT_THROW(cudf::make_dictionary_column(keys, indices), std::invalid_argument); EXPECT_THROW( - cudf::make_dictionary_column(keys.release(), indices.release(), rmm::device_buffer{}, 0), + cudf::make_dictionary_column(keys.release(), + indices.release(), + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), + 0), std::invalid_argument); } diff --git a/cpp/tests/dictionary/gather_test.cpp b/cpp/tests/dictionary/gather_test.cpp index 763b495a29b2..6fad544b3af6 100644 --- a/cpp/tests/dictionary/gather_test.cpp +++ b/cpp/tests/dictionary/gather_test.cpp @@ -54,8 +54,8 @@ TEST_F(DictionaryGatherTest, DuplicateKeys) auto keys = cudf::test::strings_column_wrapper({"pear", "apple", "fruit", "pear"}); auto values = cudf::test::fixed_width_column_wrapper({1, 2, 3, 1, 2, 3, 0}); - auto dictionary = - cudf::make_dictionary_column(keys.release(), values.release(), rmm::device_buffer{}, 0); + auto dictionary = cudf::make_dictionary_column( + keys.release(), values.release(), cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), 0); auto view = cudf::dictionary_column_view(dictionary->view()); // decoded values are: {apple, fruit, pear, apple, fruit, pear, pear} diff --git a/cpp/tests/groupby/collect_list_tests.cpp b/cpp/tests/groupby/collect_list_tests.cpp index 601ed4e9736a..41d54e4beeee 100644 --- a/cpp/tests/groupby/collect_list_tests.cpp +++ b/cpp/tests/groupby/collect_list_tests.cpp @@ -137,15 +137,26 @@ TYPED_TEST(groupby_collect_list_test, CollectOnEmptyInputLists) auto offsets = cudf::data_type{cudf::type_to_id()}; cudf::test::fixed_width_column_wrapper keys{}; - auto values = - cudf::make_lists_column(0, cudf::make_empty_column(offsets), LCW{}.release(), 0, {}); + auto values = cudf::make_lists_column(0, + cudf::make_empty_column(offsets), + LCW{}.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); cudf::test::fixed_width_column_wrapper expect_keys{}; auto expect_child = - cudf::make_lists_column(0, cudf::make_empty_column(offsets), LCW{}.release(), 0, {}); + cudf::make_lists_column(0, + cudf::make_empty_column(offsets), + LCW{}.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); auto expect_values = - cudf::make_lists_column(0, cudf::make_empty_column(offsets), std::move(expect_child), 0, {}); + cudf::make_lists_column(0, + cudf::make_empty_column(offsets), + std::move(expect_child), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); auto agg = cudf::make_collect_list_aggregation(); test_single_agg(keys, values->view(), expect_keys, expect_values->view(), std::move(agg)); @@ -162,18 +173,29 @@ TYPED_TEST(groupby_collect_list_test, CollectOnEmptyInputListsOfStructs) auto struct_child = LCW{}; auto struct_column = cudf::test::structs_column_wrapper{{struct_child}}; - auto values = cudf::make_lists_column( - 0, cudf::make_empty_column(cudf::type_id::INT32), struct_column.release(), 0, {}); + auto values = cudf::make_lists_column(0, + cudf::make_empty_column(cudf::type_id::INT32), + struct_column.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); cudf::test::fixed_width_column_wrapper expect_keys{}; auto expect_struct_child = LCW{}; auto expect_struct_column = cudf::test::structs_column_wrapper{{expect_struct_child}}; - auto expect_child = cudf::make_lists_column( - 0, cudf::make_empty_column(cudf::type_id::INT32), expect_struct_column.release(), 0, {}); - auto expect_values = cudf::make_lists_column( - 0, cudf::make_empty_column(cudf::type_id::INT32), std::move(expect_child), 0, {}); + auto expect_child = + cudf::make_lists_column(0, + cudf::make_empty_column(cudf::type_id::INT32), + expect_struct_column.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); + auto expect_values = + cudf::make_lists_column(0, + cudf::make_empty_column(cudf::type_id::INT32), + std::move(expect_child), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); auto agg = cudf::make_collect_list_aggregation(); test_single_agg(keys, values->view(), expect_keys, expect_values->view(), std::move(agg)); @@ -191,11 +213,12 @@ TYPED_TEST(groupby_collect_list_test, dictionary) cudf::test::lists_column_wrapper expect_vals_w{{1, 2, 3}, {4, 5, 6}}; cudf::test::fixed_width_column_wrapper offsets({0, 3, 6}); - auto expect_vals = cudf::make_lists_column(cudf::column_view(offsets).size() - 1, - std::make_unique(offsets), - std::make_unique(vals), - 0, - rmm::device_buffer{}); + auto expect_vals = + cudf::make_lists_column(cudf::column_view(offsets).size() - 1, + std::make_unique(offsets), + std::make_unique(vals), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); test_single_agg(keys, vals, diff --git a/cpp/tests/groupby/histogram_tests.cpp b/cpp/tests/groupby/histogram_tests.cpp index 87d64d9211f3..ed189d46ae18 100644 --- a/cpp/tests/groupby/histogram_tests.cpp +++ b/cpp/tests/groupby/histogram_tests.cpp @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: Copyright (c) 2023-2024, NVIDIA CORPORATION. + * SPDX-FileCopyrightText: Copyright (c) 2023-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. * SPDX-License-Identifier: Apache-2.0 */ @@ -106,8 +106,11 @@ TYPED_TEST(GroupbyHistogramTest, SimpleInputNoNull) auto counts = int64s_col{1, 1, 3, 1, 1, 2, 1, 1, 2, 2}; return structs_col{{values, counts}}; }(); - return cudf::make_lists_column( - 3, int32s_col{0, 3, 7, 10}.release(), structs.release(), 0, rmm::device_buffer{}); + return cudf::make_lists_column(3, + int32s_col{0, 3, 7, 10}.release(), + structs.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); }(); auto const [res_keys, res_histogram] = @@ -136,8 +139,11 @@ TYPED_TEST(GroupbyHistogramTest, SlicedInputNoNull) auto counts = int64s_col{1, 1, 3, 1, 1, 2, 1, 1, 2, 2}; return structs_col{{values, counts}}; }(); - return cudf::make_lists_column( - 3, int32s_col{0, 3, 7, 10}.release(), structs.release(), 0, rmm::device_buffer{}); + return cudf::make_lists_column(3, + int32s_col{0, 3, 7, 10}.release(), + structs.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); }(); auto const [res_keys, res_histogram] = @@ -167,8 +173,11 @@ TYPED_TEST(GroupbyHistogramTest, InputWithNulls) auto counts = int64s_col{2, 1, 2, 1, 1, 3, 2, 1, 2, 1, 1, 3}; return structs_col{{values, counts}}; }(); - return cudf::make_lists_column( - 3, int32s_col{0, 3, 8, 12}.release(), structs.release(), 0, rmm::device_buffer{}); + return cudf::make_lists_column(3, + int32s_col{0, 3, 8, 12}.release(), + structs.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); }(); auto const [res_keys, res_histogram] = @@ -203,8 +212,11 @@ TYPED_TEST(GroupbyHistogramTest, SlicedInputWithNulls) auto counts = int64s_col{2, 1, 2, 1, 1, 3, 2, 1, 2, 1, 1, 3}; return structs_col{{values, counts}}; }(); - return cudf::make_lists_column( - 3, int32s_col{0, 3, 8, 12}.release(), structs.release(), 0, rmm::device_buffer{}); + return cudf::make_lists_column(3, + int32s_col{0, 3, 8, 12}.release(), + structs.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); }(); auto const [res_keys, res_histogram] = @@ -224,8 +236,11 @@ TYPED_TEST(GroupbyMergeHistogramTest, EmptyInput) auto counts = int64s_col{}; return structs_col{{values, counts}}; }(); - return cudf::make_lists_column( - 0, int32s_col{}.release(), structs.release(), 0, rmm::device_buffer{}); + return cudf::make_lists_column(0, + int32s_col{}.release(), + structs.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); }(); auto const [res_keys, res_histogram] = groupby_histogram(keys, *values, cudf::aggregation::MERGE_HISTOGRAM); @@ -247,8 +262,11 @@ TYPED_TEST(GroupbyMergeHistogramTest, SimpleInputNoNull) auto counts = int64s_col{1, 1, 3, 1, 3, 2, 1, 1, 2, 1, 2, 3, 1, 2}; return structs_col{{values, counts}}; }(); - return cudf::make_lists_column( - 5, int32s_col{0, 3, 6, 8, 11, 14}.release(), structs.release(), 0, rmm::device_buffer{}); + return cudf::make_lists_column(5, + int32s_col{0, 3, 6, 8, 11, 14}.release(), + structs.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); }(); auto const expected_keys = int32s_col{0, 1}; @@ -258,8 +276,11 @@ TYPED_TEST(GroupbyMergeHistogramTest, SimpleInputNoNull) auto counts = int64s_col{4, 1, 2, 3, 3, 1, 2, 4, 4}; return structs_col{{values, counts}}; }(); - return cudf::make_lists_column( - 2, int32s_col{0, 5, 9}.release(), structs.release(), 0, rmm::device_buffer{}); + return cudf::make_lists_column(2, + int32s_col{0, 5, 9}.release(), + structs.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); }(); auto const [res_keys, res_histogram] = @@ -285,7 +306,7 @@ TYPED_TEST(GroupbyMergeHistogramTest, SlicedInputNoNull) int32s_col{0, 2, 4, 7, 10, 12, 15, 18}.release(), structs.release(), 0, - rmm::device_buffer{}); + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); }(); auto const keys = cudf::slice(keys_original, {2, 7})[0]; auto const values = cudf::slice(*values_original, {2, 7})[0]; @@ -297,8 +318,11 @@ TYPED_TEST(GroupbyMergeHistogramTest, SlicedInputNoNull) auto counts = int64s_col{4, 1, 2, 3, 3, 1, 2, 4, 4}; return structs_col{{values, counts}}; }(); - return cudf::make_lists_column( - 2, int32s_col{0, 5, 9}.release(), structs.release(), 0, rmm::device_buffer{}); + return cudf::make_lists_column(2, + int32s_col{0, 5, 9}.release(), + structs.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); }(); auto const [res_keys, res_histogram] = @@ -322,8 +346,11 @@ TYPED_TEST(GroupbyMergeHistogramTest, InputWithNulls) auto counts = int64s_col{1, 3, 1, 3, 2, 2, 1, 2, 2, 1, 1, 2}; return structs_col{{values, counts}}; }(); - return cudf::make_lists_column( - 5, int32s_col{0, 2, 5, 8, 10, 12}.release(), structs.release(), 0, rmm::device_buffer{}); + return cudf::make_lists_column(5, + int32s_col{0, 2, 5, 8, 10, 12}.release(), + structs.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); }(); auto const expected_keys = int32s_col{0, 1}; @@ -333,8 +360,11 @@ TYPED_TEST(GroupbyMergeHistogramTest, InputWithNulls) auto counts = int64s_col{3, 1, 3, 3, 1, 2, 4, 4}; return structs_col{{values, counts}}; }(); - return cudf::make_lists_column( - 2, int32s_col{0, 4, 8}.release(), structs.release(), 0, rmm::device_buffer{}); + return cudf::make_lists_column(2, + int32s_col{0, 4, 8}.release(), + structs.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); }(); auto const [res_keys, res_histogram] = @@ -363,7 +393,7 @@ TYPED_TEST(GroupbyMergeHistogramTest, SlicedInputWithNulls) int32s_col{0, 2, 4, 6, 9, 12, 14, 16}.release(), structs.release(), 0, - rmm::device_buffer{}); + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); }(); auto const keys = cudf::slice(keys_original, {2, 7})[0]; auto const values = cudf::slice(*values_original, {2, 7})[0]; @@ -375,8 +405,11 @@ TYPED_TEST(GroupbyMergeHistogramTest, SlicedInputWithNulls) auto counts = int64s_col{3, 1, 3, 3, 1, 2, 4, 4}; return structs_col{{values, counts}}; }(); - return cudf::make_lists_column( - 2, int32s_col{0, 4, 8}.release(), structs.release(), 0, rmm::device_buffer{}); + return cudf::make_lists_column(2, + int32s_col{0, 4, 8}.release(), + structs.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); }(); auto const [res_keys, res_histogram] = diff --git a/cpp/tests/groupby/merge_m2_tests.cpp b/cpp/tests/groupby/merge_m2_tests.cpp index 1bcc405a0fc9..4a82d9b96f4c 100644 --- a/cpp/tests/groupby/merge_m2_tests.cpp +++ b/cpp/tests/groupby/merge_m2_tests.cpp @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: Copyright (c) 2021-2026, NVIDIA CORPORATION. + * SPDX-FileCopyrightText: Copyright (c) 2021-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. * SPDX-License-Identifier: Apache-2.0 */ @@ -62,9 +62,12 @@ auto compute_partial_results(cudf::column_view const& keys, cudf::column_view co cudf::data_type(cudf::type_id::INT64), cudf::get_default_stream()); auto const num_output_rows = out_keys->num_rows(); - return std::pair(std::move(out_keys->release()[0]), - cudf::make_structs_column( - num_output_rows, std::move(out_results[0].results), 0, rmm::device_buffer{})); + return std::pair( + std::move(out_keys->release()[0]), + cudf::make_structs_column(num_output_rows, + std::move(out_results[0].results), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED))); } /** diff --git a/cpp/tests/groupby/sum_overflow_tests.cpp b/cpp/tests/groupby/sum_overflow_tests.cpp index 7238525b1691..48cd315d2c57 100644 --- a/cpp/tests/groupby/sum_overflow_tests.cpp +++ b/cpp/tests/groupby/sum_overflow_tests.cpp @@ -59,7 +59,8 @@ TYPED_TEST(groupby_sum_overflow_test, Basic) std::vector> children; children.push_back(sum_col.release()); children.push_back(overflow_col.release()); - auto expect_vals = cudf::create_structs_hierarchy(3, std::move(children), 0, {}); + auto expect_vals = cudf::create_structs_hierarchy( + 3, std::move(children), 0, cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); auto agg = cudf::make_sum_overflow_aggregation(); test_single_agg(keys, vals, expect_keys, *expect_vals, std::move(agg)); @@ -78,7 +79,8 @@ TYPED_TEST(groupby_sum_overflow_test, Basic) std::vector> children; children.push_back(sum_col.release()); children.push_back(overflow_col.release()); - auto expect_vals = cudf::create_structs_hierarchy(3, std::move(children), 0, {}); + auto expect_vals = cudf::create_structs_hierarchy( + 3, std::move(children), 0, cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); auto agg = cudf::make_sum_overflow_aggregation(); test_single_agg(keys, vals, expect_keys, *expect_vals, std::move(agg)); @@ -127,7 +129,8 @@ TYPED_TEST(groupby_sum_overflow_test, SortPathWithTdigest) std::vector> children; children.push_back(sum_col.release()); children.push_back(overflow_col.release()); - auto expect_vals = cudf::create_structs_hierarchy(3, std::move(children), 0, {}); + auto expect_vals = cudf::create_structs_hierarchy( + 3, std::move(children), 0, cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); run_and_check(vals, *expect_vals); } else { cudf::test::fixed_width_column_wrapper vals{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; @@ -136,7 +139,8 @@ TYPED_TEST(groupby_sum_overflow_test, SortPathWithTdigest) std::vector> children; children.push_back(sum_col.release()); children.push_back(overflow_col.release()); - auto expect_vals = cudf::create_structs_hierarchy(3, std::move(children), 0, {}); + auto expect_vals = cudf::create_structs_hierarchy( + 3, std::move(children), 0, cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); run_and_check(vals, *expect_vals); } } @@ -158,7 +162,8 @@ TYPED_TEST(groupby_sum_overflow_test, EmptyCols) std::vector> children; children.push_back(sum_col.release()); children.push_back(overflow_col.release()); - auto expect_vals = cudf::create_structs_hierarchy(0, std::move(children), 0, {}); + auto expect_vals = cudf::create_structs_hierarchy( + 0, std::move(children), 0, cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); auto agg = cudf::make_sum_overflow_aggregation(); test_single_agg(keys, vals, expect_keys, *expect_vals, std::move(agg)); @@ -181,7 +186,8 @@ TYPED_TEST(groupby_sum_overflow_test, ZeroValidKeys) std::vector> children; children.push_back(sum_col.release()); children.push_back(overflow_col.release()); - auto expect_vals = cudf::create_structs_hierarchy(0, std::move(children), 0, {}); + auto expect_vals = cudf::create_structs_hierarchy( + 0, std::move(children), 0, cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); auto agg = cudf::make_sum_overflow_aggregation(); test_single_agg(keys, vals, expect_keys, *expect_vals, std::move(agg)); @@ -398,7 +404,8 @@ TYPED_TEST(groupby_sum_overflow_test, SlicedInput) std::vector> children; children.push_back(sum_col.release()); children.push_back(overflow_col.release()); - auto expect_vals = cudf::create_structs_hierarchy(3, std::move(children), 0, {}); + auto expect_vals = cudf::create_structs_hierarchy( + 3, std::move(children), 0, cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); auto const keys = cudf::slice(keys_full, {1, 11}).front(); auto const vals = cudf::slice(vals_full, {1, 11}).front(); @@ -419,7 +426,8 @@ TYPED_TEST(groupby_sum_overflow_test, SlicedInput) std::vector> children; children.push_back(sum_col.release()); children.push_back(overflow_col.release()); - auto expect_vals = cudf::create_structs_hierarchy(3, std::move(children), 0, {}); + auto expect_vals = cudf::create_structs_hierarchy( + 3, std::move(children), 0, cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); auto const keys = cudf::slice(keys_full, {1, 11}).front(); auto const vals = cudf::slice(vals_full, {1, 11}).front(); @@ -470,7 +478,8 @@ TYPED_TEST(groupby_sum_overflow_test, MultiBlock) cudf::test::fixed_point_column_wrapper(sum_it, sum_it + num_groups, scale); children.push_back(sum_col.release()); children.push_back(overflow_col.release()); - auto expect_vals = cudf::create_structs_hierarchy(num_groups, std::move(children), 0, {}); + auto expect_vals = cudf::create_structs_hierarchy( + num_groups, std::move(children), 0, cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); test_single_agg(keys, vals, expect_keys, @@ -483,7 +492,8 @@ TYPED_TEST(groupby_sum_overflow_test, MultiBlock) auto sum_col = cudf::test::fixed_width_column_wrapper(sum_it, sum_it + num_groups); children.push_back(sum_col.release()); children.push_back(overflow_col.release()); - auto expect_vals = cudf::create_structs_hierarchy(num_groups, std::move(children), 0, {}); + auto expect_vals = cudf::create_structs_hierarchy( + num_groups, std::move(children), 0, cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); test_single_agg(keys, vals, expect_keys, diff --git a/cpp/tests/interop/from_arrow_device_test.cpp b/cpp/tests/interop/from_arrow_device_test.cpp index cb3750aec518..298de32102e4 100644 --- a/cpp/tests/interop/from_arrow_device_test.cpp +++ b/cpp/tests/interop/from_arrow_device_test.cpp @@ -453,8 +453,11 @@ TEST_F(FromArrowDeviceTest, FixedSizeListColumnLarge) cudf::test::fixed_width_column_wrapper(values.begin(), values.end()).release(); auto offsets_col = cudf::test::fixed_width_column_wrapper(offsets.begin(), offsets.end()).release(); - auto expected = cudf::make_lists_column( - num_rows, std::move(offsets_col), std::move(child), 0, rmm::device_buffer{}); + auto expected = cudf::make_lists_column(num_rows, + std::move(offsets_col), + std::move(child), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); auto input_schema = make_struct_fixed_size_list_int64_schema(width); nanoarrow::UniqueArray input_array; @@ -553,7 +556,8 @@ TEST_F(FromArrowDeviceTest, StructColumn) cols.push_back(std::move(list_col)); cols.push_back(std::move(sub_struct_col)); - auto struct_col = cudf::make_structs_column(num_rows, std::move(cols), 0, {}); + auto struct_col = cudf::make_structs_column( + num_rows, std::move(cols), 0, cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); cudf::table_view expected_table_view({struct_col->view()}); // Create name metadata diff --git a/cpp/tests/interop/from_arrow_host_test.cpp b/cpp/tests/interop/from_arrow_host_test.cpp index a1be56b8d81a..0c4fcdeaa1eb 100644 --- a/cpp/tests/interop/from_arrow_host_test.cpp +++ b/cpp/tests/interop/from_arrow_host_test.cpp @@ -705,7 +705,11 @@ TEST_F(FromArrowHostDeviceTest, FixedSizeListColumnZeroWidth) constexpr cudf::size_type num_rows = 3; auto offsets = cudf::test::fixed_width_column_wrapper{0, 0, 0, 0}.release(); auto child = cudf::test::fixed_width_column_wrapper{}.release(); - auto expected = cudf::make_lists_column(num_rows, std::move(offsets), std::move(child), 0, {}); + auto expected = cudf::make_lists_column(num_rows, + std::move(offsets), + std::move(child), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); // nanoarrow's schema builder rejects width zero, but ArrowSchemaView accepts it from a // foreign producer. Replace a normally constructed fixed-size-list format to exercise it. @@ -819,7 +823,8 @@ TEST_F(FromArrowHostDeviceTest, StructColumn) cols.push_back(std::move(list_col)); cols.push_back(std::move(sub_struct_col)); - auto struct_col = cudf::make_structs_column(num_rows, std::move(cols), 0, {}); + auto struct_col = cudf::make_structs_column( + num_rows, std::move(cols), 0, cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); cudf::table_view expected_table_view({struct_col->view()}); // Create name metadata diff --git a/cpp/tests/interop/to_arrow_device_test.cpp b/cpp/tests/interop/to_arrow_device_test.cpp index f19dc606768b..b3d5a2c60e15 100644 --- a/cpp/tests/interop/to_arrow_device_test.cpp +++ b/cpp/tests/interop/to_arrow_device_test.cpp @@ -385,7 +385,8 @@ TEST_F(ToArrowDeviceTest, StructColumn) cols.push_back(std::move(list_col)); cols.push_back(std::move(sub_struct_col)); - auto struct_col = cudf::make_structs_column(num_rows, std::move(cols), 0, {}); + auto struct_col = cudf::make_structs_column( + num_rows, std::move(cols), 0, cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); std::vector> table_cols; table_cols.emplace_back(struct_col.release()); cudf::table input(std::move(table_cols)); diff --git a/cpp/tests/interop/to_arrow_host_test.cpp b/cpp/tests/interop/to_arrow_host_test.cpp index 8c62a8961e18..84979e25ce6f 100644 --- a/cpp/tests/interop/to_arrow_host_test.cpp +++ b/cpp/tests/interop/to_arrow_host_test.cpp @@ -600,7 +600,8 @@ TEST_F(ToArrowHostDeviceTest, StructColumn) cols.push_back(std::move(list_col)); cols.push_back(std::move(sub_struct_col)); - auto struct_col = cudf::make_structs_column(num_rows, std::move(cols), 0, {}); + auto struct_col = cudf::make_structs_column( + num_rows, std::move(cols), 0, cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); cudf::table_view input_view({struct_col->view()}); nanoarrow::UniqueSchema expected_schema; diff --git a/cpp/tests/io/cudftable_test.cpp b/cpp/tests/io/cudftable_test.cpp index 18afff9d41a0..2b0fb954c7e8 100644 --- a/cpp/tests/io/cudftable_test.cpp +++ b/cpp/tests/io/cudftable_test.cpp @@ -399,13 +399,21 @@ TEST_F(CudftableTest, Lists) cudf::test::lists_column_wrapper child_list{{1, 2}, {3, 4}, {5, 6, 7}, {8}, {}, {9, 10}}; auto lists_of_lists_offsets = cudf::test::fixed_width_column_wrapper{0, 2, 4, 6, 6}.release(); - auto lists_of_lists_col = cudf::make_lists_column( - 4, std::move(lists_of_lists_offsets), child_list.release(), 0, rmm::device_buffer{}); + auto lists_of_lists_col = + cudf::make_lists_column(4, + std::move(lists_of_lists_offsets), + child_list.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); cudf::test::strings_column_wrapper strings_child{"hello", "world", "foo", "bar", "baz", "test"}; auto strings_offsets = cudf::test::fixed_width_column_wrapper{0, 2, 5, 5, 6}.release(); - auto lists_of_strings_col = cudf::make_lists_column( - 4, std::move(strings_offsets), strings_child.release(), 0, rmm::device_buffer{}); + auto lists_of_strings_col = + cudf::make_lists_column(4, + std::move(strings_offsets), + strings_child.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); cudf::test::fixed_width_column_wrapper timestamps_child{ cudf::timestamp_ms{100ms}, @@ -416,8 +424,12 @@ TEST_F(CudftableTest, Lists) cudf::timestamp_ms{600ms}}; auto timestamps_offsets = cudf::test::fixed_width_column_wrapper{0, 2, 3, 3, 6}.release(); - auto lists_of_timestamps_col = cudf::make_lists_column( - 4, std::move(timestamps_offsets), timestamps_child.release(), 0, rmm::device_buffer{}); + auto lists_of_timestamps_col = + cudf::make_lists_column(4, + std::move(timestamps_offsets), + timestamps_child.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); cudf::test::fixed_width_column_wrapper durations_child{ cudf::duration_ns{1000ns}, @@ -426,22 +438,34 @@ TEST_F(CudftableTest, Lists) cudf::duration_ns{4000ns}, cudf::duration_ns{5000ns}}; auto durations_offsets = cudf::test::fixed_width_column_wrapper{0, 2, 3, 3, 5}.release(); - auto lists_of_durations_col = cudf::make_lists_column( - 4, std::move(durations_offsets), durations_child.release(), 0, rmm::device_buffer{}); + auto lists_of_durations_col = + cudf::make_lists_column(4, + std::move(durations_offsets), + durations_child.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); cudf::test::fixed_point_column_wrapper decimal32_child{ {12345, -67890, 99999, 0}, {true, true, true, true}, scale_type{2}}; auto decimal32_offsets = cudf::test::fixed_width_column_wrapper{0, 2, 3, 3, 4}.release(); - auto lists_of_decimals_col = cudf::make_lists_column( - 4, std::move(decimal32_offsets), decimal32_child.release(), 0, rmm::device_buffer{}); + auto lists_of_decimals_col = + cudf::make_lists_column(4, + std::move(decimal32_offsets), + decimal32_child.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); cudf::test::fixed_width_column_wrapper struct_col1{1, 2, 3, 4, 5, 6}; cudf::test::strings_column_wrapper struct_col2{"a", "b", "c", "d", "e", "f"}; cudf::test::structs_column_wrapper struct_col{{struct_col1, struct_col2}}; auto lists_of_structs_offsets = cudf::test::fixed_width_column_wrapper{0, 1, 3, 4, 6}.release(); - auto lists_of_structs_col = cudf::make_lists_column( - 4, std::move(lists_of_structs_offsets), struct_col.release(), 0, rmm::device_buffer{}); + auto lists_of_structs_col = + cudf::make_lists_column(4, + std::move(lists_of_structs_offsets), + struct_col.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); auto const expected = cudf::table_view{{lists_of_lists_col->view(), lists_of_strings_col->view(), @@ -486,12 +510,20 @@ TEST_F(CudftableTest, DeepNestingLists) cudf::test::lists_column_wrapper level3_list{{1, 2}, {3, 4}, {5}, {6, 7, 8}}; auto level2_offsets = cudf::test::fixed_width_column_wrapper{0, 2, 4}.release(); - auto level2_list = cudf::make_lists_column( - 2, std::move(level2_offsets), level3_list.release(), 0, rmm::device_buffer{}); + auto level2_list = + cudf::make_lists_column(2, + std::move(level2_offsets), + level3_list.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); auto level1_offsets = cudf::test::fixed_width_column_wrapper{0, 2}.release(); - auto level1_list = cudf::make_lists_column( - 1, std::move(level1_offsets), std::move(level2_list), 0, rmm::device_buffer{}); + auto level1_list = + cudf::make_lists_column(1, + std::move(level1_offsets), + std::move(level2_list), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); auto const expected = cudf::table_view{{level1_list->view()}}; run_test(expected); diff --git a/cpp/tests/io/experimental/hybrid_scan_common.cpp b/cpp/tests/io/experimental/hybrid_scan_common.cpp index 0eed9aaf9e26..611d8771f32d 100644 --- a/cpp/tests/io/experimental/hybrid_scan_common.cpp +++ b/cpp/tests/io/experimental/hybrid_scan_common.cpp @@ -5,6 +5,7 @@ #include "hybrid_scan_common.hpp" +#include "cudf/utilities/memory_resource.hpp" #include "tests/io/parquet_common.hpp" #include @@ -118,7 +119,7 @@ std::unique_ptr make_list_str_column(std::mt19937& gen, if (is_list_nullable) { return cudf::test::detail::make_null_mask(list_valids, list_valids + num_rows); } else { - return std::make_pair(rmm::device_buffer{}, 0); + return std::make_pair(cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), 0); } }(); return cudf::make_lists_column( @@ -354,8 +355,12 @@ std::pair, std::vector> create_parquet_with_s auto const make_null_mask = [stream](auto begin, auto end) { auto [null_mask, null_count] = cudf::test::detail::make_null_mask_vector(begin, end); - auto d_mask = rmm::device_buffer{ - null_mask.data(), cudf::bitmask_allocation_size_bytes(cudf::distance(begin, end)), stream}; + auto const* data = reinterpret_cast(null_mask.data()); + auto d_mask = cuda::device_buffer{ + stream, + cudf::get_current_device_resource_ref(), + data, + data + cudf::bitmask_allocation_size_bytes(cudf::distance(begin, end))}; stream.sync(); return std::pair{std::move(d_mask), null_count}; }; diff --git a/cpp/tests/io/experimental/hybrid_scan_test.cpp b/cpp/tests/io/experimental/hybrid_scan_test.cpp index 354e680fd5af..4679993c6f23 100644 --- a/cpp/tests/io/experimental/hybrid_scan_test.cpp +++ b/cpp/tests/io/experimental/hybrid_scan_test.cpp @@ -727,7 +727,7 @@ TEST_F(HybridScanTest, MaterializeMixedPayloadColumns) if (is_nullable) { return cudf::test::detail::make_null_mask(list_valids, list_valids + num_rows); } else { - return std::make_pair(rmm::device_buffer{}, 0); + return std::make_pair(cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), 0); } }(); return cudf::make_lists_column( diff --git a/cpp/tests/io/experimental/variant_extract_test.cpp b/cpp/tests/io/experimental/variant_extract_test.cpp index 2d7459243faf..86177ff8acce 100644 --- a/cpp/tests/io/experimental/variant_extract_test.cpp +++ b/cpp/tests/io/experimental/variant_extract_test.cpp @@ -633,7 +633,11 @@ inline cudf::test::structs_column_wrapper wrap_multi_row_variant( auto offs = cudf::test::fixed_width_column_wrapper(offsets.begin(), offsets.end()).release(); auto data = cudf::test::fixed_width_column_wrapper(flat.begin(), flat.end()).release(); - return cudf::make_lists_column(n, std::move(offs), std::move(data), 0, {}); + return cudf::make_lists_column(n, + std::move(offs), + std::move(data), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); }; std::vector> children; children.emplace_back(build_list(meta_rows)); @@ -1956,7 +1960,8 @@ inline std::unique_ptr scalar_i32() // A single-row STRUCT column adopting `children`. inline std::unique_ptr struct_of(std::vector> children) { - return cudf::make_structs_column(1, std::move(children), 0, rmm::device_buffer{}); + return cudf::make_structs_column( + 1, std::move(children), 0, cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); } inline std::vector> two_children(std::unique_ptr a, @@ -2728,10 +2733,15 @@ TEST_F(CastVariantStatusTest, SqlNullInputProducesRowNullStatus) cudf::test::fixed_width_column_wrapper(offsets.begin(), offsets.end()).release(); auto data_col = cudf::test::fixed_width_column_wrapper(flat.begin(), flat.end()).release(); - auto values_col = cudf::make_lists_column(2, std::move(offs_col), std::move(data_col), 0, {}); + auto values_col = + cudf::make_lists_column(2, + std::move(offs_col), + std::move(data_col), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); // Mask row 1 SQL null auto null_mask = cudf::create_null_mask(2, cudf::mask_state::ALL_VALID, stream, cmr()); - cudf::set_null_mask(static_cast(null_mask.data()), 1, 2, false); + cudf::set_null_mask(reinterpret_cast(null_mask.data()), 1, 2, false); stream.sync(); values_col->set_null_mask(std::move(null_mask), 1); diff --git a/cpp/tests/io/json/json_writer.cpp b/cpp/tests/io/json/json_writer.cpp index d08740d74a70..7dc072c26014 100644 --- a/cpp/tests/io/json/json_writer.cpp +++ b/cpp/tests/io/json/json_writer.cpp @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: Copyright (c) 2023-2026, NVIDIA CORPORATION. + * SPDX-FileCopyrightText: Copyright (c) 2023-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. * SPDX-License-Identifier: Apache-2.0 */ @@ -89,8 +89,11 @@ TEST_P(JsonCompressedWriterTest, EmptyLeaf) { cudf::test::strings_column_wrapper col1{""}; cudf::test::fixed_width_column_wrapper offsets{0, 0}; - auto col2 = make_lists_column( - 1, offsets.release(), cudf::test::strings_column_wrapper{}.release(), 0, rmm::device_buffer{}); + auto col2 = make_lists_column(1, + offsets.release(), + cudf::test::strings_column_wrapper{}.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); auto col3 = cudf::test::lists_column_wrapper::make_one_empty_row_column(); cudf::table_view tbl_view{{col1, *col2, col3}}; cudf::io::table_metadata mt{{{"col1"}, {"col2"}, {"col3"}}}; diff --git a/cpp/tests/io/orc_chunked_reader_test.cu b/cpp/tests/io/orc_chunked_reader_test.cu index ee8c6c634870..15887664d454 100644 --- a/cpp/tests/io/orc_chunked_reader_test.cu +++ b/cpp/tests/io/orc_chunked_reader_test.cu @@ -71,7 +71,7 @@ auto write_file(std::vector>& input_columns, auto const [null_mask, null_count] = cudf::test::detail::make_null_mask(valid_iter + offset, valid_iter + col->size() + offset); col = cudf::structs::detail::superimpose_and_sanitize_nulls( - static_cast(null_mask.data()), + reinterpret_cast(null_mask.data()), null_count, std::move(col), cudf::get_default_stream(), @@ -220,7 +220,8 @@ TEST_F(OrcChunkedReaderTest, NestedEmptyStructColumnSelection) cudf::test::detail::make_null_mask(validity.begin(), validity.end()); std::vector> struct_children; - struct_children.emplace_back(cudf::make_structs_column(num_rows, {}, 0, {})); + struct_children.emplace_back(cudf::make_structs_column( + num_rows, {}, 0, cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED))); auto input_column = cudf::make_structs_column( num_rows, std::move(struct_children), null_count, std::move(null_mask)); ASSERT_TRUE(input_column->nullable()); @@ -243,7 +244,11 @@ TEST_F(OrcChunkedReaderTest, NullableEmptyStructChildColumnSelection) std::vector> struct_children; struct_children.emplace_back( cudf::make_structs_column(num_rows, {}, null_count, std::move(null_mask))); - auto input_column = cudf::make_structs_column(num_rows, std::move(struct_children), 0, {}); + auto input_column = + cudf::make_structs_column(num_rows, + std::move(struct_children), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); ASSERT_FALSE(input_column->nullable()); ASSERT_TRUE(input_column->child(0).nullable()); ASSERT_EQ(null_count, input_column->child(0).null_count()); @@ -953,7 +958,7 @@ TEST_F(OrcChunkedReaderTest, TestChunkedReadWithListsOfStructs) int32s_col(offsets.begin(), offsets.end()).release(), make_structs_col(), 0, - rmm::device_buffer{})); + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED))); return write_file(input_columns, "chunked_read_with_lists_of_structs", nullable); }; @@ -1266,7 +1271,11 @@ TEST_F(OrcChunkedReaderInputLimitTest, ListType) value_gen{}); auto const lists_col = - cudf::make_lists_column(num_rows, std::move(offset_col), std::move(value_col), 0, {}); + cudf::make_lists_column(num_rows, + std::move(offset_col), + std::move(value_col), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); auto const filename = std::string{"list_type"}; auto const test_files = input_limit_get_test_names(temp_env->get_temp_filepath(filename)); @@ -1325,7 +1334,11 @@ TEST_F(OrcChunkedReaderInputLimitTest, MixedColumnsHavingList) value_gen{}); auto const lists_col = - cudf::make_lists_column(num_rows, std::move(offset_col), std::move(value_col), 0, {}); + cudf::make_lists_column(num_rows, + std::move(offset_col), + std::move(value_col), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); // strings int constexpr num_chars = num_rows * str_size; @@ -1343,7 +1356,11 @@ TEST_F(OrcChunkedReaderInputLimitTest, MixedColumnsHavingList) static_cast(str_chars.data()), char_values{}); auto const str_col = - cudf::make_strings_column(num_rows, std::move(str_offset_col), std::move(str_chars), 0, {}); + cudf::make_strings_column(num_rows, + std::move(str_offset_col), + std::move(str_chars), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); // doubles auto const double_col = cudf::make_fixed_width_column( diff --git a/cpp/tests/io/orc_test.cpp b/cpp/tests/io/orc_test.cpp index 4f957d547e9b..405eee332fbc 100644 --- a/cpp/tests/io/orc_test.cpp +++ b/cpp/tests/io/orc_test.cpp @@ -1683,7 +1683,8 @@ TEST_F(OrcReaderTest, NestedEmptyStructColumnSelection) cudf::test::detail::make_null_mask(validity.begin(), validity.end()); std::vector> struct_children; - struct_children.emplace_back(cudf::make_structs_column(num_rows, {}, 0, {})); + struct_children.emplace_back(cudf::make_structs_column( + num_rows, {}, 0, cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED))); auto input_column = cudf::make_structs_column( num_rows, std::move(struct_children), null_count, std::move(null_mask)); ASSERT_TRUE(input_column->nullable()); @@ -1706,7 +1707,11 @@ TEST_F(OrcReaderTest, NullableEmptyStructChildColumnSelection) std::vector> struct_children; struct_children.emplace_back( cudf::make_structs_column(num_rows, {}, null_count, std::move(null_mask))); - auto input_column = cudf::make_structs_column(num_rows, std::move(struct_children), 0, {}); + auto input_column = + cudf::make_structs_column(num_rows, + std::move(struct_children), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); ASSERT_FALSE(input_column->nullable()); ASSERT_TRUE(input_column->child(0).nullable()); ASSERT_EQ(null_count, input_column->child(0).null_count()); @@ -1757,8 +1762,12 @@ TEST_F(OrcWriterTest, DecimalOptionsNested) std::iota(row_offsets.begin(), row_offsets.end(), 0); int32_col offsets(row_offsets.begin(), row_offsets.end()); - auto map_list_col = cudf::make_lists_column( - num_rows, offsets.release(), std::move(map_struct_col), 0, rmm::device_buffer{}); + auto map_list_col = + cudf::make_lists_column(num_rows, + offsets.release(), + std::move(map_struct_col), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); table_view expected({*map_list_col}); @@ -1857,8 +1866,11 @@ TEST_F(OrcMetadataReaderTest, TestNested) } int32_col offsets(row_offsets.begin(), row_offsets.end()); - auto list_col = - cudf::make_lists_column(num_rows, offsets.release(), std::move(s_col), 0, rmm::device_buffer{}); + auto list_col = cudf::make_lists_column(num_rows, + offsets.release(), + std::move(s_col), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); table_view expected({*list_col, *list_col}); diff --git a/cpp/tests/io/parquet_chunked_reader_test.cu b/cpp/tests/io/parquet_chunked_reader_test.cu index 7abb3cf527af..60d2c069b609 100644 --- a/cpp/tests/io/parquet_chunked_reader_test.cu +++ b/cpp/tests/io/parquet_chunked_reader_test.cu @@ -72,7 +72,7 @@ auto write_file(std::vector>& input_columns, auto const [null_mask, null_count] = cudf::test::detail::make_null_mask(valid_iter + offset, valid_iter + col->size() + offset); col = cudf::structs::detail::superimpose_and_sanitize_nulls( - static_cast(null_mask.data()), + reinterpret_cast(null_mask.data()), null_count, std::move(col), cudf::get_default_stream(), @@ -549,8 +549,11 @@ TEST_F(ParquetChunkedReaderTest, TestChunkedReadWithPlainListOfStringSpanningPag auto child_col = strings_col(child_strings.begin(), child_strings.end()).release(); auto offsets_col = int32s_col(offsets.begin(), offsets.end()).release(); - auto list_col = cudf::make_lists_column( - num_rows, std::move(offsets_col), std::move(child_col), 0, rmm::device_buffer{}); + auto list_col = cudf::make_lists_column(num_rows, + std::move(offsets_col), + std::move(child_col), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); std::vector> cols; cols.push_back(std::move(list_col)); @@ -1090,7 +1093,7 @@ TEST_F(ParquetChunkedReaderTest, TestChunkedReadWithListsOfStructs) int32s_col(offsets.begin(), offsets.end()).release(), make_structs_col(), 0, - rmm::device_buffer{})); + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED))); return write_file(input_columns, "chunked_read_with_lists_of_structs", @@ -1438,18 +1441,23 @@ TEST_F(ParquetChunkedReaderInputLimitTest, ListSpanningPagesAtPassEnd) auto const make_offsets = [&] { return int32s_col(offsets.begin(), offsets.end()).release(); }; // array - auto list_of_string = cudf::make_lists_column(num_rows, - make_offsets(), - strings_col(keys.begin(), keys.end()).release(), - 0, - rmm::device_buffer{}); + auto list_of_string = + cudf::make_lists_column(num_rows, + make_offsets(), + strings_col(keys.begin(), keys.end()).release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); // map, modeled as list> std::vector> key_value; key_value.emplace_back(strings_col(keys.begin(), keys.end()).release()); key_value.emplace_back(strings_col(values.begin(), values.end(), value_valid.begin()).release()); - auto list_of_struct = cudf::make_lists_column( - num_rows, make_offsets(), structs_col{std::move(key_value)}.release(), 0, rmm::device_buffer{}); + auto list_of_struct = + cudf::make_lists_column(num_rows, + make_offsets(), + structs_col{std::move(key_value)}.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); std::vector> cols; cols.emplace_back(std::move(list_of_string)); @@ -1608,7 +1616,12 @@ void tiny_list_rowgroup_test(bool just_list_col) // write out the single-row list column as it's own file cudf::test::fixed_width_column_wrapper values(iter, iter + row_sizes[idx]); cudf::test::fixed_width_column_wrapper offsets({0, row_sizes[idx]}); - cols.push_back(cudf::make_lists_column(1, offsets.release(), values.release(), 0, {})); + cols.push_back( + cudf::make_lists_column(1, + offsets.release(), + values.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED))); // add a column after the list if (!just_list_col) { @@ -2554,8 +2567,12 @@ TEST_F(ParquetReaderTest, ManyLargeLists) stream.sync(); // list column - auto list_col = cudf::make_lists_column( - num_rows, std::move(offsets_col), std::move(bools_col), 0, rmm::device_buffer{}); + auto list_col = + cudf::make_lists_column(num_rows, + std::move(offsets_col), + std::move(bools_col), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); auto const table = cudf::table_view({*list_col}); auto const filepath = temp_env->get_temp_filepath("ManyLargeLists.parquet"); diff --git a/cpp/tests/io/parquet_chunked_writer_test.cpp b/cpp/tests/io/parquet_chunked_writer_test.cpp index 68b3317672f3..8339c0ddc436 100644 --- a/cpp/tests/io/parquet_chunked_writer_test.cpp +++ b/cpp/tests/io/parquet_chunked_writer_test.cpp @@ -212,8 +212,12 @@ TEST_F(ParquetChunkedWriterTest, ListOfStruct) cudf::test::fixed_width_column_wrapper{0, 2, 3, 3}.release(); auto num_list_rows_1 = list_offsets_column_1->size() - 1; - auto list_col_1 = cudf::make_lists_column( - num_list_rows_1, std::move(list_offsets_column_1), struct_2_1.release(), 0, {}); + auto list_col_1 = + cudf::make_lists_column(num_list_rows_1, + std::move(list_offsets_column_1), + struct_2_1.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); auto table_1 = table_view({*list_col_1}); @@ -230,8 +234,12 @@ TEST_F(ParquetChunkedWriterTest, ListOfStruct) cudf::test::fixed_width_column_wrapper{0, 1, 2, 3}.release(); auto num_list_rows_2 = list_offsets_column_2->size() - 1; - auto list_col_2 = cudf::make_lists_column( - num_list_rows_2, std::move(list_offsets_column_2), struct_2_2.release(), 0, {}); + auto list_col_2 = + cudf::make_lists_column(num_list_rows_2, + std::move(list_offsets_column_2), + struct_2_2.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); auto table_2 = table_view({*list_col_2}); @@ -290,8 +298,12 @@ TEST_F(ParquetChunkedWriterTest, ListOfStructOfStructOfListOfList) cudf::test::fixed_width_column_wrapper{0, 2, 3, 4}.release(); auto num_list_rows_1 = list_offsets_column_1->size() - 1; - auto list_col_1 = cudf::make_lists_column( - num_list_rows_1, std::move(list_offsets_column_1), struct_2_1.release(), 0, {}); + auto list_col_1 = + cudf::make_lists_column(num_list_rows_1, + std::move(list_offsets_column_1), + struct_2_1.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); auto table_1 = table_view({*list_col_1}); @@ -315,8 +327,12 @@ TEST_F(ParquetChunkedWriterTest, ListOfStructOfStructOfListOfList) auto list_offsets_column_2 = cudf::test::fixed_width_column_wrapper{0, 1, 2}.release(); auto num_list_rows_2 = list_offsets_column_2->size() - 1; - auto list_col_2 = cudf::make_lists_column( - num_list_rows_2, std::move(list_offsets_column_2), struct_2_2.release(), 0, {}); + auto list_col_2 = + cudf::make_lists_column(num_list_rows_2, + std::move(list_offsets_column_2), + struct_2_2.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); auto table_2 = table_view({*list_col_2}); diff --git a/cpp/tests/io/parquet_common.cpp b/cpp/tests/io/parquet_common.cpp index d10dfd7bd591..bde19444af73 100644 --- a/cpp/tests/io/parquet_common.cpp +++ b/cpp/tests/io/parquet_common.cpp @@ -181,16 +181,22 @@ std::unique_ptr make_parquet_list_list_col( child_values.begin(), child_values.begin() + child_value_count); int child_offsets_size = static_cast(child_offsets).size() - 1; - auto child = cudf::make_lists_column( - child_offsets_size, child_offsets.release(), child_data.release(), 0, rmm::device_buffer{}); + auto child = cudf::make_lists_column(child_offsets_size, + child_offsets.release(), + child_data.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); int offsets_size = static_cast(offsets).size() - 1; auto [null_mask, null_count] = cudf::test::detail::make_null_mask(valids, valids + offsets_size); return include_validity ? cudf::make_lists_column( offsets_size, offsets.release(), std::move(child), null_count, std::move(null_mask)) - : cudf::make_lists_column( - offsets_size, offsets.release(), std::move(child), 0, rmm::device_buffer{}); + : cudf::make_lists_column(offsets_size, + offsets.release(), + std::move(child), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); } template std::unique_ptr make_parquet_list_list_col( diff --git a/cpp/tests/io/parquet_deletion_vectors_test.cpp b/cpp/tests/io/parquet_deletion_vectors_test.cpp index c16da368f854..5a7be5fce999 100644 --- a/cpp/tests/io/parquet_deletion_vectors_test.cpp +++ b/cpp/tests/io/parquet_deletion_vectors_test.cpp @@ -78,8 +78,11 @@ auto build_column_from_host_data(cudf::host_span host_data, rmm::device_buffer buffer{num_rows * sizeof(T), stream, mr}; cudf::detail::cuda_memcpy( cudf::device_span{static_cast(buffer.data()), num_rows}, host_data, stream); - return std::make_unique( - cudf::data_type{data_type}, num_rows, std::move(buffer), rmm::device_buffer{}, 0); + return std::make_unique(cudf::data_type{data_type}, + num_rows, + std::move(buffer), + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), + 0); } /** diff --git a/cpp/tests/io/parquet_reader_dict_test.cpp b/cpp/tests/io/parquet_reader_dict_test.cpp index c366eb0905ca..2f3d69acd8b2 100644 --- a/cpp/tests/io/parquet_reader_dict_test.cpp +++ b/cpp/tests/io/parquet_reader_dict_test.cpp @@ -96,8 +96,11 @@ std::unique_ptr make_low_cardinality_lists_of_strings() auto offsets_col = cudf::test::fixed_width_column_wrapper(offsets.begin(), offsets.end()).release(); - return cudf::make_lists_column( - num_rows, std::move(offsets_col), child.release(), 0, rmm::device_buffer{}); + return cudf::make_lists_column(num_rows, + std::move(offsets_col), + child.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); } void write_parquet(cudf::table_view const& input, std::string const& filepath) diff --git a/cpp/tests/io/parquet_reader_test.cpp b/cpp/tests/io/parquet_reader_test.cpp index 6feb86c72382..bdbf71c1c28e 100644 --- a/cpp/tests/io/parquet_reader_test.cpp +++ b/cpp/tests/io/parquet_reader_test.cpp @@ -1204,9 +1204,13 @@ void delta_large_mini_block_list_read_test(std::vector const& file_byte cudf::test::fixed_width_column_wrapper(offsets.begin(), offsets.end()); auto child = cudf::test::fixed_width_column_wrapper(leaf_values.begin(), leaf_values.end()); - auto const num_lists = static_cast(expected.size()); - auto const expected_col = cudf::make_lists_column( - num_lists, offsets_col.release(), child.release(), 0, rmm::device_buffer{}); + auto const num_lists = static_cast(expected.size()); + auto const expected_col = + cudf::make_lists_column(num_lists, + offsets_col.release(), + child.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); auto const start = static_cast(skip_rows); auto const end = num_rows.has_value() ? start + *num_rows : num_lists; @@ -1232,10 +1236,14 @@ void delta_large_mini_block_string_list_read_test( } auto offsets_col = cudf::test::fixed_width_column_wrapper(offsets.begin(), offsets.end()); - auto child = cudf::test::strings_column_wrapper(leaf.begin(), leaf.end()); - auto const num_lists = static_cast(expected.size()); - auto const expected_col = cudf::make_lists_column( - num_lists, offsets_col.release(), child.release(), 0, rmm::device_buffer{}); + auto child = cudf::test::strings_column_wrapper(leaf.begin(), leaf.end()); + auto const num_lists = static_cast(expected.size()); + auto const expected_col = + cudf::make_lists_column(num_lists, + offsets_col.release(), + child.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); auto const start = static_cast(skip_rows); auto const end = num_rows.has_value() ? start + *num_rows : num_lists; @@ -1499,11 +1507,12 @@ TEST_F(ParquetReaderTest, DeltaBinaryListLargeMiniBlockLeafNulls) leaf_values.begin(), leaf_values.end(), valid_it); auto offsets_col = cudf::test::fixed_width_column_wrapper(offsets.begin(), offsets.end()); - auto const expected = cudf::make_lists_column(static_cast(lists.size()), - offsets_col.release(), - child.release(), - 0, - rmm::device_buffer{}); + auto const expected = + cudf::make_lists_column(static_cast(lists.size()), + offsets_col.release(), + child.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); for (auto const& [block_size, mini_block_count] : {std::pair{128, 1}, std::pair{384, 4}, std::pair{256, 1}}) { @@ -1817,7 +1826,11 @@ TEST_F(ParquetReaderTest, NestingOptimizationTest) cudf::test::fixed_width_column_wrapper offsets(offsets_iter, offsets_iter + num_rows + 1); - auto c = cudf::make_lists_column(num_rows, offsets.release(), std::move(prev_col), 0, {}); + auto c = cudf::make_lists_column(num_rows, + offsets.release(), + std::move(prev_col), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); prev_col = std::move(c); } auto const& expect = prev_col; @@ -3203,7 +3216,7 @@ TEST_F(ParquetReaderTest, RepeatedNoAnnotations) auto num_list_rows = list_offsets_column->size() - 1; auto mask = cudf::create_null_mask(6, cudf::mask_state::ALL_VALID); - cudf::set_null_mask(static_cast(mask.data()), 0, 2, false); + cudf::set_null_mask(reinterpret_cast(mask.data()), 0, 2, false); auto list_col = cudf::make_lists_column( num_list_rows, std::move(list_offsets_column), struct_col.release(), 2, std::move(mask)); @@ -3315,8 +3328,12 @@ TEST_F(ParquetReaderTest, RepeatedNoAnnotationsSingleFieldNested) column_wrapper inner_someid{3, 6, 9}; auto inner_struct = cudf::test::structs_column_wrapper{{inner_someid}}; auto inner_list_offsets = cudf::test::fixed_width_column_wrapper{0, 1, 2, 3}.release(); - auto inner_list = cudf::make_lists_column( - 3, std::move(inner_list_offsets), inner_struct.release(), 0, rmm::device_buffer{}); + auto inner_list = + cudf::make_lists_column(3, + std::move(inner_list_offsets), + inner_struct.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); column_wrapper outer_id{1, 4, 7}; std::vector> outer_struct_children; @@ -3325,8 +3342,12 @@ TEST_F(ParquetReaderTest, RepeatedNoAnnotationsSingleFieldNested) auto outer_struct_col = cudf::test::structs_column_wrapper{{std::move(outer_struct_children)}}; auto outer_list_offsets = cudf::test::fixed_width_column_wrapper{0, 1, 2, 3}.release(); - auto outer_list_col = cudf::make_lists_column( - 3, std::move(outer_list_offsets), outer_struct_col.release(), 0, rmm::device_buffer{}); + auto outer_list_col = + cudf::make_lists_column(3, + std::move(outer_list_offsets), + outer_struct_col.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); // Testing for equivalence here because we only care about the outermost validity buffers. table_view expected{{col0, *outer_list_col}}; @@ -3562,8 +3583,9 @@ TEST_F(ParquetReaderTest, DeltaByteArrayStructSkipRows) std::vector> children; children.push_back(cudf::purge_nonempty_nulls( cudf::test::strings_column_wrapper(strings.begin(), strings.end(), str_valids))); - auto const struct_col = cudf::make_structs_column(num_rows, std::move(children), 0, {}); - auto const expected = cudf::table_view({struct_col->view()}); + auto const struct_col = cudf::make_structs_column( + num_rows, std::move(children), 0, cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); + auto const expected = cudf::table_view({struct_col->view()}); cudf::io::table_input_metadata md(expected); md.column_metadata[0].set_name("s"); @@ -3609,8 +3631,12 @@ TEST_F(ParquetReaderTest, DeltaByteArrayMapSkipRows) auto struct_col = cudf::test::structs_column_wrapper({keys_col, vals_col}).release(); auto offsets_col = cudf::test::fixed_width_column_wrapper(offsets.begin(), offsets.end()); - auto const map_col = cudf::make_lists_column( - num_rows, offsets_col.release(), std::move(struct_col), 0, rmm::device_buffer{}); + auto const map_col = + cudf::make_lists_column(num_rows, + offsets_col.release(), + std::move(struct_col), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); auto const expected = cudf::table_view({map_col->view()}); cudf::io::table_input_metadata md(expected); @@ -4130,8 +4156,11 @@ TEST_F(ParquetMetadataReaderTest, Nested) } column_wrapper offsets(row_offsets.begin(), row_offsets.end()); - auto list_col = - cudf::make_lists_column(num_rows, offsets.release(), std::move(s_col), 0, rmm::device_buffer{}); + auto list_col = cudf::make_lists_column(num_rows, + offsets.release(), + std::move(s_col), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); table_view expected({*list_col, *list_col}); @@ -6654,7 +6683,10 @@ TEST_F(ParquetReaderTest, RequiredStringLeafWithSeparatedNullableAncestor) std::vector> inner_children; inner_children.push_back(child_col.release()); auto inner_struct = - cudf::create_structs_hierarchy(num_rows, std::move(inner_children), 0, rmm::device_buffer{}); + cudf::create_structs_hierarchy(num_rows, + std::move(inner_children), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); std::vector> outer_children; outer_children.push_back(std::move(inner_struct)); @@ -6716,8 +6748,11 @@ TEST_F(ParquetReaderTest, RequiredStringLeafWithNullableAncestorUnderList) 0, [](auto i) { return static_cast(i * list_size); }); column_wrapper offsets_col(offsets, offsets + num_lists + 1); - auto list_col = cudf::make_lists_column( - num_lists, offsets_col.release(), std::move(struct_col), 0, rmm::device_buffer{}); + auto list_col = cudf::make_lists_column(num_lists, + offsets_col.release(), + std::move(struct_col), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); auto const filepath = temp_env->get_temp_filepath("RequiredStringLeafWithNullableAncestorUnderList.parquet"); @@ -6757,8 +6792,12 @@ TEST_F(ParquetReaderTest, RequiredStringLeafWithNullableAncestorUnderList) exp_children.push_back(std::move(exp_leaf)); auto exp_struct = make_optional_struct(std::move(exp_children), num_elements, false); - auto const expected = cudf::make_lists_column( - num_lists, std::move(exp_offsets), std::move(exp_struct), 0, rmm::device_buffer{}); + auto const expected = + cudf::make_lists_column(num_lists, + std::move(exp_offsets), + std::move(exp_struct), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); // Read the table from Parquet auto const result = cudf::io::read_parquet( diff --git a/cpp/tests/io/parquet_v2_test.cpp b/cpp/tests/io/parquet_v2_test.cpp index 1035dcf272d3..7aa21d6593a1 100644 --- a/cpp/tests/io/parquet_v2_test.cpp +++ b/cpp/tests/io/parquet_v2_test.cpp @@ -589,8 +589,11 @@ TEST_P(ParquetV2Test, ListOfStruct) cudf::test::fixed_width_column_wrapper{0, 2, 5, 5, 6}.release(); auto num_list_rows = list_offsets_column->size() - 1; - auto list_col = cudf::make_lists_column( - num_list_rows, std::move(list_offsets_column), std::move(struct_2), 0, {}); + auto list_col = cudf::make_lists_column(num_list_rows, + std::move(list_offsets_column), + std::move(struct_2), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); auto expected = table_view({*list_col}); @@ -1002,7 +1005,11 @@ TEST_P(ParquetV2Test, CheckColumnOffsetIndexStruct) auto offsets = cudf::test::fixed_width_column_wrapper(offgen, offgen + num_ordered_rows + 1); - auto c2 = cudf::make_lists_column(num_ordered_rows, offsets.release(), list.release(), 0, {}); + auto c2 = cudf::make_lists_column(num_ordered_rows, + offsets.release(), + list.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); table_view expected({c0, c1, *c2}); diff --git a/cpp/tests/io/parquet_writer_test.cpp b/cpp/tests/io/parquet_writer_test.cpp index cb83f6e5d226..7ed86374df21 100644 --- a/cpp/tests/io/parquet_writer_test.cpp +++ b/cpp/tests/io/parquet_writer_test.cpp @@ -25,8 +25,6 @@ #include #include -#include - #include #include @@ -72,7 +70,7 @@ std::unique_ptr make_wide_list_column(cudf::size_type num_rows, .release(), std::move(child), 0, - rmm::device_buffer{}); + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); } // Only the `Nvcomp` instantiation requires device GZIP support (nvCOMP 5.3+). The host @@ -642,9 +640,13 @@ TEST_F(ParquetWriterTest, EmptyList) cudf::make_empty_column(cudf::data_type(cudf::type_id::INT32)), cudf::make_empty_column(cudf::data_type{cudf::type_id::INT64}), 0, - {}); - auto L0 = cudf::make_lists_column( - 3, cudf::test::fixed_width_column_wrapper{0, 0, 0, 0}.release(), std::move(L1), 0, {}); + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); + auto L0 = + cudf::make_lists_column(3, + cudf::test::fixed_width_column_wrapper{0, 0, 0, 0}.release(), + std::move(L1), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); auto filepath = temp_env->get_temp_filepath("EmptyList.parquet"); cudf::io::write_parquet(cudf::io::parquet_writer_options_builder(cudf::io::sink_info(filepath), @@ -665,11 +667,18 @@ TEST_F(ParquetWriterTest, DeepEmptyList) cudf::make_empty_column(cudf::data_type(cudf::type_id::INT32)), cudf::make_empty_column(cudf::data_type{cudf::type_id::INT64}), 0, - {}); - auto L1 = cudf::make_lists_column( - 0, cudf::make_empty_column(cudf::data_type(cudf::type_id::INT32)), std::move(L2), 0, {}); - auto L0 = cudf::make_lists_column( - 3, cudf::test::fixed_width_column_wrapper{0, 0, 0, 0}.release(), std::move(L1), 0, {}); + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); + auto L1 = cudf::make_lists_column(0, + cudf::make_empty_column(cudf::data_type(cudf::type_id::INT32)), + std::move(L2), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); + auto L0 = + cudf::make_lists_column(3, + cudf::test::fixed_width_column_wrapper{0, 0, 0, 0}.release(), + std::move(L1), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); auto filepath = temp_env->get_temp_filepath("DeepEmptyList.parquet"); cudf::io::write_parquet(cudf::io::parquet_writer_options_builder(cudf::io::sink_info(filepath), @@ -687,15 +696,23 @@ TEST_F(ParquetWriterTest, EmptyListWithStruct) cudf::make_empty_column(cudf::data_type(cudf::type_id::INT32)), cudf::make_empty_column(cudf::data_type{cudf::type_id::INT64}), 0, - {}); + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); auto children = std::vector>{}; children.push_back(std::move(L2)); - auto S2 = cudf::make_structs_column(0, std::move(children), 0, {}); - auto L1 = cudf::make_lists_column( - 0, cudf::make_empty_column(cudf::data_type(cudf::type_id::INT32)), std::move(S2), 0, {}); - auto L0 = cudf::make_lists_column( - 3, cudf::test::fixed_width_column_wrapper{0, 0, 0, 0}.release(), std::move(L1), 0, {}); + auto S2 = cudf::make_structs_column( + 0, std::move(children), 0, cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); + auto L1 = cudf::make_lists_column(0, + cudf::make_empty_column(cudf::data_type(cudf::type_id::INT32)), + std::move(S2), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); + auto L0 = + cudf::make_lists_column(3, + cudf::test::fixed_width_column_wrapper{0, 0, 0, 0}.release(), + std::move(L1), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); auto filepath = temp_env->get_temp_filepath("EmptyListWithStruct.parquet"); cudf::io::write_parquet(cudf::io::parquet_writer_options_builder(cudf::io::sink_info(filepath), @@ -1419,8 +1436,11 @@ TEST_F(ParquetWriterTest, DictionaryEntryLimitListTest) 0, [vals_per_row](auto i) { return static_cast(i * vals_per_row); }); cudf::test::fixed_width_column_wrapper offsets(offset_values, offset_values + num_rows + 1); - return cudf::make_lists_column( - num_rows, offsets.release(), leaves.release(), 0, rmm::device_buffer{}); + return cudf::make_lists_column(num_rows, + offsets.release(), + leaves.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); }; constexpr cudf::size_type max_dict_entries = max_dict_size / sizeof(int32_t); @@ -2203,15 +2223,27 @@ TEST_F(ParquetWriterTest, ListElementFieldIds) auto simple_values = cudf::test::fixed_width_column_wrapper{1, 2, 3}; auto simple_offsets = cudf::test::fixed_width_column_wrapper{0, 2, 3}; auto simple_list = - cudf::make_lists_column(2, simple_offsets.release(), simple_values.release(), 0, {}); + cudf::make_lists_column(2, + simple_offsets.release(), + simple_values.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); auto nested_values = cudf::test::fixed_width_column_wrapper{10, 11, 12, 13}; auto nested_offsets = cudf::test::fixed_width_column_wrapper{0, 2, 3, 4}; auto inner_list = - cudf::make_lists_column(3, nested_offsets.release(), nested_values.release(), 0, {}); + cudf::make_lists_column(3, + nested_offsets.release(), + nested_values.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); auto outer_offsets = cudf::test::fixed_width_column_wrapper{0, 2, 3}; auto nested_list = - cudf::make_lists_column(2, outer_offsets.release(), std::move(inner_list), 0, {}); + cudf::make_lists_column(2, + outer_offsets.release(), + std::move(inner_list), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); auto const expected = cudf::table_view{{*simple_list, *nested_list}}; @@ -2533,7 +2565,11 @@ TEST_F(ParquetWriterTest, WriteFixedLenByteArray) auto data_child = cudf::test::fixed_width_column_wrapper(data.begin(), data.end()); auto off_child = cudf::test::fixed_width_column_wrapper(offsets.begin(), offsets.end()); - auto col = cudf::make_lists_column(num_rows, off_child.release(), data_child.release(), 0, {}); + auto col = cudf::make_lists_column(num_rows, + off_child.release(), + data_child.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); auto expected = table_view{{*col, *col, *col, *col}}; cudf::io::table_input_metadata expected_metadata(expected); diff --git a/cpp/tests/large_strings/parquet_tests.cpp b/cpp/tests/large_strings/parquet_tests.cpp index 36bf62287b8e..7a72d4a71089 100644 --- a/cpp/tests/large_strings/parquet_tests.cpp +++ b/cpp/tests/large_strings/parquet_tests.cpp @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: Copyright (c) 2024-2026, NVIDIA CORPORATION. + * SPDX-FileCopyrightText: Copyright (c) 2024-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. * SPDX-License-Identifier: Apache-2.0 */ @@ -177,7 +177,7 @@ TEST_F(ParquetStringsTest, ChunkedReadNestedLargeStrings) int32s_col(offsets.begin(), offsets.end()).release(), make_structs_col(), 0, - rmm::device_buffer{})); + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED))); // Input table auto const table = cudf::table{std::move(input_columns)}; diff --git a/cpp/tests/lists/combine/concatenate_list_elements_tests.cpp b/cpp/tests/lists/combine/concatenate_list_elements_tests.cpp index 6e758a782d65..6a8c8788d1cd 100644 --- a/cpp/tests/lists/combine/concatenate_list_elements_tests.cpp +++ b/cpp/tests/lists/combine/concatenate_list_elements_tests.cpp @@ -499,11 +499,19 @@ TEST_F(ConcatenateListElementsTest, ListsOfListsOfStructsNoNull) auto child3 = strings_col{"1", "2", "3", "4", "5", "6", "7", "8", "9", "10"}; auto structs = structs_col{{child1, child2, child3}}; auto offsets = int32s_col{0, 2, 3, 6, 6, 8, 10}; - return cudf::make_lists_column(6, offsets.release(), structs.release(), 0, {}); + return cudf::make_lists_column(6, + offsets.release(), + structs.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); }(); auto offsets = int32s_col{0, 3, 4, 6}; - return cudf::make_lists_column(3, offsets.release(), std::move(child), 0, {}); + return cudf::make_lists_column(3, + offsets.release(), + std::move(child), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); }(); // Output: @@ -516,7 +524,11 @@ TEST_F(ConcatenateListElementsTest, ListsOfListsOfStructsNoNull) auto child3 = strings_col{"1", "2", "3", "4", "5", "6", "7", "8", "9", "10"}; auto structs = structs_col{{child1, child2, child3}}; auto offsets = int32s_col{0, 6, 6, 10}; - return cudf::make_lists_column(3, offsets.release(), structs.release(), 0, {}); + return cudf::make_lists_column(3, + offsets.release(), + structs.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); }(); auto const results = cudf::lists::concatenate_list_elements(*input); @@ -547,7 +559,11 @@ TEST_F(ConcatenateListElementsTest, ListsOfListsOfStructsWithNull) }(); auto offsets = int32s_col{0, 3, 4, 6}; - return cudf::make_lists_column(3, offsets.release(), std::move(child), 0, {}); + return cudf::make_lists_column(3, + offsets.release(), + std::move(child), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); }(); // Concatenate with ignoring null lists. @@ -562,7 +578,11 @@ TEST_F(ConcatenateListElementsTest, ListsOfListsOfStructsWithNull) auto child3 = strings_col{"1", "", "3", "4", "5", "", "7", "", "9", "10"}; auto structs = structs_col{{child1, child2, child3}, nulls_at({1, 5, 7})}; auto offsets = int32s_col{0, 3, 6, 10}; - return cudf::make_lists_column(3, offsets.release(), structs.release(), 0, {}); + return cudf::make_lists_column(3, + offsets.release(), + structs.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); }(); auto const results = cudf::lists::concatenate_list_elements(*input); @@ -579,7 +599,11 @@ TEST_F(ConcatenateListElementsTest, ListsOfListsOfStructsWithNull) auto child3 = strings_col{"4", "5", ""}; auto structs = structs_col{{child1, child2, child3}, null_at(2)}; auto offsets = int32s_col{0, 3}; - return cudf::make_lists_column(1, offsets.release(), structs.release(), 0, {}); + return cudf::make_lists_column(1, + offsets.release(), + structs.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); }(); auto const sliced_input = cudf::slice(*input, {1, 2})[0]; @@ -654,11 +678,19 @@ TEST_F(ConcatenateListElementsTest, ListsOfListsOfStructsHavingListsNoNull) lists_col{{1, 1}, {2}, {3, 3}, {}, {5, 5, 5}, {6, 6}, {7}, {8}, {9, 9}, {10, 10, 10, 10}}; auto structs = structs_col{{child1, child2, child3}}; auto offsets = int32s_col{0, 2, 3, 6, 6, 8, 10}; - return cudf::make_lists_column(6, offsets.release(), structs.release(), 0, {}); + return cudf::make_lists_column(6, + offsets.release(), + structs.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); }(); auto offsets = int32s_col{0, 3, 4, 6}; - return cudf::make_lists_column(3, offsets.release(), std::move(child), 0, {}); + return cudf::make_lists_column(3, + offsets.release(), + std::move(child), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); }(); // clang-format off @@ -674,7 +706,11 @@ TEST_F(ConcatenateListElementsTest, ListsOfListsOfStructsHavingListsNoNull) lists_col{{1, 1}, {2}, {3, 3}, {}, {5, 5, 5}, {6, 6}, {7}, {8}, {9, 9}, {10, 10, 10, 10}}; auto structs = structs_col{{child1, child2, child3}}; auto offsets = int32s_col{0, 6, 6, 10}; - return cudf::make_lists_column(3, offsets.release(), structs.release(), 0, {}); + return cudf::make_lists_column(3, + offsets.release(), + structs.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); }(); auto const results = cudf::lists::concatenate_list_elements(*input); @@ -707,7 +743,11 @@ TEST_F(ConcatenateListElementsTest, ListsOfListsOfStructsHavingListsWithNulls) }(); auto offsets = int32s_col{0, 2, 4, 6}; - return cudf::make_lists_column(3, offsets.release(), std::move(child), 0, {}); + return cudf::make_lists_column(3, + offsets.release(), + std::move(child), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); }(); // Concatenate with ignoring null lists. @@ -724,7 +764,11 @@ TEST_F(ConcatenateListElementsTest, ListsOfListsOfStructsHavingListsWithNulls) null_at(3)}; auto structs = structs_col{{child1, child2, child3}}; auto offsets = int32s_col{0, 3, 6, 10}; - return cudf::make_lists_column(3, offsets.release(), structs.release(), 0, {}); + return cudf::make_lists_column(3, + offsets.release(), + structs.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); }(); auto const results = cudf::lists::concatenate_list_elements(*input); @@ -741,7 +785,11 @@ TEST_F(ConcatenateListElementsTest, ListsOfListsOfStructsHavingListsWithNulls) auto child3 = lists_col{{{}, {5, 5, 5}, {6, 6}}, null_at(0)}; auto structs = structs_col{{child1, child2, child3}}; auto offsets = int32s_col{0, 3}; - return cudf::make_lists_column(1, offsets.release(), structs.release(), 0, {}); + return cudf::make_lists_column(1, + offsets.release(), + structs.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); }(); auto const sliced_input = cudf::slice(*input, {1, 2})[0]; @@ -823,8 +871,17 @@ TEST_F(ConcatenateListElementsTest, EmptyInnerListColumnChildSizeZero) auto inner_offsets = cudf::test::fixed_width_column_wrapper{0}; auto inner_elements = cudf::test::fixed_width_column_wrapper{}; auto inner_col = - cudf::make_lists_column(0, inner_offsets.release(), inner_elements.release(), 0, {}); - auto const col = cudf::make_lists_column(1, offsets.release(), std::move(inner_col), 0, {}); + cudf::make_lists_column(0, + inner_offsets.release(), + inner_elements.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); + auto const col = + cudf::make_lists_column(1, + offsets.release(), + std::move(inner_col), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); auto const results = cudf::lists::concatenate_list_elements(*col); auto const expected = IntListsCol{IntListsCol{}}; @@ -840,7 +897,11 @@ TEST_F(ConcatenateListElementsTest, EmptyInnerListColumnWithNullRow) auto inner_offsets = cudf::test::fixed_width_column_wrapper{0}; auto inner_elements = cudf::test::fixed_width_column_wrapper{}; auto inner_col = - cudf::make_lists_column(0, inner_offsets.release(), inner_elements.release(), 0, {}); + cudf::make_lists_column(0, + inner_offsets.release(), + inner_elements.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); auto const null_it = cudf::test::iterators::null_at(0); auto [null_mask, null_count] = cudf::test::detail::make_null_mask(null_it, null_it + 2); auto const col = cudf::make_lists_column( @@ -876,13 +937,19 @@ TEST_F(ConcatenateListElementsTest, EmptyInnerListColumnChildSizeZeroWithStructG auto s_child2 = int32s_col{}; auto grandchild = structs_col{{s_child1, s_child2}}; // struct, 0 rows auto inner_offsets = cudf::test::fixed_width_column_wrapper{0}; - auto inner_col = cudf::make_lists_column(0, - inner_offsets.release(), - grandchild.release(), - 0, - {}); // list>, 0 rows + auto inner_col = cudf::make_lists_column( + 0, + inner_offsets.release(), + grandchild.release(), + 0, + cudf::create_null_mask(0, + cudf::mask_state::UNALLOCATED)); // list>, 0 rows auto outer_offsets = cudf::test::fixed_width_column_wrapper{0, 0}; - return cudf::make_lists_column(1, outer_offsets.release(), std::move(inner_col), 0, {}); + return cudf::make_lists_column(1, + outer_offsets.release(), + std::move(inner_col), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); }(); // Expected: list> with 1 empty row (the outer list flattened). @@ -891,7 +958,11 @@ TEST_F(ConcatenateListElementsTest, EmptyInnerListColumnChildSizeZeroWithStructG auto s_child2 = int32s_col{}; auto grandchild = structs_col{{s_child1, s_child2}}; auto offsets = cudf::test::fixed_width_column_wrapper{0, 0}; - return cudf::make_lists_column(1, offsets.release(), grandchild.release(), 0, {}); + return cudf::make_lists_column(1, + offsets.release(), + grandchild.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); }(); auto const results = cudf::lists::concatenate_list_elements(*col); diff --git a/cpp/tests/lists/combine/concatenate_rows_tests.cpp b/cpp/tests/lists/combine/concatenate_rows_tests.cpp index 2408ebfbbbbe..2df982fe54bc 100644 --- a/cpp/tests/lists/combine/concatenate_rows_tests.cpp +++ b/cpp/tests/lists/combine/concatenate_rows_tests.cpp @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: Copyright (c) 2021-2025, NVIDIA CORPORATION. + * SPDX-FileCopyrightText: Copyright (c) 2021-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. * SPDX-License-Identifier: Apache-2.0 */ @@ -688,7 +688,11 @@ TEST_F(ListConcatenateRowsNestedTypesTest, Struct) cudf::test::structs_column_wrapper s0(std::move(s0_children)); cudf::test::fixed_width_column_wrapper l0_offsets{0, 2, 2, 5, 6, 8}; auto const l0_size = static_cast(l0_offsets).size() - 1; - auto l0 = cudf::make_lists_column(l0_size, l0_offsets.release(), s0.release(), 0, {}); + auto l0 = cudf::make_lists_column(l0_size, + l0_offsets.release(), + s0.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); // col1 cudf::test::fixed_width_column_wrapper s1_0{ @@ -714,7 +718,11 @@ TEST_F(ListConcatenateRowsNestedTypesTest, Struct) cudf::test::structs_column_wrapper s1(std::move(s1_children)); cudf::test::fixed_width_column_wrapper l1_offsets{0, 0, 4, 7, 15, 15}; auto const l1_size = static_cast(l1_offsets).size() - 1; - auto l1 = cudf::make_lists_column(l1_size, l1_offsets.release(), s1.release(), 0, {}); + auto l1 = cudf::make_lists_column(l1_size, + l1_offsets.release(), + s1.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); // perform the concatenate cudf::table_view t({*l0, *l1}); @@ -733,7 +741,11 @@ TEST_F(ListConcatenateRowsNestedTypesTest, Struct) cudf::test::structs_column_wrapper se(std::move(se_children)); cudf::test::fixed_width_column_wrapper le_offsets{0, 2, 6, 12, 21, 23}; auto const le_size = static_cast(le_offsets).size() - 1; - auto expected = cudf::make_lists_column(le_size, le_offsets.release(), se.release(), 0, {}); + auto expected = cudf::make_lists_column(le_size, + le_offsets.release(), + se.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); CUDF_TEST_EXPECT_COLUMNS_EQUAL(*result, *expected); } diff --git a/cpp/tests/lists/contains_tests.cpp b/cpp/tests/lists/contains_tests.cpp index 856b0e0dd6af..081018bc4230 100644 --- a/cpp/tests/lists/contains_tests.cpp +++ b/cpp/tests/lists/contains_tests.cpp @@ -287,8 +287,12 @@ TYPED_TEST(TypedContainsTest, ScalarKeyNonNullListsWithNullValues) auto numerals = cudf::test::fixed_width_column_wrapper{ {X, 1, 2, X, 4, 5, X, 7, 8, X, X, 1, 2, X, 1}, nulls_at({0, 3, 6, 9, 10, 13})}; - auto search_space = cudf::make_lists_column( - 8, indices_col{0, 1, 3, 7, 7, 7, 10, 11, 15}.release(), numerals.release(), 0, {}); + auto search_space = + cudf::make_lists_column(8, + indices_col{0, 1, 3, 7, 7, 7, 10, 11, 15}.release(), + numerals.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); // Search space: [ [x], [1,2], [x,4,5,x], [], [], [7,8,x], [x], [1,2,x,1] ] auto search_key_one = create_scalar_search_key(1); { @@ -619,8 +623,12 @@ TYPED_TEST(TypedVectorContainsTest, VectorNonNullListsWithNullValues) auto numerals = cudf::test::fixed_width_column_wrapper{ {X, 1, 2, X, 4, 5, X, 7, 8, X, X, 1, 2, X, 1}, nulls_at({0, 3, 6, 9, 10, 13})}; - auto search_space = cudf::make_lists_column( - 8, indices_col{0, 1, 3, 7, 7, 7, 10, 11, 15}.release(), numerals.release(), 0, {}); + auto search_space = + cudf::make_lists_column(8, + indices_col{0, 1, 3, 7, 7, 7, 10, 11, 15}.release(), + numerals.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); // Search space: [ [x], [1,2], [x,4,5,x], [], [], [7,8,x], [x], [1,2,x,1] ] auto search_keys = cudf::test::fixed_width_column_wrapper{1, 2, 3, 1, 2, 3, 1, 1}; { @@ -1007,7 +1015,11 @@ TYPED_TEST(TypedContainsDecimalsTest, ScalarKey) auto decimals = cudf::test::fixed_point_column_wrapper{ values.begin(), values.end(), numeric::scale_type{0}}; auto list_offsets = indices_col{0, 3, 6, 9, 12, 15, 18, 21, 21, 24, 24}; - return cudf::make_lists_column(10, list_offsets.release(), decimals.release(), 0, {}); + return cudf::make_lists_column(10, + list_offsets.release(), + decimals.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); }(); auto search_key_one = cudf::make_fixed_point_scalar(typename T::rep{1}, numeric::scale_type{0}); @@ -1043,7 +1055,11 @@ TYPED_TEST(TypedContainsDecimalsTest, VectorKey) auto decimals = cudf::test::fixed_point_column_wrapper{ values.begin(), values.end(), numeric::scale_type{0}}; auto list_offsets = indices_col{0, 3, 6, 9, 12, 15, 18, 21, 21, 24, 24}; - return cudf::make_lists_column(10, list_offsets.release(), decimals.release(), 0, {}); + return cudf::make_lists_column(10, + list_offsets.release(), + decimals.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); }(); auto search_key = @@ -1085,7 +1101,11 @@ TYPED_TEST(TypedStructContainsTest, EmptyInputTest) auto offsets = indices_col{}; auto data = tdata_col{}; auto child = cudf::test::structs_column_wrapper{{data}}; - return cudf::make_lists_column(0, offsets.release(), child.release(), 0, {}); + return cudf::make_lists_column(0, + offsets.release(), + child.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); }(); auto const scalar_key = [] { @@ -1131,7 +1151,11 @@ TYPED_TEST(TypedStructContainsTest, ScalarKeyNoNullLists) }; // clang-format on auto child = cudf::test::structs_column_wrapper{{data1, data2}}; - return cudf::make_lists_column(10, offsets.release(), child.release(), 0, {}); + return cudf::make_lists_column(10, + offsets.release(), + child.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); }(); auto const key = [] { @@ -1263,7 +1287,11 @@ TYPED_TEST(TypedStructContainsTest, SlicedListsColumnNoNulls) }; // clang-format on auto child = cudf::test::structs_column_wrapper{{data1, data2}}; - return cudf::make_lists_column(10, offsets.release(), child.release(), 0, {}); + return cudf::make_lists_column(10, + offsets.release(), + child.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); }(); auto const lists = cudf::slice(lists_original->view(), {3, 10})[0]; @@ -1326,7 +1354,11 @@ TYPED_TEST(TypedStructContainsTest, ScalarKeyNoNullListsWithNullStructs) }; // clang-format on auto child = cudf::test::structs_column_wrapper{{data1, data2}, nulls_at({1, 10, 15, 24})}; - return cudf::make_lists_column(10, offsets.release(), child.release(), 0, {}); + return cudf::make_lists_column(10, + offsets.release(), + child.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); }(); auto const key = [] { @@ -1390,7 +1422,11 @@ TYPED_TEST(TypedStructContainsTest, ColumnKeyNoNullLists) }; // clang-format on auto child = cudf::test::structs_column_wrapper{{data1, data2}}; - return cudf::make_lists_column(10, offsets.release(), child.release(), 0, {}); + return cudf::make_lists_column(10, + offsets.release(), + child.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); }(); auto const keys = [] { @@ -1448,7 +1484,11 @@ TYPED_TEST(TypedStructContainsTest, ColumnKeyWithSlicedListsNoNulls) }; // clang-format on auto child = cudf::test::structs_column_wrapper{{data1, data2}}; - return cudf::make_lists_column(10, offsets.release(), child.release(), 0, {}); + return cudf::make_lists_column(10, + offsets.release(), + child.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); }(); auto const keys_original = [] { @@ -1798,10 +1838,18 @@ TYPED_TEST(TypedListContainsTest, ColumnKeyWithListsOfStructsNoNulls) }; // clang-format on auto structs = cudf::test::structs_column_wrapper{{data1, data2}}; - auto child = cudf::make_lists_column(8, child_offsets.release(), structs.release(), 0, {}); + auto child = cudf::make_lists_column(8, + child_offsets.release(), + structs.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); auto offsets = indices_col{0, 4, 8}; - return cudf::make_lists_column(2, offsets.release(), std::move(child), 0, {}); + return cudf::make_lists_column(2, + offsets.release(), + std::move(child), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); }(); auto const key = [] { diff --git a/cpp/tests/lists/explode_tests.cpp b/cpp/tests/lists/explode_tests.cpp index 373ac65c85bc..4642bca40152 100644 --- a/cpp/tests/lists/explode_tests.cpp +++ b/cpp/tests/lists/explode_tests.cpp @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: Copyright (c) 2021-2026, NVIDIA CORPORATION. + * SPDX-FileCopyrightText: Copyright (c) 2021-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. * SPDX-License-Identifier: Apache-2.0 */ @@ -11,6 +11,7 @@ #include #include +#include using FCW = cudf::test::fixed_width_column_wrapper; using LCW = cudf::test::lists_column_wrapper; @@ -365,7 +366,8 @@ TEST_F(ExplodeTest, ListOfStructsWithEmpties) s0_cols.push_back(i0.release()); cudf::test::structs_column_wrapper s0(std::move(s0_cols)); cudf::test::fixed_width_column_wrapper off0{0, 1}; - auto row0 = cudf::make_lists_column(1, off0.release(), s0.release(), 0, rmm::device_buffer{}); + auto row0 = cudf::make_lists_column( + 1, off0.release(), s0.release(), 0, cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); // row 1. 1 struct that contains a null value cudf::test::fixed_width_column_wrapper i1{{1}, {false}}; @@ -373,7 +375,8 @@ TEST_F(ExplodeTest, ListOfStructsWithEmpties) s1_cols.push_back(i1.release()); cudf::test::structs_column_wrapper s1(std::move(s1_cols)); cudf::test::fixed_width_column_wrapper off1{0, 1}; - auto row1 = cudf::make_lists_column(1, off1.release(), s1.release(), 0, rmm::device_buffer{}); + auto row1 = cudf::make_lists_column( + 1, off1.release(), s1.release(), 0, cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); // row 2. 1 null struct cudf::test::fixed_width_column_wrapper i2{0}; @@ -384,21 +387,25 @@ TEST_F(ExplodeTest, ListOfStructsWithEmpties) cudf::test::detail::make_null_mask(r2_valids.begin(), r2_valids.end()); auto s2 = cudf::make_structs_column(1, std::move(s2_cols), null_count, std::move(null_mask)); cudf::test::fixed_width_column_wrapper off2{0, 1}; - auto row2 = cudf::make_lists_column(1, off2.release(), std::move(s2), 0, rmm::device_buffer{}); + auto row2 = cudf::make_lists_column( + 1, off2.release(), std::move(s2), 0, cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); // row 3. empty list. cudf::test::fixed_width_column_wrapper i3{}; std::vector> s3_cols; s3_cols.push_back(i3.release()); - auto s3 = cudf::make_structs_column(0, std::move(s3_cols), 0, rmm::device_buffer{}); + auto s3 = cudf::make_structs_column( + 0, std::move(s3_cols), 0, cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); cudf::test::fixed_width_column_wrapper off3{0, 0}; - auto row3 = cudf::make_lists_column(1, off3.release(), std::move(s3), 0, rmm::device_buffer{}); + auto row3 = cudf::make_lists_column( + 1, off3.release(), std::move(s3), 0, cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); // row 4. null list cudf::test::fixed_width_column_wrapper i4{}; std::vector> s4_cols; s4_cols.push_back(i4.release()); - auto s4 = cudf::make_structs_column(0, std::move(s4_cols), 0, rmm::device_buffer{}); + auto s4 = cudf::make_structs_column( + 0, std::move(s4_cols), 0, cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); cudf::test::fixed_width_column_wrapper off4{0, 0}; std::vector r4_valids{false}; std::tie(null_mask, null_count) = @@ -445,8 +452,11 @@ TYPED_TEST(ExplodeTypedTest, ListOfStructs) cudf::test::strings_column_wrapper string_col{ "70", "75", "50", "55", "35", "45", "25", "30", "15", "20"}; auto struct_col = cudf::test::structs_column_wrapper{{numeric_col, string_col}}.release(); - auto a = - cudf::make_lists_column(5, FCW{0, 2, 4, 6, 8, 10}.release(), std::move(struct_col), 0, {}); + auto a = cudf::make_lists_column(5, + FCW{0, 2, 4, 6, 8, 10}.release(), + std::move(struct_col), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); FCW b{100, 200, 300, 400, 500}; @@ -1003,7 +1013,8 @@ TEST_F(ExplodeOuterTest, ListOfStructsWithEmpties) s0_cols.push_back(i0.release()); cudf::test::structs_column_wrapper s0(std::move(s0_cols)); cudf::test::fixed_width_column_wrapper off0{0, 1}; - auto row0 = cudf::make_lists_column(1, off0.release(), s0.release(), 0, rmm::device_buffer{}); + auto row0 = cudf::make_lists_column( + 1, off0.release(), s0.release(), 0, cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); // row 1. 1 struct that contains a null value cudf::test::fixed_width_column_wrapper i1{{1}, {false}}; @@ -1011,7 +1022,8 @@ TEST_F(ExplodeOuterTest, ListOfStructsWithEmpties) s1_cols.push_back(i1.release()); cudf::test::structs_column_wrapper s1(std::move(s1_cols)); cudf::test::fixed_width_column_wrapper off1{0, 1}; - auto row1 = cudf::make_lists_column(1, off1.release(), s1.release(), 0, rmm::device_buffer{}); + auto row1 = cudf::make_lists_column( + 1, off1.release(), s1.release(), 0, cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); // row 2. 1 null struct cudf::test::fixed_width_column_wrapper i2{0}; @@ -1022,21 +1034,25 @@ TEST_F(ExplodeOuterTest, ListOfStructsWithEmpties) cudf::test::detail::make_null_mask(r2_valids.begin(), r2_valids.end()); auto s2 = cudf::make_structs_column(1, std::move(s2_cols), null_count, std::move(null_mask)); cudf::test::fixed_width_column_wrapper off2{0, 1}; - auto row2 = cudf::make_lists_column(1, off2.release(), std::move(s2), 0, rmm::device_buffer{}); + auto row2 = cudf::make_lists_column( + 1, off2.release(), std::move(s2), 0, cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); // row 3. empty list. cudf::test::fixed_width_column_wrapper i3{}; std::vector> s3_cols; s3_cols.push_back(i3.release()); - auto s3 = cudf::make_structs_column(0, std::move(s3_cols), 0, rmm::device_buffer{}); + auto s3 = cudf::make_structs_column( + 0, std::move(s3_cols), 0, cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); cudf::test::fixed_width_column_wrapper off3{0, 0}; - auto row3 = cudf::make_lists_column(1, off3.release(), std::move(s3), 0, rmm::device_buffer{}); + auto row3 = cudf::make_lists_column( + 1, off3.release(), std::move(s3), 0, cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); // row 4. null list cudf::test::fixed_width_column_wrapper i4{}; std::vector> s4_cols; s4_cols.push_back(i4.release()); - auto s4 = cudf::make_structs_column(0, std::move(s4_cols), 0, rmm::device_buffer{}); + auto s4 = cudf::make_structs_column( + 0, std::move(s4_cols), 0, cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); cudf::test::fixed_width_column_wrapper off4{0, 0}; std::vector r4_valids{false}; std::tie(null_mask, null_count) = @@ -1085,8 +1101,11 @@ TYPED_TEST(ExplodeOuterTypedTest, ListOfStructs) cudf::test::strings_column_wrapper string_col{ "70", "75", "50", "55", "35", "45", "25", "30", "15", "20"}; auto struct_col = cudf::test::structs_column_wrapper{{numeric_col, string_col}}.release(); - auto a = - cudf::make_lists_column(5, FCW{0, 2, 4, 6, 8, 10}.release(), std::move(struct_col), 0, {}); + auto a = cudf::make_lists_column(5, + FCW{0, 2, 4, 6, 8, 10}.release(), + std::move(struct_col), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); FCW b{100, 200, 300, 400, 500}; diff --git a/cpp/tests/lists/reverse_tests.cpp b/cpp/tests/lists/reverse_tests.cpp index e260b328b3ac..b0767f7c86de 100644 --- a/cpp/tests/lists/reverse_tests.cpp +++ b/cpp/tests/lists/reverse_tests.cpp @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: Copyright (c) 2022-2023, NVIDIA CORPORATION. + * SPDX-FileCopyrightText: Copyright (c) 2022-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. * SPDX-License-Identifier: Apache-2.0 */ @@ -154,7 +154,11 @@ TYPED_TEST(ListsReverseTypedTest, InputListsOfListsNoNulls) auto child = lists_col{{1, 2, 3}, {4, 5, 6}, {7}, {4, 5}, {}, {4, 5, 6}, {}, {6, 7, 8}, {}, {9}}.release(); auto offsets = ints_col{0, 0, 3, 3, 6, 9, 10, 10, 10}.release(); - return cudf::make_lists_column(8, std::move(offsets), std::move(child), 0, {}); + return cudf::make_lists_column(8, + std::move(offsets), + std::move(child), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); }(); { @@ -163,7 +167,11 @@ TYPED_TEST(ListsReverseTypedTest, InputListsOfListsNoNulls) lists_col{{7}, {4, 5, 6}, {1, 2, 3}, {4, 5, 6}, {}, {4, 5}, {}, {6, 7, 8}, {}, {9}} .release(); auto offsets = ints_col{0, 0, 3, 3, 6, 9, 10, 10, 10}.release(); - return cudf::make_lists_column(8, std::move(offsets), std::move(child), 0, {}); + return cudf::make_lists_column(8, + std::move(offsets), + std::move(child), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); }(); auto const results = cudf::lists::reverse(cudf::lists_column_view(*input_original)); CUDF_TEST_EXPECT_COLUMNS_EQUAL(*expected, *results); @@ -173,7 +181,11 @@ TYPED_TEST(ListsReverseTypedTest, InputListsOfListsNoNulls) auto const expected = [] { auto child = lists_col{{7}, {4, 5, 6}, {1, 2, 3}, {4, 5, 6}, {}, {4, 5}}.release(); auto offsets = ints_col{0, 3, 3, 6}.release(); - return cudf::make_lists_column(3, std::move(offsets), std::move(child), 0, {}); + return cudf::make_lists_column(3, + std::move(offsets), + std::move(child), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); }(); auto const input = cudf::slice(*input_original, {1, 4})[0]; auto const results = cudf::lists::reverse(cudf::lists_column_view(input)); @@ -190,7 +202,11 @@ TYPED_TEST(ListsReverseTypedTest, InputListsOfListsNoNulls) auto const expected = [] { auto child = lists_col{{4, 5, 6}, {}, {4, 5}}.release(); auto offsets = ints_col{0, 0, 3}.release(); - return cudf::make_lists_column(2, std::move(offsets), std::move(child), 0, {}); + return cudf::make_lists_column(2, + std::move(offsets), + std::move(child), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); }(); auto const input = cudf::slice(*input_original, {2, 4})[0]; auto const results = cudf::lists::reverse(cudf::lists_column_view(input)); @@ -216,7 +232,7 @@ TYPED_TEST(ListsReverseTypedTest, InputListsOfListsWithNulls) .release(); auto offsets = ints_col{0, 0, 3, 3, 6, 9, 10, 10, 10}.release(); auto null_mask = cudf::create_null_mask(8, cudf::mask_state::ALL_VALID); - cudf::set_null_mask(static_cast(null_mask.data()), 2, 3, false); + cudf::set_null_mask(reinterpret_cast(null_mask.data()), 2, 3, false); return cudf::make_lists_column( 8, std::move(offsets), std::move(child), 1, std::move(null_mask)); @@ -238,7 +254,7 @@ TYPED_TEST(ListsReverseTypedTest, InputListsOfListsWithNulls) .release(); auto offsets = ints_col{0, 0, 3, 3, 6, 9, 10, 10, 10}.release(); auto null_mask = cudf::create_null_mask(8, cudf::mask_state::ALL_VALID); - cudf::set_null_mask(static_cast(null_mask.data()), 2, 3, false); + cudf::set_null_mask(reinterpret_cast(null_mask.data()), 2, 3, false); return cudf::make_lists_column( 8, std::move(offsets), std::move(child), 1, std::move(null_mask)); @@ -251,7 +267,11 @@ TYPED_TEST(ListsReverseTypedTest, InputListsOfListsWithNulls) auto const expected = [] { auto child = lists_col{{7}, {4, 5, 6}, {1, 2, 3}}.release(); auto offsets = ints_col{0, 3}.release(); - return cudf::make_lists_column(1, std::move(offsets), std::move(child), 0, {}); + return cudf::make_lists_column(1, + std::move(offsets), + std::move(child), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); }(); auto const input = cudf::slice(*input_original, {0, 1})[0]; auto const results = cudf::lists::reverse(cudf::lists_column_view(input)); @@ -265,7 +285,7 @@ TYPED_TEST(ListsReverseTypedTest, InputListsOfListsWithNulls) .release(); auto offsets = ints_col{0, 3, 3, 6}.release(); auto null_mask = cudf::create_null_mask(3, cudf::mask_state::ALL_VALID); - cudf::set_null_mask(static_cast(null_mask.data()), 1, 2, false); + cudf::set_null_mask(reinterpret_cast(null_mask.data()), 1, 2, false); return cudf::make_lists_column( 3, std::move(offsets), std::move(child), 1, std::move(null_mask)); @@ -280,7 +300,7 @@ TYPED_TEST(ListsReverseTypedTest, InputListsOfListsWithNulls) auto child = lists_col{{{4, 5, 6}, {} /*null*/, {4, 5}}, null_at(1)}.release(); auto offsets = ints_col{0, 0, 3}.release(); auto null_mask = cudf::create_null_mask(2, cudf::mask_state::ALL_VALID); - cudf::set_null_mask(static_cast(null_mask.data()), 0, 1, false); + cudf::set_null_mask(reinterpret_cast(null_mask.data()), 0, 1, false); return cudf::make_lists_column( 2, std::move(offsets), std::move(child), 1, std::move(null_mask)); @@ -338,8 +358,8 @@ TYPED_TEST(ListsReverseTypedTest, InputListsOfStructsWithNulls) }(); auto offsets = ints_col{0, 0, 8, 16, 16, 16, 24}.release(); auto null_mask = cudf::create_null_mask(6, cudf::mask_state::ALL_VALID); - cudf::set_null_mask(static_cast(null_mask.data()), 0, 1, false); - cudf::set_null_mask(static_cast(null_mask.data()), 4, 5, false); + cudf::set_null_mask(reinterpret_cast(null_mask.data()), 0, 1, false); + cudf::set_null_mask(reinterpret_cast(null_mask.data()), 4, 5, false); return cudf::make_lists_column( 6, std::move(offsets), std::move(child), 2, std::move(null_mask)); @@ -388,8 +408,8 @@ TYPED_TEST(ListsReverseTypedTest, InputListsOfStructsWithNulls) }(); auto offsets = ints_col{0, 0, 8, 16, 16, 16, 24}.release(); auto null_mask = cudf::create_null_mask(6, cudf::mask_state::ALL_VALID); - cudf::set_null_mask(static_cast(null_mask.data()), 0, 1, false); - cudf::set_null_mask(static_cast(null_mask.data()), 4, 5, false); + cudf::set_null_mask(reinterpret_cast(null_mask.data()), 0, 1, false); + cudf::set_null_mask(reinterpret_cast(null_mask.data()), 4, 5, false); return cudf::make_lists_column( 6, std::move(offsets), std::move(child), 2, std::move(null_mask)); @@ -445,7 +465,11 @@ TYPED_TEST(ListsReverseTypedTest, InputListsOfStructsWithNulls) }(); auto offsets = ints_col{0, 8, 16, 16}.release(); - return cudf::make_lists_column(3, std::move(offsets), std::move(child), 0, {}); + return cudf::make_lists_column(3, + std::move(offsets), + std::move(child), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); }(); auto const input = cudf::slice(*input_original, {1, 4})[0]; auto const results = cudf::lists::reverse(cudf::lists_column_view(input)); diff --git a/cpp/tests/lists/set_operations/difference_distinct_tests.cpp b/cpp/tests/lists/set_operations/difference_distinct_tests.cpp index 425978615f9a..d9a284be3035 100644 --- a/cpp/tests/lists/set_operations/difference_distinct_tests.cpp +++ b/cpp/tests/lists/set_operations/difference_distinct_tests.cpp @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: Copyright (c) 2022-2023, NVIDIA CORPORATION. + * SPDX-FileCopyrightText: Copyright (c) 2022-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. * SPDX-License-Identifier: Apache-2.0 */ @@ -536,12 +536,24 @@ TEST_F(SetDifferenceTest, InputListsOfNestedStructsHaveNull) return structs_col{{child1}}; }; - auto const lhs = cudf::make_lists_column( - 3, int32s_col{0, 8, 16, 24}.release(), get_structs_lhs().release(), 0, {}); - auto const rhs = cudf::make_lists_column( - 3, int32s_col{0, 8, 16, 24}.release(), get_structs_rhs().release(), 0, {}); - auto const expected = cudf::make_lists_column( - 3, int32s_col{0, 3, 8, 14}.release(), get_structs_expected().release(), 0, {}); + auto const lhs = + cudf::make_lists_column(3, + int32s_col{0, 8, 16, 24}.release(), + get_structs_lhs().release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); + auto const rhs = + cudf::make_lists_column(3, + int32s_col{0, 8, 16, 24}.release(), + get_structs_rhs().release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); + auto const expected = + cudf::make_lists_column(3, + int32s_col{0, 3, 8, 14}.release(), + get_structs_expected().release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); auto const results_sorted = set_difference_sorted(*lhs, *rhs, NULL_EQUAL); CUDF_TEST_EXPECT_COLUMNS_EQUIVALENT(*expected, *results_sorted); @@ -570,12 +582,24 @@ TEST_F(SetDifferenceTest, InputListsOfNestedStructsHaveNull) return structs_col{{child1}}; }; - auto const lhs = cudf::make_lists_column( - 3, int32s_col{0, 8, 16, 24}.release(), get_structs_lhs().release(), 0, {}); - auto const rhs = cudf::make_lists_column( - 3, int32s_col{0, 8, 16, 24}.release(), get_structs_rhs().release(), 0, {}); - auto const expected = cudf::make_lists_column( - 3, int32s_col{0, 7, 13, 21}.release(), get_structs_expected().release(), 0, {}); + auto const lhs = + cudf::make_lists_column(3, + int32s_col{0, 8, 16, 24}.release(), + get_structs_lhs().release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); + auto const rhs = + cudf::make_lists_column(3, + int32s_col{0, 8, 16, 24}.release(), + get_structs_rhs().release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); + auto const expected = + cudf::make_lists_column(3, + int32s_col{0, 7, 13, 21}.release(), + get_structs_expected().release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); auto const results_sorted = set_difference_sorted(*lhs, *rhs, NULL_UNEQUAL); CUDF_TEST_EXPECT_COLUMNS_EQUAL(*expected, *results_sorted); @@ -609,8 +633,11 @@ TEST_F(SetDifferenceTest, InputListsOfStructsOfLists) return structs_col{{child1, child2}}; }; - return cudf::make_lists_column( - 3, int32s_col{0, 3, 4, 7}.release(), get_structs().release(), 0, {}); + return cudf::make_lists_column(3, + int32s_col{0, 3, 4, 7}.release(), + get_structs().release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); }(); auto const rhs = [] { @@ -638,8 +665,11 @@ TEST_F(SetDifferenceTest, InputListsOfStructsOfLists) return structs_col{{child1, child2}}; }; - return cudf::make_lists_column( - 3, int32s_col{0, 3, 4, 7}.release(), get_structs().release(), 0, {}); + return cudf::make_lists_column(3, + int32s_col{0, 3, 4, 7}.release(), + get_structs().release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); }(); auto const expected = [] { @@ -650,8 +680,11 @@ TEST_F(SetDifferenceTest, InputListsOfStructsOfLists) return structs_col{{child1, child2}}; }; - return cudf::make_lists_column( - 3, int32s_col{0, 2, 2, 4}.release(), get_structs().release(), 0, {}); + return cudf::make_lists_column(3, + int32s_col{0, 2, 2, 4}.release(), + get_structs().release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); }(); auto const results = cudf::lists::difference_distinct(lists_cv{*lhs}, lists_cv{*rhs}); diff --git a/cpp/tests/lists/set_operations/have_overlap_tests.cpp b/cpp/tests/lists/set_operations/have_overlap_tests.cpp index 74a687c7375f..cdd469ce4668 100644 --- a/cpp/tests/lists/set_operations/have_overlap_tests.cpp +++ b/cpp/tests/lists/set_operations/have_overlap_tests.cpp @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: Copyright (c) 2022-2023, NVIDIA CORPORATION. + * SPDX-FileCopyrightText: Copyright (c) 2022-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. * SPDX-License-Identifier: Apache-2.0 */ @@ -450,10 +450,18 @@ TEST_F(ListOverlapTest, InputListsOfNestedStructsHaveNull) // Nulls are equal. { - auto const lhs = cudf::make_lists_column( - 3, int32s_col{0, 8, 16, 24}.release(), get_structs_lhs().release(), 0, {}); - auto const rhs = cudf::make_lists_column( - 3, int32s_col{0, 8, 16, 24}.release(), get_structs_rhs().release(), 0, {}); + auto const lhs = + cudf::make_lists_column(3, + int32s_col{0, 8, 16, 24}.release(), + get_structs_lhs().release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); + auto const rhs = + cudf::make_lists_column(3, + int32s_col{0, 8, 16, 24}.release(), + get_structs_rhs().release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); auto const expected = bools_col{1, 1, 1}; auto const results = cudf::lists::have_overlap(lists_cv{*lhs}, lists_cv{*rhs}, NULL_EQUAL); @@ -462,10 +470,18 @@ TEST_F(ListOverlapTest, InputListsOfNestedStructsHaveNull) // Nulls are unequal. { - auto const lhs = cudf::make_lists_column( - 3, int32s_col{0, 8, 16, 24}.release(), get_structs_lhs().release(), 0, {}); - auto const rhs = cudf::make_lists_column( - 3, int32s_col{0, 8, 16, 24}.release(), get_structs_rhs().release(), 0, {}); + auto const lhs = + cudf::make_lists_column(3, + int32s_col{0, 8, 16, 24}.release(), + get_structs_lhs().release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); + auto const rhs = + cudf::make_lists_column(3, + int32s_col{0, 8, 16, 24}.release(), + get_structs_rhs().release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); auto const expected = bools_col{0, 0, 0}; auto const results = cudf::lists::have_overlap(lists_cv{*lhs}, lists_cv{*rhs}, NULL_UNEQUAL); @@ -500,8 +516,11 @@ TEST_F(ListOverlapTest, InputListsOfStructsOfLists) return structs_col{{child1, child2}}; }; - return cudf::make_lists_column( - 3, int32s_col{0, 3, 4, 7}.release(), get_structs().release(), 0, {}); + return cudf::make_lists_column(3, + int32s_col{0, 3, 4, 7}.release(), + get_structs().release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); }(); auto const rhs = [] { @@ -529,8 +548,11 @@ TEST_F(ListOverlapTest, InputListsOfStructsOfLists) return structs_col{{child1, child2}}; }; - return cudf::make_lists_column( - 3, int32s_col{0, 3, 4, 7}.release(), get_structs().release(), 0, {}); + return cudf::make_lists_column(3, + int32s_col{0, 3, 4, 7}.release(), + get_structs().release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); }(); auto const expected = bools_col{0, 1, 1}; diff --git a/cpp/tests/lists/set_operations/intersect_distinct_tests.cpp b/cpp/tests/lists/set_operations/intersect_distinct_tests.cpp index 74462f21320e..571d78c03d9f 100644 --- a/cpp/tests/lists/set_operations/intersect_distinct_tests.cpp +++ b/cpp/tests/lists/set_operations/intersect_distinct_tests.cpp @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: Copyright (c) 2022-2023, NVIDIA CORPORATION. + * SPDX-FileCopyrightText: Copyright (c) 2022-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. * SPDX-License-Identifier: Apache-2.0 */ @@ -518,12 +518,24 @@ TEST_F(SetIntersectTest, InputListsOfNestedStructsHaveNull) return structs_col{{child1}}; }; - auto const lhs = cudf::make_lists_column( - 3, int32s_col{0, 8, 16, 24}.release(), get_structs_lhs().release(), 0, {}); - auto const rhs = cudf::make_lists_column( - 3, int32s_col{0, 8, 16, 24}.release(), get_structs_rhs().release(), 0, {}); - auto const expected = cudf::make_lists_column( - 3, int32s_col{0, 2, 3, 5}.release(), get_structs_expected().release(), 0, {}); + auto const lhs = + cudf::make_lists_column(3, + int32s_col{0, 8, 16, 24}.release(), + get_structs_lhs().release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); + auto const rhs = + cudf::make_lists_column(3, + int32s_col{0, 8, 16, 24}.release(), + get_structs_rhs().release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); + auto const expected = + cudf::make_lists_column(3, + int32s_col{0, 2, 3, 5}.release(), + get_structs_expected().release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); auto const results_sorted = set_intersect_sorted(*lhs, *rhs, NULL_EQUAL); CUDF_TEST_EXPECT_COLUMNS_EQUIVALENT(*expected, *results_sorted); @@ -538,12 +550,24 @@ TEST_F(SetIntersectTest, InputListsOfNestedStructsHaveNull) return structs_col{{child1}}; }; - auto const lhs = cudf::make_lists_column( - 3, int32s_col{0, 8, 16, 24}.release(), get_structs_lhs().release(), 0, {}); - auto const rhs = cudf::make_lists_column( - 3, int32s_col{0, 8, 16, 24}.release(), get_structs_rhs().release(), 0, {}); - auto const expected = cudf::make_lists_column( - 3, int32s_col{0, 0, 0, 0}.release(), get_structs_expected().release(), 0, {}); + auto const lhs = + cudf::make_lists_column(3, + int32s_col{0, 8, 16, 24}.release(), + get_structs_lhs().release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); + auto const rhs = + cudf::make_lists_column(3, + int32s_col{0, 8, 16, 24}.release(), + get_structs_rhs().release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); + auto const expected = + cudf::make_lists_column(3, + int32s_col{0, 0, 0, 0}.release(), + get_structs_expected().release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); auto const results_sorted = set_intersect_sorted(*lhs, *rhs, NULL_UNEQUAL); CUDF_TEST_EXPECT_COLUMNS_EQUAL(*expected, *results_sorted); @@ -577,8 +601,11 @@ TEST_F(SetIntersectTest, InputListsOfStructsOfLists) return structs_col{{child1, child2}}; }; - return cudf::make_lists_column( - 3, int32s_col{0, 3, 4, 7}.release(), get_structs().release(), 0, {}); + return cudf::make_lists_column(3, + int32s_col{0, 3, 4, 7}.release(), + get_structs().release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); }(); auto const rhs = [] { @@ -606,8 +633,11 @@ TEST_F(SetIntersectTest, InputListsOfStructsOfLists) return structs_col{{child1, child2}}; }; - return cudf::make_lists_column( - 3, int32s_col{0, 3, 4, 7}.release(), get_structs().release(), 0, {}); + return cudf::make_lists_column(3, + int32s_col{0, 3, 4, 7}.release(), + get_structs().release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); }(); auto const expected = [] { @@ -617,8 +647,11 @@ TEST_F(SetIntersectTest, InputListsOfStructsOfLists) return structs_col{{child1, child2}}; }; - return cudf::make_lists_column( - 3, int32s_col{0, 1, 2, 3}.release(), get_structs().release(), 0, {}); + return cudf::make_lists_column(3, + int32s_col{0, 1, 2, 3}.release(), + get_structs().release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); }(); auto const results = cudf::lists::intersect_distinct(lists_cv{*lhs}, lists_cv{*rhs}); diff --git a/cpp/tests/lists/set_operations/union_distinct_tests.cpp b/cpp/tests/lists/set_operations/union_distinct_tests.cpp index 51ba65453f12..170183536735 100644 --- a/cpp/tests/lists/set_operations/union_distinct_tests.cpp +++ b/cpp/tests/lists/set_operations/union_distinct_tests.cpp @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: Copyright (c) 2022-2023, NVIDIA CORPORATION. + * SPDX-FileCopyrightText: Copyright (c) 2022-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. * SPDX-License-Identifier: Apache-2.0 */ @@ -561,12 +561,24 @@ TEST_F(SetUnionTest, InputListsOfNestedStructsHaveNull) return structs_col{{child1}}; }; - auto const lhs = cudf::make_lists_column( - 3, int32s_col{0, 8, 16, 24}.release(), get_structs_lhs().release(), 0, {}); - auto const rhs = cudf::make_lists_column( - 3, int32s_col{0, 8, 16, 24}.release(), get_structs_rhs().release(), 0, {}); - auto const expected = cudf::make_lists_column( - 3, int32s_col{0, 8, 19, 32}.release(), get_structs_expected().release(), 0, {}); + auto const lhs = + cudf::make_lists_column(3, + int32s_col{0, 8, 16, 24}.release(), + get_structs_lhs().release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); + auto const rhs = + cudf::make_lists_column(3, + int32s_col{0, 8, 16, 24}.release(), + get_structs_rhs().release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); + auto const expected = + cudf::make_lists_column(3, + int32s_col{0, 8, 19, 32}.release(), + get_structs_expected().release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); auto const results_sorted = set_union_sorted(*lhs, *rhs, NULL_EQUAL); CUDF_TEST_EXPECT_COLUMNS_EQUIVALENT(*expected, *results_sorted); @@ -598,12 +610,24 @@ TEST_F(SetUnionTest, InputListsOfNestedStructsHaveNull) return structs_col{{child1}}; }; - auto const lhs = cudf::make_lists_column( - 3, int32s_col{0, 8, 16, 24}.release(), get_structs_lhs().release(), 0, {}); - auto const rhs = cudf::make_lists_column( - 3, int32s_col{0, 8, 16, 24}.release(), get_structs_rhs().release(), 0, {}); - auto const expected = cudf::make_lists_column( - 3, int32s_col{0, 14, 26, 41}.release(), get_structs_expected().release(), 0, {}); + auto const lhs = + cudf::make_lists_column(3, + int32s_col{0, 8, 16, 24}.release(), + get_structs_lhs().release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); + auto const rhs = + cudf::make_lists_column(3, + int32s_col{0, 8, 16, 24}.release(), + get_structs_rhs().release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); + auto const expected = + cudf::make_lists_column(3, + int32s_col{0, 14, 26, 41}.release(), + get_structs_expected().release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); auto const results_sorted = set_union_sorted(*lhs, *rhs, NULL_UNEQUAL); CUDF_TEST_EXPECT_COLUMNS_EQUAL(*expected, *results_sorted); diff --git a/cpp/tests/lists/sort_lists_tests.cpp b/cpp/tests/lists/sort_lists_tests.cpp index 3bad25dbd668..741d55920f3e 100644 --- a/cpp/tests/lists/sort_lists_tests.cpp +++ b/cpp/tests/lists/sort_lists_tests.cpp @@ -209,17 +209,33 @@ TEST_F(SortListsInt, ListOfStructElement) cudf::test::fixed_width_column_wrapper in_f1{30, 10}; cudf::test::structs_column_wrapper in_structs{{in_f0, in_f1}}; cudf::test::fixed_width_column_wrapper in_inner_off{0, 1, 2}; - auto in_inner = cudf::make_lists_column(2, in_inner_off.release(), in_structs.release(), 0, {}); + auto in_inner = cudf::make_lists_column(2, + in_inner_off.release(), + in_structs.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); cudf::test::fixed_width_column_wrapper in_outer_off{0, 2}; - auto in_outer = cudf::make_lists_column(1, in_outer_off.release(), std::move(in_inner), 0, {}); + auto in_outer = cudf::make_lists_column(1, + in_outer_off.release(), + std::move(in_inner), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); cudf::test::fixed_width_column_wrapper ex_f0{1, 3}; cudf::test::fixed_width_column_wrapper ex_f1{10, 30}; cudf::test::structs_column_wrapper ex_structs{{ex_f0, ex_f1}}; cudf::test::fixed_width_column_wrapper ex_inner_off{0, 1, 2}; - auto ex_inner = cudf::make_lists_column(2, ex_inner_off.release(), ex_structs.release(), 0, {}); + auto ex_inner = cudf::make_lists_column(2, + ex_inner_off.release(), + ex_structs.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); cudf::test::fixed_width_column_wrapper ex_outer_off{0, 2}; - auto ex_outer = cudf::make_lists_column(1, ex_outer_off.release(), std::move(ex_inner), 0, {}); + auto ex_outer = cudf::make_lists_column(1, + ex_outer_off.release(), + std::move(ex_inner), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); auto const [sorted_lists, stable_sorted_lists] = generate_sorted_lists(cudf::lists_column_view{in_outer->view()}, {}, {}); @@ -236,13 +252,21 @@ TEST_F(SortListsInt, StructOfListElement) cudf::test::lists_column_wrapper in_f1{{9, 0}, {8, 7}}; cudf::test::structs_column_wrapper in_structs{{in_f0, in_f1}}; cudf::test::fixed_width_column_wrapper in_off{0, 2}; - auto in_list = cudf::make_lists_column(1, in_off.release(), in_structs.release(), 0, {}); + auto in_list = cudf::make_lists_column(1, + in_off.release(), + in_structs.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); cudf::test::fixed_width_column_wrapper ex_f0{1, 2}; cudf::test::lists_column_wrapper ex_f1{{8, 7}, {9, 0}}; cudf::test::structs_column_wrapper ex_structs{{ex_f0, ex_f1}}; cudf::test::fixed_width_column_wrapper ex_off{0, 2}; - auto ex_list = cudf::make_lists_column(1, ex_off.release(), ex_structs.release(), 0, {}); + auto ex_list = cudf::make_lists_column(1, + ex_off.release(), + ex_structs.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); auto const [sorted_lists, stable_sorted_lists] = generate_sorted_lists(cudf::lists_column_view{in_list->view()}, {}, {}); diff --git a/cpp/tests/lists/stream_compaction/apply_mask_tests.cpp b/cpp/tests/lists/stream_compaction/apply_mask_tests.cpp index 5facca374465..362846c9d64a 100644 --- a/cpp/tests/lists/stream_compaction/apply_mask_tests.cpp +++ b/cpp/tests/lists/stream_compaction/apply_mask_tests.cpp @@ -199,10 +199,13 @@ TYPED_TEST(ApplyRetentionMaskTypedTest, NullsInBooleanMask) // mask offsets: {0, 3, 5, 9} // kept (valid AND true): {10, 30}, {}, {80} auto mask_child = fwcw{{1, X, 1, 0, X, X, 0, 1, 0}, nulls_at({1, 4, 5})}; - auto mask = - cudf::make_lists_column(3, offsets{0, 3, 5, 9}.release(), mask_child.release(), 0, {}); - auto filtered = apply_retention_mask(lists_column_view{input}, lists_column_view{*mask}); - auto expected = lists{{10, 30}, lists{}, {80}}; + auto mask = cudf::make_lists_column(3, + offsets{0, 3, 5, 9}.release(), + mask_child.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); + auto filtered = apply_retention_mask(lists_column_view{input}, lists_column_view{*mask}); + auto expected = lists{{10, 30}, lists{}, {80}}; CUDF_TEST_EXPECT_COLUMNS_EQUAL(*filtered, expected); } @@ -360,10 +363,13 @@ TYPED_TEST(ApplyDeletionMaskTypedTest, NullsInDeletionMask) // mask offsets: {0, 3, 5, 9} // kept (valid AND false): {}, {40}, {70, 90} auto mask_child = fwcw{{1, X, 1, 0, X, X, 0, 1, 0}, nulls_at({1, 4, 5})}; - auto mask = - cudf::make_lists_column(3, offsets{0, 3, 5, 9}.release(), mask_child.release(), 0, {}); - auto filtered = apply_deletion_mask(lists_column_view{input}, lists_column_view{*mask}); - auto expected = lists{lists{}, {40}, {70, 90}}; + auto mask = cudf::make_lists_column(3, + offsets{0, 3, 5, 9}.release(), + mask_child.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); + auto filtered = apply_deletion_mask(lists_column_view{input}, lists_column_view{*mask}); + auto expected = lists{lists{}, {40}, {70, 90}}; CUDF_TEST_EXPECT_COLUMNS_EQUAL(*filtered, expected); } diff --git a/cpp/tests/lists/stream_compaction/distinct_tests.cpp b/cpp/tests/lists/stream_compaction/distinct_tests.cpp index f7b1c12562b2..5c41f0591047 100644 --- a/cpp/tests/lists/stream_compaction/distinct_tests.cpp +++ b/cpp/tests/lists/stream_compaction/distinct_tests.cpp @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: Copyright (c) 2022-2023, NVIDIA CORPORATION. + * SPDX-FileCopyrightText: Copyright (c) 2022-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. * SPDX-License-Identifier: Apache-2.0 */ @@ -430,10 +430,18 @@ TEST_F(ListDistinctTest, InputListsOfStructsNoNull) // Test full columns. { - auto const input = cudf::make_lists_column( - 3, int32s_col{0, 8, 16, 24}.release(), get_structs().release(), 0, {}); - auto const expected = cudf::make_lists_column( - 3, int32s_col{0, 5, 11, 17}.release(), get_expected().release(), 0, {}); + auto const input = + cudf::make_lists_column(3, + int32s_col{0, 8, 16, 24}.release(), + get_structs().release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); + auto const expected = + cudf::make_lists_column(3, + int32s_col{0, 5, 11, 17}.release(), + get_expected().release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); auto const results_sorted = distinct_sorted(*input); CUDF_TEST_EXPECT_COLUMNS_EQUAL(*expected, *results_sorted); @@ -441,10 +449,18 @@ TEST_F(ListDistinctTest, InputListsOfStructsNoNull) // Test sliced columns. { - auto const input_original = cudf::make_lists_column( - 3, int32s_col{0, 8, 16, 24}.release(), get_structs().release(), 0, {}); - auto const expected_original = cudf::make_lists_column( - 3, int32s_col{0, 5, 11, 17}.release(), get_expected().release(), 0, {}); + auto const input_original = + cudf::make_lists_column(3, + int32s_col{0, 8, 16, 24}.release(), + get_structs().release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); + auto const expected_original = + cudf::make_lists_column(3, + int32s_col{0, 5, 11, 17}.release(), + get_expected().release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); auto const input = cudf::slice(*input_original, {1, 3})[0]; auto const expected = cudf::slice(*expected_original, {1, 3})[0]; @@ -549,10 +565,18 @@ TEST_F(ListDistinctTest, InputListsOfStructsHaveNull) // Test full columns. { - auto const input = cudf::make_lists_column( - 3, int32s_col{0, 8, 16, 24}.release(), get_structs().release(), 0, {}); - auto const expected = cudf::make_lists_column( - 3, int32s_col{0, 6, 12, 20}.release(), get_expected().release(), 0, {}); + auto const input = + cudf::make_lists_column(3, + int32s_col{0, 8, 16, 24}.release(), + get_structs().release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); + auto const expected = + cudf::make_lists_column(3, + int32s_col{0, 6, 12, 20}.release(), + get_expected().release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); auto const results_sorted = distinct_sorted(*input); CUDF_TEST_EXPECT_COLUMNS_EQUAL(*expected, *results_sorted); @@ -560,10 +584,18 @@ TEST_F(ListDistinctTest, InputListsOfStructsHaveNull) // Test sliced columns. { - auto const input_original = cudf::make_lists_column( - 3, int32s_col{0, 8, 16, 24}.release(), get_structs().release(), 0, {}); - auto const expected_original = cudf::make_lists_column( - 3, int32s_col{0, 6, 12, 20}.release(), get_expected().release(), 0, {}); + auto const input_original = + cudf::make_lists_column(3, + int32s_col{0, 8, 16, 24}.release(), + get_structs().release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); + auto const expected_original = + cudf::make_lists_column(3, + int32s_col{0, 6, 12, 20}.release(), + get_expected().release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); auto const input = cudf::slice(*input_original, {1, 3})[0]; auto const expected = cudf::slice(*expected_original, {1, 3})[0]; @@ -670,10 +702,18 @@ TEST_F(ListDistinctTest, InputListsOfNestedStructsHaveNull) // Test full columns. { - auto const input = cudf::make_lists_column( - 3, int32s_col{0, 8, 16, 24}.release(), get_structs().release(), 0, {}); - auto const expected = cudf::make_lists_column( - 3, int32s_col{0, 5, 11, 19}.release(), get_expected().release(), 0, {}); + auto const input = + cudf::make_lists_column(3, + int32s_col{0, 8, 16, 24}.release(), + get_structs().release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); + auto const expected = + cudf::make_lists_column(3, + int32s_col{0, 5, 11, 19}.release(), + get_expected().release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); auto const results_sorted = distinct_sorted(*input); CUDF_TEST_EXPECT_COLUMNS_EQUAL(*expected, *results_sorted); @@ -681,10 +721,18 @@ TEST_F(ListDistinctTest, InputListsOfNestedStructsHaveNull) // Test sliced columns. { - auto const input_original = cudf::make_lists_column( - 3, int32s_col{0, 8, 16, 24}.release(), get_structs().release(), 0, {}); - auto const expected_original = cudf::make_lists_column( - 3, int32s_col{0, 5, 11, 19}.release(), get_expected().release(), 0, {}); + auto const input_original = + cudf::make_lists_column(3, + int32s_col{0, 8, 16, 24}.release(), + get_structs().release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); + auto const expected_original = + cudf::make_lists_column(3, + int32s_col{0, 5, 11, 19}.release(), + get_expected().release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); auto const input = cudf::slice(*input_original, {1, 3})[0]; auto const expected = cudf::slice(*expected_original, {1, 3})[0]; @@ -726,8 +774,11 @@ TEST_F(ListDistinctTest, InputListsOfStructsOfLists) return structs_col{{child1, child2}}; }; - return cudf::make_lists_column( - 4, int32s_col{0, 3, 4, 6, 9}.release(), get_structs().release(), 0, {}); + return cudf::make_lists_column(4, + int32s_col{0, 3, 4, 6, 9}.release(), + get_structs().release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); }(); auto const expected = [] { @@ -738,8 +789,11 @@ TEST_F(ListDistinctTest, InputListsOfStructsOfLists) return structs_col{{child1, child2}}; }; - return cudf::make_lists_column( - 4, int32s_col{0, 1, 2, 3, 4}.release(), get_structs().release(), 0, {}); + return cudf::make_lists_column(4, + int32s_col{0, 1, 2, 3, 4}.release(), + get_structs().release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); }(); auto const results = cudf::lists::distinct(lists_cv{*input}); diff --git a/cpp/tests/merge/merge_test.cpp b/cpp/tests/merge/merge_test.cpp index 0302846ec96e..46c06da71997 100644 --- a/cpp/tests/merge/merge_test.cpp +++ b/cpp/tests/merge/merge_test.cpp @@ -14,6 +14,7 @@ #include #include +#include #include #include #include @@ -913,7 +914,7 @@ TEST_F(MergeTest, NestedListsofStructs) cudf::test::fixed_width_column_wrapper{0, 3, 4, 6, 7}.release(), get_structs().release(), 0, - {}); + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); }(); // [ {4} ] @@ -930,7 +931,7 @@ TEST_F(MergeTest, NestedListsofStructs) cudf::test::fixed_width_column_wrapper{0, 1, 2, 3, 4}.release(), get_structs().release(), 0, - {}); + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); }(); auto tbl1 = cudf::table_view{{*col1}}; @@ -957,7 +958,7 @@ TEST_F(MergeTest, NestedListsofStructs) cudf::test::fixed_width_column_wrapper{0, 3, 4, 5, 6, 8, 9, 10, 11}.release(), get_structs().release(), 0, - {}); + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); }(); auto expected_tbl = cudf::table_view{{*expected_col}}; diff --git a/cpp/tests/partitioning/partition_test.cpp b/cpp/tests/partitioning/partition_test.cpp index 1655373280dd..824331513fd3 100644 --- a/cpp/tests/partitioning/partition_test.cpp +++ b/cpp/tests/partitioning/partition_test.cpp @@ -297,7 +297,11 @@ TEST_F(PartitionTestNotTyped, ListOfListOfIntEmpty) fixed_width_column_wrapper level_1_offsets{0, 0, 0}; std::unique_ptr level_1_list = - cudf::make_lists_column(2, level_1_offsets.release(), level_2_list.release(), 0, {}); + cudf::make_lists_column(2, + level_1_offsets.release(), + level_2_list.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); auto table_to_partition = cudf::table_view{{*level_1_list}}; fixed_width_column_wrapper map{0, 0}; @@ -313,11 +317,19 @@ TEST_F(PartitionTestNotTyped, ListOfListOfListOfIntEmpty) fixed_width_column_wrapper level_2_offsets{}; std::unique_ptr level_2_list = - cudf::make_lists_column(0, level_2_offsets.release(), level_3_list.release(), 0, {}); + cudf::make_lists_column(0, + level_2_offsets.release(), + level_3_list.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); fixed_width_column_wrapper level_1_offsets{0, 0}; std::unique_ptr level_1_list = - cudf::make_lists_column(1, level_1_offsets.release(), std::move(level_2_list), 0, {}); + cudf::make_lists_column(1, + level_1_offsets.release(), + std::move(level_2_list), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); auto table_to_partition = cudf::table_view{{*level_1_list}}; fixed_width_column_wrapper map{0}; diff --git a/cpp/tests/quantiles/percentile_approx_test.cpp b/cpp/tests/quantiles/percentile_approx_test.cpp index 9d51b0ed7b29..c385a3b9e10b 100644 --- a/cpp/tests/quantiles/percentile_approx_test.cpp +++ b/cpp/tests/quantiles/percentile_approx_test.cpp @@ -134,7 +134,10 @@ void percentile_approx_test(cudf::column_view const& _keys, tbl.begin(), tbl.end(), std::back_inserter(cols), [](cudf::column_view const& col) { return std::make_unique(col); }); - return cudf::make_structs_column(tbl.num_rows(), std::move(cols), 0, rmm::device_buffer()); + return cudf::make_structs_column(tbl.num_rows(), + std::move(cols), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); }; // groupby path reduce_parts.push_back(cudf::type_dispatcher(values[v_idx].type(), @@ -224,7 +227,8 @@ void grouped_test(cudf::data_type input_type, std::vector> p }); } -std::pair make_null_mask(cudf::column_view const& col) +std::pair, cudf::size_type> make_null_mask( + cudf::column_view const& col) { auto itr = cudf::test::iterators::valids_at_multiples_of(2); return cudf::test::detail::make_null_mask(itr, itr + col.size()); diff --git a/cpp/tests/reductions/approx_distinct_count_tests.cpp b/cpp/tests/reductions/approx_distinct_count_tests.cpp index effbcfe0e412..38a2072e9d16 100644 --- a/cpp/tests/reductions/approx_distinct_count_tests.cpp +++ b/cpp/tests/reductions/approx_distinct_count_tests.cpp @@ -695,8 +695,12 @@ TEST_F(ApproxDistinctCount, ListColumn) cudf::test::fixed_width_column_wrapper values_col(values.begin(), values.end()); cudf::test::fixed_width_column_wrapper offsets_col(offsets.begin(), offsets.end()); - auto input_col = cudf::make_lists_column( - num_rows, offsets_col.release(), values_col.release(), 0, rmm::device_buffer{}); + auto input_col = + cudf::make_lists_column(num_rows, + offsets_col.release(), + values_col.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); cudf::table_view input_table({*input_col}); auto adc = cudf::approx_distinct_count(input_table); diff --git a/cpp/tests/reductions/list_rank_test.cpp b/cpp/tests/reductions/list_rank_test.cpp index 732cad257e68..3adc5c13d6d4 100644 --- a/cpp/tests/reductions/list_rank_test.cpp +++ b/cpp/tests/reductions/list_rank_test.cpp @@ -184,7 +184,7 @@ TEST_F(ListRankScanTest, ListOfStruct) auto list_column = cudf::column_view(cudf::data_type(cudf::type_id::LIST), 17, nullptr, - static_cast(null_mask.data()), + reinterpret_cast(null_mask.data()), null_count, 0, {offsets, struct_col}); diff --git a/cpp/tests/reductions/tdigest_tests.cpp b/cpp/tests/reductions/tdigest_tests.cpp index 384462c4cdb0..cc705ec920ac 100644 --- a/cpp/tests/reductions/tdigest_tests.cpp +++ b/cpp/tests/reductions/tdigest_tests.cpp @@ -30,7 +30,8 @@ struct reduce_op { tbl.begin(), tbl.end(), std::back_inserter(cols), [](cudf::column_view const& col) { return std::make_unique(col); }); - return cudf::make_structs_column(tbl.num_rows(), std::move(cols), 0, rmm::device_buffer()); + return cudf::make_structs_column( + tbl.num_rows(), std::move(cols), 0, cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); } }; @@ -48,7 +49,8 @@ struct reduce_merge_op { tbl.begin(), tbl.end(), std::back_inserter(cols), [](cudf::column_view const& col) { return std::make_unique(col); }); - return cudf::make_structs_column(tbl.num_rows(), std::move(cols), 0, rmm::device_buffer()); + return cudf::make_structs_column( + tbl.num_rows(), std::move(cols), 0, cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); } }; } // namespace @@ -135,8 +137,11 @@ TEST_F(ReductionTDigestMerge, FewHeavyCentroids) cudf::test::fixed_width_column_wrapper c0w({100.0, 50.0}, stream, setup_mr); cudf::test::structs_column_wrapper c0s({c0c, c0w}, {}, stream, setup_mr); cudf::test::fixed_width_column_wrapper c0_offsets({0, 2}, stream, setup_mr); - auto c0l = - cudf::make_lists_column(1, c0_offsets.release(), c0s.release(), 0, rmm::device_buffer{}); + auto c0l = cudf::make_lists_column(1, + c0_offsets.release(), + c0s.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); cudf::test::fixed_width_column_wrapper c0min({1.0}, stream, setup_mr); cudf::test::fixed_width_column_wrapper c0max({2.0}, stream, setup_mr); std::vector> c0_children; @@ -144,8 +149,12 @@ TEST_F(ReductionTDigestMerge, FewHeavyCentroids) c0_children.push_back(c0min.release()); c0_children.push_back(c0max.release()); // tdigest struct - auto c0 = - cudf::make_structs_column(1, std::move(c0_children), 0, {}, stream, setup_mr.get_output_mr()); + auto c0 = cudf::make_structs_column(1, + std::move(c0_children), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), + stream, + setup_mr.get_output_mr()); cudf::tdigest::tdigest_column_view tdv0(*c0); // digest 2 @@ -153,8 +162,11 @@ TEST_F(ReductionTDigestMerge, FewHeavyCentroids) cudf::test::fixed_width_column_wrapper c1w({200.0, 50.0}, stream, setup_mr); cudf::test::structs_column_wrapper c1s({c1c, c1w}, {}, stream, setup_mr); cudf::test::fixed_width_column_wrapper c1_offsets({0, 2}, stream, setup_mr); - auto c1l = - cudf::make_lists_column(1, c1_offsets.release(), c1s.release(), 0, rmm::device_buffer{}); + auto c1l = cudf::make_lists_column(1, + c1_offsets.release(), + c1s.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); cudf::test::fixed_width_column_wrapper c1min({3.0}, stream, setup_mr); cudf::test::fixed_width_column_wrapper c1max({4.0}, stream, setup_mr); std::vector> c1_children; @@ -162,8 +174,12 @@ TEST_F(ReductionTDigestMerge, FewHeavyCentroids) c1_children.push_back(c1min.release()); c1_children.push_back(c1max.release()); // tdigest struct - auto c1 = - cudf::make_structs_column(1, std::move(c1_children), 0, {}, stream, setup_mr.get_output_mr()); + auto c1 = cudf::make_structs_column(1, + std::move(c1_children), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), + stream, + setup_mr.get_output_mr()); std::vector views; views.push_back(*c0); @@ -185,15 +201,23 @@ TEST_F(ReductionTDigestMerge, FewHeavyCentroids) tbl.begin(), tbl.end(), std::back_inserter(cols), [&](cudf::column_view const& col) { return std::make_unique(col, stream, mr.get_output_mr()); }); - auto result = cudf::make_structs_column( - tbl.num_rows(), std::move(cols), 0, rmm::device_buffer(), stream, mr.get_output_mr()); + auto result = cudf::make_structs_column(tbl.num_rows(), + std::move(cols), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), + stream, + mr.get_output_mr()); // we expect to see exactly 4 centroids (the same inputs) with properly computed min/max. cudf::test::fixed_width_column_wrapper ec({1.0, 2.0, 3.0, 4.0}, stream, setup_mr); cudf::test::fixed_width_column_wrapper ew({100.0, 50.0, 200.0, 50.0}, stream, setup_mr); cudf::test::structs_column_wrapper es({ec, ew}, {}, stream, setup_mr); cudf::test::fixed_width_column_wrapper e_offsets({0, 4}, stream, setup_mr); - auto el = cudf::make_lists_column(1, e_offsets.release(), es.release(), 0, rmm::device_buffer{}); + auto el = cudf::make_lists_column(1, + e_offsets.release(), + es.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); cudf::test::fixed_width_column_wrapper emin({1.0}, stream, setup_mr); cudf::test::fixed_width_column_wrapper emax({4.0}, stream, setup_mr); std::vector> e_children; @@ -202,7 +226,12 @@ TEST_F(ReductionTDigestMerge, FewHeavyCentroids) e_children.push_back(emax.release()); // tdigest struct auto expected = - cudf::make_structs_column(1, std::move(e_children), 0, {}, stream, setup_mr.get_output_mr()); + cudf::make_structs_column(1, + std::move(e_children), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), + stream, + setup_mr.get_output_mr()); CUDF_TEST_EXPECT_COLUMNS_EQUAL( *result, *expected, cudf::test::debug_output_level::FIRST_ERROR, stream, mr); diff --git a/cpp/tests/reshape/interleave_columns_tests.cpp b/cpp/tests/reshape/interleave_columns_tests.cpp index 66dc44a8e790..64ad4aab6a6e 100644 --- a/cpp/tests/reshape/interleave_columns_tests.cpp +++ b/cpp/tests/reshape/interleave_columns_tests.cpp @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: Copyright (c) 2020-2025, NVIDIA CORPORATION. + * SPDX-FileCopyrightText: Copyright (c) 2020-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. * SPDX-License-Identifier: Apache-2.0 */ @@ -10,6 +10,7 @@ #include #include +#include #include using namespace cudf::test::iterators; @@ -838,11 +839,23 @@ TYPED_TEST(ListsColumnsInterleaveTypedTest, InputListsOfStructsNoNull) }(); auto const col1 = - cudf::make_lists_column(3, IntCol{0, 1, 3, 5}.release(), structs1.release(), 0, {}); + cudf::make_lists_column(3, + IntCol{0, 1, 3, 5}.release(), + structs1.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); auto const col2 = - cudf::make_lists_column(3, IntCol{0, 3, 4, 5}.release(), structs2.release(), 0, {}); - auto const expected = cudf::make_lists_column( - 6, IntCol{0, 1, 4, 6, 7, 9, 10}.release(), structs_expected.release(), 0, {}); + cudf::make_lists_column(3, + IntCol{0, 3, 4, 5}.release(), + structs2.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); + auto const expected = + cudf::make_lists_column(6, + IntCol{0, 1, 4, 6, 7, 9, 10}.release(), + structs_expected.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); auto const results = cudf::interleave_columns(TView{{col1->view(), col2->view()}}); CUDF_TEST_EXPECT_COLUMNS_EQUIVALENT(*expected, *results, verbosity); } @@ -883,11 +896,23 @@ TYPED_TEST(ListsColumnsInterleaveTypedTest, InputListsOfStructsWithNulls) }(); auto const col1 = - cudf::make_lists_column(3, IntCol{0, 1, 3, 5}.release(), structs1.release(), 0, {}); + cudf::make_lists_column(3, + IntCol{0, 1, 3, 5}.release(), + structs1.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); auto const col2 = - cudf::make_lists_column(3, IntCol{0, 3, 4, 5}.release(), structs2.release(), 0, {}); - auto const expected = cudf::make_lists_column( - 6, IntCol{0, 1, 4, 6, 7, 9, 10}.release(), structs_expected.release(), 0, {}); + cudf::make_lists_column(3, + IntCol{0, 3, 4, 5}.release(), + structs2.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); + auto const expected = + cudf::make_lists_column(6, + IntCol{0, 1, 4, 6, 7, 9, 10}.release(), + structs_expected.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); auto const results = cudf::interleave_columns(TView{{col1->view(), col2->view()}}); CUDF_TEST_EXPECT_COLUMNS_EQUIVALENT(*expected, *results, verbosity); } @@ -920,11 +945,23 @@ TYPED_TEST(ListsColumnsInterleaveTypedTest, SlicedInputListsOfStructsNoNull) }(); auto const col1_original = - cudf::make_lists_column(5, IntCol{0, 2, 3, 5, 7, 8}.release(), structs1.release(), 0, {}); + cudf::make_lists_column(5, + IntCol{0, 2, 3, 5, 7, 8}.release(), + structs1.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); auto const col2_original = - cudf::make_lists_column(4, IntCol{0, 3, 4, 5, 7}.release(), structs2.release(), 0, {}); - auto const expected = cudf::make_lists_column( - 6, IntCol{0, 1, 4, 6, 7, 9, 10}.release(), structs_expected.release(), 0, {}); + cudf::make_lists_column(4, + IntCol{0, 3, 4, 5, 7}.release(), + structs2.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); + auto const expected = + cudf::make_lists_column(6, + IntCol{0, 1, 4, 6, 7, 9, 10}.release(), + structs_expected.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); auto const col1 = cudf::slice(col1_original->view(), {1, 4})[0]; auto const col2 = cudf::slice(col2_original->view(), {0, 3})[0]; @@ -969,14 +1006,26 @@ TYPED_TEST(ListsColumnsInterleaveTypedTest, SlicedInputListsOfStructsWithNulls) }(); auto const col1_original = - cudf::make_lists_column(5, IntCol{0, 1, 2, 4, 6, 7}.release(), structs1.release(), 0, {}); + cudf::make_lists_column(5, + IntCol{0, 1, 2, 4, 6, 7}.release(), + structs1.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); auto const col2_original = - cudf::make_lists_column(4, IntCol{0, 1, 4, 5, 6}.release(), structs2.release(), 0, {}); - - auto const col1 = cudf::slice(col1_original->view(), {1, 4})[0]; - auto const col2 = cudf::slice(col2_original->view(), {1, 4})[0]; - auto const expected = cudf::make_lists_column( - 6, IntCol{0, 1, 4, 6, 7, 9, 10}.release(), structs_expected.release(), 0, {}); + cudf::make_lists_column(4, + IntCol{0, 1, 4, 5, 6}.release(), + structs2.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); + + auto const col1 = cudf::slice(col1_original->view(), {1, 4})[0]; + auto const col2 = cudf::slice(col2_original->view(), {1, 4})[0]; + auto const expected = + cudf::make_lists_column(6, + IntCol{0, 1, 4, 6, 7, 9, 10}.release(), + structs_expected.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); auto const results = cudf::interleave_columns(TView{{col1, col2}}); CUDF_TEST_EXPECT_COLUMNS_EQUIVALENT(*expected, *results, verbosity); } diff --git a/cpp/tests/rolling/collect_ops_test.cpp b/cpp/tests/rolling/collect_ops_test.cpp index ca1f1ba827c8..344dc2026eed 100644 --- a/cpp/tests/rolling/collect_ops_test.cpp +++ b/cpp/tests/rolling/collect_ops_test.cpp @@ -12,6 +12,7 @@ #include #include #include +#include #include #include #include @@ -620,7 +621,7 @@ TYPED_TEST(TypedCollectListTest, BasicGroupedRollingWindowWithNulls) expected_offsets.release(), expected_child.release(), 0, - {}); + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); CUDF_TEST_EXPECT_COLUMNS_EQUIVALENT(expected_result->view(), result->view()); } @@ -646,7 +647,7 @@ TYPED_TEST(TypedCollectListTest, BasicGroupedRollingWindowWithNulls) expected_offsets.release(), expected_child.release(), 0, - {}); + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); CUDF_TEST_EXPECT_COLUMNS_EQUIVALENT(expected_result->view(), result->view()); } @@ -903,11 +904,12 @@ TYPED_TEST(TypedCollectListTest, BasicGroupedTimeRangeRollingWindowOnStructs) auto struct_members = std::vector>{}; struct_members.emplace_back(numeric_member_column.release()); struct_members.emplace_back(string_member_column.release()); - auto const struct_column = cudf::make_structs_column(9, std::move(struct_members), 0, {}); - auto const preceding = cudf::duration_scalar(2, true); - auto const following = cudf::duration_scalar(1, true); - auto const min_periods = 1; - auto const result = cudf::grouped_range_rolling_window( + auto const struct_column = cudf::make_structs_column( + 9, std::move(struct_members), 0, cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); + auto const preceding = cudf::duration_scalar(2, true); + auto const following = cudf::duration_scalar(1, true); + auto const min_periods = 1; + auto const result = cudf::grouped_range_rolling_window( cudf::table_view{std::vector{group_column}}, time_column, cudf::order::ASCENDING, @@ -930,11 +932,18 @@ TYPED_TEST(TypedCollectListTest, BasicGroupedTimeRangeRollingWindowOnStructs) expected_struct_members.emplace_back(expected_string_column.release()); auto expected_structs_column = - cudf::make_structs_column(32, std::move(expected_struct_members), 0, {}); + cudf::make_structs_column(32, + std::move(expected_struct_members), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); auto expected_offsets_column = cudf::test::fixed_width_column_wrapper{0, 4, 8, 13, 18, 23, 24, 26, 29, 32}.release(); - auto expected_result = cudf::make_lists_column( - 9, std::move(expected_offsets_column), std::move(expected_structs_column), 0, {}); + auto expected_result = + cudf::make_lists_column(9, + std::move(expected_offsets_column), + std::move(expected_structs_column), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); CUDF_TEST_EXPECT_COLUMNS_EQUIVALENT(expected_result->view(), result->view()); @@ -1221,11 +1230,12 @@ TYPED_TEST(TypedCollectListTest, GroupedTimeRangeRollingWindowOnStructsWithMinPe auto struct_members = std::vector>{}; struct_members.emplace_back(numeric_member_column.release()); struct_members.emplace_back(string_member_column.release()); - auto const struct_column = cudf::make_structs_column(9, std::move(struct_members), 0, {}); - auto const preceding = cudf::duration_scalar(2, true); - auto const following = cudf::duration_scalar(1, true); - auto const min_periods = 4; - auto const result = cudf::grouped_range_rolling_window( + auto const struct_column = cudf::make_structs_column( + 9, std::move(struct_members), 0, cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); + auto const preceding = cudf::duration_scalar(2, true); + auto const following = cudf::duration_scalar(1, true); + auto const min_periods = 4; + auto const result = cudf::grouped_range_rolling_window( cudf::table_view{std::vector{group_column}}, time_column, cudf::order::ASCENDING, @@ -1247,7 +1257,10 @@ TYPED_TEST(TypedCollectListTest, GroupedTimeRangeRollingWindowOnStructsWithMinPe expected_struct_members.emplace_back(expected_string_column.release()); auto expected_structs_column = - cudf::make_structs_column(23, std::move(expected_struct_members), 0, {}); + cudf::make_structs_column(23, + std::move(expected_struct_members), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); auto expected_offsets_column = cudf::test::fixed_width_column_wrapper{0, 4, 8, 13, 18, 23, 23, 23, 23, 23}.release(); auto expected_validity_iter = cudf::test::iterators::nulls_at({5, 6, 7, 8}); @@ -1757,7 +1770,7 @@ TYPED_TEST(TypedCollectSetTest, BasicGroupedRollingWindowWithNulls) expected_offsets.release(), expected_child.release(), 0, - {}); + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); CUDF_TEST_EXPECT_COLUMNS_EQUIVALENT(expected_result->view(), result->view()); } @@ -1805,7 +1818,7 @@ TYPED_TEST(TypedCollectSetTest, BasicGroupedRollingWindowWithNulls) expected_offsets.release(), expected_child.release(), 0, - {}); + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); CUDF_TEST_EXPECT_COLUMNS_EQUIVALENT(expected_result->view(), result->view()); } @@ -1843,7 +1856,7 @@ TYPED_TEST(TypedCollectSetTest, BasicGroupedRollingWindowWithNulls) expected_offsets.release(), expected_child.release(), 0, - {}); + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); CUDF_TEST_EXPECT_COLUMNS_EQUIVALENT(expected_result->view(), result->view()); } @@ -2235,7 +2248,7 @@ TEST_F(CollectSetTest, StructTypeRollingWindow) cudf::test::fixed_width_column_wrapper{0, 2, 5, 8, 11, 13}.release(), cudf::test::structs_column_wrapper{{child1, child2}}.release(), 0, - {}); + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); }(); auto const result = rolling_collect_set(input_column, @@ -2261,9 +2274,18 @@ TEST_F(CollectSetTest, ListTypeRollingWindow) 0, 3, 5, 8, 10, 11, 13, 14, 17, 18, 21, 22, 25, 26}; auto outer_offsets = cudf::test::fixed_width_column_wrapper{0, 2, 5, 8, 11, 13}; - auto inner_list = cudf::make_lists_column(13, inner_offsets.release(), data.release(), 0, {}); + auto inner_list = + cudf::make_lists_column(13, + inner_offsets.release(), + data.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); - return cudf::make_lists_column(5, outer_offsets.release(), std::move(inner_list), 0, {}); + return cudf::make_lists_column(5, + outer_offsets.release(), + std::move(inner_list), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); }(); auto const result = diff --git a/cpp/tests/rolling/grouped_rolling_range_test.cpp b/cpp/tests/rolling/grouped_rolling_range_test.cpp index ea0d8eaa228a..b65b4d42ee34 100644 --- a/cpp/tests/rolling/grouped_rolling_range_test.cpp +++ b/cpp/tests/rolling/grouped_rolling_range_test.cpp @@ -160,15 +160,15 @@ struct GroupedRollingRangeOrderByNumericTest : public BaseGroupedRollingRangeOrd auto const nulled_order_by = [&] { auto col = generate_order_by_column(); auto new_null_mask = create_null_mask(col->size(), cudf::mask_state::ALL_VALID); - cudf::set_null_mask(static_cast(new_null_mask.data()), + cudf::set_null_mask(reinterpret_cast(new_null_mask.data()), 0, 2, false); // Nulls in first group. - cudf::set_null_mask(static_cast(new_null_mask.data()), + cudf::set_null_mask(reinterpret_cast(new_null_mask.data()), 6, 8, false); // Nulls in second group. - cudf::set_null_mask(static_cast(new_null_mask.data()), + cudf::set_null_mask(reinterpret_cast(new_null_mask.data()), 10, 12, false); // Nulls in third group. @@ -473,15 +473,15 @@ struct GroupedRollingRangeOrderByDecimalTypedTest auto const nulled_order_by = [&] { auto col = generate_order_by_column(order_by_column_scale); auto new_null_mask = create_null_mask(col->size(), cudf::mask_state::ALL_VALID); - cudf::set_null_mask(static_cast(new_null_mask.data()), + cudf::set_null_mask(reinterpret_cast(new_null_mask.data()), 0, 2, false); // Nulls in first group. - cudf::set_null_mask(static_cast(new_null_mask.data()), + cudf::set_null_mask(reinterpret_cast(new_null_mask.data()), 6, 8, false); // Nulls in second group. - cudf::set_null_mask(static_cast(new_null_mask.data()), + cudf::set_null_mask(reinterpret_cast(new_null_mask.data()), 10, 12, false); // Nulls in third group. diff --git a/cpp/tests/row_operator/row_operator_tests.cu b/cpp/tests/row_operator/row_operator_tests.cu index 70c6e29556fa..4b1a1271b535 100644 --- a/cpp/tests/row_operator/row_operator_tests.cu +++ b/cpp/tests/row_operator/row_operator_tests.cu @@ -15,6 +15,7 @@ #include #include #include +#include #include #include @@ -210,8 +211,11 @@ TYPED_TEST(TypedTableViewTest, TestSortSameTableFromTwoTablesWithListsOfStructs) auto child1 = strings_col{{"a", "c", "a", "b"}, stream, mr}; return structs_col{{child0, child1}, {}, stream, mr}; }; - return cudf::make_lists_column( - 2, int32s_col{{0, 2, 4}, stream, mr}.release(), get_structs().release(), 0, {}); + return cudf::make_lists_column(2, + int32s_col{{0, 2, 4}, stream, mr}.release(), + get_structs().release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); }(); auto const col2 = [] { auto const get_structs = [] { @@ -219,7 +223,11 @@ TYPED_TEST(TypedTableViewTest, TestSortSameTableFromTwoTablesWithListsOfStructs) auto child1 = strings_col{}; return structs_col{{child0, child1}}; }; - return cudf::make_lists_column(0, int32s_col{}.release(), get_structs().release(), 0, {}); + return cudf::make_lists_column(0, + int32s_col{}.release(), + get_structs().release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); }(); auto const column_order = std::vector{cudf::order::ASCENDING}; diff --git a/cpp/tests/search/search_list_test.cpp b/cpp/tests/search/search_list_test.cpp index c8bdcfe1e3e8..cc9ed805aae1 100644 --- a/cpp/tests/search/search_list_test.cpp +++ b/cpp/tests/search/search_list_test.cpp @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: Copyright (c) 2022-2024, NVIDIA CORPORATION. + * SPDX-FileCopyrightText: Copyright (c) 2022-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. * SPDX-License-Identifier: Apache-2.0 */ @@ -9,6 +9,7 @@ #include #include +#include #include #include #include @@ -303,7 +304,11 @@ TYPED_TEST(TypedListContainsTestColumnNeedles, ListsOfStructs) }; // clang-format on auto child = structs_col{{data1, data2}}; - return cudf::make_lists_column(5, offsets.release(), child.release(), 0, {}); + return cudf::make_lists_column(5, + offsets.release(), + child.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); }(); auto const needles = [] { @@ -323,7 +328,11 @@ TYPED_TEST(TypedListContainsTestColumnNeedles, ListsOfStructs) }; // clang-format on auto child = structs_col{{data1, data2}}; - return cudf::make_lists_column(5, offsets.release(), child.release(), 0, {}); + return cudf::make_lists_column(5, + offsets.release(), + child.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); }(); auto const expected = bools_col{0, 1, 1, 0, 0}; @@ -432,7 +441,11 @@ TEST_F(ListBinarySearch, ListsOfStructs) }; // clang-format on auto child = structs_col{{data1, data2}}; - return cudf::make_lists_column(9, offsets.release(), child.release(), 0, {}); + return cudf::make_lists_column(9, + offsets.release(), + child.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); }(); auto const needles = [] { @@ -458,7 +471,11 @@ TEST_F(ListBinarySearch, ListsOfStructs) }; // clang-format on auto child = structs_col{{data1, data2}}; - return cudf::make_lists_column(8, offsets.release(), child.release(), 0, {}); + return cudf::make_lists_column(8, + offsets.release(), + child.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); }(); auto const [result_lower_bound, result_upper_bound] = search_bounds( @@ -497,7 +514,11 @@ TEST_F(ListBinarySearch, ListsOfEqualStructsInTwoTables) }; // clang-format on auto child = structs_col{{data1, data2}}; - return cudf::make_lists_column(9, offsets.release(), child.release(), 0, {}); + return cudf::make_lists_column(9, + offsets.release(), + child.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); }(); auto const needles = [] { @@ -525,7 +546,11 @@ TEST_F(ListBinarySearch, ListsOfEqualStructsInTwoTables) }; // clang-format on auto child = structs_col{{data1, data2}}; - return cudf::make_lists_column(9, offsets.release(), child.release(), 0, {}); + return cudf::make_lists_column(9, + offsets.release(), + child.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); }(); // In this search, the two table have many equal structs. @@ -570,28 +595,42 @@ TEST_F(ListBinarySearch, CrazyListTest) }; // clang-format on auto child = structs_col{{data1, data2}}; - return cudf::make_lists_column(9, offsets.release(), child.release(), 0, {}); + return cudf::make_lists_column(9, + offsets.release(), + child.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); }(); auto struct_nested0 = [&] { std::vector> child_columns; child_columns.emplace_back(std::move(lists_of_structs_of_ints)); - return cudf::make_structs_column(9, std::move(child_columns), 0, {}); + return cudf::make_structs_column( + 9, std::move(child_columns), 0, cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); }(); auto struct_nested1 = [&] { std::vector> child_columns; child_columns.emplace_back(std::move(struct_nested0)); - return cudf::make_structs_column(9, std::move(child_columns), 0, {}); + return cudf::make_structs_column( + 9, std::move(child_columns), 0, cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); }(); auto list_nested0 = [&] { auto offsets = int32s_col{0, 3, 3, 4, 6, 9}; - return cudf::make_lists_column(5, offsets.release(), std::move(struct_nested1), 0, {}); + return cudf::make_lists_column(5, + offsets.release(), + std::move(struct_nested1), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); }(); auto offsets = int32s_col{0, 0, 2, 4, 5, 5}; - return cudf::make_lists_column(5, offsets.release(), std::move(list_nested0), 0, {}); + return cudf::make_lists_column(5, + offsets.release(), + std::move(list_nested0), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); }(); auto const needles = [] { @@ -620,28 +659,42 @@ TEST_F(ListBinarySearch, CrazyListTest) }; // clang-format on auto child = structs_col{{data1, data2}}; - return cudf::make_lists_column(9, offsets.release(), child.release(), 0, {}); + return cudf::make_lists_column(9, + offsets.release(), + child.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); }(); auto struct_nested0 = [&] { std::vector> child_columns; child_columns.emplace_back(std::move(lists_of_structs_of_ints)); - return cudf::make_structs_column(9, std::move(child_columns), 0, {}); + return cudf::make_structs_column( + 9, std::move(child_columns), 0, cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); }(); auto struct_nested1 = [&] { std::vector> child_columns; child_columns.emplace_back(std::move(struct_nested0)); - return cudf::make_structs_column(9, std::move(child_columns), 0, {}); + return cudf::make_structs_column( + 9, std::move(child_columns), 0, cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); }(); auto list_nested0 = [&] { auto offsets = int32s_col{0, 3, 3, 4, 6, 9}; - return cudf::make_lists_column(5, offsets.release(), std::move(struct_nested1), 0, {}); + return cudf::make_lists_column(5, + offsets.release(), + std::move(struct_nested1), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); }(); auto offsets = int32s_col{0, 2, 2, 4, 4, 5}; - return cudf::make_lists_column(5, offsets.release(), std::move(list_nested0), 0, {}); + return cudf::make_lists_column(5, + offsets.release(), + std::move(list_nested0), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); }(); // In this search, the two table have many equal structs. diff --git a/cpp/tests/sort/sort_nested_types_tests.cpp b/cpp/tests/sort/sort_nested_types_tests.cpp index 85b77d84b646..5bb586ab7bc7 100644 --- a/cpp/tests/sort/sort_nested_types_tests.cpp +++ b/cpp/tests/sort/sort_nested_types_tests.cpp @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: Copyright (c) 2023-2024, NVIDIA CORPORATION. + * SPDX-FileCopyrightText: Copyright (c) 2023-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. * SPDX-License-Identifier: Apache-2.0 */ @@ -240,15 +240,19 @@ TEST_F(NestedStructTest, SimpleStructsOfListsOfStructsNoNulls) auto child1 = int32s_col{0, 4, 3, 2, 1, 1, 5, 1, 5, 5, 4, 2, 4, 1, 3}; return structs_col{{child0, child1}}; }; - return cudf::make_lists_column( - 8, int32s_col{0, 3, 5, 6, 6, 8, 10, 12, 15}.release(), get_structs().release(), 0, {}); + return cudf::make_lists_column(8, + int32s_col{0, 3, 5, 6, 6, 8, 10, 12, 15}.release(), + get_structs().release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); }; std::vector> children; children.emplace_back(make_lists_of_structs()); children.emplace_back(make_lists_of_structs()); - return cudf::make_structs_column(8, std::move(children), 0, {}); + return cudf::make_structs_column( + 8, std::move(children), 0, cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); }(); { @@ -275,8 +279,11 @@ TEST_F(NestedListTest, SimpleListsOfStructsNoNulls) auto child1 = int32s_col{0, 4, 3, 2, 1, 1, 5, 1, 5, 5, 4, 2, 4, 1, 3}; return structs_col{{child0, child1}}; }; - return cudf::make_lists_column( - 8, int32s_col{0, 3, 5, 6, 6, 8, 10, 12, 15}.release(), get_structs().release(), 0, {}); + return cudf::make_lists_column(8, + int32s_col{0, 3, 5, 6, 6, 8, 10, 12, 15}.release(), + get_structs().release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); }(); { @@ -305,7 +312,7 @@ TEST_F(NestedListTest, SlicedListsOfStructsNoNulls) int32s_col{0, 1, 2, 5, 7, 8, 8, 10, 12, 14, 17, 18}.release(), get_structs().release(), 0, - {}); + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); }(); auto const input = cudf::slice(*input_original, {2, 10})[0]; @@ -331,8 +338,11 @@ TEST_F(NestedListTest, ListsOfEqualStructsNoNulls) auto child1 = strings_col{"a", "c", "a", "b"}; return structs_col{{child0, child1}}; }; - return cudf::make_lists_column( - 2, int32s_col{0, 2, 4}.release(), get_structs().release(), 0, {}); + return cudf::make_lists_column(2, + int32s_col{0, 2, 4}.release(), + get_structs().release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); }(); { @@ -365,8 +375,11 @@ TEST_F(NestedListTest, SimpleListsOfStructsWithNulls) auto child1 = int32s_col{{2, null, 2, null, 2, 5, 4, 3, 0, 1, 3, 2, 2}, nulls_at({1, 3})}; return structs_col{{child0, child1}, nulls_at({1, 3})}; }; - return cudf::make_lists_column( - 8, int32s_col{0, 3, 3, 5, 5, 7, 7, 10, 13}.release(), get_structs().release(), 0, {}); + return cudf::make_lists_column(8, + int32s_col{0, 3, 3, 5, 5, 7, 7, 10, 13}.release(), + get_structs().release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); }(); { @@ -411,9 +424,12 @@ TEST_F(NestedListTest, ListsOfListsOfStructsNoNulls) int32s_col{0, 1, 3, 4, 5, 7, 9, 10, 12, 12, 14, 15, 17, 17}.release(), get_structs().release(), 0, - {}); - return cudf::make_lists_column( - 8, int32s_col{0, 3, 4, 6, 6, 8, 10, 10, 13}.release(), std::move(lists_of_structs), 0, {}); + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); + return cudf::make_lists_column(8, + int32s_col{0, 3, 4, 6, 6, 8, 10, 10, 13}.release(), + std::move(lists_of_structs), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); }(); { diff --git a/cpp/tests/sort/sort_test.cpp b/cpp/tests/sort/sort_test.cpp index e4925f99f019..7a0f7e26a140 100644 --- a/cpp/tests/sort/sort_test.cpp +++ b/cpp/tests/sort/sort_test.cpp @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: Copyright (c) 2019-2026, NVIDIA CORPORATION. + * SPDX-FileCopyrightText: Copyright (c) 2019-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. * SPDX-License-Identifier: Apache-2.0 */ @@ -948,9 +948,13 @@ TYPED_TEST(Sort, WithEmptyListColumn) cudf::make_empty_column(cudf::data_type(cudf::type_id::INT32)), cudf::make_empty_column(cudf::data_type{cudf::type_id::INT64}), 0, - {}); - auto L0 = cudf::make_lists_column( - 3, cudf::test::fixed_width_column_wrapper{0, 0, 0, 0}.release(), std::move(L1), 0, {}); + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); + auto L0 = + cudf::make_lists_column(3, + cudf::test::fixed_width_column_wrapper{0, 0, 0, 0}.release(), + std::move(L1), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); auto expect = cudf::test::fixed_width_column_wrapper{0, 1, 2}; auto result = cudf::sorted_order(cudf::table_view({*L0})); @@ -1038,8 +1042,8 @@ TEST_F(SortCornerTest, WithEmptyStructColumn) std::vector> child_columns; child_columns.push_back(std::move(struct_col)); child_columns.push_back(col3.release()); - auto struct_col2 = - cudf::make_structs_column(6, std::move(child_columns), 0, rmm::device_buffer{}); + auto struct_col2 = cudf::make_structs_column( + 6, std::move(child_columns), 0, cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); cudf::table_view input2{{struct_col2->view()}}; int_col expected2{{5, 4, 3, 2, 0, 1}}; @@ -1056,10 +1060,11 @@ TEST_F(SortCornerTest, WithEmptyStructColumn) int_col col4{{5, 4, 3, 2, 1, 0}}; std::vector> grand_child; grand_child.push_back(col4.release()); - auto child_col_2 = cudf::make_structs_column(6, std::move(grand_child), 0, rmm::device_buffer{}); + auto child_col_2 = cudf::make_structs_column( + 6, std::move(grand_child), 0, cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); child_columns2.push_back(std::move(child_col_2)); - auto struct_col3 = - cudf::make_structs_column(6, std::move(child_columns2), 0, rmm::device_buffer{}); + auto struct_col3 = cudf::make_structs_column( + 6, std::move(child_columns2), 0, cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); cudf::table_view input3{{struct_col3->view()}}; int_col expected3{{4, 1, 5, 3, 2, 0}}; diff --git a/cpp/tests/sort/top_k_tests.cpp b/cpp/tests/sort/top_k_tests.cpp index 821eb363f33e..b5e85c2c333d 100644 --- a/cpp/tests/sort/top_k_tests.cpp +++ b/cpp/tests/sort/top_k_tests.cpp @@ -12,6 +12,7 @@ #include #include #include +#include #include #include #include @@ -385,9 +386,12 @@ TEST_F(TopK, SegmentedUncoveredNull) auto expected_values = cudf::test::fixed_width_column_wrapper( {50, 40, 25, 15}, cudf::test::iterators::no_nulls()); auto expected_offsets = cudf::test::fixed_width_column_wrapper({0, 2, 4}); - auto expected = - cudf::make_lists_column(2, expected_offsets.release(), expected_values.release(), 0, {}); - auto result = cudf::segmented_top_k(input, offsets, 2); + auto expected = cudf::make_lists_column(2, + expected_offsets.release(), + expected_values.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); + auto result = cudf::segmented_top_k(input, offsets, 2); CUDF_TEST_EXPECT_COLUMNS_EQUAL(expected->view(), result->view()); auto expected_order = cudf::test::lists_column_wrapper({{4, 0}, {6, 5}}); diff --git a/cpp/tests/stream_compaction/apply_mask_tests.cpp b/cpp/tests/stream_compaction/apply_mask_tests.cpp index f6feb0e7a1b2..83fb3504a956 100644 --- a/cpp/tests/stream_compaction/apply_mask_tests.cpp +++ b/cpp/tests/stream_compaction/apply_mask_tests.cpp @@ -315,7 +315,7 @@ TEST_F(ApplyRetentionMask, ListOfStructsFiltering) fixed_width_column_wrapper{0, 2, 4, 6, 8, 10}.release(), struct_column.release(), 0, - {}); + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); auto filter_mask = fixed_width_column_wrapper{{1, 0, 1, 0, 1}}; @@ -337,7 +337,7 @@ TEST_F(ApplyRetentionMask, ListOfStructsFiltering) fixed_width_column_wrapper{0, 2, 4, 6}.release(), expected_struct_column.release(), 0, - {}); + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); CUDF_TEST_EXPECT_COLUMNS_EQUIVALENT(filtered_list_column, expected_list_of_structs_column->view()); diff --git a/cpp/tests/stream_compaction/distinct_tests.cpp b/cpp/tests/stream_compaction/distinct_tests.cpp index 32253437be8c..3fb803b83ea7 100644 --- a/cpp/tests/stream_compaction/distinct_tests.cpp +++ b/cpp/tests/stream_compaction/distinct_tests.cpp @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: Copyright (c) 2019-2024, NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-FileCopyrightText: Copyright (c) 2019-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. * SPDX-License-Identifier: Apache-2.0 */ @@ -873,7 +873,7 @@ TEST_F(DistinctKeepAny, ListsOfStructs) auto const keys = cudf::column_view(cudf::data_type(cudf::type_id::LIST), 17, nullptr, - static_cast(null_mask.data()), + reinterpret_cast(null_mask.data()), null_count, 0, {offsets, structs}); @@ -959,7 +959,7 @@ TEST_F(DistinctKeepFirstLastNone, ListsOfStructs) auto const keys = cudf::column_view(cudf::data_type(cudf::type_id::LIST), 17, nullptr, - static_cast(null_mask.data()), + reinterpret_cast(null_mask.data()), null_count, 0, {offsets, structs}); @@ -1055,7 +1055,7 @@ TEST_F(DistinctKeepAny, SlicedListsOfStructs) auto const keys = cudf::column_view(cudf::data_type(cudf::type_id::LIST), 17, nullptr, - static_cast(null_mask.data()), + reinterpret_cast(null_mask.data()), null_count, 0, {offsets, structs}); @@ -1109,7 +1109,7 @@ TEST_F(DistinctKeepAny, ListsOfEmptyStructs) cudf::column_view(cudf::data_type(cudf::type_id::STRUCT), 14, nullptr, - static_cast(structs_null_mask.data()), + reinterpret_cast(structs_null_mask.data()), structs_null_count); auto const offsets = int32s_col{0, 0, 0, 0, 0, 2, 4, 6, 7, 8, 9, 10, 12, 14}; @@ -1120,7 +1120,7 @@ TEST_F(DistinctKeepAny, ListsOfEmptyStructs) cudf::column_view(cudf::data_type(cudf::type_id::LIST), 13, nullptr, - static_cast(lists_null_mask.data()), + reinterpret_cast(lists_null_mask.data()), lists_null_count, 0, {offsets, structs}); diff --git a/cpp/tests/stream_compaction/stable_distinct_tests.cpp b/cpp/tests/stream_compaction/stable_distinct_tests.cpp index 120aa12dabac..5b8a9fa4c2b7 100644 --- a/cpp/tests/stream_compaction/stable_distinct_tests.cpp +++ b/cpp/tests/stream_compaction/stable_distinct_tests.cpp @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: Copyright (c) 2023-2024, NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-FileCopyrightText: Copyright (c) 2023-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. * SPDX-License-Identifier: Apache-2.0 */ @@ -812,7 +812,7 @@ TEST_F(StableDistinctKeepAny, ListsOfStructs) auto const keys = cudf::column_view(cudf::data_type(cudf::type_id::LIST), 17, nullptr, - static_cast(null_mask.data()), + reinterpret_cast(null_mask.data()), null_count, 0, {offsets, structs}); @@ -896,7 +896,7 @@ TEST_F(StableDistinctKeepFirstLastNone, ListsOfStructs) auto const keys = cudf::column_view(cudf::data_type(cudf::type_id::LIST), 17, nullptr, - static_cast(null_mask.data()), + reinterpret_cast(null_mask.data()), null_count, 0, {offsets, structs}); @@ -989,7 +989,7 @@ TEST_F(StableDistinctKeepAny, SlicedListsOfStructs) auto const keys = cudf::column_view(cudf::data_type(cudf::type_id::LIST), 17, nullptr, - static_cast(null_mask.data()), + reinterpret_cast(null_mask.data()), null_count, 0, {offsets, structs}); @@ -1044,7 +1044,7 @@ TEST_F(StableDistinctKeepAny, ListsOfEmptyStructs) cudf::column_view(cudf::data_type(cudf::type_id::STRUCT), 14, nullptr, - static_cast(structs_null_mask.data()), + reinterpret_cast(structs_null_mask.data()), structs_null_count); auto const offsets = int32s_col{0, 0, 0, 0, 0, 2, 4, 6, 7, 8, 9, 10, 12, 14}; @@ -1055,7 +1055,7 @@ TEST_F(StableDistinctKeepAny, ListsOfEmptyStructs) cudf::column_view(cudf::data_type(cudf::type_id::LIST), 13, nullptr, - static_cast(lists_null_mask.data()), + reinterpret_cast(lists_null_mask.data()), lists_null_count, 0, {offsets, structs}); diff --git a/cpp/tests/stream_compaction/unique_tests.cpp b/cpp/tests/stream_compaction/unique_tests.cpp index 2bc0480e47e4..a630332815ce 100644 --- a/cpp/tests/stream_compaction/unique_tests.cpp +++ b/cpp/tests/stream_compaction/unique_tests.cpp @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: Copyright (c) 2019-2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. + * SPDX-FileCopyrightText: Copyright (c) 2019-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. * SPDX-License-Identifier: Apache-2.0 */ @@ -467,7 +467,7 @@ TEST_F(Unique, ListsOfStructsKeepAny) auto const keys = cudf::column_view(cudf::data_type(cudf::type_id::LIST), 17, nullptr, - static_cast(null_mask.data()), + reinterpret_cast(null_mask.data()), null_count, 0, {offsets, structs}); @@ -550,7 +550,7 @@ TEST_F(Unique, ListsOfStructsKeepFirstLastNone) auto const keys = cudf::column_view(cudf::data_type(cudf::type_id::LIST), 17, nullptr, - static_cast(null_mask.data()), + reinterpret_cast(null_mask.data()), null_count, 0, {offsets, structs}); @@ -610,7 +610,7 @@ TEST_F(Unique, ListsOfEmptyStructsKeepAny) cudf::column_view(cudf::data_type(cudf::type_id::STRUCT), 14, nullptr, - static_cast(structs_null_mask.data()), + reinterpret_cast(structs_null_mask.data()), structs_null_count); auto const offsets = int32s_col{0, 0, 0, 0, 0, 2, 4, 6, 7, 8, 9, 10, 12, 14}; @@ -621,7 +621,7 @@ TEST_F(Unique, ListsOfEmptyStructsKeepAny) cudf::column_view(cudf::data_type(cudf::type_id::LIST), 13, nullptr, - static_cast(lists_null_mask.data()), + reinterpret_cast(lists_null_mask.data()), lists_null_count, 0, {offsets, structs}); diff --git a/cpp/tests/streams/column_view_test.cpp b/cpp/tests/streams/column_view_test.cpp index 0c0541311b9c..0cda5671e23f 100644 --- a/cpp/tests/streams/column_view_test.cpp +++ b/cpp/tests/streams/column_view_test.cpp @@ -22,7 +22,7 @@ struct TypedColumnTest : public cudf::test::BaseFixture { TypedColumnTest(cuda::stream_ref stream = cudf::test::get_default_stream()) : data{_num_elements * sizeof(T), stream}, - mask{cudf::bitmask_allocation_size_bytes(_num_elements), stream} + mask{cudf::create_null_mask(_num_elements, cudf::mask_state::UNINITIALIZED, stream)} { std::vector h_data(std::max(data.size(), mask.size())); std::iota(h_data.begin(), h_data.end(), 0); @@ -39,11 +39,11 @@ struct TypedColumnTest : public cudf::test::BaseFixture { std::uniform_int_distribution distribution{200, 1000}; cudf::size_type _num_elements{distribution(generator)}; rmm::device_buffer data{}; - rmm::device_buffer mask{}; - rmm::device_buffer all_valid_mask{create_null_mask( - num_elements(), cudf::mask_state::ALL_VALID, cudf::test::get_default_stream())}; - rmm::device_buffer all_null_mask{ - create_null_mask(num_elements(), cudf::mask_state::ALL_NULL, cudf::test::get_default_stream())}; + cuda::device_buffer mask = cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED); + cuda::device_buffer all_valid_mask = + create_null_mask(num_elements(), cudf::mask_state::ALL_VALID, cudf::test::get_default_stream()); + cuda::device_buffer all_null_mask = + create_null_mask(num_elements(), cudf::mask_state::ALL_NULL, cudf::test::get_default_stream()); }; TYPED_TEST_SUITE(TypedColumnTest, cudf::test::Types); diff --git a/cpp/tests/streams/strings/factory_test.cpp b/cpp/tests/streams/strings/factory_test.cpp index 5df8fc604f95..2019894ef469 100644 --- a/cpp/tests/streams/strings/factory_test.cpp +++ b/cpp/tests/streams/strings/factory_test.cpp @@ -63,7 +63,8 @@ TEST_F(StringsFactoryTest, StructConstruction) children.push_back(cudf::test::fixed_width_column_wrapper{1, 2, 3}.release()); children.push_back(cudf::test::strings_column_wrapper{"a", "b", "c"}.release()); - auto result = cudf::make_structs_column(3, std::move(children), 0, rmm::device_buffer{}, stream); + auto result = cudf::make_structs_column( + 3, std::move(children), 0, cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), stream); EXPECT_EQ(result->size(), 3); } @@ -75,7 +76,7 @@ TEST_F(StringsFactoryTest, StructHierarchyConstruction) children.push_back(cudf::test::fixed_width_column_wrapper{1, 2, 3}.release()); children.push_back(cudf::test::strings_column_wrapper{"a", "b", "c"}.release()); - auto result = - cudf::create_structs_hierarchy(3, std::move(children), 0, rmm::device_buffer{}, stream); + auto result = cudf::create_structs_hierarchy( + 3, std::move(children), 0, cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), stream); EXPECT_EQ(result->size(), 3); } diff --git a/cpp/tests/strings/contains_tests.cpp b/cpp/tests/strings/contains_tests.cpp index 53e5d9f18829..adba06d80a0e 100644 --- a/cpp/tests/strings/contains_tests.cpp +++ b/cpp/tests/strings/contains_tests.cpp @@ -11,6 +11,7 @@ #include #include +#include #include #include #include @@ -288,9 +289,13 @@ TEST_F(StringsContainsTests, HexTest) auto d_offsets = std::make_unique( cudf::detail::make_device_uvector( offsets, cudf::get_default_stream(), cudf::get_current_device_resource_ref()), - rmm::device_buffer{}, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), 0); - auto input = cudf::make_strings_column(count, std::move(d_offsets), d_chars.release(), 0, {}); + auto input = cudf::make_strings_column(count, + std::move(d_offsets), + d_chars.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); auto strings_view = cudf::strings_column_view(input->view()); for (auto ch : ascii_chars) { diff --git a/cpp/tests/strings/factories_test.cu b/cpp/tests/strings/factories_test.cu index 51c0bdd87ff3..1ae9d9c35ced 100644 --- a/cpp/tests/strings/factories_test.cu +++ b/cpp/tests/strings/factories_test.cu @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: Copyright (c) 2019-2026, NVIDIA CORPORATION. + * SPDX-FileCopyrightText: Copyright (c) 2019-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. * SPDX-License-Identifier: Apache-2.0 */ @@ -11,6 +11,7 @@ #include #include #include +#include #include #include #include @@ -137,12 +138,11 @@ TEST_F(StringsFactoriesTest, CreateColumnFromOffsets) auto d_offsets = std::make_unique( cudf::detail::make_device_uvector( h_offsets, cudf::get_default_stream(), cudf::get_current_device_resource_ref()), - rmm::device_buffer{}, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), 0); - auto d_nulls = cudf::detail::make_device_uvector( - h_nulls, cudf::get_default_stream(), cudf::get_current_device_resource_ref()); - auto column = cudf::make_strings_column( - count, std::move(d_offsets), d_buffer.release(), null_count, d_nulls.release()); + auto d_nulls = cudf::copy_bitmask(h_nulls.data(), 0, count); + auto column = cudf::make_strings_column( + count, std::move(d_offsets), d_buffer.release(), null_count, std::move(d_nulls)); EXPECT_EQ(column->type(), cudf::data_type{cudf::type_id::STRING}); EXPECT_EQ(column->null_count(), null_count); EXPECT_EQ(1, column->num_children()); @@ -185,12 +185,12 @@ TEST_F(StringsFactoriesTest, EmptyStringsColumn) auto d_offsets = std::make_unique( cudf::detail::make_zeroed_device_uvector( 1, cudf::get_default_stream(), cudf::get_current_device_resource_ref()), - rmm::device_buffer{}, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), 0); - rmm::device_uvector d_nulls{0, cudf::get_default_stream()}; + auto d_nulls = cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED); auto results = - cudf::make_strings_column(0, std::move(d_offsets), d_chars.release(), 0, d_nulls.release()); + cudf::make_strings_column(0, std::move(d_offsets), d_chars.release(), 0, std::move(d_nulls)); cudf::test::expect_column_empty(results->view()); rmm::device_uvector d_strings{0, cudf::get_default_stream()}; diff --git a/cpp/tests/strings/strip_tests.cpp b/cpp/tests/strings/strip_tests.cpp index b0a1cdeb8176..5237b23923cd 100644 --- a/cpp/tests/strings/strip_tests.cpp +++ b/cpp/tests/strings/strip_tests.cpp @@ -91,8 +91,8 @@ TEST_F(StringsStripTest, EmptyStringsColumn) TEST_F(StringsStripTest, AllEmptyStrings) { - auto input = - cudf::test::strings_column_wrapper({"", "", "", "", "", ""}, {true, true, false, true, true}); + auto input = cudf::test::strings_column_wrapper({"", "", "", "", "", ""}, + {true, true, false, true, true, true}); auto results = cudf::strings::strip(cudf::strings_column_view(input), cudf::strings::side_type::BOTH); CUDF_TEST_EXPECT_COLUMNS_EQUAL(*results, input); diff --git a/cpp/tests/structs/structs_column_tests.cpp b/cpp/tests/structs/structs_column_tests.cpp index 563ddb11ff44..176a891d86e7 100644 --- a/cpp/tests/structs/structs_column_tests.cpp +++ b/cpp/tests/structs/structs_column_tests.cpp @@ -63,7 +63,8 @@ TYPED_TEST(TypedStructColumnWrapperTest, TestColumnFactoryConstruction) cols.push_back(std::move(ages_col)); cols.push_back(std::move(is_human_col)); - auto struct_col = cudf::make_structs_column(num_rows, std::move(cols), 0, {}); + auto struct_col = cudf::make_structs_column( + num_rows, std::move(cols), 0, cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); EXPECT_EQ(num_rows, struct_col->size()); @@ -398,8 +399,11 @@ TYPED_TEST(TypedStructColumnWrapperTest, TestListsOfStructs) cudf::test::fixed_width_column_wrapper{0, 2, 3, 5, 6}.release(); auto num_list_rows = list_offsets_column->size() - 1; - auto list_col = cudf::make_lists_column( - num_list_rows, std::move(list_offsets_column), std::move(struct_col), 0, {}); + auto list_col = cudf::make_lists_column(num_list_rows, + std::move(list_offsets_column), + std::move(struct_col), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); // List of structs was constructed successfully. No exceptions. // Verify that child columns is as it was set. @@ -531,8 +535,12 @@ TYPED_TEST(TypedStructColumnWrapperTest, EmptyColumnsOfStructs) EXPECT_TRUE(struct_column->size() == 0); EXPECT_TRUE(struct_column->null_count() == 0); - auto empty_list_of_structs = cudf::make_lists_column( - 0, fixed_width_column_wrapper{0}.release(), std::move(struct_column), 0, {}); + auto empty_list_of_structs = + cudf::make_lists_column(0, + fixed_width_column_wrapper{0}.release(), + std::move(struct_column), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); EXPECT_TRUE(empty_list_of_structs->size() == 0); EXPECT_TRUE(empty_list_of_structs->null_count() == 0); @@ -586,8 +594,11 @@ TYPED_TEST(TypedStructColumnWrapperTest, CopyColumnFromView) CUDF_TEST_EXPECT_COLUMNS_EQUIVALENT(clone_structs_column, structs_column); auto list_of_structs_column = - cudf::make_lists_column( - 3, fixed_width_column_wrapper{0, 2, 4, 6}.release(), structs_column.release(), 0, {}) + cudf::make_lists_column(3, + fixed_width_column_wrapper{0, 2, 4, 6}.release(), + structs_column.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)) .release(); CUDF_TEST_EXPECT_COLUMNS_EQUIVALENT(list_of_structs_column->view(), @@ -600,8 +611,12 @@ TEST_F(StructColumnWrapperTest, TestStructsColumnWithEmptyChild) // because EMPTY columns cannot have a null mask. This test ensures that // we can construct a structs column with a parent null mask and an EMPTY // child and then view it. - auto empty_col = std::make_unique( - cudf::data_type(cudf::type_id::EMPTY), 3, rmm::device_buffer{}, rmm::device_buffer{}, 0); + auto empty_col = + std::make_unique(cudf::data_type(cudf::type_id::EMPTY), + 3, + rmm::device_buffer{}, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), + 0); int num_rows{empty_col->size()}; vector_of_columns cols; cols.push_back(std::move(empty_col)); diff --git a/cpp/tests/table/table_tests.cpp b/cpp/tests/table/table_tests.cpp index 71fda287d8e4..afb3ef6371b3 100644 --- a/cpp/tests/table/table_tests.cpp +++ b/cpp/tests/table/table_tests.cpp @@ -358,10 +358,16 @@ TEST_F(TableTest, TablesEqualStructColumnsDeepLeafMismatch) TEST_F(TableTest, TablesEqualThrowsForNonEqualityComparableTypes) { - auto left = - column{cudf::data_type{cudf::type_id::EMPTY}, 3, rmm::device_buffer{}, rmm::device_buffer{}, 0}; - auto right = - column{cudf::data_type{cudf::type_id::EMPTY}, 3, rmm::device_buffer{}, rmm::device_buffer{}, 0}; + auto left = column{cudf::data_type{cudf::type_id::EMPTY}, + 3, + rmm::device_buffer{}, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), + 0}; + auto right = column{cudf::data_type{cudf::type_id::EMPTY}, + 3, + rmm::device_buffer{}, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), + 0}; EXPECT_THROW( std::ignore = cudf::tables_equal(cudf::table_view{{left}}, cudf::table_view{{right}}), diff --git a/cpp/tests/text/minhash_tests.cpp b/cpp/tests/text/minhash_tests.cpp index df3e642f0db1..51de3f869d6a 100644 --- a/cpp/tests/text/minhash_tests.cpp +++ b/cpp/tests/text/minhash_tests.cpp @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: Copyright (c) 2023-2026, NVIDIA CORPORATION. + * SPDX-FileCopyrightText: Copyright (c) 2023-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. * SPDX-License-Identifier: Apache-2.0 */ @@ -225,7 +225,11 @@ TEST_F(MinHashTest, ErrorsTest) cuda::counting_iterator{0}, cuda::counting_iterator{static_cast(h_input.size() + 1)}); auto input_ngrams = - cudf::make_lists_column(h_input.size(), offsets.release(), input.release(), 0, {}); + cudf::make_lists_column(h_input.size(), + offsets.release(), + input.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); lview = cudf::lists_column_view(input_ngrams->view()); EXPECT_THROW(nvtext::minhash_ngrams(lview, 4, 0, pview, pview), std::overflow_error); EXPECT_THROW(nvtext::minhash64_ngrams(lview, 4, 0, pview64, pview64), std::overflow_error); @@ -275,7 +279,11 @@ TEST_F(MinHashTest, NgramsWide) auto str_data = cudf::test::strings_column_wrapper(many.begin(), many.end()); auto offsets = cudf::test::fixed_width_column_wrapper({0ul, many.size() / 2, many.size()}); - auto input = cudf::make_lists_column(2, offsets.release(), str_data.release(), 0, {}); + auto input = cudf::make_lists_column(2, + offsets.release(), + str_data.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); auto view = cudf::lists_column_view(input->view()); diff --git a/cpp/tests/transform/mask_to_bools_test.cpp b/cpp/tests/transform/mask_to_bools_test.cpp index 047b53beee62..e580ab68f797 100644 --- a/cpp/tests/transform/mask_to_bools_test.cpp +++ b/cpp/tests/transform/mask_to_bools_test.cpp @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: Copyright (c) 2020-2023, NVIDIA CORPORATION. + * SPDX-FileCopyrightText: Copyright (c) 2020-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. * SPDX-License-Identifier: Apache-2.0 */ @@ -54,7 +54,7 @@ TEST_P(MaskToBoolsTest, LargeDataSizeTest) auto mask = cudf::bools_to_mask(col); auto out = cudf::mask_to_bools( - static_cast(mask.first->data()), begin_bit, end_bit); + reinterpret_cast(mask.first->data()), begin_bit, end_bit); CUDF_TEST_EXPECT_COLUMNS_EQUAL(expected, out->view()); } diff --git a/cpp/tests/transform/row_bit_count_test.cu b/cpp/tests/transform/row_bit_count_test.cu index 20e329808f0e..b47c16191090 100644 --- a/cpp/tests/transform/row_bit_count_test.cu +++ b/cpp/tests/transform/row_bit_count_test.cu @@ -12,6 +12,7 @@ #include #include #include +#include #include #include @@ -45,9 +46,18 @@ std::pair, std::unique_ptr> build_li 1, 2, 3, 4, 5, 10, 6, 7, 8, 9, -1, -2, -3, -4, -5, -6, -7, -8, -9}; cudf::test::fixed_width_column_wrapper inner_offsets{ 0, 2, 5, 6, 9, 10, 12, 14, 17, 19}; - auto inner_list = cudf::make_lists_column(9, inner_offsets.release(), values.release(), 0, {}); + auto inner_list = + cudf::make_lists_column(9, + inner_offsets.release(), + values.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); cudf::test::fixed_width_column_wrapper outer_offsets{0, 2, 2, 3, 5, 7, 9}; - auto list = cudf::make_lists_column(6, outer_offsets.release(), std::move(inner_list), 0, {}); + auto list = cudf::make_lists_column(6, + outer_offsets.release(), + std::move(inner_list), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); // expected size = (num rows at level 1 + num_rows at level 2) + # values in the leaf cudf::test::fixed_width_column_wrapper expected{ @@ -130,7 +140,7 @@ std::unique_ptr build_nested_column1(std::vector const& stru outer_offsets_col.release(), struct_column.release(), 0, - rmm::device_buffer{}); + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); } std::unique_ptr build_nested_column2(std::vector const& struct_validity) @@ -162,7 +172,7 @@ std::unique_ptr build_nested_column2(std::vector const& stru outer_offsets_col.release(), outer_struct.release(), 0, - rmm::device_buffer{}); + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); } } // namespace row_bit_count_test @@ -247,7 +257,11 @@ TYPED_TEST(RowBitCountTyped, ListsWithNulls) auto inner_list = cudf::make_lists_column( 5, inner_offsets.release(), values.release(), null_count, std::move(null_mask)); cudf::test::fixed_width_column_wrapper outer_offsets{0, 2, 2, 3, 5}; - auto list = cudf::make_lists_column(4, outer_offsets.release(), std::move(inner_list), 0, {}); + auto list = cudf::make_lists_column(4, + outer_offsets.release(), + std::move(inner_list), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); cudf::table_view t({*list}); auto result = cudf::row_bit_count(t); @@ -351,12 +365,20 @@ TEST_F(RowBitCount, StructsWithLists_RowsExceedingASingleBlock) // List = {{0,1}, {2,3}, {4,5}, ..., {2*(num_rows-1), 2*num_rows-1}}; auto lists_column = - cudf::make_lists_column(num_rows, std::move(list_offsets), std::move(ints), 0, {}); + cudf::make_lists_column(num_rows, + std::move(list_offsets), + std::move(ints), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); // Struct. auto struct_members = std::vector>{}; struct_members.emplace_back(std::move(lists_column)); - auto structs_column = cudf::make_structs_column(num_rows, std::move(struct_members), 0, {}); + auto structs_column = + cudf::make_structs_column(num_rows, + std::move(struct_members), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); // Compute row_bit_count, and compare. auto row_bit_counts = cudf::row_bit_count(cudf::table_view{{structs_column->view()}}); @@ -505,7 +527,7 @@ TEST_F(RowBitCount, NestedTypes) l4_offsets_col.release(), innermost_struct.release(), 0, - rmm::device_buffer{}); + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); // inner struct std::vector> inner_struct_children; @@ -542,7 +564,7 @@ TEST_F(RowBitCount, NullsInStringsList) offsets_wrapper{0, 2, 4, 6, 8}.release(), cudf::test::strings_column_wrapper{strings.begin(), strings.end(), valids.begin()}.release(), 0, - {}); + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); CUDF_TEST_EXPECT_COLUMNS_EQUIVALENT( cudf::row_bit_count(cudf::table_view{{lists_col->view()}})->view(), cudf::test::fixed_width_column_wrapper{138, 106, 130, 130}); @@ -553,9 +575,13 @@ TEST_F(RowBitCount, EmptyChildColumnInListOfStrings) // Test with a list column with 4 empty list rows. // Note: Since there are no strings in any of the lists, // the lists column's child can be empty. - auto offsets = cudf::test::fixed_width_column_wrapper{0, 0, 0, 0, 0}; - auto lists_col = cudf::make_lists_column( - 4, offsets.release(), cudf::make_empty_column(cudf::data_type{cudf::type_id::STRING}), 0, {}); + auto offsets = cudf::test::fixed_width_column_wrapper{0, 0, 0, 0, 0}; + auto lists_col = + cudf::make_lists_column(4, + offsets.release(), + cudf::make_empty_column(cudf::data_type{cudf::type_id::STRING}), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); CUDF_TEST_EXPECT_COLUMNS_EQUIVALENT( cudf::row_bit_count(cudf::table_view{{lists_col->view()}})->view(), @@ -572,8 +598,13 @@ TEST_F(RowBitCount, EmptyChildColumnInListOfLists) return cudf::empty_like(exemplar); }; - auto offsets = cudf::test::fixed_width_column_wrapper{0, 0, 0, 0, 0}; - auto lists_col = cudf::make_lists_column(4, offsets.release(), empty_child_lists_column(), 0, {}); + auto offsets = cudf::test::fixed_width_column_wrapper{0, 0, 0, 0, 0}; + auto lists_col = + cudf::make_lists_column(4, + offsets.release(), + empty_child_lists_column(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); CUDF_TEST_EXPECT_COLUMNS_EQUIVALENT( cudf::row_bit_count(cudf::table_view{{lists_col->view()}})->view(), @@ -635,12 +666,20 @@ TEST_F(RowBitCount, DepthJump) // to depth 0 (the topmost int column) cudf::test::fixed_width_column_wrapper ____c0{1, 2, 3, 5, 5, 6, 7, 8}; cudf::test::fixed_width_column_wrapper ___offsets{0, 2, 4, 6, 8}; - auto ___c0 = cudf::make_lists_column(4, ___offsets.release(), ____c0.release(), 0, {}); + auto ___c0 = cudf::make_lists_column(4, + ___offsets.release(), + ____c0.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); std::vector> __children; __children.push_back(std::move(___c0)); cudf::test::structs_column_wrapper __c0(std::move(__children)); cudf::test::fixed_width_column_wrapper _offsets{0, 3, 4}; - auto _c0 = cudf::make_lists_column(2, _offsets.release(), __c0.release(), 0, {}); + auto _c0 = cudf::make_lists_column(2, + _offsets.release(), + __c0.release(), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); cudf::test::fixed_width_column_wrapper _c1{3, 4}; std::vector> children; children.push_back(std::move(_c0)); diff --git a/cpp/tests/unary/cast_tests.cpp b/cpp/tests/unary/cast_tests.cpp index 1830422344e7..49fc5fd8d059 100644 --- a/cpp/tests/unary/cast_tests.cpp +++ b/cpp/tests/unary/cast_tests.cpp @@ -10,6 +10,7 @@ #include #include +#include #include #include #include @@ -79,7 +80,7 @@ inline cudf::column make_exp_chrono_column(cudf::type_id type_id) test_timestamps_D.size() * sizeof(test_timestamps_D.front()), cudf::get_default_stream()}, - rmm::device_buffer{}, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), 0); case cudf::type_id::TIMESTAMP_SECONDS: return cudf::column( @@ -88,7 +89,7 @@ inline cudf::column make_exp_chrono_column(cudf::type_id type_id) rmm::device_buffer{test_timestamps_s.data(), test_timestamps_s.size() * sizeof(test_timestamps_s.front()), cudf::get_default_stream()}, - rmm::device_buffer{}, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), 0); case cudf::type_id::TIMESTAMP_MILLISECONDS: return cudf::column( @@ -97,7 +98,7 @@ inline cudf::column make_exp_chrono_column(cudf::type_id type_id) rmm::device_buffer{test_timestamps_ms.data(), test_timestamps_ms.size() * sizeof(test_timestamps_ms.front()), cudf::get_default_stream()}, - rmm::device_buffer{}, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), 0); case cudf::type_id::TIMESTAMP_MICROSECONDS: return cudf::column( @@ -106,7 +107,7 @@ inline cudf::column make_exp_chrono_column(cudf::type_id type_id) rmm::device_buffer{test_timestamps_us.data(), test_timestamps_us.size() * sizeof(test_timestamps_us.front()), cudf::get_default_stream()}, - rmm::device_buffer{}, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), 0); case cudf::type_id::TIMESTAMP_NANOSECONDS: return cudf::column( @@ -115,7 +116,7 @@ inline cudf::column make_exp_chrono_column(cudf::type_id type_id) rmm::device_buffer{test_timestamps_ns.data(), test_timestamps_ns.size() * sizeof(test_timestamps_ns.front()), cudf::get_default_stream()}, - rmm::device_buffer{}, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), 0); case cudf::type_id::DURATION_DAYS: return cudf::column( @@ -124,7 +125,7 @@ inline cudf::column make_exp_chrono_column(cudf::type_id type_id) rmm::device_buffer{test_durations_D.data(), test_durations_D.size() * sizeof(test_durations_D.front()), cudf::get_default_stream()}, - rmm::device_buffer{}, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), 0); case cudf::type_id::DURATION_SECONDS: return cudf::column( @@ -133,7 +134,7 @@ inline cudf::column make_exp_chrono_column(cudf::type_id type_id) rmm::device_buffer{test_durations_s.data(), test_durations_s.size() * sizeof(test_durations_s.front()), cudf::get_default_stream()}, - rmm::device_buffer{}, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), 0); case cudf::type_id::DURATION_MILLISECONDS: return cudf::column( @@ -142,7 +143,7 @@ inline cudf::column make_exp_chrono_column(cudf::type_id type_id) rmm::device_buffer{test_durations_ms.data(), test_durations_ms.size() * sizeof(test_durations_ms.front()), cudf::get_default_stream()}, - rmm::device_buffer{}, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), 0); case cudf::type_id::DURATION_MICROSECONDS: return cudf::column( @@ -151,7 +152,7 @@ inline cudf::column make_exp_chrono_column(cudf::type_id type_id) rmm::device_buffer{test_durations_us.data(), test_durations_us.size() * sizeof(test_durations_us.front()), cudf::get_default_stream()}, - rmm::device_buffer{}, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), 0); case cudf::type_id::DURATION_NANOSECONDS: return cudf::column( @@ -160,7 +161,7 @@ inline cudf::column make_exp_chrono_column(cudf::type_id type_id) rmm::device_buffer{test_durations_ns.data(), test_durations_ns.size() * sizeof(test_durations_ns.front()), cudf::get_default_stream()}, - rmm::device_buffer{}, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), 0); default: CUDF_FAIL("Unsupported type_id"); } diff --git a/cpp/tests/utilities/column_utilities.cu b/cpp/tests/utilities/column_utilities.cu index f86a34640913..41c99b6d7cbd 100644 --- a/cpp/tests/utilities/column_utilities.cu +++ b/cpp/tests/utilities/column_utilities.cu @@ -967,14 +967,16 @@ std::vector bitmask_to_host(cudf::column_view const& c, auto num_bitmasks = num_bitmask_words(c.size()); auto [bitmask_span, _] = [&] { if (c.offset() == 0) { - return std::pair{cudf::device_span(c.null_mask(), num_bitmasks), - rmm::device_buffer{}}; + return std::pair, cuda::device_buffer>{ + cudf::device_span(c.null_mask(), num_bitmasks), + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)}; } auto mask = copy_bitmask( c.null_mask(), c.offset(), c.offset() + c.size(), stream, mr.get_temporary_mr()); - return std::pair{cudf::device_span( - static_cast(mask.data()), num_bitmasks), - std::move(mask)}; + return std::pair, cuda::device_buffer>{ + cudf::device_span(reinterpret_cast(mask.data()), + num_bitmasks), + std::move(mask)}; }(); return cudf::detail::make_std_vector(bitmask_span, stream); } else { diff --git a/cpp/tests/utilities/tdigest_utilities.cpp b/cpp/tests/utilities/tdigest_utilities.cpp index 37cfbc0d4933..b5338ece2ce7 100644 --- a/cpp/tests/utilities/tdigest_utilities.cpp +++ b/cpp/tests/utilities/tdigest_utilities.cpp @@ -91,12 +91,21 @@ std::unique_ptr make_expected_tdigest_column(std::vector(tdigest.mean, stream, temporary_mr)); inner_children.push_back(std::make_unique(tdigest.weight, stream, temporary_mr)); // tdigest struct - auto tdigests = cudf::make_structs_column( - tdigest.mean.size(), std::move(inner_children), 0, {}, stream, temporary_mr); + auto tdigests = + cudf::make_structs_column(tdigest.mean.size(), + std::move(inner_children), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), + stream, + temporary_mr); auto offsets = fixed_width_column_wrapper({0, tdigest.mean.size()}, stream, temporary_resources); - auto list = cudf::make_lists_column(1, offsets.release(), std::move(tdigests), 0, {}); + auto list = cudf::make_lists_column(1, + offsets.release(), + std::move(tdigests), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); auto min_col = fixed_width_column_wrapper({tdigest.min}, stream, temporary_resources); auto max_col = fixed_width_column_wrapper({tdigest.max}, stream, temporary_resources); @@ -105,7 +114,12 @@ std::unique_ptr make_expected_tdigest_column(std::vector #include #include +#include #include #include @@ -1343,8 +1344,11 @@ TYPED_TEST(ListColumnWrapperTestTyped, ListsOfStructs) auto lists_column_offsets = cudf::test::fixed_width_column_wrapper{0, 2, 4, 8}.release(); auto num_lists = lists_column_offsets->size() - 1; - auto lists_column = - make_lists_column(num_lists, std::move(lists_column_offsets), std::move(struct_column), 0, {}); + auto lists_column = make_lists_column(num_lists, + std::move(lists_column_offsets), + std::move(struct_column), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); // Check if child column is unchanged. @@ -1409,14 +1413,21 @@ TYPED_TEST(ListColumnWrapperTestTyped, ListsOfListsOfStructs) auto lists_column_offsets = cudf::test::fixed_width_column_wrapper{0, 2, 4, 8}.release(); auto num_lists = lists_column_offsets->size() - 1; - auto lists_column = - make_lists_column(num_lists, std::move(lists_column_offsets), std::move(struct_column), 0, {}); + auto lists_column = make_lists_column(num_lists, + std::move(lists_column_offsets), + std::move(struct_column), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); auto lists_of_lists_column_offsets = cudf::test::fixed_width_column_wrapper{0, 2, 3}.release(); - auto num_lists_of_lists = lists_of_lists_column_offsets->size() - 1; - auto lists_of_lists_of_structs_column = make_lists_column( - num_lists_of_lists, std::move(lists_of_lists_column_offsets), std::move(lists_column), 0, {}); + auto num_lists_of_lists = lists_of_lists_column_offsets->size() - 1; + auto lists_of_lists_of_structs_column = + make_lists_column(num_lists_of_lists, + std::move(lists_of_lists_column_offsets), + std::move(lists_column), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); // Check if child column is unchanged. @@ -1522,8 +1533,11 @@ TYPED_TEST(ListColumnWrapperTestTyped, LargeListsOfStructsWithValidity) auto list_offset_column = cudf::test::fixed_width_column_wrapper( list_offset_iterator, list_offset_iterator + num_list_rows + 1) .release(); - auto lists_column = make_lists_column( - num_list_rows, std::move(list_offset_column), std::move(struct_column), 0, {}); + auto lists_column = make_lists_column(num_list_rows, + std::move(list_offset_column), + std::move(struct_column), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); // List construction succeeded. // Verify that the child is unchanged. diff --git a/cpp/tests/wrappers/timestamps_test.cu b/cpp/tests/wrappers/timestamps_test.cu index 675847959c30..d16a396e87d7 100644 --- a/cpp/tests/wrappers/timestamps_test.cu +++ b/cpp/tests/wrappers/timestamps_test.cu @@ -200,8 +200,8 @@ TYPED_TEST(ChronoColumnTest, ChronosCanBeComparedInDeviceCode) TYPED_TEST(ChronoColumnTest, ChronoFactoryNullMaskAsParm) { - rmm::device_buffer null_mask{create_null_mask(this->size(), cudf::mask_state::ALL_NULL)}; - auto column = make_fixed_width_column(cudf::data_type{cudf::type_to_id()}, + auto null_mask = create_null_mask(this->size(), cudf::mask_state::ALL_NULL); + auto column = make_fixed_width_column(cudf::data_type{cudf::type_to_id()}, this->size(), std::move(null_mask), this->size()); @@ -215,8 +215,8 @@ TYPED_TEST(ChronoColumnTest, ChronoFactoryNullMaskAsParm) TYPED_TEST(ChronoColumnTest, ChronoFactoryNullMaskAsEmptyParm) { - rmm::device_buffer null_mask{}; - auto column = make_fixed_width_column( + auto null_mask = cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED); + auto column = make_fixed_width_column( cudf::data_type{cudf::type_to_id()}, this->size(), std::move(null_mask), 0); EXPECT_EQ(column->type(), cudf::data_type{cudf::type_to_id()}); diff --git a/java/src/main/native/src/ColumnVectorJni.cpp b/java/src/main/native/src/ColumnVectorJni.cpp index 866fc58ce6a6..57476839f5a5 100644 --- a/java/src/main/native/src/ColumnVectorJni.cpp +++ b/java/src/main/native/src/ColumnVectorJni.cpp @@ -320,8 +320,12 @@ JNIEXPORT jlong JNICALL Java_ai_rapids_cudf_ColumnVector_makeList( auto offsets = cudf::make_column_from_scalar(*zero, row_count + 1); cudf::data_type n_data_type = cudf::jni::make_data_type(j_type, scale); auto empty_col = cudf::make_empty_column(n_data_type); - return release_as_jlong(cudf::make_lists_column( - row_count, std::move(offsets), std::move(empty_col), 0, rmm::device_buffer())); + return release_as_jlong( + cudf::make_lists_column(row_count, + std::move(offsets), + std::move(empty_col), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED))); } else { auto count = cudf::make_numeric_scalar(cudf::data_type(cudf::type_id::INT32)); count->set_valid_async(true); @@ -329,8 +333,12 @@ JNIEXPORT jlong JNICALL Java_ai_rapids_cudf_ColumnVector_makeList( std::unique_ptr offsets = cudf::sequence(row_count + 1, *zero, *count); auto data_col = cudf::interleave_columns(cudf::table_view(children_vector)); - return release_as_jlong(cudf::make_lists_column( - row_count, std::move(offsets), std::move(data_col), 0, rmm::device_buffer())); + return release_as_jlong( + cudf::make_lists_column(row_count, + std::move(offsets), + std::move(data_col), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED))); } } JNI_CATCH(env, 0); @@ -349,11 +357,12 @@ JNIEXPORT jlong JNICALL Java_ai_rapids_cudf_ColumnVector_makeListFromOffsets( CUDF_EXPECTS(offsets_cv->type().id() == cudf::type_id::INT32, "Input offsets does not have type INT32."); - return release_as_jlong(cudf::make_lists_column(static_cast(row_count), - std::make_unique(*offsets_cv), - std::make_unique(*child_cv), - 0, - {})); + return release_as_jlong( + cudf::make_lists_column(static_cast(row_count), + std::make_unique(*offsets_cv), + std::make_unique(*child_cv), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED))); } JNI_CATCH(env, 0); } diff --git a/java/src/main/native/src/ColumnViewJni.cpp b/java/src/main/native/src/ColumnViewJni.cpp index fe1a46ae6e72..1517ab01b19d 100644 --- a/java/src/main/native/src/ColumnViewJni.cpp +++ b/java/src/main/native/src/ColumnViewJni.cpp @@ -1737,7 +1737,7 @@ JNIEXPORT jlong JNICALL Java_ai_rapids_cudf_ColumnView_binaryOpVV( auto out = make_fixed_width_column(n_data_type, lhs->size(), cudf::mask_state::UNALLOCATED); if (op == cudf::binary_operator::NULL_EQUALS) { - out->set_null_mask(rmm::device_buffer{}, 0); + out->set_null_mask(cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), 0); } else { auto [new_mask, null_count] = cudf::bitmask_and(cudf::table_view{{*lhs, *rhs}}); out->set_null_mask(std::move(new_mask), null_count); @@ -1783,7 +1783,7 @@ JNIEXPORT jlong JNICALL Java_ai_rapids_cudf_ColumnView_binaryOpVS( auto out = make_fixed_width_column(n_data_type, lhs->size(), cudf::mask_state::UNALLOCATED); if (op == cudf::binary_operator::NULL_EQUALS) { - out->set_null_mask(rmm::device_buffer{}, 0); + out->set_null_mask(cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), 0); } else { auto [new_mask, new_null_count] = cudf::binops::scalar_col_valid_mask_and(*lhs, *rhs); out->set_null_mask(std::move(new_mask), new_null_count); @@ -2248,7 +2248,7 @@ JNIEXPORT jlong JNICALL Java_ai_rapids_cudf_ColumnView_bitwiseMergeAndSetValidit // descendants for STRUCTs so that child masks stay consistent , // and fix offsets for LIST/STRINGs by purging non-empty nulls. auto result = cudf::structs::detail::superimpose_and_sanitize_nulls( - static_cast(merge_mask.data()), + reinterpret_cast(merge_mask.data()), merge_null_count, std::move(copy), cudf::get_default_stream(), diff --git a/java/src/main/native/src/ColumnViewJni.cu b/java/src/main/native/src/ColumnViewJni.cu index 8491de9da8ac..d75885977e4d 100644 --- a/java/src/main/native/src/ColumnViewJni.cu +++ b/java/src/main/native/src/ColumnViewJni.cu @@ -128,8 +128,8 @@ void post_process_list_overlap(cudf::column_view const& lhs, // new nullmask. if (overlap_cv.nullable()) { auto [null_mask, null_count] = cudf::bitmask_and( - std::vector{overlap_cv.null_mask(), - static_cast(new_null_mask->data())}, + std::vector{ + overlap_cv.null_mask(), reinterpret_cast(new_null_mask->data())}, std::vector{0, 0}, overlap_cv.size(), stream, @@ -175,7 +175,10 @@ std::unique_ptr lists_distinct_by_key(cudf::lists_column_view cons out_structs_members.emplace_back(std::move(out_columns[1])); out_structs_members.emplace_back(std::move(out_columns[2])); auto out_structs = - cudf::make_structs_column(out_labels.size(), std::move(out_structs_members), 0, {}); + cudf::make_structs_column(out_labels.size(), + std::move(out_structs_members), + 0, + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED)); // Assemble a lists column of structs. auto out_offsets = make_numeric_column( diff --git a/java/src/main/native/src/ScalarJni.cpp b/java/src/main/native/src/ScalarJni.cpp index 0699ea1b88c3..ded4f1b58108 100644 --- a/java/src/main/native/src/ScalarJni.cpp +++ b/java/src/main/native/src/ScalarJni.cpp @@ -1,5 +1,5 @@ /* - * SPDX-FileCopyrightText: Copyright (c) 2019-2025, NVIDIA CORPORATION. + * SPDX-FileCopyrightText: Copyright (c) 2019-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. * SPDX-License-Identifier: Apache-2.0 */ @@ -575,7 +575,7 @@ JNIEXPORT jlong JNICALL Java_ai_rapids_cudf_Scalar_binaryOpSV( auto out = make_fixed_width_column(n_data_type, rhs->size(), cudf::mask_state::UNALLOCATED); if (op == cudf::binary_operator::NULL_EQUALS) { - out->set_null_mask(rmm::device_buffer{}, 0); + out->set_null_mask(cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), 0); } else { auto [new_mask, new_null_count] = cudf::binops::scalar_col_valid_mask_and(*rhs, *lhs); out->set_null_mask(std::move(new_mask), new_null_count); diff --git a/java/src/main/native/src/TableJni.cpp b/java/src/main/native/src/TableJni.cpp index 35ff0b1e6bd6..16b4312e8bcb 100644 --- a/java/src/main/native/src/TableJni.cpp +++ b/java/src/main/native/src/TableJni.cpp @@ -885,11 +885,12 @@ jlongArray mixed_join_size(JNIEnv* env, auto col_data = matches_per_row->release(); cudf::jni::native_jlongArray result(env, 2); result[0] = static_cast(join_size); - result[1] = ptr_as_jlong(new cudf::column{cudf::data_type{cudf::type_id::INT32}, - col_size, - std::move(col_data), - rmm::device_buffer{}, - 0}); + result[1] = + ptr_as_jlong(new cudf::column{cudf::data_type{cudf::type_id::INT32}, + col_size, + std::move(col_data), + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), + 0}); return result.get_jArray(); } JNI_CATCH(env, NULL); @@ -4916,8 +4917,12 @@ Java_ai_rapids_cudf_Table_contiguousSplitGroups(JNIEnv* env, auto const vec = thrust::host_vector(begin, end); auto buf = rmm::device_buffer{vec.data(), size * sizeof(cudf::size_type), cudf::get_default_stream()}; - auto gather_map_col = std::make_unique( - cudf::data_type{cudf::type_id::INT32}, size, std::move(buf), rmm::device_buffer{}, 0); + auto gather_map_col = + std::make_unique(cudf::data_type{cudf::type_id::INT32}, + size, + std::move(buf), + cudf::create_null_mask(0, cudf::mask_state::UNALLOCATED), + 0); // gather the first key in each group to remove duplicated ones. group_by_result_table = cudf::gather(groups.keys->view(), gather_map_col->view()); diff --git a/python/cudf/cudf/core/buffer/buffer.py b/python/cudf/cudf/core/buffer/buffer.py index fd99f85246ff..bb238bd12bec 100644 --- a/python/cudf/cudf/core/buffer/buffer.py +++ b/python/cudf/cudf/core/buffer/buffer.py @@ -1,4 +1,4 @@ -# SPDX-FileCopyrightText: Copyright (c) 2020-2026, NVIDIA CORPORATION. +# SPDX-FileCopyrightText: Copyright (c) 2020-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. # SPDX-License-Identifier: Apache-2.0 from __future__ import annotations @@ -461,7 +461,7 @@ def get_ptr_and_size(array_interface: Mapping) -> tuple[int, int]: """ shape = array_interface["shape"] or (1,) - strides = array_interface["strides"] + strides = array_interface.get("strides") itemsize = numpy.dtype(array_interface["typestr"]).itemsize if strides is None or pylibcudf.column.is_c_contiguous( shape, strides, itemsize diff --git a/python/pylibcudf/pylibcudf/column.pyx b/python/pylibcudf/pylibcudf/column.pyx index 67738a71fa63..76f01e287eb7 100644 --- a/python/pylibcudf/pylibcudf/column.pyx +++ b/python/pylibcudf/pylibcudf/column.pyx @@ -49,7 +49,7 @@ from ._interop_helpers cimport ( _release_schema, ) from .filling cimport sequence -from .gpumemoryview cimport gpumemoryview +from .gpumemoryview cimport gpumemoryview, _from_cuda_device_buffer from .scalar cimport Scalar from .span import Span, is_span as py_is_span from .traits cimport ( @@ -692,8 +692,8 @@ cdef class Column: cdef gpumemoryview mask = None if null_count > 0: - mask = gpumemoryview( - DeviceBuffer.c_from_unique_ptr(move(contents.null_mask), _stream, mr) + mask = _from_cuda_device_buffer( + move(contents.null_mask), _stream, mr ) children = [] diff --git a/python/pylibcudf/pylibcudf/gpumemoryview.pxd b/python/pylibcudf/pylibcudf/gpumemoryview.pxd index 08be0a8b4771..4992ec5498e6 100644 --- a/python/pylibcudf/pylibcudf/gpumemoryview.pxd +++ b/python/pylibcudf/pylibcudf/gpumemoryview.pxd @@ -1,6 +1,20 @@ # SPDX-FileCopyrightText: Copyright (c) 2023-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. # SPDX-License-Identifier: Apache-2.0 from libc.stdint cimport uint64_t, uintptr_t +from libcpp.memory cimport unique_ptr + +from pylibcudf.libcudf.utilities.device_buffer cimport byte, device_buffer + + +cdef class _CudaDeviceBuffer: + cdef unique_ptr[device_buffer[byte]] c_obj + cdef object stream + cdef object mr + + +cdef gpumemoryview _from_cuda_device_buffer( + unique_ptr[device_buffer[byte]] buf, object stream, object mr +) cdef class gpumemoryview: # TODO: Eventually probably want to make this opaque, but for now it's fine diff --git a/python/pylibcudf/pylibcudf/gpumemoryview.pyx b/python/pylibcudf/pylibcudf/gpumemoryview.pyx index 15c8226c0548..aaa50aaf746f 100644 --- a/python/pylibcudf/pylibcudf/gpumemoryview.pyx +++ b/python/pylibcudf/pylibcudf/gpumemoryview.pyx @@ -3,6 +3,8 @@ from libc.stddef cimport size_t from libc.stdint cimport uintptr_t, uint64_t +from libcpp.memory cimport unique_ptr +from libcpp.utility cimport move from collections.abc import Mapping import cython import functools @@ -10,6 +12,29 @@ import operator from typing import Any from .types cimport DataType, size_of, type_id +from pylibcudf.libcudf.utilities.device_buffer cimport byte, device_buffer + + +cdef class _CudaDeviceBuffer: + @property + def __cuda_array_interface__(self): + return { + "data": (self.c_obj.get().data(), False), + "shape": (self.c_obj.get().size(),), + "typestr": "|u1", + "version": 3, + } + + +cdef gpumemoryview _from_cuda_device_buffer( + unique_ptr[device_buffer[byte]] buf, object stream, object mr +): + cdef _CudaDeviceBuffer owner = _CudaDeviceBuffer.__new__(_CudaDeviceBuffer) + owner.c_obj = move(buf) + # Keep the stream and memory resource alive until the allocation is freed. + owner.stream = stream + owner.mr = mr + return gpumemoryview(owner) cdef gpumemoryview _slice(gpumemoryview parent, uintptr_t ptr, uint64_t nbytes): diff --git a/python/pylibcudf/pylibcudf/join.pyx b/python/pylibcudf/pylibcudf/join.pyx index acf5a2d77171..f9233aec46a8 100644 --- a/python/pylibcudf/pylibcudf/join.pyx +++ b/python/pylibcudf/pylibcudf/join.pyx @@ -8,12 +8,13 @@ from libcpp.memory cimport make_unique, unique_ptr from libcpp.optional cimport optional from libcpp.utility cimport move from pylibcudf.libcudf cimport join as cpp_join +from pylibcudf.libcudf cimport null_mask as cpp_null_mask from pylibcudf.libcudf.column.column cimport column from pylibcudf.libcudf.table.table cimport table from pylibcudf.libcudf.table.table_view cimport table_view -from pylibcudf.libcudf.types cimport null_equality +from pylibcudf.libcudf.types cimport mask_state, null_equality +from pylibcudf.libcudf.utilities.device_buffer cimport byte, device_buffer -from rmm.librmm.device_buffer cimport device_buffer from rmm.pylibrmm.stream cimport Stream from rmm.pylibrmm.memory_resource cimport DeviceMemoryResource @@ -53,11 +54,19 @@ cdef Column _column_from_gather_map( ): # helper to convert a gather map to a Column cdef Stream _stream = _get_stream(stream) + cdef unique_ptr[device_buffer[byte]] mask = ( + cpp_null_mask.create_null_mask_unique_ptr( + 0, + mask_state.UNALLOCATED, + _stream.view().value(), + mr.get_mr(), + ) + ) return Column.from_libcudf( move( make_unique[column]( move(dereference(gather_map.get())), - device_buffer(), + move(dereference(mask)), 0 ) ), _stream, mr diff --git a/python/pylibcudf/pylibcudf/libcudf/column/column.pxd b/python/pylibcudf/pylibcudf/libcudf/column/column.pxd index b22eeb1dd407..5252da219edf 100644 --- a/python/pylibcudf/pylibcudf/libcudf/column/column.pxd +++ b/python/pylibcudf/pylibcudf/libcudf/column/column.pxd @@ -1,4 +1,4 @@ -# SPDX-FileCopyrightText: Copyright (c) 2020-2026, NVIDIA CORPORATION. +# SPDX-FileCopyrightText: Copyright (c) 2020-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. # SPDX-License-Identifier: Apache-2.0 from libcpp cimport bool from libcpp.memory cimport unique_ptr @@ -9,6 +9,10 @@ from pylibcudf.libcudf.column.column_view cimport ( mutable_column_view, ) from pylibcudf.libcudf.types cimport data_type, size_type +from pylibcudf.libcudf.utilities.device_buffer cimport ( + byte, + device_buffer as cuda_device_buffer, +) from rmm.librmm.device_buffer cimport device_buffer from cuda.bindings.cyruntime cimport cudaStream_t @@ -18,7 +22,7 @@ from rmm.librmm.memory_resource cimport device_async_resource_ref cdef extern from "cudf/column/column.hpp" namespace "cudf" nogil: cdef cppclass column_contents "cudf::column::contents": unique_ptr[device_buffer] data - unique_ptr[device_buffer] null_mask + unique_ptr[cuda_device_buffer[byte]] null_mask vector[unique_ptr[column]] children cdef cppclass column: diff --git a/python/pylibcudf/pylibcudf/libcudf/column/column_factories.pxd b/python/pylibcudf/pylibcudf/libcudf/column/column_factories.pxd index f8cf3b38ccb7..690f250e8a39 100644 --- a/python/pylibcudf/pylibcudf/libcudf/column/column_factories.pxd +++ b/python/pylibcudf/pylibcudf/libcudf/column/column_factories.pxd @@ -1,4 +1,4 @@ -# SPDX-FileCopyrightText: Copyright (c) 2020-2026, NVIDIA CORPORATION. +# SPDX-FileCopyrightText: Copyright (c) 2020-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. # SPDX-License-Identifier: Apache-2.0 from libcpp.memory cimport unique_ptr from pylibcudf.exception_handler cimport libcudf_exception_handler @@ -12,7 +12,7 @@ from pylibcudf.libcudf.types cimport ( type_id, ) -from rmm.librmm.device_buffer cimport device_buffer +from pylibcudf.libcudf.utilities.device_buffer cimport byte, device_buffer from cuda.bindings.cyruntime cimport cudaStream_t from rmm.librmm.memory_resource cimport device_async_resource_ref @@ -29,7 +29,7 @@ cdef extern from "cudf/column/column_factories.hpp" namespace "cudf" nogil: cdef unique_ptr[column] make_numeric_column( data_type type, size_type size, - device_buffer mask, + device_buffer[byte] mask, size_type null_count, cudaStream_t stream, device_async_resource_ref mr @@ -45,7 +45,7 @@ cdef extern from "cudf/column/column_factories.hpp" namespace "cudf" nogil: cdef unique_ptr[column] make_fixed_point_column( data_type type, size_type size, - device_buffer mask, + device_buffer[byte] mask, size_type null_count, cudaStream_t stream, device_async_resource_ref mr) except +libcudf_exception_handler @@ -60,7 +60,7 @@ cdef extern from "cudf/column/column_factories.hpp" namespace "cudf" nogil: cdef unique_ptr[column] make_timestamp_column( data_type type, size_type size, - device_buffer mask, + device_buffer[byte] mask, size_type null_count, cudaStream_t stream, device_async_resource_ref mr) except +libcudf_exception_handler @@ -75,7 +75,7 @@ cdef extern from "cudf/column/column_factories.hpp" namespace "cudf" nogil: cdef unique_ptr[column] make_duration_column( data_type type, size_type size, - device_buffer mask, + device_buffer[byte] mask, size_type null_count, cudaStream_t stream, device_async_resource_ref mr) except +libcudf_exception_handler @@ -90,7 +90,7 @@ cdef extern from "cudf/column/column_factories.hpp" namespace "cudf" nogil: cdef unique_ptr[column] make_fixed_width_column( data_type type, size_type size, - device_buffer mask, + device_buffer[byte] mask, size_type null_count, cudaStream_t stream, device_async_resource_ref mr) except +libcudf_exception_handler diff --git a/python/pylibcudf/pylibcudf/libcudf/null_mask.pxd b/python/pylibcudf/pylibcudf/libcudf/null_mask.pxd index 330c69f0579c..92870cfda5ed 100644 --- a/python/pylibcudf/pylibcudf/libcudf/null_mask.pxd +++ b/python/pylibcudf/pylibcudf/libcudf/null_mask.pxd @@ -1,25 +1,26 @@ -# SPDX-FileCopyrightText: Copyright (c) 2020-2026, NVIDIA CORPORATION. +# SPDX-FileCopyrightText: Copyright (c) 2020-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. # SPDX-License-Identifier: Apache-2.0 from libc.stdint cimport int32_t from libcpp.pair cimport pair +from libcpp.memory cimport unique_ptr from pylibcudf.exception_handler cimport libcudf_exception_handler from pylibcudf.libcudf.column.column_view cimport column_view from pylibcudf.libcudf.table.table_view cimport table_view from pylibcudf.libcudf.types cimport bitmask_type, mask_state, size_type +from pylibcudf.libcudf.utilities.device_buffer cimport byte, device_buffer -from rmm.librmm.device_buffer cimport device_buffer from cuda.bindings.cyruntime cimport cudaStream_t from rmm.librmm.memory_resource cimport device_async_resource_ref cdef extern from "cudf/null_mask.hpp" namespace "cudf" nogil: - cdef device_buffer copy_bitmask ( + cdef device_buffer[byte] copy_bitmask ( column_view view, cudaStream_t stream, device_async_resource_ref mr ) except +libcudf_exception_handler - cdef device_buffer copy_bitmask ( + cdef device_buffer[byte] copy_bitmask ( const bitmask_type* null_mask, size_type begin_bit, size_type end_bit, @@ -32,20 +33,20 @@ cdef extern from "cudf/null_mask.hpp" namespace "cudf" nogil: size_t padding_boundary ) except +libcudf_exception_handler - cdef device_buffer create_null_mask ( + cdef device_buffer[byte] create_null_mask ( size_type size, mask_state state, cudaStream_t stream, device_async_resource_ref mr ) except +libcudf_exception_handler - cdef pair[device_buffer, size_type] bitmask_and( + cdef pair[device_buffer[byte], size_type] bitmask_and( table_view view, cudaStream_t stream, device_async_resource_ref mr ) - cdef pair[device_buffer, size_type] bitmask_or( + cdef pair[device_buffer[byte], size_type] bitmask_or( table_view view, cudaStream_t stream, device_async_resource_ref mr @@ -64,3 +65,72 @@ cdef extern from "cudf/null_mask.hpp" namespace "cudf" nogil: size_type stop, cudaStream_t stream ) + + +cdef extern from * namespace "pylibcudf" nogil: + """ + #include + #include + + namespace pylibcudf { + inline auto copy_bitmask_to_unique_ptr( + cudf::column_view view, cudaStream_t stream, + rmm::device_async_resource_ref mr) + { + return std::make_unique>( + cudf::copy_bitmask(view, stream, mr)); + } + + inline auto copy_bitmask_to_unique_ptr( + cudf::bitmask_type const* mask, cudf::size_type begin_bit, + cudf::size_type end_bit, cudaStream_t stream, + rmm::device_async_resource_ref mr) + { + return std::make_unique>( + cudf::copy_bitmask(mask, begin_bit, end_bit, stream, mr)); + } + + inline auto create_null_mask_unique_ptr( + cudf::size_type size, cudf::mask_state state, cudaStream_t stream, + rmm::device_async_resource_ref mr) + { + return std::make_unique>( + cudf::create_null_mask(size, state, stream, mr)); + } + + inline auto bitmask_and_unique_ptr( + cudf::table_view view, cudaStream_t stream, + rmm::device_async_resource_ref mr) + { + auto [mask, count] = cudf::bitmask_and(view, stream, mr); + return std::pair{ + std::make_unique>(std::move(mask)), count}; + } + + inline auto bitmask_or_unique_ptr( + cudf::table_view view, cudaStream_t stream, + rmm::device_async_resource_ref mr) + { + auto [mask, count] = cudf::bitmask_or(view, stream, mr); + return std::pair{ + std::make_unique>(std::move(mask)), count}; + } + } // namespace pylibcudf + """ + cdef unique_ptr[device_buffer[byte]] copy_bitmask_to_unique_ptr( + column_view view, cudaStream_t stream, device_async_resource_ref mr + ) except +libcudf_exception_handler + cdef unique_ptr[device_buffer[byte]] copy_bitmask_to_unique_ptr( + const bitmask_type* mask, size_type begin_bit, size_type end_bit, + cudaStream_t stream, device_async_resource_ref mr + ) except +libcudf_exception_handler + cdef unique_ptr[device_buffer[byte]] create_null_mask_unique_ptr( + size_type size, mask_state state, cudaStream_t stream, + device_async_resource_ref mr + ) except +libcudf_exception_handler + cdef pair[unique_ptr[device_buffer[byte]], size_type] bitmask_and_unique_ptr( + table_view view, cudaStream_t stream, device_async_resource_ref mr + ) except +libcudf_exception_handler + cdef pair[unique_ptr[device_buffer[byte]], size_type] bitmask_or_unique_ptr( + table_view view, cudaStream_t stream, device_async_resource_ref mr + ) except +libcudf_exception_handler diff --git a/python/pylibcudf/pylibcudf/libcudf/transform.pxd b/python/pylibcudf/pylibcudf/libcudf/transform.pxd index 76867c550070..4befe68ceccb 100644 --- a/python/pylibcudf/pylibcudf/libcudf/transform.pxd +++ b/python/pylibcudf/pylibcudf/libcudf/transform.pxd @@ -22,7 +22,7 @@ from pylibcudf.libcudf.types cimport ( udf_source_type, ) -from rmm.librmm.device_buffer cimport device_buffer +from pylibcudf.libcudf.utilities.device_buffer cimport byte, device_buffer from cuda.bindings.cyruntime cimport cudaStream_t from rmm.librmm.memory_resource cimport device_async_resource_ref @@ -49,7 +49,7 @@ cdef extern from "cudf/transform.hpp" namespace "cudf" nogil: ctypedef const transform_output const_transform_output - cdef pair[unique_ptr[device_buffer], size_type] bools_to_mask ( + cdef pair[unique_ptr[device_buffer[byte]], size_type] bools_to_mask ( const column_view& input, cudaStream_t stream, device_async_resource_ref mr @@ -63,7 +63,7 @@ cdef extern from "cudf/transform.hpp" namespace "cudf" nogil: device_async_resource_ref mr ) except +libcudf_exception_handler - cdef pair[unique_ptr[device_buffer], size_type] nans_to_nulls( + cdef pair[unique_ptr[device_buffer[byte]], size_type] nans_to_nulls( const column_view& input, cudaStream_t stream, device_async_resource_ref mr diff --git a/python/pylibcudf/pylibcudf/libcudf/utilities/device_buffer.pxd b/python/pylibcudf/pylibcudf/libcudf/utilities/device_buffer.pxd new file mode 100644 index 000000000000..065ada14adbc --- /dev/null +++ b/python/pylibcudf/pylibcudf/libcudf/utilities/device_buffer.pxd @@ -0,0 +1,11 @@ +# SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. +# SPDX-License-Identifier: Apache-2.0 + +cdef extern from "" namespace "std": + cdef cppclass byte: + pass + +cdef extern from "" namespace "cuda" nogil: + cdef cppclass device_buffer[T]: + T* data() + size_t size() diff --git a/python/pylibcudf/pylibcudf/null_mask.pxd b/python/pylibcudf/pylibcudf/null_mask.pxd index 2a2d83bfaa96..95c3d6e4f3b7 100644 --- a/python/pylibcudf/pylibcudf/null_mask.pxd +++ b/python/pylibcudf/pylibcudf/null_mask.pxd @@ -3,17 +3,17 @@ from pylibcudf.libcudf.types cimport mask_state, size_type -from rmm.pylibrmm.device_buffer cimport DeviceBuffer from rmm.pylibrmm.memory_resource cimport DeviceMemoryResource from .column cimport Column +from .gpumemoryview cimport gpumemoryview -cpdef DeviceBuffer copy_bitmask( +cpdef gpumemoryview copy_bitmask( Column col, object stream = *, DeviceMemoryResource mr=* ) -cpdef DeviceBuffer copy_bitmask_from_bitmask( +cpdef gpumemoryview copy_bitmask_from_bitmask( object bitmask, size_type begin_bit, size_type end_bit, @@ -23,18 +23,18 @@ cpdef DeviceBuffer copy_bitmask_from_bitmask( cpdef size_t bitmask_allocation_size_bytes(size_type number_of_bits) -cpdef DeviceBuffer create_null_mask( +cpdef gpumemoryview create_null_mask( size_type size, mask_state state=*, object stream = *, DeviceMemoryResource mr=* ) -cpdef tuple[DeviceBuffer, int] bitmask_and( +cpdef tuple[gpumemoryview, int] bitmask_and( columns, object stream = *, DeviceMemoryResource mr=* ) -cpdef tuple[DeviceBuffer, int] bitmask_or( +cpdef tuple[gpumemoryview, int] bitmask_or( columns, object stream = *, DeviceMemoryResource mr=* ) diff --git a/python/pylibcudf/pylibcudf/null_mask.pyi b/python/pylibcudf/pylibcudf/null_mask.pyi index 396905eb5723..3141b35d17f3 100644 --- a/python/pylibcudf/pylibcudf/null_mask.pyi +++ b/python/pylibcudf/pylibcudf/null_mask.pyi @@ -3,7 +3,7 @@ from collections.abc import Sequence -from rmm.pylibrmm.device_buffer import DeviceBuffer +from pylibcudf.gpumemoryview import gpumemoryview from rmm.pylibrmm.memory_resource import DeviceMemoryResource from pylibcudf.column import Column @@ -15,31 +15,31 @@ def copy_bitmask( col: Column, stream: CudaStreamLike | None = None, mr: DeviceMemoryResource | None = None, -) -> DeviceBuffer: ... +) -> gpumemoryview: ... def copy_bitmask_from_bitmask( bitmask: Span, begin_bit: int, end_bit: int, stream: CudaStreamLike | None = None, mr: DeviceMemoryResource | None = None, -) -> DeviceBuffer: ... +) -> gpumemoryview: ... def bitmask_allocation_size_bytes(number_of_bits: int) -> int: ... def create_null_mask( size: int, state: MaskState = MaskState.UNINITIALIZED, stream: CudaStreamLike | None = None, mr: DeviceMemoryResource | None = None, -) -> DeviceBuffer: ... +) -> gpumemoryview: ... def bitmask_and( columns: Sequence[Column], stream: CudaStreamLike | None = None, mr: DeviceMemoryResource | None = None, -) -> tuple[DeviceBuffer, int]: ... +) -> tuple[gpumemoryview, int]: ... def bitmask_or( columns: Sequence[Column], stream: CudaStreamLike | None = None, mr: DeviceMemoryResource | None = None, -) -> tuple[DeviceBuffer, int]: ... +) -> tuple[gpumemoryview, int]: ... def null_count( bitmask: Span, start: int, stop: int, stream: CudaStreamLike | None = None ) -> int: ... diff --git a/python/pylibcudf/pylibcudf/null_mask.pyx b/python/pylibcudf/pylibcudf/null_mask.pyx index 2b5757386b70..c448c885e5af 100644 --- a/python/pylibcudf/pylibcudf/null_mask.pyx +++ b/python/pylibcudf/pylibcudf/null_mask.pyx @@ -2,16 +2,15 @@ # SPDX-License-Identifier: Apache-2.0 from collections.abc import Sequence from libc.stdint cimport uintptr_t -from libcpp.memory cimport make_unique +from libcpp.memory cimport unique_ptr from libcpp.pair cimport pair from libcpp.utility cimport move from pylibcudf.libcudf cimport null_mask as cpp_null_mask from pylibcudf.libcudf.column.column_view cimport column_view from pylibcudf.libcudf.table.table_view cimport table_view from pylibcudf.libcudf.types cimport mask_state, size_type, bitmask_type +from pylibcudf.libcudf.utilities.device_buffer cimport byte, device_buffer -from rmm.librmm.device_buffer cimport device_buffer -from rmm.pylibrmm.device_buffer cimport DeviceBuffer from rmm.pylibrmm.stream cimport Stream from rmm.pylibrmm.memory_resource cimport DeviceMemoryResource @@ -20,6 +19,7 @@ from pylibcudf.libcudf.types import mask_state as MaskState # no-cython-lint from .span import Span, is_span as py_is_span from .column cimport Column +from .gpumemoryview cimport gpumemoryview, _from_cuda_device_buffer from .table cimport Table from .utils cimport _get_stream, _get_memory_resource from typing import TYPE_CHECKING @@ -38,20 +38,12 @@ __all__ = [ "index_of_first_set_bit", ] -cdef DeviceBuffer buffer_to_python( - device_buffer buf, object stream, DeviceMemoryResource mr -): - return DeviceBuffer.c_from_unique_ptr( - make_unique[device_buffer](move(buf)), stream, mr - ) - - -cpdef DeviceBuffer copy_bitmask( +cpdef gpumemoryview copy_bitmask( Column col, object stream: CudaStreamLike | None = None, DeviceMemoryResource mr=None ): - """Copies ``col``'s bitmask into a ``DeviceBuffer``. + """Copies ``col``'s bitmask into a ``gpumemoryview``. For details, see :cpp:func:`copy_bitmask`. @@ -66,30 +58,30 @@ cpdef DeviceBuffer copy_bitmask( Returns ------- - rmm.DeviceBuffer - A ``DeviceBuffer`` containing ``col``'s bitmask, or an empty - ``DeviceBuffer`` if ``col`` is not nullable + gpumemoryview + A view containing ``col``'s bitmask, or an empty view if ``col`` is + not nullable. """ - cdef device_buffer db + cdef unique_ptr[device_buffer[byte]] db cdef Stream _stream = _get_stream(stream) cdef cudaStream_t _cs = _stream.view().get() mr = _get_memory_resource(mr) cdef column_view c_col = col.view() with nogil: - db = cpp_null_mask.copy_bitmask(c_col, _cs, mr.get_mr()) + db = cpp_null_mask.copy_bitmask_to_unique_ptr(c_col, _cs, mr.get_mr()) - return buffer_to_python(move(db), _stream, mr) + return _from_cuda_device_buffer(move(db), _stream, mr) -cpdef DeviceBuffer copy_bitmask_from_bitmask( +cpdef gpumemoryview copy_bitmask_from_bitmask( object bitmask: Span, size_type begin_bit, size_type end_bit, object stream: CudaStreamLike | None = None, DeviceMemoryResource mr=None ): - """Copies a portion of a bitmask into a ``DeviceBuffer``. + """Copies a portion of a bitmask into a ``gpumemoryview``. For details, see :cpp:func:`copy_bitmask`. @@ -108,23 +100,23 @@ cpdef DeviceBuffer copy_bitmask_from_bitmask( Returns ------- - rmm.DeviceBuffer - A ``DeviceBuffer`` containing ``col``'s bitmask, or an empty - ``DeviceBuffer`` if ``col`` is not nullable + gpumemoryview + A view containing the copied bitmask, or an empty view if the input is + not nullable. """ if not py_is_span(bitmask): raise TypeError( f"bitmask must satisfy Span protocol (have .ptr and .size), " f"got {type(bitmask).__name__}" ) - cdef device_buffer db + cdef unique_ptr[device_buffer[byte]] db cdef Stream _stream = _get_stream(stream) cdef cudaStream_t _cs = _stream.view().get() mr = _get_memory_resource(mr) cdef uintptr_t ptr = bitmask.ptr with nogil: - db = cpp_null_mask.copy_bitmask( + db = cpp_null_mask.copy_bitmask_to_unique_ptr( ptr, begin_bit, end_bit, @@ -132,7 +124,7 @@ cpdef DeviceBuffer copy_bitmask_from_bitmask( mr.get_mr() ) - return buffer_to_python(move(db), _stream, mr) + return _from_cuda_device_buffer(move(db), _stream, mr) cpdef size_t bitmask_allocation_size_bytes(size_type number_of_bits): @@ -156,13 +148,13 @@ cpdef size_t bitmask_allocation_size_bytes(size_type number_of_bits): return cpp_null_mask.bitmask_allocation_size_bytes(number_of_bits, 64) -cpdef DeviceBuffer create_null_mask( +cpdef gpumemoryview create_null_mask( size_type size, mask_state state = mask_state.UNINITIALIZED, object stream: CudaStreamLike | None = None, DeviceMemoryResource mr=None ): - """Creates a ``DeviceBuffer`` for use as a null value indicator bitmask of a + """Creates a ``gpumemoryview`` of a null value indicator bitmask for a ``Column``. For details, see :cpp:func:`create_null_mask`. @@ -182,22 +174,23 @@ cpdef DeviceBuffer create_null_mask( Returns ------- - rmm.DeviceBuffer - A ``DeviceBuffer`` for use as a null bitmask satisfying the desired size and - state + gpumemoryview + A view of a null bitmask satisfying the desired size and state. """ - cdef device_buffer db + cdef unique_ptr[device_buffer[byte]] db cdef Stream _stream = _get_stream(stream) cdef cudaStream_t _cs = _stream.view().get() mr = _get_memory_resource(mr) with nogil: - db = cpp_null_mask.create_null_mask(size, state, _cs, mr.get_mr()) + db = cpp_null_mask.create_null_mask_unique_ptr( + size, state, _cs, mr.get_mr() + ) - return buffer_to_python(move(db), _stream, mr) + return _from_cuda_device_buffer(move(db), _stream, mr) -cpdef tuple[DeviceBuffer, int] bitmask_and( +cpdef tuple[gpumemoryview, int] bitmask_and( columns: Sequence[Column], object stream: CudaStreamLike | None = None, DeviceMemoryResource mr=None, @@ -217,25 +210,28 @@ cpdef tuple[DeviceBuffer, int] bitmask_and( Returns ------- - tuple[DeviceBuffer, size_type] + tuple[gpumemoryview, size_type] A tuple of the resulting mask and count of unset bits """ cdef Table c_table = Table(columns) - cdef pair[device_buffer, size_type] c_result + cdef pair[unique_ptr[device_buffer[byte]], size_type] c_result cdef Stream _stream = _get_stream(stream) cdef cudaStream_t _cs = _stream.view().get() mr = _get_memory_resource(mr) cdef table_view c_input = c_table.view() with nogil: - c_result = cpp_null_mask.bitmask_and( + c_result = cpp_null_mask.bitmask_and_unique_ptr( c_input, _cs, mr.get_mr() ) - return buffer_to_python(move(c_result.first), _stream, mr), c_result.second + return ( + _from_cuda_device_buffer(move(c_result.first), _stream, mr), + c_result.second, + ) -cpdef tuple[DeviceBuffer, int] bitmask_or( +cpdef tuple[gpumemoryview, int] bitmask_or( columns: Sequence[Column], object stream: CudaStreamLike | None = None, DeviceMemoryResource mr=None, @@ -255,20 +251,25 @@ cpdef tuple[DeviceBuffer, int] bitmask_or( Returns ------- - tuple[DeviceBuffer, size_type] + tuple[gpumemoryview, size_type] A tuple of the resulting mask and count of unset bits """ cdef Table c_table = Table(columns) - cdef pair[device_buffer, size_type] c_result + cdef pair[unique_ptr[device_buffer[byte]], size_type] c_result cdef Stream _stream = _get_stream(stream) cdef cudaStream_t _cs = _stream.view().get() mr = _get_memory_resource(mr) cdef table_view c_input = c_table.view() with nogil: - c_result = cpp_null_mask.bitmask_or(c_input, _cs, mr.get_mr()) + c_result = cpp_null_mask.bitmask_or_unique_ptr( + c_input, _cs, mr.get_mr() + ) - return buffer_to_python(move(c_result.first), _stream, mr), c_result.second + return ( + _from_cuda_device_buffer(move(c_result.first), _stream, mr), + c_result.second, + ) cpdef size_type null_count( diff --git a/python/pylibcudf/pylibcudf/nvtext/deduplicate.pyx b/python/pylibcudf/pylibcudf/nvtext/deduplicate.pyx index 20ce5c492936..977d28454b80 100644 --- a/python/pylibcudf/pylibcudf/nvtext/deduplicate.pyx +++ b/python/pylibcudf/pylibcudf/nvtext/deduplicate.pyx @@ -6,6 +6,7 @@ from cython.operator import dereference from libcpp.memory cimport unique_ptr, make_unique from libcpp.utility cimport move from pylibcudf.column cimport Column +from pylibcudf.libcudf cimport null_mask as cpp_null_mask from pylibcudf.libcudf.column.column cimport column from pylibcudf.libcudf.column.column_view cimport column_view from pylibcudf.libcudf.nvtext.deduplicate cimport ( @@ -14,14 +15,14 @@ from pylibcudf.libcudf.nvtext.deduplicate cimport ( resolve_duplicates as cpp_resolve_duplicates, resolve_duplicates_pair as cpp_resolve_duplicates_pair, ) -from pylibcudf.libcudf.types cimport size_type +from pylibcudf.libcudf.types cimport mask_state, size_type +from pylibcudf.libcudf.utilities.device_buffer cimport byte, device_buffer from pylibcudf.utils cimport _get_stream, _get_memory_resource from typing import TYPE_CHECKING if TYPE_CHECKING: from pylibcudf.typing import CudaStreamLike from rmm.pylibrmm.memory_resource cimport DeviceMemoryResource -from rmm.librmm.device_buffer cimport device_buffer from rmm.pylibrmm.stream cimport Stream from cuda.bindings.cyruntime cimport cudaStream_t @@ -35,11 +36,19 @@ cdef Column _column_from_suffix_array( cpp_suffix_array_type suffix_array, Stream stream, DeviceMemoryResource mr ): # helper to convert a suffix array to a Column + cdef unique_ptr[device_buffer[byte]] mask = ( + cpp_null_mask.create_null_mask_unique_ptr( + 0, + mask_state.UNALLOCATED, + stream.view().value(), + mr.get_mr(), + ) + ) return Column.from_libcudf( move( make_unique[column]( move(dereference(suffix_array.get())), - device_buffer(), + move(dereference(mask)), 0 ) ), stream, mr diff --git a/python/pylibcudf/pylibcudf/transform.pyx b/python/pylibcudf/pylibcudf/transform.pyx index 30e62973440c..214f49648b14 100644 --- a/python/pylibcudf/pylibcudf/transform.pyx +++ b/python/pylibcudf/pylibcudf/transform.pyx @@ -22,14 +22,13 @@ from pylibcudf.libcudf.types cimport ( udf_source_type, ) -from rmm.librmm.device_buffer cimport device_buffer -from rmm.pylibrmm.device_buffer cimport DeviceBuffer from rmm.pylibrmm.stream cimport Stream from rmm.pylibrmm.memory_resource cimport DeviceMemoryResource from .column cimport Column from .expressions cimport Expression -from .gpumemoryview cimport gpumemoryview +from .gpumemoryview cimport gpumemoryview, _from_cuda_device_buffer +from pylibcudf.libcudf.utilities.device_buffer cimport byte, device_buffer from .types cimport DataType, null_aware, output_nullability from .utils cimport _get_stream, _get_memory_resource from typing import TYPE_CHECKING @@ -75,7 +74,7 @@ cpdef tuple[gpumemoryview, int] nans_to_nulls( ------- Two-tuple of a gpumemoryview wrapping the null mask and the new null count. """ - cdef pair[unique_ptr[device_buffer], size_type] c_result + cdef pair[unique_ptr[device_buffer[byte]], size_type] c_result cdef Stream _stream = _get_stream(stream) cdef cudaStream_t _cs = _stream.view().get() @@ -88,9 +87,7 @@ cpdef tuple[gpumemoryview, int] nans_to_nulls( ) return ( - gpumemoryview( - DeviceBuffer.c_from_unique_ptr(move(c_result.first), _stream, mr) - ), + _from_cuda_device_buffer(move(c_result.first), _stream, mr), c_result.second ) @@ -230,7 +227,7 @@ cpdef tuple[gpumemoryview, int] bools_to_mask( tuple[gpumemoryview, int] Two-tuple of a gpumemoryview wrapping the bitmask and the null count. """ - cdef pair[unique_ptr[device_buffer], size_type] c_result + cdef pair[unique_ptr[device_buffer[byte]], size_type] c_result cdef Stream _stream = _get_stream(stream) cdef cudaStream_t _cs = _stream.view().get() @@ -243,9 +240,7 @@ cpdef tuple[gpumemoryview, int] bools_to_mask( ) return ( - gpumemoryview( - DeviceBuffer.c_from_unique_ptr(move(c_result.first), _stream, mr) - ), + _from_cuda_device_buffer(move(c_result.first), _stream, mr), c_result.second )