CODEWITHSUNDEEP
c++11boostmemory-managementallocatormemory-pool
alfC
alfC

Reputation: 16242

Allocator that manages a single block of memory

Due to system limitations, suppose that I can only allocate memory from a heap once (for example with std::allocator or some other more general C++11 compliant allocator).

This single allocation will take a large memory block. Then I want to use containers and dynamic memory but all restricted to the previously allocated block of memory.

I managed to write very simple allocator that incrementally "gives" memory shifting a pointer. In this allocator deallocate is a no-op, and memory from the block is not returned to the block. One can obviously do better than this. In other words, I want a managed heap.

Reusing this block memory in a sequence is a hard problem because one needs to manage discontinuous free segments, defragmentation, (optional) thread-safety, etc.

What is the name of this pattern? For some time I though that this was a pool allocator but it seem that that refers to something else (reusing small objects).

What features or standard libraries of C++ can I use either implement and administer such allocation or at least build my own with little effort?

I expected to find something in Boost. But Boost.Pool is something else and it looks like something like this is implemented for a specific purpose in Boost.Interprocess but it doesn't seem to be easy to use and I have a hard time to understand it outside their prototypical use (such a interprocess shared memory.)

Otherwise, the closest thing I found is this https://www.boost.org/doc/libs/1_41_0/libs/pool/doc/interfaces/pool_alloc.html , but it seems that ::new can be called several times.

Example code:

int main(){
    UserBlockAllocator<double> a(new double[1000], 1000); 
    {
        std::vector<double, UserBlockAllocator<double>> v0(600, a);
    } // v0 returns memory to block managed by a
    std::vector<double, UserBlockAllocator<double>> v1(600, a);
    std::vector<double, UserBlockAllocator<double>> v2(600, a); //out of memory
}

Upvotes: 1

Views: 1048

Answers (1)

Julius
Julius

Reputation: 1861

This pattern is referred to as arena allocator or stack allocator. If I understand the std::pmr stuff correctly, a std::pmr::monotonic_buffer_resource is related to that, but I have never tried that.

With those keywords you find something, but I have no experience with the tools.

Note that it is easy to succesfully deallocate the most recent allocation.

A powerful pattern is the composition of allocators as described in an entertaining talk by Andrei Alexandrescu at CppCon 2015. If you want to build your own tool, you might consider the combination of a FreeListAllocator (43:18) on top of your StackAllocator (35:42). This way, you may solve the problem how to manage discontinous free segments (as you describe it).

Upvotes: 2

Related Questions