device_buffer.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2019-2025, 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 <rmm/cuda_device.hpp>
#include <rmm/cuda_stream_view.hpp>
#include <rmm/detail/error.hpp>
#include <rmm/detail/export.hpp>
#include <rmm/mr/device/per_device_resource.hpp>
#include <rmm/resource_ref.hpp>
 
#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());
 
  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());
 
  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]] 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() const noexcept { return _mr; }
 
 private:
  void* _data{nullptr};        
  std::size_t _size{};         
  std::size_t _capacity{};     
  cuda_stream_view _stream{};  
 
  rmm::device_async_resource_ref _mr{
    rmm::mr::get_current_device_resource_ref()};  
  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