table_device_view.cuh

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: Copyright (c) 2019-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 * SPDX-License-Identifier: Apache-2.0
 */
#pragma once
 
#include <cudf/column/column_device_view.cuh>
#include <cudf/table/table_view.hpp>
#include <cudf/types.hpp>
#include <cudf/utilities/default_stream.hpp>
#include <cudf/utilities/memory_resource.hpp>
 
#include <rmm/device_buffer.hpp>
#include <rmm/resource_ref.hpp>
 
#include <cuda/stream>
 
#include <cassert>
#include <memory>
 
namespace CUDF_EXPORT cudf {
namespace detail {
 
template <typename ColumnDeviceView, typename HostTableView>
class table_device_view_base {
 public:
  table_device_view_base()                              = delete;
  ~table_device_view_base()                             = default;
  table_device_view_base(table_device_view_base const&) = default;  
  table_device_view_base(table_device_view_base&&)      = default;  
  table_device_view_base& operator=(table_device_view_base const&) = default;
  table_device_view_base& operator=(table_device_view_base&&) = default;
 
  __device__ ColumnDeviceView* begin() const noexcept { return _columns; }
 
  __device__ ColumnDeviceView* end() const noexcept { return _columns + _num_columns; }
 
  __device__ ColumnDeviceView const& column(size_type column_index) const noexcept
  {
    assert(column_index >= 0);
    assert(column_index < _num_columns);
    return _columns[column_index];
  }
 
  __device__ ColumnDeviceView& column(size_type column_index) noexcept
  {
    assert(column_index >= 0);
    assert(column_index < _num_columns);
    return _columns[column_index];
  }
 
  [[nodiscard]] __host__ __device__ size_type num_columns() const noexcept { return _num_columns; }
 
  [[nodiscard]] __host__ __device__ size_type num_rows() const noexcept { return _num_rows; }
 
  void destroy();
 
 private:
  ColumnDeviceView* _columns{};  
  size_type _num_rows{};
  size_type _num_columns{};
 
 protected:
  table_device_view_base(HostTableView source_view, ColumnDeviceView* columns);
};
}  // namespace detail
 
class table_device_view : public detail::table_device_view_base<column_device_view, table_view> {
 public:
  static std::unique_ptr<table_device_view, std::function<void(table_device_view*)>> create(
    table_view source_view,
    cuda::stream_ref stream           = cudf::get_default_stream(),
    rmm::device_async_resource_ref mr = cudf::get_current_device_resource_ref());
 
 private:
  table_device_view(table_view source_view, column_device_view* columns);
};
 
class mutable_table_device_view
  : public detail::table_device_view_base<mutable_column_device_view, mutable_table_view> {
 public:
  static std::unique_ptr<mutable_table_device_view, std::function<void(mutable_table_device_view*)>>
  create(mutable_table_view source_view,
         cuda::stream_ref stream           = cudf::get_default_stream(),
         rmm::device_async_resource_ref mr = cudf::get_current_device_resource_ref());
 
 private:
  mutable_table_device_view(mutable_table_view source_view, mutable_column_device_view* columns);
};
 
template <typename ColumnDeviceView, typename HostTableView>
std::pair<std::unique_ptr<rmm::device_buffer>, ColumnDeviceView*> create_column_device_views(
  HostTableView source_view,
  cuda::stream_ref stream,
  rmm::device_async_resource_ref mr = cudf::get_current_device_resource_ref());
 
}  // namespace CUDF_EXPORT cudf