Merge pull request #10955 from adityamandaleeka/makeHandleStoreClass

Make a GCHandleStore class and interface for use by the VM

Author: adityamandaleeka

src/gc/gc.h

@@ -115,7 +115,7 @@ extern "C" GCHeapType g_gc_heap_type;
 extern "C" uint32_t g_max_generation;
 extern "C" MethodTable* g_gc_pFreeObjectMethodTable;
 
-::IGCHandleTable*  CreateGCHandleTable();
+::IGCHandleManager*  CreateGCHandleManager();
 
 namespace WKS {
     ::IGCHeapInternal* CreateGCHeap();
@@ -260,8 +260,8 @@ void updateGCShadow(Object** ptr, Object* val);
 // The single GC heap instance, shared with the VM.
 extern IGCHeapInternal* g_theGCHeap;
 
-// The single GC handle table instance, shared with the VM.
-extern IGCHandleTable* g_theGCHandleTable;
+// The single GC handle manager instance, shared with the VM.
+extern IGCHandleManager* g_theGCHandleManager;
 
 #ifndef DACCESS_COMPILE
 inline bool IsGCInProgress(bool bConsiderGCStart = false)

src/gc/gccommon.cpp

@@ -15,7 +15,7 @@
 #include "gc.h"
 
 IGCHeapInternal* g_theGCHeap;
-IGCHandleTable* g_theGCHandleTable;
+IGCHandleManager* g_theGCHandleManager;
 
 #ifdef FEATURE_STANDALONE_GC
 IGCToCLR* g_theGCToCLR;
@@ -143,18 +143,18 @@ namespace SVR
     extern void PopulateDacVars(GcDacVars* dacVars);
 }
 
