While looking at those data sets can give us a good overview about how the GC affects our application's performance, it's just not enough in order to get more in-depth insights about observed "fezzes" in the application. For instance, even if we'll see that in 90% of the time we only spend 2% in GC collections, it still doesn't mean that during some critical moment in our application, there wasn't any generation 2 collection that caused our application to freeze for about 200ms, which could cause some serious damage in some scenarios.
The problem is that GC collections don't just cause the application to "run more slowly", but it puts the application into a complete stop for unknown amounts of time. So solely looking at the %Time in GC graph doesn't tells us for sure what was the real damage of each collection. Also, remember that perfmon's highest sampling resolution is only 1 second. So in case we've suffered from a single generation 2 collection, we've might even won't notice it as we should. More than that, its almost impossible to make sure that perfmon is runs, gathers and records the correct data on every machine that runs your application at any given time.
This is why we need a reliable way to monitor when the GC decides to perform a collection, and when it does, check the collection's generation, and the amount of time it takes to complete it.
Today, the System.GC class doesn't expose us an accurate way to collect this data. However, by writing a custom CLR Host, we could integrate our code with the CLR and receive from it the proper notifications that will tell us exactly when each and every GC starts and end in the process.
In order to do so, we will need to implement the IHostGCManager interface, and use one out of its three available callback functions. The first is SuspensionStarting, and the second is SuspensionEnding, which also passes us a single DWORD parameter that represent the number of generation that ended. So as you might have already figured out, the CLR makes sure to call SuspensionStarting right before it starts the collection, and afterwords, it calls SuspensionEnding.
One thing to pay attention about SuspensionEnding is that the documentation available on MSDN isn't entirely accurate, and might confuse users about what are the possible triggers to call the callback. This is what the documentation says today:
"...Notifies the host that the common language runtime (CLR) is resuming execution of tasks on threads that had been suspended for a garbage collection.So according to the documentation, the callback will only be invoked due to freezings caused by a GC. However, this isn't the only trigger for invoking this callback. Actually, the CLR will invoke it also after it continuous execution after other kinds of "stop-the-world" operations that it might perform (e.g, loading and unloading of AppDomains). If we'll look in the SSCLI's implementation to where that callback is invoked, we could notice the following code:
[parameter: generation] The garbage collection generation that is just finishing, from which the thread is resuming."
if (pGCThreadControl)
{
// If we the suspension was for a GC, tell the host what generation GC.
DWORD Generation = (bFinishedGC
? GCHeap::GetGCHeap()->GetCondemnedGeneration()
: ~0U);
pGCThreadControl->SuspensionEnding(Generation);
}
As for the measuring itself, we'll use the QueryPerformanceCounter function (in .Net, wrapped by the Stopwatch class), to achieve the highest possible time resolution for every collection.
Since in most of the time, the collections that we'll encounter will be very short ones (mostly ephemeral collections, that could take only a few millisecond per collection), we'll likely want to avoid spending time recording the data (so we'll avoid unnecessary IO). In such case it could be useful to use a logging framework that will filter collections according to their severity (e.g, Debug for very short collections, Info for more notable collections, and Warn for more lengthy collections that might indicate a problem). After attaching an appender that writes all of our logs to the console window, and running an application that constantly allocates memory, we could get an output such as this:
As a reference, I'm including a sample CLR Host that monitors collections, and writes to the console their duration:
#include
#include
#include
#include
using namespace std;
#define APP_STARTUP_EXE L"TestApplication.exe"
#define APP_ENTRY_TYPE L"SomeNamespace.Program"
#define APP_ENTRY_METHOD L"Main"
class MyCLRHost : public IHostControl, public IHostGCManager
{
private:
LONG m_refCount;
LARGE_INTEGER m_lastGCStart;
LARGE_INTEGER m_frequency;
public:
MyCLRHost() { QueryPerformanceFrequency(&m_frequency); }
// IHostControl
HRESULT __stdcall GetHostManager(REFIID riid, void** ppObject)
{
if(riid == IID_IHostGCManager)
{
*ppObject = static_cast(this);
return S_OK;
}
*ppObject = NULL;
return E_NOINTERFACE;
}
// IUnknown
HRESULT __stdcall QueryInterface(REFIID riid, void** ppvObject)
{
if (riid == IID_IHostGCManager)
{
*ppvObject = static_cast(this);
return S_OK;
}
*ppvObject = NULL;
return E_NOINTERFACE;
}
HRESULT __stdcall SetAppDomainManager(DWORD appDomain, IUnknown* domainManager)
{
return S_OK;
}
ULONG __stdcall AddRef() { return InterlockedIncrement(&m_refCount); }
ULONG __stdcall Release() { return InterlockedDecrement(&m_refCount); }
// IHostGCManager
HRESULT __stdcall ThreadIsBlockingForSuspension() { return S_OK; }
HRESULT __stdcall SuspensionStarting()
{
m_lastGCStart;
QueryPerformanceCounter(&m_lastGCStart);
return S_OK;
}
HRESULT __stdcall SuspensionEnding(DWORD gen)
{
LARGE_INTEGER gcEnd;
QueryPerformanceCounter(&gcEnd);
double duration = ((gcEnd.QuadPart - m_lastGCStart.QuadPart))
* 1000.0 / (double)m_frequency.QuadPart;
if(gen != UINT_MAX)
cout<<"GC generation "<<<" ended: "<<<"ms"<
else
cout<<"CLR suspension ended: "<<<" ms"<
return S_OK;
}
};
int _tmain(int argc, _TCHAR* argv[])
{
ICLRRuntimeHost* pCLR;
DWORD startupFlags = STARTUP_CONCURRENT_GC;
HRESULT hr = CorBindToRuntimeEx(L"v2.0.50727", L"wks", startupFlags,
CLSID_CLRRuntimeHost, IID_ICLRRuntimeHost, (LPVOID*)&pCLR);
assert(SUCCEEDED(hr));
MyCLRHost customHost;
hr = pCLR->SetHostControl(&customHost);
assert(SUCCEEDED(hr));
hr = pCLR->Start();
assert(SUCCEEDED(hr));
DWORD retcode;
hr = pCLR->ExecuteInDefaultAppDomain(APP_STARTUP_EXE,
APP_ENTRY_TYPE, APP_ENTRY_METHOD, L"" , &retcode);
assert(SUCCEEDED(hr));
return 0;
};