Public Member Functions | Static Public Member Functions | List of all members
thrust::mr::unsynchronized_pool_resource< Upstream > Class Template Referencefinal

#include <thrust/mr/pool.h>

Inheritance diagram for thrust::mr::unsynchronized_pool_resource< Upstream >:
thrust::mr::memory_resource< Upstream::pointer >

Public Member Functions

 unsynchronized_pool_resource (Upstream *upstream, pool_options options=get_default_options())
 unsynchronized_pool_resource (pool_options options=get_default_options())
 ~unsynchronized_pool_resource ()
void release ()
virtual void_ptr do_allocate (std::size_t bytes, std::size_t alignment=alignof(max_align_t))
virtual void do_deallocate (void_ptr p, std::size_t n, std::size_t alignment=alignof(max_align_t))
- Public Member Functions inherited from thrust::mr::memory_resource< Upstream::pointer >
virtual ~memory_resource ()
pointer allocate (std::size_t bytes, std::size_t alignment=alignof(max_align_t))
void deallocate (pointer p, std::size_t bytes, std::size_t alignment=alignof(max_align_t))
__host__ __device__ bool is_equal (const memory_resource &other) const noexcept
__host__ virtual __device__ bool do_is_equal (const memory_resource &other) const noexcept

Static Public Member Functions

static pool_options get_default_options ()

Additional Inherited Members

- Public Types inherited from thrust::mr::memory_resource< Upstream::pointer >
typedef Upstream::pointer pointer

Detailed Description

template<typename Upstream>
class thrust::mr::unsynchronized_pool_resource< Upstream >

A memory resource adaptor allowing for pooling and caching allocations from Upstream, using memory allocated from it for both blocks then allocated to the user and for internal bookkeeping of the cached memory.

On a typical memory resource, calls to allocate and deallocate actually allocate and deallocate memory. Pooling memory resources only allocate and deallocate memory from an external resource (the upstream memory resource) when there's no suitable memory currently cached; otherwise, they use memory they have acquired beforehand, to make memory allocation faster and more efficient.

The non-disjoint version of the pool resource uses a single upstream memory resource. Every allocation is larger than strictly necessary to fulfill the end-user's request, because it needs to account for the memory overhead of tracking the memory blocks and chunks inside those same memory regions. Nevertheless, this version should be more memory-efficient than the disjoint_unsynchronized_pool_resource, because it doesn't need to allocate additional blocks of memory from a separate resource, which in turn would necessitate the bookkeeping overhead in the upstream resource.

This version requires that memory allocated from Upstream is accessible from device. It supports smart references, meaning that the non-managed CUDA resource, returning a device-tagged pointer, will work, but will be much less efficient than the disjoint version, which wouldn't need to touch device memory at all, and therefore wouldn't need to transfer it back and forth between the host and the device whenever an allocation or a deallocation happens.

Template Parameters
Upstreamthe type of memory resources that will be used for allocating memory blocks

The documentation for this class was generated from the following file: