Pre-process out more precise tracing code when RECYCLER_VISITED_HOST is not defined

Author: Bo Cupp

bin/GCStress/RecyclerTestObject.h

@@ -327,24 +327,34 @@ class RecyclerVisitedObject : public RecyclerTestObject
 
         // Randomly select the type of object to create
         AllocationType allocType = static_cast<AllocationType>(GetRandomInteger(static_cast<unsigned int>(AllocationType::Count)));
+        wchar_t* allocTypeName;
         switch (allocType)
         {
         case AllocationType::TraceAndFinalized:
             mem = RecyclerAllocVisitedHostTracedAndFinalizedZero(recyclerInstance, size);
+            allocTypeName = L"TraceAndFinalized";
             break;
         case AllocationType::TraceOnly:
             mem = RecyclerAllocVisitedHostTracedZero(recyclerInstance, size);
+            allocTypeName = L"TraceOnly";
             break;
         case AllocationType::FinalizeLeaf:
             mem = RecyclerAllocVisitedHostFinalizedZero(recyclerInstance, size);
+            allocTypeName = L"FinalizeLeaf";
             break;
         default:
             Assert(allocType == AllocationType::Leaf);
             mem = RecyclerAllocLeafZero(recyclerInstance, size);
+            allocTypeName = L"Leaf";
         }
 
         // Construct the v-table, allocType, and count information for the new object.
         RecyclerVisitedObject* obj = new (mem) RecyclerVisitedObject(allocType, count);
+        
+        wchar_t debugString[1024];
+        swprintf_s(debugString, L"Allocate 0x%08x%08x : %s\n", ((uintptr_t)mem)>>32, (uintptr_t)mem, allocTypeName);
+        OutputDebugString(debugString);
+
         return obj;
     }
 
@@ -385,6 +395,10 @@ class RecyclerVisitedObject : public RecyclerTestObject
         BOOL success = ::HeapFree(GetProcessHeap(), 0, unmanagedResource);
         VerifyCondition(success != FALSE);
         unmanagedResource = nullptr;
+
+        wchar_t debugString[1024];
+        swprintf_s(debugString, L"Dispose 0x%08x%08x\n", ((uintptr_t)this) >> 32, (uintptr_t)this);
+        OutputDebugString(debugString);
     }
 
 

lib/Common/Memory/MarkContext.cpp

@@ -14,7 +14,9 @@ MarkContext::MarkContext(Recycler * recycler, PagePool * pagePool) :
     recycler(recycler),
     pagePool(pagePool),
     markStack(pagePool),
+#ifdef RECYCLER_VISITED_HOST
     preciseStack(pagePool),
+#endif
     trackStack(pagePool)
 {
 }
