Multiple frozen segments

src/coreclr/inc/clrconfigvalues.h

@@ -406,8 +406,15 @@ RETAIL_CONFIG_DWORD_INFO(INTERNAL_BreakOnOutOfMemoryWithinRange, W("BreakOnOutOf
 ///
 /// Frozen segments (aka Frozen Object Heap)
 ///
-RETAIL_CONFIG_DWORD_INFO(INTERNAL_FrozenSegmentReserveSize, W("FrozenSegmentReserveSize"), 0x400000, "Amount of memory to reserve for frozen segments") // 4Mb
-RETAIL_CONFIG_DWORD_INFO(INTERNAL_FrozenSegmentCommitSize, W("FrozenSegmentCommitSize"), 0x10000, "Amount of memory to commit on demand for frozen segments") // 64Kb
+#ifdef _DEBUG
+#define FrozenSegmentReserveSize (0x4000) // 16Kb
+#define FrozenSegmentCommitSize (0x1000)  // 4Kb
+#else
+#define FrozenSegmentReserveSize (0x400000) // 4Mb
+#define FrozenSegmentCommitSize (0x10000)   // 64Kb
+#endif
+RETAIL_CONFIG_DWORD_INFO(INTERNAL_FrozenSegmentReserveSize, W("FrozenSegmentReserveSize"), FrozenSegmentReserveSize, "Amount of memory to reserve for a frozen segment")
+RETAIL_CONFIG_DWORD_INFO(INTERNAL_FrozenSegmentCommitSize, W("FrozenSegmentCommitSize"), FrozenSegmentCommitSize, "Amount of memory to commit on demand for frozen segments")
 
 ///
 /// Log

src/coreclr/vm/appdomain.cpp

@@ -101,8 +101,8 @@ CrstStatic          BaseDomain::m_SpecialStaticsCrst;
 int                 BaseDomain::m_iNumberOfProcessors = 0;
 
 // System Domain Statics
-GlobalStringLiteralMap* SystemDomain::m_pGlobalStringLiteralMap = NULL;
-FrozenObjectHeap*       SystemDomain::m_FrozenObjects           = NULL;
+GlobalStringLiteralMap*  SystemDomain::m_pGlobalStringLiteralMap = NULL;
+FrozenObjectHeapManager* SystemDomain::m_FrozenObjectHeapManager = NULL;
 
 DECLSPEC_ALIGN(16)
 static BYTE         g_pSystemDomainMemory[sizeof(SystemDomain)];
@@ -1209,8 +1209,8 @@ void SystemDomain::LazyInitFrozenObjectsHeap()
     }
     CONTRACTL_END;
 
-    NewHolder<FrozenObjectHeap> pFoh(new FrozenObjectHeap());
-    if (InterlockedCompareExchangeT<FrozenObjectHeap*>(&m_FrozenObjects, pFoh, nullptr) == nullptr)
+    NewHolder<FrozenObjectHeapManager> pFoh(new FrozenObjectHeapManager());
+    if (InterlockedCompareExchangeT<FrozenObjectHeapManager*>(&m_FrozenObjectHeapManager, pFoh, nullptr) == nullptr)
     {
         pFoh.SuppressRelease();
     }

src/coreclr/vm/appdomain.hpp

@@ -40,7 +40,7 @@ class SystemDomain;
 class AppDomain;
 class GlobalStringLiteralMap;
 class StringLiteralMap;
-class FrozenObjectHeap;
+class FrozenObjectHeapManager;
 class MngStdInterfacesInfo;
 class DomainAssembly;
 class LoadLevelLimiter;
@@ -2467,17 +2467,17 @@ class SystemDomain : public BaseDomain
         _ASSERTE(m_pGlobalStringLiteralMap);
         return m_pGlobalStringLiteralMap;
     }
-    static FrozenObjectHeap* GetSegmentWithFrozenObjects()
+    static FrozenObjectHeapManager* GetFrozenObjectHeapManager()
     {
         WRAPPER_NO_CONTRACT;
 
 #ifdef FEATURE_BASICFREEZE
-        if (m_FrozenObjects == NULL)
+        if (m_FrozenObjectHeapManager == NULL)
         {
             SystemDomain::LazyInitFrozenObjectsHeap();
         }
 #endif
-        return m_FrozenObjects;
+        return m_FrozenObjectHeapManager;
     }
 #endif // DACCESS_COMPILE
 
