A pool memory resource that manages fixed-size memory blocks from a pre-allocated buffer. The allocation size must be less or equal to the block size. The allocation alignment must be less or equal to the block alignment. Throws std::bad_alloc if the constraint is not met or run out of memory. More...

#include <flow_pool_memory_resource.h>

Inheritance diagram for flow::PoolMemoryResource:

Classes
struct	Header

Public Member Functions
	PoolMemoryResource (void *buffer, std::size_t capacity, std::size_t blockSize, std::size_t blockAlignment=sizeof(std::max_align_t))
	~PoolMemoryResource ()
Public Member Functions inherited from flow::MemoryResource
virtual	~MemoryResource ()=default
void *	allocate (std::size_t bytes, std::size_t alignment=alignof(std::max_align_t))
void	deallocate (void *address, std::size_t bytes, std::size_t alignment=alignof(std::max_align_t))

Protected Member Functions
virtual void *	allocateImp (std::size_t bytes, std::size_t alignment) override
virtual void	deallocateImp (void *address, std::size_t bytes, std::size_t alignment) override

Protected Attributes
std::size_t	blockSize_
std::size_t	blockAlignment_
Header *	head_

Detailed Description

A pool memory resource that manages fixed-size memory blocks from a pre-allocated buffer. The allocation size must be less or equal to the block size. The allocation alignment must be less or equal to the block alignment. Throws std::bad_alloc if the constraint is not met or run out of memory.

Definition at line 14 of file flow_pool_memory_resource.h.

Constructor & Destructor Documentation

◆ PoolMemoryResource()

flow::PoolMemoryResource::PoolMemoryResource	(	void *	buffer,
		std::size_t	capacity,
		std::size_t	blockSize,
		std::size_t	blockAlignment = sizeof(std::max_align_t) )

inline

Definition at line 16 of file flow_pool_memory_resource.h.

      : blockSize_(blockSize), blockAlignment_(blockAlignment), head_(nullptr) {
 
      Header** headPtr = &head_;
      for (;;) {
        Header* header = alignWithHeader<Header>(blockAlignment_, blockSize_, buffer, capacity);
        if (!header) {
          break;
        }
 
        new (header) Header(nullptr);
        *headPtr = header;
        headPtr = &(header->next);
 
        buffer = reinterpret_cast<std::byte*>(buffer) + sizeof(Header) + blockSize;
        capacity -= sizeof(Header) + blockSize;
      }
    }

References flow::alignWithHeader(), blockAlignment_, blockSize_, head_, and flow::PoolMemoryResource::Header::next.

◆ ~PoolMemoryResource()

flow::PoolMemoryResource::~PoolMemoryResource ( )

inline

Definition at line 35 of file flow_pool_memory_resource.h.

                          {
      // May be useless, since it has a trivial destructor.
      while (head_) {
        Header* next = head_->next;
        head_->~Header();
        head_ = next;
      }
    }

References head_.

Member Function Documentation

◆ allocateImp()

virtual void * flow::PoolMemoryResource::allocateImp	(	std::size_t	bytes,
		std::size_t	alignment )

inlineoverrideprotectedvirtual

Implements flow::MemoryResource.

Definition at line 53 of file flow_pool_memory_resource.h.

                                                                             {
      if (blockSize_ < bytes || blockAlignment_ < alignment || !head_) {
        throw std::bad_alloc();
      }
 
      void* allocatedBlock = head_ + 1;
      head_ = head_->next;
      return allocatedBlock;
    }

References blockAlignment_, blockSize_, and head_.

◆ deallocateImp()

virtual void flow::PoolMemoryResource::deallocateImp	(	void *	address,
		std::size_t	bytes,
		std::size_t	alignment )

inlineoverrideprotectedvirtual

Implements flow::MemoryResource.

Definition at line 63 of file flow_pool_memory_resource.h.

                                                                                                                               {
      if (!address) {
        return;
      }
      Header* header = reinterpret_cast<Header*>(address) - 1;
      header->next = head_;
      head_ = header;
    }