Add support for a Recycler-managed "Host Heap" to facilitate tracing of objects which relate to scriptable types

bin/GCStress/GCStress.cpp

@@ -214,16 +214,23 @@ void BuildObjectCreationTable()
     objectCreationTable.AddWeightedEntry(&ScannedObject<1, 50>::New, 10000);
     objectCreationTable.AddWeightedEntry(&BarrierObject<1, 50>::New, 2000);
     objectCreationTable.AddWeightedEntry(&TrackedObject<1, 50>::New, 2000);
+#ifdef RECYCLER_VISITED_HOST
+    objectCreationTable.AddWeightedEntry(&RecyclerVisitedObject<1, 50>::New, 2000);
+#endif
 
     objectCreationTable.AddWeightedEntry(&LeafObject<51, 1000>::New, 10);
     objectCreationTable.AddWeightedEntry(&ScannedObject<51, 1000>::New, 100);
     objectCreationTable.AddWeightedEntry(&BarrierObject<51, 1000>::New, 20);
     objectCreationTable.AddWeightedEntry(&TrackedObject<51, 1000>::New, 20);
+#ifdef RECYCLER_VISITED_HOST
+    objectCreationTable.AddWeightedEntry(&RecyclerVisitedObject<51, 1000>::New, 40);
+#endif
 
     objectCreationTable.AddWeightedEntry(&LeafObject<1001, 50000>::New, 1);
     objectCreationTable.AddWeightedEntry(&ScannedObject<1001, 50000>::New, 10);
     objectCreationTable.AddWeightedEntry(&BarrierObject<1001, 50000>::New, 2);
 //    objectCreationTable.AddWeightedEntry(&TrackedObject<1001, 50000>::New, 2);    // Large tracked objects are not supported
+//    objectCreationTable.AddWeightedEntry(&RecyclerVisitedObject<1001, 50000>::New, 2); // Large recycler visited objects are not supported
 }
 
 void BuildOperationTable()

bin/GCStress/RecyclerTestObject.cpp

@@ -10,6 +10,7 @@ size_t RecyclerTestObject::walkObjectCount = 0;
 size_t RecyclerTestObject::walkScannedByteCount = 0;
 size_t RecyclerTestObject::walkBarrierByteCount = 0;
 size_t RecyclerTestObject::walkTrackedByteCount = 0;
+size_t RecyclerTestObject::walkRecyclerVisitedByteCount = 0;
 size_t RecyclerTestObject::walkLeafByteCount = 0;
 size_t RecyclerTestObject::currentWalkDepth = 0;
 size_t RecyclerTestObject::maxWalkDepth = 0;

bin/GCStress/RecyclerTestObject.h

@@ -4,7 +4,9 @@
 //-------------------------------------------------------------------------------------------------------
 #include "stdafx.h"
 
-class RecyclerTestObject : public FinalizableObject
+#include "Core/RecyclerHeapMarkingContext.h"
+
+class RecyclerTestObject : public IRecyclerVisitedObject
 {
 protected:
     RecyclerTestObject()
@@ -13,10 +15,16 @@ class RecyclerTestObject : public FinalizableObject
     }
 
 public:
-    // FinalizableObject implementation
+    // IRecyclerVisitedObject implementation. We don't use FinalizableObject here as
+    // RecyclerVisitedObjects need to have Trace called on them, which is not allowed for
+    // FinalizableObject.
     virtual void Finalize(bool isShutdown) override { VerifyCondition(false); };
     virtual void Dispose(bool isShutdown) override { VerifyCondition(false); };
-    virtual void Mark(Recycler * recycler) override { VerifyCondition(false); };
+    virtual void OnMark() override {}
+    virtual void Mark(RecyclerHeapHandle recycler) override { Mark(static_cast<Recycler*>(recycler)); };
+    virtual void Trace(IRecyclerHeapMarkingContext* markContext) override { VerifyCondition(false); };
+
+    virtual void Mark(Recycler * recycler) { VerifyCondition(false); };
 
 public:
     static void BeginWalk()
@@ -27,6 +35,7 @@ class RecyclerTestObject : public FinalizableObject
         walkScannedByteCount = 0;
         walkBarrierByteCount = 0;
         walkTrackedByteCount = 0;
+        walkRecyclerVisitedByteCount = 0;
         walkLeafByteCount = 0;
         maxWalkDepth = 0;
 
@@ -66,13 +75,14 @@ class RecyclerTestObject : public FinalizableObject
         VerifyCondition(currentWalkDepth == 0);
 
         wprintf(_u("Full heap walk finished\n"));
