This is to separate the diagnostics code out from gc.cpp (except

GC's own logging), gcee.cpp and objecthandle.cpp.

The rule is GC will call the diagnostics functions at various points to communicate
info and these diagnostics functions might call back into the GC if they require
initimate knowledge of the GC in order to get certain info. This way gc.cpp does
not need to know about details of the diagnostics components, eg, the profiling context;
and the diagnostics components do not need to know details about the GC. So got rid of
ProfilingScanContext in gcinterface.h and passed scanning functions to GC and handle table.

Got rid of where it goes through things per heap as this is not something that diagnostics
should care about, including going through stack roots per heap (which is only done in
GC for scalability purposes but profiling is doing this on a single thread). This also makes it faster.

Got rid of the checks for gc_low/high in ProfScanRootsHelper as this is knowledge
profiling shouldn't have. And it was also incorrectly not including all interior
pointer stack roots.

1 files changed, 2 insertions, 205 deletions

diff --git a/src/gc/gcee.cpp b/src/gc/gcee.cpp
index 58a553661e..c93cc91b57 100644
--- a/src/gc/gcee.cpp
+++ b/src/gc/gcee.cpp
@@ -381,209 +381,6 @@ size_t GCHeap::GetNow()
     return GetHighPrecisionTimeStamp();
 }
 
