Merge pull request #10911 from adityamandaleeka/handle_table_local_gc_hide_internals

[Local GC] Hide handle table internals from VM side

Author: adityamandaleeka

src/gc/gchandletable.cpp

@@ -23,39 +23,78 @@ void GCHandleTable::Shutdown()
     Ref_Shutdown();
 }
 
-void* GCHandleTable::GetHandleTableContext(void* handleTable)
+void* GCHandleTable::GetGlobalHandleStore()
 {
-    return (void*)((uintptr_t)::HndGetHandleTableADIndex((HHANDLETABLE)handleTable).m_dwIndex);
+    return (void*)g_HandleTableMap.pBuckets[0];
 }
 
-void* GCHandleTable::GetHandleTableForHandle(OBJECTHANDLE handle)
+void* GCHandleTable::CreateHandleStore(void* context)
 {
-    return (void*)::HndGetHandleTable(handle);
+#ifndef FEATURE_REDHAWK
+    return (void*)::Ref_CreateHandleTableBucket(ADIndex((DWORD)(uintptr_t)context));
+#else
+    assert("CreateHandleStore is not implemented when FEATURE_REDHAWK is defined!");
+    return nullptr;
+#endif
 }
 
-OBJECTHANDLE GCHandleTable::CreateHandleOfType(void* table, Object* object, int type)
+void* GCHandleTable::GetHandleContext(OBJECTHANDLE handle)
 {
-    return ::HndCreateHandle((HHANDLETABLE)table, type, ObjectToOBJECTREF(object));
+    return (void*)((uintptr_t)::HndGetHandleTableADIndex(::HndGetHandleTable(handle)).m_dwIndex);
+}
+
+void GCHandleTable::DestroyHandleStore(void* store)
+{
+    Ref_DestroyHandleTableBucket((HandleTableBucket*) store);
+}
+
+void GCHandleTable::UprootHandleStore(void* store)
+{
+    Ref_RemoveHandleTableBucket((HandleTableBucket*) store);
+}
+
+bool GCHandleTable::ContainsHandle(void* store, OBJECTHANDLE handle)
+{
+    return ((HandleTableBucket*)store)->Contains(handle);
+}
+
+OBJECTHANDLE GCHandleTable::CreateHandleOfType(void* store, Object* object, int type)
+{
+    HHANDLETABLE handletable = ((HandleTableBucket*)store)->pTable[GetCurrentThreadHomeHeapNumber()];
+    return ::HndCreateHandle(handletable, type, ObjectToOBJECTREF(object));
+}
+
+OBJECTHANDLE GCHandleTable::CreateHandleOfType(void* store, Object* object, int type, int heapToAffinitizeTo)
+{
+    HHANDLETABLE handletable = ((HandleTableBucket*)store)->pTable[heapToAffinitizeTo];
+    return ::HndCreateHandle(handletable, type, ObjectToOBJECTREF(object));
 }
 
 OBJECTHANDLE GCHandleTable::CreateGlobalHandleOfType(Object* object, int type)
 {
     return ::HndCreateHandle(g_HandleTableMap.pBuckets[0]->pTable[GetCurrentThreadHomeHeapNumber()], type, ObjectToOBJECTREF(object)); 
 }
 
-OBJECTHANDLE GCHandleTable::CreateHandleWithExtraInfo(void* table, Object* object, int type, void* pExtraInfo)
+OBJECTHANDLE GCHandleTable::CreateHandleWithExtraInfo(void* store, Object* object, int type, void* pExtraInfo)
 {
-    return ::HndCreateHandle((HHANDLETABLE)table, type, ObjectToOBJECTREF(object), reinterpret_cast<uintptr_t>(pExtraInfo));
+    HHANDLETABLE handletable = ((HandleTableBucket*)store)->pTable[GetCurrentThreadHomeHeapNumber()];
+    return ::HndCreateHandle(handletable, type, ObjectToOBJECTREF(object), reinterpret_cast<uintptr_t>(pExtraInfo));
 }
 
