Nocturno Nocturno - 1 month ago 5
C Question

What is the meaning of the term 'arena' in relation to memory?

I'm reading a text on memory as a programming concept. In one of the later chapters, the author makes heavy use of the word 'arena' but never defines it. I searched for a technical meaning of the word but found nothing. Here are a few contexts in which the author uses the term 'arena':

"The next example of serialization incorporates a strategy called
memory allocation from a specific arena."

"...this is useful when dealing with memory leaks or when allocating
from a specific arena."

"...if we want to deallocate the memory then we will deallocate the
whole arena."

The author uses the term over 100 times in this one chapter. The only related definition in the glossary is:

allocation from arena - Technique of allocating an arena first and then
managing the allocation/deallocation within the arena by the program
itself (rather then by the process memory manager); used for
compaction and serialization of complex data structures and objects,
or for managing memory in safety-critical and /or fault-tolerant

The only related question I've found on SO is Exception safety in memory arena 2, and was no help. Can anyone define 'arena' for me given these contexts?


An arena is just a large, contiguous piece of memory that you allocate once and then use to manage memory manually by handing out parts of that memory. For example:

char * arena = malloc(HUGE_NUMBER);

unsigned int current = 0;

void * my_malloc(size_t n) { current += n; return arena + current - n; }

The point is that you get full control over how the memory allocation works. The only thing outside your control is the single library call for the initial allocation.

One popular use case is where each arena is only used to allocate memory blocks of one single, fixed size. In that case, you can write very efficient reclamation algorithms. Another use case is to have one arena per "task", and when you're done with the task, you can free the entire arena in one go and don't need to worry about tracking individual deallocations.

Each of those techniques is very specialized and generally only comes in handy if you know exactly what you're doing and why the normal library allocation is not good enough. Note that a good memory allocator will already do lots of magic itself, and you need a decent amount of evidence that that's not good enough before you start handling memory yourself.