-void ProfScanRootsHelper(Object** ppObject, ScanContext *pSC, uint32_t dwFlags)
-{
-#if defined(GC_PROFILING) || defined(FEATURE_EVENT_TRACE)
-    Object *pObj = *ppObject;
-#ifdef INTERIOR_POINTERS
-    if (dwFlags & GC_CALL_INTERIOR)
-    {
-        uint8_t *o = (uint8_t*)pObj;
-        gc_heap* hp = gc_heap::heap_of (o);
-
-        if ((o < hp->gc_low) || (o >= hp->gc_high))
-        {
-            return;
-        }
-        pObj = (Object*) hp->find_object(o, hp->gc_low);
-    }
-#endif //INTERIOR_POINTERS
-    ScanRootsHelper(pObj, ppObject, pSC, dwFlags);
-#endif // defined(GC_PROFILING) || defined(FEATURE_EVENT_TRACE)
-}
-
-// TODO - at some point we would like to completely decouple profiling
-// from ETW tracing using a pattern similar to this, where the
-// ProfilingScanContext has flags about whether or not certain things
-// should be tracked, and each one of these ProfilerShouldXYZ functions
-// will check these flags and determine what to do based upon that.
-// GCProfileWalkHeapWorker can, in turn, call those methods without fear
-// of things being ifdef'd out.
-
-// Returns TRUE if GC profiling is enabled and the profiler
-// should scan dependent handles, FALSE otherwise.
-BOOL ProfilerShouldTrackConditionalWeakTableElements() 
-{
-#if defined(GC_PROFILING)
-    return CORProfilerTrackConditionalWeakTableElements();
-#else
-    return FALSE;
-#endif // defined (GC_PROFILING)
-}
-
-// If GC profiling is enabled, informs the profiler that we are done
-// tracing dependent handles.
-void ProfilerEndConditionalWeakTableElementReferences(void* heapId)
-{
-#if defined (GC_PROFILING)
-    g_profControlBlock.pProfInterface->EndConditionalWeakTableElementReferences(heapId);
-#else
-    UNREFERENCED_PARAMETER(heapId);
-#endif // defined (GC_PROFILING)
-}
-
-// If GC profiling is enabled, informs the profiler that we are done
-// tracing root references.
-void ProfilerEndRootReferences2(void* heapId) 
-{
-#if defined (GC_PROFILING)
-    g_profControlBlock.pProfInterface->EndRootReferences2(heapId);
-#else
-    UNREFERENCED_PARAMETER(heapId);
-#endif // defined (GC_PROFILING)
-}
-
-// This is called only if we've determined that either:
-//     a) The Profiling API wants to do a walk of the heap, and it has pinned the
-//     profiler in place (so it cannot be detached), and it's thus safe to call into the
-//     profiler, OR
-//     b) ETW infrastructure wants to do a walk of the heap either to log roots,
-//     objects, or both.
-// This can also be called to do a single walk for BOTH a) and b) simultaneously.  Since
-// ETW can ask for roots, but not objects
-#if defined(GC_PROFILING) || defined(FEATURE_EVENT_TRACE)
-
-void GCProfileWalkHeapWorker(BOOL fProfilerPinned, BOOL fShouldWalkHeapRootsForEtw, BOOL fShouldWalkHeapObjectsForEtw)
-{
-    {
-        ProfilingScanContext SC(fProfilerPinned);
-
-        // **** Scan roots:  Only scan roots if profiling API wants them or ETW wants them.
-        if (fProfilerPinned || fShouldWalkHeapRootsForEtw)
-        {
-#ifdef MULTIPLE_HEAPS
-            int hn;
-
-            // Must emulate each GC thread number so we can hit each
-            // heap for enumerating the roots.
-            for (hn = 0; hn < gc_heap::n_heaps; hn++)
-            {
-                // Ask the vm to go over all of the roots for this specific
-                // heap.
-                gc_heap* hp = gc_heap::g_heaps [hn];
-                SC.thread_number = hn;
-                GCScan::GcScanRoots(&ProfScanRootsHelper, max_generation, max_generation, &SC);
-
-                // The finalizer queue is also a source of roots
-                SC.dwEtwRootKind = kEtwGCRootKindFinalizer;
-                hp->finalize_queue->GcScanRoots(&ProfScanRootsHelper, hn, &SC);
-            }
-#else
-            // Ask the vm to go over all of the roots
-            GCScan::GcScanRoots(&ProfScanRootsHelper, max_generation, max_generation, &SC);
-
-            // The finalizer queue is also a source of roots
-            SC.dwEtwRootKind = kEtwGCRootKindFinalizer;
-            pGenGCHeap->finalize_queue->GcScanRoots(&ProfScanRootsHelper, 0, &SC);
-
-#endif // MULTIPLE_HEAPS
-            // Handles are kept independent of wks/svr/concurrent builds
-            SC.dwEtwRootKind = kEtwGCRootKindHandle;
-            GCScan::GcScanHandlesForProfilerAndETW(max_generation, &SC);
-
-            // indicate that regular handle scanning is over, so we can flush the buffered roots
-            // to the profiler.  (This is for profapi only.  ETW will flush after the
-            // entire heap was is complete, via ETW::GCLog::EndHeapDump.)
-            if (fProfilerPinned)
-            {
-                ProfilerEndRootReferences2(&SC.pHeapId);
-            }
-        }
-
-        // **** Scan dependent handles: only if the profiler supports it or ETW wants roots
-        if ((fProfilerPinned && ProfilerShouldTrackConditionalWeakTableElements()) ||
-            fShouldWalkHeapRootsForEtw)
-        {
-            // GcScanDependentHandlesForProfiler double-checks
-            // CORProfilerTrackConditionalWeakTableElements() before calling into the profiler
-
-            GCScan::GcScanDependentHandlesForProfilerAndETW(max_generation, &SC);
-
-            // indicate that dependent handle scanning is over, so we can flush the buffered roots
-            // to the profiler.  (This is for profapi only.  ETW will flush after the
-            // entire heap was is complete, via ETW::GCLog::EndHeapDump.)
-            if (fProfilerPinned && ProfilerShouldTrackConditionalWeakTableElements())
-            {
-                ProfilerEndConditionalWeakTableElementReferences(&SC.pHeapId);
-            }
-        }
-
-        ProfilerWalkHeapContext profilerWalkHeapContext(fProfilerPinned, SC.pvEtwContext);
-
-        // **** Walk objects on heap: only if profiling API wants them or ETW wants them.
-        if (fProfilerPinned || fShouldWalkHeapObjectsForEtw)
-        {
-#ifdef MULTIPLE_HEAPS
-            int hn;
-
-            // Walk the heap and provide the objref to the profiler
-            for (hn = 0; hn < gc_heap::n_heaps; hn++)
-            {
-                gc_heap* hp = gc_heap::g_heaps [hn];         
-                hp->walk_heap(&HeapWalkHelper, &profilerWalkHeapContext, max_generation, TRUE /* walk the large object heap */);
-            }
-#else
-            gc_heap::walk_heap(&HeapWalkHelper, &profilerWalkHeapContext, max_generation, TRUE);
-#endif //MULTIPLE_HEAPS
-        }
-
-#ifdef FEATURE_EVENT_TRACE
-        // **** Done! Indicate to ETW helpers that the heap walk is done, so any buffers
-        // should be flushed into the ETW stream
-        if (fShouldWalkHeapObjectsForEtw || fShouldWalkHeapRootsForEtw)
-        {
-            ETW::GCLog::EndHeapDump(&profilerWalkHeapContext);
-        }
-#endif // FEATURE_EVENT_TRACE
-    }
-}
-#endif // defined(GC_PROFILING) || defined(FEATURE_EVENT_TRACE)
-
-void GCProfileWalkHeap()
-{
-    BOOL fWalkedHeapForProfiler = FALSE;
-
-#ifdef FEATURE_EVENT_TRACE
-    if (ETW::GCLog::ShouldWalkStaticsAndCOMForEtw())
-        ETW::GCLog::WalkStaticsAndCOMForETW();
-    
-    BOOL fShouldWalkHeapRootsForEtw = ETW::GCLog::ShouldWalkHeapRootsForEtw();
-    BOOL fShouldWalkHeapObjectsForEtw = ETW::GCLog::ShouldWalkHeapObjectsForEtw();
-#else // !FEATURE_EVENT_TRACE
-    BOOL fShouldWalkHeapRootsForEtw = FALSE;
-    BOOL fShouldWalkHeapObjectsForEtw = FALSE;
-#endif // FEATURE_EVENT_TRACE
-
-#if defined (GC_PROFILING)
-    {
-        BEGIN_PIN_PROFILER(CORProfilerTrackGC());
-        GCProfileWalkHeapWorker(TRUE /* fProfilerPinned */, fShouldWalkHeapRootsForEtw, fShouldWalkHeapObjectsForEtw);
-        fWalkedHeapForProfiler = TRUE;
-        END_PIN_PROFILER();
-    }
-#endif // defined (GC_PROFILING)
-
-#if defined (GC_PROFILING) || defined(FEATURE_EVENT_TRACE)
-    // we need to walk the heap if one of GC_PROFILING or FEATURE_EVENT_TRACE
-    // is defined, since both of them make use of the walk heap worker.
-    if (!fWalkedHeapForProfiler &&
-        (fShouldWalkHeapRootsForEtw || fShouldWalkHeapObjectsForEtw))
-    {
-        GCProfileWalkHeapWorker(FALSE /* fProfilerPinned */, fShouldWalkHeapRootsForEtw, fShouldWalkHeapObjectsForEtw);
-    }
-#endif // defined(GC_PROFILING) || defined(FEATURE_EVENT_TRACE)
-}
-
 BOOL GCHeap::IsGCInProgressHelper (BOOL bConsiderGCStart)
 {
     return GcInProgress || (bConsiderGCStart? VolatileLoad(&gc_heap::gc_started) : FALSE);
@@ -786,7 +583,7 @@ IGCHeapInternal* CreateGCHeap() {
     return new(nothrow) GCHeap();   // we return wks or svr 
 }
 
-void GCHeap::TraceGCSegments()
+void GCHeap::DiagTraceGCSegments()
 {
 #ifdef FEATURE_EVENT_TRACE
     heap_segment* seg = 0;
@@ -823,7 +620,7 @@ void GCHeap::TraceGCSegments()
 #endif // FEATURE_EVENT_TRACE
 }
 
-void GCHeap::DescrGenerationsToProfiler (gen_walk_fn fn, void *context)
+void GCHeap::DiagDescrGenerations (gen_walk_fn fn, void *context)
 {
 #if defined(GC_PROFILING) || defined(FEATURE_EVENT_TRACE)
     pGenGCHeap->descr_generations_to_profiler(fn, context);