Hey guys,

Though I'm not quite there yet, I'm considering a remake (or at least a "makeover") for my previous memory manager. Let me describe what the existing version is/does and how it works, then perhaps you can help me come up with ideas for a better, faster and more efficient one...

First of all, I wrote the memory manager's "guts" in C++, and my C#-based engine would interoperate with it through a thin wrapper. One of the basic theories behind the memory manager's design is that the standard C/C++ memory management is good for static, less frequent allocations and deallocations of medium and large sized blocks of memory, but not so much for high-frequency allocations of small objects (as in a game loop). It also offers no garbage collection, no defragmentation, no streaming, etc.

This being the case, the memory manager starts with the allocation of a moderately sized "pool" of contiguous memory. The pool is expanded/shrunk based on application memory usage statistics (e.g., if the application usually needs only 2MB of memory 80% of the time it calls upon the mem manager we keep the pool at, say, 4MB, as that is pretty small still with extra room, and only up the size when more is needed on a short-term basis). It must take into account the amount of available physical memory on the local machine, and uses its own special paging file (caching can be turned on/off, btw, for performance reasons or system limitations... e.g., a game console system). Items in paging can be tracked in an easy way, a custom "paging pointer" class that stores the FILE*, length of the item (in bytes) and the offset in the paging file ([ptr + offset]). Furthermore, paging is defragmented like the physical memory to maximize its efficiency and space -- memory can also be partially paged (in other words, split) when it is beneficial to performance and RAM usage (e.g., items used very infrequently can be totally or partially paged if marked low priority). As you might have already guessed, we take advantage of the CPU's concurrent processing abilities based on the amount of CPU cores; selecting the appropriate amount of threads for the task. In fact, we use this to our advantage not only when working with physical memory but with our paging file. We split the item we want by the number of threads we have at our disposal, and each thread concurrently copies its designated portion to/from paging and physical memory -- the speed increases are significant.

One of the most important features is garbage collection. The memory manager uses its own smart-pointer system which tracks references to itself, and thus the underlying item in memory. You guessed it, when it goes out of scope it cleans up its memory and signals the memory manager of the newly freed memory's size and location. The memory manager can either immediately reuse that hunk of memory, or decide to defragment when things begin to get choppy. I also have a system in place to, if so desired, override standard C++ constructors and destructors to work directly with the memory management system.

This system's origins are rooted in an old operating system I wrote. Not a practical operating system like Windows, Mac OS or Linux, but one I wrote for learning purposes. It worked so well that I decided to apply much of the same concepts to game memory management, and came up with a pretty darn good system. But considering its age (a couple years) and the fact that I'm a better programmer than I was back then I've decided to revisit its design. And this time I think I need to put more emphasis on what I do on the managed side and what I do on the unmanaged side. For instance, might I be better off using managed threads this time to enter the unmanaged code? Might I be better off completely migrating to C#? How might performance and efficiency be increased in a newer design? What flaws are there in my old designs? Just please don't base opinions on what language is "better" or the commonly held misconception that C/C++ are superior in performance to C# (as I've seen first-hand that the opposite can often be true as well).

Regards,