Custom memory allocations and arenas are notoriously hard to deal with in Rust due to the ownership model.

In a lot of projects, they can significantly improve performance. For example, let's take databases. Sending a query to a database produces a lot of temporary objects, and if the default allocator is used, you will need to allocate and deallocate thousands of small objects for each query, which is wasteful.

Almost every database engine uses custom memory pools to improve performance. Some go so far as to statically allocate all the memory before the program starts.

Another good example is scripting languages. I have an article on how Python uses arenas to reduce the number of allocations for Python types. A simple web app in Python can allocate more than a million of objects after 100 HTTP requests. Using a system allocator for such a case is wasteful.

And yet, to this day, there is no proper way to deal with custom allocations and arenas in Rust. The allocator_api, which allows using a custom allocator, has been nightly-only (experimental) since 2016.

Recently, I wanted to learn how to implement an arena in Rust. This is my explanation of how to implement a basic version.

What is an arena?

An arena is a preallocated memory block that you allocate only once. Instead of allocating 1000 small objects, you can allocate one big block of memory and put the objects there when needed. This is usually done by simply moving the pointer forward in the allocated memory block. Usually, blocks allocated inside the arena are called slots or cells.

When you are done working with the allocated block, you can reuse the allocated space for the next set of objects instead of deallocating it. You don't even need to clear the memory - all you need to do is move the pointer back to the beginning of the block.

By using arenas, you get faster allocations, less memory fragmentation, and better cache locality.

Basic implementation -> The simplest possible arena can be implemented as a vector that has a fixed capacity.