column_view.hpp

前往此文件的文档。

/*
 * 版权所有 (c) 2019-2025, NVIDIA CORPORATION.
 *
 * 遵循 Apache License, Version 2.0 ("许可证") 许可。
 * 除非符合许可证的规定，否则不得使用此文件。
 * 您可以在以下网址获取许可证副本：
 *
 * https://apache.ac.cn/licenses/LICENSE-2.0
 *
 * 除非适用法律要求或书面同意，否则根据许可证
 * 分发的软件按“原样”分发，
 * 不附带任何明示或暗示的担保或条件。
 * 有关管理权限和限制的特定语言，请参见许可证。
 *
 */
#pragma once

#include <cudf/types.hpp>
#include <cudf/utilities/error.hpp>
#include <cudf/utilities/prefetch.hpp>
#include <cudf/utilities/span.hpp>
#include <cudf/utilities/traits.hpp>
#include <cudf/utilities/type_dispatcher.hpp>

#include <limits>
#include <type_traits>
#include <vector>

namespace CUDF_EXPORT cudf {
namespace detail {
class column_view_base {
 public
 template <typename T = void,
 CUDF_ENABLE_IF(std::is_same_v<T, void> or is_rep_layout_compatible<T>())>
 T const* head() const noexcept
 {
 return static_cast<T const*>(get_data());
 }

 template <typename T, CUDF_ENABLE_IF(is_rep_layout_compatible<T>())>
 T const* data() const noexcept
 {
 return head<T>() + _offset;
 }

 template <typename T, CUDF_ENABLE_IF(is_rep_layout_compatible<T>())>
 T const* begin() const noexcept
 {
 return data<T>();
 }

 template <typename T, CUDF_ENABLE_IF(is_rep_layout_compatible<T>())>
 T const* end() const noexcept
 {
 return begin<T>() + size();
 }

 [[nodiscard]] size_type size() const noexcept { return _size; }

 [[nodiscard]] bool is_empty() const noexcept { return size() == 0; }

 [[nodiscard]] data_type type() const noexcept { return _type; }

 [[nodiscard]] bool nullable() const noexcept { return nullptr != _null_mask; }

 [[nodiscard]] size_type null_count() const { return _null_count; }

 [[nodiscard]] size_type null_count(
 size_type begin,
 size_type end,
 rmm::cuda_stream_view stream = cudf::get_default_stream()) const;

 [[nodiscard]] bool has_nulls() const { return null_count() > 0; }

 [[nodiscard]] bool has_nulls(size_type begin,
 size_type end,
 rmm::cuda_stream_view stream = cudf::get_default_stream()) const
 {
 return null_count(begin, end, stream) > 0;
 }

 [[nodiscard]] bitmask_type const* null_mask() const noexcept { return _null_mask; }

 [[nodiscard]] size_type offset() const noexcept { return _offset; }

 protected
 [[nodiscard]] virtual void const* get_data() const noexcept { return _data; }

 data_type _type{type_id::EMPTY};
 size_type _size{};
 void const* _data{};
 bitmask_type const* _null_mask{};
 mutable size_type _null_count{};
 size_type _offset{};

 column_view_base() = default;
 virtual ~column_view_base() = default;
 column_view_base(column_view_base const&) = default;
 column_view_base(column_view_base&&) = default;
 column_view_base& operator=(column_view_base const&) = default;
 column_view_base& operator=(column_view_base&&) = default;

 column_view_base(data_type type,
 size_type size,
 void const* data,
 bitmask_type const* null_mask,
 size_type null_count,
 size_type offset = 0);
};

} // 命名空间 detail

class column_view : public detail::column_view_base {
 public
 column_view() = default;

 // 这些 pragma 解决 nvcc 的问题，即如果在 __device__ 代码路径中使用了 column_view，
 // 这些函数最终会被创建为 __host__ __device__，因为它们是显式 default 的。但是，如果
 // 它们最终被简单的 __host__ 函数调用
 // (例如 std::vector 析构函数)，则会出现编译错误，因为您正在尝试从 __host__ 函数调用 __host__ __device__ 函数。
 //
 //
#ifdef __CUDACC__
#pragma nv_exec_check_disable
#endif
 ~column_view() override = default;
#ifdef __CUDACC__
#pragma nv_exec_check_disable
#endif
 column_view(column_view const&) = default;
 column_view(column_view&&) = default;
 column_view& operator=(column_view const&) = default;
 column_view& operator=(column_view&&) = default;

