device_buffer.hpp

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: Copyright (c) 2019-2026, NVIDIA CORPORATION.
 * SPDX-License-Identifier: Apache-2.0
 */
#pragma once
 
#include <rmm/aligned.hpp>
#include <rmm/cuda_device.hpp>
#include <rmm/cuda_stream_view.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_runtime_api.h>
 
#include <cassert>
#include <cstddef>
 
namespace RMM_NAMESPACE {
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_view stream,
                         device_async_resource_ref mr = mr::get_current_device_resource_ref());
 
  explicit device_buffer(std::size_t size,
                         std::size_t alignment,
                         cuda_stream_view stream,
                         device_async_resource_ref mr = mr::get_current_device_resource_ref());
 
  device_buffer(void const* source_data,
                std::size_t size,
                cuda_stream_view stream,
                device_async_resource_ref mr = mr::get_current_device_resource_ref());
 
  explicit device_buffer(void const* source_data,
                         std::size_t size,
                         std::size_t alignment,
                         cuda_stream_view stream,
                         device_async_resource_ref mr = mr::get_current_device_resource_ref());
  device_buffer(device_buffer const& other,
                cuda_stream_view stream,
                device_async_resource_ref 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_view stream);
 
  void resize(std::size_t new_size, cuda_stream_view stream);
 
  void shrink_to_fit(cuda_stream_view 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_view stream() const noexcept { return _stream; }
 
  void set_stream(cuda_stream_view 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_view _stream{};  
 
  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
}  // namespace RMM_NAMESPACE