device_buffer.hpp

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 <rmm/aligned.hpp>
#include <rmm/cuda_device.hpp>
#include <rmm/detail/error.hpp>
#include <rmm/detail/export.hpp>
#include <rmm/mr/per_device_resource.hpp>
#include <rmm/resource_ref.hpp>
 
#include <cuda/memory_resource>
#include <cuda/stream>
#include <cuda_runtime_api.h>
 
#include <cassert>
#include <cstddef>
 
RMM_NAMESPACE_BEGIN
class device_buffer {
 public:
  // The copy constructor and copy assignment operator without a stream are deleted because they
  // provide no way to specify an explicit stream
  device_buffer(device_buffer const& other)            = delete;
  device_buffer& operator=(device_buffer const& other) = delete;
 
  // Note: we cannot use `device_buffer() = default;` because nvcc implicitly adds
  // `__host__ __device__` specifiers to the defaulted constructor when it is called within the
  // context of both host and device functions.
  device_buffer();
 
  explicit device_buffer(
    std::size_t size,
    cuda::stream_ref stream,
    cuda::mr::any_resource<cuda::mr::device_accessible> mr = mr::get_current_device_resource_ref());
 
  // clang-format off
  // clang-format on
  explicit device_buffer(
    std::size_t size,
    std::size_t alignment,
    cuda::stream_ref stream,
    cuda::mr::any_resource<cuda::mr::device_accessible> mr = mr::get_current_device_resource_ref());
 
  device_buffer(
    void const* source_data,
    std::size_t size,
    cuda::stream_ref stream,
    cuda::mr::any_resource<cuda::mr::device_accessible> mr = mr::get_current_device_resource_ref());
 
  // clang-format off
  // clang-format on
  explicit device_buffer(
    void const* source_data,
    std::size_t size,
    std::size_t alignment,
    cuda::stream_ref stream,
    cuda::mr::any_resource<cuda::mr::device_accessible> mr = mr::get_current_device_resource_ref());
  device_buffer(
    device_buffer const& other,
    cuda::stream_ref stream,
    cuda::mr::any_resource<cuda::mr::device_accessible> mr = mr::get_current_device_resource_ref());
 
  device_buffer(device_buffer&& other) noexcept;
 
  device_buffer& operator=(device_buffer&& other) noexcept;
 
  ~device_buffer() noexcept;
 
  void reserve(std::size_t new_capacity, cuda::stream_ref stream);
 
  void resize(std::size_t new_size, cuda::stream_ref stream);
 
  void shrink_to_fit(cuda::stream_ref stream);
 
  [[nodiscard]] void const* data() const noexcept { return _data; }
 
  void* data() noexcept { return _data; }
 
  [[nodiscard]] std::size_t size() const noexcept { return _size; }
 
  [[nodiscard]] std::int64_t ssize() const noexcept
  {
    assert(size() < static_cast<std::size_t>(std::numeric_limits<int64_t>::max()) &&
           "Size overflows signed integer");
    return static_cast<int64_t>(size());
  }
 
  [[nodiscard]] bool is_empty() const noexcept { return 0 == size(); }
 
  [[nodiscard]] std::size_t capacity() const noexcept { return _capacity; }
 
  [[nodiscard]] std::size_t alignment() const noexcept { return _alignment; }
 
  [[nodiscard]] cuda::stream_ref stream() const noexcept { return _stream; }
 
  void set_stream(cuda::stream_ref stream) noexcept { _stream = stream; }
 
  [[nodiscard]] rmm::device_async_resource_ref memory_resource() noexcept { return _mr; }
 
 private:
  void* _data{nullptr};  
  std::size_t _size{};   
  std::size_t _alignment{rmm::CUDA_ALLOCATION_ALIGNMENT};  
  std::size_t _capacity{};  
  cuda::stream_ref _stream{cuda::stream_ref{
    cudaStream_t{cudaStreamDefault}}};  
 
  cuda::mr::any_resource<cuda::mr::device_accessible> _mr;  
  cuda_device_id _device{get_current_cuda_device()};
 
  void allocate_async(std::size_t bytes);
 
  void deallocate_async() noexcept;
 
  void copy_async(void const* source, std::size_t bytes);
};
  // end of group
RMM_NAMESPACE_END