I have an single threaded, embedded application that allocates and deallocates lots and lots of small blocks (32-64b). The perfect scenario for a cache based allocator. And although I could TRY to write one it’ll likely be a waste of time, and not as well tested and tuned as some solution that’s already been on the front lines.
So what would be the best allocator I could use for this scenario?
Note: I’m using a Lua Virtual Machine in the system (which is the culprit of 80+% of the allocations), so I can’t trivially refactor my code to use stack allocations to increase allocation performance.
I did some research on this very topic recently, as we had an issue with memory fragmentation. In the end we decided to stay with GNU libc’s implementation, and add some application-level memory pools where necessary. There were other allocators which had better fragmentation behavior, but we weren’t comfortable enough with them replace malloc globally. GNU’s has the benefit of a long history behind it.
In your case it seems justified; assuming you can’t fix the VM, those tiny allocations are very wasteful. I don’t know what your whole environment is, but you might consider wrapping the calls to malloc/realloc/free on just the VM so that you can pass it off to a handler designed for small pools.