copying.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2018-2022, NVIDIA CORPORATION.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#pragma once
 
#include <cudf/column/column_view.hpp>
#include <cudf/lists/lists_column_view.hpp>
#include <cudf/scalar/scalar.hpp>
#include <cudf/strings/strings_column_view.hpp>
#include <cudf/structs/structs_column_view.hpp>
#include <cudf/table/table.hpp>
#include <cudf/types.hpp>
 
#include <rmm/mr/device/per_device_resource.hpp>
 
#include <memory>
#include <vector>
 
namespace cudf {
 
enum class out_of_bounds_policy : bool {
  NULLIFY,    
  DONT_CHECK  
};
 
std::unique_ptr<table> gather(
  table_view const& source_table,
  column_view const& gather_map,
  out_of_bounds_policy bounds_policy  = out_of_bounds_policy::DONT_CHECK,
  rmm::mr::device_memory_resource* mr = rmm::mr::get_current_device_resource());
 
std::unique_ptr<table> reverse(
  table_view const& source_table,
  rmm::mr::device_memory_resource* mr = rmm::mr::get_current_device_resource());
 
std::unique_ptr<column> reverse(
  column_view const& source_column,
  rmm::mr::device_memory_resource* mr = rmm::mr::get_current_device_resource());
 
std::unique_ptr<table> scatter(
  table_view const& source,
  column_view const& scatter_map,
  table_view const& target,
  rmm::mr::device_memory_resource* mr = rmm::mr::get_current_device_resource());
 
std::unique_ptr<table> scatter(
  std::vector<std::reference_wrapper<const scalar>> const& source,
  column_view const& indices,
  table_view const& target,
  rmm::mr::device_memory_resource* mr = rmm::mr::get_current_device_resource());
 
enum class mask_allocation_policy {
  NEVER,   
  RETAIN,  
  ALWAYS   
};
 
std::unique_ptr<column> empty_like(column_view const& input);
 
std::unique_ptr<column> empty_like(scalar const& input);
 
std::unique_ptr<column> allocate_like(
  column_view const& input,
  mask_allocation_policy mask_alloc   = mask_allocation_policy::RETAIN,
  rmm::mr::device_memory_resource* mr = rmm::mr::get_current_device_resource());
 
std::unique_ptr<column> allocate_like(
  column_view const& input,
  size_type size,
  mask_allocation_policy mask_alloc   = mask_allocation_policy::RETAIN,
  rmm::mr::device_memory_resource* mr = rmm::mr::get_current_device_resource());
 
std::unique_ptr<table> empty_like(table_view const& input_table);
 
void copy_range_in_place(column_view const& source,
                         mutable_column_view& target,
                         size_type source_begin,
                         size_type source_end,
                         size_type target_begin);
 
std::unique_ptr<column> copy_range(
  column_view const& source,
  column_view const& target,
  size_type source_begin,
  size_type source_end,
  size_type target_begin,
  rmm::mr::device_memory_resource* mr = rmm::mr::get_current_device_resource());
 
std::unique_ptr<column> shift(
  column_view const& input,
  size_type offset,
  scalar const& fill_value,
  rmm::mr::device_memory_resource* mr = rmm::mr::get_current_device_resource());
 
std::vector<column_view> slice(column_view const& input, host_span<size_type const> indices);
std::vector<column_view> slice(column_view const& input, std::initializer_list<size_type> indices);
 
std::vector<table_view> slice(table_view const& input, host_span<size_type const> indices);
std::vector<table_view> slice(table_view const& input, std::initializer_list<size_type> indices);
 
std::vector<column_view> split(column_view const& input, host_span<size_type const> splits);
std::vector<column_view> split(column_view const& input, std::initializer_list<size_type> splits);
 
std::vector<table_view> split(table_view const& input, host_span<size_type const> splits);
std::vector<table_view> split(table_view const& input, std::initializer_list<size_type> splits);
 
struct packed_columns {
  struct metadata {
    metadata() = default;
 