@@ -40,21 +42,27 @@ void MarkContext::OnObjectMarked(void* object, void* parent)
 void MarkContext::Init(uint reservedPageCount)
 {
     markStack.Init(reservedPageCount);
+#ifdef RECYCLER_VISITED_HOST
     preciseStack.Init();
+#endif
     trackStack.Init();
 }
 
 void MarkContext::Clear()
 {
     markStack.Clear();
+#ifdef RECYCLER_VISITED_HOST
     preciseStack.Clear();
+#endif
     trackStack.Clear();
 }
 
 void MarkContext::Abort()
 {
     markStack.Abort();
+#ifdef RECYCLER_VISITED_HOST
     preciseStack.Abort();
+#endif
     trackStack.Abort();
 
     pagePool->ReleaseFreePages();
@@ -64,7 +72,9 @@ void MarkContext::Abort()
 void MarkContext::Release()
 {
     markStack.Release();
+#ifdef RECYCLER_VISITED_HOST
     preciseStack.Release();
+#endif
     trackStack.Release();
 
     pagePool->ReleaseFreePages();
@@ -78,20 +88,28 @@ uint MarkContext::Split(uint targetCount, __in_ecount(targetCount) MarkContext *
     __analysis_assume(targetCount <= PageStack<IRecyclerVisitedObject*>::MaxSplitTargets);
 
     PageStack<MarkCandidate> * targetMarkStacks[PageStack<MarkCandidate>::MaxSplitTargets];
+#ifdef RECYCLER_VISITED_HOST
     PageStack<IRecyclerVisitedObject*> * targetPreciseStacks[PageStack<IRecyclerVisitedObject*>::MaxSplitTargets];
+#endif
 
     for (uint i = 0; i < targetCount; i++)
     {
         targetMarkStacks[i] = &targetContexts[i]->markStack;
+#ifdef RECYCLER_VISITED_HOST
         targetPreciseStacks[i] = &targetContexts[i]->preciseStack;
+#endif
     }
 
     // Return the max count of the two splits - since the stacks have more or less unrelated sizes, they
     // could yield different number of splits, but the caller wants to know the max parallelism it
     // should use on the results of the split.
     const uint markStackSplitCount = this->markStack.Split(targetCount, targetMarkStacks);
+#ifdef RECYCLER_VISITED_HOST
     const uint preciseStackSplitCount = this->preciseStack.Split(targetCount, targetPreciseStacks);
     return max(markStackSplitCount, preciseStackSplitCount);
+#else
+    return markStackSplitCount;
+#endif
 }
 
 

lib/Common/Memory/MarkContext.h

@@ -31,7 +31,9 @@ class MarkContext
     Recycler * GetRecycler() { return this->recycler; }
 
     bool AddMarkedObject(void * obj, size_t byteCount);
+#ifdef RECYCLER_VISITED_HOST
     bool AddPreciselyTracedObject(IRecyclerVisitedObject *obj);
+#endif
 #if ENABLE_CONCURRENT_GC
     bool AddTrackedObject(FinalizableObject * obj);
 #endif
@@ -56,9 +58,17 @@ class MarkContext
     void Release();
 
     bool HasPendingMarkObjects() const { return !markStack.IsEmpty(); }
+#ifdef RECYCLER_VISITED_HOST
     bool HasPendingPreciselyTracedObjects() const { return !preciseStack.IsEmpty(); }
+#endif
     bool HasPendingTrackObjects() const { return !trackStack.IsEmpty(); }
-    bool HasPendingObjects() const { return HasPendingMarkObjects() || HasPendingPreciselyTracedObjects() || HasPendingTrackObjects(); }
+    bool HasPendingObjects() const { 
+        return HasPendingMarkObjects() 
+#ifdef RECYCLER_VISITED_HOST
+            || HasPendingPreciselyTracedObjects() 
+#endif
+            || HasPendingTrackObjects(); 
+    }
 
     PageAllocator * GetPageAllocator() { return this->pagePool->GetPageAllocator(); }
 
@@ -92,7 +102,13 @@ class MarkContext
 
 
 #ifdef ENABLE_DEBUG_CONFIG_OPTIONS
-    void SetMaxPageCount(size_t maxPageCount) { markStack.SetMaxPageCount(maxPageCount); preciseStack.SetMaxPageCount(maxPageCount); trackStack.SetMaxPageCount(maxPageCount); }
+    void SetMaxPageCount(size_t maxPageCount) { 
+        markStack.SetMaxPageCount(maxPageCount); 
+#ifdef RECYCLER_VISITED_HOST
+        preciseStack.SetMaxPageCount(maxPageCount); 
+#endif
+        trackStack.SetMaxPageCount(maxPageCount); 
+    }
 #endif
 
 #ifdef RECYCLER_MARK_TRACK

lib/Common/Memory/MarkContext.inl

@@ -34,12 +34,14 @@ bool MarkContext::AddMarkedObject(void * objectAddress, size_t objectSize)
     return markStack.Push(markCandidate);
 }
 
+#ifdef RECYCLER_VISITED_HOST
 inline bool MarkContext::AddPreciselyTracedObject(IRecyclerVisitedObject* obj)
 {
     FAULTINJECT_MEMORY_MARK_NOTHROW(_u("AddPreciselyTracedObject"), 0);
 
     return preciseStack.Push(obj);
 }
+#endif
 
 #if ENABLE_CONCURRENT_GC
 inline
@@ -195,11 +197,13 @@ void MarkContext::ProcessMark()
     }
 #endif
 
+#ifdef RECYCLER_VISITED_HOST
     // Flip between processing the generic mark stack (conservatively traced with ScanMemory) and
     // the precise stack (precisely traced via IRecyclerVisitedObject::Trace). Each of those
     // operations on an object has the potential to add new marked objects to either or both
     // stacks so we must loop until they are both empty.
     while (!markStack.IsEmpty() || !preciseStack.IsEmpty())
+#endif
     {
 #if defined(_M_IX86) || defined(_M_X64)
         MarkCandidate current, next;
@@ -239,6 +243,7 @@ void MarkContext::ProcessMark()
 
         Assert(markStack.IsEmpty());
 
+#ifdef RECYCLER_VISITED_HOST
         if (!preciseStack.IsEmpty())
         {
             MarkContextWrapper<parallel> markContextWrapper(this);
@@ -250,5 +255,6 @@ void MarkContext::ProcessMark()
         }
 
         Assert(preciseStack.IsEmpty());
+#endif
     }
 }

lib/Common/Memory/Recycler.h

@@ -1575,7 +1575,9 @@ class Recycler
     template <bool doSpecialMark>
     void ScanMemory(void ** obj, size_t byteCount) { if (byteCount != 0) { ScanMemoryInline<doSpecialMark>(obj, byteCount); } }
     bool AddMark(void * candidate, size_t byteCount);
+#ifdef RECYCLER_VISITED_HOST
     bool AddPreciselyTracedMark(IRecyclerVisitedObject * candidate);
+#endif
 
     // Sweep
 #if ENABLE_PARTIAL_GC

lib/Common/Memory/Recycler.inl

@@ -521,13 +521,15 @@ Recycler::AddMark(void * candidate, size_t byteCount) throw()
     return markContext.AddMarkedObject(candidate, byteCount);
 }
 
+#ifdef RECYCLER_VISITED_HOST
 inline bool
 Recycler::AddPreciselyTracedMark(IRecyclerVisitedObject * candidate) throw()
 {
     // This API cannot be used for parallel marking as we don't have enough information to determine which MarkingContext to use.
     Assert((this->collectionState & Collection_Parallel) == 0);
     return markContext.AddPreciselyTracedObject(candidate);
 }
+#endif
 
 template <typename T>
 void