188 - Generate a dump when a .NET gen collection starts and ends

README.md

@@ -26,6 +26,7 @@ procdump [-n Count]
         [-c|-cl CPU_Usage]
         [-m|-ml Commit_Usage1[,Commit_Usage2,...]]
         [-gcm Memory_Usage1[,Memory_Usage2...]]
+        [-gcgen Generation]
         [-tc Thread_Threshold]
         [-fc FileDescriptor_Threshold]
         [-sig Signal_Number]
@@ -46,6 +47,7 @@ Options:
    -m      Memory commit threshold(s) (MB) above which to create dumps.
    -ml     Memory commit threshold(s) (MB) below which to create dumps.
    -gcm    [.NET] GC memory threshold(s) (MB) above which to create dumps.
+   -gcgen  [.NET] Create dump when the garbage collection of the specified generation starts and finishes.
    -tc     Thread count threshold above which to create a dump of the process.
    -fc     File descriptor count threshold above which to create a dump of the process.
    -sig    Signal number to intercept to create a dump of the process.
@@ -96,6 +98,10 @@ The following will create a core dump when .NET memory usage is >= 100 MB follow
 ```
 sudo procdump -gcm 100,200 1234
 ```
+The following will create a core dump at the start and end of a .NET generation 1 garbage collection.
+```
+sudo procdump -gcgen 1
+```
 The following will create a core dump in the `/tmp` directory immediately.
 ```
 sudo procdump 1234 /tmp

include/GenHelpers.h

@@ -110,6 +110,7 @@ bool createDir(const char *dir, mode_t perms);
 char* GetSocketPath(char* prefix, pid_t pid, pid_t targetPid);
 int send_all(int socket, void *buffer, size_t length);
 int recv_all(int socket, void* buffer, size_t length);
+pid_t gettid();
 
 #endif // GENHELPERS_H
 

include/Monitor.h

@@ -33,6 +33,9 @@ bool BeginMonitoring(struct ProcDumpConfiguration *self);
 bool MonitorDotNet(struct ProcDumpConfiguration *self);
 char* GetThresholds(struct ProcDumpConfiguration *self);
 char* GetClientData(struct ProcDumpConfiguration *self, char* fullDumpPath);
+char* GetClientDataInt(enum TriggerType triggerType, char* path, int value);
+char* GetClientDataString(enum TriggerType triggerType, char* path, char* value);
+bool ExitProcessMonitor(struct ProcDumpConfiguration* config, pthread_t processMonitor);
 
 // Monitor worker threads
 void *CommitMonitoringThread(void *thread_args /* struct ProcDumpConfiguration* */);

include/ProcDumpConfiguration.h

@@ -69,6 +69,7 @@ struct ProcDumpConfiguration {
     int NumberOfDumpsCollected; // Number of dumps we have collected
     bool bTerminated; // Do we know whether the process has terminated and subsequently whether we are terminating?
     char* socketPath;
+    bool bExitProcessMonitor;
 
     // Quit
     int nQuit; // if not 0, then quit
@@ -89,6 +90,7 @@ struct ProcDumpConfiguration {
     int MemoryCurrentThreshold;
     bool bMemoryTriggerBelowValue;  // -m or -ml
     bool bMonitoringGCMemory;       // -gcm
+    int DumpGCGeneration;           // -gcgen
     int ThresholdSeconds;           // -s
     bool bTimerThreshold;           // -s
     int NumberOfDumpsToCollect;     // -n

include/ProfilerCommon.h

@@ -18,7 +18,8 @@ enum TriggerType
     ThreadCount,
     FileDescriptorCount,
     Exception,
-    GCThreshold
+    GCThreshold,
+    GCGeneration
 };
 
 #endif // PROFILERCOMMON_H

procdump.1

@@ -7,6 +7,8 @@ procdump [-n Count]
         [-s Seconds]
         [-c|-cl CPU_Usage]
         [-m|-ml Commit_Usage1[,Commit_Usage2,...]]
+        [-gcm Memory_Usage1[,Memory_Usage2...]]
+        [-gcgen Generation]
         [-tc Thread_Threshold]
         [-fc FileDescriptor_Threshold]
         [-sig Signal_Number]
@@ -26,6 +28,8 @@ Options:
    -cl     CPU threshold below which to create a dump of the process.
    -m      Memory commit thresholds (MB) above which to create dumps.
    -ml     Memory commit thresholds (MB) below which to create dumps.
+   -gcm    [.NET] GC memory threshold(s) (MB) above which to create dumps.
+   -gcgen  [.NET] Create dump when the garbage collection of the specified generation starts and finishes.
    -tc     Thread count threshold above which to create a dump of the process.
    -fc     File descriptor count threshold above which to create a dump of the process.
    -sig    Signal number to intercept to create a dump of the process.

profiler/inc/ProcDumpProfiler.h

@@ -112,6 +112,8 @@ class CorProfiler : public ICorProfilerCallback8
     enum TriggerType triggerType;
     int currentThresholdIndex;
     bool gen2Collection;
+    int gcGeneration;
+    bool gcGenStarted;
 
     String GetExceptionName(ObjectID objectId);
     String GetExceptionMessage(ObjectID objectId);
@@ -129,6 +131,7 @@ class CorProfiler : public ICorProfilerCallback8
     bool WildcardSearch(WCHAR*, WCHAR*);
     u_int64_t GetGCHeapSize();
     bool WriteDumpHelper(std::string dumpName);
+    bool IsHighPerfBasicGC();
 
 public:
     CorProfiler();

profiler/src/ProcDumpProfiler.cpp

@@ -189,10 +189,25 @@ bool CorProfiler::WildcardSearch(WCHAR* szClassName, WCHAR* szSearch)
     return false;
 }
 
+//------------------------------------------------------------------------------------------------------------------------------------------------------
+// CorProfiler::IsHighPerfBasicGC
+//------------------------------------------------------------------------------------------------------------------------------------------------------
+bool CorProfiler::IsHighPerfBasicGC()
+{
+    if(triggerType == GCThreshold || triggerType == GCGeneration)
+    {
+        return true;
+    }
+
+    return false;
+}
+
 //------------------------------------------------------------------------------------------------------------------------------------------------------
 // CorProfiler::CorProfiler
 //------------------------------------------------------------------------------------------------------------------------------------------------------
-CorProfiler::CorProfiler() : refCount(0), corProfilerInfo8(nullptr), corProfilerInfo3(nullptr), corProfilerInfo(nullptr), procDumpPid(0), currentThresholdIndex(0), gen2Collection(false)
+CorProfiler::CorProfiler() :
+    refCount(0), corProfilerInfo8(nullptr), corProfilerInfo3(nullptr), corProfilerInfo(nullptr),
+    procDumpPid(0), currentThresholdIndex(0), gen2Collection(false), gcGeneration(-1), gcGenStarted(false)
 {
     // Configure logging
     el::Loggers::reconfigureAllLoggers(el::ConfigurationType::Filename, LOG_FILE);
@@ -273,7 +288,7 @@ HRESULT STDMETHODCALLTYPE CorProfiler::InitializeForAttach(IUnknown *pCorProfile
             return E_FAIL;
         }
     }
-    else if(triggerType == GCThreshold)
+    else if(IsHighPerfBasicGC() == true)
     {
         HRESULT hr = this->corProfilerInfo8->SetEventMask2(0, COR_PRF_HIGH_BASIC_GC);
         if(FAILED(hr))
@@ -332,6 +347,7 @@ WCHAR* CorProfiler::GetUint16(char* buffer)
 //
 //      DOTNET_EXCEPTION_TRIGGER;<fullpathtodumplocation>;<pidofprocdump>;<exception>:<numdumps>;<exception>:<numdumps>,...
 //      DOTNET_GC_THRESHOLD_TRIGGER;<fullpathtodumplocation>;<pidofprocdump>;Threshold1;Threshold2,...
+//      DOTNET_GC_GEN_TRIGGER;<fullpathtodumplocation>;<pidofprocdump>;GCGeneration
 //
 //------------------------------------------------------------------------------------------------------------------------------------------------------
 bool CorProfiler::ParseClientData(char* clientData)
@@ -401,6 +417,12 @@ bool CorProfiler::ParseClientData(char* clientData)
             // GC threshold list
             gcMemoryThresholdMonitorList.push_back(std::stoi(dataItem) << 20);
         }
+        else if (triggerType == GCGeneration)
+        {
+            // GC generation
+            gcGeneration = std::stoi(dataItem);
+            break;
+        }
         else
         {
             LOG(TRACE) << "CorProfiler::ParseClientData Unrecognized trigger type";
@@ -418,6 +440,11 @@ bool CorProfiler::ParseClientData(char* clientData)
         LOG(TRACE) << "CorProfiler::ParseClientData:GCMemoryThreshold  " << element;
     }
 
+    if(gcGeneration != -1)
+    {
+        LOG(TRACE) << "CorProfiler::ParseClientData:GCGeneration  " << gcGeneration;
+    }
+
     LOG(TRACE) << "CorProfiler::ParseClientData: Exit";
     return true;
 }
@@ -802,8 +829,26 @@ HRESULT STDMETHODCALLTYPE CorProfiler::GarbageCollectionStarted(int cGenerations
 
     if(gcMemoryThresholdMonitorList.size() > 0 && generationCollected[2] == true)
     {
+        // GC memory threshold dump
         gen2Collection = true;
     }
+    else if(gcGeneration != -1 && gcGenStarted == false && gcGeneration < cGenerations && generationCollected[gcGeneration] == true)
+    {
+        // GC Generation dump
+        LOG(TRACE) << "CorProfiler::GarbageCollectionStarted: Dump on generation: " << gcGeneration << " and cGenerations = " << cGenerations;
+        std::string dump = GetDumpName(1, convertString<std::string,std::wstring>(L"gc_gen"));
+        if(WriteDumpHelper(dump) == false)
+        {
+            SendCatastrophicFailureStatus();
+            return E_FAIL;
+        }
+
+        gcGenStarted = true;
+    }
+    else
+    {
+        LOG(TRACE) << "CorProfiler::GarbageCollectionStarted: Invalid trigger data, trigger = " << triggerType << " cGenerations " << cGenerations;
+    }
 
     LOG(TRACE) << "CorProfiler::GarbageCollectionStarted: Exit";
     return S_OK;
@@ -849,6 +894,23 @@ HRESULT STDMETHODCALLTYPE CorProfiler::GarbageCollectionFinished()
             }
         }
     }
+    else if(gcGenStarted == true)
+    {
+        // GC Generation dump
+        LOG(TRACE) << "CorProfiler::GarbageCollectionFinished: Dump on generation: " << gcGeneration;
+        gcGenStarted = false;
+
+        std::string dump = GetDumpName(2, convertString<std::string,std::wstring>(L"gc_gen"));
+        if(WriteDumpHelper(dump) == false)
+        {
+            SendCatastrophicFailureStatus();
+            return E_FAIL;
+        }
+
+        // Stop monitoring
+        CleanupProfiler();
+        UnloadProfiler();
+    }
 
     LOG(TRACE) << "CorProfiler::GarbageCollectionFinished: Exit";
     return S_OK;

src/GenHelpers.c

@@ -6,7 +6,9 @@
 // General purpose helpers
 //
 //--------------------------------------------------------------------
+#define _GNU_SOURCE
 #include "Includes.h"
+#include <syscall.h>
 
 //--------------------------------------------------------------------
 //
@@ -547,5 +549,24 @@ int recv_all(int socket, void* buffer, size_t length)
         length -= i;
     }
 
+    return 0;
+}
+
+//--------------------------------------------------------------------
+//
+// gettid
+//
+// Returns the current thread ID. Useful to add in trace statements
+// when threads are created to match to a debug session.
+//
+// Note: SYS_gettid is not POSIX compliant.
+//
+//--------------------------------------------------------------------
+pid_t gettid()
+{
+#ifdef SYS_gettid
+    return syscall(SYS_gettid);
+#endif
+
     return 0;
 }