Allocate string literals on frozen segments

src/coreclr/gc/gc.cpp

@@ -7753,6 +7753,8 @@ inline
 BOOL gc_heap::ephemeral_pointer_p (uint8_t* o)
 {
 #ifdef USE_REGIONS
+
+
     int gen_num = object_gennum ((uint8_t*)o);
     assert (gen_num >= 0);
     return (gen_num < max_generation);
@@ -44690,6 +44692,13 @@ unsigned int GCHeap::GetGenerationWithRange (Object* object, uint8_t** ppStart,
 bool GCHeap::IsEphemeral (Object* object)
 {
     uint8_t* o = (uint8_t*)object;
+#if defined(FEATURE_BASICFREEZE) && defined(USE_REGIONS)
+    if (!is_in_heap_range(o))
+    {
+        // objects in frozen segments are not ephemeral
+        return FALSE;
+    }
+#endif
     gc_heap* hp = gc_heap::heap_of (o);
     return !!hp->ephemeral_pointer_p (o);
 }

src/coreclr/inc/crsttypes.h

@@ -134,7 +134,8 @@ enum CrstType
     CrstUnwindInfoTableLock = 116,
     CrstVSDIndirectionCellLock = 117,
     CrstWrapperTemplate = 118,
-    kNumberOfCrstTypes = 119
+    CrstFrozenObjectHeap = 119,
+    kNumberOfCrstTypes = 120
 };
 
 #endif // __CRST_TYPES_INCLUDED

src/coreclr/jit/assertionprop.cpp

@@ -1150,8 +1150,14 @@ void Compiler::optPrintAssertion(AssertionDsc* curAssertion, AssertionIndex asse
 
                     if (op1Type == TYP_REF)
                     {
-                        assert(curAssertion->op2.u1.iconVal == 0);
-                        printf("null");
+                        if (curAssertion->op2.u1.iconVal == 0)
+                        {
+                            printf("null");
+                        }
+                        else
+                        {
+                            printf("[%08p]", dspPtr(curAssertion->op2.u1.iconVal));
+                        }
                     }
                     else
                     {
@@ -3063,11 +3069,9 @@ GenTree* Compiler::optVNConstantPropOnTree(BasicBlock* block, GenTree* tree)
 
         case TYP_REF:
         {
-            assert(vnStore->ConstantValue<size_t>(vnCns) == 0);
-            // Support onle ref(ref(0)), do not support other forms (e.g byref(ref(0)).
             if (tree->TypeGet() == TYP_REF)
             {
-                conValTree = gtNewIconNode(0, TYP_REF);
+                conValTree = gtNewIconNode(vnStore->ConstantValue<size_t>(vnCns), TYP_REF);
             }
         }
         break;
@@ -4024,8 +4028,14 @@ GenTree* Compiler::optAssertionPropGlobal_RelOp(ASSERT_VALARG_TP assertions, Gen
             else if (op1->TypeGet() == TYP_REF)
             {
                 // The only constant of TYP_REF that ValueNumbering supports is 'null'
-                assert(vnStore->ConstantValue<size_t>(vnCns) == 0);
-                printf("null\n");
+                if (vnStore->ConstantValue<size_t>(vnCns) == 0)
+                {
+                    printf("null\n");
+                }
+                else
+                {
+                    printf("%d (gcref)\n", static_cast<target_ssize_t>(vnStore->ConstantValue<size_t>(vnCns)));
+                }
             }
             else if (op1->TypeGet() == TYP_BYREF)
             {
@@ -4078,9 +4088,7 @@ GenTree* Compiler::optAssertionPropGlobal_RelOp(ASSERT_VALARG_TP assertions, Gen
         }
         else if (op1->TypeGet() == TYP_REF)
         {
-            op1->BashToConst(0, TYP_REF);
-            // The only constant of TYP_REF that ValueNumbering supports is 'null'
-            noway_assert(vnStore->ConstantValue<size_t>(vnCns) == 0);
+            op1->BashToConst(static_cast<target_ssize_t>(vnStore->ConstantValue<size_t>(vnCns)), TYP_REF);
         }
         else if (op1->TypeGet() == TYP_BYREF)
         {

src/coreclr/jit/gentree.cpp

@@ -3835,10 +3835,17 @@ bool Compiler::gtIsLikelyRegVar(GenTree* tree)
 //
 bool Compiler::gtCanSwapOrder(GenTree* firstNode, GenTree* secondNode)
 {
-    // Relative of order of global / side effects can't be swapped.
-
     bool canSwap = true;
 
+    // Don't swap "CONST_HDL op CNS"
+    if (firstNode->IsIntegralConst() && secondNode->IsIntegralConst() && varTypeIsGC(firstNode) &&
+        !varTypeIsGC(secondNode))
+    {
+        canSwap = false;
+    }
+
+    // Relative of order of global / side effects can't be swapped.
+
     if (optValnumCSE_phase)
     {
         canSwap = optCSE_canSwap(firstNode, secondNode);

src/coreclr/vm/CMakeLists.txt

@@ -326,6 +326,7 @@ set(VM_SOURCES_WKS
     fcall.cpp
     fieldmarshaler.cpp
     finalizerthread.cpp
+    frozenobjectheap.cpp
     gccover.cpp
     gcenv.ee.static.cpp
     gcenv.ee.common.cpp
@@ -431,6 +432,7 @@ set(VM_HEADERS_WKS
     fcall.h
     fieldmarshaler.h
     finalizerthread.h
+    frozenobjectheap.h
     gcenv.h
     gcenv.ee.h
     gcenv.os.h

src/coreclr/vm/appdomain.cpp

@@ -22,6 +22,7 @@
 #include "assemblynative.hpp"
 #include "shimload.h"
 #include "stringliteralmap.h"
+#include "frozenobjectheap.h"
 #include "codeman.h"
 #include "comcallablewrapper.h"
 #include "eventtrace.h"
@@ -101,6 +102,7 @@ int                 BaseDomain::m_iNumberOfProcessors = 0;
 
 // System Domain Statics
 GlobalStringLiteralMap* SystemDomain::m_pGlobalStringLiteralMap = NULL;
+FrozenObjectHeap*       SystemDomain::m_FrozenObjects           = NULL;
 
 DECLSPEC_ALIGN(16)
 static BYTE         g_pSystemDomainMemory[sizeof(SystemDomain)];
@@ -1196,6 +1198,24 @@ void SystemDomain::LazyInitGlobalStringLiteralMap()
     }
 }
 
+void SystemDomain::LazyInitFrozenObjectsHeap()
+{
+    CONTRACTL
+    {
+        THROWS;
+        GC_TRIGGERS;
+        MODE_ANY;
+        INJECT_FAULT(COMPlusThrowOM(););
+    }
+    CONTRACTL_END;
+
+    NewHolder<FrozenObjectHeap> pFoh(new FrozenObjectHeap());
+    if (InterlockedCompareExchangeT<FrozenObjectHeap*>(&m_FrozenObjects, pFoh, nullptr) == nullptr)
+    {
+        pFoh.SuppressRelease();
+    }
+}
+
 /*static*/ void SystemDomain::EnumAllStaticGCRefs(promote_func* fn, ScanContext* sc)
 {
     CONTRACT_VOID

src/coreclr/vm/appdomain.hpp

@@ -40,6 +40,7 @@ class SystemDomain;
 class AppDomain;
 class GlobalStringLiteralMap;
 class StringLiteralMap;
+class FrozenObjectHeap;
 class MngStdInterfacesInfo;
 class DomainAssembly;
 class LoadLevelLimiter;
@@ -2393,6 +2394,7 @@ class SystemDomain : public BaseDomain
     void Init();
     void Stop();
     static void LazyInitGlobalStringLiteralMap();
+    static void LazyInitFrozenObjectsHeap();
 
     //****************************************************************************************
     //
@@ -2465,6 +2467,18 @@ class SystemDomain : public BaseDomain
         _ASSERTE(m_pGlobalStringLiteralMap);
         return m_pGlobalStringLiteralMap;
     }
+    static FrozenObjectHeap* GetSegmentWithFrozenObjects()
+    {
+        WRAPPER_NO_CONTRACT;
+
+#ifdef FEATURE_BASICFREEZE
+        if (m_FrozenObjects == NULL)
+        {
+            SystemDomain::LazyInitFrozenObjectsHeap();
+        }
+#endif
+        return m_FrozenObjects;
+    }
 #endif // DACCESS_COMPILE
 
 #if defined(FEATURE_COMINTEROP_APARTMENT_SUPPORT)
@@ -2634,6 +2648,7 @@ class SystemDomain : public BaseDomain
     static CrstStatic       m_SystemDomainCrst;
 
     static GlobalStringLiteralMap *m_pGlobalStringLiteralMap;
+    static FrozenObjectHeap *m_FrozenObjects;
 #endif // DACCESS_COMPILE
 
 public:

src/coreclr/vm/ceeload.cpp

@@ -2835,7 +2835,7 @@ void ModuleBase::InitializeStringData(DWORD token, EEStringData *pstrData, CQuic
 }
 
 
-OBJECTHANDLE ModuleBase::ResolveStringRef(DWORD token)
+OBJECTHANDLE ModuleBase::ResolveStringRef(DWORD token, void** ppPinnedString)
 {
     CONTRACTL
     {
@@ -2864,7 +2864,7 @@ OBJECTHANDLE ModuleBase::ResolveStringRef(DWORD token)
 
     pLoaderAllocator = this->GetLoaderAllocator();
 
-    string = (OBJECTHANDLE)pLoaderAllocator->GetStringObjRefPtrFromUnicodeString(&strData);
+    string = (OBJECTHANDLE)pLoaderAllocator->GetStringObjRefPtrFromUnicodeString(&strData, ppPinnedString);
 
     return string;
 }

src/coreclr/vm/ceeload.h

@@ -579,7 +579,7 @@ class ModuleBase
     }
 
     // Resolving
-    OBJECTHANDLE ResolveStringRef(DWORD Token);
+    OBJECTHANDLE ResolveStringRef(DWORD Token, void** ppPinnedString = nullptr);
 private:
     // string helper
     void InitializeStringData(DWORD token, EEStringData *pstrData, CQuickBytes *pqb);

src/coreclr/vm/dynamicmethod.cpp

@@ -1275,7 +1275,8 @@ STRINGREF* LCGMethodResolver::GetOrInternString(STRINGREF *pProtectedStringRef)
     // lock the global string literal interning map
     CrstHolder gch(pStringLiteralMap->GetHashTableCrstGlobal());
 
-    StringLiteralEntryHolder pEntry(pStringLiteralMap->GetInternedString(pProtectedStringRef, dwHash, /* bAddIfNotFound */ TRUE));
+    StringLiteralEntryHolder pEntry(pStringLiteralMap->GetInternedString(pProtectedStringRef, dwHash,
+        /* bAddIfNotFound */ TRUE, /* bPreferFrozenObjectHeap */ FALSE));
 
     DynamicStringLiteral* pStringLiteral = (DynamicStringLiteral*)m_jitTempData.New(sizeof(DynamicStringLiteral));
     pStringLiteral->m_pEntry = pEntry.Extract();

src/coreclr/vm/frozenobjectheap.cpp

@@ -0,0 +1,120 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+#include "frozenobjectheap.h"
+#include "memorypool.h"
+
+FrozenObjectHeap::FrozenObjectHeap():
+    m_pStart(nullptr),
+    m_pCurrent(nullptr),
+    m_pCommited(nullptr),
+    m_Size(0),
+    m_SegmentHandle(nullptr)
+    COMMA_INDEBUG(m_ObjectsCount(0))
+{
+    m_PageSize = GetOsPageSize();
+    m_Crst.Init(CrstFrozenObjectHeap, CRST_UNSAFE_ANYMODE);
+}
+
+FrozenObjectHeap::~FrozenObjectHeap()
+{
+    if (m_SegmentHandle != nullptr)
+    {
+        GCHeapUtilities::GetGCHeap()->UnregisterFrozenSegment(m_SegmentHandle);
+    }
+
+    if (m_pStart != nullptr)
+    {
+        ClrVirtualFree(m_pStart, 0, MEM_RELEASE);
+    }
+}
+
+bool FrozenObjectHeap::Initialize()
+{
+    m_Size = m_PageSize * 1024; // e.g. 4Mb
+
+    _ASSERT(m_PageSize > MIN_OBJECT_SIZE);
+    _ASSERT(m_SegmentHandle == nullptr);
+    _ASSERT(m_pStart == nullptr);
+
+    // TODO: Implement COMMIT on demand.
+    void* alloc = ClrVirtualAllocAligned(nullptr, m_Size, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE, m_PageSize);
+    ZeroMemory(alloc, m_Size); // Will remove, was just testing.
+
+    if (alloc != nullptr)
+    {
+        segment_info si;
+        si.pvMem = alloc;
+        si.ibFirstObject = sizeof(ObjHeader);
+        si.ibAllocated = m_Size;
+        si.ibCommit = m_Size;
+        si.ibReserved = m_Size;
+
+        m_SegmentHandle = GCHeapUtilities::GetGCHeap()->RegisterFrozenSegment(&si);
+        if (m_SegmentHandle != nullptr)
+        {
+            m_pStart = static_cast<uint8_t*>(alloc);
+            m_pCurrent = m_pStart;
+            m_pCommited = m_pStart;
+            INDEBUG(m_ObjectsCount = 0);
+            ASSERT((intptr_t)m_pCurrent % DATA_ALIGNMENT == 0);
+            return true;
+        }
+
+        // GC refused to register frozen segment (OOM?)
+        ClrVirtualFree(m_pStart, 0, MEM_RELEASE);
+        m_pStart = nullptr;
+    }
+    return false;
+}
+
+Object* FrozenObjectHeap::AllocateObject(size_t objectSize)
+{
+    CrstHolder ch(&m_Crst);
+
+    if (objectSize > m_PageSize)
+    {
+        // Since FrozenObjectHeap is just an optimization, let's not fill it with large objects.
+        return nullptr;
+    }
+
+    if (m_pStart == nullptr)
+    {
+        // m_Size > 0 means we already tried to init and it failed.
+        // so bail out to avoid doing Alloc again.
+        if ((m_Size > 0) || !Initialize())
+        {
+            return nullptr;
+        }
+    }
+
+    _ASSERT(m_pStart != nullptr);
+    _ASSERT(m_SegmentHandle != nullptr);
+
+    _ASSERT(IS_ALIGNED(m_pCurrent, DATA_ALIGNMENT));
+    _ASSERT(IS_ALIGNED(objectSize, DATA_ALIGNMENT));
+
+    uint8_t* obj = m_pCurrent;
+    if ((size_t)(m_pStart + m_Size) < (size_t)(obj + objectSize))
+    {
+        // heap is full
+        return nullptr;
+    }
+
+    INDEBUG(m_ObjectsCount++);
+    m_pCurrent = obj + objectSize;
+
+    // Skip object header (NOTE: objectSize already includes it)
+    return reinterpret_cast<Object*>(obj + sizeof(ObjHeader));
+}
+
+bool FrozenObjectHeap::IsInHeap(Object* object)
+{
+    const auto ptr = reinterpret_cast<uint8_t*>(object);
+    if (ptr >= m_pStart && ptr < m_pCurrent)
+    {
+        _ASSERT(GCHeapUtilities::GetGCHeap()->IsInFrozenSegment(object));
+        return true;
+    }
+    return false;
+}