diff --git a/src/coreclr/gc/env/gctoeeinterface.standalone.inl b/src/coreclr/gc/env/gctoeeinterface.standalone.inl
index 45786b01d3e..e8dc20e2fd4 100644
--- a/src/coreclr/gc/env/gctoeeinterface.standalone.inl
+++ b/src/coreclr/gc/env/gctoeeinterface.standalone.inl
@@ -19,11 +19,21 @@ namespace standalone
             ::GCToEEInterface::RestartEE(bFinishedGC);
         }
 
+        void GcScanCurrentStackRoots(promote_func* fn, ScanContext* sc)
+        {
+            ::GCToEEInterface::GcScanCurrentStackRoots(fn, sc);
+        }
+
         void GcScanRoots(promote_func* fn, int condemned, int max_gen, ScanContext* sc)
         {
             ::GCToEEInterface::GcScanRoots(fn, condemned, max_gen, sc);
         }
 
+        void GcPoll()
+        {
+            ::GCToEEInterface::GcPoll();
+        }
+
         void GcStartWork(int condemned, int max_gen)
         {
             ::GCToEEInterface::GcStartWork(condemned, max_gen);
diff --git a/src/coreclr/gc/gc.h b/src/coreclr/gc/gc.h
index 4087d1fac6b..aa7004ab88e 100644
--- a/src/coreclr/gc/gc.h
+++ b/src/coreclr/gc/gc.h
@@ -338,7 +338,7 @@ inline bool IsServerHeap()
 {
 #ifdef FEATURE_SVR_GC
     assert(g_gc_heap_type != GC_HEAP_INVALID);
-    return g_gc_heap_type == GC_HEAP_SVR;
+    return g_gc_heap_type >= GC_HEAP_SVR;
 #else // FEATURE_SVR_GC
     return false;
 #endif // FEATURE_SVR_GC
diff --git a/src/coreclr/gc/gchandletable.cpp b/src/coreclr/gc/gchandletable.cpp
index ef0bbf8c93a..5a2bec144d1 100644
--- a/src/coreclr/gc/gchandletable.cpp
+++ b/src/coreclr/gc/gchandletable.cpp
@@ -73,7 +73,11 @@ HHANDLETABLE GCHandleStore::GetTable()
 
 OBJECTHANDLE GCHandleStore::CreateHandleOfType(Object* object, HandleType type)
 {
+#ifdef FEATURE_SATORI_GC
+    HHANDLETABLE handletable = _underlyingBucket.pTable[GetCurrentThreadHomeHeapNumber()];
+#else
     HHANDLETABLE handletable = GetTable();
+#endif
     return ::HndCreateHandle(handletable, type, ObjectToOBJECTREF(object));
 }
 
diff --git a/src/coreclr/gc/handletablescan.cpp b/src/coreclr/gc/handletablescan.cpp
index e5b27da8e62..34200e794db 100644
--- a/src/coreclr/gc/handletablescan.cpp
+++ b/src/coreclr/gc/handletablescan.cpp
@@ -787,6 +787,10 @@ void BlockResetAgeMapForBlocksWorker(uint32_t *pdwGen, uint32_t dwClumpMask, Sca
     STATIC_CONTRACT_GC_NOTRIGGER;
     STATIC_CONTRACT_MODE_COOPERATIVE;
 
+#if FEATURE_SATORI_GC
+    __UNREACHABLE();
+#endif
+
     // fetch the table segment we are working in
     TableSegment *pSegment = pInfo->pCurrentSegment;
 
diff --git a/src/coreclr/gc/objecthandle.cpp b/src/coreclr/gc/objecthandle.cpp
index 1b6df1b5f29..a8885b101b1 100644
--- a/src/coreclr/gc/objecthandle.cpp
+++ b/src/coreclr/gc/objecthandle.cpp
@@ -1326,11 +1326,13 @@ bool Ref_ScanDependentHandlesForPromotion(DhContext *pDhContext)
                 if (walk->pBuckets[i] != NULL)
                 {
                     int uCPUindex = getSlotNumber(pDhContext->m_pScanContext);
-                    // int uCPUlimit = getNumberOfSlots();
-                    // assert(uCPUlimit > 0);
-                    int uCPUstep = getThreadCount(pDhContext->m_pScanContext);
                     HHANDLETABLE* pTable = walk->pBuckets[i]->pTable;
-                    // for ( ; uCPUindex < uCPUlimit; uCPUindex += uCPUstep)
+#if !defined(FEATURE_SATORI_GC)
+                    int uCPUlimit = getNumberOfSlots();
+                    assert(uCPUlimit > 0);
+                    int uCPUstep = getThreadCount(pDhContext->m_pScanContext);
+                    for (; uCPUindex < uCPUlimit; uCPUindex += uCPUstep)
+#endif
                     {
                         HHANDLETABLE hTable = pTable[uCPUindex];
                         if (hTable)
@@ -1411,11 +1413,13 @@ void Ref_ScanWeakInteriorPointersForRelocation(uint32_t condemned, uint32_t maxg
             if (walk->pBuckets[i] != NULL)
             {
                 int uCPUindex = getSlotNumber(sc);
+                HHANDLETABLE* pTable = walk->pBuckets[i]->pTable;
+#if !defined(FEATURE_SATORI_GC)
                 int uCPUlimit = getNumberOfSlots();
                 assert(uCPUlimit > 0);
                 int uCPUstep = getThreadCount(sc);
-                HHANDLETABLE* pTable = walk->pBuckets[i]->pTable;
-                for ( ; uCPUindex < uCPUlimit; uCPUindex += uCPUstep)
+                for (; uCPUindex < uCPUlimit; uCPUindex += uCPUstep)
+#endif
                 {
                     HHANDLETABLE hTable = pTable[uCPUindex];
                     if (hTable)
diff --git a/src/coreclr/gc/satori/SatoriAllocator.h b/src/coreclr/gc/satori/SatoriAllocator.h
index f8ccb7a5363..24c1ef71161 100644
--- a/src/coreclr/gc/satori/SatoriAllocator.h
+++ b/src/coreclr/gc/satori/SatoriAllocator.h
@@ -125,7 +125,7 @@ private:
 #else
         BitScanReverse(&highestBit, value);
 #endif
-        return min(highestBit - Satori::REGION_BITS, Satori::ALLOCATOR_BUCKET_COUNT - 1);
+        return min((int)highestBit - Satori::REGION_BITS, Satori::ALLOCATOR_BUCKET_COUNT - 1);
     }
 };
 
diff --git a/src/coreclr/gc/satori/SatoriGC.cpp b/src/coreclr/gc/satori/SatoriGC.cpp
index e2e40de7241..2888fd82470 100644
--- a/src/coreclr/gc/satori/SatoriGC.cpp
+++ b/src/coreclr/gc/satori/SatoriGC.cpp
@@ -891,3 +891,12 @@ uint64_t SatoriGC::GetGenerationBudget(int generation)
     // avoid IDE0060: Remove unused parameter 'generation'
     return -1 + 0 * generation;
 }
+
+size_t SatoriGC::GetLOHThreshold()
+{
+    return Satori::LARGE_OBJECT_THRESHOLD;
+}
+
+void SatoriGC::DiagWalkHeapWithACHandling(walk_fn fn, void *context, int gen_number, bool walk_large_object_heap_p)
+{
+}
diff --git a/src/coreclr/gc/satori/SatoriGC.h b/src/coreclr/gc/satori/SatoriGC.h
index a6b23eb0668..b1813b25bf9 100644
--- a/src/coreclr/gc/satori/SatoriGC.h
+++ b/src/coreclr/gc/satori/SatoriGC.h
@@ -165,6 +165,10 @@ public:
 
     // Inherited via IGCHeapInternal
     uint64_t GetGenerationBudget(int generation) override;
+
+    // Inherited via IGCHeapInternal
+    size_t GetLOHThreshold() override;
+    void DiagWalkHeapWithACHandling(walk_fn fn, void *context, int gen_number, bool walk_large_object_heap_p) override;
 };
 
 #endif
diff --git a/src/coreclr/gc/satori/SatoriObject.cpp b/src/coreclr/gc/satori/SatoriObject.cpp
index 9905607961e..f0431b60415 100644
--- a/src/coreclr/gc/satori/SatoriObject.cpp
+++ b/src/coreclr/gc/satori/SatoriObject.cpp
@@ -91,7 +91,7 @@ void SatoriObject::DirtyCardsForContent()
 {
     _ASSERTE(IsMarked());
     MethodTable* mt = RawGetMethodTable();
-    if (mt->ContainsPointersOrCollectible())
+    if (mt->ContainsGCPointersOrCollectible())
     {
         SatoriPage* page = ContainingRegion()->m_containingPage;
         // if dealing with a collectible type, include MT in the dirty range
diff --git a/src/coreclr/gc/satori/SatoriObject.inl b/src/coreclr/gc/satori/SatoriObject.inl
index 49d9cc9be3e..35a6135f69d 100644
--- a/src/coreclr/gc/satori/SatoriObject.inl
+++ b/src/coreclr/gc/satori/SatoriObject.inl
@@ -282,7 +282,7 @@ inline void SatoriObject::ForEachObjectRef(F lambda, bool includeCollectibleAllo
         lambda((SatoriObject**)&loaderAllocator);
     }
 
-    if (!mt->ContainsPointers())
+    if (!mt->ContainsGCPointers())
     {
         return;
     }
@@ -354,7 +354,7 @@ inline void SatoriObject::ForEachObjectRef(F lambda, size_t size, bool includeCo
         lambda((SatoriObject**)&loaderAllocator);
     }
 
-    if (!mt->ContainsPointers())
+    if (!mt->ContainsGCPointers())
     {
         return;
     }
@@ -421,7 +421,7 @@ inline void SatoriObject::ForEachObjectRef(F lambda, size_t start, size_t end)
         lambda((SatoriObject**)&loaderAllocator);
     }
 
-    if (!mt->ContainsPointers())
+    if (!mt->ContainsGCPointers())
     {
         return;
     }
diff --git a/src/coreclr/gc/satori/SatoriRecycler.cpp b/src/coreclr/gc/satori/SatoriRecycler.cpp
index 57959b885b0..e71e2f2b48b 100644
--- a/src/coreclr/gc/satori/SatoriRecycler.cpp
+++ b/src/coreclr/gc/satori/SatoriRecycler.cpp
@@ -1073,10 +1073,10 @@ void SatoriRecycler::AdjustHeuristics()
 
     // we trigger GC when ephemeral size grows to SatoriUtil::Gen1Target(),
     // the budget is the diff to reach that
-    size_t newGen1Budget = max(MIN_GEN1_BUDGET, ephemeralOccupancy * (SatoriUtil::Gen1Target() - 100) / 100);
+    size_t newGen1Budget = max((size_t)MIN_GEN1_BUDGET, ephemeralOccupancy * (SatoriUtil::Gen1Target() - 100) / 100);
 
     // alternatively we allow gen1 allocs up to 1/8 of total limit.
-    size_t altNewGen1Budget = max(MIN_GEN1_BUDGET, m_totalLimit / 8);
+    size_t altNewGen1Budget = max((size_t)MIN_GEN1_BUDGET, m_totalLimit / 8);
 
     // take max of both budgets
     newGen1Budget = max(newGen1Budget, altNewGen1Budget);
@@ -2114,7 +2114,7 @@ bool SatoriRecycler::DrainMarkQueuesConcurrent(SatoriWorkChunk* srcChunk, int64_
 
 void SatoriRecycler::ScheduleMarkAsChildRanges(SatoriObject* o)
 {
-    if (o->RawGetMethodTable()->ContainsPointersOrCollectible())
+    if (o->RawGetMethodTable()->ContainsGCPointersOrCollectible())
     {
         size_t start = o->Start();
         size_t remains = o->Size();
@@ -2146,7 +2146,7 @@ void SatoriRecycler::ScheduleMarkAsChildRanges(SatoriObject* o)
 
 bool SatoriRecycler::ScheduleUpdateAsChildRanges(SatoriObject* o)
 {
-    if (o->RawGetMethodTable()->ContainsPointers())
+    if (o->RawGetMethodTable()->ContainsGCPointers())
     {
         size_t start = o->Start() + sizeof(size_t);
         size_t remains = o->Size() - sizeof(size_t);
diff --git a/src/coreclr/gc/satori/SatoriRegion.cpp b/src/coreclr/gc/satori/SatoriRegion.cpp
index 59b92b52197..38799d9e041 100644
--- a/src/coreclr/gc/satori/SatoriRegion.cpp
+++ b/src/coreclr/gc/satori/SatoriRegion.cpp
@@ -912,7 +912,7 @@ inline void SatoriRegion::PushToMarkStackIfHasPointers(SatoriObject* obj)
     _ASSERTE(obj->SameRegion(this));
     _ASSERTE(!obj->GetNextInLocalMarkStack());
 
-    if (obj->RawGetMethodTable()->ContainsPointersOrCollectible())
+    if (obj->RawGetMethodTable()->ContainsGCPointersOrCollectible())
     {
         obj->SetNextInLocalMarkStack(m_markStack);
         _ASSERTE(m_markStack == obj->GetNextInLocalMarkStack());
diff --git a/src/coreclr/gc/unix/events.cpp b/src/coreclr/gc/unix/events.cpp
index f384d15fbcd..3232bbbced5 100644
--- a/src/coreclr/gc/unix/events.cpp
+++ b/src/coreclr/gc/unix/events.cpp
@@ -308,7 +308,7 @@ bool GCEvent::CreateOSManualEventNoThrow(bool initialState)
 }
 
 #define _INC_PTHREADS
-#include "..\satori\SatoriGate.h"
+#include "../satori/SatoriGate.h"
 
 #if defined(TARGET_LINUX)
 
diff --git a/src/coreclr/jit/targetamd64.h b/src/coreclr/jit/targetamd64.h
index 7fc3cc544cb..7277d1af376 100644
--- a/src/coreclr/jit/targetamd64.h
+++ b/src/coreclr/jit/targetamd64.h
@@ -204,11 +204,12 @@
   // Registers no longer containing GC pointers after CORINFO_HELP_ASSIGN_REF and CORINFO_HELP_CHECKED_ASSIGN_REF.
   #define RBM_CALLEE_GCTRASH_WRITEBARRIER       RBM_CALLEE_TRASH_NOGC
 
-  // Registers no longer containing GC pointers after CORINFO_HELP_ASSIGN_BYREF.
-  #define RBM_CALLEE_GCTRASH_WRITEBARRIER_BYREF (RBM_RAX | RBM_RCX)
-
+  // TODO: Satori make more precise?
   // Registers killed by CORINFO_HELP_ASSIGN_BYREF.
-  #define RBM_CALLEE_TRASH_WRITEBARRIER_BYREF   (RBM_RSI | RBM_RDI | RBM_CALLEE_GCTRASH_WRITEBARRIER_BYREF)
+  #define RBM_CALLEE_TRASH_WRITEBARRIER_BYREF   (RBM_RSI | RBM_RDI | RBM_CALLEE_TRASH_NOGC)
+
+  // Registers no longer containing GC pointers after CORINFO_HELP_ASSIGN_BYREF.
+  #define RBM_CALLEE_GCTRASH_WRITEBARRIER_BYREF (RBM_CALLEE_TRASH_NOGC & ~(RBM_RDI | RBM_RSI))
 
   // We have two register classifications
   // * callee trash: aka     volatile or caller saved
diff --git a/src/coreclr/nativeaot/BuildIntegration/Microsoft.NETCore.Native.Unix.targets b/src/coreclr/nativeaot/BuildIntegration/Microsoft.NETCore.Native.Unix.targets
index 356c402446c..efd3cfddaf2 100644
--- a/src/coreclr/nativeaot/BuildIntegration/Microsoft.NETCore.Native.Unix.targets
+++ b/src/coreclr/nativeaot/BuildIntegration/Microsoft.NETCore.Native.Unix.targets
@@ -245,7 +245,6 @@ The .NET Foundation licenses this file to you under the MIT license.
       <LinkerArg Include="-L/usr/local/lib -linotify" Condition="'$(_targetOS)' == 'freebsd'" />
       <LinkerArg Include="@(ExtraLinkerArg->'-Wl,%(Identity)')" />
       <LinkerArg Include="@(NativeFramework->'-framework %(Identity)')" Condition="'$(_IsApplePlatform)' == 'true'" />
-      <LinkerArg Include="-ld_classic" Condition="'$(_IsApplePlatform)' == 'true'" />
       <LinkerArg Include="-Wl,--eh-frame-hdr" Condition="'$(_IsApplePlatform)' != 'true'" />
 
       <!-- Google requires all the native libraries to be aligned to 16 bytes (for 16k memory page size)
diff --git a/src/coreclr/nativeaot/Runtime.Base/src/System/Runtime/InternalCalls.cs b/src/coreclr/nativeaot/Runtime.Base/src/System/Runtime/InternalCalls.cs
index 36eeb78bc27..14971821198 100644
--- a/src/coreclr/nativeaot/Runtime.Base/src/System/Runtime/InternalCalls.cs
+++ b/src/coreclr/nativeaot/Runtime.Base/src/System/Runtime/InternalCalls.cs
@@ -270,7 +270,7 @@ namespace System.Runtime
         internal static extern void RhpSignalFinalizationComplete(uint fCount, int observedFullGcCount);
 
         [DllImport(Redhawk.BaseName)]
-        internal static extern object RhpGetNextFinalizableObject();
+        internal static extern unsafe void RhpGetNextFinalizableObject(void* pResult);
 
         [DllImport(Redhawk.BaseName)]
         internal static extern ulong RhpGetTickCount64();
diff --git a/src/coreclr/nativeaot/Runtime/EHHelpers.cpp b/src/coreclr/nativeaot/Runtime/EHHelpers.cpp
index 569cf36e84f..3bb8921c0da 100644
--- a/src/coreclr/nativeaot/Runtime/EHHelpers.cpp
+++ b/src/coreclr/nativeaot/Runtime/EHHelpers.cpp
@@ -276,6 +276,14 @@ EXTERN_C int32_t __stdcall RhpPInvokeExceptionGuard(PEXCEPTION_RECORD       pExc
 FCDECL2(void, RhpThrowHwEx, int exceptionCode, TADDR faultingIP);
 
 EXTERN_C CODE_LOCATION RhpAssignRefAVLocation;
+EXTERN_C CODE_LOCATION RhpAssignRefAVLocationNotHeap;
+EXTERN_C CODE_LOCATION RhpCheckedAssignRefAVLocation;
+EXTERN_C CODE_LOCATION RhpByRefAssignRefAVLocation1;
+
+#if !defined(HOST_ARM64)
+EXTERN_C CODE_LOCATION RhpByRefAssignRefAVLocation2;
+#endif
+
 #if defined(HOST_X86)
 EXTERN_C CODE_LOCATION RhpAssignRefEAXAVLocation;
 EXTERN_C CODE_LOCATION RhpAssignRefECXAVLocation;
@@ -299,17 +307,18 @@ EXTERN_C CODE_LOCATION RhpByRefAssignRefAVLocation1;
 EXTERN_C CODE_LOCATION RhpByRefAssignRefAVLocation2;
 #endif
 
-#if defined(HOST_ARM64) && !defined(LSE_INSTRUCTIONS_ENABLED_BY_DEFAULT)
-EXTERN_C CODE_LOCATION RhpCheckedLockCmpXchgAVLocation2;
-EXTERN_C CODE_LOCATION RhpCheckedXchgAVLocation2;
-#endif
-
 static bool InWriteBarrierHelper(uintptr_t faultingIP)
 {
 #ifndef USE_PORTABLE_HELPERS
     static uintptr_t writeBarrierAVLocations[] =
     {
         (uintptr_t)&RhpAssignRefAVLocation,
+        (uintptr_t)&RhpAssignRefAVLocationNotHeap,
+        (uintptr_t)&RhpCheckedAssignRefAVLocation,
+        (uintptr_t)&RhpByRefAssignRefAVLocation1,
+#if !defined(HOST_ARM64)
+        (uintptr_t)&RhpByRefAssignRefAVLocation2,
+#endif
 #if defined(HOST_X86)
         (uintptr_t)&RhpAssignRefEAXAVLocation,
         (uintptr_t)&RhpAssignRefECXAVLocation,
diff --git a/src/coreclr/nativeaot/Runtime/FinalizerHelpers.cpp b/src/coreclr/nativeaot/Runtime/FinalizerHelpers.cpp
index 5e1b0c9bcd3..1e493670583 100644
--- a/src/coreclr/nativeaot/Runtime/FinalizerHelpers.cpp
+++ b/src/coreclr/nativeaot/Runtime/FinalizerHelpers.cpp
@@ -217,17 +217,16 @@ EXTERN_C UInt32_BOOL QCALLTYPE RhpWaitForFinalizerRequest()
 //
 
 // Fetch next object which needs finalization or return null if we've reached the end of the list.
-FCIMPL0(OBJECTREF, RhpGetNextFinalizableObject)
+EXTERN_C void QCALLTYPE RhpGetNextFinalizableObject(Object** pResult)
 {
     Thread* pThread = ThreadStore::GetCurrentThread();
     pThread->DeferTransitionFrame();
     pThread->DisablePreemptiveMode();
 
-    OBJECTREF refNext = NULL;
     while (true)
     {
         // Get the next finalizable object. If we get back NULL we've reached the end of the list.
-        refNext = GCHeapUtilities::GetGCHeap()->GetNextFinalizable();
+        OBJECTREF refNext = GCHeapUtilities::GetGCHeap()->GetNextFinalizable();
         if (refNext != NULL)
         {
             // The queue may contain objects which have been marked as finalized already (via GC.SuppressFinalize()
@@ -240,10 +239,9 @@ FCIMPL0(OBJECTREF, RhpGetNextFinalizableObject)
             }
         }
 
+        *pResult = refNext;
         break;
     }
 
     pThread->EnablePreemptiveMode();
-    return refNext;
 }
-FCIMPLEND
diff --git a/src/coreclr/nativeaot/Runtime/GCHelpers.cpp b/src/coreclr/nativeaot/Runtime/GCHelpers.cpp
index 3bcd89f0e82..4eceb3607b7 100644
--- a/src/coreclr/nativeaot/Runtime/GCHelpers.cpp
+++ b/src/coreclr/nativeaot/Runtime/GCHelpers.cpp
@@ -52,6 +52,9 @@ bool InitializeGC()
     g_heap_type = GC_HEAP_WKS;
 #endif
 
+    //TODO: Satori
+    g_heap_type = GC_HEAP_SATORI;
+
     if (g_pRhConfig->GetgcConservative())
     {
         GetRuntimeInstance()->EnableConservativeStackReporting();
diff --git a/src/coreclr/nativeaot/Runtime/GCMemoryHelpers.cpp b/src/coreclr/nativeaot/Runtime/GCMemoryHelpers.cpp
index 43683bbece3..3cf96805293 100644
--- a/src/coreclr/nativeaot/Runtime/GCMemoryHelpers.cpp
+++ b/src/coreclr/nativeaot/Runtime/GCMemoryHelpers.cpp
@@ -73,3 +73,4 @@ FCIMPL3(void, RhBulkMoveWithWriteBarrier, uint8_t* pDest, uint8_t* pSrc, size_t
     }
 #endif //FEATURE_SATORI_GC
 }
+FCIMPLEND
diff --git a/src/coreclr/nativeaot/Runtime/ObjectLayout.h b/src/coreclr/nativeaot/Runtime/ObjectLayout.h
index 350390364fa..8a693cd2741 100644
--- a/src/coreclr/nativeaot/Runtime/ObjectLayout.h
+++ b/src/coreclr/nativeaot/Runtime/ObjectLayout.h
@@ -54,7 +54,7 @@ public:
 #endif
 #else
         // Satori does not mess up MT pointers.
-        { return get_EEType(); }
+        { return GetMethodTable(); }
 #endif
 
     ObjHeader * GetHeader() { return dac_cast<DPTR(ObjHeader)>(dac_cast<TADDR>(this) - SYNC_BLOCK_SKEW); }
diff --git a/src/coreclr/nativeaot/Runtime/amd64/WriteBarriers.S b/src/coreclr/nativeaot/Runtime/amd64/WriteBarriers.S
index 4d7c7ca1627..caa00127b7f 100644
--- a/src/coreclr/nativeaot/Runtime/amd64/WriteBarriers.S
+++ b/src/coreclr/nativeaot/Runtime/amd64/WriteBarriers.S
@@ -607,12 +607,10 @@ LEAF_ENTRY RhpCheckedLockCmpXchg, _TEXT
         jb      RecordEscape_CmpXchg            // target is exposed. record an escape.
 
     JustAssign_CmpXchg:
-ALTERNATE_ENTRY RhpCheckedLockCmpXchgAVLocationNotHeap
         lock cmpxchg    [rdi], rsi     // no card marking, src is not a heap object
         ret
 
     AssignAndMarkCards_CmpXchg:
-ALTERNATE_ENTRY RhpCheckedLockCmpXchgAVLocation
         lock cmpxchg    [rdi], rsi
         jne             Exit_CmpXchg
 
@@ -777,12 +775,10 @@ LEAF_ENTRY RhpCheckedXchg, _TEXT
         jb      RecordEscape_Xchg            // target is exposed. record an escape.
 
     JustAssign_Xchg:
-ALTERNATE_ENTRY RhpCheckedXchgAVLocationNotHeap
         xchg    [rdi], rax              // no card marking, src is not a heap object
         ret
 
     AssignAndMarkCards_Xchg:
-ALTERNATE_ENTRY RhpCheckedXchgAVLocation
         xchg    [rdi], rax
 
         // TUNING: barriers in different modes could be separate pieces of code, but barrier switch 
diff --git a/src/coreclr/nativeaot/Runtime/amd64/WriteBarriers.asm b/src/coreclr/nativeaot/Runtime/amd64/WriteBarriers.asm
index f90a618dee9..fe4bee34dfe 100644
--- a/src/coreclr/nativeaot/Runtime/amd64/WriteBarriers.asm
+++ b/src/coreclr/nativeaot/Runtime/amd64/WriteBarriers.asm
@@ -603,12 +603,10 @@ endif
         jb      RecordEscape            ; target is exposed. record an escape.
 
     JustAssign:
-ALTERNATE_ENTRY RhpCheckedLockCmpXchgAVLocationNotHeap
         lock cmpxchg    [rcx], rdx      ; no card marking, src is not a heap object
         ret
 
     AssignAndMarkCards:
-ALTERNATE_ENTRY RhpCheckedLockCmpXchgAVLocation
         lock cmpxchg    [rcx], rdx
         jne             Exit
 
@@ -766,12 +764,10 @@ endif
         jb      RecordEscape            ; target is exposed. record an escape.
 
     JustAssign:
-ALTERNATE_ENTRY RhpCheckedXchgAVLocationNotHeap
         xchg    [rcx], rax              ; no card marking, src is not a heap object
         ret
 
     AssignAndMarkCards:
-ALTERNATE_ENTRY RhpCheckedXchgAVLocation
         xchg    [rcx], rax
 
     ; TUNING: barriers in different modes could be separate pieces of code, but barrier switch 
diff --git a/src/coreclr/nativeaot/Runtime/arm64/WriteBarriers.S b/src/coreclr/nativeaot/Runtime/arm64/WriteBarriers.S
index 9d2328c3bf5..33fea62750a 100644
--- a/src/coreclr/nativeaot/Runtime/arm64/WriteBarriers.S
+++ b/src/coreclr/nativeaot/Runtime/arm64/WriteBarriers.S
@@ -710,7 +710,6 @@ LEAF_ENTRY RhpCheckedLockCmpXchg
 
     LOCAL_LABEL(JustAssign_Cmp_Xchg):
         // skip setting cards
-ALTERNATE_ENTRY RhpCheckedLockCmpXchgAVLocationNotHeap
         mov      x10, #0
 
     LOCAL_LABEL(AssignAndMarkCards_Cmp_Xchg):
@@ -723,7 +722,6 @@ ALTERNATE_ENTRY RhpCheckedLockCmpXchgAVLocationNotHeap
 #endif
 
         mov    x17, x2
-ALTERNATE_ENTRY RhpCheckedLockCmpXchgAVLocation
         casal  x2, x1, [x0]                  // exchange
         mov    x0, x2                        // x0 = result
         cmp    x2, x17
@@ -736,7 +734,6 @@ LOCAL_LABEL(NoUpdate_Cmp_Xchg):
         ret     lr
 
     LOCAL_LABEL(TryAgain1_Cmp_Xchg):
-ALTERNATE_ENTRY RhpCheckedLockCmpXchgAVLocation2
         ldaxr   x0, [x14]
         cmp     x0, x2
         bne     LOCAL_LABEL(NoUpdate_Cmp_Xchg)
@@ -927,11 +924,9 @@ LEAF_ENTRY RhpCheckedXchg, _TEXT
     LOCAL_LABEL(JustAssign_Xchg):
 // TODO: VS use LSE_INSTRUCTIONS_ENABLED_BY_DEFAULT instead
 #ifdef TARGET_OSX
-ALTERNATE_ENTRY RhpCheckedXchgAVLocationNotHeap
         swpal  x1, x0, [x0]                   // exchange
 #else
     LOCAL_LABEL(TryAgain_Xchg):
-ALTERNATE_ENTRY RhpCheckedXchgAVLocationNotHeap
         ldaxr   x17, [x0]
         stlxr   w12, x1, [x0]
         cbnz    w12, LOCAL_LABEL(TryAgain_Xchg)
@@ -943,12 +938,9 @@ ALTERNATE_ENTRY RhpCheckedXchgAVLocationNotHeap
     LOCAL_LABEL(AssignAndMarkCards_Xchg):
         mov    x14, x0                        // x14 = dst
 #ifdef TARGET_OSX
-ALTERNATE_ENTRY RhpCheckedXchgAVLocation
         swpal  x1, x0, [x0]                   // exchange
 #else
     LOCAL_LABEL(TryAgain1_Xchg):
-ALTERNATE_ENTRY RhpCheckedXchgAVLocation
-ALTERNATE_ENTRY RhpCheckedXchgAVLocation2
         ldaxr   x17, [x0]
         stlxr   w12, x1, [x0]
         cbnz    w12, LOCAL_LABEL(TryAgain1_Xchg)
diff --git a/src/coreclr/nativeaot/Runtime/arm64/WriteBarriers.asm b/src/coreclr/nativeaot/Runtime/arm64/WriteBarriers.asm
index 9a3c008ad8e..6a5be683d9b 100644
--- a/src/coreclr/nativeaot/Runtime/arm64/WriteBarriers.asm
+++ b/src/coreclr/nativeaot/Runtime/arm64/WriteBarriers.asm
@@ -691,7 +691,6 @@ RecordEscape
 
 JustAssign_Cmp_Xchg
         ;; skip setting cards
-    ALTERNATE_ENTRY RhpCheckedLockCmpXchgAVLocationNotHeap
         mov     x10, #0
 
 AssignAndMarkCards_Cmp_Xchg
@@ -704,7 +703,6 @@ AssignAndMarkCards_Cmp_Xchg
 #endif
 
         mov    x17, x2
-    ALTERNATE_ENTRY RhpCheckedLockCmpXchgAVLocation
         casal  x2, x1, [x0]                  ;; exchange
         mov    x0, x2                        ;; x0 = result
         cmp    x2, x17
@@ -717,7 +715,6 @@ NoUpdate_Cmp_Xchg
         ret     lr
 
 TryAgain1_Cmp_Xchg
-    ALTERNATE_ENTRY RhpCheckedLockCmpXchgAVLocation2
         ldaxr   x0, [x14]
         cmp     x0, x2
         bne     NoUpdate_Cmp_Xchg
@@ -901,7 +898,6 @@ RecordEscape_Cmp_Xchg
 
 JustAssign_Xchg
 TryAgain_Xchg
-    ALTERNATE_ENTRY RhpCheckedXchgAVLocationNotHeap
    ;; TODO: VS use LSE_INSTRUCTIONS_ENABLED_BY_DEFAULT instead
         ldaxr   x17, [x0]
         stlxr   w12, x1, [x0]
@@ -913,8 +909,6 @@ TryAgain_Xchg
 AssignAndMarkCards_Xchg
         mov    x14, x0                        ;; x14 = dst
 TryAgain1_Xchg
-    ALTERNATE_ENTRY RhpCheckedXchgAVLocation
-    ALTERNATE_ENTRY RhpCheckedXchgAVLocation2
         ldaxr   x17, [x0]
         stlxr   w12, x1, [x0]
         cbnz    w12, TryAgain1_Xchg
diff --git a/src/coreclr/nativeaot/Runtime/gcenv.ee.cpp b/src/coreclr/nativeaot/Runtime/gcenv.ee.cpp
index 196fce7d750..d53f7859b00 100644
--- a/src/coreclr/nativeaot/Runtime/gcenv.ee.cpp
+++ b/src/coreclr/nativeaot/Runtime/gcenv.ee.cpp
@@ -91,6 +91,47 @@ void GCToEEInterface::BeforeGcScanRoots(int condemned, bool is_bgc, bool is_conc
 #endif
 }
 
+/*
+ * Scan current stack
+ */
+
+void GCToEEInterface::GcScanCurrentStackRoots(ScanFunc* fn, ScanContext* sc)
+{
+    Thread* pThread = ThreadStore::GetCurrentThread();
+    if (pThread->IsGCSpecial())
+        return;
+
+    InlinedThreadStaticRoot* pRoot = pThread->GetInlinedThreadStaticList();
+    while (pRoot != NULL)
+    {
+        STRESS_LOG2(LF_GC | LF_GCROOTS, LL_INFO100, "{ Scanning Thread's %p inline thread statics root %p. \n", pThread, pRoot);
+        EnumGcRef(&pRoot->m_threadStaticsBase, GCRK_Object, fn, sc);
+        pRoot = pRoot->m_next;
+    }
+
+    STRESS_LOG1(LF_GC | LF_GCROOTS, LL_INFO100, "{ Scanning Thread's %p thread statics root. \n", pThread);
+    EnumGcRef(pThread->GetThreadStaticStorage(), GCRK_Object, fn, sc);
+
+    STRESS_LOG1(LF_GC | LF_GCROOTS, LL_INFO100, "{ Starting scan of Thread %p\n", pThread);
+    sc->thread_under_crawl = pThread;
+#if defined(FEATURE_EVENT_TRACE) && !defined(DACCESS_COMPILE)
+    sc->dwEtwRootKind = kEtwGCRootKindStack;
+#endif
+
+    pThread->GcScanRoots(fn, sc);
+
+#if defined(FEATURE_EVENT_TRACE) && !defined(DACCESS_COMPILE)
+    sc->dwEtwRootKind = kEtwGCRootKindOther;
+#endif
+    STRESS_LOG1(LF_GC | LF_GCROOTS, LL_INFO100, "Ending scan of Thread %p }\n", pThread);
+
+    sc->thread_under_crawl = NULL;
+}
+
+/*
+ * Scan all stack roots
+ */
+
 void GCToEEInterface::GcScanRoots(ScanFunc* fn, int condemned, int max_gen, ScanContext* sc)
 {
     // STRESS_LOG1(LF_GCROOTS, LL_INFO10, "GCScan: Phase = %s\n", sc->promotion ? "promote" : "relocate");
@@ -154,6 +195,20 @@ void GCToEEInterface::AfterGcScanRoots(int condemned, int /*max_gen*/, ScanConte
 #endif
 }
 
+void GCToEEInterface::GcPoll()
+{
+    if (ThreadStore::IsTrapThreadsRequested())
+    {
+        Thread* pThread = ThreadStore::GetCurrentThread();
+        assert(!pThread->IsGCSpecial());
+        assert(pThread->IsCurrentThreadInCooperativeMode());
+        assert(pThread != ThreadStore::GetSuspendingThread());
+
+        pThread->EnablePreemptiveMode();
+        pThread->DisablePreemptiveMode();
+    }
+}
+
 void GCToEEInterface::GcDone(int condemned)
 {
     // Invoke any registered callouts for the end of the collection.
@@ -559,35 +614,6 @@ struct ThreadStubArguments
     CLREventStatic m_ThreadStartedEvent;
 };
 
-static bool CreateUnsuspendableThread(void (*threadStart)(void*), void* arg, const char* name)
-{
-    UNREFERENCED_PARAMETER(name);
-
-    ThreadStubArguments* threadStubArgs = new (nothrow) ThreadStubArguments();
-    if (!threadStubArgs)
-        return false;
-
-    threadStubArgs->m_pRealStartRoutine = threadStart;
-    threadStubArgs->m_pRealContext = arg;
-
-    // Helper used to wrap the start routine of background GC threads so we can do things like initialize the
-    // Redhawk thread state which requires running in the new thread's context.
-    auto threadStub = [](void* argument) -> DWORD
-    {
-        ThreadStore::RawGetCurrentThread()->SetGCSpecial();
-
-        ThreadStubArguments* pStartContext = (ThreadStubArguments*)argument;
-        auto realStartRoutine = pStartContext->m_pRealStartRoutine;
-        void* realContext = pStartContext->m_pRealContext;
-        delete pStartContext;
-
-        STRESS_LOG_RESERVE_MEM(GC_STRESSLOG_MULTIPLY);
-
-        realStartRoutine(realContext);
-
-        return 0;
-    };
-
 static bool CreateNonSuspendableThread(void (*threadStart)(void*), void* arg, const char* name)
 {
     UNREFERENCED_PARAMETER(name);
diff --git a/src/coreclr/nativeaot/System.Private.CoreLib/src/Internal/Runtime/FrozenObjectHeapManager.cs b/src/coreclr/nativeaot/System.Private.CoreLib/src/Internal/Runtime/FrozenObjectHeapManager.cs
index 81f1eec9cfd..6029e01e519 100644
--- a/src/coreclr/nativeaot/System.Private.CoreLib/src/Internal/Runtime/FrozenObjectHeapManager.cs
+++ b/src/coreclr/nativeaot/System.Private.CoreLib/src/Internal/Runtime/FrozenObjectHeapManager.cs
@@ -32,6 +32,8 @@ namespace Internal.Runtime
 
         private object? TryAllocateObject(MethodTable* type, nuint objectSize)
         {
+            // TODO: Satori can allocate immortal objects naturally. Use that instead. (see: AllocateImmortalObject)
+
             HalfBakedObject* obj = null;
 
             using (m_Crst.EnterScope())
diff --git a/src/coreclr/vm/amd64/JitHelpers_Fast.asm b/src/coreclr/vm/amd64/JitHelpers_Fast.asm
index 38bfcfc642a..0b3fd45a9da 100644
--- a/src/coreclr/vm/amd64/JitHelpers_Fast.asm
+++ b/src/coreclr/vm/amd64/JitHelpers_Fast.asm
@@ -57,14 +57,9 @@ ifndef FEATURE_SATORI_GC
 ;   RDI - address of ref-field (assigned to)
 ;   RSI - address of the data  (source)
 ;   RCX is trashed
-;   RAX is trashed
-;
-;   NOTE: Keep in sync with RBM_CALLEE_TRASH_WRITEBARRIER_BYREF and RBM_CALLEE_GCTRASH_WRITEBARRIER_BYREF
-;         if you add more trashed registers.
-;
+;   RAX is trashed when FEATURE_USE_SOFTWARE_WRITE_WATCH_FOR_GC_HEAP is defined
 ; Exit:
 ;   RDI, RSI are incremented by SIZEOF(LPVOID)
-;
 LEAF_ENTRY JIT_ByRefWriteBarrier, _TEXT
         mov     rcx, [rsi]
 
@@ -157,6 +152,8 @@ endif
         cmp     rcx, [g_ephemeral_high]
         jnb     Exit
 
+        ; do the following checks only if we are allowed to trash rax
+        ; otherwise we don't have enough registers
 ifdef FEATURE_USE_SOFTWARE_WRITE_WATCH_FOR_GC_HEAP
         mov     rax, rcx
 
@@ -317,6 +314,8 @@ Section segment para 'DATA'
 JIT_WriteBarrier_Loc:
         dq 0
 
+extern JIT_WriteBarrier:proc
+
 LEAF_ENTRY  JIT_WriteBarrier_Callable, _TEXT
         ; JIT_WriteBarrier(Object** dst, Object* src)
 
@@ -327,224 +326,6 @@ LEAF_ENTRY  JIT_WriteBarrier_Callable, _TEXT
         jmp     JIT_WriteBarrier
 LEAF_END JIT_WriteBarrier_Callable, _TEXT
 
-; Mark start of the code region that we patch at runtime
-LEAF_ENTRY JIT_PatchedCodeStart, _TEXT
-        ret
-LEAF_END JIT_PatchedCodeStart, _TEXT
-
-; void JIT_CheckedWriteBarrier(Object** dst, Object* src)
-LEAF_ENTRY JIT_CheckedWriteBarrier, _TEXT
-    ; See if dst is in GCHeap
-        mov     rax, [g_card_bundle_table] ; fetch the page byte map
-        mov     r8,  rcx
-        shr     r8,  30                    ; dst page index
-        cmp     byte ptr [rax + r8], 0
-        jne     CheckedEntry
-
-    NotInHeap:
-        ; See comment above about possible AV
-        mov     [rcx], rdx
-        ret
-LEAF_END_MARKED JIT_CheckedWriteBarrier, _TEXT
-
-ALTERNATE_ENTRY macro Name
-
-Name label proc
-PUBLIC Name
-        endm
-
-;
-;   rcx - dest address 
-;   rdx - object
-;
-LEAF_ENTRY JIT_WriteBarrier, _TEXT
-
-ifdef FEATURE_SATORI_EXTERNAL_OBJECTS
-    ; check if src is in heap
-        mov     rax, [g_card_bundle_table] ; fetch the page byte map
-    ALTERNATE_ENTRY CheckedEntry
-        mov     r8,  rdx
-        shr     r8,  30                    ; src page index
-        cmp     byte ptr [rax + r8], 0
-        je      JustAssign                 ; src not in heap
-else
-    ALTERNATE_ENTRY CheckedEntry
-endif
-
-    ; check for escaping assignment
-    ; 1) check if we own the source region
-        mov     r8, rdx
-        and     r8, 0FFFFFFFFFFE00000h  ; source region
-
-ifndef FEATURE_SATORI_EXTERNAL_OBJECTS
-        jz      JustAssign              ; assigning null
-endif
-
-        mov     rax,  gs:[30h]          ; thread tag, TEB on NT
-        cmp     qword ptr [r8], rax     
-        jne     AssignAndMarkCards      ; not local to this thread
-
-    ; 2) check if the src and dst are from the same region
-        mov     rax, rcx
-        and     rax, 0FFFFFFFFFFE00000h ; target aligned to region
-        cmp     rax, r8
-        jne     RecordEscape            ; cross region assignment. definitely escaping
-
-    ; 3) check if the target is exposed
-        mov     rax, rcx
-        and     rax, 01FFFFFh
-        shr     rax, 3
-        bt      qword ptr [r8], rax
-        jb      RecordEscape            ; target is exposed. record an escape.
-
-    JustAssign:
-        mov     [rcx], rdx              ; no card marking, src is not a heap object
-        ret
-
-    AssignAndMarkCards:
-        mov     [rcx], rdx
-
-    ; TUNING: barriers in different modes could be separate pieces of code, but barrier switch 
-    ;         needs to suspend EE, not sure if skipping mode check would worth that much.
-        mov     r11, qword ptr [g_sw_ww_table]
-
-    ; check the barrier state. this must be done after the assignment (in program order)
-    ; if state == 2 we do not set or dirty cards.
-        cmp     r11, 2h
-        jne     DoCards
-    Exit:
-        ret
-
-    DoCards:
-    ; if same region, just check if barrier is not concurrent
-        xor     rdx, rcx
-        shr     rdx, 21
-        jz      CheckConcurrent
-
-    ; if src is in gen2/3 and the barrier is not concurrent we do not need to mark cards
-        cmp     dword ptr [r8 + 16], 2
-        jl      MarkCards
-
-    CheckConcurrent:
-        cmp     r11, 0h
-        je      Exit
-
-    MarkCards:
-    ; fetch card location for rcx
-        mov     r9 , [g_card_table]     ; fetch the page map
-        mov     r8,  rcx
-        shr     rcx, 30
-        mov     rax, qword ptr [r9 + rcx * 8] ; page
-        sub     r8, rax   ; offset in page
-        mov     rdx,r8
-        shr     r8, 9     ; card offset
-        shr     rdx, 20   ; group index
-        lea     rdx, [rax + rdx * 2 + 80h] ; group offset
-
-    ; check if concurrent marking is in progress
-        cmp     r11, 0h
-        jne     DirtyCard
-
-    ; SETTING CARD FOR RCX
-     SetCard:
-        cmp     byte ptr [rax + r8], 0
-        jne     Exit
-        mov     byte ptr [rax + r8], 1
-     SetGroup:
-        cmp     byte ptr [rdx], 0
-        jne     CardSet
-        mov     byte ptr [rdx], 1
-     SetPage:
-        cmp     byte ptr [rax], 0
-        jne     CardSet
-        mov     byte ptr [rax], 1
-
-     CardSet:
-    ; check if concurrent marking is still not in progress
-        cmp     qword ptr [g_sw_ww_table], 0h
-        jne     DirtyCard
-        ret
-
-    ; DIRTYING CARD FOR RCX
-     DirtyCard:
-        mov     byte ptr [rax + r8], 4
-     DirtyGroup:
-        cmp     byte ptr [rdx], 4
-        je      Exit
-        mov     byte ptr [rdx], 4
-     DirtyPage:
-        cmp     byte ptr [rax], 4
-        je      Exit
-        mov     byte ptr [rax], 4
-        ret
-
-    ; this is expected to be rare.
-    RecordEscape:
-
-        ; 4) check if the source is escaped
-        mov     rax, rdx
-        add     rax, 8                        ; escape bit is MT + 1
-        and     rax, 01FFFFFh
-        shr     rax, 3
-        bt      qword ptr [r8], rax
-        jb      AssignAndMarkCards            ; source is already escaped.
-
-        ; Align rsp
-        mov  r9, rsp
-        and  rsp, -16
-
-        ; save rsp, rcx, rdx, r8 and have enough stack for the callee
-        push r9
-        push rcx
-        push rdx
-        push r8
-        sub  rsp, 20h
-
-        ; void SatoriRegion::EscapeFn(SatoriObject** dst, SatoriObject* src, SatoriRegion* region)
-        call    qword ptr [r8 + 8]
-
-        add     rsp, 20h
-        pop     r8
-        pop     rdx
-        pop     rcx
-        pop     rsp
-        jmp     AssignAndMarkCards
-LEAF_END_MARKED JIT_WriteBarrier, _TEXT
-
-; JIT_ByRefWriteBarrier has weird symantics, see usage in StubLinkerX86.cpp
-;
-; Entry:
-;   RDI - address of ref-field (assigned to)
-;   RSI - address of the data  (source)
-;   Note: RyuJIT assumes that all volatile registers can be trashed by 
-;   the CORINFO_HELP_ASSIGN_BYREF helper (i.e. JIT_ByRefWriteBarrier)
-;   except RDI and RSI. This helper uses and defines RDI and RSI, so
-;   they remain as live GC refs or byrefs, and are not killed.
-; Exit:
-;   RDI, RSI are incremented by SIZEOF(LPVOID)
-LEAF_ENTRY JIT_ByRefWriteBarrier, _TEXT
-        mov     rcx, rdi
-        mov     rdx, [rsi]
-        add     rdi, 8h
-        add     rsi, 8h
-
-    ; See if dst is in GCHeap
-        mov     rax, [g_card_bundle_table] ; fetch the page byte map
-        mov     r8,  rcx
-        shr     r8,  30                    ; dst page index
-        cmp     byte ptr [rax + r8], 0
-        jne     CheckedEntry
-
-    NotInHeap:
-        mov     [rcx], rdx
-        ret
-LEAF_END_MARKED JIT_ByRefWriteBarrier, _TEXT
-
-; Mark start of the code region that we patch at runtime
-LEAF_ENTRY JIT_PatchedCodeLast, _TEXT
-        ret
-LEAF_END JIT_PatchedCodeLast, _TEXT
-
 endif  ; FEATURE_SATORI_GC
 
 ; The following helper will access ("probe") a word on each page of the stack
diff --git a/src/coreclr/vm/amd64/jithelpers_fast.S b/src/coreclr/vm/amd64/jithelpers_fast.S
index 4cbd23c84d2..fe59571018e 100644
--- a/src/coreclr/vm/amd64/jithelpers_fast.S
+++ b/src/coreclr/vm/amd64/jithelpers_fast.S
@@ -5,6 +5,8 @@
 #include "unixasmmacros.inc"
 #include "asmconstants.h"
 
+#ifndef FEATURE_SATORI_GC
+
 // JIT_ByRefWriteBarrier has weird semantics, see usage in StubLinkerX86.cpp
 //
 // Entry:
@@ -215,248 +217,7 @@ LEAF_END_MARKED JIT_ByRefWriteBarrier, _TEXT
 
 #else  //FEATURE_SATORI_GC      ##############################################################################
 
-.macro ALTERNATE_ENTRY Name
-        .global C_FUNC(\Name)
-C_FUNC(\Name):
-.endm
-
-// Mark start of the code region that we patch at runtime
-LEAF_ENTRY JIT_PatchedCodeStart, _TEXT
-        ret
-LEAF_END JIT_PatchedCodeStart, _TEXT
-
-
-// void JIT_CheckedWriteBarrier(Object** dst, Object* src)
-LEAF_ENTRY JIT_CheckedWriteBarrier, _TEXT
-
-     // See if dst is in GCHeap
-        PREPARE_EXTERNAL_VAR g_card_bundle_table, rax   // fetch the page byte map
-        mov     rax, [rax]
-        mov     r8, rdi
-        shr     r8, 30                                  // dst page index
-        cmp     byte ptr [rax + r8], 0
-        jne     C_FUNC(CheckedEntry)
-
-    NotInHeap:
-        // See comment above about possible AV
-        mov     [rdi], rsi
-        ret
-LEAF_END_MARKED JIT_CheckedWriteBarrier, _TEXT
-
-
-//
-//   rdi - dest address
-//   rsi - object
-//
-.balign 16
-LEAF_ENTRY JIT_WriteBarrier, _TEXT
-#ifdef FEATURE_SATORI_EXTERNAL_OBJECTS
-    // check if src is in heap
-        PREPARE_EXTERNAL_VAR g_card_bundle_table, rax   // fetch the page byte map
-        mov     rax, [rax]
-    ALTERNATE_ENTRY CheckedEntry
-        mov     r8, rsi
-        shr     r8, 30                                  //  src page index
-        cmp     byte ptr [rax + r8], 0
-        je      JustAssign                              // src not in heap
-#else
-    ALTERNATE_ENTRY CheckedEntry
-#endif
-
-    // check for escaping assignment
-    // 1) check if we own the source region
-        mov     rdx, rsi
-        and     rdx, 0xFFFFFFFFFFE00000  // source region
-#ifndef FEATURE_SATORI_EXTERNAL_OBJECTS
-        jz      JustAssign              // assigning null
-#endif
-#ifdef TARGET_OSX
-        mov     rax,  gs:[0]            // thread tag
-#else
-        mov     rax,  fs:[0]            // thread tag
-#endif
-        cmp     qword ptr [rdx], rax     
-        jne     AssignAndMarkCards      // not local to this thread
-
-    // 2) check if the src and dst are from the same region
-        mov     rax, rdi
-        and     rax, 0xFFFFFFFFFFE00000 // target aligned to region
-        cmp     rax, rdx
-        jnz     RecordEscape            // cross region assignment. definitely escaping
-
-    // 3) check if the target is exposed
-        mov     rax, rdi
-        and     rax, 0x1FFFFF
-        shr     rax, 3
-        bt      qword ptr [rdx], rax
-        jb      RecordEscape            // target is exposed. record an escape.
-
-    JustAssign:
-        mov     [rdi], rsi              // no card marking, src is not a heap object
-
-        // set rdi, rsi per contract with JIT_ByRefWriteBarrier
-        add     rdi, 8
-        mov     rsi, r10
-        ret
-
-    AssignAndMarkCards:
-        mov     [rdi], rsi
-
-        // TUNING: barriers in different modes could be separate pieces of code, but barrier switch 
-        //         needs to suspend EE, not sure if skipping mode check would worth that much.
-        PREPARE_EXTERNAL_VAR g_sw_ww_table, rcx
-        mov     r11, [rcx]
-
-        // set rdi per contract with JIT_ByRefWriteBarrier
-        mov     rax, rdi
-        add     rdi, 8
-
-        // check the barrier state. this must be done after the assignment (in program order)
-        // if state == 2 we do not set or dirty cards.
-        cmp     r11, 2
-        jne     DoCards
-        // set rsi per contract with JIT_ByRefWriteBarrier
-        mov     rsi, r10
-    Exit:
-        ret
-
-    DoCards:
-    // if same region, just check if barrier is not concurrent
-        xor     rsi, rax
-        shr     rsi, 21
-        // set rsi per contract with JIT_ByRefWriteBarrier
-        mov     rsi, r10
-        jz      CheckConcurrent         // same region, just check if barrier is not concurrent
-
-    // if src is in gen2/3 and the barrier is not concurrent we do not need to mark cards
-        cmp     dword ptr [rdx + 16], 2
-        jl     MarkCards
-
-    CheckConcurrent:
-    // if concurrent, load card location
-        cmp     r11, 0
-        je      Exit
-
-    MarkCards:
-    // fetch card location for rax  (saved rdi)
-        PREPARE_EXTERNAL_VAR g_card_table, r9 
-        mov     r9,  [r9]  // fetch the page map
-        mov     rdx, rax
-        shr     rax, 30
-        mov     rax, qword ptr [r9 + rax * 8] // page
-        sub     rdx, rax   // offset in page
-        mov     r8,  rdx
-        shr     rdx, 9     // card offset
-        shr     r8,  20    // group index
-        lea     r8,  [rax + r8 * 2 + 0x80] // group offset
-
-     // check if concurrent marking is in progress
-        cmp     r11, 0
-        jne     DirtyCard
-
-     // SETTING CARD
-     SetCard:
-        cmp     byte ptr [rax + rdx], 0
-        jne     Exit
-        mov     byte ptr [rax + rdx], 1
-     SetGroup:
-        cmp     byte ptr [r8], 0
-        jne     CardSet
-        mov     byte ptr [r8], 1
-     SetPage:
-        cmp     byte ptr [rax], 0
-        jne     CardSet
-        mov     byte ptr [rax], 1
-
-     CardSet:
-     // check if concurrent marking is still not in progress
-        cmp     qword ptr [rcx], 0
-        jne     DirtyCard
-        ret
-
-     // DIRTYING CARD
-     DirtyCard:
-        mov     byte ptr [rax + rdx], 4
-     DirtyGroup:
-        cmp     byte ptr [r8], 4
-        je      Exit
-        mov     byte ptr [r8], 4
-     DirtyPage:
-        cmp     byte ptr [rax], 4
-        je      Exit
-        mov     byte ptr [rax], 4
-        ret
-
-    // this is expected to be rare.
-    RecordEscape:
-
-    // 4) check if the source is escaped
-        mov     rax, rsi
-        add     rax, 8                        // escape bit is MT + 1
-        and     rax, 0x1FFFFF
-        shr     rax, 3
-        bt      qword ptr [rdx], rax
-        jb      AssignAndMarkCards            // source is already escaped.
-
-        // Align rsp
-        mov  r9, rsp
-        and  rsp, -16
-        sub  rsp, 8
-
-        // save rsp, rdi, rsi, rdx and r10 (possibly preadjusted rsi)
-        push r9
-        push rdi
-        push rsi
-        push rdx
-        push r10
-
-        // void SatoriRegion::EscapeFn(SatoriObject** dst, SatoriObject* src, SatoriRegion* region)
-        call    qword ptr [rdx + 8]
-
-        pop     r10
-        pop     rdx
-        pop     rsi
-        pop     rdi
-        pop     rsp
-        jmp     AssignAndMarkCards
-LEAF_END_MARKED JIT_WriteBarrier, _TEXT
-
-
-// JIT_ByRefWriteBarrier has weird symantics, see usage in StubLinkerX86.cpp
-//
-// Entry:
-//   RDI - address of ref-field (assigned to)
-//   RSI - address of the data  (source)
-//   Note: RyuJIT assumes that all volatile registers can be trashed by 
-//   the CORINFO_HELP_ASSIGN_BYREF helper (i.e. JIT_ByRefWriteBarrier)
-//   except RDI and RSI. This helper uses and defines RDI and RSI, so
-//   they remain as live GC refs or byrefs, and are not killed.
-// Exit:
-//   RDI, RSI are incremented by SIZEOF(LPVOID)
-LEAF_ENTRY JIT_ByRefWriteBarrier, _TEXT
-        lea     r10, [rsi + 8]
-        mov     rsi, [rsi]
-
-     // See if dst is in GCHeap
-        PREPARE_EXTERNAL_VAR g_card_bundle_table, rax   // fetch the page byte map
-        mov     rax, [rax]
-
-        mov     r8, rdi
-        shr     r8, 30                                  // dst page index
-        cmp     byte ptr [rax + r8], 0
-        jne     C_FUNC(CheckedEntry)
-
-    NotInHeap_ByRefWriteBarrier:
-        mov     [rdi], rsi
-        add     rdi, 8
-        mov     rsi, r10
-        ret
-LEAF_END_MARKED JIT_ByRefWriteBarrier, _TEXT
-
-// Mark start of the code region that we patch at runtime
-LEAF_ENTRY JIT_PatchedCodeLast, _TEXT
-        ret
-LEAF_END JIT_PatchedCodeLast, _TEXT
+// look in patchedcode.S
 
 #endif  // FEATURE_SATORI_GC
 
diff --git a/src/coreclr/vm/amd64/patchedcode.S b/src/coreclr/vm/amd64/patchedcode.S
index 9af4e3ce855..167b5caf7d8 100644
--- a/src/coreclr/vm/amd64/patchedcode.S
+++ b/src/coreclr/vm/amd64/patchedcode.S
@@ -5,6 +5,8 @@
 #include "unixasmmacros.inc"
 #include "asmconstants.h"
 
+#ifndef FEATURE_SATORI_GC
+
 // Mark start of the code region that we patch at runtime
 LEAF_ENTRY JIT_PatchedCodeStart, _TEXT
         ret
@@ -243,3 +245,250 @@ LEAF_END_MARKED JIT_WriteBarrier, _TEXT
 LEAF_ENTRY JIT_PatchedCodeLast, _TEXT
         ret
 LEAF_END JIT_PatchedCodeLast, _TEXT
+
+#else  //FEATURE_SATORI_GC      ##############################################################################
+
+.macro ALTERNATE_ENTRY Name
+        .global C_FUNC(\Name)
+C_FUNC(\Name):
+.endm
+
+// Mark start of the code region that we patch at runtime
+LEAF_ENTRY JIT_PatchedCodeStart, _TEXT
+        ret
+LEAF_END JIT_PatchedCodeStart, _TEXT
+
+
+// void JIT_CheckedWriteBarrier(Object** dst, Object* src)
+LEAF_ENTRY JIT_CheckedWriteBarrier, _TEXT
+
+     // See if dst is in GCHeap
+        PREPARE_EXTERNAL_VAR g_card_bundle_table, rax   // fetch the page byte map
+        mov     rax, [rax]
+        mov     r8, rdi
+        shr     r8, 30                                  // dst page index
+        cmp     byte ptr [rax + r8], 0
+        jne     C_FUNC(CheckedEntry)
+
+    NotInHeap:
+        // See comment above about possible AV
+        mov     [rdi], rsi
+        ret
+LEAF_END_MARKED JIT_CheckedWriteBarrier, _TEXT
+
+
+//
+//   rdi - dest address
+//   rsi - object
+//
+.balign 16
+LEAF_ENTRY JIT_WriteBarrier, _TEXT
+#ifdef FEATURE_SATORI_EXTERNAL_OBJECTS
+    // check if src is in heap
+        PREPARE_EXTERNAL_VAR g_card_bundle_table, rax   // fetch the page byte map
+        mov     rax, [rax]
+    ALTERNATE_ENTRY CheckedEntry
+        mov     r8, rsi
+        shr     r8, 30                                  //  src page index
+        cmp     byte ptr [rax + r8], 0
+        je      JustAssign                              // src not in heap
+#else
+    ALTERNATE_ENTRY CheckedEntry
+#endif
+
+    // check for escaping assignment
+    // 1) check if we own the source region
+        mov     rdx, rsi
+        and     rdx, 0xFFFFFFFFFFE00000  // source region
+#ifndef FEATURE_SATORI_EXTERNAL_OBJECTS
+        jz      JustAssign              // assigning null
+#endif
+#ifdef TARGET_OSX
+        mov     rax,  gs:[0]            // thread tag
+#else
+        mov     rax,  fs:[0]            // thread tag
+#endif
+        cmp     qword ptr [rdx], rax     
+        jne     AssignAndMarkCards      // not local to this thread
+
+    // 2) check if the src and dst are from the same region
+        mov     rax, rdi
+        and     rax, 0xFFFFFFFFFFE00000 // target aligned to region
+        cmp     rax, rdx
+        jnz     RecordEscape            // cross region assignment. definitely escaping
+
+    // 3) check if the target is exposed
+        mov     rax, rdi
+        and     rax, 0x1FFFFF
+        shr     rax, 3
+        bt      qword ptr [rdx], rax
+        jb      RecordEscape            // target is exposed. record an escape.
+
+    JustAssign:
+        mov     [rdi], rsi              // no card marking, src is not a heap object
+
+        // set rdi, rsi per contract with JIT_ByRefWriteBarrier
+        add     rdi, 8
+        mov     rsi, r10
+        ret
+
+    AssignAndMarkCards:
+        mov     [rdi], rsi
+
+        // TUNING: barriers in different modes could be separate pieces of code, but barrier switch 
+        //         needs to suspend EE, not sure if skipping mode check would worth that much.
+        PREPARE_EXTERNAL_VAR g_sw_ww_table, rcx
+        mov     r11, [rcx]
+
+        // set rdi per contract with JIT_ByRefWriteBarrier
+        mov     rax, rdi
+        add     rdi, 8
+
+        // check the barrier state. this must be done after the assignment (in program order)
+        // if state == 2 we do not set or dirty cards.
+        cmp     r11, 2
+        jne     DoCards
+        // set rsi per contract with JIT_ByRefWriteBarrier
+        mov     rsi, r10
+    Exit:
+        ret
+
+    DoCards:
+    // if same region, just check if barrier is not concurrent
+        xor     rsi, rax
+        shr     rsi, 21
+        // set rsi per contract with JIT_ByRefWriteBarrier
+        mov     rsi, r10
+        jz      CheckConcurrent         // same region, just check if barrier is not concurrent
+
+    // if src is in gen2/3 and the barrier is not concurrent we do not need to mark cards
+        cmp     dword ptr [rdx + 16], 2
+        jl     MarkCards
+
+    CheckConcurrent:
+    // if concurrent, load card location
+        cmp     r11, 0
+        je      Exit
+
+    MarkCards:
+    // fetch card location for rax  (saved rdi)
+        PREPARE_EXTERNAL_VAR g_card_table, r9 
+        mov     r9,  [r9]  // fetch the page map
+        mov     rdx, rax
+        shr     rax, 30
+        mov     rax, qword ptr [r9 + rax * 8] // page
+        sub     rdx, rax   // offset in page
+        mov     r8,  rdx
+        shr     rdx, 9     // card offset
+        shr     r8,  20    // group index
+        lea     r8,  [rax + r8 * 2 + 0x80] // group offset
+
+     // check if concurrent marking is in progress
+        cmp     r11, 0
+        jne     DirtyCard
+
+     // SETTING CARD
+     SetCard:
+        cmp     byte ptr [rax + rdx], 0
+        jne     Exit
+        mov     byte ptr [rax + rdx], 1
+     SetGroup:
+        cmp     byte ptr [r8], 0
+        jne     CardSet
+        mov     byte ptr [r8], 1
+     SetPage:
+        cmp     byte ptr [rax], 0
+        jne     CardSet
+        mov     byte ptr [rax], 1
+
+     CardSet:
+     // check if concurrent marking is still not in progress
+        cmp     qword ptr [rcx], 0
+        jne     DirtyCard
+        ret
+
+     // DIRTYING CARD
+     DirtyCard:
+        mov     byte ptr [rax + rdx], 4
+     DirtyGroup:
+        cmp     byte ptr [r8], 4
+        je      Exit
+        mov     byte ptr [r8], 4
+     DirtyPage:
+        cmp     byte ptr [rax], 4
+        je      Exit
+        mov     byte ptr [rax], 4
+        ret
+
+    // this is expected to be rare.
+    RecordEscape:
+
+    // 4) check if the source is escaped
+        mov     rax, rsi
+        add     rax, 8                        // escape bit is MT + 1
+        and     rax, 0x1FFFFF
+        shr     rax, 3
+        bt      qword ptr [rdx], rax
+        jb      AssignAndMarkCards            // source is already escaped.
+
+        // Align rsp
+        mov  r9, rsp
+        and  rsp, -16
+        sub  rsp, 8
+
+        // save rsp, rdi, rsi, rdx and r10 (possibly preadjusted rsi)
+        push r9
+        push rdi
+        push rsi
+        push rdx
+        push r10
+
+        // void SatoriRegion::EscapeFn(SatoriObject** dst, SatoriObject* src, SatoriRegion* region)
+        call    qword ptr [rdx + 8]
+
+        pop     r10
+        pop     rdx
+        pop     rsi
+        pop     rdi
+        pop     rsp
+        jmp     AssignAndMarkCards
+LEAF_END_MARKED JIT_WriteBarrier, _TEXT
+
+
+// JIT_ByRefWriteBarrier has weird symantics, see usage in StubLinkerX86.cpp
+//
+// Entry:
+//   RDI - address of ref-field (assigned to)
+//   RSI - address of the data  (source)
+//   Note: RyuJIT assumes that all volatile registers can be trashed by 
+//   the CORINFO_HELP_ASSIGN_BYREF helper (i.e. JIT_ByRefWriteBarrier)
+//   except RDI and RSI. This helper uses and defines RDI and RSI, so
+//   they remain as live GC refs or byrefs, and are not killed.
+// Exit:
+//   RDI, RSI are incremented by SIZEOF(LPVOID)
+LEAF_ENTRY JIT_ByRefWriteBarrier, _TEXT
+        lea     r10, [rsi + 8]
+        mov     rsi, [rsi]
+
+     // See if dst is in GCHeap
+        PREPARE_EXTERNAL_VAR g_card_bundle_table, rax   // fetch the page byte map
+        mov     rax, [rax]
+
+        mov     r8, rdi
+        shr     r8, 30                                  // dst page index
+        cmp     byte ptr [rax + r8], 0
+        jne     C_FUNC(CheckedEntry)
+
+    NotInHeap_ByRefWriteBarrier:
+        mov     [rdi], rsi
+        add     rdi, 8
+        mov     rsi, r10
+        ret
+LEAF_END_MARKED JIT_ByRefWriteBarrier, _TEXT
+
+// Mark start of the code region that we patch at runtime
+LEAF_ENTRY JIT_PatchedCodeLast, _TEXT
+        ret
+LEAF_END JIT_PatchedCodeLast, _TEXT
+
+#endif  // FEATURE_SATORI_GC
diff --git a/src/coreclr/vm/amd64/patchedcode.asm b/src/coreclr/vm/amd64/patchedcode.asm
index 56d325979f6..9ad4727a47b 100644
--- a/src/coreclr/vm/amd64/patchedcode.asm
+++ b/src/coreclr/vm/amd64/patchedcode.asm
@@ -16,6 +16,7 @@ ifdef _DEBUG
 extern JIT_WriteBarrier_Debug:proc
 endif
 
+ifndef FEATURE_SATORI_GC
 
 ; Mark start of the code region that we patch at runtime
 LEAF_ENTRY JIT_PatchedCodeStart, _TEXT
@@ -199,4 +200,234 @@ LEAF_ENTRY JIT_PatchedCodeLast, _TEXT
         ret
 LEAF_END JIT_PatchedCodeLast, _TEXT
 
+else  ;FEATURE_SATORI_GC     ##########################################################################
+
+EXTERN g_card_table:QWORD
+EXTERN g_card_bundle_table:QWORD
+EXTERN g_sw_ww_table:QWORD
+
+ifdef FEATURE_USE_SOFTWARE_WRITE_WATCH_FOR_GC_HEAP
+EXTERN  g_sw_ww_enabled_for_gc_heap:BYTE
+endif
+
+; Mark start of the code region that we patch at runtime
+LEAF_ENTRY JIT_PatchedCodeStart, _TEXT
+        ret
+LEAF_END JIT_PatchedCodeStart, _TEXT
+
+; void JIT_CheckedWriteBarrier(Object** dst, Object* src)
+LEAF_ENTRY JIT_CheckedWriteBarrier, _TEXT
+    ; See if dst is in GCHeap
+        mov     rax, [g_card_bundle_table] ; fetch the page byte map
+        mov     r8,  rcx
+        shr     r8,  30                    ; dst page index
+        cmp     byte ptr [rax + r8], 0
+        jne     CheckedEntry
+
+    NotInHeap:
+        ; See comment above about possible AV
+        mov     [rcx], rdx
+        ret
+LEAF_END_MARKED JIT_CheckedWriteBarrier, _TEXT
+
+ALTERNATE_ENTRY macro Name
+
+Name label proc
+PUBLIC Name
+        endm
+
+;
+;   rcx - dest address 
+;   rdx - object
+;
+LEAF_ENTRY JIT_WriteBarrier, _TEXT
+
+ifdef FEATURE_SATORI_EXTERNAL_OBJECTS
+    ; check if src is in heap
+        mov     rax, [g_card_bundle_table] ; fetch the page byte map
+    ALTERNATE_ENTRY CheckedEntry
+        mov     r8,  rdx
+        shr     r8,  30                    ; src page index
+        cmp     byte ptr [rax + r8], 0
+        je      JustAssign                 ; src not in heap
+else
+    ALTERNATE_ENTRY CheckedEntry
+endif
+
+    ; check for escaping assignment
+    ; 1) check if we own the source region
+        mov     r8, rdx
+        and     r8, 0FFFFFFFFFFE00000h  ; source region
+
+ifndef FEATURE_SATORI_EXTERNAL_OBJECTS
+        jz      JustAssign              ; assigning null
+endif
+
+        mov     rax,  gs:[30h]          ; thread tag, TEB on NT
+        cmp     qword ptr [r8], rax     
+        jne     AssignAndMarkCards      ; not local to this thread
+
+    ; 2) check if the src and dst are from the same region
+        mov     rax, rcx
+        and     rax, 0FFFFFFFFFFE00000h ; target aligned to region
+        cmp     rax, r8
+        jne     RecordEscape            ; cross region assignment. definitely escaping
+
+    ; 3) check if the target is exposed
+        mov     rax, rcx
+        and     rax, 01FFFFFh
+        shr     rax, 3
+        bt      qword ptr [r8], rax
+        jb      RecordEscape            ; target is exposed. record an escape.
+
+    JustAssign:
+        mov     [rcx], rdx              ; no card marking, src is not a heap object
+        ret
+
+    AssignAndMarkCards:
+        mov     [rcx], rdx
+
+    ; TUNING: barriers in different modes could be separate pieces of code, but barrier switch 
+    ;         needs to suspend EE, not sure if skipping mode check would worth that much.
+        mov     r11, qword ptr [g_sw_ww_table]
+
+    ; check the barrier state. this must be done after the assignment (in program order)
+    ; if state == 2 we do not set or dirty cards.
+        cmp     r11, 2h
+        jne     DoCards
+    Exit:
+        ret
+
+    DoCards:
+    ; if same region, just check if barrier is not concurrent
+        xor     rdx, rcx
+        shr     rdx, 21
+        jz      CheckConcurrent
+
+    ; if src is in gen2/3 and the barrier is not concurrent we do not need to mark cards
+        cmp     dword ptr [r8 + 16], 2
+        jl      MarkCards
+
+    CheckConcurrent:
+        cmp     r11, 0h
+        je      Exit
+
+    MarkCards:
+    ; fetch card location for rcx
+        mov     r9 , [g_card_table]     ; fetch the page map
+        mov     r8,  rcx
+        shr     rcx, 30
+        mov     rax, qword ptr [r9 + rcx * 8] ; page
+        sub     r8, rax   ; offset in page
+        mov     rdx,r8
+        shr     r8, 9     ; card offset
+        shr     rdx, 20   ; group index
+        lea     rdx, [rax + rdx * 2 + 80h] ; group offset
+
+    ; check if concurrent marking is in progress
+        cmp     r11, 0h
+        jne     DirtyCard
+
+    ; SETTING CARD FOR RCX
+     SetCard:
+        cmp     byte ptr [rax + r8], 0
+        jne     Exit
+        mov     byte ptr [rax + r8], 1
+     SetGroup:
+        cmp     byte ptr [rdx], 0
+        jne     CardSet
+        mov     byte ptr [rdx], 1
+     SetPage:
+        cmp     byte ptr [rax], 0
+        jne     CardSet
+        mov     byte ptr [rax], 1
+
+     CardSet:
+    ; check if concurrent marking is still not in progress
+        cmp     qword ptr [g_sw_ww_table], 0h
+        jne     DirtyCard
+        ret
+
+    ; DIRTYING CARD FOR RCX
+     DirtyCard:
+        mov     byte ptr [rax + r8], 4
+     DirtyGroup:
+        cmp     byte ptr [rdx], 4
+        je      Exit
+        mov     byte ptr [rdx], 4
+     DirtyPage:
+        cmp     byte ptr [rax], 4
+        je      Exit
+        mov     byte ptr [rax], 4
+        ret
+
+    ; this is expected to be rare.
+    RecordEscape:
+
+        ; 4) check if the source is escaped
+        mov     rax, rdx
+        add     rax, 8                        ; escape bit is MT + 1
+        and     rax, 01FFFFFh
+        shr     rax, 3
+        bt      qword ptr [r8], rax
+        jb      AssignAndMarkCards            ; source is already escaped.
+
+        ; Align rsp
+        mov  r9, rsp
+        and  rsp, -16
+
+        ; save rsp, rcx, rdx, r8 and have enough stack for the callee
+        push r9
+        push rcx
+        push rdx
+        push r8
+        sub  rsp, 20h
+
+        ; void SatoriRegion::EscapeFn(SatoriObject** dst, SatoriObject* src, SatoriRegion* region)
+        call    qword ptr [r8 + 8]
+
+        add     rsp, 20h
+        pop     r8
+        pop     rdx
+        pop     rcx
+        pop     rsp
+        jmp     AssignAndMarkCards
+LEAF_END_MARKED JIT_WriteBarrier, _TEXT
+
+; JIT_ByRefWriteBarrier has weird symantics, see usage in StubLinkerX86.cpp
+;
+; Entry:
+;   RDI - address of ref-field (assigned to)
+;   RSI - address of the data  (source)
+;   Note: RyuJIT assumes that all volatile registers can be trashed by 
+;   the CORINFO_HELP_ASSIGN_BYREF helper (i.e. JIT_ByRefWriteBarrier)
+;   except RDI and RSI. This helper uses and defines RDI and RSI, so
+;   they remain as live GC refs or byrefs, and are not killed.
+; Exit:
+;   RDI, RSI are incremented by SIZEOF(LPVOID)
+LEAF_ENTRY JIT_ByRefWriteBarrier, _TEXT
+        mov     rcx, rdi
+        mov     rdx, [rsi]
+        add     rdi, 8h
+        add     rsi, 8h
+
+    ; See if dst is in GCHeap
+        mov     rax, [g_card_bundle_table] ; fetch the page byte map
+        mov     r8,  rcx
+        shr     r8,  30                    ; dst page index
+        cmp     byte ptr [rax + r8], 0
+        jne     CheckedEntry
+
+    NotInHeap:
+        mov     [rcx], rdx
+        ret
+LEAF_END_MARKED JIT_ByRefWriteBarrier, _TEXT
+
+; Mark start of the code region that we patch at runtime
+LEAF_ENTRY JIT_PatchedCodeLast, _TEXT
+        ret
+LEAF_END JIT_PatchedCodeLast, _TEXT
+
+endif  ; FEATURE_SATORI_GC
+
         end
diff --git a/src/coreclr/vm/arm64/patchedcode.S b/src/coreclr/vm/arm64/patchedcode.S
index ae8d07ab1f9..cbd33112261 100644
--- a/src/coreclr/vm/arm64/patchedcode.S
+++ b/src/coreclr/vm/arm64/patchedcode.S
@@ -52,6 +52,8 @@ WRITE_BARRIER_ENTRY JIT_ByRefWriteBarrier
 
 WRITE_BARRIER_END JIT_ByRefWriteBarrier
 
+#ifndef FEATURE_SATORI_GC
+
 //-----------------------------------------------------------------------------
 // Simple WriteBarriers
 // void JIT_CheckedWriteBarrier(Object** dst, Object* src)
@@ -201,6 +203,222 @@ LOCAL_LABEL(Exit):
     ret  lr
 WRITE_BARRIER_END JIT_WriteBarrier
 
+#else  // FEATURE_SATORI_GC
+
+//-----------------------------------------------------------------------------
+// Simple WriteBarriers
+// void JIT_CheckedWriteBarrier(Object** dst, Object* src)
+// On entry:
+//   x14  : the destination address (LHS of the assignment)
+//   x15  : the object reference (RHS of the assignment)
+//
+// On exit:
+//   x12  : trashed
+//   x14  : trashed (incremented by 8 to implement JIT_ByRefWriteBarrier contract)
+//   x15  : trashed
+//   x16  : trashed (ip0)
+//   x17  : trashed (ip1)
+//
+WRITE_BARRIER_ENTRY JIT_CheckedWriteBarrier
+    // See if dst is in GCHeap
+        ldr     x16, LOCAL_LABEL(wbs_card_bundle_table)
+        lsr     x17, x14, #30                       // dst page index
+        ldrb    w12, [x16, x17]
+        cbz     x12 , LOCAL_LABEL(NotInHeap)
+        b       C_FUNC(CheckedEntry)
+
+    LOCAL_LABEL(NotInHeap):
+        str  x15, [x14], #8
+        ret  lr
+WRITE_BARRIER_END JIT_CheckedWriteBarrier
+
+// void JIT_WriteBarrier(Object** dst, Object* src)
+// On entry:
+//   x14  : the destination address (LHS of the assignment)
+//   x15  : the object reference (RHS of the assignment)
+//
+// On exit:
+//   x12  : trashed
+//   x14  : trashed (incremented by 8 to implement JIT_ByRefWriteBarrier contract)
+//   x15  : trashed
+//   x16  : trashed (ip0)
+//   x17  : trashed (ip1)
+//
+WRITE_BARRIER_ENTRY JIT_WriteBarrier
+    // check for escaping assignment
+    // 1) check if we own the source region
+#ifdef FEATURE_SATORI_EXTERNAL_OBJECTS
+        ldr     x16, LOCAL_LABEL(wbs_card_bundle_table)
+    C_FUNC(CheckedEntry):
+        lsr     x17, x15, #30                   // source page index
+        ldrb    w12, [x16, x17]
+        cbz     x12, LOCAL_LABEL(JustAssign)    // null or external (immutable) object
+#else
+    C_FUNC(CheckedEntry):
+        cbz     x15, LOCAL_LABEL(JustAssign)    // assigning null
+#endif
+        and     x16,  x15, #0xFFFFFFFFFFE00000  // source region
+        ldr     x12, [x16]                      // region tag
+#ifdef TARGET_OSX
+        mrs     x17, TPIDRRO_EL0
+        and     x17, x17, #-8                   // thread tag on OSX
+#else
+        mrs     x17, TPIDR_EL0                  // thread tag on other Unix
+#endif
+        cmp     x12, x17
+        bne     LOCAL_LABEL(AssignAndMarkCards) // not local to this thread
+
+    // 2) check if the src and dst are from the same region
+        and     x12, x14, #0xFFFFFFFFFFE00000   // target aligned to region
+        cmp     x12, x16
+        bne     LOCAL_LABEL(RecordEscape)       // cross region assignment. definitely escaping
+
+    // 3) check if the target is exposed
+        ubfx        x17, x14,#9,#12             // word index = (dst >> 9) & 0x1FFFFF
+        ldr         x17, [x16, x17, lsl #3]     // mark word = [region + index * 8]
+        lsr         x12, x14, #3                // bit = (dst >> 3) [& 63]
+        lsr         x17, x17, x12
+        tbnz        x17, #0, LOCAL_LABEL(RecordEscape) // target is exposed. record an escape.
+
+    // UNORDERED! assignment of unescaped, null or external (immutable) object
+    LOCAL_LABEL(JustAssign):
+        str  x15, [x14], #8
+        ret  lr
+
+    LOCAL_LABEL(AssignAndMarkCards):
+        stlr    x15, [x14]
+
+    // TUNING: barriers in different modes could be separate pieces of code, but barrier switch 
+    //         needs to suspend EE, not sure if skipping mode check would worth that much.
+        ldr     x17, LOCAL_LABEL(wbs_sw_ww_table)
+    // check the barrier state. this must be done after the assignment (in program order)
+    // if state == 2 we do not set or dirty cards.
+        tbz     x17, #1, LOCAL_LABEL(DoCards)
+
+    LOCAL_LABEL(ExitNoCards):
+        add     x14, x14, 8
+        ret     lr
+
+    LOCAL_LABEL(DoCards):
+    // if same region, just check if barrier is not concurrent
+        and     x12, x14, #0xFFFFFFFFFFE00000   // target aligned to region
+        cmp     x12, x16
+        beq     LOCAL_LABEL(CheckConcurrent)    // same region, just check if barrier is not concurrent
+
+    // if src is in gen2/3 and the barrier is not concurrent we do not need to mark cards
+        ldr     w12, [x16, 16]                  // source region + 16 -> generation
+        tbz     x12, #1, LOCAL_LABEL(MarkCards)
+
+    LOCAL_LABEL(CheckConcurrent):
+    // if not concurrent, exit
+        cbz     x17, LOCAL_LABEL(ExitNoCards)
+
+    LOCAL_LABEL(MarkCards):
+    // need couple temps. Save before using.
+        stp     x2,  x3,  [sp, -16]!
+
+    // fetch card location for x14
+        ldr     x12, LOCAL_LABEL(wbs_card_table)     // fetch the page map
+        lsr     x16, x14, #30
+        ldr     x16, [x12, x16, lsl #3]              // page
+        sub     x2,  x14, x16   // offset in page
+        lsr     x15, x2,  #20   // group index
+        lsr     x2,  x2,  #9    // card offset
+        lsl     x15, x15, #1    // group offset (index * 2)
+
+    // check if concurrent marking is in progress
+        cbnz    x17, LOCAL_LABEL(DirtyCard)
+
+    // SETTING CARD FOR X14
+    LOCAL_LABEL(SetCard):
+        ldrb    w3, [x16, x2]
+        cbnz    w3, LOCAL_LABEL(Exit)
+        mov     w17, #1
+        strb    w17, [x16, x2]
+    LOCAL_LABEL(SetGroup):
+        add     x12, x16, #0x80
+        ldrb    w3, [x12, x15]
+        cbnz    w3, LOCAL_LABEL(CardSet)
+        strb    w17, [x12, x15]
+    LOCAL_LABEL(SetPage):
+        ldrb    w3, [x16]
+        cbnz    w3, LOCAL_LABEL(CardSet)
+        strb    w17, [x16]
+
+    LOCAL_LABEL(CardSet):
+    // check if concurrent marking is still not in progress
+        ldr     x12, LOCAL_LABEL(wbs_sw_ww_table)    // !wbs_sw_ww_table -> !concurrent
+        cbnz    x12, LOCAL_LABEL(DirtyCard)
+
+    LOCAL_LABEL(Exit):
+        ldp  x2,  x3, [sp], 16
+        add  x14, x14, 8
+        ret  lr
+
+    // DIRTYING CARD FOR X14
+    LOCAL_LABEL(DirtyCard):
+        mov     w17, #4
+        add     x2, x2, x16
+        // must be after the field write to allow concurrent clean
+        stlrb   w17, [x2]
+    LOCAL_LABEL(DirtyGroup):
+        add     x12, x16, #0x80
+        ldrb    w3, [x12, x15]
+        tbnz    w3, #2, LOCAL_LABEL(Exit)
+        strb    w17, [x12, x15]
+    LOCAL_LABEL(DirtyPage):
+        ldrb    w3, [x16]
+        tbnz    w3, #2, LOCAL_LABEL(Exit)
+        strb    w17, [x16]
+        b       LOCAL_LABEL(Exit)
+
+    // this is expected to be rare.
+    LOCAL_LABEL(RecordEscape):
+
+    // 4) check if the source is escaped (x16 has source region)
+        add         x12, x15, #8                   // escape bit is MT + 1
+        ubfx        x17, x12, #9,#12               // word index = (dst >> 9) & 0x1FFFFF
+        ldr         x17, [x16, x17, lsl #3]        // mark word = [region + index * 8]
+        lsr         x12, x12, #3                   // bit = (dst >> 3) [& 63]
+        lsr         x17, x17, x12
+        tbnz        x17, #0, LOCAL_LABEL(AssignAndMarkCards)        // source is already escaped.
+
+        // because of the barrier call convention
+        // we need to preserve caller-saved x0 through x15 and x29/x30
+
+        stp     x29,x30, [sp, -16 * 9]!
+        stp     x0, x1,  [sp, 16 * 1]
+        stp     x2, x3,  [sp, 16 * 2]
+        stp     x4, x5,  [sp, 16 * 3]
+        stp     x6, x7,  [sp, 16 * 4]
+        stp     x8, x9,  [sp, 16 * 5]
+        stp     x10,x11, [sp, 16 * 6]
+        stp     x12,x13, [sp, 16 * 7]
+        stp     x14,x15, [sp, 16 * 8]
+
+        // void SatoriRegion::EscapeFn(SatoriObject** dst, SatoriObject* src, SatoriRegion* region)
+        // mov  x0, x14  EscapeFn does not use dst, it is just to avoid arg shuffle on x64
+        mov  x1, x15
+        mov  x2, x16                       // source region
+        ldr  x12, [x16, #8]                 // EscapeFn address
+        blr  x12
+
+        ldp     x0, x1,  [sp, 16 * 1]
+        ldp     x2, x3,  [sp, 16 * 2]
+        ldp     x4, x5,  [sp, 16 * 3]
+        ldp     x6, x7,  [sp, 16 * 4]
+        ldp     x8, x9,  [sp, 16 * 5]
+        ldp     x10,x11, [sp, 16 * 6]
+        ldp     x12,x13, [sp, 16 * 7]
+        ldp     x14,x15, [sp, 16 * 8]
+        ldp     x29,x30, [sp], 16 * 9
+
+        and     x16, x15, #0xFFFFFFFFFFE00000  // source region
+        b       LOCAL_LABEL(AssignAndMarkCards)
+WRITE_BARRIER_END JIT_WriteBarrier
+
+#endif  // FEATURE_SATORI_GC
+
     // Begin patchable literal pool
     .balign 64  // Align to power of two at least as big as patchable literal pool so that it fits optimally in cache line
 WRITE_BARRIER_ENTRY JIT_WriteBarrier_Table
diff --git a/src/coreclr/vm/arm64/patchedcode.asm b/src/coreclr/vm/arm64/patchedcode.asm
index 4bb8aa19681..72962324e58 100644
--- a/src/coreclr/vm/arm64/patchedcode.asm
+++ b/src/coreclr/vm/arm64/patchedcode.asm
@@ -86,6 +86,8 @@ wbs_GCShadowEnd
 
     WRITE_BARRIER_END JIT_ByRefWriteBarrier
 
+#ifndef FEATURE_SATORI_GC
+
 ;-----------------------------------------------------------------------------
 ; Simple WriteBarriers
 ; void JIT_CheckedWriteBarrier(Object** dst, Object* src)
@@ -232,6 +234,215 @@ Exit
         ret      lr
     WRITE_BARRIER_END JIT_WriteBarrier
 
+#else  // FEATURE_SATORI_GC
+
+;-----------------------------------------------------------------------------
+; Simple WriteBarriers
+; void JIT_CheckedWriteBarrier(Object** dst, Object* src)
+; On entry:
+;   x14  : the destination address (LHS of the assignment)
+;   x15  : the object reference (RHS of the assignment)
+;
+; On exit:
+;   x12  : trashed
+;   x14  : trashed (incremented by 8 to implement JIT_ByRefWriteBarrier contract)
+;   x15  : trashed
+;   x17  : trashed (ip1) if FEATURE_USE_SOFTWARE_WRITE_WATCH_FOR_GC_HEAP
+;
+    WRITE_BARRIER_ENTRY JIT_CheckedWriteBarrier
+    ; See if dst is in GCHeap
+        ldr     x16, wbs_card_bundle_table
+        lsr     x17, x14, #30                       ; source page index
+        ldrb    w12, [x16, x17]
+        cbnz    x12, CheckedEntry
+
+NotInHeap
+        str  x15, [x14], #8
+        ret  lr
+    WRITE_BARRIER_END JIT_CheckedWriteBarrier
+
+; void JIT_WriteBarrier(Object** dst, Object* src)
+; On entry:
+;   x14  : the destination address (LHS of the assignment)
+;   x15  : the object reference (RHS of the assignment)
+;
+; On exit:
+;   x12  : trashed
+;   x14  : trashed (incremented by 8 to implement JIT_ByRefWriteBarrier contract)
+;   x15  : trashed
+;   x16  : trashed (ip0)
+;   x17  : trashed (ip1)
+;
+    WRITE_BARRIER_ENTRY JIT_WriteBarrier
+    ; check for escaping assignment
+    ; 1) check if we own the source region
+#ifdef FEATURE_SATORI_EXTERNAL_OBJECTS
+        ldr     x16, wbs_card_bundle_table
+CheckedEntry
+        lsr     x17, x15, #30                   ; source page index
+        ldrb    w12, [x16, x17]
+        cbz     x12, JustAssign                 ; null or external (immutable) object
+#else
+CheckedEntry
+        cbz     x15, JustAssign                 ; assigning null
+#endif
+        and     x16,  x15, #0xFFFFFFFFFFE00000  ; source region
+        ldr     x12, [x16]                      ; region tag
+        cmp     x12, x18                        ; x18 - TEB
+        bne     AssignAndMarkCards              ; not local to this thread
+
+    ; 2) check if the src and dst are from the same region
+        and     x12, x14, #0xFFFFFFFFFFE00000   ; target aligned to region
+        cmp     x12, x16
+        bne     RecordEscape                    ; cross region assignment. definitely escaping
+
+    ; 3) check if the target is exposed
+        ubfx        x17, x14,#9,#12             ; word index = (dst >> 9) & 0x1FFFFF
+        ldr         x17, [x16, x17, lsl #3]     ; mark word = [region + index * 8]
+        lsr         x12, x14, #3                ; bit = (dst >> 3) [& 63]
+        lsr         x17, x17, x12
+        tbnz        x17, #0, RecordEscape       ; target is exposed. record an escape.
+
+    ; UNORDERED! assignment of unescaped, null or external (immutable) object
+JustAssign
+        str  x15, [x14], #8
+        ret  lr
+
+AssignAndMarkCards
+        stlr    x15, [x14]
+
+    ; TUNING: barriers in different modes could be separate pieces of code, but barrier switch 
+    ;         needs to suspend EE, not sure if skipping mode check would worth that much.
+        ldr     x17, wbs_sw_ww_table
+    ; check the barrier state. this must be done after the assignment (in program order
+    ; if state == 2 we do not set or dirty cards.
+        tbz     x17, #1, DoCards
+
+ExitNoCards
+        add     x14, x14, 8
+        ret     lr
+
+DoCards
+    ; if same region, just check if barrier is not concurrent
+        and     x12, x14, #0xFFFFFFFFFFE00000   ; target aligned to region
+        cmp     x12, x16
+        beq     CheckConcurrent    ; same region, just check if barrier is not concurrent
+
+    ; if src is in gen2/3 and the barrier is not concurrent we do not need to mark cards
+        ldr     w12, [x16, 16]                  ; source region + 16 -> generation
+        tbz     x12, #1, MarkCards
+
+CheckConcurrent
+    ; if not concurrent, exit
+        cbz     x17, ExitNoCards
+
+MarkCards
+    ; need couple temps. Save before using.
+        stp     x2,  x3,  [sp, -16]!
+
+    ; fetch card location for x14
+        ldr     x12, wbs_card_table                  ; fetch the page map
+        lsr     x16, x14, #30
+        ldr     x16, [x12, x16, lsl #3]              ; page
+        sub     x2,  x14, x16   ; offset in page
+        lsr     x15, x2,  #20   ; group index
+        lsr     x2,  x2,  #9    ; card offset
+        lsl     x15, x15, #1    ; group offset (index * 2)
+
+    ; check if concurrent marking is in progress
+        cbnz    x17, DirtyCard
+
+    ; SETTING CARD FOR X14
+SetCard
+        ldrb    w3, [x16, x2]
+        cbnz    w3, Exit
+        mov     w17, #1
+        strb    w17, [x16, x2]
+SetGroup
+        add     x12, x16, #0x80
+        ldrb    w3, [x12, x15]
+        cbnz    w3, CardSet
+        strb    w17, [x12, x15]
+SetPage
+        ldrb    w3, [x16]
+        cbnz    w3, CardSet
+        strb    w17, [x16]
+
+CardSet
+    ; check if concurrent marking is still not in progress
+        ldr     x12, wbs_sw_ww_table            ; !wbs_sw_ww_table -> !concurrent
+        cbnz    x12, DirtyCard
+
+Exit
+        ldp  x2,  x3, [sp], 16
+        add  x14, x14, 8
+        ret  lr
+
+    ; DIRTYING CARD FOR X14
+DirtyCard
+        mov     w17, #4
+        add     x2, x2, x16
+        ; must be after the field write to allow concurrent clean
+        stlrb   w17, [x2]
+DirtyGroup
+        add     x12, x16, #0x80
+        ldrb    w3, [x12, x15]
+        tbnz    w3, #2, Exit
+        strb    w17, [x12, x15]
+DirtyPage
+        ldrb    w3, [x16]
+        tbnz    w3, #2, Exit
+        strb    w17, [x16]
+        b       Exit
+
+    ; this is expected to be rare.
+RecordEscape
+
+    ; 4) check if the source is escaped (x16 has source region)
+        add         x12, x15, #8                   ; escape bit is MT + 1
+        ubfx        x17, x12, #9,#12               ; word index = (dst >> 9) & 0x1FFFFF
+        ldr         x17, [x16, x17, lsl #3]        ; mark word = [region + index * 8]
+        lsr         x12, x12, #3                   ; bit = (dst >> 3) [& 63]
+        lsr         x17, x17, x12
+        tbnz        x17, #0, AssignAndMarkCards    ; source is already escaped.
+
+        ; because of the barrier call convention
+        ; we need to preserve caller-saved x0 through x15 and x29/x30
+
+        stp     x29,x30, [sp, -16 * 9]!
+        stp     x0, x1,  [sp, 16 * 1]
+        stp     x2, x3,  [sp, 16 * 2]
+        stp     x4, x5,  [sp, 16 * 3]
+        stp     x6, x7,  [sp, 16 * 4]
+        stp     x8, x9,  [sp, 16 * 5]
+        stp     x10,x11, [sp, 16 * 6]
+        stp     x12,x13, [sp, 16 * 7]
+        stp     x14,x15, [sp, 16 * 8]
+
+        ; void SatoriRegion::EscapeFn(SatoriObject** dst, SatoriObject* src, SatoriRegion* region)
+        ; mov  x0, x14  EscapeFn does not use dst, it is just to avoid arg shuffle on x64
+        mov  x1, x15
+        mov  x2, x16                        ; source region
+        ldr  x12, [x16, #8]                 ; EscapeFn address
+        blr  x12
+
+        ldp     x0, x1,  [sp, 16 * 1]
+        ldp     x2, x3,  [sp, 16 * 2]
+        ldp     x4, x5,  [sp, 16 * 3]
+        ldp     x6, x7,  [sp, 16 * 4]
+        ldp     x8, x9,  [sp, 16 * 5]
+        ldp     x10,x11, [sp, 16 * 6]
+        ldp     x12,x13, [sp, 16 * 7]
+        ldp     x14,x15, [sp, 16 * 8]
+        ldp     x29,x30, [sp], 16 * 9
+
+        and     x16, x15, #0xFFFFFFFFFFE00000  ; source region
+        b       AssignAndMarkCards
+    WRITE_BARRIER_END JIT_WriteBarrier
+
+#endif  // FEATURE_SATORI_GC
+
+
 ; ------------------------------------------------------------------
 ; End of the writeable code region
     LEAF_ENTRY JIT_PatchedCodeLast
diff --git a/src/coreclr/vm/ceemain.cpp b/src/coreclr/vm/ceemain.cpp
index f94e1c31220..dbe1c3beb29 100644
--- a/src/coreclr/vm/ceemain.cpp
+++ b/src/coreclr/vm/ceemain.cpp
@@ -1734,8 +1734,7 @@ static void RuntimeThreadShutdown(void* thread)
         // For case where thread calls ExitThread directly, we need to reset the
         // frame pointer. Otherwise stackwalk would AV. We need to do it in cooperative mode.
         // We need to set m_GCOnTransitionsOK so this thread won't trigger GC when toggle GC mode
-                //TODO: Satori Is the check for g_fForbidEnterEE needed?
-        if (thread->m_pFrame != FRAME_TOP && !g_fForbidEnterEE)
+        if (pThread->m_pFrame != FRAME_TOP)
         {
 #ifdef _DEBUG
             pThread->m_GCOnTransitionsOK = FALSE;
diff --git a/src/coreclr/vm/comutilnative.cpp b/src/coreclr/vm/comutilnative.cpp
index a3bce5b1427..6df30614f4b 100644
--- a/src/coreclr/vm/comutilnative.cpp
+++ b/src/coreclr/vm/comutilnative.cpp
@@ -959,6 +959,10 @@ FCIMPL0(INT64, GCInterface::GetTotalAllocatedBytesApproximate)
 {
     FCALL_CONTRACT;
 
+#if FEATURE_SATORI_GC
+    return GCHeapUtilities::GetGCHeap()->GetTotalAllocatedBytes();
+#else
+
 #ifdef TARGET_64BIT
     uint64_t unused_bytes = Thread::dead_threads_non_alloc_bytes;
 #else
@@ -983,6 +987,7 @@ FCIMPL0(INT64, GCInterface::GetTotalAllocatedBytesApproximate)
     }
 
     return current_high;
+#endif
 }
 FCIMPLEND;
 
@@ -994,6 +999,12 @@ extern "C" INT64 QCALLTYPE GCInterface_GetTotalAllocatedBytesPrecise()
 
     GCX_COOP();
 
+#if FEATURE_SATORI_GC
+
+    GCHeapUtilities::GetGCHeap()->GarbageCollect(1);
+
+    allocated = GCHeapUtilities::GetGCHeap()->GetTotalAllocatedBytes();
+#else
     // We need to suspend/restart the EE to get each thread's
     // non-allocated memory from their allocation contexts
 
@@ -1011,11 +1022,10 @@ extern "C" INT64 QCALLTYPE GCInterface_GetTotalAllocatedBytesPrecise()
     }
 
     ThreadSuspend::RestartEE(FALSE, TRUE);
-
+#endif
     END_QCALL;
 
     return allocated;
-#endif
 }
 
 #ifdef FEATURE_BASICFREEZE
diff --git a/src/coreclr/vm/frozenobjectheap.cpp b/src/coreclr/vm/frozenobjectheap.cpp
index 94a747471cb..1492590396c 100644
--- a/src/coreclr/vm/frozenobjectheap.cpp
+++ b/src/coreclr/vm/frozenobjectheap.cpp
@@ -38,6 +38,7 @@ Object* FrozenObjectHeapManager::TryAllocateObject(PTR_MethodTable type, size_t
     Object* obj = nullptr;
 
 #if FEATURE_SATORI_GC
+    // TODO: Satori does not have any size limitations here.
     if (objectSize > FOH_COMMIT_SIZE)
     {
       // The current design doesn't allow objects larger than FOH_COMMIT_SIZE and
@@ -144,35 +145,6 @@ Object* FrozenObjectHeapManager::TryAllocateObject(PTR_MethodTable type, size_t
 #endif // !FEATURE_BASICFREEZE
 }
 
-static void* ReserveMemory(size_t size)
-{
-#if defined(TARGET_X86) || defined(TARGET_AMD64)
-    // We have plenty of space in-range on X86/AMD64 so we can afford keeping
-    // FOH segments there so e.g. JIT can use relocs for frozen objects.
-    return ExecutableAllocator::Instance()->Reserve(size);
-#else
-    return ClrVirtualAlloc(nullptr, size, MEM_RESERVE, PAGE_READWRITE);
-#endif
-}
-
-static void* CommitMemory(void* ptr, size_t size)
-{
-#if defined(TARGET_X86) || defined(TARGET_AMD64)
-    return ExecutableAllocator::Instance()->Commit(ptr, size, /*isExecutable*/ false);
-#else
-    return ClrVirtualAlloc(ptr, size, MEM_COMMIT, PAGE_READWRITE);
-#endif
-}
-
-static void ReleaseMemory(void* ptr)
-{
-#if defined(TARGET_X86) || defined(TARGET_AMD64)
-    ExecutableAllocator::Instance()->Release(ptr);
-#else
-    ClrVirtualFree(ptr, 0, MEM_RELEASE);
-#endif
-}
-
 // Reserve sizeHint bytes of memory for the given frozen segment.
 // The requested size can be be ignored in case of memory pressure and FOH_SEGMENT_DEFAULT_SIZE is used instead.
 FrozenObjectSegment::FrozenObjectSegment(size_t sizeHint) :
@@ -186,7 +158,7 @@ FrozenObjectSegment::FrozenObjectSegment(size_t sizeHint) :
     _ASSERT(m_Size > FOH_COMMIT_SIZE);
     _ASSERT(m_Size % FOH_COMMIT_SIZE == 0);
 
-    void* alloc = ReserveMemory(m_Size);
+    void* alloc = ClrVirtualAlloc(nullptr, m_Size, MEM_RESERVE, PAGE_READWRITE);
     if (alloc == nullptr)
     {
         // Try again with the default FOH size
@@ -195,7 +167,7 @@ FrozenObjectSegment::FrozenObjectSegment(size_t sizeHint) :
             m_Size = FOH_SEGMENT_DEFAULT_SIZE;
             _ASSERT(m_Size > FOH_COMMIT_SIZE);
             _ASSERT(m_Size % FOH_COMMIT_SIZE == 0);
-            alloc = ReserveMemory(m_Size);
+            alloc = ClrVirtualAlloc(nullptr, m_Size, MEM_RESERVE, PAGE_READWRITE);
         }
 
         if (alloc == nullptr)
@@ -205,10 +177,10 @@ FrozenObjectSegment::FrozenObjectSegment(size_t sizeHint) :
     }
 
     // Commit a chunk in advance
-    void* committedAlloc = CommitMemory(alloc, FOH_COMMIT_SIZE);
+    void* committedAlloc = ClrVirtualAlloc(alloc, FOH_COMMIT_SIZE, MEM_COMMIT, PAGE_READWRITE);
     if (committedAlloc == nullptr)
     {
-        ReleaseMemory(alloc);
+        ClrVirtualFree(alloc, 0, MEM_RELEASE);
         ThrowOutOfMemory();
     }
 
@@ -290,7 +262,7 @@ Object* FrozenObjectSegment::TryAllocateObject(PTR_MethodTable type, size_t obje
         // Make sure we don't go out of bounds during this commit
         _ASSERT(m_SizeCommitted + FOH_COMMIT_SIZE <= m_Size);
 
-        if (CommitMemory(m_pStart + m_SizeCommitted, FOH_COMMIT_SIZE) == nullptr)
+        if (ClrVirtualAlloc(m_pStart + m_SizeCommitted, FOH_COMMIT_SIZE, MEM_COMMIT, PAGE_READWRITE) == nullptr)
         {
             ThrowOutOfMemory();
         }
diff --git a/src/coreclr/vm/gcenv.ee.cpp b/src/coreclr/vm/gcenv.ee.cpp
index 0be8e55855e..c6ec06025c0 100644
--- a/src/coreclr/vm/gcenv.ee.cpp
+++ b/src/coreclr/vm/gcenv.ee.cpp
@@ -301,9 +301,11 @@ void GCToEEInterface::GcScanCurrentStackRoots(promote_func* fn, ScanContext* sc)
 #endif // FEATURE_EVENT_TRACE
     ScanStackRoots(pThread, fn, sc);
     ScanTailCallArgBufferRoots(pThread, fn, sc);
+    ScanThreadStaticRoots(pThread, fn, sc);
 #ifdef FEATURE_EVENT_TRACE
     sc->dwEtwRootKind = kEtwGCRootKindOther;
 #endif // FEATURE_EVENT_TRACE
+
      STRESS_LOG2(LF_GC | LF_GCROOTS, LL_INFO100, "Ending scan of Thread %p ID = 0x%x }\n", pThread, pThread->GetThreadId());
 }
 
@@ -552,7 +554,7 @@ void GCToEEInterface::GcPoll()
     }
     CONTRACTL_END;
 
-    if (g_TrapReturningThreads.LoadWithoutBarrier())
+    if (g_TrapReturningThreads)
     {
         Thread* pThread = ::GetThread();
         _ASSERTE(!ThreadStore::HoldingThreadStore(pThread));
diff --git a/src/coreclr/vm/gcheaputilities.h b/src/coreclr/vm/gcheaputilities.h
index 39bc4034721..32d7bf64553 100644
--- a/src/coreclr/vm/gcheaputilities.h
+++ b/src/coreclr/vm/gcheaputilities.h
@@ -127,7 +127,11 @@ public:
 
     static bool UseThreadAllocationContexts()
     {
+#ifdef FEATURE_SATORI_GC
+        return true;
+#else
         return s_useThreadAllocationContexts;
+#endif
     }
 
 #ifdef FEATURE_USE_SOFTWARE_WRITE_WATCH_FOR_GC_HEAP
diff --git a/src/coreclr/vm/gchelpers.cpp b/src/coreclr/vm/gchelpers.cpp
index 2b0a098c128..c36b8479087 100644
--- a/src/coreclr/vm/gchelpers.cpp
+++ b/src/coreclr/vm/gchelpers.cpp
@@ -1120,7 +1120,7 @@ Object* AllocateImmortalObject(MethodTable* pMT, size_t objectSize)
     SetTypeHandleOnThreadForAlloc(TypeHandle(pMT));
 
     GC_ALLOC_FLAGS flags = GC_ALLOC_IMMORTAL;
-    if (pMT->ContainsPointers())
+    if (pMT->ContainsGCPointers())
         flags |= GC_ALLOC_CONTAINS_REF;
 
 #ifdef FEATURE_64BIT_ALIGNMENT
@@ -1438,7 +1438,7 @@ bool IsInHeapSatori(void* ptr)
 void CheckEscapeSatori(Object** dst, Object* ref)
 {
     SatoriObject* obj = (SatoriObject*)ref;
-    // TODO: no nullcheck when external
+    // TODO: Satori no nullcheck needed when external? (null is susbset of external)
     if (!obj || obj->IsExternal())
         return;
 
@@ -1536,14 +1536,13 @@ void ErectWriteBarrierForMT(MethodTable **dst, MethodTable *ref)
     STATIC_CONTRACT_NOTHROW;
     STATIC_CONTRACT_GC_NOTRIGGER;
 
+#if FEATURE_SATORI_GC
+    // this whole thing is unnecessary in Satori
+    __UNREACHABLE();
+#else
+
     *dst = ref;
 
-#if FEATURE_SATORI_GC
-
-    // Satori large objects are allocated in either gen1 or gen2.
-    // PublishObject will sort this out and mark cards as needed.
-
-#else
 #ifdef WRITE_BARRIER_CHECK
     updateGCShadow((Object **)dst, (Object *)ref);     // support debugging write barrier, updateGCShadow only cares that these are pointers
 #endif
diff --git a/src/coreclr/vm/object.cpp b/src/coreclr/vm/object.cpp
index ada2903b749..0f1bdcae30e 100644
--- a/src/coreclr/vm/object.cpp
+++ b/src/coreclr/vm/object.cpp
@@ -1384,9 +1384,12 @@ void* __cdecl GCSafeMemCpy(void * dest, const void * src, size_t len)
     STATIC_CONTRACT_GC_NOTRIGGER;
     STATIC_CONTRACT_FORBID_FAULT;
 
+#ifdef FEATURE_SATORI_GC
     if (IsInHeapSatori((Object**)dest))
-    //if (!(((*(BYTE**)&dest) <  g_lowest_address ) ||
-    //      ((*(BYTE**)&dest) >= g_highest_address)))
+#else
+    if (!(((*(BYTE**)&dest) <  g_lowest_address ) ||
+          ((*(BYTE**)&dest) >= g_highest_address)))
+#endif
     {
         Thread* pThread = GetThreadNULLOk();
 
diff --git a/src/coreclr/vm/object.h b/src/coreclr/vm/object.h
index 676268a7bd2..a055d5d71ef 100644
--- a/src/coreclr/vm/object.h
+++ b/src/coreclr/vm/object.h
@@ -157,8 +157,13 @@ class Object
     VOID SetMethodTableForUOHObject(MethodTable *pMT)
     {
         WRAPPER_NO_CONTRACT;
+#if FEATURE_SATORI_GC
+        // nothing extra needs to happen in Satori.
+        m_pMethTab = pMT;
+#else
         // This function must be used if the allocation occurs on a UOH heap, and the method table might be a collectible type
         ErectWriteBarrierForMT(&m_pMethTab, pMT);
+#endif
     }
 #endif //!DACCESS_COMPILE
 
diff --git a/src/coreclr/vm/threadsuspend.cpp b/src/coreclr/vm/threadsuspend.cpp
index f1539e464c9..2ddc2c3b120 100644
--- a/src/coreclr/vm/threadsuspend.cpp
+++ b/src/coreclr/vm/threadsuspend.cpp
@@ -3252,40 +3252,6 @@ COR_PRF_SUSPEND_REASON GCSuspendReasonToProfSuspendReason(ThreadSuspend::SUSPEND
 }
 #endif // PROFILING_SUPPORTED
 
-// exponential spinwait with an approximate time limit for waiting in microsecond range.
-void SpinWait(int usecLimit)
-{
-    LARGE_INTEGER li;
-    QueryPerformanceCounter(&li);
-    int64_t startTicks = li.QuadPart;
-
-    QueryPerformanceFrequency(&li);
-    int64_t ticksPerSecond = li.QuadPart;
-    int64_t endTicks = startTicks + (usecLimit * ticksPerSecond) / 1000000;
-
-#ifdef TARGET_UNIX
-    if (usecLimit > 10)
-    {
-            PAL_nanosleep(usecLimit * 1000);
-    }
-#endif // TARGET_UNIX
-
-    for (int i = 0; i < 30; i++)
-    {
-        QueryPerformanceCounter(&li);
-        int64_t currentTicks = li.QuadPart;
-        if (currentTicks > endTicks)
-        {
-            break;
-        }
-
-        for (int j = 0; j < (1 << i); j++)
-        {
-            System_YieldProcessor();
-        }
-    }
-}
-
 //************************************************************************************
 //
 // SuspendRuntime is responsible for ensuring that all managed threads reach a
diff --git a/src/libraries/System.Collections.Concurrent/src/System.Collections.Concurrent.csproj b/src/libraries/System.Collections.Concurrent/src/System.Collections.Concurrent.csproj
index 0f1a91d9afc..90b815473b8 100644
--- a/src/libraries/System.Collections.Concurrent/src/System.Collections.Concurrent.csproj
+++ b/src/libraries/System.Collections.Concurrent/src/System.Collections.Concurrent.csproj
@@ -13,24 +13,6 @@
     <Compile Include="System\Collections\Concurrent\CDSCollectionETWBCLProvider.cs" />
     <Compile Include="System\Collections\Concurrent\ConcurrentBag.cs" />
     <Compile Include="System\Collections\Concurrent\ConcurrentDictionary.cs" />
-
-    <Compile Include="System\Collections\Concurrent\ConcurrentDictionary\DictionaryImpl.cs" />
-    <Compile Include="System\Collections\Concurrent\ConcurrentDictionary\DictionaryImpl.SnapshotImpl.cs" />
-    <Compile Include="System\Collections\Concurrent\ConcurrentDictionary\DictionaryImpl`2.cs" />
-    <Compile Include="System\Collections\Concurrent\ConcurrentDictionary\DictionaryImpl`3.cs" />
-    <Compile Include="System\Collections\Concurrent\ConcurrentDictionary\DictionaryImplBoxed.cs" />
-    <Compile Include="System\Collections\Concurrent\ConcurrentDictionary\DictionaryImplInt.cs" />
-    <Compile Include="System\Collections\Concurrent\ConcurrentDictionary\DictionaryImplLong.cs" />
-    <Compile Include="System\Collections\Concurrent\ConcurrentDictionary\DictionaryImplNint.cs" />
-    <Compile Include="System\Collections\Concurrent\ConcurrentDictionary\DictionaryImplUint.cs" />
-    <Compile Include="System\Collections\Concurrent\ConcurrentDictionary\DictionaryImplUlong.cs" />
-    <Compile Include="System\Collections\Concurrent\ConcurrentDictionary\DictionaryImplNuint.cs" />
-    <Compile Include="System\Collections\Concurrent\ConcurrentDictionary\DictionaryImplRef.cs" />
-
-    <Compile Include="System\Collections\Concurrent\ConcurrentDictionary\Counter\CounterBase.cs" />
-    <Compile Include="System\Collections\Concurrent\ConcurrentDictionary\Counter\Counter32.cs" />
-    <Compile Include="System\Collections\Concurrent\ConcurrentDictionary\Counter\Counter64.cs" />
-
     <Compile Include="System\Collections\Concurrent\ConcurrentStack.cs" />
     <Compile Include="System\Collections\Concurrent\OrderablePartitioner.cs" />
     <Compile Include="System\Collections\Concurrent\Partitioner.cs" />
diff --git a/src/libraries/System.Collections.Concurrent/src/System/Collections/Concurrent/ConcurrentDictionary.cs b/src/libraries/System.Collections.Concurrent/src/System/Collections/Concurrent/ConcurrentDictionary.cs
index 682f04c67bf..038568cdc08 100644
--- a/src/libraries/System.Collections.Concurrent/src/System/Collections/Concurrent/ConcurrentDictionary.cs
+++ b/src/libraries/System.Collections.Concurrent/src/System/Collections/Concurrent/ConcurrentDictionary.cs
@@ -4,20 +4,16 @@
 #nullable disable
 #pragma warning disable CS8632 // The annotation for nullable reference types should only be used in code within a '#nullable' annotations context.
 
-using System;
-using System.Collections;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 using System.Runtime.CompilerServices;
-using static System.Collections.Concurrent.DictionaryImpl;
+using System.Threading;
 
 namespace System.Collections.Concurrent
 {
-    /// <summary>
-    /// Represents a thread-safe and lock-free collection of keys and values.
-    /// </summary>
+    /// <summary>Represents a thread-safe collection of keys and values.</summary>
     /// <typeparam name="TKey">The type of the keys in the dictionary.</typeparam>
     /// <typeparam name="TValue">The type of the values in the dictionary.</typeparam>
     /// <remarks>
@@ -28,27 +24,52 @@ namespace System.Collections.Concurrent
     [DebuggerDisplay("Count = {Count}")]
     public class ConcurrentDictionary<TKey, TValue> : IDictionary<TKey, TValue>, IDictionary, IReadOnlyDictionary<TKey, TValue> where TKey : notnull
     {
-        internal DictionaryImpl<TKey, TValue> _table;
-        internal uint _lastResizeTickMillis;
-        internal object _sweeperInstance;
-        internal int _sweepRequests;
+        /// <summary>Internal tables of the dictionary.</summary>
+        /// <remarks>
+        /// When using <see cref="_tables"/>, we must read the volatile _tables field into a local variable:
+        /// it is set to a new table on each table resize. Volatile.Reads on array elements then ensure that
+        /// we have a copy of the reference to tables._buckets[bucketNo]: this protects us from reading fields
+        /// ('_hashcode', '_key', '_value' and '_next') of different instances.
+        /// </remarks>
+        private volatile Tables _tables;
+        /// <summary>The maximum number of elements per lock before a resize operation is triggered.</summary>
+        private int _budget;
+        /// <summary>Whether to dynamically increase the size of the striped lock.</summary>
+        private readonly bool _growLockArray;
+        /// <summary>Whether a non-null comparer in <see cref="Tables._comparer"/> is the default comparer.</summary>
+        /// <remarks>
+        /// This is only used for reference types. It lets us use the key's GetHashCode directly rather than going indirectly
+        /// through the comparer.  It can't be used for Equals, as the key might implement IEquatable and employ different
+        /// equality semantics than the virtual Equals, however unlikely that may be. This field enables us to save an
+        /// interface dispatch when using the default comparer with a non-string reference type key, at the expense of an
+        /// extra branch when using a custom comparer with a reference type key.
+        /// </remarks>
+        private readonly bool _comparerIsDefaultForClasses;
 
         /// <summary>The default capacity, i.e. the initial # of buckets.</summary>
         /// <remarks>
         /// When choosing this value, we are making a trade-off between the size of a very small dictionary,
         /// and the number of resizes when constructing a large dictionary.
         /// </remarks>
-        private const int DefaultCapacity = 0;
+        private const int DefaultCapacity = 31;
 
-        /// <summary>Concurrency level is ignored. However it must be > 0.</summary>
-        private static int DefaultConcurrencyLevel => 1;
+        /// <summary>
+        /// The maximum size of the striped lock that will not be exceeded when locks are automatically
+        /// added as the dictionary grows.
+        /// </summary>
+        /// <remarks>
+        /// The user is allowed to exceed this limit by passing
+        /// a concurrency level larger than MaxLockNumber into the constructor.
+        /// </remarks>
+        private const int MaxLockNumber = 1024;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="ConcurrentDictionary{TKey,TValue}"/>
         /// class that is empty, has the default concurrency level, has the default initial capacity, and
         /// uses the default comparer for the key type.
         /// </summary>
-        public ConcurrentDictionary() : this(DefaultConcurrencyLevel, DefaultCapacity, null) { }
+        public ConcurrentDictionary()
+            : this(DefaultConcurrencyLevel, DefaultCapacity, growLockArray: true, null) { }
 
         /// <summary>
         /// Initializes a new instance of the <see cref="ConcurrentDictionary{TKey,TValue}"/>
@@ -60,7 +81,8 @@ namespace System.Collections.Concurrent
         /// <param name="capacity">The initial number of elements that the <see cref="ConcurrentDictionary{TKey,TValue}"/> can contain.</param>
         /// <exception cref="ArgumentOutOfRangeException"><paramref name="concurrencyLevel"/> is less than 1.</exception>
         /// <exception cref="ArgumentOutOfRangeException"> <paramref name="capacity"/> is less than 0.</exception>
-        public ConcurrentDictionary(int concurrencyLevel, int capacity) : this(concurrencyLevel, capacity, null) { }
+        public ConcurrentDictionary(int concurrencyLevel, int capacity)
+            : this(concurrencyLevel, capacity, growLockArray: false, null) { }
 
         /// <summary>
         /// Initializes a new instance of the <see cref="ConcurrentDictionary{TKey,TValue}"/>
@@ -71,7 +93,8 @@ namespace System.Collections.Concurrent
         /// cref="IEnumerable{T}"/> whose elements are copied to the new <see cref="ConcurrentDictionary{TKey,TValue}"/>.</param>
         /// <exception cref="ArgumentNullException"><paramref name="collection"/> is a null reference (Nothing in Visual Basic).</exception>
         /// <exception cref="ArgumentException"><paramref name="collection"/> contains one or more duplicate keys.</exception>
-        public ConcurrentDictionary(IEnumerable<KeyValuePair<TKey, TValue>> collection) : this(collection, null) { }
+        public ConcurrentDictionary(IEnumerable<KeyValuePair<TKey, TValue>> collection)
+            : this(DefaultConcurrencyLevel, collection, null) { }
 
         /// <summary>
         /// Initializes a new instance of the <see cref="ConcurrentDictionary{TKey,TValue}"/>
@@ -79,7 +102,8 @@ namespace System.Collections.Concurrent
         /// <see cref="IEqualityComparer{TKey}"/>.
         /// </summary>
         /// <param name="comparer">The <see cref="IEqualityComparer{TKey}"/> implementation to use when comparing keys.</param>
-        public ConcurrentDictionary(IEqualityComparer<TKey>? comparer) : this(DefaultConcurrencyLevel, DefaultCapacity, comparer) { }
+        public ConcurrentDictionary(IEqualityComparer<TKey>? comparer)
+            : this(DefaultConcurrencyLevel, DefaultCapacity, growLockArray: true, comparer) { }
 
         /// <summary>
         /// Initializes a new instance of the <see cref="ConcurrentDictionary{TKey,TValue}"/>
@@ -90,7 +114,7 @@ namespace System.Collections.Concurrent
         /// <param name="comparer">The <see cref="IEqualityComparer{TKey}"/> implementation to use when comparing keys.</param>
         /// <exception cref="ArgumentNullException"><paramref name="collection"/> is a null reference (Nothing in Visual Basic).</exception>
         public ConcurrentDictionary(IEnumerable<KeyValuePair<TKey, TValue>> collection, IEqualityComparer<TKey>? comparer)
-            : this(comparer)
+            : this(DefaultConcurrencyLevel, GetCapacityFromCollection(collection), comparer)
         {
             ArgumentNullException.ThrowIfNull(collection);
 
@@ -113,29 +137,13 @@ namespace System.Collections.Concurrent
         /// <exception cref="ArgumentOutOfRangeException"><paramref name="concurrencyLevel"/> is less than 1.</exception>
         /// <exception cref="ArgumentException"><paramref name="collection"/> contains one or more duplicate keys.</exception>
         public ConcurrentDictionary(int concurrencyLevel, IEnumerable<KeyValuePair<TKey, TValue>> collection, IEqualityComparer<TKey>? comparer)
-            : this(concurrencyLevel, DefaultCapacity, comparer)
+            : this(concurrencyLevel, GetCapacityFromCollection(collection), growLockArray: false, comparer)
         {
             ArgumentNullException.ThrowIfNull(collection);
 
             InitializeFromCollection(collection);
         }
 
-        private void InitializeFromCollection(IEnumerable<KeyValuePair<TKey, TValue>> collection)
-        {
-            foreach (KeyValuePair<TKey, TValue> pair in collection)
-            {
-                if (pair.Key is null)
-                {
-                    ThrowHelper.ThrowKeyNullException();
-                }
-
-                if (!this.TryAdd(pair.Key, pair.Value))
-                {
-                    throw new ArgumentException(SR.ConcurrentDictionary_SourceContainsDuplicateKeys);
-                }
-            }
-        }
-
         /// <summary>
         /// Initializes a new instance of the <see cref="ConcurrentDictionary{TKey,TValue}"/>
         /// class that is empty, has the specified concurrency level, has the specified initial capacity, and
@@ -146,115 +154,200 @@ namespace System.Collections.Concurrent
         /// <param name="comparer">The <see cref="IEqualityComparer{TKey}"/> implementation to use when comparing keys.</param>
         /// <exception cref="ArgumentOutOfRangeException"><paramref name="concurrencyLevel"/> is less than 1. -or- <paramref name="capacity"/> is less than 0.</exception>
         public ConcurrentDictionary(int concurrencyLevel, int capacity, IEqualityComparer<TKey>? comparer)
+            : this(concurrencyLevel, capacity, growLockArray: false, comparer)
         {
-            if (concurrencyLevel < 1)
+        }
+
+        internal ConcurrentDictionary(int concurrencyLevel, int capacity, bool growLockArray, IEqualityComparer<TKey>? comparer)
+        {
+            if (concurrencyLevel <= 0)
             {
                 if (concurrencyLevel != -1)
                 {
                     throw new ArgumentOutOfRangeException(nameof(concurrencyLevel), SR.ConcurrentDictionary_ConcurrencyLevelMustBePositiveOrNegativeOne);
                 }
+
+                concurrencyLevel = DefaultConcurrencyLevel;
             }
 
             ArgumentOutOfRangeException.ThrowIfNegative(capacity);
 
-            // add some extra so that filled to capacity would be at 50% density
-            capacity = Math.Max(capacity, capacity * 2);
-
-            if (!typeof(TKey).IsValueType)
+            // The capacity should be at least as large as the concurrency level. Otherwise, we would have locks that don't guard
+            // any buckets.  We also want it to be a prime.
+            if (capacity < concurrencyLevel)
             {
-                _table = new DictionaryImplRef<TKey, TKey, TValue>(capacity, this);
-                _table._keyComparer = comparer ?? EqualityComparer<TKey>.Default;
-                return;
+                capacity = concurrencyLevel;
+            }
+            capacity = HashHelpers.GetPrime(capacity);
+
+            var locks = new object[concurrencyLevel];
+            locks[0] = locks; // reuse array as the first lock object just to avoid an additional allocation
+            for (int i = 1; i < locks.Length; i++)
+            {
+                locks[i] = new object();
+            }
+
+            var countPerLock = new int[locks.Length];
+            var buckets = new VolatileNode[capacity];
+
+            // For reference types, we always want to store a comparer instance, either the one provided, or if
+            // one wasn't provided, the default (accessing EqualityComparer<TKey>.Default with shared generics
+            // on every dictionary access can add measurable overhead).  For value types, if no comparer is provided,
+            // or if the default is provided, we'd prefer to use EqualityComparer<TKey>.Default.Equals/GetHashCode
+            // on every use, enabling the JIT to devirtualize and possibly inline the operation.
+            if (typeof(TKey).IsValueType)
+            {
+                if (comparer is not null && // first check for null to avoid forcing default comparer instantiation unnecessarily
+                    ReferenceEquals(comparer, EqualityComparer<TKey>.Default))
+                {
+                    comparer = null;
+                }
             }
             else
             {
-                if (typeof(TKey) == typeof(int))
-                {
-                    if (comparer == null)
-                    {
-                        _table = Unsafe.As<DictionaryImpl<TKey, TValue>>(new DictionaryImplIntNoComparer<TValue>(capacity, Unsafe.As<ConcurrentDictionary<int, TValue>>(this)));
-                    }
-                    else
-                    {
-                        _table = Unsafe.As<DictionaryImpl<TKey, TValue>>(new DictionaryImplInt<TValue>(capacity, Unsafe.As<ConcurrentDictionary<int, TValue>>(this)));
-                        _table._keyComparer = comparer;
-                    }
-                    return;
-                }
+                comparer ??= EqualityComparer<TKey>.Default;
 
-                if (typeof(TKey) == typeof(uint))
+                // Special-case EqualityComparer<string>.Default, StringComparer.Ordinal, and StringComparer.OrdinalIgnoreCase.
+                // We use a non-randomized comparer for improved perf, falling back to a randomized comparer if the
+                // hash buckets become unbalanced.
+                if (typeof(TKey) == typeof(string) &&
+                    NonRandomizedStringEqualityComparer.GetStringComparer(comparer) is IEqualityComparer<string> stringComparer)
                 {
-                    if (comparer == null)
-                    {
-                        _table = Unsafe.As<DictionaryImpl<TKey, TValue>>(new DictionaryImplUintNoComparer<TValue>(capacity, Unsafe.As<ConcurrentDictionary<uint, TValue>>(this)));
-                    }
-                    else
-                    {
-                        _table = Unsafe.As<DictionaryImpl<TKey, TValue>>(new DictionaryImplUint<TValue>(capacity, Unsafe.As<ConcurrentDictionary<uint, TValue>>(this)));
-                        _table._keyComparer = comparer;
-                    }
-                    return;
+                    comparer = (IEqualityComparer<TKey>)stringComparer;
                 }
-
-                if (typeof(TKey) == typeof(long))
+                else if (ReferenceEquals(comparer, EqualityComparer<TKey>.Default))
                 {
-                    if (comparer == null)
-                    {
-                        _table = Unsafe.As<DictionaryImpl<TKey, TValue>>(new DictionaryImplLongNoComparer<TValue>(capacity, Unsafe.As<ConcurrentDictionary<long, TValue>>(this)));
-                    }
-                    else
-                    {
-                        _table = Unsafe.As<DictionaryImpl<TKey, TValue>>(new DictionaryImplLong<TValue>(capacity, Unsafe.As<ConcurrentDictionary<long, TValue>>(this)));
-                        _table._keyComparer = comparer;
-                    }
-                    return;
-                }
-
-                if (typeof(TKey) == typeof(ulong))
-                {
-                    if (comparer == null)
-                    {
-                        _table = Unsafe.As<DictionaryImpl<TKey, TValue>>(new DictionaryImplUlongNoComparer<TValue>(capacity, Unsafe.As<ConcurrentDictionary<ulong, TValue>>(this)));
-                    }
-                    else
-                    {
-                        _table = Unsafe.As<DictionaryImpl<TKey, TValue>>(new DictionaryImplUlong<TValue>(capacity, Unsafe.As<ConcurrentDictionary<ulong, TValue>>(this)));
-                        _table._keyComparer = comparer;
-                    }
-                    return;
-                }
-
-                if (typeof(TKey) == typeof(nint))
-                {
-                    if (comparer == null)
-                    {
-                        _table = Unsafe.As<DictionaryImpl<TKey, TValue>>(new DictionaryImplNintNoComparer<TValue>(capacity, Unsafe.As<ConcurrentDictionary<nint, TValue>>(this)));
-                    }
-                    else
-                    {
-                        _table = Unsafe.As<DictionaryImpl<TKey, TValue>>(new DictionaryImplNint<TValue>(capacity, Unsafe.As<ConcurrentDictionary<nint, TValue>>(this)));
-                        _table._keyComparer = comparer;
-                    }
-                    return;
-                }
-
-                if (typeof(TKey) == typeof(nuint))
-                {
-                    if (comparer == null)
-                    {
-                        _table = Unsafe.As<DictionaryImpl<TKey, TValue>>(new DictionaryImplNuintNoComparer<TValue>(capacity, Unsafe.As<ConcurrentDictionary<nuint, TValue>>(this)));
-                    }
-                    else
-                    {
-                        _table = Unsafe.As<DictionaryImpl<TKey, TValue>>(new DictionaryImplNuint<TValue>(capacity, Unsafe.As<ConcurrentDictionary<nuint, TValue>>(this)));
-                        _table._keyComparer = comparer;
-                    }
-                    return;
+                    _comparerIsDefaultForClasses = true;
                 }
             }
 
-            _table = new DictionaryImplBoxed<TKey, TValue>(capacity, this);
-            _table._keyComparer = comparer ?? EqualityComparer<TKey>.Default;
+            _tables = new Tables(buckets, locks, countPerLock, comparer);
+            _growLockArray = growLockArray;
+            _budget = buckets.Length / locks.Length;
+        }
+
+        /// <summary>
+        /// Gets an instance of a type that may be used to perform operations on a <see cref="ConcurrentDictionary{TKey, TValue}"/>
+        /// using a <typeparamref name="TAlternateKey"/> as a key instead of a <typeparamref name="TKey"/>.
+        /// </summary>
+        /// <typeparam name="TAlternateKey">The alternate type of a key for performing lookups.</typeparam>
+        /// <returns>The created lookup instance.</returns>
+        /// <exception cref="InvalidOperationException">This instance's comparer is not compatible with <typeparamref name="TAlternateKey"/>.</exception>
+        /// <remarks>
+        /// This instance must be using a comparer that implements <see cref="IAlternateEqualityComparer{TAlternateKey, TKey}"/> with
+        /// <typeparamref name="TAlternateKey"/> and <typeparamref name="TKey"/>. If it doesn't, an exception will be thrown.
+        /// </remarks>
+        public AlternateLookup<TAlternateKey> GetAlternateLookup<TAlternateKey>() where TAlternateKey : notnull, allows ref struct
+        {
+            if (!IsCompatibleKey<TAlternateKey>(_tables))
+            {
+                ThrowHelper.ThrowIncompatibleComparer();
+            }
+
+            return new AlternateLookup<TAlternateKey>(this);
+        }
+
+        /// <summary>
+        /// Gets an instance of a type that may be used to perform operations on a <see cref="ConcurrentDictionary{TKey, TValue}"/>
+        /// using a <typeparamref name="TAlternateKey"/> as a key instead of a <typeparamref name="TKey"/>.
+        /// </summary>
+        /// <typeparam name="TAlternateKey">The alternate type of a key for performing lookups.</typeparam>
+        /// <param name="lookup">The created lookup instance when the method returns true, or a default instance that should not be used if the method returns false.</param>
+        /// <returns>true if a lookup could be created; otherwise, false.</returns>
+        /// <remarks>
+        /// This instance must be using a comparer that implements <see cref="IAlternateEqualityComparer{TAlternateKey, TKey}"/> with
+        /// <typeparamref name="TAlternateKey"/> and <typeparamref name="TKey"/>. If it doesn't, the method will return false.
+        /// </remarks>
+        public bool TryGetAlternateLookup<TAlternateKey>(out AlternateLookup<TAlternateKey> lookup) where TAlternateKey : notnull, allows ref struct
+        {
+            if (IsCompatibleKey<TAlternateKey>(_tables))
+            {
+                lookup = new AlternateLookup<TAlternateKey>(this);
+                return true;
+            }
+
+            lookup = default;
+            return false;
+        }
+
+        /// <summary>Computes an initial capacity to use based on an initial seed collection.</summary>
+        /// <param name="collection">The collection with which to initially populate this dictionary.</param>
+        /// <returns>The capacity to use.</returns>
+        /// <remarks>
+        /// Growing is expensive, and we don't know if the caller plans to add additional items beyond this
+        /// initial collection, so we use the maximum of the collection's size and the default capacity. That way,
+        /// the initial capacity selected isn't pessimized by seeding it with a collection that happens to be
+        /// smaller.
+        /// </remarks>
+        private static int GetCapacityFromCollection(IEnumerable<KeyValuePair<TKey, TValue>> collection) =>
+            collection switch
+            {
+                ICollection<KeyValuePair<TKey, TValue>> c => Math.Max(DefaultCapacity, c.Count),
+                IReadOnlyCollection<KeyValuePair<TKey, TValue>> rc => Math.Max(DefaultCapacity, rc.Count),
+                _ => DefaultCapacity,
+            };
+
+        /// <summary>Computes the hash code for the specified key using the dictionary's comparer.</summary>
+        /// <param name="comparer">
+        /// The comparer. It's passed in to avoid having to look it up via a volatile read on <see cref="_tables"/>;
+        /// such a comparer could also be incorrect if the table upgraded comparer concurrently.
+        /// </param>
+        /// <param name="key">The key for which to compute the hash code.</param>
+        /// <returns>The hash code of the key.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private int GetHashCode(IEqualityComparer<TKey>? comparer, TKey key)
+        {
+            if (typeof(TKey).IsValueType)
+            {
+                return comparer is null ? key.GetHashCode() : comparer.GetHashCode(key);
+            }
+
+            Debug.Assert(comparer is not null);
+            return _comparerIsDefaultForClasses ? key.GetHashCode() : comparer.GetHashCode(key);
+        }
+
+        /// <summary>Determines whether the specified key and the key stored in the specified node are equal.</summary>
+        /// <param name="comparer">
+        /// The comparer. It's passed in to avoid having to look it up via a volatile read on <see cref="_tables"/>;
+        /// such a comparer could also be incorrect if the table upgraded comparer concurrently.
+        /// </param>
+        /// <param name="node">The node containing the key to compare.</param>
+        /// <param name="key">The other key to compare.</param>
+        /// <returns>true if the keys are equal; otherwise, false.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static bool NodeEqualsKey(IEqualityComparer<TKey>? comparer, Node node, TKey key)
+        {
+            if (typeof(TKey).IsValueType)
+            {
+                return comparer is null ?
+                    EqualityComparer<TKey>.Default.Equals(node._key, key) :
+                    comparer.Equals(node._key, key);
+            }
+
+            Debug.Assert(comparer is not null);
+            return comparer.Equals(node._key, key);
+        }
+
+        private void InitializeFromCollection(IEnumerable<KeyValuePair<TKey, TValue>> collection)
+        {
+            foreach (KeyValuePair<TKey, TValue> pair in collection)
+            {
+                if (pair.Key is null)
+                {
+                    ThrowHelper.ThrowKeyNullException();
+                }
+
+                if (!TryAddInternal(_tables, pair.Key, null, pair.Value, updateIfExists: false, acquireLock: false, out _))
+                {
+                    throw new ArgumentException(SR.ConcurrentDictionary_SourceContainsDuplicateKeys);
+                }
+            }
+
+            if (_budget == 0)
+            {
+                Tables tables = _tables;
+                _budget = tables._buckets.Length / tables._locks.Length;
+            }
         }
 
         /// <summary>
@@ -275,8 +368,7 @@ namespace System.Collections.Concurrent
                 ThrowHelper.ThrowKeyNullException();
             }
 
-            TValue oldVal = default;
-            return _table.PutIfMatch(key, value, ref oldVal, ValueMatch.NullOrDead);
+            return TryAddInternal(_tables, key, null, value, updateIfExists: false, acquireLock: true, out _);
         }
 
         /// <summary>
@@ -285,18 +377,7 @@ namespace System.Collections.Concurrent
         /// <param name="key">The key to locate in the <see cref="ConcurrentDictionary{TKey, TValue}"/>.</param>
         /// <returns>true if the <see cref="ConcurrentDictionary{TKey, TValue}"/> contains an element with the specified key; otherwise, false.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="key"/> is a null reference (Nothing in Visual Basic).</exception>
-        public bool ContainsKey(TKey key)
-        {
-            if (key is null)
-            {
-                ThrowHelper.ThrowKeyNullException();
-            }
-
-            object oldValObj = _table.TryGetValue(key);
-            Debug.Assert(!(oldValObj is Prime));
-
-            return oldValObj != null;
-        }
+        public bool ContainsKey(TKey key) => TryGetValue(key, out _);
 
         /// <summary>
         /// Attempts to remove and return the value with the specified key from the <see cref="ConcurrentDictionary{TKey, TValue}"/>.
@@ -316,8 +397,7 @@ namespace System.Collections.Concurrent
                 ThrowHelper.ThrowKeyNullException();
             }
 
-            value = default;
-            return _table.RemoveIfMatch(key, ref value, ValueMatch.NotNullOrDead);
+            return TryRemoveInternal(key, out value, matchValue: false, default);
         }
 
         /// <summary>Removes a key and value from the dictionary.</summary>
@@ -342,33 +422,82 @@ namespace System.Collections.Concurrent
                 ThrowHelper.ThrowArgumentNullException(nameof(item), SR.ConcurrentDictionary_ItemKeyIsNull);
             }
 
-            TValue oldVal = item.Value;
-            return _table.RemoveIfMatch(item.Key, ref oldVal, ValueMatch.OldValue);
+            return TryRemoveInternal(item.Key, out _, matchValue: true, item.Value);
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static TValue FromObjectValue(object obj)
+        /// <summary>
+        /// Removes the specified key from the dictionary if it exists and returns its associated value.
+        /// If matchValue flag is set, the key will be removed only if is associated with a particular
+        /// value.
+        /// </summary>
+        /// <param name="key">The key to search for and remove if it exists.</param>
+        /// <param name="value">The variable into which the removed value, if found, is stored.</param>
+        /// <param name="matchValue">Whether removal of the key is conditional on its value.</param>
+        /// <param name="oldValue">The conditional value to compare against if <paramref name="matchValue"/> is true</param>
+        private bool TryRemoveInternal(TKey key, [MaybeNullWhen(false)] out TValue value, bool matchValue, TValue? oldValue)
         {
-            // regular value type
-            if (default(TValue) != null)
-            {
-                return Unsafe.As<Boxed<TValue>>(obj).Value;
-            }
+            Tables tables = _tables;
 
-            // null
-            if (obj == NULLVALUE)
-            {
-                return default(TValue);
-            }
+            IEqualityComparer<TKey>? comparer = tables._comparer;
+            int hashcode = GetHashCode(comparer, key);
 
-            // ref type
-            if (!typeof(TValue).IsValueType)
+            while (true)
             {
-                return Unsafe.As<object, TValue>(ref obj);
-            }
+                object[] locks = tables._locks;
+                ref Node? bucket = ref GetBucketAndLock(tables, hashcode, out uint lockNo);
 
-            // nullable
-            return (TValue)obj;
+                lock (locks[lockNo])
+                {
+                    // If the table just got resized, we may not be holding the right lock, and must retry.
+                    // This should be a rare occurrence.
+                    if (tables != _tables)
+                    {
+                        tables = _tables;
+                        if (!ReferenceEquals(comparer, tables._comparer))
+                        {
+                            comparer = tables._comparer;
+                            hashcode = GetHashCode(comparer, key);
+                        }
+                        continue;
+                    }
+
+                    Node? prev = null;
+                    for (Node? curr = bucket; curr is not null; curr = curr._next)
+                    {
+                        Debug.Assert((prev is null && curr == bucket) || prev!._next == curr);
+
+                        if (hashcode == curr._hashcode && NodeEqualsKey(comparer, curr, key))
+                        {
+                            if (matchValue)
+                            {
+                                bool valuesMatch = EqualityComparer<TValue>.Default.Equals(oldValue, curr._value);
+                                if (!valuesMatch)
+                                {
+                                    value = default;
+                                    return false;
+                                }
+                            }
+
+                            if (prev is null)
+                            {
+                                Volatile.Write(ref bucket, curr._next);
+                            }
+                            else
+                            {
+                                prev._next = curr._next;
+                            }
+
+                            value = curr._value;
+                            tables._countPerLock[lockNo]--;
+                            return true;
+                        }
+                        prev = curr;
+                    }
+                }
+
+                value = default;
+                return false;
+            }
         }
 
         /// <summary>
@@ -389,20 +518,71 @@ namespace System.Collections.Concurrent
                 ThrowHelper.ThrowKeyNullException();
             }
 
-            object oldValObj = _table.TryGetValue(key);
+            Tables tables = _tables;
 
-            Debug.Assert(!(oldValObj is Prime));
-
-            if (oldValObj != null)
+            IEqualityComparer<TKey>? comparer = tables._comparer;
+            if (typeof(TKey).IsValueType && // comparer can only be null for value types; enable JIT to eliminate entire if block for ref types
+                comparer is null)
             {
-                value = FromObjectValue(oldValObj);
-                return true;
+                int hashcode = key.GetHashCode();
+                for (Node? n = GetBucket(tables, hashcode); n is not null; n = n._next)
+                {
+                    if (hashcode == n._hashcode && EqualityComparer<TKey>.Default.Equals(n._key, key))
+                    {
+                        value = n._value;
+                        return true;
+                    }
+                }
             }
             else
             {
-                value = default(TValue);
-                return false;
+                Debug.Assert(comparer is not null);
+                int hashcode = GetHashCode(comparer, key);
+                for (Node? n = GetBucket(tables, hashcode); n is not null; n = n._next)
+                {
+                    if (hashcode == n._hashcode && comparer.Equals(n._key, key))
+                    {
+                        value = n._value;
+                        return true;
+                    }
+                }
             }
+
+            value = default;
+            return false;
+        }
+
+        private static bool TryGetValueInternal(Tables tables, TKey key, int hashcode, [MaybeNullWhen(false)] out TValue value)
+        {
+            IEqualityComparer<TKey>? comparer = tables._comparer;
+
+            if (typeof(TKey).IsValueType && // comparer can only be null for value types; enable JIT to eliminate entire if block for ref types
+                comparer is null)
+            {
+                for (Node? n = GetBucket(tables, hashcode); n is not null; n = n._next)
+                {
+                    if (hashcode == n._hashcode && EqualityComparer<TKey>.Default.Equals(n._key, key))
+                    {
+                        value = n._value;
+                        return true;
+                    }
+                }
+            }
+            else
+            {
+                Debug.Assert(comparer is not null);
+                for (Node? n = GetBucket(tables, hashcode); n is not null; n = n._next)
+                {
+                    if (hashcode == n._hashcode && comparer.Equals(n._key, key))
+                    {
+                        value = n._value;
+                        return true;
+                    }
+                }
+            }
+
+            value = default;
+            return false;
         }
 
         /// <summary>
@@ -427,14 +607,127 @@ namespace System.Collections.Concurrent
                 ThrowHelper.ThrowKeyNullException();
             }
 
-            TValue oldVal = comparisonValue;
-            return _table.PutIfMatch(key, newValue, ref oldVal, ValueMatch.OldValue);
+            return TryUpdateInternal(_tables, key, null, newValue, comparisonValue);
+        }
+
+        /// <summary>
+        /// Updates the value associated with <paramref name="key"/> to <paramref name="newValue"/> if the existing value is equal
+        /// to <paramref name="comparisonValue"/>.
+        /// </summary>
+        /// <param name="tables">The tables that were used to create the hash code.</param>
+        /// <param name="key">The key whose value is compared with <paramref name="comparisonValue"/> and
+        /// possibly replaced.</param>
+        /// <param name="nullableHashcode">The hashcode computed for <paramref name="key"/>.</param>
+        /// <param name="newValue">The value that replaces the value of the element with <paramref
+        /// name="key"/> if the comparison results in equality.</param>
+        /// <param name="comparisonValue">The value that is compared to the value of the element with
+        /// <paramref name="key"/>.</param>
+        /// <returns>
+        /// true if the value with <paramref name="key"/> was equal to <paramref name="comparisonValue"/> and
+        /// replaced with <paramref name="newValue"/>; otherwise, false.
+        /// </returns>
+        /// <exception cref="ArgumentNullException"><paramref name="key"/> is a null reference.</exception>
+        private bool TryUpdateInternal(Tables tables, TKey key, int? nullableHashcode, TValue newValue, TValue comparisonValue)
+        {
+            IEqualityComparer<TKey>? comparer = tables._comparer;
+
+            int hashcode = nullableHashcode ?? GetHashCode(comparer, key);
+            Debug.Assert(nullableHashcode is null || nullableHashcode == hashcode);
+
+            EqualityComparer<TValue> valueComparer = EqualityComparer<TValue>.Default;
+
+            while (true)
+            {
+                object[] locks = tables._locks;
+                ref Node? bucket = ref GetBucketAndLock(tables, hashcode, out uint lockNo);
+
+                lock (locks[lockNo])
+                {
+                    // If the table just got resized, we may not be holding the right lock, and must retry.
+                    // This should be a rare occurrence.
+                    if (tables != _tables)
+                    {
+                        tables = _tables;
+                        if (!ReferenceEquals(comparer, tables._comparer))
+                        {
+                            comparer = tables._comparer;
+                            hashcode = GetHashCode(comparer, key);
+                        }
+                        continue;
+                    }
+
+                    // Try to find this key in the bucket
+                    Node? prev = null;
+                    for (Node? node = bucket; node is not null; node = node._next)
+                    {
+                        Debug.Assert((prev is null && node == bucket) || prev!._next == node);
+                        if (hashcode == node._hashcode && NodeEqualsKey(comparer, node, key))
+                        {
+                            if (valueComparer.Equals(node._value, comparisonValue))
+                            {
+                                // Do the reference type check up front to handle many cases of shared generics.
+                                // If TValue is a value type then the field's value here can be baked in. Otherwise,
+                                // for the remaining shared generic cases the field access here would disqualify inlining,
+                                // so the following check cannot be factored out of TryAddInternal/TryUpdateInternal.
+                                if (!typeof(TValue).IsValueType || ConcurrentDictionaryTypeProps<TValue>.IsWriteAtomic)
+                                {
+                                    node._value = newValue;
+                                }
+                                else
+                                {
+                                    var newNode = new Node(node._key, newValue, hashcode, node._next);
+
+                                    if (prev is null)
+                                    {
+                                        Volatile.Write(ref bucket, newNode);
+                                    }
+                                    else
+                                    {
+                                        prev._next = newNode;
+                                    }
+                                }
+
+                                return true;
+                            }
+
+                            return false;
+                        }
+
+                        prev = node;
+                    }
+
+                    // didn't find the key
+                    return false;
+                }
+            }
         }
 
         /// <summary>
         /// Removes all keys and values from the <see cref="ConcurrentDictionary{TKey,TValue}"/>.
         /// </summary>
-        public void Clear() => _table.Clear();
+        public void Clear()
+        {
+            int locksAcquired = 0;
+            try
+            {
+                AcquireAllLocks(ref locksAcquired);
+
+                // If the dictionary is already empty, then there's nothing to clear.
+                if (AreAllBucketsEmpty())
+                {
+                    return;
+                }
+
+                Tables tables = _tables;
+                var newTables = new Tables(new VolatileNode[HashHelpers.GetPrime(DefaultCapacity)], tables._locks, new int[tables._countPerLock.Length], tables._comparer);
+                _tables = newTables;
+                _budget = Math.Max(1, newTables._buckets.Length / newTables._locks.Length);
+            }
+            finally
+            {
+                ReleaseLocks(locksAcquired);
+            }
+        }
 
         /// <summary>
         /// Copies the elements of the <see cref="ICollection{T}"/> to an array of type <see cref="KeyValuePair{TKey,TValue}"/>,
@@ -454,7 +747,27 @@ namespace System.Collections.Concurrent
         /// </exception>
         void ICollection<KeyValuePair<TKey, TValue>>.CopyTo(KeyValuePair<TKey, TValue>[] array, int index)
         {
-            CopyToPairs(array, index);
+            ArgumentNullException.ThrowIfNull(array);
+
+            ArgumentOutOfRangeException.ThrowIfNegative(index);
+
+            int locksAcquired = 0;
+            try
+            {
+                AcquireAllLocks(ref locksAcquired);
+
+                int count = GetCountNoLocks();
+                if (array.Length - count < index)
+                {
+                    throw new ArgumentException(SR.ConcurrentDictionary_ArrayNotLargeEnough);
+                }
+
+                CopyToPairs(array, index);
+            }
+            finally
+            {
+                ReleaseLocks(locksAcquired);
+            }
         }
 
         /// <summary>
@@ -465,103 +778,68 @@ namespace System.Collections.Concurrent
         /// </returns>
         public KeyValuePair<TKey, TValue>[] ToArray()
         {
-            var snapshot = _table.GetSnapshot();
-
-            int count = snapshot.Count;
-            if (count == 0)
+            int locksAcquired = 0;
+            try
             {
-                return Array.Empty<KeyValuePair<TKey, TValue>>();
-            }
+                AcquireAllLocks(ref locksAcquired);
 
-            var array = new KeyValuePair<TKey, TValue>[count];
-            int idx = 0;
-            while (snapshot.MoveNext() && idx < array.Length)
+                int count = GetCountNoLocks();
+                if (count == 0)
+                {
+                    return Array.Empty<KeyValuePair<TKey, TValue>>();
+                }
+
+                var array = new KeyValuePair<TKey, TValue>[count];
+                CopyToPairs(array, 0);
+                return array;
+            }
+            finally
             {
-                array[idx++] = snapshot.Current;
+                ReleaseLocks(locksAcquired);
             }
-
-            if (idx != array.Length)
-            {
-                Array.Resize(ref array, idx);
-            }
-
-            return array;
         }
 
-        /// <summary>Copy dictionary contents to an array.</summary>
+        /// <summary>Copy dictionary contents to an array - shared implementation between ToArray and CopyTo.</summary>
+        /// <remarks>Important: the caller must hold all locks in _locks before calling CopyToPairs.</remarks>
         private void CopyToPairs(KeyValuePair<TKey, TValue>[] array, int index)
         {
-            ArgumentNullException.ThrowIfNull(array);
-
-            ArgumentOutOfRangeException.ThrowIfNegative(index);
-
-            var length = array.Length;
-            if (index > length)
+            foreach (VolatileNode bucket in _tables._buckets)
             {
-                throw new ArgumentException(SR.ConcurrentDictionary_ArrayNotLargeEnough);
-            }
-
-            foreach (var entry in this)
-            {
-                if ((uint)index < (uint)length)
+                for (Node? current = bucket._node; current is not null; current = current._next)
                 {
-                    array[index++] = entry;
-                }
-                else
-                {
-                    throw new ArgumentException(SR.ConcurrentDictionary_ArrayNotLargeEnough);
+                    array[index] = new KeyValuePair<TKey, TValue>(current._key, current._value);
+                    Debug.Assert(index < int.MaxValue, "This method should only be called when there's no overflow risk");
+                    index++;
                 }
             }
         }
 
-        /// <summary>Copy dictionary contents to an array.</summary>
+        /// <summary>Copy dictionary contents to an array - shared implementation between ToArray and CopyTo.</summary>
+        /// <remarks>Important: the caller must hold all locks in _locks before calling CopyToPairs.</remarks>
         private void CopyToEntries(DictionaryEntry[] array, int index)
         {
-            ArgumentNullException.ThrowIfNull(array);
-
-            ArgumentOutOfRangeException.ThrowIfNegative(index);
-
-            var length = array.Length;
-            if (index >= length)
+            foreach (VolatileNode bucket in _tables._buckets)
             {
-                throw new ArgumentException(SR.ConcurrentDictionary_ArrayNotLargeEnough);
-            }
-
-            foreach (var entry in this)
-            {
-                if ((uint)index < (uint)length)
+                for (Node? current = bucket._node; current is not null; current = current._next)
                 {
-                    array[index++] = new DictionaryEntry(entry.Key, entry.Value);
-                }
-                else
-                {
-                    throw new ArgumentException(SR.ConcurrentDictionary_ArrayNotLargeEnough);
+                    array[index] = new DictionaryEntry(current._key, current._value);
+                    Debug.Assert(index < int.MaxValue, "This method should only be called when there's no overflow risk");
+                    index++;
                 }
             }
         }
 
-        /// <summary>Copy dictionary contents to an array.</summary>
+        /// <summary>Copy dictionary contents to an array - shared implementation between ToArray and CopyTo.</summary>
+        /// <remarks>Important: the caller must hold all locks in _locks before calling CopyToPairs.</remarks>
         private void CopyToObjects(object[] array, int index)
         {
-            ArgumentNullException.ThrowIfNull(array);
-
-            ArgumentOutOfRangeException.ThrowIfNegative(index);
-
-            var length = array.Length;
-            if (index > length)
+            foreach (VolatileNode bucket in _tables._buckets)
             {
-                throw new ArgumentException(SR.ConcurrentDictionary_ArrayNotLargeEnough);
-            }
-
-            foreach (var entry in this)
-            {
-                if ((uint)index < (uint)length)
+                for (Node? current = bucket._node; current is not null; current = current._next)
                 {
-                    array[index++] = entry;
-                }
-                else
-                {
-                    throw new ArgumentException(SR.ConcurrentDictionary_ArrayNotLargeEnough);
+                    array[index] = new KeyValuePair<TKey, TValue>(current._key, current._value);
+                    Debug.Assert(index < int.MaxValue, "This method should only be called when there's no overflow risk");
+                    index++;
                 }
             }
         }
@@ -575,9 +853,223 @@ namespace System.Collections.Concurrent
         /// of the dictionary.  The contents exposed through the enumerator may contain modifications
         /// made to the dictionary after <see cref="GetEnumerator"/> was called.
         /// </remarks>
-        public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator()
+        public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator() => new Enumerator(this);
+
+        /// <summary>Provides an enumerator implementation for the dictionary.</summary>
+        private sealed class Enumerator : IEnumerator<KeyValuePair<TKey, TValue>>
         {
-            return new SnapshotEnumerator(_table.GetSnapshot());
+            // Provides a manually-implemented version of (approximately) this iterator:
+            //     VolatileNodeWrapper[] buckets = _tables._buckets;
+            //     for (int i = 0; i < buckets.Length; i++)
+            //         for (Node? current = buckets[i]._node; current is not null; current = current._next)
+            //             yield return new KeyValuePair<TKey, TValue>(current._key, current._value);
+
+            private readonly ConcurrentDictionary<TKey, TValue> _dictionary;
+
+            private ConcurrentDictionary<TKey, TValue>.VolatileNode[]? _buckets;
+            private Node? _node;
+            private int _i;
+            private int _state;
+
+            private const int StateUninitialized = 0;
+            private const int StateOuterloop = 1;
+            private const int StateInnerLoop = 2;
+            private const int StateDone = 3;
+
+            public Enumerator(ConcurrentDictionary<TKey, TValue> dictionary)
+            {
+                _dictionary = dictionary;
+                _i = -1;
+            }
+
+            public KeyValuePair<TKey, TValue> Current { get; private set; }
+
+            object IEnumerator.Current => Current;
+
+            public void Reset()
+            {
+                _buckets = null;
+                _node = null;
+                Current = default;
+                _i = -1;
+                _state = StateUninitialized;
+            }
+
+            public void Dispose() { }
+
+            public bool MoveNext()
+            {
+                switch (_state)
+                {
+                    case StateUninitialized:
+                        _buckets = _dictionary._tables._buckets;
+                        _i = -1;
+                        goto case StateOuterloop;
+
+                    case StateOuterloop:
+                        ConcurrentDictionary<TKey, TValue>.VolatileNode[]? buckets = _buckets;
+                        Debug.Assert(buckets is not null);
+
+                        int i = ++_i;
+                        if ((uint)i < (uint)buckets.Length)
+                        {
+                            _node = buckets[i]._node;
+                            _state = StateInnerLoop;
+                            goto case StateInnerLoop;
+                        }
+                        goto default;
+
+                    case StateInnerLoop:
+                        if (_node is Node node)
+                        {
+                            Current = new KeyValuePair<TKey, TValue>(node._key, node._value);
+                            _node = node._next;
+                            return true;
+                        }
+                        goto case StateOuterloop;
+
+                    default:
+                        _state = StateDone;
+                        return false;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Shared internal implementation for inserts and updates.
+        /// If key exists, we always return false; and if updateIfExists == true we force update with value;
+        /// If key doesn't exist, we always add value and return true;
+        /// </summary>
+        private bool TryAddInternal(Tables tables, TKey key, int? nullableHashcode, TValue value, bool updateIfExists, bool acquireLock, out TValue resultingValue)
+        {
+            IEqualityComparer<TKey>? comparer = tables._comparer;
+
+            int hashcode = nullableHashcode ?? GetHashCode(comparer, key);
+            Debug.Assert(nullableHashcode is null || nullableHashcode == hashcode);
+
+            while (true)
+            {
+                object[] locks = tables._locks;
+                ref Node? bucket = ref GetBucketAndLock(tables, hashcode, out uint lockNo);
+
+                bool resizeDesired = false;
+                bool forceRehash = false;
+                bool lockTaken = false;
+                try
+                {
+                    if (acquireLock)
+                    {
+                        Monitor.Enter(locks[lockNo], ref lockTaken);
+                    }
+
+                    // If the table just got resized, we may not be holding the right lock, and must retry.
+                    // This should be a rare occurrence.
+                    if (tables != _tables)
+                    {
+                        tables = _tables;
+                        if (!ReferenceEquals(comparer, tables._comparer))
+                        {
+                            comparer = tables._comparer;
+                            hashcode = GetHashCode(comparer, key);
+                        }
+                        continue;
+                    }
+
+                    // Try to find this key in the bucket
+                    uint collisionCount = 0;
+                    Node? prev = null;
+                    for (Node? node = bucket; node is not null; node = node._next)
+                    {
+                        Debug.Assert((prev is null && node == bucket) || prev!._next == node);
+                        if (hashcode == node._hashcode && NodeEqualsKey(comparer, node, key))
+                        {
+                            // The key was found in the dictionary. If updates are allowed, update the value for that key.
+                            // We need to create a new node for the update, in order to support TValue types that cannot
+                            // be written atomically, since lock-free reads may be happening concurrently.
+                            if (updateIfExists)
+                            {
+                                // Do the reference type check up front to handle many cases of shared generics.
+                                // If TValue is a value type then the field's value here can be baked in. Otherwise,
+                                // for the remaining shared generic cases the field access here would disqualify inlining,
+                                // so the following check cannot be factored out of TryAddInternal/TryUpdateInternal.
+                                if (!typeof(TValue).IsValueType || ConcurrentDictionaryTypeProps<TValue>.IsWriteAtomic)
+                                {
+                                    node._value = value;
+                                }
+                                else
+                                {
+                                    var newNode = new Node(node._key, value, hashcode, node._next);
+                                    if (prev is null)
+                                    {
+                                        Volatile.Write(ref bucket, newNode);
+                                    }
+                                    else
+                                    {
+                                        prev._next = newNode;
+                                    }
+                                }
+                                resultingValue = value;
+                            }
+                            else
+                            {
+                                resultingValue = node._value;
+                            }
+                            return false;
+                        }
+                        prev = node;
+                        if (!typeof(TKey).IsValueType) // this is only relevant to strings, and we can avoid this code for all value types
+                        {
+                            collisionCount++;
+                        }
+                    }
+
+                    // The key was not found in the bucket. Insert the key-value pair.
+                    var resultNode = new Node(key, value, hashcode, bucket);
+                    Volatile.Write(ref bucket, resultNode);
+                    checked
+                    {
+                        tables._countPerLock[lockNo]++;
+                    }
+
+                    // If the number of elements guarded by this lock has exceeded the budget, resize the bucket table.
+                    // It is also possible that GrowTable will increase the budget but won't resize the bucket table.
+                    // That happens if the bucket table is found to be poorly utilized due to a bad hash function.
+                    if (tables._countPerLock[lockNo] > _budget)
+                    {
+                        resizeDesired = true;
+                    }
+
+                    // We similarly want to invoke redo the tables if we're using a non-randomized comparer
+                    // and need to upgrade to a randomized comparer due to too many collisions.
+                    if (!typeof(TKey).IsValueType &&
+                        collisionCount > HashHelpers.HashCollisionThreshold &&
+                        comparer is NonRandomizedStringEqualityComparer)
+                    {
+                        forceRehash = true;
+                    }
+                }
+                finally
+                {
+                    if (lockTaken)
+                    {
+                        Monitor.Exit(locks[lockNo]);
+                    }
+                }
+
+                // The fact that we got here means that we just performed an insertion. If necessary, we will grow the table.
+                //
+                // Concurrency notes:
+                // - Notice that we are not holding any locks at when calling GrowTable. This is necessary to prevent deadlocks.
+                // - As a result, it is possible that GrowTable will be called unnecessarily. But, GrowTable will obtain lock 0
+                //   and then verify that the table we passed to it as the argument is still the current table.
+                if (resizeDesired | forceRehash)
+                {
+                    GrowTable(tables, resizeDesired, forceRehash);
+                }
+
+                resultingValue = value;
+                return true;
+            }
         }
 
         /// <summary>Gets or sets the value associated with the specified key.</summary>
@@ -596,21 +1088,11 @@ namespace System.Collections.Concurrent
         {
             get
             {
-                if (key is null)
+                if (!TryGetValue(key, out TValue? value))
                 {
-                    ThrowHelper.ThrowKeyNullException();
+                    ThrowKeyNotFoundException(key);
                 }
-
-                object oldValObj = _table.TryGetValue(key);
-                Debug.Assert(!(oldValObj is Prime));
-                if (oldValObj != null)
-                {
-                    return FromObjectValue(oldValObj);
-                }
-
-                ThrowKeyNotFoundException(key);
-                // call above does not return
-                while (true) ;
+                return value;
             }
             set
             {
@@ -619,8 +1101,7 @@ namespace System.Collections.Concurrent
                     ThrowHelper.ThrowKeyNullException();
                 }
 
-                TValue oldVal = default;
-                _table.PutIfMatch(key, value, ref oldVal, ValueMatch.Any);
+                TryAddInternal(_tables, key, null, value, updateIfExists: true, acquireLock: true, out _);
             }
         }
 
@@ -628,7 +1109,7 @@ namespace System.Collections.Concurrent
         /// <remarks>Separate from ThrowHelper to avoid boxing at call site while reusing this generic instantiation.</remarks>
         [DoesNotReturn]
         private static void ThrowKeyNotFoundException(TKey key) =>
-                throw new KeyNotFoundException(SR.Format(SR.Arg_KeyNotFoundWithKey, key.ToString()));
+            throw new KeyNotFoundException(SR.Format(SR.Arg_KeyNotFoundWithKey, key.ToString()));
 
         /// <summary>
         /// Gets the <see cref="IEqualityComparer{TKey}" />
@@ -645,7 +1126,23 @@ namespace System.Collections.Concurrent
         /// generic interface by using a constructor that accepts a comparer parameter;
         /// if you do not specify one, the default generic equality comparer <see cref="EqualityComparer{TKey}.Default" /> is used.
         /// </remarks>
-        public IEqualityComparer<TKey> Comparer => _table._keyComparer ?? EqualityComparer<TKey>.Default;
+        public IEqualityComparer<TKey> Comparer
+        {
+            get
+            {
+                IEqualityComparer<TKey>? comparer = _tables._comparer;
+
+                if (typeof(TKey) == typeof(string))
+                {
+                    if ((comparer as NonRandomizedStringEqualityComparer)?.GetUnderlyingEqualityComparer() is IEqualityComparer<string> ec)
+                    {
+                        return (IEqualityComparer<TKey>)ec;
+                    }
+                }
+
+                return comparer ?? EqualityComparer<TKey>.Default;
+            }
+        }
 
         /// <summary>
         /// Gets the number of key/value pairs contained in the <see
@@ -658,7 +1155,36 @@ namespace System.Collections.Concurrent
         /// <remarks>Count has snapshot semantics and represents the number of items in the <see
         /// cref="ConcurrentDictionary{TKey,TValue}"/>
         /// at the moment when Count was accessed.</remarks>
-        public int Count => _table.Count;
+        public int Count
+        {
+            get
+            {
+                int locksAcquired = 0;
+                try
+                {
+                    AcquireAllLocks(ref locksAcquired);
+
+                    return GetCountNoLocks();
+                }
+                finally
+                {
+                    ReleaseLocks(locksAcquired);
+                }
+            }
+        }
+
+        /// <summary>Gets the number of pairs stored in the dictionary.</summary>
+        /// <remarks>This assumes all of the dictionary's locks have been taken, or else the result may not be accurate.</remarks>
+        private int GetCountNoLocks()
+        {
+            int count = 0;
+            foreach (int value in _tables._countPerLock)
+            {
+                checked { count += value; }
+            }
+
+            return count;
+        }
 
         /// <summary>
         /// Adds a key/value pair to the <see cref="ConcurrentDictionary{TKey,TValue}"/>
@@ -677,11 +1203,27 @@ namespace System.Collections.Concurrent
         /// if the key was not in the dictionary.</returns>
         public TValue GetOrAdd(TKey key, Func<TKey, TValue> valueFactory)
         {
-            ArgumentNullException.ThrowIfNull(key);
+            if (key is null)
+            {
+                ThrowHelper.ThrowKeyNullException();
+            }
 
-            ArgumentNullException.ThrowIfNull(valueFactory);
+            if (valueFactory is null)
+            {
+                ThrowHelper.ThrowArgumentNullException(nameof(valueFactory));
+            }
 
-            return _table.GetOrAdd(key, valueFactory);
+            Tables tables = _tables;
+
+            IEqualityComparer<TKey>? comparer = tables._comparer;
+            int hashcode = GetHashCode(comparer, key);
+
+            if (!TryGetValueInternal(tables, key, hashcode, out TValue? resultingValue))
+            {
+                TryAddInternal(tables, key, hashcode, valueFactory(key), updateIfExists: false, acquireLock: true, out resultingValue);
+            }
+
+            return resultingValue;
         }
 
         /// <summary>
@@ -708,28 +1250,22 @@ namespace System.Collections.Concurrent
                 ThrowHelper.ThrowKeyNullException();
             }
 
-            ArgumentNullException.ThrowIfNull(valueFactory);
-
-            object oldValObj = _table.TryGetValue(key);
-            Debug.Assert(!(oldValObj is Prime));
-
-            if (oldValObj != null)
+            if (valueFactory is null)
             {
-                return FromObjectValue(oldValObj);
+                ThrowHelper.ThrowArgumentNullException(nameof(valueFactory));
             }
-            else
+
+            Tables tables = _tables;
+
+            IEqualityComparer<TKey>? comparer = tables._comparer;
+            int hashcode = GetHashCode(comparer, key);
+
+            if (!TryGetValueInternal(tables, key, hashcode, out TValue? resultingValue))
             {
-                TValue newValue = valueFactory(key, factoryArgument);
-                TValue oldVal = default;
-                if (_table.PutIfMatch(key, newValue, ref oldVal, ValueMatch.NullOrDead))
-                {
-                    return newValue;
-                }
-                else
-                {
-                    return oldVal;
-                }
+                TryAddInternal(tables, key, hashcode, valueFactory(key, factoryArgument), updateIfExists: false, acquireLock: true, out resultingValue);
             }
+
+            return resultingValue;
         }
 
         /// <summary>
@@ -751,16 +1287,19 @@ namespace System.Collections.Concurrent
                 ThrowHelper.ThrowKeyNullException();
             }
 
-            TValue oldVal = default;
-            if (_table.PutIfMatch(key, value, ref oldVal, ValueMatch.NullOrDead))
+            Tables tables = _tables;
+
+            IEqualityComparer<TKey>? comparer = tables._comparer;
+            int hashcode = GetHashCode(comparer, key);
+
+            if (!TryGetValueInternal(tables, key, hashcode, out TValue? resultingValue))
             {
-                return value;
+                TryAddInternal(tables, key, hashcode, value, updateIfExists: false, acquireLock: true, out resultingValue);
             }
 
-            return oldVal;
+            return resultingValue;
         }
 
-
         /// <summary>
         /// Adds a key/value pair to the <see cref="ConcurrentDictionary{TKey,TValue}"/> if the key does not already
         /// exist, or updates a key/value pair in the <see cref="ConcurrentDictionary{TKey,TValue}"/> if the key
@@ -790,28 +1329,48 @@ namespace System.Collections.Concurrent
                 ThrowHelper.ThrowKeyNullException();
             }
 
-            ArgumentNullException.ThrowIfNull(addValueFactory);
+            if (addValueFactory is null)
+            {
+                ThrowHelper.ThrowArgumentNullException(nameof(addValueFactory));
+            }
 
-            ArgumentNullException.ThrowIfNull(updateValueFactory);
+            if (updateValueFactory is null)
+            {
+                ThrowHelper.ThrowArgumentNullException(nameof(updateValueFactory));
+            }
+
+            Tables tables = _tables;
+
+            IEqualityComparer<TKey>? comparer = tables._comparer;
+            int hashcode = GetHashCode(comparer, key);
 
-            TValue tValue2;
             while (true)
             {
-                TValue tValue;
-                if (this.TryGetValue(key, out tValue))
+                if (TryGetValueInternal(tables, key, hashcode, out TValue? oldValue))
                 {
-                    tValue2 = updateValueFactory(key, tValue, factoryArgument);
-                    if (this.TryUpdate(key, tValue2, tValue))
+                    // key exists, try to update
+                    TValue newValue = updateValueFactory(key, oldValue, factoryArgument);
+                    if (TryUpdateInternal(tables, key, hashcode, newValue, oldValue))
                     {
-                        return tValue2;
+                        return newValue;
                     }
                 }
                 else
                 {
-                    tValue2 = addValueFactory(key, factoryArgument);
-                    if (this.TryAdd(key, tValue2))
+                    // key doesn't exist, try to add
+                    if (TryAddInternal(tables, key, hashcode, addValueFactory(key, factoryArgument), updateIfExists: false, acquireLock: true, out TValue resultingValue))
                     {
-                        return tValue2;
+                        return resultingValue;
+                    }
+                }
+
+                if (tables != _tables)
+                {
+                    tables = _tables;
+                    if (!ReferenceEquals(comparer, tables._comparer))
+                    {
+                        comparer = tables._comparer;
+                        hashcode = GetHashCode(comparer, key);
                     }
                 }
             }
@@ -843,32 +1402,51 @@ namespace System.Collections.Concurrent
                 ThrowHelper.ThrowKeyNullException();
             }
 
-            ArgumentNullException.ThrowIfNull(addValueFactory);
+            if (addValueFactory is null)
+            {
+                ThrowHelper.ThrowArgumentNullException(nameof(addValueFactory));
+            }
 
-            ArgumentNullException.ThrowIfNull(updateValueFactory);
+            if (updateValueFactory is null)
+            {
+                ThrowHelper.ThrowArgumentNullException(nameof(updateValueFactory));
+            }
+
+            Tables tables = _tables;
+
+            IEqualityComparer<TKey>? comparer = tables._comparer;
+            int hashcode = GetHashCode(comparer, key);
 
-            TValue tValue2;
             while (true)
             {
-                TValue tValue;
-                if (this.TryGetValue(key, out tValue))
+                if (TryGetValueInternal(tables, key, hashcode, out TValue? oldValue))
                 {
-                    tValue2 = updateValueFactory(key, tValue);
-                    if (this.TryUpdate(key, tValue2, tValue))
+                    // key exists, try to update
+                    TValue newValue = updateValueFactory(key, oldValue);
+                    if (TryUpdateInternal(tables, key, hashcode, newValue, oldValue))
                     {
-                        break;
+                        return newValue;
                     }
                 }
                 else
                 {
-                    tValue2 = addValueFactory(key);
-                    if (this.TryAdd(key, tValue2))
+                    // key doesn't exist, try to add
+                    if (TryAddInternal(tables, key, hashcode, addValueFactory(key), updateIfExists: false, acquireLock: true, out TValue resultingValue))
                     {
-                        break;
+                        return resultingValue;
+                    }
+                }
+
+                if (tables != _tables)
+                {
+                    tables = _tables;
+                    if (!ReferenceEquals(comparer, tables._comparer))
+                    {
+                        comparer = tables._comparer;
+                        hashcode = GetHashCode(comparer, key);
                     }
                 }
             }
-            return tValue2;
         }
 
         /// <summary>
@@ -895,23 +1473,44 @@ namespace System.Collections.Concurrent
                 ThrowHelper.ThrowKeyNullException();
             }
 
-            ArgumentNullException.ThrowIfNull(updateValueFactory);
+            if (updateValueFactory is null)
+            {
+                ThrowHelper.ThrowArgumentNullException(nameof(updateValueFactory));
+            }
+
+            Tables tables = _tables;
+
+            IEqualityComparer<TKey>? comparer = tables._comparer;
+            int hashcode = GetHashCode(comparer, key);
 
-            TValue tValue2;
             while (true)
             {
-                TValue tValue;
-                if (this.TryGetValue(key, out tValue))
+                if (TryGetValueInternal(tables, key, hashcode, out TValue? oldValue))
                 {
-                    tValue2 = updateValueFactory(key, tValue);
-                    if (this.TryUpdate(key, tValue2, tValue))
+                    // key exists, try to update
+                    TValue newValue = updateValueFactory(key, oldValue);
+                    if (TryUpdateInternal(tables, key, hashcode, newValue, oldValue))
                     {
-                        return tValue2;
+                        return newValue;
                     }
                 }
-                else if (this.TryAdd(key, addValue))
+                else
                 {
-                    return addValue;
+                    // key doesn't exist, try to add
+                    if (TryAddInternal(tables, key, hashcode, addValue, updateIfExists: false, acquireLock: true, out TValue resultingValue))
+                    {
+                        return resultingValue;
+                    }
+                }
+
+                if (tables != _tables)
+                {
+                    tables = _tables;
+                    if (!ReferenceEquals(comparer, tables._comparer))
+                    {
+                        comparer = tables._comparer;
+                        hashcode = GetHashCode(comparer, key);
+                    }
                 }
             }
         }
@@ -921,7 +1520,35 @@ namespace System.Collections.Concurrent
         /// </summary>
         /// <value>true if the <see cref="ConcurrentDictionary{TKey,TValue}"/> is empty; otherwise,
         /// false.</value>
-        public bool IsEmpty => _table.Count == 0;
+        public bool IsEmpty
+        {
+            get
+            {
+                // Check if any buckets are non-empty, without acquiring any locks.
+                // This fast path should generally suffice as collections are usually not empty.
+                if (!AreAllBucketsEmpty())
+                {
+                    return false;
+                }
+
+                // We didn't see any buckets containing items, however we can't be sure
+                // the collection was actually empty at any point in time as items may have been
+                // added and removed while iterating over the buckets such that we never saw an
+                // empty bucket, but there was always an item present in at least one bucket.
+                int locksAcquired = 0;
+                try
+                {
+                    AcquireAllLocks(ref locksAcquired);
+
+                    return AreAllBucketsEmpty();
+                }
+                finally
+                {
+                    ReleaseLocks(locksAcquired);
+                }
+            }
+        }
+
         #region IDictionary<TKey,TValue> members
 
         /// <summary>
@@ -1005,12 +1632,9 @@ namespace System.Collections.Concurrent
         /// cref="ICollection{TValue}"/>.</param>
         /// <returns>true if the <paramref name="keyValuePair"/> is found in the <see
         /// cref="ICollection{T}"/>; otherwise, false.</returns>
-        bool ICollection<KeyValuePair<TKey, TValue>>.Contains(KeyValuePair<TKey, TValue> keyValuePair)
-        {
-            TValue value;
-            return TryGetValue(keyValuePair.Key, out value) &&
-                EqualityComparer<TValue>.Default.Equals(value, keyValuePair.Value);
-        }
+        bool ICollection<KeyValuePair<TKey, TValue>>.Contains(KeyValuePair<TKey, TValue> keyValuePair) =>
+            TryGetValue(keyValuePair.Key, out TValue? value) &&
+            EqualityComparer<TValue>.Default.Equals(value, keyValuePair.Value);
 
         /// <summary>
         /// Gets a value indicating whether the dictionary is read-only.
@@ -1112,7 +1736,7 @@ namespace System.Collections.Concurrent
         /// <see cref="IDictionary"/>.</summary>
         /// <returns>An <see cref="IDictionaryEnumerator"/> for the <see
         /// cref="IDictionary"/>.</returns>
-        IDictionaryEnumerator IDictionary.GetEnumerator() => new SnapshotIDictionaryEnumerator(_table.GetSnapshot());
+        IDictionaryEnumerator IDictionary.GetEnumerator() => new DictionaryEnumerator(this);
 
         /// <summary>
         /// Gets a value indicating whether the <see
@@ -1225,14 +1849,14 @@ namespace System.Collections.Concurrent
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         private static void ThrowIfInvalidObjectValue(object? value)
         {
-            if (value != null)
+            if (value is not null)
             {
                 if (!(value is TValue))
                 {
                     ThrowHelper.ThrowValueNullException();
                 }
             }
-            else if (default(TValue) != null)
+            else if (default(TValue) is not null)
             {
                 ThrowHelper.ThrowValueNullException();
             }
@@ -1263,32 +1887,49 @@ namespace System.Collections.Concurrent
         void ICollection.CopyTo(Array array, int index)
         {
             ArgumentNullException.ThrowIfNull(array);
+            ArgumentOutOfRangeException.ThrowIfNegative(index);
 
-            // To be consistent with the behavior of ICollection.CopyTo() in Dictionary<TKey,TValue>,
-            // we recognize three types of target arrays:
-            //    - an array of KeyValuePair<TKey, TValue> structs
-            //    - an array of DictionaryEntry structs
-            //    - an array of objects
-
-            if (array is KeyValuePair<TKey, TValue>[] pairs)
+            int locksAcquired = 0;
+            try
             {
-                CopyToPairs(pairs, index);
-                return;
-            }
+                AcquireAllLocks(ref locksAcquired);
 
-            if (array is DictionaryEntry[] entries)
+                int count = GetCountNoLocks();
+                if (array.Length - count < index)
+                {
+                    throw new ArgumentException(SR.ConcurrentDictionary_ArrayNotLargeEnough);
+                }
+
+                // To be consistent with the behavior of ICollection.CopyTo() in Dictionary<TKey,TValue>,
+                // we recognize three types of target arrays:
+                //    - an array of KeyValuePair<TKey, TValue> structs
+                //    - an array of DictionaryEntry structs
+                //    - an array of objects
+
+                if (array is KeyValuePair<TKey, TValue>[] pairs)
+                {
+                    CopyToPairs(pairs, index);
+                    return;
+                }
+
+                if (array is DictionaryEntry[] entries)
+                {
+                    CopyToEntries(entries, index);
+                    return;
+                }
+
+                if (array is object[] objects)
+                {
+                    CopyToObjects(objects, index);
+                    return;
+                }
+
+                throw new ArgumentException(SR.ConcurrentDictionary_ArrayIncorrectType, nameof(array));
+            }
+            finally
             {
-                CopyToEntries(entries, index);
-                return;
+                ReleaseLocks(locksAcquired);
             }
-
-            if (array is object[] objects)
-            {
-                CopyToObjects(objects, index);
-                return;
-            }
-
-            throw new ArgumentException(SR.ConcurrentDictionary_ArrayIncorrectType, nameof(array));
         }
 
         /// <summary>
@@ -1310,18 +1951,234 @@ namespace System.Collections.Concurrent
 
         #endregion
 
+        private bool AreAllBucketsEmpty() =>
+            !_tables._countPerLock.AsSpan().ContainsAnyExcept(0);
+
+        /// <summary>
+        /// Replaces the bucket table with a larger one. To prevent multiple threads from resizing the
+        /// table as a result of races, the Tables instance that holds the table of buckets deemed too
+        /// small is passed in as an argument to GrowTable(). GrowTable() obtains a lock, and then checks
+        /// the Tables instance has been replaced in the meantime or not.
+        /// </summary>
+        private void GrowTable(Tables tables, bool resizeDesired, bool forceRehashIfNonRandomized)
+        {
+            int locksAcquired = 0;
+            try
+            {
+                // The thread that first obtains _locks[0] will be the one doing the resize operation
+                AcquireFirstLock(ref locksAcquired);
+
+                // Make sure nobody resized the table while we were waiting for lock 0:
+                if (tables != _tables)
+                {
+                    // We assume that since the table reference is different, it was already resized (or the budget
+                    // was adjusted). If we ever decide to do table shrinking, or replace the table for other reasons,
+                    // we will have to revisit this logic.
+                    return;
+                }
+
+                int newLength = tables._buckets.Length;
+
+                IEqualityComparer<TKey>? upgradeComparer = null;
+                if (forceRehashIfNonRandomized && tables._comparer is NonRandomizedStringEqualityComparer nrsec)
+                {
+                    upgradeComparer = (IEqualityComparer<TKey>)nrsec.GetUnderlyingEqualityComparer();
+                }
+
+                if (resizeDesired)
+                {
+                    // Compute the (approx.) total size. Use an Int64 accumulation variable to avoid an overflow.
+                    // If the bucket array is too empty, we have an imbalance.
+                    // If we have a string key and we're still using a non-randomized comparer,
+                    // take this as a sign that we need to upgrade to one.
+                    // Otherwise, double the budget instead of resizing the table.
+                    if (upgradeComparer is null && GetCountNoLocks() < tables._buckets.Length / 4)
+                    {
+                        _budget = 2 * _budget;
+                        if (_budget < 0)
+                        {
+                            _budget = int.MaxValue;
+                        }
+                        return;
+                    }
+
+                    // Compute the new table size at least twice the previous table size.
+                    // Double the size of the buckets table and choose a prime that's at least as large.
+                    if ((newLength = tables._buckets.Length * 2) < 0 ||
+                        (newLength = HashHelpers.GetPrime(newLength)) > Array.MaxLength)
+                    {
+                        newLength = Array.MaxLength;
+
+                        // We want to make sure that GrowTable will not be called again, since table is at the maximum size.
+                        // To achieve that, we set the budget to int.MaxValue.
+                        //
+                        // (There is one special case that would allow GrowTable() to be called in the future:
+                        // calling Clear() on the ConcurrentDictionary will shrink the table and lower the budget.)
+                        _budget = int.MaxValue;
+                    }
+                }
+
+                object[] newLocks = tables._locks;
+
+                // Add more locks
+                if (_growLockArray && tables._locks.Length < MaxLockNumber)
+                {
+                    newLocks = new object[tables._locks.Length * 2];
+                    Array.Copy(tables._locks, newLocks, tables._locks.Length);
+                    for (int i = tables._locks.Length; i < newLocks.Length; i++)
+                    {
+                        newLocks[i] = new object();
+                    }
+                }
+
+                var newBuckets = new VolatileNode[newLength];
+                var newCountPerLock = new int[newLocks.Length];
+                var newTables = new Tables(newBuckets, newLocks, newCountPerLock, upgradeComparer ?? tables._comparer);
+
+                // Now acquire all other locks for the table
+                AcquirePostFirstLock(tables, ref locksAcquired);
+
+                // Copy all data into a new table, creating new nodes for all elements
+                foreach (VolatileNode bucket in tables._buckets)
+                {
+                    Node? current = bucket._node;
+                    while (current is not null)
+                    {
+                        int hashCode = upgradeComparer is null ? current._hashcode : upgradeComparer.GetHashCode(current._key);
+
+                        Node? next = current._next;
+                        ref Node? newBucket = ref GetBucketAndLock(newTables, hashCode, out uint newLockNo);
+
+                        newBucket = new Node(current._key, current._value, hashCode, newBucket);
+
+                        checked
+                        {
+                            newCountPerLock[newLockNo]++;
+                        }
+
+                        current = next;
+                    }
+                }
+
+                // Adjust the budget
+                _budget = Math.Max(1, newBuckets.Length / newLocks.Length);
+
+                // Replace tables with the new versions
+                _tables = newTables;
+            }
+            finally
+            {
+                ReleaseLocks(locksAcquired);
+            }
+        }
+
+        /// <summary>The number of concurrent writes for which to optimize by default.</summary>
+        private static int DefaultConcurrencyLevel => Environment.ProcessorCount;
+
+        /// <summary>
+        /// Acquires all locks for this hash table, and increments locksAcquired by the number
+        /// of locks that were successfully acquired. The locks are acquired in an increasing
+        /// order.
+        /// </summary>
+        private void AcquireAllLocks(ref int locksAcquired)
+        {
+            if (CDSCollectionETWBCLProvider.Log.IsEnabled())
+            {
+                CDSCollectionETWBCLProvider.Log.ConcurrentDictionary_AcquiringAllLocks(_tables._buckets.Length);
+            }
+
+            // First, acquire lock 0, then acquire the rest. _tables won't change after acquiring lock 0.
+            AcquireFirstLock(ref locksAcquired);
+            AcquirePostFirstLock(_tables, ref locksAcquired);
+            Debug.Assert(locksAcquired == _tables._locks.Length);
+        }
+
+        /// <summary>Acquires the first lock.</summary>
+        /// <param name="locksAcquired">The number of locks acquired. It should be 0 on entry and 1 on exit.</param>
+        /// <remarks>
+        /// Once the caller owns the lock on lock 0, _tables._locks will not change (i.e., grow),
+        /// so a caller can safely snap _tables._locks to read the remaining locks. When the locks array grows,
+        /// even though the array object itself changes, the locks from the previous array are kept.
+        /// </remarks>
+        private void AcquireFirstLock(ref int locksAcquired)
+        {
+            object[] locks = _tables._locks;
+            Debug.Assert(locksAcquired == 0);
+            Debug.Assert(!Monitor.IsEntered(locks[0]));
+
+            Monitor.Enter(locks[0]);
+            locksAcquired = 1;
+        }
+
+        /// <summary>Acquires all of the locks after the first, which must already be acquired.</summary>
+        /// <param name="tables">The tables snapped after the first lock was acquired.</param>
+        /// <param name="locksAcquired">
+        /// The number of locks acquired, which should be 1 on entry.  It's incremented as locks
+        /// are taken so that the caller can reliably release those locks in a finally in case
+        /// of exception.
+        /// </param>
+        private static void AcquirePostFirstLock(Tables tables, ref int locksAcquired)
+        {
+            object[] locks = tables._locks;
+            Debug.Assert(Monitor.IsEntered(locks[0]));
+            Debug.Assert(locksAcquired == 1);
+
+            for (int i = 1; i < locks.Length; i++)
+            {
+                Monitor.Enter(locks[i]);
+                locksAcquired++;
+            }
+
+            Debug.Assert(locksAcquired == locks.Length);
+        }
+
+        /// <summary>Releases all of the locks up to the specified number acquired.</summary>
+        /// <param name="locksAcquired">The number of locks acquired.  All lock numbers in the range [0, locksAcquired) will be released.</param>
+        private void ReleaseLocks(int locksAcquired)
+        {
+            Debug.Assert(locksAcquired >= 0);
+
+            object[] locks = _tables._locks;
+            for (int i = 0; i < locksAcquired; i++)
+            {
+                Monitor.Exit(locks[i]);
+            }
+        }
+
         /// <summary>
         /// Gets a collection containing the keys in the dictionary.
         /// </summary>
         private ReadOnlyCollection<TKey> GetKeys()
         {
-            var keys = new List<TKey>(Count);
-            foreach (var kv in this)
+            int locksAcquired = 0;
+            try
             {
-                keys.Add(kv.Key);
-            }
+                AcquireAllLocks(ref locksAcquired);
 
-            return new ReadOnlyCollection<TKey>(keys);
+                int count = GetCountNoLocks();
+                if (count == 0)
+                {
+                    return ReadOnlyCollection<TKey>.Empty;
+                }
+
+                var keys = new TKey[count];
+                int i = 0;
+                foreach (VolatileNode bucket in _tables._buckets)
+                {
+                    for (Node? node = bucket._node; node is not null; node = node._next)
+                    {
+                        keys[i] = node._key;
+                        i++;
+                    }
+                }
+                Debug.Assert(i == count);
+
+                return new ReadOnlyCollection<TKey>(keys);
+            }
+            finally
+            {
+                ReleaseLocks(locksAcquired);
+            }
         }
 
         /// <summary>
@@ -1329,50 +2186,151 @@ namespace System.Collections.Concurrent
         /// </summary>
         private ReadOnlyCollection<TValue> GetValues()
         {
-            var values = new List<TValue>(Count);
-            foreach (var kv in this)
+            int locksAcquired = 0;
+            try
             {
-                values.Add(kv.Value);
-            }
+                AcquireAllLocks(ref locksAcquired);
 
-            return new ReadOnlyCollection<TValue>(values);
+                int count = GetCountNoLocks();
+                if (count == 0)
+                {
+                    return ReadOnlyCollection<TValue>.Empty;
+                }
+
+                var keys = new TValue[count];
+                int i = 0;
+                foreach (VolatileNode bucket in _tables._buckets)
+                {
+                    for (Node? node = bucket._node; node is not null; node = node._next)
+                    {
+                        keys[i] = node._value;
+                        i++;
+                    }
+                }
+                Debug.Assert(i == count);
+
+                return new ReadOnlyCollection<TValue>(keys);
+            }
+            finally
+            {
+                ReleaseLocks(locksAcquired);
+            }
         }
 
-        internal sealed class SnapshotEnumerator : IEnumerator<KeyValuePair<TKey, TValue>>
+        private struct VolatileNode
         {
-            private DictionaryImpl<TKey, TValue>.Snapshot _snapshot;
-            public SnapshotEnumerator(DictionaryImpl<TKey, TValue>.Snapshot snapshot)
-            {
-                _snapshot = snapshot;
-            }
-
-            public KeyValuePair<TKey, TValue> Current => _snapshot.Current;
-            object IEnumerator.Current => _snapshot.Current;
-
-            public bool MoveNext() => _snapshot.MoveNext();
-            public void Reset() => _snapshot.Reset();
-            public void Dispose() { }
+            // Workaround for https://github.com/dotnet/runtime/issues/65789.
+            // If we had a Node?[] array, to safely read from the array we'd need to do Volatile.Read(ref array[i]),
+            // but that triggers an unnecessary ldelema, which in turn results in a call to CastHelpers.LdelemaRef.
+            // With this wrapper, the non-inlined call disappears.
+            internal volatile Node? _node;
         }
 
-        internal sealed class SnapshotIDictionaryEnumerator : IDictionaryEnumerator
+        /// <summary>
+        /// A node in a singly-linked list representing a particular hash table bucket.
+        /// </summary>
+        private sealed class Node
         {
-            private DictionaryImpl<TKey, TValue>.Snapshot _snapshot;
-            public SnapshotIDictionaryEnumerator(DictionaryImpl<TKey, TValue>.Snapshot snapshot)
+            internal readonly TKey _key;
+            internal TValue _value;
+            internal volatile Node? _next;
+            internal readonly int _hashcode;
+
+            internal Node(TKey key, TValue value, int hashcode, Node? next)
             {
-                _snapshot = snapshot;
+                _key = key;
+                _value = value;
+                _next = next;
+                _hashcode = hashcode;
             }
+        }
 
-            public DictionaryEntry Entry => _snapshot.Entry;
-            object IEnumerator.Current => _snapshot.Entry;
+        /// <summary>Computes a ref to the bucket for a particular key.</summary>
+        /// <remarks>This reads the bucket with a read acquire barrier.</remarks>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static Node? GetBucket(Tables tables, int hashcode)
+        {
+            VolatileNode[] buckets = tables._buckets;
+            if (IntPtr.Size == 8)
+            {
+                return buckets[HashHelpers.FastMod((uint)hashcode, (uint)buckets.Length, tables._fastModBucketsMultiplier)]._node;
+            }
+            else
+            {
+                return buckets[(uint)hashcode % (uint)buckets.Length]._node;
+            }
+        }
 
-            public object Key => _snapshot.Current.Key;
-            public object Value => _snapshot.Current.Value;
+        /// <summary>Computes the bucket and lock number for a particular key.</summary>
+        /// <remarks>This returns a ref to the bucket node; no barriers are employed.</remarks>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static ref Node? GetBucketAndLock(Tables tables, int hashcode, out uint lockNo)
+        {
+            VolatileNode[] buckets = tables._buckets;
+            uint bucketNo;
+            if (IntPtr.Size == 8)
+            {
+                bucketNo = HashHelpers.FastMod((uint)hashcode, (uint)buckets.Length, tables._fastModBucketsMultiplier);
+            }
+            else
+            {
+                bucketNo = (uint)hashcode % (uint)buckets.Length;
+            }
+            lockNo = bucketNo % (uint)tables._locks.Length; // doesn't use FastMod, as it would require maintaining a different multiplier
+            return ref buckets[bucketNo]._node;
+        }
 
-            public bool MoveNext() => _snapshot.MoveNext();
-            public void Reset() => _snapshot.Reset();
-#pragma warning disable CA1822 // Mark members as static
-            public void Dispose() { }
-#pragma warning restore CA1822 // Mark members as static
+        /// <summary>Tables that hold the internal state of the ConcurrentDictionary</summary>
+        /// <remarks>Wrapping all of the mutable state into a single object allows us to swap in everything atomically.</remarks>
+        private sealed class Tables
+        {
+            /// <summary>The comparer to use for lookups in the tables.</summary>
+            internal readonly IEqualityComparer<TKey>? _comparer;
+            /// <summary>A singly-linked list for each bucket.</summary>
+            internal readonly VolatileNode[] _buckets;
+            /// <summary>Pre-computed multiplier for use on 64-bit performing faster modulo operations.</summary>
+            internal readonly ulong _fastModBucketsMultiplier;
+            /// <summary>A set of locks, each guarding a section of the table.</summary>
+            internal readonly object[] _locks;
+            /// <summary>The number of elements guarded by each lock.</summary>
+            internal readonly int[] _countPerLock;
+
+            internal Tables(VolatileNode[] buckets, object[] locks, int[] countPerLock, IEqualityComparer<TKey>? comparer)
+            {
+                Debug.Assert(typeof(TKey).IsValueType || comparer is not null);
+
+                _buckets = buckets;
+                _locks = locks;
+                _countPerLock = countPerLock;
+                _comparer = comparer;
+                if (IntPtr.Size == 8)
+                {
+                    _fastModBucketsMultiplier = HashHelpers.GetFastModMultiplier((uint)buckets.Length);
+                }
+            }
+        }
+
+        /// <summary>
+        /// A private class to represent enumeration over the dictionary that implements the
+        /// IDictionaryEnumerator interface.
+        /// </summary>
+        private sealed class DictionaryEnumerator : IDictionaryEnumerator
+        {
+            private readonly IEnumerator<KeyValuePair<TKey, TValue>> _enumerator; // Enumerator over the dictionary.
+
+            internal DictionaryEnumerator(ConcurrentDictionary<TKey, TValue> dictionary) => _enumerator = dictionary.GetEnumerator();
+
+            public DictionaryEntry Entry => new DictionaryEntry(_enumerator.Current.Key, _enumerator.Current.Value);
+
+            public object Key => _enumerator.Current.Key;
+
+            public object? Value => _enumerator.Current.Value;
+
+            public object Current => Entry;
+
+            public bool MoveNext() => _enumerator.MoveNext();
+
+            public void Reset() => _enumerator.Reset();
         }
 
         /// <summary>Checks whether the dictionary has a comparer compatible with <typeparamref name="TAlternateKey"/>.</summary>
@@ -1717,13 +2675,57 @@ namespace System.Collections.Concurrent
         }
     }
 
+    internal static class ConcurrentDictionaryTypeProps<T>
+    {
+        /// <summary>Whether T's type can be written atomically (i.e., with no danger of torn reads).</summary>
+        internal static readonly bool IsWriteAtomic = IsWriteAtomicPrivate();
+
+        private static bool IsWriteAtomicPrivate()
+        {
+            // Section 12.6.6 of ECMA CLI explains which types can be read and written atomically without
+            // the risk of tearing. See https://www.ecma-international.org/publications/files/ECMA-ST/ECMA-335.pdf
+
+            if (!typeof(T).IsValueType ||
+                typeof(T) == typeof(IntPtr) ||
+                typeof(T) == typeof(UIntPtr))
+            {
+                return true;
+            }
+
+            switch (Type.GetTypeCode(typeof(T)))
+            {
+                case TypeCode.Boolean:
+                case TypeCode.Byte:
+                case TypeCode.Char:
+                case TypeCode.Int16:
+                case TypeCode.Int32:
+                case TypeCode.SByte:
+                case TypeCode.Single:
+                case TypeCode.UInt16:
+                case TypeCode.UInt32:
+                    return true;
+
+                case TypeCode.Double:
+                case TypeCode.Int64:
+                case TypeCode.UInt64:
+                    return IntPtr.Size == 8;
+
+                default:
+                    return false;
+            }
+        }
+    }
+
     internal sealed class IDictionaryDebugView<TKey, TValue> where TKey : notnull
     {
         private readonly IDictionary<TKey, TValue> _dictionary;
 
         public IDictionaryDebugView(IDictionary<TKey, TValue> dictionary)
         {
-            ArgumentNullException.ThrowIfNull(dictionary);
+            if (dictionary is null)
+            {
+                ThrowHelper.ThrowArgumentNullException(nameof(dictionary));
+            }
 
             _dictionary = dictionary;
         }
diff --git a/src/libraries/System.Collections.Concurrent/src/System/Collections/Concurrent/ConcurrentDictionary/Counter/Counter32.cs b/src/libraries/System.Collections.Concurrent/src/System/Collections/Concurrent/ConcurrentDictionary/Counter/Counter32.cs
deleted file mode 100644
index e95a65b1ab5..00000000000
--- a/src/libraries/System.Collections.Concurrent/src/System/Collections/Concurrent/ConcurrentDictionary/Counter/Counter32.cs
+++ /dev/null
@@ -1,236 +0,0 @@
-// Copyright (c) 2022 Vladimir Sadov
-//
-// Permission is hereby granted, free of charge, to any person
-// obtaining a copy of this software and associated documentation
-// files (the "Software"), to deal in the Software without
-// restriction, including without limitation the rights to use,
-// copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the
-// Software is furnished to do so, subject to the following
-// conditions:
-//
-// The above copyright notice and this permission notice shall be
-// included in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
-// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
-// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
-// OTHER DEALINGS IN THE SOFTWARE.
-//
-// Counter32.cs
-//
-
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-using System.Threading;
-
-#nullable disable
-
-namespace System.Collections.Concurrent
-{
-    /// <summary>
-    /// Scalable 32bit counter that can be used from multiple threads.
-    /// </summary>
-    internal sealed class Counter32: CounterBase
-    {
-        private sealed class Cell
-        {
-            [StructLayout(LayoutKind.Explicit, Size = CACHE_LINE * 2 - OBJ_HEADER_SIZE)]
-            public struct SpacedCounter
-            {
-                [FieldOffset(CACHE_LINE - OBJ_HEADER_SIZE)]
-                public int count;
-            }
-
-            public SpacedCounter counter;
-        }
-
-        // spaced out counters
-        private Cell[] cells;
-
-        // default counter
-        private int count;
-
-        // delayed estimated count
-        private int lastCount;
-
-        /// <summary>
-        /// Initializes a new instance of the <see
-        /// cref="Counter32"/>
-        /// </summary>
-        public Counter32()
-        {
-        }
-
-        /// <summary>
-        /// Returns the value of the counter at the time of the call.
-        /// </summary>
-        /// <remarks>
-        /// The value may miss in-progress updates if the counter is being concurrently modified.
-        /// </remarks>
-        public int Value
-        {
-            get
-            {
-                var count = this.count;
-                var cells = this.cells;
-
-                if (cells != null)
-                {
-                    for (int i = 0; i < cells.Length; i++)
-                    {
-                        var cell = cells[i];
-                        if (cell != null)
-                        {
-                            count += cell.counter.count;
-                        }
-                        else
-                        {
-                            break;
-                        }
-                    }
-                }
-
-                return count;
-            }
-        }
-
-        /// <summary>
-        /// Returns the approximate value of the counter at the time of the call.
-        /// </summary>
-        /// <remarks>
-        /// EstimatedValue could be significantly cheaper to obtain, but may be slightly delayed.
-        /// </remarks>
-        public int EstimatedValue
-        {
-            get
-            {
-                if (this.cells == null)
-                {
-                    return this.count;
-                }
-
-                var curTicks = (uint)Environment.TickCount;
-                // more than a millisecond passed?
-                if (curTicks != lastCountTicks)
-                {
-                    lastCountTicks = curTicks;
-                    lastCount = Value;
-                }
-
-                return lastCount;
-            }
-        }
-
-        /// <summary>
-        /// Increments the counter by 1.
-        /// </summary>
-        public void Increment()
-        {
-            int curCellCount = this.cellCount;
-            var drift = increment(ref GetCountRef(curCellCount));
-
-            if (drift != 0)
-            {
-                TryAddCell(curCellCount);
-            }
-        }
-
-        /// <summary>
-        /// Decrements the counter by 1.
-        /// </summary>
-        public void Decrement()
-        {
-            int curCellCount = this.cellCount;
-            var drift = decrement(ref GetCountRef(curCellCount));
-
-            if (drift != 0)
-            {
-                TryAddCell(curCellCount);
-            }
-        }
-
-        /// <summary>
-        /// Increments the counter by 'value'.
-        /// </summary>
-        public void Add(int value)
-        {
-            int curCellCount = this.cellCount;
-            var drift = add(ref GetCountRef(curCellCount), value);
-
-            if (drift != 0)
-            {
-                TryAddCell(curCellCount);
-            }
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private ref int GetCountRef(int curCellCount)
-        {
-            ref var countRef = ref count;
-
-            Cell[] cells;
-            if ((cells = this.cells) != null && curCellCount > 1)
-            {
-                var cell = cells[GetIndex((uint)curCellCount)];
-                if (cell != null)
-                {
-                    countRef = ref cell.counter.count;
-                }
-            }
-
-            return ref countRef;
-        }
-
-        private static int increment(ref int val)
-        {
-            return -val - 1 + Interlocked.Increment(ref val);
-        }
-
-        private static int add(ref int val, int inc)
-        {
-            return -val - inc + Interlocked.Add(ref val, inc);
-        }
-
-        private static int decrement(ref int val)
-        {
-            return val - 1 - Interlocked.Decrement(ref val);
-        }
-
-        private void TryAddCell(int curCellCount)
-        {
-            if (curCellCount < s_MaxCellCount)
-            {
-                TryAddCellCore(curCellCount);
-            }
-        }
-
-        [MethodImpl(MethodImplOptions.NoInlining)]
-        private void TryAddCellCore(int curCellCount)
-        {
-            var cells = this.cells;
-            if (cells == null)
-            {
-                var newCells = new Cell[s_MaxCellCount];
-                cells = Interlocked.CompareExchange(ref this.cells, newCells, null) ?? newCells;
-            }
-
-            if (cells[curCellCount] == null)
-            {
-                Interlocked.CompareExchange(ref cells[curCellCount], new Cell(), null);
-            }
-
-            if (this.cellCount == curCellCount)
-            {
-                Interlocked.CompareExchange(ref this.cellCount, curCellCount + 1, curCellCount);
-            }
-        }
-    }
-}
diff --git a/src/libraries/System.Collections.Concurrent/src/System/Collections/Concurrent/ConcurrentDictionary/Counter/Counter64.cs b/src/libraries/System.Collections.Concurrent/src/System/Collections/Concurrent/ConcurrentDictionary/Counter/Counter64.cs
deleted file mode 100644
index 1bd6b2ba578..00000000000
--- a/src/libraries/System.Collections.Concurrent/src/System/Collections/Concurrent/ConcurrentDictionary/Counter/Counter64.cs
+++ /dev/null
@@ -1,235 +0,0 @@
-// Copyright (c) 2022 Vladimir Sadov
-//
-// Permission is hereby granted, free of charge, to any person
-// obtaining a copy of this software and associated documentation
-// files (the "Software"), to deal in the Software without
-// restriction, including without limitation the rights to use,
-// copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the
-// Software is furnished to do so, subject to the following
-// conditions:
-//
-// The above copyright notice and this permission notice shall be
-// included in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
-// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
-// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
-// OTHER DEALINGS IN THE SOFTWARE.
-//
-// Counter64.cs
-//
-
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-using System.Threading;
-
-#nullable disable
-
-namespace System.Collections.Concurrent
-{
-    /// <summary>
-    /// Scalable 64bit counter that can be used from multiple threads.
-    /// </summary>
-    internal sealed class Counter64 : CounterBase
-    {
-        private sealed class Cell
-        {
-            [StructLayout(LayoutKind.Explicit, Size = CACHE_LINE * 2 - OBJ_HEADER_SIZE)]
-            public struct SpacedCounter
-            {
-                [FieldOffset(CACHE_LINE - OBJ_HEADER_SIZE)]
-                public long count;
-            }
-
-            public SpacedCounter counter;
-        }
-
-        // spaced out counters
-        private Cell[] cells;
-
-        // default counter
-        private long count;
-
-        // delayed count
-        private long lastCount;
-
-        /// <summary>
-        /// Initializes a new instance of the <see
-        /// cref="Counter32"/>
-        /// </summary>
-        public Counter64()
-        {
-        }
-
-        /// <summary>
-        /// Returns the value of the counter at the time of the call.
-        /// </summary>
-        /// <remarks>
-        /// The value may miss in-progress updates if the counter is being concurrently modified.
-        /// </remarks>
-        public long Value
-        {
-            get
-            {
-                var count = this.count;
-                var cells = this.cells;
-
-                if (cells != null)
-                {
-                    for (int i = 0; i < cells.Length; i++)
-                    {
-                        var cell = cells[i];
-                        if (cell != null)
-                        {
-                            count += cell.counter.count;
-                        }
-                        else
-                        {
-                            break;
-                        }
-                    }
-                }
-
-                return count;
-            }
-        }
-
-        /// <summary>
-        /// Returns the approximate value of the counter at the time of the call.
-        /// </summary>
-        /// <remarks>
-        /// EstimatedValue could be significantly cheaper to obtain, but may be slightly delayed.
-        /// </remarks>
-        public long EstimatedValue
-        {
-            get
-            {
-                if (this.cellCount == 0)
-                {
-                    return Value;
-                }
-
-                var curTicks = (uint)Environment.TickCount;
-                // more than a millisecond passed?
-                if (curTicks != lastCountTicks)
-                {
-                    lastCountTicks = curTicks;
-                    lastCount = Value;
-                }
-
-                return lastCount;
-            }
-        }
-
-        /// <summary>
-        /// Increments the counter by 1.
-        /// </summary>
-        public void Increment()
-        {
-            int curCellCount = this.cellCount;
-            var drift = increment(ref GetCountRef(curCellCount));
-
-            if (drift != 0)
-            {
-                TryAddCell(curCellCount);
-            }
-        }
-
-        /// <summary>
-        /// Decrements the counter by 1.
-        /// </summary>
-        public void Decrement()
-        {
-            int curCellCount = this.cellCount;
-            var drift = decrement(ref GetCountRef(curCellCount));
-
-            if (drift != 0)
-            {
-                TryAddCell(curCellCount);
-            }
-        }
-
-        /// <summary>
-        /// Increments the counter by 'value'.
-        /// </summary>
-        public void Add(int value)
-        {
-            int curCellCount = this.cellCount;
-            var drift = add(ref GetCountRef(curCellCount), value);
-
-            if (drift != 0)
-            {
-                TryAddCell(curCellCount);
-            }
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private ref long GetCountRef(int curCellCount)
-        {
-            ref var countRef = ref count;
-
-            Cell[] cells;
-            if ((cells = this.cells) != null && curCellCount > 1)
-            {
-                var cell = cells[GetIndex((uint)curCellCount)];
-                if (cell != null)
-                {
-                    countRef = ref cell.counter.count;
-                }
-            }
-
-            return ref countRef;
-        }
-
-        private static long increment(ref long val)
-        {
-            return -val - 1 + Interlocked.Increment(ref val);
-        }
-
-        private static long add(ref long val, int inc)
-        {
-            return -val - inc + Interlocked.Add(ref val, inc);
-        }
-
-        private static long decrement(ref long val)
-        {
-            return val - 1 - Interlocked.Decrement(ref val);
-        }
-
-        private void TryAddCell(int curCellCount)
-        {
-            if (curCellCount < s_MaxCellCount)
-            {
-                TryAddCellCore(curCellCount);
-            }
-        }
-
-        private void TryAddCellCore(int curCellCount)
-        {
-            var cells = this.cells;
-            if (cells == null)
-            {
-                var newCells = new Cell[s_MaxCellCount];
-                cells = Interlocked.CompareExchange(ref this.cells, newCells, null) ?? newCells;
-            }
-
-            if (cells[curCellCount] == null)
-            {
-                Interlocked.CompareExchange(ref cells[curCellCount], new Cell(), null);
-            }
-
-            if (this.cellCount == curCellCount)
-            {
-                Interlocked.CompareExchange(ref this.cellCount, curCellCount + 1, curCellCount);
-            }
-        }
-    }
-}
diff --git a/src/libraries/System.Collections.Concurrent/src/System/Collections/Concurrent/ConcurrentDictionary/Counter/CounterBase.cs b/src/libraries/System.Collections.Concurrent/src/System/Collections/Concurrent/ConcurrentDictionary/Counter/CounterBase.cs
deleted file mode 100644
index 4e92c209cf0..00000000000
--- a/src/libraries/System.Collections.Concurrent/src/System/Collections/Concurrent/ConcurrentDictionary/Counter/CounterBase.cs
+++ /dev/null
@@ -1,62 +0,0 @@
-// Copyright (c) 2022 Vladimir Sadov
-//
-// Permission is hereby granted, free of charge, to any person
-// obtaining a copy of this software and associated documentation
-// files (the "Software"), to deal in the Software without
-// restriction, including without limitation the rights to use,
-// copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the
-// Software is furnished to do so, subject to the following
-// conditions:
-//
-// The above copyright notice and this permission notice shall be
-// included in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
-// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
-// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
-// OTHER DEALINGS IN THE SOFTWARE.
-//
-// CounterBase.cs
-//
-
-using System;
-using System.Collections;
-using System.Runtime.CompilerServices;
-
-namespace System.Collections.Concurrent
-{
-    /// <summary>
-    /// Scalable counter base.
-    /// </summary>
-    internal class CounterBase
-    {
-        private protected const int CACHE_LINE = 64;
-        private protected const int OBJ_HEADER_SIZE = 8;
-
-        private protected static readonly int s_MaxCellCount = HashHelpers.AlignToPowerOfTwo(Environment.ProcessorCount) + 1;
-
-        // how many cells we have
-        private protected int cellCount;
-
-        // delayed count time
-        private protected uint lastCountTicks;
-
-        private protected CounterBase()
-        {
-            // touch a static
-            _ = s_MaxCellCount;
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private protected static unsafe int GetIndex(uint cellCount)
-        {
-            nuint addr = (nuint)(&cellCount);
-            return (int)(addr % cellCount);
-        }
-    }
-}
diff --git a/src/libraries/System.Collections.Concurrent/src/System/Collections/Concurrent/ConcurrentDictionary/DictionaryImpl.SnapshotImpl.cs b/src/libraries/System.Collections.Concurrent/src/System/Collections/Concurrent/ConcurrentDictionary/DictionaryImpl.SnapshotImpl.cs
deleted file mode 100644
index b196080256b..00000000000
--- a/src/libraries/System.Collections.Concurrent/src/System/Collections/Concurrent/ConcurrentDictionary/DictionaryImpl.SnapshotImpl.cs
+++ /dev/null
@@ -1,112 +0,0 @@
-// Copyright (c) 2022 Vladimir Sadov
-//
-// Permission is hereby granted, free of charge, to any person
-// obtaining a copy of this software and associated documentation
-// files (the "Software"), to deal in the Software without
-// restriction, including without limitation the rights to use,
-// copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the
-// Software is furnished to do so, subject to the following
-// conditions:
-//
-// The above copyright notice and this permission notice shall be
-// included in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
-// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
-// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
-// OTHER DEALINGS IN THE SOFTWARE.
-//
-// DictionaryImpl.SnapshotImpl.cs
-//
-
-#nullable disable
-
-using System;
-using System.Collections;
-using System.Collections.Generic;
-using System.Collections.ObjectModel;
-using System.Diagnostics;
-using System.Runtime.CompilerServices;
-using System.Threading;
-
-namespace System.Collections.Concurrent
-{
-    internal abstract partial class DictionaryImpl<TKey, TKeyStore, TValue>
-        : DictionaryImpl<TKey, TValue>
-    {
-        internal override Snapshot GetSnapshot()
-        {
-            return new SnapshotImpl(this);
-        }
-
-        private sealed class SnapshotImpl : Snapshot
-        {
-            private readonly DictionaryImpl<TKey, TKeyStore, TValue> _table;
-
-            public SnapshotImpl(DictionaryImpl<TKey, TKeyStore, TValue> dict)
-            {
-                this._table = dict;
-
-                // linearization point.
-                // if table is quiescent and has no copy in progress,
-                // we can simply iterate over its table.
-                while (true)
-                {
-                    if (_table._newTable == null)
-                    {
-                        break;
-                    }
-
-                    // there is a copy in progress, finish it and try again
-                    _table.HelpCopy(copy_all: true);
-                    this._table = (DictionaryImpl<TKey, TKeyStore, TValue>)(this._table._topDict._table);
-                }
-            }
-
-            public override int Count => _table.Count;
-
-            public override bool MoveNext()
-            {
-                var entries = this._table._entries;
-                while (_idx < entries.Length)
-                {
-                    var nextEntry = entries[_idx++];
-
-                    if (nextEntry.value != null)
-                    {
-                        var nextKstore = nextEntry.key;
-                        if (nextKstore == null)
-                        {
-                            // slot was deleted.
-                            continue;
-                        }
-
-                        _curKey = _table.keyFromEntry(nextKstore);
-                        object nextV = _table.TryGetValue(_curKey);
-                        if (nextV != null)
-                        {
-                            _curValue = _table.FromObjectValue(nextV);
-                            return true;
-                        }
-                    }
-                }
-
-                _curKey = default;
-                _curValue = default;
-                return false;
-            }
-
-            public override void Reset()
-            {
-                _idx = 0;
-                _curKey = default;
-                _curValue = default;
-            }
-        }
-    }
-}
diff --git a/src/libraries/System.Collections.Concurrent/src/System/Collections/Concurrent/ConcurrentDictionary/DictionaryImpl.cs b/src/libraries/System.Collections.Concurrent/src/System/Collections/Concurrent/ConcurrentDictionary/DictionaryImpl.cs
deleted file mode 100644
index 30819c6a6e2..00000000000
--- a/src/libraries/System.Collections.Concurrent/src/System/Collections/Concurrent/ConcurrentDictionary/DictionaryImpl.cs
+++ /dev/null
@@ -1,119 +0,0 @@
-// Copyright (c) 2022 Vladimir Sadov
-//
-// Permission is hereby granted, free of charge, to any person
-// obtaining a copy of this software and associated documentation
-// files (the "Software"), to deal in the Software without
-// restriction, including without limitation the rights to use,
-// copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the
-// Software is furnished to do so, subject to the following
-// conditions:
-//
-// The above copyright notice and this permission notice shall be
-// included in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
-// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
-// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
-// OTHER DEALINGS IN THE SOFTWARE.
-//
-// DictionaryImpl.cs
-//
-
-#nullable disable
-
-using System.Collections.Concurrent;
-using System.Collections.Generic;
-using System.Runtime.CompilerServices;
-
-namespace System.Collections.Concurrent
-{
-    internal abstract class DictionaryImpl
-    {
-        internal DictionaryImpl() { }
-
-        internal enum ValueMatch
-        {
-            Any,            // sets new value unconditionally, used by index set and TryRemove(key)
-            NullOrDead,     // set value if original value is null or dead, used by Add/TryAdd
-            NotNullOrDead,  // set value if original value is alive, used by Remove
-            OldValue,       // sets new value if old value matches
-        }
-
-        internal sealed class Prime
-        {
-            internal object originalValue;
-
-            public Prime(object originalValue)
-            {
-                this.originalValue = originalValue;
-            }
-        }
-
-        internal static readonly object TOMBSTONE = new object();
-        internal static readonly Prime TOMBPRIME = new Prime(TOMBSTONE);
-        internal static readonly object NULLVALUE = new object();
-
-        // represents a trivially copied empty entry
-        // we insert it in the old table during rehashing
-        // to reduce chances that more entries are added
-        protected const int TOMBPRIMEHASH = 1 << 31;
-
-        // we cannot distigush zero keys from uninitialized state
-        // so we force them to have this special hash instead
-        protected const int ZEROHASH = 1 << 30;
-
-        // all regular hashes have both these bits set
-        // to be different from either 0, TOMBPRIMEHASH or ZEROHASH
-        // having only these bits set in a case of Ref key means that the slot is permanently deleted.
-        protected const int SPECIAL_HASH_BITS = TOMBPRIMEHASH | ZEROHASH;
-
-        // Heuristic to decide if we have reprobed toooo many times.  Running over
-        // the reprobe limit on a 'get' call acts as a 'miss'; on a 'put' call it
-        // can trigger a table resize.  Several places must have exact agreement on
-        // what the reprobe_limit is, so we share it here.
-        protected const int REPROBE_LIMIT = 4;
-        protected const int REPROBE_LIMIT_SHIFT = 8;
-
-        protected static int ReprobeLimit(int lenMask)
-        {
-            // 1/2 of table with some extra
-            return REPROBE_LIMIT + (lenMask >> REPROBE_LIMIT_SHIFT);
-        }
-
-        protected static bool EntryValueNullOrDead(object entryValue)
-        {
-            return entryValue == null || entryValue == TOMBSTONE;
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        protected static int ReduceHashToIndex(int fullHash, int lenMask)
-        {
-            var h = (uint)fullHash;
-
-            // xor-shift some upper bits down, in case if variations are mostly in high bits
-            // and scatter the bits a little to break up clusters if hashes are periodic (like 42, 43, 44, ...)
-            // long clusters can cause long reprobes. small clusters are ok though.
-            h ^= h >> 15;
-            h ^= h >> 8;
-            h += (h >> 3) * 2654435769u;
-
-            return (int)h & lenMask;
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        internal static object ToObjectValue<TValue>(TValue value)
-        {
-            if (default(TValue) != null)
-            {
-                return new Boxed<TValue>(value);
-            }
-
-            return (object)value ?? NULLVALUE;
-        }
-    }
-}
diff --git a/src/libraries/System.Collections.Concurrent/src/System/Collections/Concurrent/ConcurrentDictionary/DictionaryImplBoxed.cs b/src/libraries/System.Collections.Concurrent/src/System/Collections/Concurrent/ConcurrentDictionary/DictionaryImplBoxed.cs
deleted file mode 100644
index b322a178faf..00000000000
--- a/src/libraries/System.Collections.Concurrent/src/System/Collections/Concurrent/ConcurrentDictionary/DictionaryImplBoxed.cs
+++ /dev/null
@@ -1,165 +0,0 @@
-// Copyright (c) 2022 Vladimir Sadov
-//
-// Permission is hereby granted, free of charge, to any person
-// obtaining a copy of this software and associated documentation
-// files (the "Software"), to deal in the Software without
-// restriction, including without limitation the rights to use,
-// copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the
-// Software is furnished to do so, subject to the following
-// conditions:
-//
-// The above copyright notice and this permission notice shall be
-// included in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
-// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
-// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
-// OTHER DEALINGS IN THE SOFTWARE.
-//
-// DictionaryImplBoxed.cs
-//
-
-#nullable disable
-
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-using System.Threading;
-
-namespace System.Collections.Concurrent
-{
-    internal sealed class DictionaryImplBoxed<TKey, TValue>
-            : DictionaryImpl<TKey, Boxed<TKey>, TValue>
-    {
-        internal DictionaryImplBoxed(int capacity, ConcurrentDictionary<TKey, TValue> topDict)
-            : base(capacity, topDict)
-        {
-        }
-
-        internal DictionaryImplBoxed(int capacity, DictionaryImplBoxed<TKey, TValue> other)
-            : base(capacity, other)
-        {
-        }
-
-        protected override bool TryClaimSlotForPut(ref Boxed<TKey> entryKey, TKey key)
-        {
-            var entryKeyValue = entryKey;
-            if (entryKeyValue == null)
-            {
-                entryKeyValue = Interlocked.CompareExchange(ref entryKey, new Boxed<TKey>(key), null);
-                if (entryKeyValue == null)
-                {
-                    // claimed a new slot
-                    this.allocatedSlotCount.Increment();
-                    return true;
-                }
-            }
-
-            return _keyComparer.Equals(key, entryKey.Value);
-        }
-
-        protected override bool TryClaimSlotForCopy(ref Boxed<TKey> entryKey, Boxed<TKey> key)
-        {
-            var entryKeyValue = entryKey;
-            if (entryKeyValue == null)
-            {
-                entryKeyValue = Interlocked.CompareExchange(ref entryKey, key, null);
-                if (entryKeyValue == null)
-                {
-                    // claimed a new slot
-                    this.allocatedSlotCount.Increment();
-                    return true;
-                }
-            }
-
-            return _keyComparer.Equals(key.Value, entryKey.Value);
-        }
-
-        protected override bool keyEqual(TKey key, Boxed<TKey> entryKey)
-        {
-            //NOTE: slots are claimed in two stages - claim a hash, then set a key
-            //      it is possible to observe a slot with a null key, but with hash already set
-            //      that is not a match since the key is not yet in the table
-            if (entryKey == null)
-            {
-                return false;
-            }
-
-            return _keyComparer.Equals(key, entryKey.Value);
-        }
-
-        protected override DictionaryImpl<TKey, Boxed<TKey>, TValue> CreateNew(int capacity)
-        {
-            return new DictionaryImplBoxed<TKey, TValue>(capacity, this);
-        }
-
-        protected override TKey keyFromEntry(Boxed<TKey> entryKey)
-        {
-            return entryKey.Value;
-        }
-    }
-
-#pragma warning disable CS0659 // Type overrides Object.Equals(object o) but does not override Object.GetHashCode()
-    internal sealed class Boxed<T>
-    {
-        // 0 - allow writes, 1 - someone is writing, 2 frozen.
-        public int writeStatus;
-        public T Value;
-
-        public Boxed(T key)
-        {
-            this.Value = key;
-        }
-
-        public override bool Equals(object obj)
-        {
-            return EqualityComparer<T>.Default.Equals(this.Value, Unsafe.As<Boxed<T>>(obj).Value);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public bool TryVolatileWrite(T value)
-        {
-            if (Interlocked.CompareExchange(ref writeStatus, 1, 0) == 0)
-            {
-                Value = value;
-                Volatile.Write(ref writeStatus, 0);
-                return true;
-            }
-            return false;
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public bool TryCompareExchange(T oldValue, T newValue, out bool changed)
-        {
-            changed = false;
-            if (Interlocked.CompareExchange(ref writeStatus, 1, 0) != 0)
-            {
-                return false;
-            }
-
-            if (EqualityComparer<T>.Default.Equals(Value, oldValue))
-            {
-                Value = newValue;
-                changed = true;
-            }
-
-            Volatile.Write(ref writeStatus, 0);
-            return true;
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        internal void Freeze()
-        {
-            // Wait for writers (1) to leave. Already 2 is ok, or set 0 -> 2.
-            while (Interlocked.CompareExchange(ref writeStatus, 2, 0) == 1);
-        }
-    }
-#pragma warning restore CS0659 // Type overrides Object.Equals(object o) but does not override Object.GetHashCode()
-}
diff --git a/src/libraries/System.Collections.Concurrent/src/System/Collections/Concurrent/ConcurrentDictionary/DictionaryImplInt.cs b/src/libraries/System.Collections.Concurrent/src/System/Collections/Concurrent/ConcurrentDictionary/DictionaryImplInt.cs
deleted file mode 100644
index bde2aee832e..00000000000
--- a/src/libraries/System.Collections.Concurrent/src/System/Collections/Concurrent/ConcurrentDictionary/DictionaryImplInt.cs
+++ /dev/null
@@ -1,171 +0,0 @@
-// Copyright (c) 2022 Vladimir Sadov
-//
-// Permission is hereby granted, free of charge, to any person
-// obtaining a copy of this software and associated documentation
-// files (the "Software"), to deal in the Software without
-// restriction, including without limitation the rights to use,
-// copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the
-// Software is furnished to do so, subject to the following
-// conditions:
-//
-// The above copyright notice and this permission notice shall be
-// included in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
-// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
-// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
-// OTHER DEALINGS IN THE SOFTWARE.
-//
-// DictionaryImplInt.cs
-//
-
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.Runtime.InteropServices;
-using System.Threading;
-
-namespace System.Collections.Concurrent
-{
-    internal sealed class DictionaryImplInt<TValue>
-                : DictionaryImpl<int, int, TValue>
-    {
-        internal DictionaryImplInt(int capacity, ConcurrentDictionary<int, TValue> topDict)
-            : base(capacity, topDict)
-        {
-        }
-
-        internal DictionaryImplInt(int capacity, DictionaryImplInt<TValue> other)
-            : base(capacity, other)
-        {
-        }
-
-        protected override bool TryClaimSlotForPut(ref int entryKey, int key)
-        {
-            return TryClaimSlot(ref entryKey, key);
-        }
-
-        protected override bool TryClaimSlotForCopy(ref int entryKey, int key)
-        {
-            return TryClaimSlot(ref entryKey, key);
-        }
-
-        private bool TryClaimSlot(ref int entryKey, int key)
-        {
-            var entryKeyValue = entryKey;
-            //zero keys are claimed via hash
-            if (entryKeyValue == 0 & key != 0)
-            {
-                entryKeyValue = Interlocked.CompareExchange(ref entryKey, key, 0);
-                if (entryKeyValue == 0)
-                {
-                    // claimed a new slot
-                    this.allocatedSlotCount.Increment();
-                    return true;
-                }
-            }
-
-            return key == entryKeyValue || _keyComparer.Equals(key, entryKey);
-        }
-
-        protected override int hash(int key)
-        {
-            if (key == 0)
-            {
-                return ZEROHASH;
-            }
-
-            return base.hash(key);
-        }
-
-        protected override bool keyEqual(int key, int entryKey)
-        {
-            return key == entryKey || _keyComparer.Equals(key, entryKey);
-        }
-
-        protected override DictionaryImpl<int, int, TValue> CreateNew(int capacity)
-        {
-            return new DictionaryImplInt<TValue>(capacity, this);
-        }
-
-        protected override int keyFromEntry(int entryKey)
-        {
-            return entryKey;
-        }
-    }
-
-    internal sealed class DictionaryImplIntNoComparer<TValue>
-            : DictionaryImpl<int, int, TValue>
-    {
-        internal DictionaryImplIntNoComparer(int capacity, ConcurrentDictionary<int, TValue> topDict)
-            : base(capacity, topDict)
-        {
-        }
-
-        internal DictionaryImplIntNoComparer(int capacity, DictionaryImplIntNoComparer<TValue> other)
-            : base(capacity, other)
-        {
-        }
-
-        protected override bool TryClaimSlotForPut(ref int entryKey, int key)
-        {
-            return TryClaimSlot(ref entryKey, key);
-        }
-
-        protected override bool TryClaimSlotForCopy(ref int entryKey, int key)
-        {
-            return TryClaimSlot(ref entryKey, key);
-        }
-
-        private bool TryClaimSlot(ref int entryKey, int key)
-        {
-            var entryKeyValue = entryKey;
-            //zero keys are claimed via hash
-            if (entryKeyValue == 0 & key != 0)
-            {
-                entryKeyValue = Interlocked.CompareExchange(ref entryKey, key, 0);
-                if (entryKeyValue == 0)
-                {
-                    // claimed a new slot
-                    this.allocatedSlotCount.Increment();
-                    return true;
-                }
-            }
-
-            return key == entryKeyValue;
-        }
-
-        // inline the base implementation to devirtualize calls to hash and keyEqual
-        internal override object TryGetValue(int key)
-        {
-            return base.TryGetValue(key);
-        }
-
-        protected override int hash(int key)
-        {
-            return (key == 0) ?
-                ZEROHASH :
-                key | SPECIAL_HASH_BITS;
-        }
-
-        protected override bool keyEqual(int key, int entryKey)
-        {
-            return key == entryKey;
-        }
-
-        protected override DictionaryImpl<int, int, TValue> CreateNew(int capacity)
-        {
-            return new DictionaryImplIntNoComparer<TValue>(capacity, this);
-        }
-
-        protected override int keyFromEntry(int entryKey)
-        {
-            return entryKey;
-        }
-    }
-}
diff --git a/src/libraries/System.Collections.Concurrent/src/System/Collections/Concurrent/ConcurrentDictionary/DictionaryImplLong.cs b/src/libraries/System.Collections.Concurrent/src/System/Collections/Concurrent/ConcurrentDictionary/DictionaryImplLong.cs
deleted file mode 100644
index 44f95646a17..00000000000
--- a/src/libraries/System.Collections.Concurrent/src/System/Collections/Concurrent/ConcurrentDictionary/DictionaryImplLong.cs
+++ /dev/null
@@ -1,171 +0,0 @@
-// Copyright (c) 2022 Vladimir Sadov
-//
-// Permission is hereby granted, free of charge, to any person
-// obtaining a copy of this software and associated documentation
-// files (the "Software"), to deal in the Software without
-// restriction, including without limitation the rights to use,
-// copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the
-// Software is furnished to do so, subject to the following
-// conditions:
-//
-// The above copyright notice and this permission notice shall be
-// included in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
-// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
-// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
-// OTHER DEALINGS IN THE SOFTWARE.
-//
-// DictionaryImplLong.cs
-//
-
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.Runtime.InteropServices;
-using System.Threading;
-
-namespace System.Collections.Concurrent
-{
-    internal sealed class DictionaryImplLong<TValue>
-                : DictionaryImpl<long, long, TValue>
-    {
-        internal DictionaryImplLong(int capacity, ConcurrentDictionary<long, TValue> topDict)
-            : base(capacity, topDict)
-        {
-        }
-
-        internal DictionaryImplLong(int capacity, DictionaryImplLong<TValue> other)
-            : base(capacity, other)
-        {
-        }
-
-        protected override bool TryClaimSlotForPut(ref long entryKey, long key)
-        {
-            return TryClaimSlot(ref entryKey, key);
-        }
-
-        protected override bool TryClaimSlotForCopy(ref long entryKey, long key)
-        {
-            return TryClaimSlot(ref entryKey, key);
-        }
-
-        private bool TryClaimSlot(ref long entryKey, long key)
-        {
-            var entryKeyValue = entryKey;
-            //zero keys are claimed via hash
-            if (entryKeyValue == 0 & key != 0)
-            {
-                entryKeyValue = Interlocked.CompareExchange(ref entryKey, key, 0);
-                if (entryKeyValue == 0)
-                {
-                    // claimed a new slot
-                    this.allocatedSlotCount.Increment();
-                    return true;
-                }
-            }
-
-            return key == entryKeyValue || _keyComparer.Equals(key, entryKey);
-        }
-
-        protected override int hash(long key)
-        {
-            if (key == 0)
-            {
-                return ZEROHASH;
-            }
-
-            return base.hash(key);
-        }
-
-        protected override bool keyEqual(long key, long entryKey)
-        {
-            return key == entryKey || _keyComparer.Equals(key, entryKey);
-        }
-
-        protected override DictionaryImpl<long, long, TValue> CreateNew(int capacity)
-        {
-            return new DictionaryImplLong<TValue>(capacity, this);
-        }
-
-        protected override long keyFromEntry(long entryKey)
-        {
-            return entryKey;
-        }
-    }
-
-    internal sealed class DictionaryImplLongNoComparer<TValue>
-            : DictionaryImpl<long, long, TValue>
-    {
-        internal DictionaryImplLongNoComparer(int capacity, ConcurrentDictionary<long, TValue> topDict)
-            : base(capacity, topDict)
-        {
-        }
-
-        internal DictionaryImplLongNoComparer(int capacity, DictionaryImplLongNoComparer<TValue> other)
-            : base(capacity, other)
-        {
-        }
-
-        protected override bool TryClaimSlotForPut(ref long entryKey, long key)
-        {
-            return TryClaimSlot(ref entryKey, key);
-        }
-
-        protected override bool TryClaimSlotForCopy(ref long entryKey, long key)
-        {
-            return TryClaimSlot(ref entryKey, key);
-        }
-
-        private bool TryClaimSlot(ref long entryKey, long key)
-        {
-            var entryKeyValue = entryKey;
-            //zero keys are claimed via hash
-            if (entryKeyValue == 0 & key != 0)
-            {
-                entryKeyValue = Interlocked.CompareExchange(ref entryKey, key, 0);
-                if (entryKeyValue == 0)
-                {
-                    // claimed a new slot
-                    this.allocatedSlotCount.Increment();
-                    return true;
-                }
-            }
-
-            return key == entryKeyValue;
-        }
-
-        // inline the base implementation to devirtualize calls to hash and keyEqual
-        internal override object TryGetValue(long key)
-        {
-            return base.TryGetValue(key);
-        }
-
-        protected override int hash(long key)
-        {
-            return (key == 0) ?
-                ZEROHASH :
-                key.GetHashCode() | SPECIAL_HASH_BITS;
-        }
-
-        protected override bool keyEqual(long key, long entryKey)
-        {
-            return key == entryKey;
-        }
-
-        protected override DictionaryImpl<long, long, TValue> CreateNew(int capacity)
-        {
-            return new DictionaryImplLongNoComparer<TValue>(capacity, this);
-        }
-
-        protected override long keyFromEntry(long entryKey)
-        {
-            return entryKey;
-        }
-    }
-}
diff --git a/src/libraries/System.Collections.Concurrent/src/System/Collections/Concurrent/ConcurrentDictionary/DictionaryImplNint.cs b/src/libraries/System.Collections.Concurrent/src/System/Collections/Concurrent/ConcurrentDictionary/DictionaryImplNint.cs
deleted file mode 100644
index ecaba4c2388..00000000000
--- a/src/libraries/System.Collections.Concurrent/src/System/Collections/Concurrent/ConcurrentDictionary/DictionaryImplNint.cs
+++ /dev/null
@@ -1,171 +0,0 @@
-// Copyright (c) 2022 Vladimir Sadov
-//
-// Permission is hereby granted, free of charge, to any person
-// obtaining a copy of this software and associated documentation
-// files (the "Software"), to deal in the Software without
-// restriction, including without limitation the rights to use,
-// copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the
-// Software is furnished to do so, subject to the following
-// conditions:
-//
-// The above copyright notice and this permission notice shall be
-// included in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
-// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
-// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
-// OTHER DEALINGS IN THE SOFTWARE.
-//
-// DictionaryImplNint.cs
-//
-
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.Runtime.InteropServices;
-using System.Threading;
-
-namespace System.Collections.Concurrent
-{
-    internal sealed class DictionaryImplNint<TValue>
-                : DictionaryImpl<nint, nint, TValue>
-    {
-        internal DictionaryImplNint(int capacity, ConcurrentDictionary<nint, TValue> topDict)
-            : base(capacity, topDict)
-        {
-        }
-
-        internal DictionaryImplNint(int capacity, DictionaryImplNint<TValue> other)
-            : base(capacity, other)
-        {
-        }
-
-        protected override bool TryClaimSlotForPut(ref nint entryKey, nint key)
-        {
-            return TryClaimSlot(ref entryKey, key);
-        }
-
-        protected override bool TryClaimSlotForCopy(ref nint entryKey, nint key)
-        {
-            return TryClaimSlot(ref entryKey, key);
-        }
-
-        private bool TryClaimSlot(ref nint entryKey, nint key)
-        {
-            var entryKeyValue = entryKey;
-            //zero keys are claimed via hash
-            if (entryKeyValue == 0 & key != 0)
-            {
-                entryKeyValue = Interlocked.CompareExchange(ref entryKey, key, (nint)0);
-                if (entryKeyValue == 0)
-                {
-                    // claimed a new slot
-                    this.allocatedSlotCount.Increment();
-                    return true;
-                }
-            }
-
-            return key == entryKeyValue || _keyComparer.Equals(key, entryKey);
-        }
-
-        protected override int hash(nint key)
-        {
-            if (key == 0)
-            {
-                return ZEROHASH;
-            }
-
-            return base.hash(key);
-        }
-
-        protected override bool keyEqual(nint key, nint entryKey)
-        {
-            return key == entryKey || _keyComparer.Equals(key, entryKey);
-        }
-
-        protected override DictionaryImpl<nint, nint, TValue> CreateNew(int capacity)
-        {
-            return new DictionaryImplNint<TValue>(capacity, this);
-        }
-
-        protected override nint keyFromEntry(nint entryKey)
-        {
-            return entryKey;
-        }
-    }
-
-    internal sealed class DictionaryImplNintNoComparer<TValue>
-            : DictionaryImpl<nint, nint, TValue>
-    {
-        internal DictionaryImplNintNoComparer(int capacity, ConcurrentDictionary<nint, TValue> topDict)
-            : base(capacity, topDict)
-        {
-        }
-
-        internal DictionaryImplNintNoComparer(int capacity, DictionaryImplNintNoComparer<TValue> other)
-            : base(capacity, other)
-        {
-        }
-
-        protected override bool TryClaimSlotForPut(ref nint entryKey, nint key)
-        {
-            return TryClaimSlot(ref entryKey, key);
-        }
-
-        protected override bool TryClaimSlotForCopy(ref nint entryKey, nint key)
-        {
-            return TryClaimSlot(ref entryKey, key);
-        }
-
-        private bool TryClaimSlot(ref nint entryKey, nint key)
-        {
-            var entryKeyValue = entryKey;
-            //zero keys are claimed via hash
-            if (entryKeyValue == 0 & key != 0)
-            {
-                entryKeyValue = Interlocked.CompareExchange(ref entryKey, key, (nint)0);
-                if (entryKeyValue == 0)
-                {
-                    // claimed a new slot
-                    this.allocatedSlotCount.Increment();
-                    return true;
-                }
-            }
-
-            return key == entryKeyValue;
-        }
-
-        // inline the base implementation to devirtualize calls to hash and keyEqual
-        internal override object TryGetValue(nint key)
-        {
-            return base.TryGetValue(key);
-        }
-
-        protected override int hash(nint key)
-        {
-            return (key == 0) ?
-                ZEROHASH :
-                key.GetHashCode() | SPECIAL_HASH_BITS;
-        }
-
-        protected override bool keyEqual(nint key, nint entryKey)
-        {
-            return key == entryKey;
-        }
-
-        protected override DictionaryImpl<nint, nint, TValue> CreateNew(int capacity)
-        {
-            return new DictionaryImplNintNoComparer<TValue>(capacity, this);
-        }
-
-        protected override nint keyFromEntry(nint entryKey)
-        {
-            return entryKey;
-        }
-    }
-}
diff --git a/src/libraries/System.Collections.Concurrent/src/System/Collections/Concurrent/ConcurrentDictionary/DictionaryImplNuint.cs b/src/libraries/System.Collections.Concurrent/src/System/Collections/Concurrent/ConcurrentDictionary/DictionaryImplNuint.cs
deleted file mode 100644
index a00240bfb9f..00000000000
--- a/src/libraries/System.Collections.Concurrent/src/System/Collections/Concurrent/ConcurrentDictionary/DictionaryImplNuint.cs
+++ /dev/null
@@ -1,171 +0,0 @@
-// Copyright (c) 2022 Vladimir Sadov
-//
-// Permission is hereby granted, free of charge, to any person
-// obtaining a copy of this software and associated documentation
-// files (the "Software"), to deal in the Software without
-// restriction, including without limitation the rights to use,
-// copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the
-// Software is furnished to do so, subject to the following
-// conditions:
-//
-// The above copyright notice and this permission notice shall be
-// included in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
-// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
-// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
-// OTHER DEALINGS IN THE SOFTWARE.
-//
-// DictionaryImplNuint.cs
-//
-
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.Runtime.InteropServices;
-using System.Threading;
-
-namespace System.Collections.Concurrent
-{
-    internal sealed class DictionaryImplNuint<TValue>
-                : DictionaryImpl<nuint, nuint, TValue>
-    {
-        internal DictionaryImplNuint(int capacity, ConcurrentDictionary<nuint, TValue> topDict)
-            : base(capacity, topDict)
-        {
-        }
-
-        internal DictionaryImplNuint(int capacity, DictionaryImplNuint<TValue> other)
-            : base(capacity, other)
-        {
-        }
-
-        protected override bool TryClaimSlotForPut(ref nuint entryKey, nuint key)
-        {
-            return TryClaimSlot(ref entryKey, key);
-        }
-
-        protected override bool TryClaimSlotForCopy(ref nuint entryKey, nuint key)
-        {
-            return TryClaimSlot(ref entryKey, key);
-        }
-
-        private bool TryClaimSlot(ref nuint entryKey, nuint key)
-        {
-            var entryKeyValue = entryKey;
-            //zero keys are claimed via hash
-            if (entryKeyValue == 0 & key != 0)
-            {
-                entryKeyValue = Interlocked.CompareExchange(ref entryKey, key, (nuint)0);
-                if (entryKeyValue == 0)
-                {
-                    // claimed a new slot
-                    this.allocatedSlotCount.Increment();
-                    return true;
-                }
-            }
-
-            return key == entryKeyValue || _keyComparer.Equals(key, entryKey);
-        }
-
-        protected override int hash(nuint key)
-        {
-            if (key == 0)
-            {
-                return ZEROHASH;
-            }
-
-            return base.hash(key);
-        }
-
-        protected override bool keyEqual(nuint key, nuint entryKey)
-        {
-            return key == entryKey || _keyComparer.Equals(key, entryKey);
-        }
-
-        protected override DictionaryImpl<nuint, nuint, TValue> CreateNew(int capacity)
-        {
-            return new DictionaryImplNuint<TValue>(capacity, this);
-        }
-
-        protected override nuint keyFromEntry(nuint entryKey)
-        {
-            return entryKey;
-        }
-    }
-
-    internal sealed class DictionaryImplNuintNoComparer<TValue>
-            : DictionaryImpl<nuint, nuint, TValue>
-    {
-        internal DictionaryImplNuintNoComparer(int capacity, ConcurrentDictionary<nuint, TValue> topDict)
-            : base(capacity, topDict)
-        {
-        }
-
-        internal DictionaryImplNuintNoComparer(int capacity, DictionaryImplNuintNoComparer<TValue> other)
-            : base(capacity, other)
-        {
-        }
-
-        protected override bool TryClaimSlotForPut(ref nuint entryKey, nuint key)
-        {
-            return TryClaimSlot(ref entryKey, key);
-        }
-
-        protected override bool TryClaimSlotForCopy(ref nuint entryKey, nuint key)
-        {
-            return TryClaimSlot(ref entryKey, key);
-        }
-
-        private bool TryClaimSlot(ref nuint entryKey, nuint key)
-        {
-            var entryKeyValue = entryKey;
-            //zero keys are claimed via hash
-            if (entryKeyValue == 0 & key != 0)
-            {
-                entryKeyValue = Interlocked.CompareExchange(ref entryKey, key, (nuint)0);
-                if (entryKeyValue == 0)
-                {
-                    // claimed a new slot
-                    this.allocatedSlotCount.Increment();
-                    return true;
-                }
-            }
-
-            return key == entryKeyValue;
-        }
-
-        // inline the base implementation to devirtualize calls to hash and keyEqual
-        internal override object TryGetValue(nuint key)
-        {
-            return base.TryGetValue(key);
-        }
-
-        protected override int hash(nuint key)
-        {
-            return (key == 0) ?
-                ZEROHASH :
-                key.GetHashCode() | SPECIAL_HASH_BITS;
-        }
-
-        protected override bool keyEqual(nuint key, nuint entryKey)
-        {
-            return key == entryKey;
-        }
-
-        protected override DictionaryImpl<nuint, nuint, TValue> CreateNew(int capacity)
-        {
-            return new DictionaryImplNuintNoComparer<TValue>(capacity, this);
-        }
-
-        protected override nuint keyFromEntry(nuint entryKey)
-        {
-            return entryKey;
-        }
-    }
-}
diff --git a/src/libraries/System.Collections.Concurrent/src/System/Collections/Concurrent/ConcurrentDictionary/DictionaryImplRef.cs b/src/libraries/System.Collections.Concurrent/src/System/Collections/Concurrent/ConcurrentDictionary/DictionaryImplRef.cs
deleted file mode 100644
index bb8a1091dc3..00000000000
--- a/src/libraries/System.Collections.Concurrent/src/System/Collections/Concurrent/ConcurrentDictionary/DictionaryImplRef.cs
+++ /dev/null
@@ -1,121 +0,0 @@
-// Copyright (c) 2022 Vladimir Sadov
-//
-// Permission is hereby granted, free of charge, to any person
-// obtaining a copy of this software and associated documentation
-// files (the "Software"), to deal in the Software without
-// restriction, including without limitation the rights to use,
-// copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the
-// Software is furnished to do so, subject to the following
-// conditions:
-//
-// The above copyright notice and this permission notice shall be
-// included in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
-// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
-// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
-// OTHER DEALINGS IN THE SOFTWARE.
-//
-// DictionaryImplRef.cs
-//
-
-#nullable disable
-
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-using System.Threading;
-
-namespace System.Collections.Concurrent
-{
-    internal sealed class DictionaryImplRef<TKey, TKeyStore, TValue>
-            : DictionaryImpl<TKey, TKey, TValue>
-    {
-        internal DictionaryImplRef(int capacity, ConcurrentDictionary<TKey, TValue> topDict)
-            : base(capacity, topDict)
-        {
-            Debug.Assert(!typeof(TKey).IsValueType);
-        }
-
-        internal DictionaryImplRef(int capacity, DictionaryImplRef<TKey, TKeyStore, TValue> other)
-            : base(capacity, other)
-        {
-            Debug.Assert(!typeof(TKey).IsValueType);
-        }
-
-        protected override bool TryClaimSlotForPut(ref TKey entryKey, TKey key)
-        {
-            return TryClaimSlot(ref entryKey, key);
-        }
-
-        protected override bool TryClaimSlotForCopy(ref TKey entryKey, TKey key)
-        {
-            return TryClaimSlot(ref entryKey, key);
-        }
-
-        private bool TryClaimSlot(ref TKey entryKey, TKey key)
-        {
-            ref object keyLocation = ref Unsafe.As<TKey, object>(ref entryKey);
-            object entryKeyValue = keyLocation;
-            if (entryKeyValue == null)
-            {
-                entryKeyValue = Interlocked.CompareExchange(ref keyLocation, key, null);
-                if (entryKeyValue == null)
-                {
-                    // claimed a new slot
-                    this.allocatedSlotCount.Increment();
-                    return true;
-                }
-            }
-
-            return (object)key == entryKeyValue ||
-                _keyComparer.Equals(key, Unsafe.As<object, TKey>(ref entryKeyValue));
-        }
-
-        // inline the base implementation to devirtualize calls to hash and keyEqual
-        internal override object TryGetValue(TKey key)
-        {
-            return base.TryGetValue(key);
-        }
-
-        protected override int hash(TKey key)
-        {
-            return base.hash(key);
-        }
-
-        protected override bool keyEqual(TKey key, TKey entryKey)
-        {
-            if ((object)key == (object)entryKey)
-            {
-                return true;
-            }
-
-            //NOTE: slots are claimed in two stages - claim a hash, then set a key
-            //      it is possible to observe a slot with a null key, but with hash already set
-            //      that is not a match since the key is not yet in the table
-            if (entryKey == null)
-            {
-                return false;
-            }
-
-            return _keyComparer.Equals(entryKey, key);
-        }
-
-        protected override DictionaryImpl<TKey, TKey, TValue> CreateNew(int capacity)
-        {
-            return new DictionaryImplRef<TKey, TKeyStore, TValue>(capacity, this);
-        }
-
-        protected override TKey keyFromEntry(TKey entryKey)
-        {
-            return entryKey;
-        }
-    }
-}
diff --git a/src/libraries/System.Collections.Concurrent/src/System/Collections/Concurrent/ConcurrentDictionary/DictionaryImplUint.cs b/src/libraries/System.Collections.Concurrent/src/System/Collections/Concurrent/ConcurrentDictionary/DictionaryImplUint.cs
deleted file mode 100644
index 0af7da5fef8..00000000000
--- a/src/libraries/System.Collections.Concurrent/src/System/Collections/Concurrent/ConcurrentDictionary/DictionaryImplUint.cs
+++ /dev/null
@@ -1,171 +0,0 @@
-// Copyright (c) 2022 Vladimir Sadov
-//
-// Permission is hereby granted, free of charge, to any person
-// obtaining a copy of this software and associated documentation
-// files (the "Software"), to deal in the Software without
-// restriction, including without limitation the rights to use,
-// copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the
-// Software is furnished to do so, subject to the following
-// conditions:
-//
-// The above copyright notice and this permission notice shall be
-// included in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
-// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
-// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
-// OTHER DEALINGS IN THE SOFTWARE.
-//
-// DictionaryImplUint.cs
-//
-
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.Runtime.InteropServices;
-using System.Threading;
-
-namespace System.Collections.Concurrent
-{
-    internal sealed class DictionaryImplUint<TValue>
-                : DictionaryImpl<uint, uint, TValue>
-    {
-        internal DictionaryImplUint(int capacity, ConcurrentDictionary<uint, TValue> topDict)
-            : base(capacity, topDict)
-        {
-        }
-
-        internal DictionaryImplUint(int capacity, DictionaryImplUint<TValue> other)
-            : base(capacity, other)
-        {
-        }
-
-        protected override bool TryClaimSlotForPut(ref uint entryKey, uint key)
-        {
-            return TryClaimSlot(ref entryKey, key);
-        }
-
-        protected override bool TryClaimSlotForCopy(ref uint entryKey, uint key)
-        {
-            return TryClaimSlot(ref entryKey, key);
-        }
-
-        private bool TryClaimSlot(ref uint entryKey, uint key)
-        {
-            var entryKeyValue = entryKey;
-            //zero keys are claimed via hash
-            if (entryKeyValue == 0 & key != 0)
-            {
-                entryKeyValue = Interlocked.CompareExchange(ref entryKey, key, 0);
-                if (entryKeyValue == 0)
-                {
-                    // claimed a new slot
-                    this.allocatedSlotCount.Increment();
-                    return true;
-                }
-            }
-
-            return key == entryKeyValue || _keyComparer.Equals(key, entryKey);
-        }
-
-        protected override int hash(uint key)
-        {
-            if (key == 0)
-            {
-                return ZEROHASH;
-            }
-
-            return base.hash(key);
-        }
-
-        protected override bool keyEqual(uint key, uint entryKey)
-        {
-            return key == entryKey || _keyComparer.Equals(key, entryKey);
-        }
-
-        protected override DictionaryImpl<uint, uint, TValue> CreateNew(int capacity)
-        {
-            return new DictionaryImplUint<TValue>(capacity, this);
-        }
-
-        protected override uint keyFromEntry(uint entryKey)
-        {
-            return entryKey;
-        }
-    }
-
-    internal sealed class DictionaryImplUintNoComparer<TValue>
-            : DictionaryImpl<uint, uint, TValue>
-    {
-        internal DictionaryImplUintNoComparer(int capacity, ConcurrentDictionary<uint, TValue> topDict)
-            : base(capacity, topDict)
-        {
-        }
-
-        internal DictionaryImplUintNoComparer(int capacity, DictionaryImplUintNoComparer<TValue> other)
-            : base(capacity, other)
-        {
-        }
-
-        protected override bool TryClaimSlotForPut(ref uint entryKey, uint key)
-        {
-            return TryClaimSlot(ref entryKey, key);
-        }
-
-        protected override bool TryClaimSlotForCopy(ref uint entryKey, uint key)
-        {
-            return TryClaimSlot(ref entryKey, key);
-        }
-
-        private bool TryClaimSlot(ref uint entryKey, uint key)
-        {
-            var entryKeyValue = entryKey;
-            //zero keys are claimed via hash
-            if (entryKeyValue == 0 & key != 0)
-            {
-                entryKeyValue = Interlocked.CompareExchange(ref entryKey, key, 0);
-                if (entryKeyValue == 0)
-                {
-                    // claimed a new slot
-                    this.allocatedSlotCount.Increment();
-                    return true;
-                }
-            }
-
-            return key == entryKeyValue;
-        }
-
-        // inline the base implementation to devirtualize calls to hash and keyEqual
-        internal override object TryGetValue(uint key)
-        {
-            return base.TryGetValue(key);
-        }
-
-        protected override int hash(uint key)
-        {
-            return (key == 0) ?
-                ZEROHASH :
-                (int)key | SPECIAL_HASH_BITS;
-        }
-
-        protected override bool keyEqual(uint key, uint entryKey)
-        {
-            return key == entryKey;
-        }
-
-        protected override DictionaryImpl<uint, uint, TValue> CreateNew(int capacity)
-        {
-            return new DictionaryImplUintNoComparer<TValue>(capacity, this);
-        }
-
-        protected override uint keyFromEntry(uint entryKey)
-        {
-            return entryKey;
-        }
-    }
-}
diff --git a/src/libraries/System.Collections.Concurrent/src/System/Collections/Concurrent/ConcurrentDictionary/DictionaryImplUlong.cs b/src/libraries/System.Collections.Concurrent/src/System/Collections/Concurrent/ConcurrentDictionary/DictionaryImplUlong.cs
deleted file mode 100644
index ea1c5a64b7a..00000000000
--- a/src/libraries/System.Collections.Concurrent/src/System/Collections/Concurrent/ConcurrentDictionary/DictionaryImplUlong.cs
+++ /dev/null
@@ -1,171 +0,0 @@
-// Copyright (c) 2022 Vladimir Sadov
-//
-// Permission is hereby granted, free of charge, to any person
-// obtaining a copy of this software and associated documentation
-// files (the "Software"), to deal in the Software without
-// restriction, including without limitation the rights to use,
-// copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the
-// Software is furnished to do so, subject to the following
-// conditions:
-//
-// The above copyright notice and this permission notice shall be
-// included in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
-// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
-// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
-// OTHER DEALINGS IN THE SOFTWARE.
-//
-// DictionaryImplUlong.cs
-//
-
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.Runtime.InteropServices;
-using System.Threading;
-
-namespace System.Collections.Concurrent
-{
-    internal sealed class DictionaryImplUlong<TValue>
-                : DictionaryImpl<ulong, ulong, TValue>
-    {
-        internal DictionaryImplUlong(int capacity, ConcurrentDictionary<ulong, TValue> topDict)
-            : base(capacity, topDict)
-        {
-        }
-
-        internal DictionaryImplUlong(int capacity, DictionaryImplUlong<TValue> other)
-            : base(capacity, other)
-        {
-        }
-
-        protected override bool TryClaimSlotForPut(ref ulong entryKey, ulong key)
-        {
-            return TryClaimSlot(ref entryKey, key);
-        }
-
-        protected override bool TryClaimSlotForCopy(ref ulong entryKey, ulong key)
-        {
-            return TryClaimSlot(ref entryKey, key);
-        }
-
-        private bool TryClaimSlot(ref ulong entryKey, ulong key)
-        {
-            var entryKeyValue = entryKey;
-            //zero keys are claimed via hash
-            if (entryKeyValue == 0 & key != 0)
-            {
-                entryKeyValue = Interlocked.CompareExchange(ref entryKey, key, 0);
-                if (entryKeyValue == 0)
-                {
-                    // claimed a new slot
-                    this.allocatedSlotCount.Increment();
-                    return true;
-                }
-            }
-
-            return key == entryKeyValue || _keyComparer.Equals(key, entryKey);
-        }
-
-        protected override int hash(ulong key)
-        {
-            if (key == 0)
-            {
-                return ZEROHASH;
-            }
-
-            return base.hash(key);
-        }
-
-        protected override bool keyEqual(ulong key, ulong entryKey)
-        {
-            return key == entryKey || _keyComparer.Equals(key, entryKey);
-        }
-
-        protected override DictionaryImpl<ulong, ulong, TValue> CreateNew(int capacity)
-        {
-            return new DictionaryImplUlong<TValue>(capacity, this);
-        }
-
-        protected override ulong keyFromEntry(ulong entryKey)
-        {
-            return entryKey;
-        }
-    }
-
-    internal sealed class DictionaryImplUlongNoComparer<TValue>
-            : DictionaryImpl<ulong, ulong, TValue>
-    {
-        internal DictionaryImplUlongNoComparer(int capacity, ConcurrentDictionary<ulong, TValue> topDict)
-            : base(capacity, topDict)
-        {
-        }
-
-        internal DictionaryImplUlongNoComparer(int capacity, DictionaryImplUlongNoComparer<TValue> other)
-            : base(capacity, other)
-        {
-        }
-
-        protected override bool TryClaimSlotForPut(ref ulong entryKey, ulong key)
-        {
-            return TryClaimSlot(ref entryKey, key);
-        }
-
-        protected override bool TryClaimSlotForCopy(ref ulong entryKey, ulong key)
-        {
-            return TryClaimSlot(ref entryKey, key);
-        }
-
-        private bool TryClaimSlot(ref ulong entryKey, ulong key)
-        {
-            var entryKeyValue = entryKey;
-            //zero keys are claimed via hash
-            if (entryKeyValue == 0 & key != 0)
-            {
-                entryKeyValue = Interlocked.CompareExchange(ref entryKey, key, 0);
-                if (entryKeyValue == 0)
-                {
-                    // claimed a new slot
-                    this.allocatedSlotCount.Increment();
-                    return true;
-                }
-            }
-
-            return key == entryKeyValue;
-        }
-
-        // inline the base implementation to devirtualize calls to hash and keyEqual
-        internal override object TryGetValue(ulong key)
-        {
-            return base.TryGetValue(key);
-        }
-
-        protected override int hash(ulong key)
-        {
-            return (key == 0) ?
-                ZEROHASH :
-                key.GetHashCode() | SPECIAL_HASH_BITS;
-        }
-
-        protected override bool keyEqual(ulong key, ulong entryKey)
-        {
-            return key == entryKey;
-        }
-
-        protected override DictionaryImpl<ulong, ulong, TValue> CreateNew(int capacity)
-        {
-            return new DictionaryImplUlongNoComparer<TValue>(capacity, this);
-        }
-
-        protected override ulong keyFromEntry(ulong entryKey)
-        {
-            return entryKey;
-        }
-    }
-}
diff --git a/src/libraries/System.Collections.Concurrent/src/System/Collections/Concurrent/ConcurrentDictionary/DictionaryImpl`2.cs b/src/libraries/System.Collections.Concurrent/src/System/Collections/Concurrent/ConcurrentDictionary/DictionaryImpl`2.cs
deleted file mode 100644
index e8d0aec2ce9..00000000000
--- a/src/libraries/System.Collections.Concurrent/src/System/Collections/Concurrent/ConcurrentDictionary/DictionaryImpl`2.cs
+++ /dev/null
@@ -1,107 +0,0 @@
-// Copyright (c) 2022 Vladimir Sadov
-//
-// Permission is hereby granted, free of charge, to any person
-// obtaining a copy of this software and associated documentation
-// files (the "Software"), to deal in the Software without
-// restriction, including without limitation the rights to use,
-// copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the
-// Software is furnished to do so, subject to the following
-// conditions:
-//
-// The above copyright notice and this permission notice shall be
-// included in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
-// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
-// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
-// OTHER DEALINGS IN THE SOFTWARE.
-//
-// DictionaryImpl`2.cs
-//
-
-#nullable disable
-
-using System;
-using System.Collections;
-using System.Collections.Generic;
-using System.Reflection;
-using System.Runtime.CompilerServices;
-
-namespace System.Collections.Concurrent
-{
-    internal abstract class DictionaryImpl<TKey, TValue>
-        : DictionaryImpl
-    {
-        internal readonly bool valueIsValueType = typeof(TValue).IsValueType;
-        internal IEqualityComparer<TKey> _keyComparer;
-
-        internal DictionaryImpl() { }
-
-        internal abstract void Clear();
-        internal abstract int Count { get; }
-
-        internal abstract object TryGetValue(TKey key);
-        internal abstract bool PutIfMatch(TKey key, TValue newVal, ref TValue oldValue, ValueMatch match);
-        internal abstract bool RemoveIfMatch(TKey key, ref TValue oldValue, ValueMatch match);
-        internal abstract TValue GetOrAdd(TKey key, Func<TKey, TValue> valueFactory);
-
-        internal abstract Snapshot GetSnapshot();
-
-        internal abstract class Snapshot
-        {
-            protected int _idx;
-            protected TKey _curKey;
-            protected TValue _curValue;
-
-            public abstract int Count { get; }
-            public abstract bool MoveNext();
-            public abstract void Reset();
-
-            internal DictionaryEntry Entry
-            {
-                get
-                {
-                    return new DictionaryEntry(_curKey, _curValue);
-                }
-            }
-
-            internal KeyValuePair<TKey, TValue> Current
-            {
-                get
-                {
-                    return new KeyValuePair<TKey, TValue>(this._curKey, _curValue);
-                }
-            }
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        protected TValue FromObjectValue(object obj)
-        {
-            // regular value type
-            if (default(TValue) != null)
-            {
-                return Unsafe.As<Boxed<TValue>>(obj).Value;
-            }
-
-            // null
-            if (obj == NULLVALUE)
-            {
-                return default(TValue);
-            }
-
-            // ref type
-            if (!valueIsValueType)
-            {
-                return Unsafe.As<object, TValue>(ref obj);
-            }
-
-            // nullable
-            return (TValue)obj;
-        }
-    }
-}
diff --git a/src/libraries/System.Collections.Concurrent/src/System/Collections/Concurrent/ConcurrentDictionary/DictionaryImpl`3.cs b/src/libraries/System.Collections.Concurrent/src/System/Collections/Concurrent/ConcurrentDictionary/DictionaryImpl`3.cs
deleted file mode 100644
index 5c871c01618..00000000000
--- a/src/libraries/System.Collections.Concurrent/src/System/Collections/Concurrent/ConcurrentDictionary/DictionaryImpl`3.cs
+++ /dev/null
@@ -1,1473 +0,0 @@
-// Copyright (c) 2022 Vladimir Sadov
-//
-// Permission is hereby granted, free of charge, to any person
-// obtaining a copy of this software and associated documentation
-// files (the "Software"), to deal in the Software without
-// restriction, including without limitation the rights to use,
-// copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the
-// Software is furnished to do so, subject to the following
-// conditions:
-//
-// The above copyright notice and this permission notice shall be
-// included in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
-// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
-// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
-// OTHER DEALINGS IN THE SOFTWARE.
-//
-// DictionaryImpl`3.cs
-//
-
-//
-// Core algorithms are based on NonBlockingHashMap,
-// written and released to the public domain by Dr.Cliff Click.
-// A good overview is here https://www.youtube.com/watch?v=HJ-719EGIts
-//
-
-#nullable disable
-
-using System;
-using System.Collections;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.Reflection;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-using System.Threading;
-using System.Threading.Tasks;
-
-namespace System.Collections.Concurrent
-{
-    internal abstract partial class DictionaryImpl<TKey, TKeyStore, TValue>
-        : DictionaryImpl<TKey, TValue>
-    {
-        private readonly Entry[] _entries;
-        internal DictionaryImpl<TKey, TKeyStore, TValue> _newTable;
-
-        protected readonly ConcurrentDictionary<TKey, TValue> _topDict;
-        protected readonly Counter32 allocatedSlotCount = new Counter32();
-        private Counter32 _size;
-
-        internal static readonly bool valueIsAtomic = IsValueAtomicPrimitive();
-
-        // Sometimes many threads race to create a new very large table.  Only 1
-        // wins the race, but the losers all allocate a junk large table with
-        // hefty allocation costs.  Attempt to control the overkill here by
-        // throttling attempts to create a new table.  I cannot really block here
-        // (lest I lose the non-blocking property) but late-arriving threads can
-        // give the initial resizing thread a little time to allocate the initial
-        // new table.
-        //
-        // count of threads attempting an initial resize
-        private int _resizers;
-
-        // The next part of the table to copy.  It monotonically transits from zero
-        // to table.length.  Visitors to the table can claim 'work chunks' by
-        // CAS'ing this field up, then copying the indicated indices from the old
-        // table to the new table.  Workers are not required to finish any chunk;
-        // the counter simply wraps and work is copied duplicately until somebody
-        // somewhere completes the count.
-        private int _claimedChunk;
-
-        // Work-done reporting.  Used to efficiently signal when we can move to
-        // the new table.  From 0 to length of old table refers to copying from the old
-        // table to the new.
-        private int _copyDone;
-
-        [DebuggerDisplay("key = {key}; hash = {hash}; value = {value};")]
-        [StructLayout(LayoutKind.Sequential)]
-        public struct Entry
-        {
-            internal int hash;
-            internal TKeyStore key;
-            internal object value;
-        }
-
-        private const int MIN_SIZE = 8;
-
-        // targeted time span between resizes.
-        // if resizing more often than this, try expanding.
-        private const uint RESIZE_MILLIS_TARGET = (uint)1000;
-
-        // create an empty dictionary
-        protected abstract DictionaryImpl<TKey, TKeyStore, TValue> CreateNew(int capacity);
-
-        // convert key from its storage form (noop or unboxing) used in Key enumarators
-        protected abstract TKey keyFromEntry(TKeyStore entryKey);
-
-        // compares key with another in its storage form
-        protected abstract bool keyEqual(TKey key, TKeyStore entryKey);
-
-        // claiming (by writing atomically to the entryKey location)
-        // or getting existing slot suitable for storing a given key.
-        protected abstract bool TryClaimSlotForPut(ref TKeyStore entryKey, TKey key);
-
-        // claiming (by writing atomically to the entryKey location)
-        // or getting existing slot suitable for storing a given key in its store form (could be boxed).
-        protected abstract bool TryClaimSlotForCopy(ref TKeyStore entryKey, TKeyStore key);
-
-        internal DictionaryImpl(int capacity, ConcurrentDictionary<TKey, TValue> topDict)
-        {
-            capacity = Math.Max(capacity, MIN_SIZE);
-
-            capacity = HashHelpers.AlignToPowerOfTwo(capacity);
-            this._entries = new Entry[capacity];
-            this._size = new Counter32();
-            this._topDict = topDict;
-
-            if (RuntimeHelpers.IsReferenceOrContainsReferences<TKey>())
-            {
-                // do not create a real sweeper just yet. Often it is not needed.
-                topDict._sweeperInstance = NULLVALUE;
-            }
-
-            _ = valueIsAtomic;
-        }
-
-        protected DictionaryImpl(int capacity, DictionaryImpl<TKey, TKeyStore, TValue> other)
-        {
-            capacity = HashHelpers.AlignToPowerOfTwo(capacity);
-            this._entries = new Entry[capacity];
-            this._size = other._size;
-            this._topDict = other._topDict;
-            this._keyComparer = other._keyComparer;
-        }
-
-        /// <summary>
-        /// Determines whether type TValue can be written atomically
-        /// </summary>
-        private static bool IsValueAtomicPrimitive()
-        {
-            // only intereste in primitive value types here.
-            if (default(TValue) == null)
-            {
-                return false;
-            }
-
-            //
-            // Section 12.6.6 of ECMA CLI explains which types can be read and written atomically without
-            // the risk of tearing.
-            //
-            // See http://www.ecma-international.org/publications/files/ECMA-ST/Ecma-335.pdf
-            //
-            if (typeof(TValue) == typeof(bool) ||
-                typeof(TValue) == typeof(byte) ||
-                typeof(TValue) == typeof(char) ||
-                typeof(TValue) == typeof(short) ||
-                typeof(TValue) == typeof(int) ||
-                typeof(TValue) == typeof(sbyte) ||
-                typeof(TValue) == typeof(float) ||
-                typeof(TValue) == typeof(ushort) ||
-                typeof(TValue) == typeof(uint) ||
-                typeof(TValue) == typeof(IntPtr) ||
-                typeof(TValue) == typeof(UIntPtr))
-            {
-                return true;
-            }
-
-            if (typeof(TValue) == typeof(long) ||
-                typeof(TValue) == typeof(double) ||
-                typeof(TValue) == typeof(ulong))
-            {
-                return IntPtr.Size == 8;
-            }
-
-            return false;
-        }
-
-        private static uint CurrentTickMillis()
-        {
-            return (uint)Environment.TickCount;
-        }
-
-        protected virtual int hash(TKey key)
-        {
-            Debug.Assert(!(key is null));
-
-            int h = _keyComparer.GetHashCode(key);
-
-            // ensure that hash never matches 0, TOMBPRIMEHASH, ZEROHASH or REGULAR_HASH_BITS
-            return h | (SPECIAL_HASH_BITS | 1);
-        }
-
-        internal sealed override int Count
-        {
-            get
-            {
-                return this.Size;
-            }
-        }
-
-        internal sealed override void Clear()
-        {
-            var newTable = CreateNew(MIN_SIZE);
-            newTable._size = new Counter32();
-            _topDict._table = newTable;
-        }
-
-        /// <summary>
-        /// returns null if value is not present in the table
-        /// otherwise returns the actual value or NULLVALUE if null is the actual value
-        /// </summary>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        internal override object TryGetValue(TKey key)
-        {
-            int fullHash = this.hash(key);
-            var curTable = this;
-
-        tryWithNewTable:
-
-            var lenMask = curTable._entries.Length - 1;
-            int idx = ReduceHashToIndex(fullHash, lenMask);
-
-            // Main spin/reprobe loop
-            int reprobeCount = 0;
-            while (true)
-            {
-                ref var entry = ref curTable._entries[idx];
-
-                // an entry is never reused for a different key
-                // key/value/hash all read atomically and order of reads is unimportant
-
-                // is this our slot?
-                if (fullHash == entry.hash && keyEqual(key, entry.key))
-                {
-                    // read the value before the _newTable.
-                    // if the new table is null later, then the value cannot be forwarded
-                    // this also orders reads from the table.
-                    var entryValue = Volatile.Read(ref entry.value);
-                    if (EntryValueNullOrDead(entryValue))
-                    {
-                        break;
-                    }
-
-                    // "READ BARRIER", if copying has started, we must help with copying and
-                    // read from the new table.
-
-                    // if no new table, no need to check for primed value,
-                    // but TOMBPRIME is possible when sweeping, check for that
-                    if ((curTable._newTable == null && entryValue != TOMBPRIME) ||
-                        entryValue.GetType() != typeof(Prime))
-                    {
-                        return entryValue;
-                    }
-
-                    // found a prime, that means the copying or sweeping has started
-                    // help and retry in the new table
-                    curTable = curTable.CopySlotAndGetNewTable(ref entry, shouldHelp: true);
-                    goto tryWithNewTable;
-                }
-
-                if (entry.hash == 0)
-                {
-                    // the slot has not been claimed - the rest of the bucket is empty
-                    break;
-                }
-
-                // get, put and remove must have the same key lookup logic.
-                // But only 'put' needs to force a table-resize for a too-long key-reprobe sequence
-                // hitting reprobe limit or finding TOMBPRIMEHASH here means that the key is not in this table,
-                // but there could be more in the new table
-                if (entry.hash == TOMBPRIMEHASH || reprobeCount >= ReprobeLimit(lenMask))
-                {
-                    if (curTable._newTable != null)
-                    {
-                        curTable.HelpCopy();
-                        curTable = curTable._newTable;
-                        goto tryWithNewTable;
-                    }
-
-                    // no new table, so this is a miss
-                    break;
-                }
-
-                // quadratic reprobe
-                reprobeCount++;
-                curTable.ResizeOnReprobeCheck(reprobeCount);
-                idx = (idx + reprobeCount) & lenMask;
-            }
-
-            return null;
-        }
-
-        /// <summary>
-        /// returns true if value was removed from the table.
-        /// oldVal contains original value or default(TValue), if it was not present in the table
-        /// </summary>
-        internal sealed override bool RemoveIfMatch(TKey key, ref TValue oldVal, ValueMatch match)
-        {
-            Debug.Assert(
-                match == ValueMatch.NotNullOrDead ||
-                match == ValueMatch.OldValue ||
-                match == ValueMatch.Any);   // same as NotNullOrDead, but not reporting the old value
-
-            var curTable = this;
-            int fullHash = curTable.hash(key);
-
-        tryWithNewTable:
-
-            var lenMask = curTable._entries.Length - 1;
-            int idx = ReduceHashToIndex(fullHash, lenMask);
-            ref Entry entry = ref curTable._entries[idx];
-
-            // Main spin/reprobe loop
-            int reprobeCount = 0;
-            while (true)
-            {
-                // an entry is never reused for a different key
-                // key/value/hash all read atomically and order of reads is unimportant
-                var entryHash = entry.hash;
-
-                // is this our slot?
-                if (fullHash == entryHash && curTable.keyEqual(key, entry.key))
-                {
-                    break;
-                }
-
-                if (entryHash == 0)
-                {
-                    // Found an unassigned slot - which means this
-                    // key has never been in this table.
-                    oldVal = default;
-                    goto FAILED;
-                }
-
-                // get, put and remove must have the same key lookup logic.
-                // But only 'put' needs to force a table-resize for a too-long key-reprobe sequence
-                // hitting reprobe limit or finding TOMBPRIMEHASH here means that the key is not in this table,
-                // but there could be more in the new table
-                if (entryHash == TOMBPRIMEHASH || reprobeCount >= ReprobeLimit(lenMask))
-                {
-                    if (curTable._newTable != null)
-                    {
-                        curTable.HelpCopy();
-                        curTable = curTable._newTable;
-                        goto tryWithNewTable;
-                    }
-
-                    // no new table, so this is a miss
-                    goto FAILED;
-                }
-
-                // quadratic reprobing
-                reprobeCount++;
-                curTable.ResizeOnReprobeCheck(reprobeCount);
-                idx = (idx + reprobeCount) & lenMask;
-                entry = ref curTable._entries[idx];
-            }
-
-            // Found the proper Key slot, now update the Value.
-            // We never put a null, so Value slots monotonically move from null to
-            // not-null (deleted Values use Tombstone).
-
-            // volatile read to make sure we read the element before we read the _newTable
-            // that would guarantee that as long as _newTable == null, entryValue cannot be forwarded.
-            var entryValue = Volatile.Read(ref entry.value);
-            var newTable = curTable._newTable;
-
-            // See if we are moving to a new table.
-            // If so, copy our slot and retry in the new table.
-            // Seeing TOMBPRIME entry while no newTable means the slot is in a process of being deleted
-            // Let CopySlotAndGetNewTable handle that case too.
-            if (newTable != null || entryValue == TOMBPRIME)
-            {
-                var newTable1 = curTable.CopySlotAndGetNewTable(ref entry, shouldHelp: true);
-                Debug.Assert(newTable == newTable1 || (newTable == null && newTable1 == this));
-                curTable = newTable1;
-                goto tryWithNewTable;
-            }
-
-            // We are finally prepared to update the existing table
-            while (true)
-            {
-                Debug.Assert(!(entryValue is Prime));
-
-                // can't remove if nothing is there
-                if (EntryValueNullOrDead(entryValue))
-                {
-                    oldVal = default;
-                    goto FAILED;
-                }
-
-                if (ValueIsAtomicPrimitive() && match != ValueMatch.Any)
-                {
-                    // must freeze before removing or before checking for value match
-                    // unless it is "Any" case where we have no witnesses of the old value
-                    // and can assume all writes in the current box "happened before" the remove.
-                    Unsafe.As<Boxed<TValue>>(entryValue).Freeze();
-                }
-
-                if (match == ValueMatch.OldValue)
-                {
-                    TValue unboxedEntryValue = FromObjectValue(entryValue);
-                    if (!EqualityComparer<TValue>.Default.Equals(oldVal, unboxedEntryValue))
-                    {
-                        oldVal = unboxedEntryValue;
-                        goto FAILED;
-                    }
-                }
-
-                // Actually change the Value
-                var prev = Interlocked.CompareExchange(ref entry.value, TOMBSTONE, entryValue);
-                if (prev == entryValue)
-                {
-                    // CAS succeeded - we removed!
-                    if (match == ValueMatch.NotNullOrDead)
-                    {
-                        oldVal = FromObjectValue(prev);
-                    }
-
-                    // Adjust the size
-                    curTable._size.Decrement();
-                    SweepCheck();
-
-                    return true;
-                }
-
-                // If a Prime'd value got installed, we need to re-run on the new table.
-                Debug.Assert(prev != null);
-                if (prev.GetType() == typeof(Prime))
-                {
-                    curTable = curTable.CopySlotAndGetNewTable(ref entry, shouldHelp: true);
-                    goto tryWithNewTable;
-                }
-
-                // Otherwise we lost the CAS to another racing put/remove.
-                // Simply retry from the start.
-                entryValue = prev;
-            }
-
-        FAILED:
-            return false;
-        }
-
-        // 1) finds or creates a slot for the key
-        // 2) sets the slot value to the newVal if original value meets oldVal and match condition
-        // 3) returns true if the value was actually changed
-        // Note that pre-existence of the slot is irrelevant
-        // since slot without a value is as good as no slot at all
-        internal sealed override bool PutIfMatch(TKey key, TValue newVal, ref TValue oldVal, ValueMatch match)
-        {
-            Debug.Assert(
-                match == ValueMatch.NullOrDead ||
-                match == ValueMatch.OldValue ||
-                match == ValueMatch.Any);
-
-            var curTable = this;
-            int fullHash = curTable.hash(key);
-
-        tryWithNewTable:
-
-            var lenMask = curTable._entries.Length - 1;
-            int idx = ReduceHashToIndex(fullHash, lenMask);
-            ref Entry entry = ref curTable._entries[idx];
-
-            // Spin till we get a slot for the key or force a resizing.
-            int reprobeCount = 0;
-            while (true)
-            {
-                // an entry is never reused for a different key
-                // key/value/hash all read atomically and order of reads is unimportant
-                var entryHash = entry.hash;
-                if (entryHash == 0)
-                {
-                    // Found an unassigned slot - which means this key has never been in this table.
-                    // claim the hash first
-                    Debug.Assert(fullHash != 0);
-                    entryHash = Interlocked.CompareExchange(ref entry.hash, fullHash, 0);
-                    if (entryHash == 0)
-                    {
-                        entryHash = fullHash;
-                        if (entryHash == ZEROHASH)
-                        {
-                            // "added" entry for zero key
-                            curTable.allocatedSlotCount.Increment();
-                            break;
-                        }
-                    }
-                }
-
-                if (entryHash == fullHash)
-                {
-                    // hash is good, one way or another,
-                    // try claiming the slot for the key
-                    if (curTable.TryClaimSlotForPut(ref entry.key, key))
-                    {
-                        break;
-                    }
-                }
-
-                // here we know that this slot does not map to our key and must reprobe or resize
-                // hitting reprobe limit or finding TOMBPRIMEHASH here means that the key is not in this table,
-                // but there could be more in the new table
-                if (entryHash == TOMBPRIMEHASH || reprobeCount >= ReprobeLimit(lenMask))
-                {
-                    // start resize or get new table if resize is already in progress
-                    var newTable1 = curTable.Resize(isForReprobe: true);
-                    // help along an existing copy
-                    curTable.HelpCopy();
-                    curTable = newTable1;
-                    goto tryWithNewTable;
-                }
-
-                // quadratic reprobing
-                reprobeCount++;
-                curTable.ResizeOnReprobeCheck(reprobeCount);
-                idx = (idx + reprobeCount) & lenMask;
-                entry = ref curTable._entries[idx];
-            }
-
-            // Found the proper Key slot, now update the Value.
-            // We never put a null, so Value slots monotonically move from null to
-            // not-null (deleted Values use Tombstone).
-
-            // volatile read to make sure we read the element before we read the _newTable
-            // that would guarantee that as long as _newTable == null, entryValue cannot be forwarded.
-            var entryValue = Volatile.Read(ref entry.value);
-
-            // See if we want to move to a new table (to avoid high average re-probe counts).
-            // We only check on the initial set of a Value from null to
-            // not-null (i.e., once per key-insert).
-            var newTable = curTable._newTable;
-
-            // newTable == entryValue only when both are nulls
-            if ((object)newTable == (object)entryValue &&
-            curTable.TableIsCrowded())
-            {
-                // Force the new table copy to start
-                newTable = curTable.Resize(isForReprobe: false);
-                Debug.Assert(curTable._newTable != null && newTable == curTable._newTable);
-            }
-
-            // See if we are moving to a new table.
-            // If so, copy our slot and retry in the new table.
-            // Seeing TOMBPRIME entry while no newTable means the slot is in a process of being deleted
-            // Let CopySlotAndGetNewTable handle that case too.
-            if (newTable != null || entryValue == TOMBPRIME)
-            {
-                var newTable1 = curTable.CopySlotAndGetNewTable(ref entry, shouldHelp: true);
-                Debug.Assert(newTable == newTable1 || (newTable == null && newTable1 == this));
-                curTable = newTable1;
-                goto tryWithNewTable;
-            }
-
-            // We are finally prepared to update the existing table
-            while (true)
-            {
-                Debug.Assert(!(entryValue is Prime));
-                var entryValueNullOrDead = EntryValueNullOrDead(entryValue);
-
-                switch (match)
-                {
-                    case ValueMatch.Any:
-                        if (ValueIsAtomicPrimitive() &&
-                            !entryValueNullOrDead &&
-                            Unsafe.As<Boxed<TValue>>(entryValue).TryVolatileWrite(newVal))
-                        {
-                            return true;
-                        }
-                        break;
-
-                    case ValueMatch.OldValue:
-                        if (entryValueNullOrDead)
-                        {
-                            goto FAILED;
-                        }
-
-                        if (ValueIsAtomicPrimitive() &&
-                            Unsafe.As<Boxed<TValue>>(entryValue).TryCompareExchange(oldVal, newVal, out var changed))
-                        {
-                            return changed;
-                        }
-
-                        if (ValueIsAtomicPrimitive())
-                        {
-                            // we could not change the value in place (this is rare), fallback to replacing the whole box.
-                            Unsafe.As<Boxed<TValue>>(entryValue).Freeze();
-                        }
-
-                        TValue unboxedEntryValue = FromObjectValue(entryValue);
-                        if (!EqualityComparer<TValue>.Default.Equals(oldVal, unboxedEntryValue))
-                        {
-                            goto FAILED;
-                        }
-                        break;
-
-                    default:
-                        Debug.Assert(match == ValueMatch.NullOrDead);
-                        if (!entryValueNullOrDead)
-                        {
-                            // this is the only case where caller expects to see oldVal
-                            // NB: No need to freeze here. This is keyed on mere presence of the value.
-                            oldVal = FromObjectValue(entryValue);
-                            goto FAILED;
-                        }
-                        break;
-                }
-
-                // Actually change the Value
-                object newValObj = ToObjectValue(newVal);
-                var prev = Interlocked.CompareExchange(ref entry.value, newValObj, entryValue);
-                if (prev == entryValue)
-                {
-                    // CAS succeeded - we did the update!
-                    // Adjust sizes
-                    if (entryValueNullOrDead)
-                    {
-                        curTable._size.Increment();
-                    }
-
-                    return true;
-                }
-                // Else CAS failed
-
-                // If a Prime'd value got installed, we need to re-run the put on the new table.
-                Debug.Assert(prev != null);
-                if (prev.GetType() == typeof(Prime))
-                {
-                    curTable = curTable.CopySlotAndGetNewTable(ref entry, shouldHelp: true);
-                    goto tryWithNewTable;
-                }
-
-                // Otherwise we lost the CAS to another racing put.
-                // Simply retry from the start.
-                entryValue = prev;
-            }
-
-        FAILED:
-            return false;
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-#pragma warning disable CA1822 // Mark members as static
-        private bool ValueIsAtomicPrimitive()
-#pragma warning restore CA1822 // Mark members as static
-        {
-            return default(TValue) != null && valueIsAtomic;
-        }
-
-        internal sealed override TValue GetOrAdd(TKey key, Func<TKey, TValue> valueFactory)
-        {
-            object newValObj = null;
-            TValue result = default(TValue);
-
-            var curTable = this;
-            int fullHash = curTable.hash(key);
-
-        TRY_WITH_NEW_TABLE:
-
-            var lenMask = curTable._entries.Length - 1;
-            int idx = ReduceHashToIndex(fullHash, lenMask);
-            ref Entry entry = ref curTable._entries[idx];
-
-            // Spin till we get a slot for the key or force a resizing.
-            int reprobeCount = 0;
-            while (true)
-            {
-                // hash and key are CAS-ed down and follow a specific sequence of states.
-                // hence the order of their reads is irrelevant and they do not need to be volatile
-                var entryHash = entry.hash;
-                if (entryHash == 0)
-                {
-                    // Found an unassigned slot - which means this
-                    // key has never been in this table.
-                    // Slot is completely clean, claim the hash first
-                    Debug.Assert(fullHash != 0);
-                    entryHash = Interlocked.CompareExchange(ref entry.hash, fullHash, 0);
-                    if (entryHash == 0)
-                    {
-                        entryHash = fullHash;
-                        if (entryHash == ZEROHASH)
-                        {
-                            // "added" entry for zero key
-                            curTable.allocatedSlotCount.Increment();
-                            break;
-                        }
-                    }
-                }
-
-                if (entryHash == fullHash)
-                {
-                    // hash is good, one way or another,
-                    // try claiming the slot for the key
-                    if (curTable.TryClaimSlotForPut(ref entry.key, key))
-                    {
-                        break;
-                    }
-                }
-
-                // here we know that this slot does not map to our key
-                // and must reprobe or resize
-                // hitting reprobe limit or finding TOMBPRIMEHASH here means that the key is not in this table,
-                // but there could be more in the new table
-                if (entryHash == TOMBPRIMEHASH || reprobeCount >= ReprobeLimit(lenMask))
-                {
-                    // start resize or get new table if resize is already in progress
-                    var newTable1 = curTable.Resize(isForReprobe: true);
-                    // help along an existing copy
-                    curTable.HelpCopy();
-                    curTable = newTable1;
-                    goto TRY_WITH_NEW_TABLE;
-                }
-
-                // quadratic reprobing
-                reprobeCount++;
-                curTable.ResizeOnReprobeCheck(reprobeCount);
-                idx = (idx + reprobeCount) & lenMask;
-                entry = ref curTable._entries[idx];
-            }
-
-            // Found the proper Key slot, now update the Value.
-            // We never put a null, so Value slots monotonically move from null to
-            // not-null (deleted Values use Tombstone).
-
-            // volatile read to make sure we read the element before we read the _newTable
-            // that would guarantee that as long as _newTable == null, entryValue cannot be forwarded.
-            var entryValue = Volatile.Read(ref entry.value);
-
-            // See if we want to move to a new table (to avoid high average re-probe counts).
-            // We only check on the initial set of a Value from null to
-            // not-null (i.e., once per key-insert).
-            var newTable = curTable._newTable;
-
-            // newTable == entryValue only when both are nulls
-            if ((object)newTable == (object)entryValue &&
-                curTable.TableIsCrowded())
-            {
-                // Force the new table copy to start
-                newTable = curTable.Resize(isForReprobe: false);
-                Debug.Assert(curTable._newTable != null && curTable._newTable == newTable);
-            }
-
-            // See if we are moving to a new table.
-            // If so, copy our slot and retry in the new table.
-            // Seeing TOMBPRIME entry while no newTable means the slot is in a process of being deleted
-            // Let CopySlotAndGetNewTable handle that case too.
-            if (newTable != null || entryValue == TOMBPRIME)
-            {
-                var newTable1 = curTable.CopySlotAndGetNewTable(ref entry, shouldHelp: true);
-                Debug.Assert(newTable == newTable1);
-                curTable = newTable;
-                goto TRY_WITH_NEW_TABLE;
-            }
-
-            if (!EntryValueNullOrDead(entryValue))
-            {
-                goto GOT_PREV_VALUE;
-            }
-
-            // prev value is null or dead.
-            // let's try install new value
-            newValObj ??= ToObjectValue(result = valueFactory(key));
-            while (true)
-            {
-                Debug.Assert(!(entryValue is Prime));
-
-                // Actually change the Value
-                var prev = Interlocked.CompareExchange(ref entry.value, newValObj, entryValue);
-                if (prev == entryValue)
-                {
-                    // CAS succeeded - we did the update!
-                    // Adjust sizes
-                    curTable._size.Increment();
-                    goto DONE;
-                }
-                // Else CAS failed
-
-                // If a Prime'd value got installed, we need to re-run on the new table.
-                Debug.Assert(prev != null);
-                if (prev.GetType() == typeof(Prime))
-                {
-                    curTable = curTable.CopySlotAndGetNewTable(ref entry, shouldHelp: true);
-                    goto TRY_WITH_NEW_TABLE;
-                }
-
-                // Otherwise we lost the CAS to another racing put.
-                entryValue = prev;
-                if (entryValue != TOMBSTONE)
-                {
-                    goto GOT_PREV_VALUE;
-                }
-            }
-
-        GOT_PREV_VALUE:
-            result = FromObjectValue(entryValue);
-
-        DONE:
-            return result;
-        }
-
-        private bool PutSlotCopy(TKeyStore key, object value, int fullHash)
-        {
-            Debug.Assert(key != null);
-            Debug.Assert(value != TOMBSTONE);
-            Debug.Assert(value != null);
-            Debug.Assert(!(value is Prime));
-
-            var curTable = this;
-
-        TRY_WITH_NEW_TABLE:
-
-            var lenMask = curTable._entries.Length - 1;
-            int idx = ReduceHashToIndex(fullHash, lenMask);
-            ref Entry entry = ref curTable._entries[idx];
-
-            // Spin till we get a slot for the key or force a resizing.
-            int reprobeCount = 0;
-            while (true)
-            {
-                var entryHash = entry.hash;
-                if (entryHash == 0)
-                {
-                    // Slot is completely clean, claim the hash
-                    Debug.Assert(fullHash != 0);
-                    entryHash = Interlocked.CompareExchange(ref entry.hash, fullHash, 0);
-                    if (entryHash == 0)
-                    {
-                        entryHash = fullHash;
-                        if (entryHash == ZEROHASH)
-                        {
-                            // "added" entry for zero key
-                            curTable.allocatedSlotCount.Increment();
-                            break;
-                        }
-                    }
-                }
-
-                if (entryHash == fullHash)
-                {
-                    // hash is good, one way or another, claim the key
-                    if (curTable.TryClaimSlotForCopy(ref entry.key, key))
-                    {
-                        break;
-                    }
-                }
-
-                // this slot contains a different key
-
-                // here we know that this slot does not map to our key
-                // and must reprobe or resize
-                // hitting reprobe limit or finding TOMBPRIMEHASH here means that
-                // we will not find an appropriate slot in this table
-                // but there could be more in the new one
-                if (entryHash == TOMBPRIMEHASH || reprobeCount >= ReprobeLimit(lenMask))
-                {
-                    var resized = curTable.Resize(isForReprobe: true);
-                    curTable = resized;
-                    goto TRY_WITH_NEW_TABLE;
-                }
-
-                // quadratic reprobing
-                reprobeCount++;
-                // no resize check on reprobe needed.
-                // we always insert a new value (or somebody else inserts)
-                idx = (idx + reprobeCount) & lenMask;
-                entry = ref curTable._entries[idx];
-            }
-
-            // Found the proper Key slot, now update the Value.
-
-            // volatile read to make sure we read the element before we read the _newTable
-            // that would guarantee that as long as _newTable == null, entryValue cannot be forwarded.
-            var entryValue = Volatile.Read(ref entry.value);
-
-            // See if we want to move to a new table (to avoid high average re-probe counts).
-            // We only check on the initial set of a Value from null to
-            // not-null (i.e., once per key-insert).
-            var newTable = curTable._newTable;
-
-            // newTable == entryValue only when both are nulls
-            if ((object)newTable == (object)entryValue &&
-                curTable.TableIsCrowded())
-            {
-                // Force the new table copy to start
-                newTable = curTable.Resize(isForReprobe: false);
-                Debug.Assert(curTable._newTable != null && curTable._newTable == newTable);
-            }
-
-            // See if we are moving to a new table.
-            // If so, copy our slot and retry in the new table.
-            // Seeing TOMBPRIME entry while no newTable means the slot is in a process of being deleted
-            // Let CopySlotAndGetNewTable handle that case too.
-            if (newTable != null || entryValue == TOMBPRIME)
-            {
-                var newTable1 = curTable.CopySlotAndGetNewTable(ref entry, shouldHelp: false);
-                Debug.Assert(newTable == newTable1);
-                curTable = newTable;
-                goto TRY_WITH_NEW_TABLE;
-            }
-
-            // We are finally prepared to update the existing table
-            // if entry value is null and our CAS succeeds - we did the update!
-            // otherwise someone else copied the value.
-            // table-copy does not (effectively) increase the number of live k/v pairs
-            // so no need to update size
-            return entry.value == null &&
-                   Interlocked.CompareExchange(ref entry.value, value, null) == null;
-        }
-
-        // check once in a while if a table might benefit from resizing.
-        // one reason for this is that crowdedness check uses estimated counts
-        // so we do not always catch this on key inserts.
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private void ResizeOnReprobeCheck(int reprobeCount)
-        {
-            // must be ^2 - 1
-            const int reprobeCheckPeriod = 16 - 1;
-
-            // once per reprobeCheckPeriod, check if the table is crowded
-            // and initiate a resize
-            if ((reprobeCount & reprobeCheckPeriod) == 0)
-            {
-                ReprobeResizeCheckSlow();
-            }
-        }
-
-        [MethodImpl(MethodImplOptions.NoInlining)]
-        private void ReprobeResizeCheckSlow()
-        {
-            if (this.TableIsCrowded())
-            {
-                this.Resize(isForReprobe: false);
-                this.HelpCopy();
-            }
-        }
-
-        ///////////////////////////////////////////////////////////
-        // Resize support
-        ///////////////////////////////////////////////////////////
-
-        internal int Size
-        {
-            get
-            {
-                // counter does not lose counts, but reports of increments/decrements can be delayed
-                // it might be confusing if we ever report negative size.
-                var size = _size.Value;
-                var negMask = ~(size >> 31);
-                return size & negMask;
-            }
-        }
-
-        internal int EstimatedSlotsUsed
-        {
-            get
-            {
-                return (int)allocatedSlotCount.EstimatedValue;
-            }
-        }
-
-        internal bool TableIsCrowded()
-        {
-            // 75% utilization, switch to a bigger table
-            return EstimatedSlotsUsed >= (_entries.Length / 4 * 3);
-        }
-
-        // Help along an existing resize operation.  This is just a fast cut-out
-        // wrapper, to encourage inlining for the fast no-copy-in-progress case.
-        private void HelpCopyIfNeeded()
-        {
-            if (this._newTable != null)
-            {
-                this.HelpCopy(copy_all: false);
-            }
-        }
-
-        // Help along an existing resize operation.
-        internal void HelpCopy(bool copy_all = false)
-        {
-            var newTable = this._newTable;
-            var oldEntries = this._entries;
-            int toCopy = oldEntries.Length;
-
-#if DEBUG
-            const int CHUNK_SIZE = 16;
-#else
-            const int CHUNK_SIZE = 1024;
-#endif
-            int MIN_COPY_WORK = Math.Min(toCopy, CHUNK_SIZE); // Limit per-thread work
-
-            bool panic = false;
-            int claimedChunk = -1;
-
-            while (this._copyDone < toCopy)
-            {
-                // Still needing to copy?
-                // Carve out a chunk of work.
-                if (!panic)
-                {
-                    claimedChunk = this._claimedChunk;
-
-                    while (true)
-                    {
-                        // panic check
-                        // We "panic" if we have tried TWICE to copy every slot - and it still
-                        // has not happened.  i.e., twice some thread somewhere claimed they
-                        // would copy 'slot X' (by bumping _copyIdx) but they never claimed to
-                        // have finished (by bumping _copyDone).  Our choices become limited:
-                        // we can wait for the work-claimers to finish (and become a blocking
-                        // algorithm) or do the copy work ourselves.  Tiny tables with huge
-                        // thread counts trying to copy the table often 'panic'.
-                        if (claimedChunk > (toCopy / (CHUNK_SIZE / 2)))
-                        {
-                            panic = true;
-                            break;
-                        }
-
-                        var alreadyClaimed = Interlocked.CompareExchange(ref this._claimedChunk, claimedChunk + 1, claimedChunk);
-                        if (alreadyClaimed == claimedChunk)
-                        {
-                            break;
-                        }
-
-                        claimedChunk = alreadyClaimed;
-                    }
-                }
-                else
-                {
-                    // we went through the whole table in panic mode
-                    // there cannot be possibly anything left to copy.
-                    if (claimedChunk > ((toCopy / (CHUNK_SIZE / 2)) + toCopy / CHUNK_SIZE))
-                    {
-                        _copyDone = toCopy;
-                        PromoteNewTable();
-                        return;
-                    }
-
-                    claimedChunk++;
-                }
-
-                // We now know what to copy.  Try to copy.
-                int workdone = 0;
-                int copyStart = claimedChunk * CHUNK_SIZE;
-                for (int i = 0; i < MIN_COPY_WORK; i++)
-                {
-                    if (this._copyDone >= toCopy)
-                    {
-                        PromoteNewTable();
-                        return;
-                    }
-
-                    if (CopySlot(ref oldEntries[(copyStart + i) & (toCopy - 1)], newTable))
-                    {
-                        workdone++;
-                    }
-                }
-
-                if (workdone > 0)
-                {
-                    // See if we can promote
-                    var copyDone = Interlocked.Add(ref this._copyDone, workdone);
-
-                    // Check for copy being ALL done, and promote.
-                    if (copyDone >= toCopy)
-                    {
-                        PromoteNewTable();
-                    }
-                }
-
-                if (!(copy_all | panic))
-                {
-                    return;
-                }
-            }
-
-            // Extra promotion check, in case another thread finished all copying
-            // then got stalled before promoting.
-            PromoteNewTable();
-        }
-
-        private void PromoteNewTable()
-        {
-            // Looking at the top-level table?
-            // Note that we might have
-            // nested in-progress copies and manage to finish a nested copy before
-            // finishing the top-level copy.  We only promote top-level copies.
-            if (_topDict._table == this)
-            {
-                // Attempt to promote
-                if (Interlocked.CompareExchange(ref _topDict._table, this._newTable, this) == this)
-                {
-                    _topDict._lastResizeTickMillis = CurrentTickMillis();
-                }
-            }
-        }
-
-        // Copy slot 'idx' from the old table to the new table.  If this thread
-        // confirmed the copy, update the counters and check for promotion.
-        //
-        // Returns the result of reading the new table, mostly as a
-        // convenience to callers.  We come here with 1-shot copy requests
-        // typically because the caller has found a Prime, and has not yet read
-        // the new table - which must have changed from null-to-not-null
-        // before any Prime appears.  So the caller needs to read the new table
-        // field to retry his operation in the new table, but probably has not
-        // read it yet.
-        internal DictionaryImpl<TKey, TKeyStore, TValue> CopySlotAndGetNewTable(ref Entry entry, bool shouldHelp)
-        {
-            // However this could be just an entry partially swept.
-            // In such case treat the value as being copied (into oblivion) and return the same table back to retry.
-            var newTable = this._newTable;
-
-            // We're here because the caller saw a Prime or new table, which implies copying or sweeping is in progress.
-            Debug.Assert(entry.value is Prime || newTable != null);
-
-            if (newTable == null)
-            {
-                Debug.Assert(!typeof(TKeyStore).GetTypeInfo().IsValueType);
-                // help with sweeping in case the sweeper thread is stuck. We do not want to come here again.
-                // we write unconditionally though, since this is a relatively rare case.
-                entry.hash = SPECIAL_HASH_BITS;
-                entry.key = default(TKeyStore);
-
-                return this;
-            }
-
-            if (CopySlot(ref entry, newTable))
-            {
-                // Record the slot copied
-                var copyDone = Interlocked.Increment(ref this._copyDone);
-
-                // Check for copy being ALL done, and promote.
-                if (copyDone >= this._entries.Length)
-                {
-                    PromoteNewTable();
-                    return newTable;
-                }
-            }
-
-            // Generically help along any copy (except if called recursively from a helper)
-            if (shouldHelp)
-            {
-                this.HelpCopy();
-            }
-
-            return newTable;
-        }
-
-        // Copy one K/V pair from old table to new table.
-        // Returns true if we actually did the copy.
-        // Regardless, once this returns, the copy is available in the new table and
-        // slot in the old table is no longer usable.
-        private static bool CopySlot(ref Entry oldEntry, DictionaryImpl<TKey, TKeyStore, TValue> newTable)
-        {
-            Debug.Assert(newTable != null);
-
-            // Blindly set the hash from 0 to TOMBPRIMEHASH, to eagerly stop
-            // fresh put's from claiming new slots in the old table when the old
-            // table is mid-resize.
-            var hash = oldEntry.hash;
-            if (hash == 0)
-            {
-                hash = Interlocked.CompareExchange(ref oldEntry.hash, TOMBPRIMEHASH, 0);
-                if (hash == 0)
-                {
-                    // slot was not claimed, copy is done here
-                    return true;
-                }
-            }
-
-            if (hash == TOMBPRIMEHASH)
-            {
-                // slot was trivially copied, but not by us
-                return false;
-            }
-
-            // Prevent new values from appearing in the old table.
-            // Put a forwarding entry, to prevent further updates.
-            // NOTE: Read of the value below must happen before reading of the key,
-            // however this read does not need to be volatile since we will have
-            // some fences in between reads.
-            object oldval = oldEntry.value;
-
-            // already boxed?
-            Prime box = oldval as Prime;
-            if (box != null)
-            {
-                // volatile read here since we need to make sure
-                // that the key read below happens after we have read oldval above
-                // (this read is a dependednt read after oldval, and reading the key happens-after)
-                Volatile.Read(ref box.originalValue);
-            }
-            else
-            {
-                do
-                {
-                    box = EntryValueNullOrDead(oldval) ?
-                        TOMBPRIME :
-                        new Prime(oldval);
-
-                    // CAS down a box'd version of oldval
-                    // also works as a complete fence between reading the value and the key
-                    object prev = Interlocked.CompareExchange(ref oldEntry.value, box, oldval);
-
-                    if (prev == oldval)
-                    {
-                        // If we made the Value slot hold a TOMBPRIME, then we both
-                        // prevented further updates here but also the (absent)
-                        // oldval is vacuously available in the new table.  We
-                        // return with true here: any thread looking for a value for
-                        // this key can correctly go straight to the new table and
-                        // skip looking in the old table.
-                        if (box == TOMBPRIME)
-                        {
-                            return true;
-                        }
-
-                        // Break loop; oldval is now boxed by us
-                        // it still needs to be copied into the new table.
-                        break;
-                    }
-
-                    oldval = prev;
-                    box = oldval as Prime;
-                }
-                while (box == null);
-            }
-
-            if (box == TOMBPRIME)
-            {
-                // Copy already complete here, but not by us.
-                return false;
-            }
-
-            // Copy the value into the new table, but only if we overwrite a null.
-            // If another value is already in the new table, then somebody else
-            // wrote something there and that write is happens-after any value that
-            // appears in the old table.  If putIfMatch does not find a null in the
-            // new table - somebody else should have recorded the null-not_null
-            // transition in this copy.
-            object originalValue = box.originalValue;
-            Debug.Assert(originalValue != TOMBSTONE);
-
-            // since we have a real value, there must be a nontrivial key in the table.
-            // regular read is ok because value is always CASed down after the key
-            // and we ensured that we read the key after the value with fences above
-            var key = oldEntry.key;
-            bool copiedIntoNew = newTable.PutSlotCopy(key, originalValue, hash);
-
-            // Finally, now that any old value is exposed in the new table, we can
-            // forever hide the old-table value by gently inserting TOMBPRIME value.
-            // This will stop other threads from uselessly attempting to copy this slot
-            // (i.e., it's a speed optimization not a correctness issue).
-            if (oldEntry.value != TOMBPRIME)
-            {
-                oldEntry.value = TOMBPRIME;
-            }
-
-            // if we failed to copy, it means something has already appeared in
-            // the new table and old value should have been copied before that (not by us).
-            return copiedIntoNew;
-        }
-
-        // kick off resizing, if not started already, and return the new table.
-        private DictionaryImpl<TKey, TKeyStore, TValue> Resize(bool isForReprobe)
-        {
-            // Check for resize already in progress, probably triggered by another thread.
-            // reads of this._newTable in Resize are not volatile
-            // we are just opportunistically checking if a new table has arrived.
-            return this._newTable ?? ResizeImpl(isForReprobe);
-        }
-
-        // Resizing after too many probes.  "How Big???" heuristics are here.
-        // Callers will (not this routine) help any in-progress copy.
-        // Since this routine has a fast cutout for copy-already-started, callers
-        // MUST 'help_copy' lest we have a path which forever runs through
-        // 'resize' only to discover a copy-in-progress which never progresses.
-        private DictionaryImpl<TKey, TKeyStore, TValue> ResizeImpl(bool isForReprobe)
-        {
-            const int MAX_SIZE = 1 << 30;
-            const int MAX_CHURN_SIZE = 1 << 20;
-
-            // First up: compute new table size.
-            int oldlen = this._entries.Length;
-
-            // First size estimate is 4x of the current size
-            int oldsz = Size;
-            int newsz = oldsz < (MAX_SIZE / 4) ?
-                                        oldsz * 4 :
-                                        oldsz;
-
-            newsz = Math.Max(newsz, MIN_SIZE);
-
-            if (isForReprobe)
-            {
-                // if half slots are dead, just do regular resize
-                // otherwise we want to double the length to not come here too soon
-                if (allocatedSlotCount.Value < oldsz * 2)
-                {
-                    if (oldlen < (MAX_SIZE / 2))
-                    {
-                        newsz = Math.Max(newsz, oldlen * 2);
-                    }
-                }
-            }
-
-            if (newsz <= oldlen)
-            {
-                // if new table would shrink or hold steady,
-                // we must be resizing because of churn.
-                // target churn based resize rate to be about 1 per RESIZE_TICKS_TARGET
-                var resizeSpan = CurrentTickMillis() - _topDict._lastResizeTickMillis;
-
-                // note that CurrentTicks() will wrap around every 50 days.
-                // For our purposes that is tolerable since it just
-                // adds a possibility that in some rare cases a churning resize will not be
-                // considered a churning one.
-                if (resizeSpan < RESIZE_MILLIS_TARGET)
-                {
-                    // last resize too recent, expand
-                    newsz = oldlen < MAX_CHURN_SIZE ? oldlen << 1 : oldlen;
-                }
-                else
-                {
-                    // do not allow shrink too fast
-                    newsz = Math.Max(newsz, (int)((long)oldlen * RESIZE_MILLIS_TARGET / resizeSpan));
-                }
-            }
-
-            // Align up to a power of 2
-            newsz = HashHelpers.AlignToPowerOfTwo(newsz);
-
-            // Size calculation: 2 words (K+V) per table entry, plus a handful.  We
-            // guess at 32-bit pointers; 64-bit pointers screws up the size calc by
-            // 2x but does not screw up the heuristic very much.
-            int kBs4 = (((newsz << 1) + 4) << 3/*word to bytes*/) >> 12/*kBs4*/;
-
-            var newTable = this._newTable;
-
-            // Now, if allocation is big enough,
-            // limit the number of threads actually allocating memory to a
-            // handful - lest we have 750 threads all trying to allocate a giant
-            // resized array.
-            // conveniently, Increment is also a full fence
-            if (kBs4 > 0 && Interlocked.Increment(ref _resizers) >= 2)
-            {
-                // Already 2 guys trying; wait and see
-                // See if resize is already in progress
-                if (newTable != null)
-                {
-                    return newTable;         // Use the new table already
-                }
-
-                SpinWait.SpinUntil(() => this._newTable != null, 8 * kBs4);
-            }
-
-            // Last check, since the 'new' below is expensive and there is a chance
-            // that another thread slipped in a new table while we ran the heuristic.
-            newTable = this._newTable;
-            // See if resize is already in progress
-            if (newTable != null)
-            {
-                return newTable;          // Use the new table already
-            }
-
-            newTable = this.CreateNew(newsz);
-
-            // The new table must be CAS'd in to ensure only 1 winner
-            var prev = this._newTable ??
-                        Interlocked.CompareExchange(ref this._newTable, newTable, null);
-
-            if (prev != null)
-            {
-                return prev;
-            }
-            else
-            {
-                return newTable;
-            }
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private void SweepCheck()
-        {
-            if (_topDict._sweepRequests == 0)
-            {
-                _topDict._sweepRequests = 1;
-                Sweeper.TryRearm(this);
-            }
-        }
-
-        private sealed class Sweeper
-        {
-            private DictionaryImpl<TKey, TKeyStore, TValue> _dict;
-
-            public static void TryRearm(DictionaryImpl<TKey, TKeyStore, TValue> dict)
-            {
-                ref var sweeperLocation = ref dict._topDict._sweeperInstance;
-                var obj = sweeperLocation;
-                if (obj != null && Interlocked.CompareExchange(ref sweeperLocation, null, obj) == obj)
-                {
-                    Sweeper sweeper = obj as Sweeper ?? new Sweeper();
-                    sweeper._dict = dict;
-                    GC.ReRegisterForFinalize(sweeper);
-                }
-            }
-
-            ~Sweeper()
-            {
-#pragma warning disable IDE0200 // Lambda can be removed
-                Task.Run(() => Sweep());
-#pragma warning restore IDE0200
-            }
-
-            private void Sweep()
-            {
-                var dict = _dict;
-                this._dict = null;
-
-                if (dict == null)
-                {
-                    // this could happen when table is destroyed
-                    return;
-                }
-
-                // any key removed after we start sweeping may not be swept
-                // signal to future removers that they need another request.
-                // note that remove is a CAS, so remover will see this value
-                // after removing.
-                Interlocked.Exchange(ref dict._topDict._sweepRequests, 0);
-
-                var entries = dict._entries;
-                for (int i = 0; i < entries.Length; i++)
-                {
-                    // if resizing, just help to resize instead
-                    if (dict._newTable != null)
-                    {
-                        do
-                        {
-                            dict.HelpCopy(copy_all: true);
-                            dict = dict._newTable;
-                        } while (dict._newTable != null);
-                        break;
-                    }
-
-                    ref var e = ref entries[i];
-                    if (e.value == TOMBSTONE)
-                    {
-                        if (Interlocked.CompareExchange(ref e.value, TOMBPRIME, TOMBSTONE) == TOMBSTONE)
-                        {
-                            e.hash = SPECIAL_HASH_BITS;
-                            e.key = default(TKeyStore);
-                            Interlocked.Increment(ref dict._copyDone);
-                        }
-                    }
-
-                }
-
-                // got new requests while sweeping. revisit after next GC.
-                dict._topDict._sweeperInstance = this;
-                if (dict._topDict._sweepRequests != 0)
-                {
-                    TryRearm(dict);
-                }
-            }
-        }
-    }
-}
diff --git a/src/tests/JIT/Methodical/doublearray/dblarray1.cs b/src/tests/JIT/Methodical/doublearray/dblarray1.cs
index 7c377fc8579..459997ca2b4 100644
--- a/src/tests/JIT/Methodical/doublearray/dblarray1.cs
+++ b/src/tests/JIT/Methodical/doublearray/dblarray1.cs
@@ -95,6 +95,7 @@ public class DblArray1
     [SkipOnCoreClr("This test is not compatible with GCStress.", RuntimeTestModes.AnyGCStress)]
     [OuterLoop]
     [ActiveIssue("https://github.com/dotnet/runtime/issues/101284", typeof(TestLibrary.Utilities), nameof(TestLibrary.Utilities.IsNativeAot))]
+    [ActiveIssue("Satori: tests implementation details")]
     public static int TestEntryPoint()
     {
         if (RuntimeInformation.ProcessArchitecture == Architecture.X86)
diff --git a/src/tests/JIT/Methodical/doublearray/dblarray2.cs b/src/tests/JIT/Methodical/doublearray/dblarray2.cs
index 427b72d15b4..d6827aaaf06 100644
--- a/src/tests/JIT/Methodical/doublearray/dblarray2.cs
+++ b/src/tests/JIT/Methodical/doublearray/dblarray2.cs
@@ -284,6 +284,7 @@ public class DblArray
     [SkipOnCoreClr("This test is not compatible with GCStress.", RuntimeTestModes.AnyGCStress)]
     [SkipOnMono("Needs triage")]
     [ActiveIssue("https://github.com/dotnet/runtime/issues/101284", typeof(TestLibrary.Utilities), nameof(TestLibrary.Utilities.IsNativeAot))]
+    [ActiveIssue("Satori: tests implementation details")]
     public static int TestEntryPoint()
     {
         if (RuntimeInformation.ProcessArchitecture == Architecture.X86)
diff --git a/src/tests/JIT/Methodical/doublearray/dblarray3.cs b/src/tests/JIT/Methodical/doublearray/dblarray3.cs
index 053e1c14700..7b2ff8e0247 100644
--- a/src/tests/JIT/Methodical/doublearray/dblarray3.cs
+++ b/src/tests/JIT/Methodical/doublearray/dblarray3.cs
@@ -145,6 +145,7 @@ public class DblArray3
     [SkipOnMono("Needs triage")]
     [OuterLoop]
     [ActiveIssue("https://github.com/dotnet/runtime/issues/101284", typeof(TestLibrary.Utilities), nameof(TestLibrary.Utilities.IsNativeAot))]
+    [ActiveIssue("Satori: tests implementation details")]
     public static int TestEntryPoint()
     {
         Console.WriteLine(RuntimeInformation.ProcessArchitecture);
diff --git a/src/tests/JIT/Methodical/doublearray/dblarray4.cs b/src/tests/JIT/Methodical/doublearray/dblarray4.cs
index 748bf3de2fa..f50292f96fa 100644
--- a/src/tests/JIT/Methodical/doublearray/dblarray4.cs
+++ b/src/tests/JIT/Methodical/doublearray/dblarray4.cs
@@ -23,6 +23,7 @@ public class DblArray4
     [SkipOnCoreClr("This test is not compatible with GCStress.", RuntimeTestModes.AnyGCStress)]
     [OuterLoop]
     [ActiveIssue("https://github.com/dotnet/runtime/issues/101284", typeof(TestLibrary.Utilities), nameof(TestLibrary.Utilities.IsNativeAot))]
+    [ActiveIssue("Satori: tests implementation details")]
     public static int TestEntryPoint()
     {
         if (RuntimeInformation.ProcessArchitecture == Architecture.X86)
diff --git a/src/tests/issues.targets b/src/tests/issues.targets
index e46041b78fc..170c2191cb9 100644
--- a/src/tests/issues.targets
+++ b/src/tests/issues.targets
@@ -100,7 +100,16 @@
       <ExcludeList Include="$(XunitTestBinBase)/GC/API/NoGCRegion/**">
         <Issue>Satori GC apis</Issue>
       </ExcludeList>
-
+      <ExcludeList Include="$(XunitTestBinBase)/baseservices/RuntimeConfiguration/TestConfigTester/*">
+        <Issue>Satori GC apis</Issue>
+      </ExcludeList>
+      <ExcludeList Include="$(XunitTestBinBase)/GC/API/Refresh/**">
+        <Issue>Satori GC apis</Issue>
+      </ExcludeList>
+      <ExcludeList Include="$(XunitTestBinBase)/GC/API/GetGeneration/*">
+        <Issue>Satori GC apis</Issue>
+      </ExcludeList>
+      
       <ExcludeList Include="$(XunitTestBinBase)/JIT/Methodical/doublearray/**">
         <Issue>Satori GC apis, LOH expectations</Issue>
       </ExcludeList>
@@ -130,10 +139,15 @@
       <ExcludeList Include="$(XunitTestBinBase)/profiler/gc/gcallocate/*">
         <Issue>Satori profiler tracing</Issue>
       </ExcludeList>
-
+      <ExcludeList Include="$(XunitTestBinBase)/profiler/gcheapenumeration/**">
+        <Issue>Satori profiler tracing</Issue>
+      </ExcludeList>
       <ExcludeList Include="$(XunitTestBinBase)/profiler/handles/handles/*">
         <Issue>Satori profiler tracing</Issue>
       </ExcludeList>
+      <ExcludeList Include="$(XunitTestBinBase)/profiler/unittest/enumthreads/*">
+        <Issue>Satori profiler tracing</Issue>
+      </ExcludeList>
 
       <ExcludeList Include="$(XunitTestBinBase)/readytorun/coreroot_determinism/coreroot_determinism/*">
         <Issue>Satori Unknown</Issue>