-        wprintf(_u("Object Count:   %12llu\n"), (unsigned long long) walkObjectCount);
-        wprintf(_u("Scanned Bytes:  %12llu\n"), (unsigned long long) walkScannedByteCount);
-        wprintf(_u("Barrier Bytes:  %12llu\n"), (unsigned long long) walkBarrierByteCount);
-        wprintf(_u("Tracked Bytes:  %12llu\n"), (unsigned long long) walkTrackedByteCount);
-        wprintf(_u("Leaf Bytes:     %12llu\n"), (unsigned long long) walkLeafByteCount);
-        wprintf(_u("Total Bytes:    %12llu\n"), (unsigned long long) (walkScannedByteCount + walkBarrierByteCount + walkTrackedByteCount + walkLeafByteCount));
-        wprintf(_u("Max Depth:      %12llu\n"), (unsigned long long) maxWalkDepth);
+        wprintf(_u("Object Count:           %12llu\n"), (unsigned long long) walkObjectCount);
+        wprintf(_u("Scanned Bytes:          %12llu\n"), (unsigned long long) walkScannedByteCount);
+        wprintf(_u("Barrier Bytes:          %12llu\n"), (unsigned long long) walkBarrierByteCount);
+        wprintf(_u("Tracked Bytes:          %12llu\n"), (unsigned long long) walkTrackedByteCount);
+        wprintf(_u("RecyclerVisited Bytes:  %12llu\n"), (unsigned long long) walkRecyclerVisitedByteCount);
+        wprintf(_u("Leaf Bytes:             %12llu\n"), (unsigned long long) walkLeafByteCount);
+        wprintf(_u("Total Bytes:            %12llu\n"), (unsigned long long) (walkScannedByteCount + walkBarrierByteCount + walkTrackedByteCount + walkLeafByteCount + walkRecyclerVisitedByteCount));
+        wprintf(_u("Max Depth:              %12llu\n"), (unsigned long long) maxWalkDepth);
     }
 
     // Virtual methods
@@ -100,6 +110,7 @@ class RecyclerTestObject : public FinalizableObject
     static size_t walkLeafByteCount;
     static size_t walkBarrierByteCount;
     static size_t walkTrackedByteCount;
+    static size_t walkRecyclerVisitedByteCount;
     static size_t currentWalkDepth;
     static size_t maxWalkDepth;
 
@@ -232,8 +243,13 @@ class BarrierObject : public RecyclerTestObject
     FieldNoBarrier(RecyclerTestObject *) references[0];  // SWB-TODO: is this correct?
 };
 
+// TrackedObject must be a FinalizableObject (in order to be 'new'ed with RecyclerNewTrackedLeafPlusZ)
+// but it also must be a RecyclerTestObject to participate in GCStress. It must inherit from RecyclerTestObject
+// first so that the algined pointer is returned from New.
+// Fortunately, the v-tables for RecyclerTestObject and FinalizableObject line up, so the 
+// IRecyclerVisitedObject/FinalizableObject calls end up in the right place.
 template <unsigned int minCount, unsigned int maxCount>
-class TrackedObject : public RecyclerTestObject
+class TrackedObject : public RecyclerTestObject, public FinalizableObject
 {
 private:
     TrackedObject(unsigned int count) :
@@ -295,4 +311,124 @@ class TrackedObject : public RecyclerTestObject
     FieldNoBarrier(RecyclerTestObject *) references[0];  // SWB-TODO: is this correct?
 };
 