@@ -2648,7 +2648,7 @@ class SystemDomain : public BaseDomain
     static CrstStatic       m_SystemDomainCrst;
 
     static GlobalStringLiteralMap *m_pGlobalStringLiteralMap;
-    static FrozenObjectHeap *m_FrozenObjects;
+    static FrozenObjectHeapManager *m_FrozenObjectHeapManager;
 #endif // DACCESS_COMPILE
 
 public:

src/coreclr/vm/frozenobjectheap.cpp

@@ -4,135 +4,151 @@
 #include "frozenobjectheap.h"
 #include "memorypool.h"
 
-FrozenObjectHeap::FrozenObjectHeap():
-    m_pStart(nullptr),
-    m_pCurrent(nullptr),
-    m_CommitChunkSize(0),
-    m_SizeCommitted(0),
-    m_SizeReserved(0),
-    m_SegmentHandle(nullptr)
-    COMMA_INDEBUG(m_ObjectsCount(0))
+
+FrozenObjectHeapManager::FrozenObjectHeapManager():
+    m_CurrentHeap(nullptr)
 {
     m_Crst.Init(CrstFrozenObjectHeap, CRST_UNSAFE_COOPGC);
+    m_HeapCommitChunkSize = CLRConfig::GetConfigValue(CLRConfig::INTERNAL_FrozenSegmentCommitSize);
+    m_HeapSize = CLRConfig::GetConfigValue(CLRConfig::INTERNAL_FrozenSegmentReserveSize);
 }
 
-FrozenObjectHeap::~FrozenObjectHeap()
+// Allocates an object of the give size (including header) on a frozen segment.
+// May return nullptr in the following cases:
+//   1) DOTNET_FrozenSegmentReserveSize is 0 (disabled)
+//   2) Object is too large (large than DOTNET_FrozenSegmentCommitSize)
+// in such cases caller is responsible to find a more appropriate heap to allocate it
+Object* FrozenObjectHeapManager::AllocateObject(size_t objectSize)
 {
-    if (m_SegmentHandle != nullptr)
+    CONTRACTL
     {
-        GCHeapUtilities::GetGCHeap()->UnregisterFrozenSegment(m_SegmentHandle);
+        THROWS;
+        MODE_COOPERATIVE;
     }
+    CONTRACTL_END
+
+    CrstHolder ch(&m_Crst);
 
-    if (m_pStart != nullptr)
+    // Quick way to disable Frozen Heaps
+    if (m_HeapSize == 0)
     {
-        ClrVirtualFree(m_pStart, 0, MEM_RELEASE);
+        return nullptr;
     }
-}
 
