Memory Management : Prevent Memory from Being Moved, Allocate Unmanaged Memory

Prevent Memory from Being Moved

Scenario/Problem:	You need to force an object to remain in its memory location, especially for interop with native code. When the garbage collector runs, it moves objects around in memory in a compaction process. This requires fixing up all the memory addresses for all the moved objects. Obviously, this is not possible for objects the GC does not know about—such as in a native code interop situation.
Solution:	“Fix” the memory in place.

int[] vals = new int[10];
//the location of vals is fixed for the duration of the block
fixed (int* pI = &vals[0])
{
    pI[i] = 13;
}

Note

You should keep memory fixed only as long as you absolutely need to. While memory is fixed in place, the GC is less efficient as it attempts to work around the unmovable block.

Allocate Unmanaged Memory

Scenario/Problem:

You need a buffer of memory that unmanaged code can access and you don’t want the GC involved at all.

Solution:

Use the Marshal.AllocHGlobal() method and manually add some memory pressure: unsafe class MyDataClass { IntPtr _memory = IntPtr.Zero; public int NumObjects { get; private set; } public int MemorySize { get { return sizeof(Int32) * NumObjects; } } public MyDataClass(int numObjects) { this.NumObjects = numObjects; _memory = Marshal.AllocHGlobal(MemorySize); //we should tell the garbage collector that we are using more //memory so it can schedule collections better //(note--it still doesn't change the amount //that GC.GetTotalMemory returns) GC.AddMemoryPressure(MemorySize); Int32* pI = (Int32*)_memory; for (int i = 0; i < NumObjects; ++i) { pI[i] = i; } } //unmanaged resources need a finalizer to make //sure they're cleaned up! ~MyDataClass() { if (_memory != IntPtr.Zero) { Marshal.FreeHGlobal(_memory); //tell garbage collector memory is gone GC.RemoveMemoryPressure(MemorySize); } } }

When you allocate memory in this way, .NET knows nothing about it, as this program snippet shows:

static void Main(string[] args)
{
    Console.WriteLine("Memory usage before unmanaged allocation: {0:N0}", GC.GetTotalMemory(false));
    MyDataClass obj = new MyDataClass(10000000);

    //unmanaged memory is not counted!
    Console.WriteLine("Memory usage after unmanaged allocation: {0:N0}", GC.GetTotalMemory(false));
}

					  

The output is as follows:

Memory usage before unmanaged allocation: 665,456
Memory usage after unmanaged allocation: 706,416

The AddMemoryPressure method notifies the CLR that it should take this into account when scheduling garbage collection, but that is all the involvement it has. When your unmanaged memory is freed, you should release this pressure.