Question

Let’s say I have a program(C++, for example) that allocates multiple objects, never bigger than a given size(let’s call it MAX_OBJECT_SIZE).

I also have a region(I’ll call it a “page”) on the heap(allocated with, say, malloc(REGION_SIZE), where REGION_SIZE >= MAX_OBJECT_SIZE).
I keep reserving space in that page until the filled space equals PAGE_SIZE(or at least gets > PAGE_SIZE – MAX_OBJECT_SIZE).

Now, I want to allocate more memory. Obviously my previous “page” won’t be enough. So I have at least two options:

1. Use realloc(page, NEW_SIZE), where NEW_SIZE > PAGE_SIZE;
2. Allocate a new “page”(page2) and put the new object there.

If I wanted to have a custom allocate function, then:

1. Using the first method, I’d see how much I had filled, and then put my new object there(and add the size of the object to my filled memory variable).
2. Using the second method, I’d have a list(vector? array?) of pages, then look for the current page, and then use a method similar to 1 on the selected page.

Eventually, I’d need a method to free memory too, but I can figure out that part.

So my question is: What is the most efficient way to solve a problem like this? Is it option 1, option 2 or some other option I haven’t considered here? Is a small benchmark needed/enough to draw conclusions for real-world situations?
I understand that different operations may perform differently, but I’m looking for an overall metric.

Answer 1

In my experience option 2 is much easier to work with has minimal overhead. Realloc does not guarantee it will increase the size of existing memory. And in practice it almost never does. If you use it you will need to go back and remap all of the old objects. That would require that you remember where every object allocated was… That can be a ton over overhead.

But it’s hard to qualify “most efficient” without knowing exactly what metrics you use.

This is the memory manager I always use. It works for the entire application not just one object.

allocs:

for every allocation determine the size of the object allocated.

1 look at a link list of frees for objects of that size to see if anything has been freed if so take the first free

2 look for in a look up table and if not found

2.1 allocate an array of N objects of the size being allocated.

3 return the next free object of the desired size.

3.1 if the array is full add a new page.

N objects can be programmer tunned. If you know you have a million 16 byte objects you might want that N to be slightly higher.

for objects over some size X, do not keep an array simply allocate a new object.

frees:

determine the size of the object, add it to the link list of frees.

if the size of the object allocated is less than the size of a pointer the link list does not need to incur any memory overhead. simply use the already allocated memory to store the nodes.

The problem with this method is memory is never returned to the operating system until the application has exited or the programmer decides to defragment the memory. defragmenting is another post. it can be done.