Cached memory allocators

[yasmin]

I am dealing with internal memory fragmentation issues in my program (C++ program on freeBSD). It involves a large number of fixed-size structures.
For example for my records which are typically fixed at 100 bytes, the default allocator allocates 128 bytes (closest power of two) wasting 28 bytes per records and this adds up to a significant amount over several thousand records.

Before jumping in and writing my own custom allocator which grabs memory pages and carves out block-sizes of 100 bytes each, I wanted to look around and see what cached allocators are available out there.

I came across allocators such as the mt-allocator in libstdc++, but the problem is that it is still a power-of-two allocator i.e. it pre-allocates only in blocks sizes 2,4,8,16,32, etc. which is exactly what I am trying to avoid.

Does anyone have experience with (or recommendations for) cached allocators where the client can specify the cache structure & size in advance (sort of like BSD memory allocator: http://docs.freebsd.or g/44doc/papers/kernmalloc.html ).
I am working in a multi-threaded environment and hence performance of the allocator is important as well.

[weaknessforcats]

Have you considered using placement new??

You allocate a buffer using new and then allocate items in the buffer byusing placement new.

[RRick]

Replacement new? That's a new term for me. I'm just going to clarify part of what W4cats said.

Each class has an operator new that can be overriden. This is similar to the operator=, where the compiler supplies a default one which you can override. In this case, the class new uses the global new to create a big pool of objects that are then farmed out.

If you make a class new, you also need to make a matching class delete.

[weaknessforcats]

Replacement new?

No. Placement new not replacement new.

Placement new is used when you specify the location where the allocation is to be made. It is used when you write your own memory managers.

int main()
{
    char buffer[1024];
 
    int* i = new(buffer) int[5];
 
}
 

Here a local 1K buffer is allocated and the new places the array of 5 ints in that buffer. It's now up to you to manage what goes on in buffer.