Arena Class Reference

#include <lockedpool.h>

Inheritance diagram for Arena:

Classes
struct	Stats

Public Member Functions
	Arena (void *base, size_t size, size_t alignment)
virtual	~Arena ()
	Arena (const Arena &other)=delete
Arena &	operator= (const Arena &)=delete
void *	alloc (size_t size)
void	free (void *ptr)
Stats	stats () const
bool	addressInArena (void *ptr) const

Private Types
typedef std::multimap< size_t, char * >	SizeToChunkSortedMap
typedef std::unordered_map< char *, SizeToChunkSortedMap::const_iterator >	ChunkToSizeMap

Private Attributes
SizeToChunkSortedMap	size_to_free_chunk
ChunkToSizeMap	chunks_free
ChunkToSizeMap	chunks_free_end
std::unordered_map< char *, size_t >	chunks_used
char *	base
char *	end
size_t	alignment

Member Typedef Documentation

ChunkToSizeMap

typedef std::unordered_map<char*, SizeToChunkSortedMap::const_iterator> Arena::ChunkToSizeMap

private

SizeToChunkSortedMap

typedef std::multimap<size_t, char*> Arena::SizeToChunkSortedMap

private

Constructor & Destructor Documentation

Arena() [1/2]

Arena::Arena	(	void *	base,
		size_t	size,
		size_t	alignment
	)

~Arena()

Arena::~Arena ( )

virtual

Arena() [2/2]

Arena::Arena ( const Arena &  other )

delete

Member Function Documentation

addressInArena()

bool Arena::addressInArena ( void *  ptr ) const

inline

Return whether a pointer points inside this arena. This returns base <= ptr < (base+size) so only use it for (inclusive) chunk starting addresses.

alloc()

void * Arena::alloc

(

size_t

size

)

Allocate size bytes from this arena. Returns pointer on success, or 0 if memory is full or the application tried to allocate 0 bytes.

free()

void Arena::free

(

void *

ptr

)

Free a previously allocated chunk of memory. Freeing the zero pointer has no effect. Raises std::runtime_error in case of error.

operator=()

Arena& Arena::operator= ( const Arena &  )

delete

stats()

Arena::Stats Arena::stats

(

)

const

Get arena usage statistics

Member Data Documentation

alignment

size_t Arena::alignment

private

Minimum chunk alignment

base

char* Arena::base

private

Base address of arena

chunks_free

ChunkToSizeMap Arena::chunks_free

private

Map from begin of free chunk to its node in size_to_free_chunk

chunks_free_end

ChunkToSizeMap Arena::chunks_free_end

private

Map from end of free chunk to its node in size_to_free_chunk

chunks_used

std::unordered_map<char*, size_t> Arena::chunks_used

private

Map from begin of used chunk to its size

end

char* Arena::end

private

End address of arena

size_to_free_chunk

SizeToChunkSortedMap Arena::size_to_free_chunk

private

Map to enable O(log(n)) best-fit allocation, as it's sorted by size

---

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

• src/support/lockedpool.h
• src/support/lockedpool.cpp