thrust_allocator_adaptor.hpp

/*
 * 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 <thrust/detail/type_traits/pointer_traits.h>
#include <thrust/device_malloc_allocator.h>
 
namespace rmm::mr {
template <typename T>
class thrust_allocator : public thrust::device_malloc_allocator<T> {
 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, device_memory_resource* 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(num * sizeof(T), _stream)));
  }
 
  void deallocate(pointer ptr, size_type num)
  {
    return _mr->deallocate(thrust::raw_pointer_cast(ptr), num * sizeof(T), _stream);
  }
 
  [[nodiscard]] device_memory_resource* resource() const noexcept { return _mr; }
 
  [[nodiscard]] cuda_stream_view stream() const noexcept { return _stream; }
 
 private:
  cuda_stream_view _stream{};
  device_memory_resource* _mr{rmm::mr::get_current_device_resource()};
};
}  // namespace rmm::mr