    metadata(std::vector<uint8_t>&& v) : data_(std::move(v)) {}
 
    [[nodiscard]] uint8_t const* data() const { return data_.data(); }
 
    [[nodiscard]] size_t size() const { return data_.size(); }
 
   private:
    std::vector<uint8_t> data_;
  };
 
  packed_columns()
    : metadata_(std::make_unique<metadata>()), gpu_data(std::make_unique<rmm::device_buffer>())
  {
  }
 
  packed_columns(std::unique_ptr<metadata>&& md, std::unique_ptr<rmm::device_buffer>&& gd)
    : metadata_(std::move(md)), gpu_data(std::move(gd))
  {
  }
 
  std::unique_ptr<metadata> metadata_;           
  std::unique_ptr<rmm::device_buffer> gpu_data;  
};
 
struct packed_table {
  cudf::table_view table;  
  packed_columns data;     
};
 
std::vector<packed_table> contiguous_split(
  cudf::table_view const& input,
  std::vector<size_type> const& splits,
  rmm::mr::device_memory_resource* mr = rmm::mr::get_current_device_resource());
 
packed_columns pack(cudf::table_view const& input,
                    rmm::mr::device_memory_resource* mr = rmm::mr::get_current_device_resource());
 
packed_columns::metadata pack_metadata(table_view const& table,
                                       uint8_t const* contiguous_buffer,
                                       size_t buffer_size);
 
table_view unpack(packed_columns const& input);
 
table_view unpack(uint8_t const* metadata, uint8_t const* gpu_data);
 
std::unique_ptr<column> copy_if_else(
  column_view const& lhs,
  column_view const& rhs,
  column_view const& boolean_mask,
  rmm::mr::device_memory_resource* mr = rmm::mr::get_current_device_resource());
 
std::unique_ptr<column> copy_if_else(
  scalar const& lhs,
  column_view const& rhs,
  column_view const& boolean_mask,
  rmm::mr::device_memory_resource* mr = rmm::mr::get_current_device_resource());
 
std::unique_ptr<column> copy_if_else(
  column_view const& lhs,
  scalar const& rhs,
  column_view const& boolean_mask,
  rmm::mr::device_memory_resource* mr = rmm::mr::get_current_device_resource());
 
std::unique_ptr<column> copy_if_else(
  scalar const& lhs,
  scalar const& rhs,
  column_view const& boolean_mask,
  rmm::mr::device_memory_resource* mr = rmm::mr::get_current_device_resource());
 
std::unique_ptr<table> boolean_mask_scatter(
  table_view const& input,
  table_view const& target,
  column_view const& boolean_mask,
  rmm::mr::device_memory_resource* mr = rmm::mr::get_current_device_resource());
 
std::unique_ptr<table> boolean_mask_scatter(
  std::vector<std::reference_wrapper<const scalar>> const& input,
  table_view const& target,
  column_view const& boolean_mask,
  rmm::mr::device_memory_resource* mr = rmm::mr::get_current_device_resource());
 
std::unique_ptr<scalar> get_element(
  column_view const& input,
  size_type index,
  rmm::mr::device_memory_resource* mr = rmm::mr::get_current_device_resource());
 
enum class sample_with_replacement : bool {
  FALSE,  
  TRUE    
};
 
std::unique_ptr<table> sample(
  table_view const& input,
  size_type const n,
  sample_with_replacement replacement = sample_with_replacement::FALSE,
  int64_t const seed                  = 0,
  rmm::mr::device_memory_resource* mr = rmm::mr::get_current_device_resource());
 
bool has_nonempty_nulls(column_view const& input);
 
bool may_have_nonempty_nulls(column_view const& input);
 
std::unique_ptr<column> purge_nonempty_nulls(
  column_view const& input,
  rmm::mr::device_memory_resource* mr = rmm::mr::get_current_device_resource());
 
}  // namespace cudf