 column_view(data_type type,
 size_type size,
 void const* data,
 bitmask_type const* null_mask,
 size_type null_count,
 size_type offset = 0,
 std::vector<column_view> const& children = {});

 [[nodiscard]] column_view child(size_type child_index) const noexcept
 {
 return _children[child_index];
 }

 [[nodiscard]] size_type num_children() const noexcept { return _children.size(); }

 auto child_begin() const noexcept { return _children.cbegin(); }

 auto child_end() const noexcept { return _children.cend(); }

 template <typename T, CUDF_ENABLE_IF(cudf::is_numeric<T>() or cudf::is_chrono<T>())>
 column_view(device_span<T const> data)
 : column_view(
 cudf::data_type{cudf::type_to_id<T>()}, data.size(), data.data(), nullptr, 0, 0, {})
 {
 CUDF_EXPECTS(
 data.size() <= static_cast<std::size_t>(std::numeric_limits<cudf::size_type>::max()),
 "Data exceeds the column size limit",
 std::overflow_error);
 }

 template <typename T, CUDF_ENABLE_IF(cudf::is_numeric<T>() or cudf::is_chrono<T>())>
 [[nodiscard]] operator device_span<T const>() const
 {
 CUDF_EXPECTS(type() == cudf::data_type{cudf::type_to_id<T>()},
 "Device span type must match column view type.");
 CUDF_EXPECTS(!nullable(), "A nullable column view cannot be converted to a device span.");
 return device_span<T const>(data<T>(), size());
 }

 protected
 void const* get_data() const noexcept override;

 private
 friend column_view bit_cast(column_view const& input, data_type type);

 std::vector<column_view> _children{};
}; // 命名空间 cudf

class mutable_column_view : public detail::column_view_base {
 public
 mutable_column_view() = default;

 ~mutable_column_view() override{
 // 需要此项，以确保任何 TU 的隐式析构函数的第一个实例不会从标记为 host+device 的 host+device 函数“构建”出来。
 //
 };

 mutable_column_view(mutable_column_view const&) = default;
 mutable_column_view(mutable_column_view&&) = default;
 mutable_column_view& operator=(mutable_column_view const&) = default;
 mutable_column_view& operator=(mutable_column_view&&) = default;

 mutable_column_view(data_type type,
 size_type size,
 void* data,
 bitmask_type* null_mask,
 size_type null_count,
 size_type offset = 0,
 std::vector<mutable_column_view> const& children = {});

 template <typename T = void,
 CUDF_ENABLE_IF(std::is_same_v<T, void> or is_rep_layout_compatible<T>())>
 T* head() const noexcept
 {
 return const_cast<T*>(detail::column_view_base::head<T>());
 }

 template <typename T, CUDF_ENABLE_IF(is_rep_layout_compatible<T>())>
 T* data() const noexcept
 {
 return const_cast<T*>(detail::column_view_base::data<T>());
 }

 template <typename T, CUDF_ENABLE_IF(is_rep_layout_compatible<T>())>
 T* begin() const noexcept
 {
 return const_cast<T*>(detail::column_view_base::begin<T>());
 }

 template <typename T, CUDF_ENABLE_IF(is_rep_layout_compatible<T>())>
 T* end() const noexcept
 {
 return const_cast<T*>(detail::column_view_base::end<T>());
 }

 [[nodiscard]] bitmask_type* null_mask() const noexcept
 {
 return const_cast<bitmask_type*>(detail::column_view_base::null_mask());
 }

 void set_null_count(size_type new_null_count);

 [[nodiscard]] mutable_column_view child(size_type child_index) const noexcept
 {
 return mutable_children[child_index];
 }

 [[nodiscard]] size_type num_children() const noexcept { return mutable_children.size(); }

 auto child_begin() const noexcept { return mutable_children.begin(); }

 auto child_end() const noexcept { return mutable_children.cend(); }

 operator column_view() const;

 protected
 [[nodiscard]] void const* get_data() const noexcept override;

 private
 friend mutable_column_view bit_cast(mutable_column_view const& input, data_type type);

 std::vector<mutable_column_view> mutable_children;
};

size_type count_descendants(column_view parent);

column_view bit_cast(column_view const& input, data_type type);

mutable_column_view bit_cast(mutable_column_view const& input, data_type type);

namespace detail {
std::size_t shallow_hash(column_view const& input);

bool is_shallow_equivalent(column_view const& lhs, column_view const& rhs);

} // 命名空间 detail
} // 命名空间 CUDF_EXPORT cudf