-bool InitializeGarbageCollector(IGCToCLR* clrToGC, IGCHeap** gcHeap, IGCHandleTable** gcHandleTable, GcDacVars* gcDacVars)
+bool InitializeGarbageCollector(IGCToCLR* clrToGC, IGCHeap** gcHeap, IGCHandleManager** gcHandleManager, GcDacVars* gcDacVars)
 {
     LIMITED_METHOD_CONTRACT;
 
     IGCHeapInternal* heap;
 
     assert(gcDacVars != nullptr);
     assert(gcHeap != nullptr);
-    assert(gcHandleTable != nullptr);
+    assert(gcHandleManager != nullptr);
 
-    IGCHandleTable* handleTable = CreateGCHandleTable();
-    if (handleTable == nullptr)
+    IGCHandleManager* handleManager = CreateGCHandleManager();
+    if (handleManager == nullptr)
     {
         return false;
     }
@@ -192,7 +192,7 @@ bool InitializeGarbageCollector(IGCToCLR* clrToGC, IGCHeap** gcHeap, IGCHandleTa
     assert(clrToGC == nullptr);
 #endif
 
-    *gcHandleTable = handleTable;
+    *gcHandleManager = handleManager;
     *gcHeap = heap;
     return true;
 }

src/gc/gchandletable.cpp

@@ -8,104 +8,127 @@
 #include "gchandletableimpl.h"
 #include "objecthandle.h"
 
-IGCHandleTable* CreateGCHandleTable()
+GCHandleStore* g_gcGlobalHandleStore;
+
+IGCHandleManager* CreateGCHandleManager()
 {
-    return new(nothrow) GCHandleTable();
+    return new (nothrow) GCHandleManager();
 }
 
-bool GCHandleTable::Initialize()
+void GCHandleStore::Uproot()
 {
-    return Ref_Initialize();
+    Ref_RemoveHandleTableBucket(&_underlyingBucket);
 }
 
-void GCHandleTable::Shutdown()
+bool GCHandleStore::ContainsHandle(OBJECTHANDLE handle)
 {
-    Ref_Shutdown();
+    return _underlyingBucket.Contains(handle);
 }
 
-void* GCHandleTable::GetGlobalHandleStore()
+OBJECTHANDLE GCHandleStore::CreateHandleOfType(Object* object, int type)
 {
-    return (void*)g_HandleTableMap.pBuckets[0];
+    HHANDLETABLE handletable = _underlyingBucket.pTable[GetCurrentThreadHomeHeapNumber()];
+    return ::HndCreateHandle(handletable, type, ObjectToOBJECTREF(object));
 }
 
-void* GCHandleTable::CreateHandleStore(void* context)
+OBJECTHANDLE GCHandleStore::CreateHandleOfType(Object* object, int type, int heapToAffinitizeTo)
 {
-#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
+    HHANDLETABLE handletable = _underlyingBucket.pTable[heapToAffinitizeTo];
+    return ::HndCreateHandle(handletable, type, ObjectToOBJECTREF(object));
 }
 
-void* GCHandleTable::GetHandleContext(OBJECTHANDLE handle)
+OBJECTHANDLE GCHandleStore::CreateHandleWithExtraInfo(Object* object, int type, void* pExtraInfo)
 {
-    return (void*)((uintptr_t)::HndGetHandleTableADIndex(::HndGetHandleTable(handle)).m_dwIndex);
+    HHANDLETABLE handletable = _underlyingBucket.pTable[GetCurrentThreadHomeHeapNumber()];
+    return ::HndCreateHandle(handletable, type, ObjectToOBJECTREF(object), reinterpret_cast<uintptr_t>(pExtraInfo));
 }
 
-void GCHandleTable::DestroyHandleStore(void* store)
+OBJECTHANDLE GCHandleStore::CreateDependentHandle(Object* primary, Object* secondary)
 {
-    Ref_DestroyHandleTableBucket((HandleTableBucket*) store);
+    HHANDLETABLE handletable = _underlyingBucket.pTable[GetCurrentThreadHomeHeapNumber()];
+    OBJECTHANDLE handle = ::HndCreateHandle(handletable, HNDTYPE_DEPENDENT, ObjectToOBJECTREF(primary));
+    ::SetDependentHandleSecondary(handle, ObjectToOBJECTREF(secondary));
+
+    return handle;
 }
 
-void GCHandleTable::UprootHandleStore(void* store)
+GCHandleStore::~GCHandleStore()
 {
-    Ref_RemoveHandleTableBucket((HandleTableBucket*) store);
+    ::Ref_DestroyHandleTableBucket(&_underlyingBucket);
 }
 
-bool GCHandleTable::ContainsHandle(void* store, OBJECTHANDLE handle)
+bool GCHandleManager::Initialize()
 {
-    return ((HandleTableBucket*)store)->Contains(handle);
+    return Ref_Initialize();
 }
 
-OBJECTHANDLE GCHandleTable::CreateHandleOfType(void* store, Object* object, int type)
+void GCHandleManager::Shutdown()
 {
-    HHANDLETABLE handletable = ((HandleTableBucket*)store)->pTable[GetCurrentThreadHomeHeapNumber()];
-    return ::HndCreateHandle(handletable, type, ObjectToOBJECTREF(object));
+    if (g_gcGlobalHandleStore != nullptr)
+    {
+        DestroyHandleStore(g_gcGlobalHandleStore);
+    }
+
+    ::Ref_Shutdown();
 }
 
-OBJECTHANDLE GCHandleTable::CreateHandleOfType(void* store, Object* object, int type, int heapToAffinitizeTo)
+IGCHandleStore* GCHandleManager::GetGlobalHandleStore()
 {
-    HHANDLETABLE handletable = ((HandleTableBucket*)store)->pTable[heapToAffinitizeTo];
-    return ::HndCreateHandle(handletable, type, ObjectToOBJECTREF(object));
+    return g_gcGlobalHandleStore;
 }
 
-OBJECTHANDLE GCHandleTable::CreateGlobalHandleOfType(Object* object, int type)
+IGCHandleStore* GCHandleManager::CreateHandleStore(void* context)
 {
-    return ::HndCreateHandle(g_HandleTableMap.pBuckets[0]->pTable[GetCurrentThreadHomeHeapNumber()], type, ObjectToOBJECTREF(object)); 
+#ifndef FEATURE_REDHAWK
+    GCHandleStore* store = new (nothrow) GCHandleStore();
+    if (store == nullptr)
+        return nullptr;
+
+    bool success = ::Ref_InitializeHandleTableBucket(&store->_underlyingBucket, context);
+    if (!success)
+    {
+        delete store;
+        return nullptr;
+    }
+
+    return store;
+#else
+    assert("CreateHandleStore is not implemented when FEATURE_REDHAWK is defined!");
+    return nullptr;
+#endif
 }
 
-OBJECTHANDLE GCHandleTable::CreateHandleWithExtraInfo(void* store, Object* object, int type, void* pExtraInfo)
+void GCHandleManager::DestroyHandleStore(IGCHandleStore* store)
 {
-    HHANDLETABLE handletable = ((HandleTableBucket*)store)->pTable[GetCurrentThreadHomeHeapNumber()];
-    return ::HndCreateHandle(handletable, type, ObjectToOBJECTREF(object), reinterpret_cast<uintptr_t>(pExtraInfo));
+    delete store;
 }
 
-OBJECTHANDLE GCHandleTable::CreateDependentHandle(void* store, Object* primary, Object* secondary)
+void* GCHandleManager::GetHandleContext(OBJECTHANDLE handle)
 {
-    HHANDLETABLE handletable = ((HandleTableBucket*)store)->pTable[GetCurrentThreadHomeHeapNumber()];
-    OBJECTHANDLE handle = ::HndCreateHandle(handletable, HNDTYPE_DEPENDENT, ObjectToOBJECTREF(primary));
-    ::SetDependentHandleSecondary(handle, ObjectToOBJECTREF(secondary));
+    return (void*)((uintptr_t)::HndGetHandleTableADIndex(::HndGetHandleTable(handle)).m_dwIndex);
+}
 
-    return handle;
+OBJECTHANDLE GCHandleManager::CreateGlobalHandleOfType(Object* object, int type)
+{
+    return ::HndCreateHandle(g_HandleTableMap.pBuckets[0]->pTable[GetCurrentThreadHomeHeapNumber()], type, ObjectToOBJECTREF(object)); 
 }
 
-OBJECTHANDLE GCHandleTable::CreateDuplicateHandle(OBJECTHANDLE handle)
+OBJECTHANDLE GCHandleManager::CreateDuplicateHandle(OBJECTHANDLE handle)
 {
     return ::HndCreateHandle(HndGetHandleTable(handle), HNDTYPE_DEFAULT, ::HndFetchHandle(handle));
 }
 
-void GCHandleTable::DestroyHandleOfType(OBJECTHANDLE handle, int type)
+void GCHandleManager::DestroyHandleOfType(OBJECTHANDLE handle, int type)
 {
     ::HndDestroyHandle(::HndGetHandleTable(handle), type, handle);
 }
 
-void GCHandleTable::DestroyHandleOfUnknownType(OBJECTHANDLE handle)
+void GCHandleManager::DestroyHandleOfUnknownType(OBJECTHANDLE handle)
 {
     ::HndDestroyHandleOfUnknownType(::HndGetHandleTable(handle), handle);
 }
 
-void* GCHandleTable::GetExtraInfoFromHandle(OBJECTHANDLE handle)
+void* GCHandleManager::GetExtraInfoFromHandle(OBJECTHANDLE handle)
 {
     return (void*)::HndGetHandleExtraInfo(handle);
 }

src/gc/gchandletableimpl.h

@@ -6,33 +6,44 @@
 #define GCHANDLETABLE_H_
 
 #include "gcinterface.h"
+#include "objecthandle.h"
 
-class GCHandleTable : public IGCHandleTable
+class GCHandleStore : public IGCHandleStore
 {
 public:
-    virtual bool Initialize();
+    virtual void Uproot();
 
-    virtual void Shutdown();
+    virtual bool ContainsHandle(OBJECTHANDLE handle);
 
-    virtual void* GetGlobalHandleStore();
+    virtual OBJECTHANDLE CreateHandleOfType(Object* object, int type);
 
-    virtual void* CreateHandleStore(void* context);
+    virtual OBJECTHANDLE CreateHandleOfType(Object* object, int type, int heapToAffinitizeTo);
 
-    virtual void* GetHandleContext(OBJECTHANDLE handle);
+    virtual OBJECTHANDLE CreateHandleWithExtraInfo(Object* object, int type, void* pExtraInfo);
+
+    virtual OBJECTHANDLE CreateDependentHandle(Object* primary, Object* secondary);
+
+    virtual ~GCHandleStore();
+
+    HandleTableBucket _underlyingBucket;
+};
 
-    virtual void DestroyHandleStore(void* store);
+extern GCHandleStore* g_gcGlobalHandleStore;
 
-    virtual void UprootHandleStore(void* store);
+class GCHandleManager : public IGCHandleManager
+{
+public:
+    virtual bool Initialize();
 
-    virtual bool ContainsHandle(void* store, OBJECTHANDLE handle);
+    virtual void Shutdown();
 
-    virtual OBJECTHANDLE CreateHandleOfType(void* store, Object* object, int type);
+    virtual void* GetHandleContext(OBJECTHANDLE handle);
 
-    virtual OBJECTHANDLE CreateHandleOfType(void* store, Object* object, int type, int heapToAffinitizeTo);
+    virtual IGCHandleStore* GetGlobalHandleStore();
 
-    virtual OBJECTHANDLE CreateHandleWithExtraInfo(void* store, Object* object, int type, void* pExtraInfo);
+    virtual IGCHandleStore* CreateHandleStore(void* context);
 
-    virtual OBJECTHANDLE CreateDependentHandle(void* store, Object* primary, Object* secondary);
+    virtual void DestroyHandleStore(IGCHandleStore* store);
 
     virtual OBJECTHANDLE CreateGlobalHandleOfType(Object* object, int type);
 

src/gc/gcinterface.h

@@ -169,12 +169,12 @@ struct segment_info
 
 class Object;
 class IGCHeap;
-class IGCHandleTable;
+class IGCHandleManager;
 
 // Initializes the garbage collector. Should only be called
 // once, during EE startup. Returns true if the initialization
 // was successful, false otherwise.
-bool InitializeGarbageCollector(IGCToCLR* clrToGC, IGCHeap** gcHeap, IGCHandleTable** gcHandleTable, GcDacVars* gcDacVars);
+bool InitializeGarbageCollector(IGCToCLR* clrToGC, IGCHeap** gcHeap, IGCHandleManager** gcHandleTable, GcDacVars* gcDacVars);
 
 // The runtime needs to know whether we're using workstation or server GC 
 // long before the GCHeap is created. This function sets the type of
@@ -402,32 +402,38 @@ typedef struct OBJECTHANDLE__* OBJECTHANDLE;
 typedef uintptr_t OBJECTHANDLE;
 #endif
 
-class IGCHandleTable {
+class IGCHandleStore {
 public:
 
-    virtual bool Initialize() = 0;
+    virtual void Uproot() = 0;
 
-    virtual void Shutdown() = 0;
+    virtual bool ContainsHandle(OBJECTHANDLE handle) = 0;
 
-    virtual void* GetHandleContext(OBJECTHANDLE handle) = 0;
+    virtual OBJECTHANDLE CreateHandleOfType(Object* object, int type) = 0;
+
+    virtual OBJECTHANDLE CreateHandleOfType(Object* object, int type, int heapToAffinitizeTo) = 0;
+
+    virtual OBJECTHANDLE CreateHandleWithExtraInfo(Object* object, int type, void* pExtraInfo) = 0;
 
-    virtual void* GetGlobalHandleStore() = 0;
+    virtual OBJECTHANDLE CreateDependentHandle(Object* primary, Object* secondary) = 0;
 
-    virtual void* CreateHandleStore(void* context) = 0;
+    virtual ~IGCHandleStore() {};
+};
 
-    virtual void DestroyHandleStore(void* store) = 0;
+class IGCHandleManager {
+public:
 
-    virtual void UprootHandleStore(void* store) = 0;
+    virtual bool Initialize() = 0;
 
-    virtual bool ContainsHandle(void* store, OBJECTHANDLE handle) = 0;
+    virtual void Shutdown() = 0;
 
-    virtual OBJECTHANDLE CreateHandleOfType(void* store, Object* object, int type) = 0;
+    virtual void* GetHandleContext(OBJECTHANDLE handle) = 0;
 
-    virtual OBJECTHANDLE CreateHandleOfType(void* store, Object* object, int type, int heapToAffinitizeTo) = 0;
+    virtual IGCHandleStore* GetGlobalHandleStore() = 0;
 
-    virtual OBJECTHANDLE CreateHandleWithExtraInfo(void* store, Object* object, int type, void* pExtraInfo) = 0;
+    virtual IGCHandleStore* CreateHandleStore(void* context) = 0;
 
-    virtual OBJECTHANDLE CreateDependentHandle(void* store, Object* primary, Object* secondary) = 0;
+    virtual void DestroyHandleStore(IGCHandleStore* store) = 0;
 
     virtual OBJECTHANDLE CreateGlobalHandleOfType(Object* object, int type) = 0;
 

src/gc/handletablecore.cpp

@@ -1003,7 +1003,8 @@ void SegmentRelocateAsyncPinHandles (TableSegment *pSegment, HandleTable *pTarge
                     overlapped->m_userObject = NULL;
                 }
                 BashMTForPinnedObject(ObjectToOBJECTREF(value));
-                overlapped->m_pinSelf = CreateAsyncPinningHandle((HHANDLETABLE)pTargetTable,ObjectToOBJECTREF(value));
+
+                overlapped->m_pinSelf = HndCreateHandle((HHANDLETABLE)pTargetTable, HNDTYPE_ASYNCPINNED, ObjectToOBJECTREF(value));
                 *pValue = NULL;
             }
             pValue ++;