Arena allocator is an incremental memory allocator that allocates memory by simply incrementing a pointer. It allocates blocks of memory by using C's malloc(), but divides these blocks into smaller segments requested by calling Arena::alloc() and friends.
Creates a new Arena.
The min_block_size parameter describes the default size of the block. If the size parameter passed to alloc() is greater than the default size Arena will allocate and use a larger block, but it will not change the default min_block_size.
It's not required, but it's good practice to set min_block_size to a reasonable value that depends on the usage of Arena. Greater block sizes are generally safer and perform better than unreasonably low block sizes.
Creates a new Arena with a first block pointing to static_arena_memory.
Destroys the Arena instance.
This will destroy the Arena instance and release all blocks of memory allocated by it. It performs implicit reset(ResetPolicy::kHard).
Resets the Arena invalidating all blocks allocated.
See ResetPolicy for more details.
Returns a minimum block size.
Returns a maximum block size.
Tests whether this Arena is actually a ArenaTmp that uses temporary memory.
Returns remaining size of the current block.
Returns the current arena cursor (dangerous).
This is a function that can be used to get exclusive access to the current block's memory buffer.
Returns the end of the current arena block, only useful if you use ptr().
Sets the current arena pointer to ptr (must be within the current block).
Sets the end arena pointer to end (must be within the current block).
Allocates the requested memory specified by size and optionally casts the returned value to T*.
Pointer returned is valid until the Arena instance is destroyed or reset by calling reset(). If you plan to make an instance of C++ from the given pointer use placement new and delete operators:
Allocates size bytes of zeroed memory. See alloc() for more details.
Allocates size bytes of zeroed memory. See alloc() for more details.
Like new(std::nothrow) T(...), but allocated by Arena.
Like new(std::nothrow) T(...), but allocated by Arena.
Helper to duplicate data.
Helper to duplicate a formatted string, maximum size is 256 bytes.
Allocates size bytes of memory, ideally from an available pool.
size can't be zero, it will assert in debug mode in such case.
Like alloc(size), but provides a second argument allocated_size that provides a way to know how big the block returned actually is. This is useful for containers to prevent growing too early.
Like alloc(size), but returns zeroed memory.
Like alloc(size, allocated_size), but returns zeroed memory.
Releases the memory previously allocated by alloc(). The size argument has to be either the same size as used to call alloc() or allocated_size returned by alloc().
Calculates and returns statistics related to the current use of this Arena.
This function fills all members, but _pooled_size member (see ArenaStatistics::pooled_size() function) would be assigned to zero as Arena has no clue about the use of the requested memory.
This function could be relatively expensive depending on the number of blocks that is managed by the allocator. The primary case of this function is to use it during the development to get an idea about the use of Arena (or use of multiple Arenas if the statistics is aggregated).
Default alignment of allocation requests to use when using Arena.
Pointer in the current block.
End of the current block.
Current block.
First block (single-linked list).
Current block size shift - reverted to _min_block_size_shift every time the Arena is reset(ResetPolicy::kHard).
Minimum log2(block_size) to allocate.
Maximum log2(block_size) to allocate.
True when the Arena has a static block (static blocks are used by ArenaTmp).
Unused bytes (remaining bytes in blocks that couldn't be used because of size requests).
Slots that contain reusable memory chunks.
Large blocks for allocations that either couldn't use slots or one-shot allocation.