-bool FrozenObjectHeap::Initialize()
-{
-    // For internal testing
-    m_CommitChunkSize = CLRConfig::GetConfigValue(CLRConfig::INTERNAL_FrozenSegmentCommitSize);
-    m_SizeReserved = CLRConfig::GetConfigValue(CLRConfig::INTERNAL_FrozenSegmentReserveSize);
+    _ASSERT(m_HeapCommitChunkSize >= MIN_OBJECT_SIZE);
+    _ASSERT(m_HeapSize > m_HeapCommitChunkSize);
+    _ASSERT(m_HeapSize % m_HeapCommitChunkSize == 0);
 
-    if (m_SizeReserved == 0)
+    // NOTE: objectSize is expected be the full size including header
+    _ASSERT(objectSize >= MIN_OBJECT_SIZE);
+
+    if (objectSize > m_HeapCommitChunkSize)
     {
-        // A way to disable FrozenObjectHeap
-        return false;
+        // The current design doesn't allow object larger than DOTNET_FrozenSegmentCommitSize and
+        // since FrozenObjectHeap is just an optimization, let's not fill it with huge objects.
+        return nullptr;
     }
 
-    _ASSERT(m_SizeReserved > m_CommitChunkSize);
-    _ASSERT(m_SizeReserved % m_CommitChunkSize == 0);
-    _ASSERT(m_SegmentHandle == nullptr);
-    _ASSERT(m_pStart == nullptr);
-
-    void* alloc = ClrVirtualAlloc(nullptr, m_SizeReserved, MEM_RESERVE, PAGE_READWRITE);
-    if (alloc != nullptr)
+    if (m_CurrentHeap == nullptr)
     {
-        // Commit FOH_COMMIT_SIZE chunk in advance
-        alloc = ClrVirtualAlloc(alloc, m_CommitChunkSize, MEM_COMMIT, PAGE_READWRITE);
+        // Create the first heap on first allocation
+        m_CurrentHeap = new FrozenObjectHeap(m_HeapSize, m_HeapCommitChunkSize);
+        m_FrozenHeaps.Append(m_CurrentHeap);
+        _ASSERT(m_CurrentHeap != nullptr);
     }
 
-    if (alloc != nullptr)
+    Object* obj = m_CurrentHeap->AllocateObject(objectSize);
+
+    // The only case where it might be null is when the current heap is full and we need
+    // to create a new one
+    if (obj == nullptr)
     {
-        // ClrVirtualAlloc is expected to be PageSize-aligned so we can expect
-        // DATA_ALIGNMENT alignment as well
-        _ASSERT(IS_ALIGNED(alloc, DATA_ALIGNMENT));
-
-        segment_info si;
-        si.pvMem = alloc;
-        si.ibFirstObject = sizeof(ObjHeader);
-        si.ibAllocated = si.ibFirstObject;
-        si.ibCommit = m_CommitChunkSize;
-        si.ibReserved = m_SizeReserved;
-
-        m_SegmentHandle = GCHeapUtilities::GetGCHeap()->RegisterFrozenSegment(&si);
-        if (m_SegmentHandle != nullptr)
-        {
-            m_pStart = static_cast<uint8_t*>(alloc);
-            m_pCurrent = m_pStart;
-            m_SizeCommitted = si.ibCommit;
-            INDEBUG(m_ObjectsCount = 0);
-            return true;
-        }
+        m_CurrentHeap = new FrozenObjectHeap(m_HeapSize, m_HeapCommitChunkSize);
+        m_FrozenHeaps.Append(m_CurrentHeap);
+
+        // Try again
+        obj = m_CurrentHeap->AllocateObject(objectSize);
 
-        // GC refused to register frozen segment (OOM?)
-        ClrVirtualFree(m_pStart, 0, MEM_RELEASE);
-        m_pStart = nullptr;
+        // This time it's not expected to be null
+        _ASSERT(obj != nullptr);
     }
-    return false;
+    return obj;
 }
 
 
