cetl::pmr::UnsynchronizedBufferMemoryResourceDelegate< UpstreamMemoryResourceType > Class Template Reference

#include "cetl/pmr/buffer_memory_resource_delegate.hpp"

Public Member Functions
	UnsynchronizedBufferMemoryResourceDelegate (void *buffer, std::size_t buffer_size_bytes, UpstreamMemoryResourceType *upstream, std::size_t upstream_max_size_bytes) noexcept
	UnsynchronizedBufferMemoryResourceDelegate (const UnsynchronizedBufferMemoryResourceDelegate &)=delete
UnsynchronizedBufferMemoryResourceDelegate &	operator= (const UnsynchronizedBufferMemoryResourceDelegate &)=delete
	UnsynchronizedBufferMemoryResourceDelegate (UnsynchronizedBufferMemoryResourceDelegate &&) noexcept=default
UnsynchronizedBufferMemoryResourceDelegate &	operator= (UnsynchronizedBufferMemoryResourceDelegate &&)=delete
constexpr UpstreamMemoryResourceType *	upstream_resource () const
constexpr void *	allocate (std::size_t size_bytes, std::size_t alignment=alignof(std::max_align_t))
constexpr void *	reallocate (void *p, std::size_t old_size_bytes, std::size_t new_size_bytes, std::size_t new_align=alignof(std::max_align_t))
constexpr void	deallocate (void *p, std::size_t size_bytes, std::size_t alignment=alignof(std::max_align_t))
std::size_t	max_size () const noexcept
void *	data () noexcept
const void *	data () const noexcept
std::size_t	size () const noexcept

Detailed Description

template<typename UpstreamMemoryResourceType>
class cetl::pmr::UnsynchronizedBufferMemoryResourceDelegate< UpstreamMemoryResourceType >

Memory resource that supports a single allocation request within a single, contiguous block of memory.

Without any memory barriers or other synchronization primitives this is one of the simplest possible implementations of a std::pmr::memory_resource with only one feature of supporting an, optional, upstream allocator.

Delegate Class

You will need an implementation of memory_resource that uses this class as a delegate since this class does not directly rely on any C++17 nor CETL pf17 types. This allows you to use it with std::pmr::memory_resource or cetl::pf17::pmr::memory_resource.

Over-Alignment

This class supports over-alignment but you will need to over-provision the backing array to support this feature. For example, if the buffer is too small to support the requested alignment then the allocation will fail as this example, using the delegate via cetl::pf17::pmr::UnsynchronizedArrayMemoryResource, demonstrates:

    constexpr std::size_t                                               BufferSizeBytes = 64;
    cetl::pf17::pmr::UnsynchronizedArrayMemoryResource<BufferSizeBytes> resource{};
 
    // let's say we have a buffer that must be aligned to a 128-byte (1024-bit) boundary. If we tried to use
    // UnsynchronizedArrayMemoryResource with a 64-byte internal array, on a typical system, the allocation would fail.
 
    void* r = nullptr;
#if defined(__cpp_exceptions)
    try
    {
#endif
        r = resource.allocate(64, 128);
#if defined(__cpp_exceptions)
    } catch (const std::bad_alloc&)
    {
        // This is expected.
    }
#endif
    std::cout << "Over-aligned attempt failed: " << r << std::endl;
 

By over-provisioning the buffer the same alignment will succeed:

// By over-provisioning the buffer you can now get the alignment you want:
constexpr std::size_t                                               BufferSizeBytes = 64 + 128;
cetl::pf17::pmr::UnsynchronizedArrayMemoryResource<BufferSizeBytes> resource{};
 
void* r = resource.allocate(64, 128);
 
std::cout << "Over-aligned address at: " << r << std::endl;
 
resource.deallocate(r, 64, 128);

(See full example here...)

Template Parameters

MemoryResourceType

The type of the upstream memory resource to use.

Constructor & Destructor Documentation

UnsynchronizedBufferMemoryResourceDelegate()

template<typename UpstreamMemoryResourceType>

cetl::pmr::UnsynchronizedBufferMemoryResourceDelegate< UpstreamMemoryResourceType >::UnsynchronizedBufferMemoryResourceDelegate ( void * buffer, std::size_t buffer_size_bytes, UpstreamMemoryResourceType * upstream, std::size_t upstream_max_size_bytes )

inlinenoexcept

Designated constructor that initializes the object with a fixed buffer and an optional upstream memory resource.

Parameters

buffer	The buffer that is used to satisfy allocation requests.
buffer_size_bytes	The size, in bytes, of the buffer.
upstream	An optional upstream memory resource to use if the buffer is already in use.
upstream_max_size_bytes	The maximum size of the upstream buffer.

Member Function Documentation

data() [1/2]

template<typename UpstreamMemoryResourceType>

const void * cetl::pmr::UnsynchronizedBufferMemoryResourceDelegate< UpstreamMemoryResourceType >::data ( ) const

inlinenoexcept

Direct access to the internal data. It is generally not safe to use this memory directly.

data() [2/2]

template<typename UpstreamMemoryResourceType>

void * cetl::pmr::UnsynchronizedBufferMemoryResourceDelegate< UpstreamMemoryResourceType >::data ( )

inlinenoexcept

Direct access to the internal data. It is generally not safe to use this memory directly.

size()

template<typename UpstreamMemoryResourceType>

std::size_t cetl::pmr::UnsynchronizedBufferMemoryResourceDelegate< UpstreamMemoryResourceType >::size ( ) const

inlinenoexcept

The size in bytes of the internal buffer.

---

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

• /__w/CETL/CETL/include/cetl/pmr/buffer_memory_resource_delegate.hpp