thrust_allocator_adaptor.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2019-2021, 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/mr/device/device_memory_resource.hpp>
#include <rmm/mr/device/per_device_resource.hpp>
 
#include <rmm/detail/thrust_namespace.h>
#include <thrust/device_malloc_allocator.h>
#include <thrust/device_ptr.h>
#include <thrust/memory.h>
 
#include <cuda/memory_resource>
 
namespace rmm::mr {
template <typename T>
class thrust_allocator : public thrust::device_malloc_allocator<T> {
  using async_resource_ref = cuda::mr::async_resource_ref<cuda::mr::device_accessible>;
 
 public:
  using Base      = thrust::device_malloc_allocator<T>;  
  using pointer   = typename Base::pointer;              
  using size_type = typename Base::size_type;            
 
  template <typename U>
  struct rebind {
    using other = thrust_allocator<U>;  
  };
 
  thrust_allocator() = default;
 
  explicit thrust_allocator(cuda_stream_view stream) : _stream{stream} {}
 
  thrust_allocator(cuda_stream_view stream, async_resource_ref mr) : _stream{stream}, _mr(mr) {}
 
  template <typename U>
  thrust_allocator(thrust_allocator<U> const& other)
    : _mr(other.resource()), _stream{other.stream()}
  {
  }
 
  pointer allocate(size_type num)
  {
    return thrust::device_pointer_cast(
      static_cast<T*>(_mr.allocate_async(num * sizeof(T), _stream)));
  }
 
  void deallocate(pointer ptr, size_type num)
  {
    return _mr.deallocate_async(thrust::raw_pointer_cast(ptr), num * sizeof(T), _stream);
  }
 
  [[nodiscard]] async_resource_ref memory_resource() const noexcept { return _mr; }
 
  [[nodiscard]] cuda_stream_view stream() const noexcept { return _stream; }
 
  friend void get_property(thrust_allocator const&, cuda::mr::device_accessible) noexcept {}
 
 private:
  cuda_stream_view _stream{};
  async_resource_ref _mr{rmm::mr::get_current_device_resource()};
};  // end of group
}  // namespace rmm::mr