A stack-based memory resource that allocates memory in a LIFO order from a fixed buffer. Deallocation must happen in reverse order of allocation. Throws std::bad_alloc if there is insufficient space for an allocation. More...

#include <flow_stack_memory_resource.h>

Inheritance diagram for flow::StackMemoryResource:

Classes
struct	Header

Public Member Functions
	StackMemoryResource (void *buffer, std::size_t capacity) noexcept
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
void *	buffer_
std::size_t	capacity_

Detailed Description

A stack-based memory resource that allocates memory in a LIFO order from a fixed buffer. Deallocation must happen in reverse order of allocation. Throws std::bad_alloc if there is insufficient space for an allocation.

Definition at line 14 of file flow_stack_memory_resource.h.

Constructor & Destructor Documentation

◆ StackMemoryResource()

flow::StackMemoryResource::StackMemoryResource	(	void *	buffer,
		std::size_t	capacity )

inlineexplicitnoexcept

Definition at line 16 of file flow_stack_memory_resource.h.

17 : buffer_(buffer), capacity_(capacity) {

18 }

flow::StackMemoryResource::buffer_

void * buffer_

Definition flow_stack_memory_resource.h:25

flow::StackMemoryResource::capacity_

std::size_t capacity_

Definition flow_stack_memory_resource.h:26

Member Function Documentation

◆ allocateImp()

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

inlineoverrideprotectedvirtual

Implements flow::MemoryResource.

Definition at line 28 of file flow_stack_memory_resource.h.

                                                                             {
      void* oldBuffer = buffer_;
 
      void* alignedHeader = flow::alignWithHeader<Header>(alignment, bytes, buffer_, capacity_);
      if (!alignedHeader) {
        throw std::bad_alloc();
      }
 
      new (alignedHeader) Header(oldBuffer);
      void* allocatedBlock = reinterpret_cast<Header*>(alignedHeader) + 1;
      buffer_ = reinterpret_cast<std::byte*>(allocatedBlock) + bytes;
      capacity_ -= sizeof(Header) + bytes;
      return allocatedBlock;
    }

References flow::alignWithHeader(), buffer_, and capacity_.

◆ deallocateImp()

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

inlineoverrideprotectedvirtual

Implements flow::MemoryResource.

Definition at line 43 of file flow_stack_memory_resource.h.

                                                                                                              {
      // TODO: assert address is the top most valid address
      assert(address == nullptr || address <= buffer_);
      if (!address) {
        return;
      }
 
      Header* header = reinterpret_cast<Header*>(address) - 1;
      std::size_t padding = pointerDistance(header->oldBuffer, header);
      buffer_ = header->oldBuffer;
      capacity_ += padding + sizeof(Header) + bytes;
      header->~Header();
    }