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

Bo Cupp · Bo Cupp · commit 029a036e9a82 · 2017-10-04T20:39:55.000-07:00
diff --git a/bin/GCStress/RecyclerTestObject.h b/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);
     }
 
 
diff --git a/lib/Common/Memory/MarkContext.cpp b/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
 }
 
 
diff --git a/lib/Common/Memory/MarkContext.h b/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
diff --git a/lib/Common/Memory/MarkContext.inl b/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
     }
 }
diff --git a/lib/Common/Memory/Recycler.h b/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
diff --git a/lib/Common/Memory/Recycler.inl b/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

Original file line number	Diff line number	Diff line change
`@@ -34,12 +34,14 @@ bool MarkContext::AddMarkedObject(void * objectAddress, size_t objectSize)`
`34`	`34`	`return markStack.Push(markCandidate);`
`35`	`35`	`}`
`36`	`36`
	`37`	`+#ifdef RECYCLER_VISITED_HOST`
`37`	`38`	`inline bool MarkContext::AddPreciselyTracedObject(IRecyclerVisitedObject* obj)`
`38`	`39`	`{`
`39`	`40`	`FAULTINJECT_MEMORY_MARK_NOTHROW(_u("AddPreciselyTracedObject"), 0);`
`40`	`41`
`41`	`42`	`return preciseStack.Push(obj);`
`42`	`43`	`}`
	`44`	`+#endif`
`43`	`45`
`44`	`46`	`#if ENABLE_CONCURRENT_GC`
`45`	`47`	`inline`
`@@ -195,11 +197,13 @@ void MarkContext::ProcessMark()`
`195`	`197`	`}`
`196`	`198`	`#endif`
`197`	`199`
	`200`	`+#ifdef RECYCLER_VISITED_HOST`
`198`	`201`	`// Flip between processing the generic mark stack (conservatively traced with ScanMemory) and`
`199`	`202`	`// the precise stack (precisely traced via IRecyclerVisitedObject::Trace). Each of those`
`200`	`203`	`// operations on an object has the potential to add new marked objects to either or both`
`201`	`204`	`// stacks so we must loop until they are both empty.`
`202`	`205`	`while (!markStack.IsEmpty() \|\| !preciseStack.IsEmpty())`
	`206`	`+#endif`
`203`	`207`	`{`
`204`	`208`	`#if defined(_M_IX86) \|\| defined(_M_X64)`
`205`	`209`	`MarkCandidate current, next;`
`@@ -239,6 +243,7 @@ void MarkContext::ProcessMark()`
`239`	`243`
`240`	`244`	`Assert(markStack.IsEmpty());`
`241`	`245`
	`246`	`+#ifdef RECYCLER_VISITED_HOST`
`242`	`247`	`if (!preciseStack.IsEmpty())`
`243`	`248`	`{`
`244`	`249`	`MarkContextWrapper<parallel> markContextWrapper(this);`
`@@ -250,5 +255,6 @@ void MarkContext::ProcessMark()`
`250`	`255`	`}`
`251`	`256`
`252`	`257`	`Assert(preciseStack.IsEmpty());`
	`258`	`+#endif`
`253`	`259`	`}`
`254`	`260`	`}`
Original file line number	Diff line number	Diff line change
`@@ -521,13 +521,15 @@ Recycler::AddMark(void * candidate, size_t byteCount) throw()`
`521`	`521`	`return markContext.AddMarkedObject(candidate, byteCount);`
`522`	`522`	`}`
`523`	`523`
	`524`	`+#ifdef RECYCLER_VISITED_HOST`
`524`	`525`	`inline bool`
`525`	`526`	`Recycler::AddPreciselyTracedMark(IRecyclerVisitedObject * candidate) throw()`
`526`	`527`	`{`
`527`	`528`	`// This API cannot be used for parallel marking as we don't have enough information to determine which MarkingContext to use.`
`528`	`529`	`Assert((this->collectionState & Collection_Parallel) == 0);`
`529`	`530`	`return markContext.AddPreciselyTracedObject(candidate);`
`530`	`531`	`}`
	`532`	`+#endif`
`531`	`533`
`532`	`534`	`template <typename T>`
`533`	`535`	`void`