Question

I’m writing HFT trading application. I’m trying to optimize my application to minimize number of objects that garbage collected.

Example of optimization: instead of calling new Instrument(ticker) many times I create HashSet<string /*ticker*/, Instrument>

So it would be interesting to have such statistics: when application is finished I want to know how many objects were garbage collected during execution. So latter I can compare this number with “optimized” version to check that “optimization” is actually works.

If it is not possible to have such statistics then how can I test if my optimizations works i.e. actually decrease GC use?

Answer 1

How to count disposed objects is depending on your implementation but you can get GC Notifications.

Garbage Collection Notifications

This introduced with GC in .NET 3.5 SP1 to produce notifications whenever GC collection is about to begin and GC collection is completed successfully. So if you are between a very resource intensive phase of your application, GC notification will allow you to get notified that GC is approaching, so that you could stop the current process and wait for GC to complete. This makes your application to run smoothly.

The steps for getting GC notifications:

• Call GC.RegisterForFullGCNotification to allow for notifications when GC is approaching.
• Create a new thread from the application and start poll continuously in an infinite loop to methods GC.WaitForFullGCApproach and/or GC.WaitForFullGCComplete methods.
• Both the method returns GCNotificationStatus.Succeeded when the notification has to be raised.
• In Calling thread use GC.CancelFullGCNotification to unregister the notification process.

Sample Code Implementations

public class MainProgram
{
    public static List<char[]> lst = new List<char[]>();
    public static void Main(string[] args)
    {
        try
        {
            // Register for a notification. 
            GC.RegisterForFullGCNotification(10, 10);

            // Start a thread using WaitForFullGCProc.
            Thread startpolling = new Thread(() =>
            {
                while (true)
                {
                    // Check for a notification of an approaching collection.
                    GCNotificationStatus s = GC.WaitForFullGCApproach(1000);
                    if (s == GCNotificationStatus.Succeeded)
                    {
                        //Call event

                        Console.WriteLine("GC is about to begin");
                        GC.Collect();

                    }
                    else if (s == GCNotificationStatus.Canceled)
                    {
                        // Cancelled the Registration
                    }
                    else if (s == GCNotificationStatus.Timeout)
                    {
                        // Timeout occurred.
                    }

                    // Check for a notification of a completed collection.
                    s = GC.WaitForFullGCComplete(1000);
                    if (s == GCNotificationStatus.Succeeded)
                    {
                        //Call event
                        Console.WriteLine("GC has ended");
                    }
                    else if (s == GCNotificationStatus.Canceled)
                    {
                        //Cancelled the registration
                    }
                    else if (s == GCNotificationStatus.Timeout)
                    {
                        // Timeout occurred
                    }

                    Thread.Sleep(500);
                }


            });
            startpolling.Start();

            //Allocate huge memory to apply pressure on GC
            AllocateMemory();

            // Unregister the process
            GC.CancelFullGCNotification();

        }
        catch { }
    }

    private static void AllocateMemory()
    {
        while (true)
        {

            char[] bbb = new char[1000]; // creates a block of 1000 characters
            lst.Add(bbb);                // Adding to list ensures that the object doesnt gets out of scope   
            int counter = GC.CollectionCount(2);
            Console.WriteLine("GC Collected {0} objects", counter);

        }
    }

}

Reference: Garbage Collection Notifications in .NET 4.0