9

I have been researching switching my allocation method from simpling overloading new to using multiple allocators through the code base. However, how can I efficiently use multiple allocators? The only way I could devise through my research was having the allocators be globals. Although, this seemed to have issues since it is typically a "bad idea" to have the use of many globals.

I am looking to find out how to use multiple allocators efficiently. For example, I may have one allocator use only for a particular subsystem, and a different allocator for a different subsystem. I am not sure if the only way to do this is through using multiple global allocators, so I am hoping for a better insight and design.

Improve this question
2
  • 4
    Why would an allocator have to be global? As long as each allocated unit has a reference to its own allocator so that it can be correctly freed, does it matter where the allocator actually is? Commented Mar 10, 2012 at 22:06
  • Where would the allocator leave for the allocated unit though? It would seem to me as if it would have to be global. Commented Mar 10, 2012 at 22:17

3 Answers 3

Reset to default
11
+50

In C++2003 the allocator model is broken and there isn't really a proper solution. For C++2011 the allocator model was fixed and you can have per instance allocators which are propagated down to contained objects (unless, of course, you choose to replace them). Generally, for this to be useful you probably want to use a dynamically polymorphic allocator type which the default std::allocator<T> is not required to be (and generally I would expect it not to be dynamically polymorphic although this may be the better implementation choice). However, [nearly] all classes in the standard C++ library which do memory allocation are templates which take the allocator type as template argument (e.g. the IOStreams are an exception but generally they don't allocate any interesting amount of memory to warrant adding allocator support).

In several of your comments you are insisting that allocators effectively need to be global: that is definitely not correct. Each allocator-aware type stores a copy of the allocator given (at least, if it has any instance level data; if it doesn't there isn't anything to store as is e.g. the case with the default allocator using operator new() and operator delete()). This effectively means that the allocation mechanism given to an object needs to stick around as long as there is any active allocator using it. This can be done using a global object but it can also be done using e.g. reference counting or associating the allocator with an object containing all objects to which it is given. For example, if each "document" (think XML, Excel, Pages, whatever structure file) passes an allocator to its members, the allocator can live as member of the document and get destroyed when the document is destroyed after all its content is destroyed. This part of the allocator model should work with pre-C++2011 classes, as long as they take an allocator argument, as well. However, in pre-C++2011 classes the allocator won't be passed to contained objects. For example, if you give an allocator to a std::vector<std::string> the C++2011 version will create the std::strings using the allocator given to the std::vector<std::string> appropriately converted to deal with std::strings. This won't happen with pre-C++2011 allocators.

To actually use allocators in a subsystem you will effectively need to pass them around, either explicitly as an argument to your functions and/or classes or implicitly by way of allocator-aware objects which serve as a context. For example, if you use any of the standard containers as [part of] the context passed around, you can obtain the used allocator using its get_allocator() method.

Improve this answer
Sign up to request clarification or add additional context in comments.

2 Comments

Very interesting, I had not thought of the reference counting. Since I will be creating my own allocator, should I then have it inherit from something such as weak_reference to allow for reference counting?
Personally, I would use an std::shared_ptr<my_allocation_base> as a member of an allocator my_allocator. The actual allocation logic would be located in classes derived from my_allocation_base. If you only have one allocation approach you can, of course, put the logic directly into the pointed to object. Using weak_reference (don't know what this is) sounds as if it doesn't work: you want to have an actual reference to the allocation object from every object still holding correspondingly allocated memory and the reference count be reduced once it was released.
3

You can use new placement. This can be used either to specify a memory region, or to overload the type's static void* operator new(ARGS). Globals are not required, and really a bad idea here, if efficiency is important and your problems are demanding. You would need to hold on to one or more allocators, of course.

The best thing you can do is understand your problems and create strategies for your allocators based on the patterns in your program and on actual usage. The general purpose malloc is very good at what it does, so always use that as one baseline to measure against. If you don't know your usage patterns, your allocator will likely be slower than malloc.

Also keep in mind that these types you use will lose compatability with standard containers, unless you use a global or thread local and custom allocator for standard containers -- which quickly defeats the purpose in many contexts. The alternative is to also write your own allocators and containers.

Improve this answer

8 Comments

How should the allocators be held? You mentioned they should not be global, but where should the be then? (Also, I am not concerned with compatability with standard containers as I have my own already).
@chadb It depends on the problem. I use both member reference (e.g. with reference counted allocations) and external reference (e.g. an allocator for a graph whose nodes are all managed by one allocator). Thread local allocators (accessed by the thread or its data) are another approach, although I have favored external reference in that case.
What about specifically for an allocator used for an entire subsystem (whose root is not in a singleton)? That seems to be my primary use case at the moment, as I mentioned in the orignal post I believe. Where would the allocator for that be stored? I can not think of any case besides for a global there.
@chadb I mentioned graphs -- Assume this nontrivial example: this->view()->rootView()->bitmapImageAllocator(). In this case, the allocator is held by the root view. You can also hide the default operator new I mentioned to enforce a particular allocator, or pass it in as a constructor parameter. It's not always convenient, but it's possible to pass/hold those references where custom allocators are important. So objects can hold on to references or you can pass them around as parameters as needed. You could also make them thread local.
What if I am not using "graphs" (I am not actually familiar with "graphs", not does it fit into my current architecture). Is the issue with threading the only reason not to make them global? If that is the case, why not just make the particular "allocate" function thread safe in side of the function?
|
1

Some uses for multiple allocators include reduced CPU usage, reduced fragmentation, and fewer cache misses. So the solution really depends on what type and where your allocation bottleneck is.

CPU usage will be improved by having lockless heaps for active threads, eliminating synchronization. This can be done in your memory allocator with thread local storage.

Fragmentation will be improved by having allocations with different lifespans be allocated from different heaps -- allocating background IO in a separate heap from the users active task will ensure the two do not confound one another. This is likely done by having a stack for your heaps, and push/popping when you're in different functional scopes.

Cache misses will be improved by keeping allocations within a system together. Having Quadtree/Octree allocations come from their own heap will guarantee there is locality in view frustrum queries. This is best done by overloading operator new and operator delete for the specific classes (OctreeNode).

Improve this answer

1 Comment

Perhaps something what misinterpreted, however, my question was mainly how to use multiple allocators, not why.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.