How can I force .NET to shrink memory

Question

I am trying to write a test for some code I wrote recently which marks memory as pinned, by allocating a GCHandle (for persistent use across interop with C++).

I am testing with a very large allocation in a single object that contains some float and int arrays. I want to check that once I've freed the GCHandle for each of the arrays, the memory is able to be garbage collected.

Currently I can see the memory allocated increasing with a call to GC.GetTotalAllocatedBytes(true); or currentProcess.WorkingSet64; and can confirm the increase is about the same size as my rough estimate of the object being created (just adding up the size of the large arrays in the object).

However, I can't seem to get the number to shrink after removing the object, even without pinning the arrays above. I've tried

GC.Collect();            
GC.WaitForPendingFinalizers();

to force collection across all generations, but my memory use never drops. I understand that the GC may be holding memory back for reuse, but I hoped there was a way to deallocate this large chunk I've created for this singular purpose..

Am I looking at the wrong metric, or is this just something that's out of my hands?

Example:

using System.Diagnostics;
using System.Runtime.InteropServices;

namespace TestApp
{
    public class MemUser
    {        
        private float[] data;
        private GCHandle dataHandle;
        public float[] Data { get { return data; } set { data = value; } }
        public MemUser(int numData)
        {
            data = new float[numData];
        }
        public long RoughSize()
        {
            return data.Length * sizeof(float);
        }
        public void GetPinnedHandles()
        {
            if (dataHandle.IsAllocated)
                dataHandle.Free();
            dataHandle = GCHandle.Alloc(dataHandle, GCHandleType.Pinned);
        }

        public void FreePinnedHandles()
        {
            if (dataHandle.IsAllocated)
                dataHandle.Free();
        }
        public void Clear()
        {
            FreePinnedHandles();
            data = null;
        }
    }

    public class Program
    {

        public static void Main(string[] args)
        {
            const int numFloats = 500 * 1000 * 1000;
            long beforeCreation = GetProcessMemory();
            // Create the object using a large chunk of memory 
            MemUser testMemory = new MemUser(numFloats);
            long roughMemSize = testMemory.RoughSize();
            // in practice, will pin the memory, but testing without for now
            //testMemory.GetPinnedHandles();

            //confirm memory in use jumps
            long afterCreation = GetProcessMemory();            
            long difference = afterCreation - beforeCreation;
            TestResult(difference, roughMemSize);

            // get rid of the object
            testMemory.Clear();
            testMemory = null;
           
            // this test fails, memory may have even gone up
            long afterDeletion = GetProcessMemory();
            difference = afterCreation - afterDeletion;
            TestResult(difference, roughMemSize);
        }


        public static long GetProcessMemory()
        {
            Process currentProcess = System.Diagnostics.Process.GetCurrentProcess();
            GC.Collect();
            GC.WaitForPendingFinalizers();
            long totalBytesOfMemoryUsed = GC.GetTotalAllocatedBytes(true);
            //long totalBytesOfMemoryUsed = currentProcess.WorkingSet64;
            return totalBytesOfMemoryUsed;
        }
        public static void TestResult(long difference, long expected)
        {
            
            if (difference >= expected)
                Console.Write($"PASS, difference ({difference}) >= {expected}\n");
            else
                Console.Write($"FAIL, difference ({difference}) < {expected}\n");
        }
    }
}

Answer 1

You should probably be using GC.GetTotalMemory(true) to get the current memory usage. See also How to get the amount of memory used by an application.

GC.GetTotalAllocatedBytes(true);

From the documentation this looks like it counts the total number of allocations, not the current memory.

currentProcess.WorkingSet64;

Since this is process memory I would assume it includes memory that is managed by the garbage collector but not currently used. When memory is collected the GC will not immediately return it to the OS, since it is likely needed soon again.

But there are other problems. When using GCHandle.Alloc you voluntary opt out from the garbage collection. So it is very important that each alloc call is matched to a free call, at least for any long running process.

I would probably recommend using the fixed statement if possible. This should both be safer, and allow the memory to be moved when not actively used by native code. Pinning small objects for a long time can cause memory fragmentation.

Answer 2

The main issue is the code shown doesn't call dataHandle.Free() in MemUser's Clear() method.

You cannot rely on garbage collection to free GCHandle because it's a struct and not created on the heap.

I reworked your code to the following, which shows the memory is being cleared for the array, albeit without a few small additional number of bytes, which are likely related to string interning within the process and memory used by the console object.

As you can see if you run this, GC.Collect() and GC.WaitForPendingFinalizers() is not needed.

        public class MemUser
        {
            private float[] data;
            private GCHandle dataHandle;
            public MemUser(int numData)
            {
                data = new float[numData];
                dataHandle = GCHandle.Alloc(data, GCHandleType.Pinned);
            }
            public long RoughSize()
            {
                return data.Length * sizeof(float);
            }

            public void Clear()
            {
                dataHandle.Free();
                data = null;
            }
        }

        public static void Main(string[] args)
        {
            Console.WriteLine("====================================================================================================");
            const int numFloats = 500 * 1000 * 1000;
            long beforeCreation = GC.GetTotalMemory(true);
            Console.WriteLine("Memory used by process: " + beforeCreation);

            // Create the object using a large chunk of memory 
            MemUser testMemory = new MemUser(numFloats);
            long afterCreation = GC.GetTotalMemory(true);
            Console.WriteLine("Memory used by process after creation of large array pinned with GCHandle: " + afterCreation);

            //deduce the delta
            long delta = afterCreation - beforeCreation;
            Console.WriteLine("Additional memory used by process for the array and GCHandle: " + delta);
            GC.AddMemoryPressure(delta);

            // free the memory
            testMemory.Clear();
            testMemory = null;

            // did we reclaim all the memory? new delta should be close to zero once we free memory
            long afterDeletion = GC.GetTotalMemory(true);
            long newDelta = afterDeletion - beforeCreation;
            Console.WriteLine("Memory after deletion: " + afterDeletion);
            Console.WriteLine("Memory delta relative to before creation: " + newDelta);
            Console.ReadLine();
        }