-OBJECTHANDLE GCHandleTable::CreateDependentHandle(void* table, Object* primary, Object* secondary)
+OBJECTHANDLE GCHandleTable::CreateDependentHandle(void* store, Object* primary, Object* secondary)
 {
-    OBJECTHANDLE handle = ::HndCreateHandle((HHANDLETABLE)table, HNDTYPE_DEPENDENT, ObjectToOBJECTREF(primary));
+    HHANDLETABLE handletable = ((HandleTableBucket*)store)->pTable[GetCurrentThreadHomeHeapNumber()];
+    OBJECTHANDLE handle = ::HndCreateHandle(handletable, HNDTYPE_DEPENDENT, ObjectToOBJECTREF(primary));
     ::SetDependentHandleSecondary(handle, ObjectToOBJECTREF(secondary));
 
     return handle;
 }
 
+OBJECTHANDLE GCHandleTable::CreateDuplicateHandle(OBJECTHANDLE handle)
+{
+    return ::HndCreateHandle(HndGetHandleTable(handle), HNDTYPE_DEFAULT, ::HndFetchHandle(handle));
+}
+
 void GCHandleTable::DestroyHandleOfType(OBJECTHANDLE handle, int type)
 {
     ::HndDestroyHandle(::HndGetHandleTable(handle), type, handle);

src/gc/gchandletableimpl.h

@@ -14,18 +14,30 @@ class GCHandleTable : public IGCHandleTable
 
     virtual void Shutdown();
 
-    virtual void* GetHandleTableContext(void* handleTable);
+    virtual void* GetGlobalHandleStore();
 
-    virtual void* GetHandleTableForHandle(OBJECTHANDLE handle);
+    virtual void* CreateHandleStore(void* context);
 
-    virtual OBJECTHANDLE CreateHandleOfType(void* table, Object* object, int type);
+    virtual void* GetHandleContext(OBJECTHANDLE handle);
 
-    virtual OBJECTHANDLE CreateHandleWithExtraInfo(void* table, Object* object, int type, void* pExtraInfo);
+    virtual void DestroyHandleStore(void* store);
 
-    virtual OBJECTHANDLE CreateDependentHandle(void* table, Object* primary, Object* secondary);
+    virtual void UprootHandleStore(void* store);
+
+    virtual bool ContainsHandle(void* store, OBJECTHANDLE handle);
+
+    virtual OBJECTHANDLE CreateHandleOfType(void* store, Object* object, int type);
+
+    virtual OBJECTHANDLE CreateHandleOfType(void* store, Object* object, int type, int heapToAffinitizeTo);
+
+    virtual OBJECTHANDLE CreateHandleWithExtraInfo(void* store, Object* object, int type, void* pExtraInfo);
+
+    virtual OBJECTHANDLE CreateDependentHandle(void* store, Object* primary, Object* secondary);
 
     virtual OBJECTHANDLE CreateGlobalHandleOfType(Object* object, int type);
 
+    virtual OBJECTHANDLE CreateDuplicateHandle(OBJECTHANDLE handle);
+
     virtual void DestroyHandleOfType(OBJECTHANDLE handle, int type);
 
     virtual void DestroyHandleOfUnknownType(OBJECTHANDLE handle);

src/gc/gcinterface.h

@@ -409,18 +409,30 @@ class IGCHandleTable {
 
     virtual void Shutdown() = 0;
 
-    virtual void* GetHandleTableContext(void* handleTable) = 0;
+    virtual void* GetHandleContext(OBJECTHANDLE handle) = 0;
 
-    virtual void* GetHandleTableForHandle(OBJECTHANDLE handle) = 0;
+    virtual void* GetGlobalHandleStore() = 0;
 
-    virtual OBJECTHANDLE CreateHandleOfType(void* table, Object* object, int type) = 0;
+    virtual void* CreateHandleStore(void* context) = 0;
 
-    virtual OBJECTHANDLE CreateHandleWithExtraInfo(void* table, Object* object, int type, void* pExtraInfo) = 0;
+    virtual void DestroyHandleStore(void* store) = 0;
 
-    virtual OBJECTHANDLE CreateDependentHandle(void* table, Object* primary, Object* secondary) = 0;
+    virtual void UprootHandleStore(void* store) = 0;
+
+    virtual bool ContainsHandle(void* store, OBJECTHANDLE handle) = 0;
+
+    virtual OBJECTHANDLE CreateHandleOfType(void* store, Object* object, int type) = 0;
+
+    virtual OBJECTHANDLE CreateHandleOfType(void* store, Object* object, int type, int heapToAffinitizeTo) = 0;
+
+    virtual OBJECTHANDLE CreateHandleWithExtraInfo(void* store, Object* object, int type, void* pExtraInfo) = 0;
+
+    virtual OBJECTHANDLE CreateDependentHandle(void* store, Object* primary, Object* secondary) = 0;
 
     virtual OBJECTHANDLE CreateGlobalHandleOfType(Object* object, int type) = 0;
 
+    virtual OBJECTHANDLE CreateDuplicateHandle(OBJECTHANDLE handle) = 0;
+
     virtual void DestroyHandleOfType(OBJECTHANDLE handle, int type) = 0;
 
     virtual void DestroyHandleOfUnknownType(OBJECTHANDLE handle) = 0;

src/gc/handletable.cpp

@@ -1338,24 +1338,6 @@ void  Ref_RelocateAsyncPinHandles(HandleTableBucket *pSource, HandleTableBucket
 }
 #endif // !FEATURE_REDHAWK
 
-BOOL Ref_ContainHandle(HandleTableBucket *pBucket, OBJECTHANDLE handle)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-    }
-    CONTRACTL_END;
-
-    int limit = getNumberOfSlots();
-    for (int n = 0; n < limit; n ++ )
-    {
-        if (TableContainHandle(Table(pBucket->pTable[n]), handle))
-            return TRUE;
-    }
-
-    return FALSE;
-}
 /*--------------------------------------------------------------------------*/
 
 

