|
| 1 | +/* |
| 2 | + * Copyright (c) 2025, NVIDIA CORPORATION. |
| 3 | + * |
| 4 | + * Licensed under the Apache License, Version 2.0 (the "License"); |
| 5 | + * you may not use this file except in compliance with the License. |
| 6 | + * You may obtain a copy of the License at |
| 7 | + * |
| 8 | + * http://www.apache.org/licenses/LICENSE-2.0 |
| 9 | + * |
| 10 | + * Unless required by applicable law or agreed to in writing, software |
| 11 | + * distributed under the License is distributed on an "AS IS" BASIS, |
| 12 | + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 13 | + * See the License for the specific language governing permissions and |
| 14 | + * limitations under the License. |
| 15 | + */ |
| 16 | + |
| 17 | +#include <cudf_test/base_fixture.hpp> |
| 18 | +#include <cudf_test/column_wrapper.hpp> |
| 19 | +#include <cudf_test/default_stream.hpp> |
| 20 | +#include <cudf_test/type_lists.hpp> |
| 21 | + |
| 22 | +#include <cudf/column/column_view.hpp> |
| 23 | +#include <cudf/null_mask.hpp> |
| 24 | +#include <cudf/transform.hpp> |
| 25 | + |
| 26 | +#include <random> |
| 27 | +#include <vector> |
| 28 | + |
| 29 | +template <typename T> |
| 30 | +struct TypedColumnTest : public cudf::test::BaseFixture { |
| 31 | + cudf::data_type type() { return cudf::data_type{cudf::type_to_id<T>()}; } |
| 32 | + |
| 33 | + TypedColumnTest(rmm::cuda_stream_view stream = cudf::test::get_default_stream()) |
| 34 | + : data{_num_elements * cudf::size_of(type()), stream}, |
| 35 | + mask{cudf::bitmask_allocation_size_bytes(_num_elements), stream} |
| 36 | + { |
| 37 | + std::vector<char> h_data(std::max(data.size(), mask.size())); |
| 38 | + std::iota(h_data.begin(), h_data.end(), 0); |
| 39 | + CUDF_CUDA_TRY( |
| 40 | + cudaMemcpyAsync(data.data(), h_data.data(), data.size(), cudaMemcpyDefault, stream.value())); |
| 41 | + CUDF_CUDA_TRY( |
| 42 | + cudaMemcpyAsync(mask.data(), h_data.data(), mask.size(), cudaMemcpyDefault, stream.value())); |
| 43 | + } |
| 44 | + |
| 45 | + cudf::size_type num_elements() { return _num_elements; } |
| 46 | + |
| 47 | + std::random_device r; |
| 48 | + std::default_random_engine generator{r()}; |
| 49 | + std::uniform_int_distribution<cudf::size_type> distribution{200, 1000}; |
| 50 | + cudf::size_type _num_elements{distribution(generator)}; |
| 51 | + rmm::device_buffer data{}; |
| 52 | + rmm::device_buffer mask{}; |
| 53 | + rmm::device_buffer all_valid_mask{create_null_mask( |
| 54 | + num_elements(), cudf::mask_state::ALL_VALID, cudf::test::get_default_stream())}; |
| 55 | + rmm::device_buffer all_null_mask{ |
| 56 | + create_null_mask(num_elements(), cudf::mask_state::ALL_NULL, cudf::test::get_default_stream())}; |
| 57 | +}; |
| 58 | + |
| 59 | +TYPED_TEST_SUITE(TypedColumnTest, cudf::test::Types<int32_t>); |
| 60 | + |
| 61 | +/** |
| 62 | + * @brief Verifies equality of the properties and data of a `column`'s views. |
| 63 | + * |
| 64 | + * @param col The `column` to verify |
| 65 | + */ |
| 66 | +void verify_column_views(cudf::column& col) |
| 67 | +{ |
| 68 | + cudf::column_view view = col; |
| 69 | + cudf::mutable_column_view mutable_view = col; |
| 70 | + EXPECT_EQ(col.type(), view.type()); |
| 71 | + EXPECT_EQ(col.type(), mutable_view.type()); |
| 72 | + EXPECT_EQ(col.size(), view.size()); |
| 73 | + EXPECT_EQ(col.size(), mutable_view.size()); |
| 74 | + EXPECT_EQ(col.null_count(), view.null_count()); |
| 75 | + EXPECT_EQ(col.null_count(), mutable_view.null_count()); |
| 76 | + EXPECT_EQ(view.null_count(0, col.size(), cudf::test::get_default_stream()), |
| 77 | + mutable_view.null_count(0, col.size(), cudf::test::get_default_stream())); |
| 78 | + EXPECT_EQ(view.has_nulls(0, col.size(), cudf::test::get_default_stream()), |
| 79 | + mutable_view.has_nulls(0, col.size(), cudf::test::get_default_stream())); |
| 80 | + EXPECT_EQ(col.null_count(), mutable_view.null_count()); |
| 81 | + EXPECT_EQ(col.nullable(), view.nullable()); |
| 82 | + EXPECT_EQ(col.nullable(), mutable_view.nullable()); |
| 83 | + EXPECT_EQ(col.num_children(), view.num_children()); |
| 84 | + EXPECT_EQ(col.num_children(), mutable_view.num_children()); |
| 85 | + EXPECT_EQ(view.head(), mutable_view.head()); |
| 86 | + EXPECT_EQ(view.data<char>(), mutable_view.data<char>()); |
| 87 | + EXPECT_EQ(view.offset(), mutable_view.offset()); |
| 88 | +} |
| 89 | + |
| 90 | +TYPED_TEST(TypedColumnTest, CopyConstructorWithMask) |
| 91 | +{ |
| 92 | + cudf::column original{ |
| 93 | + this->type(), this->num_elements(), std::move(this->data), std::move(this->all_valid_mask), 0}; |
| 94 | + cudf::column copy{original, cudf::test::get_default_stream()}; |
| 95 | + verify_column_views(copy); |
| 96 | + CUDF_TEST_EXPECT_COLUMNS_EQUAL(original, copy); |
| 97 | + |
| 98 | + // Verify deep copy |
| 99 | + cudf::column_view original_view = original; |
| 100 | + cudf::column_view copy_view = copy; |
| 101 | + EXPECT_NE(original_view.head(), copy_view.head()); |
| 102 | + EXPECT_NE(original_view.null_mask(), copy_view.null_mask()); |
| 103 | +} |
0 commit comments