+#ifdef RECYCLER_VISITED_HOST
+
+template <unsigned int minCount, unsigned int maxCount>
+class RecyclerVisitedObject : public RecyclerTestObject
+{
+public:
+    static RecyclerTestObject * New()
+    {
+        // Determine a random amount of RecyclerTestObject* references to influence the size of this object.
+        const unsigned int count = minCount + GetRandomInteger(maxCount - minCount + 1);
+
+        void* mem = nullptr;
+        const size_t size = sizeof(RecyclerVisitedObject) + (sizeof(RecyclerTestObject*) * count);
+
+        // Randomly select the type of object to create
+        AllocationType allocType = static_cast<AllocationType>(GetRandomInteger(static_cast<unsigned int>(AllocationType::Count)));
+        switch (allocType)
+        {
+        case AllocationType::TraceAndFinalized:
+            mem = RecyclerAllocVisitedHostTracedAndFinalizedZero(recyclerInstance, size);
+            break;
+        case AllocationType::TraceOnly:
+            mem = RecyclerAllocVisitedHostTracedZero(recyclerInstance, size);
+            break;
+        case AllocationType::FinalizeLeaf:
+            mem = RecyclerAllocVisitedHostFinalizedZero(recyclerInstance, size);
+            break;
+        default:
+            Assert(allocType == AllocationType::Leaf);
+            mem = RecyclerAllocLeafZero(recyclerInstance, size);
+        }
+
+        // Construct the v-table, allocType, and count information for the new object.
+        RecyclerVisitedObject* obj = new (mem) RecyclerVisitedObject(allocType, count);
+        return obj;
+    }
+
+    virtual bool TryGetRandomLocation(Location * location) override
+    {
+        // Leaf types should not return a location
+        if (type == AllocationType::Leaf || type == AllocationType::FinalizeLeaf)
+        {
+            return false;
+        }
 
+        // Get a random slot and construct a Location for it
+        // Make this a Tagged location so that we won't inadvertently keep objects alive
+        // in the case where this object gets put on the wrong mark stack.
+        *location = Location::Tagged(&references[GetRandomInteger(count)]);
+
+        return true;
+    }
+
+    virtual void Trace(IRecyclerHeapMarkingContext* markContext) override
+    {
+        VerifyCondition(type == AllocationType::TraceAndFinalized || type == AllocationType::TraceOnly);
+        // Note that the pointers in the references arrary are technically tagged. However, this is ok
+        // as the Mark that we're performing is an interior mark, which gets us to the right object(s).
+        markContext->MarkObjects(reinterpret_cast<void**>(&references[0]), count, this);
+    }
+
+    virtual void Finalize(bool isShutdown) override
+    {
+        // Only types that request finalization should have Finalize called
+        VerifyCondition(IsFinalizable());
+    }
+    virtual void Dispose(bool isShutdown) override
+    { 
+        // Only types that request finalization should have Finalize called
+        VerifyCondition(IsFinalizable());
+        VerifyCondition(unmanagedResource != nullptr);
+        BOOL success = ::HeapFree(GetProcessHeap(), 0, unmanagedResource);
+        VerifyCondition(success != FALSE);
+        unmanagedResource = nullptr;
+    }
+
+
+protected:
+    virtual void DoWalkObject() override
+    {
+        walkRecyclerVisitedByteCount += sizeof(RecyclerVisitedObject) + count * sizeof(RecyclerTestObject *);
+
+        for (unsigned int i = 0; i < count; i++)
+        {
+            RecyclerTestObject::WalkReference(Location::Untag(references[i]));
+        }
+    }
+
+private:
+    enum class AllocationType : unsigned int
+    {
+        TraceAndFinalized = 0,
+        TraceOnly,
+        FinalizeLeaf,
+        Leaf,
+        Count,
+    };
+
+    bool IsFinalizable() const { return type == AllocationType::TraceAndFinalized || type == AllocationType::FinalizeLeaf; }
+    RecyclerVisitedObject(AllocationType allocType, unsigned int count) :
+        count(count),
+        type(allocType)
+    {
+        for (unsigned int i = 0; i < count; i++)
+        {
+            references[i] = nullptr;
+        }
+        if (IsFinalizable())
+        {
+            unmanagedResource = ::HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, GetRandomInteger(1024));
+            VerifyCondition(unmanagedResource != nullptr);
+        }
+    }
+
+
+    Field(AllocationType) type;
+    Field(void*) unmanagedResource;
+    Field(unsigned int) count;
+    FieldNoBarrier(RecyclerTestObject *) references[0];  // SWB-TODO: is this correct? (copied from TrackedObject)
+};
+#endif

bin/ch/Helpers.cpp