-Object* FrozenObjectHeap::AllocateObject(size_t objectSize)
+FrozenObjectHeap::FrozenObjectHeap(size_t reserveSize, size_t commitChunkSize):
+    m_pStart(nullptr),
+    m_pCurrent(nullptr),
+    m_CommitChunkSize(0),
+    m_SizeCommitted(0),
+    m_SegmentHandle(nullptr)
+    COMMA_INDEBUG(m_ObjectsCount(0))
 {
-    // NOTE: objectSize is expected be the full size including header
-    _ASSERT(objectSize >= MIN_OBJECT_SIZE);
+    m_SizeReserved = reserveSize;
+    m_CommitChunkSize = commitChunkSize;
 
-    CrstHolder ch(&m_Crst);
+    void* alloc = ClrVirtualAlloc(nullptr, m_SizeReserved, MEM_RESERVE, PAGE_READWRITE);
+    if (alloc == nullptr)
+    {
+        ThrowOutOfMemory();
+    }
 
-    if (m_pStart == nullptr)
+    // Commit a chunk in advance
+    alloc = ClrVirtualAlloc(alloc, m_CommitChunkSize, MEM_COMMIT, PAGE_READWRITE);
+    if (alloc == nullptr)
     {
-        // m_SizeReserved > 0 means we already tried to init and it failed.
-        // so bail out to avoid doing Alloc again.
-        if ((m_SizeReserved > 0) || !Initialize())
-        {
-            return nullptr;
-        }
+        ThrowOutOfMemory();
     }
 
-    if (objectSize > m_CommitChunkSize)
+    // ClrVirtualAlloc is expected to be PageSize-aligned so we can expect
+    // DATA_ALIGNMENT alignment as well
+    _ASSERT(IS_ALIGNED(alloc, DATA_ALIGNMENT));
+
+    segment_info si;
+    si.pvMem = alloc;
+    si.ibFirstObject = sizeof(ObjHeader);
+    si.ibAllocated = si.ibFirstObject;
+    si.ibCommit = m_CommitChunkSize;
+    si.ibReserved = m_SizeReserved;
+
+    m_SegmentHandle = GCHeapUtilities::GetGCHeap()->RegisterFrozenSegment(&si);
+    if (m_SegmentHandle == nullptr)
     {
-        // The current design doesn't allow object larger than FOH_COMMIT_CHUNK_SIZE and
-        // since FrozenObjectHeap is just an optimization, let's not fill it with huge objects.
-        return nullptr;
+        ThrowOutOfMemory();
     }
 
-    _ASSERT(m_pStart != nullptr);
-    _ASSERT(m_SegmentHandle != nullptr);
+    m_pStart = static_cast<uint8_t*>(alloc);
+    m_pCurrent = m_pStart;
+    m_SizeCommitted = si.ibCommit;
+    INDEBUG(m_ObjectsCount = 0);
+    return;
+}
+
+Object* FrozenObjectHeap::AllocateObject(size_t objectSize)
+{
+    _ASSERT(m_pStart != nullptr && m_SizeReserved > 0 && m_SegmentHandle != nullptr); // Expected to be inited
     _ASSERT(IS_ALIGNED(m_pCurrent, DATA_ALIGNMENT));
 
     uint8_t* obj = m_pCurrent;
-    if ((size_t)(m_pStart + m_SizeReserved) < (size_t)(obj + objectSize))
+    if (reinterpret_cast<size_t>(m_pStart + m_SizeReserved) < reinterpret_cast<size_t>(obj + objectSize))
     {
-        // heap is full, caller is expected to switch to other heaps
-        // TODO: register a new frozen segment
+        // heap is full
         return nullptr;
     }
 
     // Check if we need to commit a new chunk
-    if ((size_t)(m_pStart + m_SizeCommitted) < (size_t)(obj + objectSize))
+    if (reinterpret_cast<size_t>(m_pStart + m_SizeCommitted) < reinterpret_cast<size_t>(obj + objectSize))
     {
         _ASSERT(m_SizeCommitted + m_CommitChunkSize <= m_SizeReserved);
         if (ClrVirtualAlloc(m_pStart + m_SizeCommitted, m_CommitChunkSize, MEM_COMMIT, PAGE_READWRITE) == nullptr)
         {
-            // We failed to commit a new chunk of the reserved memory
-            return nullptr;
+            ThrowOutOfMemory();
         }
         m_SizeCommitted += m_CommitChunkSize;
     }
 
     INDEBUG(m_ObjectsCount++);
+
     m_pCurrent = obj + objectSize;
 
     // Notify GC that we bumped the pointer and, probably, committed more memory in the reserved part

src/coreclr/vm/frozenobjectheap.h

@@ -6,24 +6,37 @@
 
 #include "common.h"
 #include "gcinterface.h"
+#include <sarray.h>
 
-class FrozenObjectHeap
+class FrozenObjectHeap;
+
+class FrozenObjectHeapManager
 {
 public:
-    FrozenObjectHeap();
-    ~FrozenObjectHeap();
+    FrozenObjectHeapManager();
     Object* AllocateObject(size_t objectSize);
 
 private:
-    bool Initialize();
+    CrstExplicitInit m_Crst;
+    SArray<FrozenObjectHeap*> m_FrozenHeaps;
+    FrozenObjectHeap* m_CurrentHeap;
+    size_t m_HeapCommitChunkSize;
+    size_t m_HeapSize;
+};
 
+class FrozenObjectHeap
+{
+public:
+    FrozenObjectHeap(size_t reserveSize, size_t commitChunkSize);
+    Object* AllocateObject(size_t objectSize);
+
+private:
     uint8_t* m_pStart;
     uint8_t* m_pCurrent;
     size_t m_CommitChunkSize;
     size_t m_SizeCommitted;
     size_t m_SizeReserved;
     segment_handle m_SegmentHandle;
-    CrstExplicitInit m_Crst;
     INDEBUG(size_t m_ObjectsCount);
 };
 

src/coreclr/vm/gchelpers.cpp

@@ -887,10 +887,10 @@ STRINGREF AllocateString(DWORD cchStringLength, bool preferFrozenHeap)
 
     if (preferFrozenHeap)
     {
-        FrozenObjectHeap* foh = SystemDomain::GetSegmentWithFrozenObjects();
+        FrozenObjectHeapManager* foh = SystemDomain::GetFrozenObjectHeapManager();
         if (foh != nullptr)
         {
-            orString = (StringObject*)foh->AllocateObject(totalSize);
+            orString = static_cast<StringObject*>(foh->AllocateObject(totalSize));
             if (orString != nullptr)
             {
                 orString->SetMethodTable(g_pStringClass);