CODEWITHSUNDEEP
c#.netmemory-managementmemory-leaksgarbage-collection
Alex Zhukovskiy
Alex Zhukovskiy

Reputation: 10015

Some cases when necessary to call GC.Collect manualy

I've read many articles about GC, and about "do no care about objects" paradigm, but i did a test for proove it.

So idea is: i'm creating a lot of large objects stored in local functions, and I suspect that after all tasks are done it will clean the memory itself. But GC didn't. So test code:

class Program
{
    static void Main()
    {
        var allDone = new ManualResetEvent(false);
        int completed = 0;
        long sum = 0; //just to prevent optimizer to remove cycle etc.
        const int count = int.MaxValue/10000000;
        for (int i = 0; i < count; i++)
        {
            ThreadPool.QueueUserWorkItem(delegate
                                         {
                                             unchecked
                                             {
                                                 var dumb = new Dumb();
                                                 var localSum = 0;
                                                 foreach (int x in dumb.Arr)
                                                 {
                                                     localSum += x;
                                                 }
                                                 sum += localSum;
                                             }
                                             if (Interlocked.Increment(ref completed) == count)
                                                 allDone.Set();
                                             if (completed%(count/100) == 0)
                                                 Console.WriteLine("Progress = {0:N2}%", 100.0*completed/count);
                                         });
        }
        allDone.WaitOne();
        Console.WriteLine("Done. Result : {0}", sum);
        Console.ReadKey();
        GC.Collect();
        Console.WriteLine("GC Collected!");
        Console.WriteLine("GC CollectionsCount 0 = {0}, 1 = {1}, 2 = {2}", GC.CollectionCount(0), GC.CollectionCount(1),GC.CollectionCount(2));
        Console.ReadKey();
    }
}

class Dumb
{
    public int[] Arr = Enumerable.Range(1,10*1024*1024).ToArray(); // 50MB 
}

so in my case app eat ~2GB of RAM, but when I'm clicking on keyboard and launching GC.Collect it free occuped memory up to normal size of 20mb.

I've read that manual calls of GC etc is bad practice, but i cannot avoid it in this case.

Upvotes: 1

Views: 278

Answers (5)

Chad Dienhart
Chad Dienhart

Reputation: 5194

In your example there is no need to explicitly call GC.Collect() If you bring it up in the task manager or Performance Monitor you will see the GC working as it runs. GC is called when needed by the OS (when it is trying to allocate and doesn't have memory it will call GC to free some up).

That being said since your objects ( greater than 85000 bytes) are going onto the large object heap, LOH, you need to watch out for large object heap fragmentation. I've modified your code so show how you can fragment the LOH. Which will give an out of memory exception even though the memory is available, just not contiguous memory. As of .NET 4.5.1 you can set a flag to request that LOH to be compacted.

I modified your code to show an example of this here:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace GCTesting
{
    class Program
    {
        static int fragLOHbyIncrementing = 1000;
        static void Main()
        {
            var allDone = new ManualResetEvent(false);
            int completed = 0;
            long sum = 0; //just to prevent optimizer to remove cycle etc.
            const int count = 2000;
            for (int i = 0; i < count; i++)
            {
                ThreadPool.QueueUserWorkItem(delegate
                {
                    unchecked
                    {
                        var dumb = new Dumb( fragLOHbyIncrementing++ );
                        var localSum = 0;
                        foreach (int x in dumb.Arr)
                        {
                            localSum += x;
                        }
                        sum += localSum;
                    }
                    if (Interlocked.Increment(ref completed) == count)
                        allDone.Set();
                    if (completed % (count / 100) == 0)
                        Console.WriteLine("Progress = {0:N2}%", 100.0 * completed / count);
                });
            }
            allDone.WaitOne();
            Console.WriteLine("Done. Result : {0}", sum);
            Console.ReadKey();
            GC.Collect();
            Console.WriteLine("GC Collected!");
            Console.WriteLine("GC CollectionsCount 0 = {0}, 1 = {1}, 2 = {2}", GC.CollectionCount(0), GC.CollectionCount(1), GC.CollectionCount(2));
            Console.ReadKey();
        }
    }

    class Dumb
    {
        public Dumb(int incr)
        {
            try
            {
                DumbAllocation(incr);
            } 
            catch (OutOfMemoryException)
            {
                Console.WriteLine("Out of memory, trying to compact the LOH.");

                GCSettings.LargeObjectHeapCompactionMode = GCLargeObjectHeapCompactionMode.CompactOnce;
                GC.Collect();

                try // try again
                {
                    DumbAllocation(incr); 
                    Console.WriteLine("compacting the LOH worked to free up memory.");
                }
                catch (OutOfMemoryException)
                {
                    Console.WriteLine("compaction of LOH failed to free memory.");
                    throw;
                }
            }
        }

        private void DumbAllocation(int incr)
        {
            Arr = Enumerable.Range(1, (10 * 1024 * 1024) + incr).ToArray();
        }

        public int[] Arr;
    }
}

Upvotes: 2

embee
embee

Reputation: 369

The garbage collection is clever and decide when the time right to collect your objects. This is done by heuristics and you must read about that. The garbage collection makes his job very good. Are the 2GB a problem for yout system or you just wondering about the behaviour?

Whenever you call GC.Collect() don't forget the call GC.WaitingForPendingFinalizer. This avoids unwanted aging of objects with finalizer.

Upvotes: 0

LB2
LB2

Reputation: 4860

Few things I can think of that may be influencing this, but none for sure :(

  1. One possible effect is that GC doesn't kick in right away... the large objects are on the collection queue - but haven't been cleaned up yet. Specifically calling GC.Collect forces collection right there and that's where you see the difference. Otherwise it would've just happened at some point later.
  2. Second reason i can think of is that GC may collect objects, but not necessarily release memory to OS. Hence you'd continue seeing high memory usage even though it's free internally and available for allocation.

Upvotes: 0

Reed Copsey
Reed Copsey

Reputation: 564413

I've read that manual calls of GC etc is bad practice, but i cannot avoid it in this case.

You can avoid it. Just don't call it. The next time you try to do an allocation, the GC will likely kick in and take care of this for you.

Upvotes: 2

whoisj
whoisj

Reputation: 388

The .NET runtime will garbage collect without your call to the GC. However, the GC methods are exposed so that GC collections can be timed with the user experience (load screens, waiting for downloads, etc).

Use GC methods isn't always a bad idea, but if you need to ask then it likely is. :-)

Upvotes: 2

Related Questions