@@ -191,6 +191,9 @@ HRESULT Helpers::LoadScriptFromFile(LPCSTR filename, LPCSTR& contents, UINT* len
         // wrongly classified as ANSI
         //
         {
+#pragma warning(push)
+// suppressing prefast warning that "readable size is bufferLength bytes but 2 may be read" as bufferLength is clearly > 2 in the code that follows
+#pragma warning(disable:6385)
             C_ASSERT(sizeof(WCHAR) == 2);
             if (bufferLength > 2)
             {
@@ -211,6 +214,7 @@ HRESULT Helpers::LoadScriptFromFile(LPCSTR filename, LPCSTR& contents, UINT* len
 #pragma prefast(pop)
             }
         }
+#pragma warning(pop)
     }
 
     contents = reinterpret_cast<LPCSTR>(pRawBytes);

lib/Common/CommonDefines.h

@@ -239,6 +239,10 @@
 #error "Background page zeroing can't be turned on if freeing pages in the background is disabled"
 #endif
 
+#ifdef _WIN32
+#define RECYCLER_VISITED_HOST
+#endif
+
 // JIT features
 
 #if DISABLE_JIT

lib/Common/CommonMinMemory.h

@@ -40,5 +40,6 @@ class FinalizableObject;
 #include "Memory/RecyclerSweep.h"
 #include "Memory/RecyclerHeuristic.h"
 #include "Memory/MarkContext.h"
+#include "Memory/MarkContextWrapper.h"
 #include "Memory/RecyclerWatsonTelemetry.h"
 #include "Memory/Recycler.h"

lib/Common/Core/FinalizableObject.h

@@ -3,24 +3,22 @@
 // Licensed under the MIT license. See LICENSE.txt file in the project root for full license information.
 //-------------------------------------------------------------------------------------------------------
 #pragma once
-class FinalizableObject
+#include "RecyclerVisitedObject.h"
+
+class FinalizableObject : public IRecyclerVisitedObject
 {
 public:
-    // Called right after finish marking and this object is determined to be dead.
-    // Should contain only simple clean up code.
-    // Can't run another script
-    // Can't cause a re-entrant collection
-
-    virtual void Finalize(bool isShutdown) = 0;
-
-    // Call after sweeping is done.
-    // Can call other script or cause another collection.
+    virtual void OnMark() {}
 
-    virtual void Dispose(bool isShutdown) = 0;
+    void Mark(RecyclerHeapHandle recycler) final
+    {
+        Mark(static_cast<Recycler*>(recycler));
+    }
 
-    // Used only by TrackableObjects (created with TrackedBit on by RecyclerNew*Tracked)
-    virtual void Mark(Recycler * recycler) = 0;
+    void Trace(IRecyclerHeapMarkingContext* markingContext) final
+    {
+        AssertMsg(false, "Trace called on object that isn't implemented by the host");
+    }
 
-    // Special behavior on certain GC's
-    virtual void OnMark() {}
+    virtual void Mark(Recycler* recycler) = 0;
 };

lib/Common/Core/RecyclerHeapMarkingContext.h

@@ -0,0 +1,11 @@
+//-------------------------------------------------------------------------------------------------------
+// Copyright (C) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE.txt file in the project root for full license information.
+//-------------------------------------------------------------------------------------------------------
+#pragma once
+
+interface IRecyclerHeapMarkingContext
+{
+    virtual void MarkObjects(void** objects, size_t count, void* parent) = 0;
+};
+

lib/Common/Core/RecyclerVisitedObject.h

@@ -0,0 +1,31 @@
+//-------------------------------------------------------------------------------------------------------
+// Copyright (C) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE.txt file in the project root for full license information.
+//-------------------------------------------------------------------------------------------------------
+#pragma once
+
+interface IRecyclerHeapMarkingContext;
+typedef void* RecyclerHeapHandle;
+
+interface IRecyclerVisitedObject
+{
+    // Called right after finish marking and this object is determined to be dead.
+    // Should contain only simple clean up code.
+    // Can't run another script
+    // Can't cause a re-entrant collection
+    virtual void Finalize(bool isShutdown) = 0;
+
+    // Call after sweeping is done.
+    // Can call other script or cause another collection.
+    virtual void Dispose(bool isShutdown) = 0;
+
+    // Used only by TrackableObjects (created with TrackedBit on by RecyclerNew*Tracked)
+    virtual void Mark(RecyclerHeapHandle recycler) = 0;
+
+    // Special behavior on certain GC's
+    virtual void OnMark() = 0;
+
+    // Used only by RecyclerVisitedHost objects (created with RecyclerAllocVistedHost_Traced*)
+    virtual void Trace(IRecyclerHeapMarkingContext* markingContext) = 0;
+};
+

lib/Common/Exceptions/ReportError.h

@@ -27,6 +27,7 @@ enum ErrorReason
     Fatal_JsReentrancy_Error = 19,
     Fatal_TTDAbort = 20,
     Fatal_Failed_API_Result = 21,
+    Fatal_RecyclerVisitedHost_LargeHeapBlock = 22,
 };
 
 extern "C" void ReportFatalException(

lib/Common/Memory/HeapBlock.cpp

@@ -31,6 +31,16 @@ HeapBlock::AsFinalizableBlock()
     return static_cast<SmallFinalizableHeapBlockT<TBlockAttributes> *>(this);
 }
 
+#ifdef RECYCLER_VISITED_HOST
+template <typename TBlockAttributes>
+SmallRecyclerVisitedHostHeapBlockT<TBlockAttributes> *
+HeapBlock::AsRecyclerVisitedHostBlock()
+{
+    Assert(IsRecyclerVisitedHostBlock());
+    return static_cast<SmallRecyclerVisitedHostHeapBlockT<TBlockAttributes> *>(this);
+}
+#endif
+
 #ifdef RECYCLER_WRITE_BARRIER
 template <typename TBlockAttributes>
 SmallNormalWithBarrierHeapBlockT<TBlockAttributes> *