Has anyone written or knows of a custom memory manager written in C#?

Question

We have certain application written in C# and we would like it to stay this way. The application manipulates many small and short lived chunks of dynamic memory. It also appears to be sensitive to GC interruptions.

We think that one way to reduce GC is to allocate 100K chunks and then allocate memory from them using a custom memory manager. Has anyone encountered custom memory manager implementations in C#?

Answer 1

Memory management of all types that descend from System.Object is performed by the garbage collector (with the exception of structures/primitives stored on the stack). In Microsoft's implementation of the CLR, the garbage collector cannot be replaced.

You can allocate some primitives on the heap manually inside of an unsafe block and then access them via pointers, but it's not recommended.

Likely, you should profile and migrate classes to structures accordingly.

Answer 2

Perhaps you should consider using some sort of pooling architecture, where you preallocate a number of items up front then lease them from the pool. This keeps the memory requirements nicely pinned. There are a few implementations on MSDN that might serve as reference:

http://msdn2.microsoft.com/en-us/library/bb517542.aspx

http://msdn.microsoft.com/en-us/library/system.net.sockets.socketasynceventargs.socketasynceventargs.aspx

...or I can offer my generic implementation if required.

Answer 3

The only time items are collected in garbage collection is when there are no more references to the object.

You should make a static class or something to keep a lifetime reference to the object for the life of the application.

If you want to manage your own memory it is possible using unsafe in C#, but you would be better to choose a language that wasn't managed like C++.

Answer 4

The obvious option is using Marshal.AllocHGlobal and Marshal.FreeHGlobal. I also have a copy of the DougLeaAllocator (dlmalloc) written and battle-tested in C#. If you want, I can get that out to you. Either way will require careful, consistent usage of IDisposable.

Answer 5

Although I don't have experience with it, you can try to write C# unmanaged code. Or maybe, you can tell GC to not collect your objects by calling

GC.KeepAlive(obj);