src/gc/objecthandle.h

@@ -111,7 +111,6 @@ BOOL Ref_HandleAsyncPinHandles();
 void Ref_RelocateAsyncPinHandles(HandleTableBucket *pSource, HandleTableBucket *pTarget);
 void Ref_RemoveHandleTableBucket(HandleTableBucket *pBucket);
 void Ref_DestroyHandleTableBucket(HandleTableBucket *pBucket);
-BOOL Ref_ContainHandle(HandleTableBucket *pBucket, OBJECTHANDLE handle);
 
 /*
  * GC-time scanning entrypoints

src/vm/appdomain.cpp

@@ -740,10 +740,10 @@ BaseDomain::BaseDomain()
     m_pLargeHeapHandleTable = NULL;
 
 #ifndef CROSSGEN_COMPILE
-    // Note that m_hHandleTableBucket is overridden by app domains
-    m_hHandleTableBucket = g_HandleTableMap.pBuckets[0];
+    // Note that m_handleStore is overridden by app domains
+    m_handleStore = GCHandleTableUtilities::GetGCHandleTable()->GetGlobalHandleStore();
 #else
-    m_hHandleTableBucket = NULL;
+    m_handleStore = NULL;
 #endif
 
     m_pMarshalingData = NULL;
@@ -993,17 +993,6 @@ void BaseDomain::InitVSD()
 }
 
 #ifndef CROSSGEN_COMPILE
-BOOL BaseDomain::ContainsOBJECTHANDLE(OBJECTHANDLE handle)
-{
-    CONTRACTL
-    {
-        NOTHROW;
-        GC_NOTRIGGER;
-    }
-    CONTRACTL_END;
-
-    return Ref_ContainHandle(m_hHandleTableBucket,handle);
-}
 
 DWORD BaseDomain::AllocateContextStaticsOffset(DWORD* pOffsetSlot)
 {
@@ -4053,7 +4042,7 @@ AppDomain::AppDomain()
     m_pUMEntryThunkCache = NULL;
 
     m_pAsyncPool = NULL;
-    m_hHandleTableBucket = NULL;
+    m_handleStore = NULL;
 
     m_ExposedObject = NULL;
     m_pComIPForExposedObject = NULL;
@@ -4284,18 +4273,13 @@ void AppDomain::Init()
     // default domain cannot be unloaded.
     if (GetId().m_dwId == DefaultADID)
     {
-        m_hHandleTableBucket = g_HandleTableMap.pBuckets[0];
+        m_handleStore = GCHandleTableUtilities::GetGCHandleTable()->GetGlobalHandleStore();
     }
     else
     {
-        m_hHandleTableBucket = Ref_CreateHandleTableBucket(m_dwIndex);
+        m_handleStore = GCHandleTableUtilities::GetGCHandleTable()->CreateHandleStore((void*)(uintptr_t)m_dwIndex.m_dwIndex);
     }
 
-#ifdef _DEBUG
-    if (((HandleTable *)(m_hHandleTableBucket->pTable[0]))->uADIndex != m_dwIndex)
-        _ASSERTE (!"AD index mismatch");
-#endif // _DEBUG
-
 #endif // CROSSGEN_COMPILE
 
 #ifdef FEATURE_TYPEEQUIVALENCE
@@ -4594,16 +4578,10 @@ void AppDomain::Terminate()
 
     BaseDomain::Terminate();
 
-#ifdef _DEBUG
-    if (m_hHandleTableBucket &&
-        m_hHandleTableBucket->pTable &&
-        ((HandleTable *)(m_hHandleTableBucket->pTable[0]))->uADIndex != m_dwIndex)
-        _ASSERTE (!"AD index mismatch");
-#endif // _DEBUG
-
-    if (m_hHandleTableBucket) {
-        Ref_DestroyHandleTableBucket(m_hHandleTableBucket);
-        m_hHandleTableBucket = NULL;
+    if (m_handleStore) 
+    {
+        GCHandleTableUtilities::GetGCHandleTable()->DestroyHandleStore(m_handleStore);
+        m_handleStore = NULL;
     }
 
 #ifdef FEATURE_APPDOMAIN_RESOURCE_MONITORING
@@ -9220,14 +9198,7 @@ void AppDomain::ClearGCHandles()
     HandleAsyncPinHandles();
 
     // Remove our handle table as a source of GC roots
-    HandleTableBucket *pBucket = m_hHandleTableBucket;
-
-#ifdef _DEBUG
-    if (((HandleTable *)(pBucket->pTable[0]))->uADIndex != m_dwIndex)
-        _ASSERTE (!"AD index mismatch");
-#endif // _DEBUG
-
-    Ref_RemoveHandleTableBucket(pBucket);
+    GCHandleTableUtilities::GetGCHandleTable()->UprootHandleStore(m_handleStore);
 }
 
 // When an AD is unloaded, we will release all objects in this AD.
@@ -9243,13 +9214,17 @@ void AppDomain::HandleAsyncPinHandles()
     }
     CONTRACTL_END;
 
-    HandleTableBucket *pBucket = m_hHandleTableBucket;
+    // TODO: Temporarily casting stuff here until Ref_RelocateAsyncPinHandles is moved to the interface.
+    HandleTableBucket *pBucket = (HandleTableBucket*)m_handleStore;
+
     // IO completion port picks IO job using FIFO.  Here is how we know which AsyncPinHandle can be freed.
     // 1. We mark all non-pending AsyncPinHandle with READYTOCLEAN.
     // 2. We queue a dump Overlapped to the IO completion as a marker.
     // 3. When the Overlapped is picked up by completion port, we wait until all previous IO jobs are processed.
     // 4. Then we can delete all AsyncPinHandle marked with READYTOCLEAN.
-    HandleTableBucket *pBucketInDefault = SystemDomain::System()->DefaultDomain()->m_hHandleTableBucket;
+    HandleTableBucket *pBucketInDefault = (HandleTableBucket*)SystemDomain::System()->DefaultDomain()->m_handleStore;
+
+    // TODO: When this function is moved to the interface it will take void*s
     Ref_RelocateAsyncPinHandles(pBucket, pBucketInDefault);
 
     OverlappedDataObject::RequestCleanup();
@@ -9272,14 +9247,15 @@ void AppDomain::ClearGCRoots()
     // this point, so only need to synchronize the preemptive mode threads.
     ExecutionManager::Unload(GetLoaderAllocator());
 
+    IGCHandleTable* pHandleTable = GCHandleTableUtilities::GetGCHandleTable();
+
     while ((pThread = ThreadStore::GetAllThreadList(pThread, 0, 0)) != NULL)
     {
         // Delete the thread local static store
         pThread->DeleteThreadStaticData(this);
 
-
         // <TODO>@TODO: A pre-allocated AppDomainUnloaded exception might be better.</TODO>
-        if (m_hHandleTableBucket->Contains(pThread->m_LastThrownObjectHandle))
+        if (pHandleTable->ContainsHandle(m_handleStore, pThread->m_LastThrownObjectHandle))
         {
             // Never delete a handle to a preallocated exception object.
             if (!CLRException::IsPreallocatedExceptionHandle(pThread->m_LastThrownObjectHandle))
@@ -9291,7 +9267,7 @@ void AppDomain::ClearGCRoots()
         }
 
         // Clear out the exceptions objects held by a thread.
-        pThread->GetExceptionState()->ClearThrowablesForUnload(m_hHandleTableBucket);
+        pThread->GetExceptionState()->ClearThrowablesForUnload(m_handleStore);
     }
 
     //delete them while we still have the runtime suspended