.NET: Add caching for proxy objects

Author: praydog

csharp-api/REFrameworkNET/IObject.hpp

@@ -6,6 +6,7 @@
 
 namespace REFrameworkNET {
 ref class TypeDefinition;
+interface class IProxy;
 value struct InvokeRet;
 
 // Base interface of ManagedObject and NativeObject
@@ -19,5 +20,7 @@ public interface class IObject : public IProxyable, public System::IEquatable<IO
     // For interface types
     generic <typename T>
     T As();
+
+    IProxy^ GetProxy(System::Type^ proxyType);
 };
 }

csharp-api/REFrameworkNET/ManagedObject.cpp

@@ -19,13 +19,15 @@ namespace REFrameworkNET {
     void ManagedObject::CleanupKnownCaches() {
         Cache<ManagedObject>::CleanupAll();
         Cache<SystemString>::CleanupAll();
+        UnifiedObject::ProxyPool::Clear();
     }
 
     void ManagedObject::Internal_Finalize() {
-        if (m_object == nullptr) {
+        if (m_object == nullptr || !m_initialized) {
             return;
         }
 
+        UnifiedObject::ProxyPool::Remove(this);
         ReleaseIfGlobalized();
 
         // Only if we are not marked as weak are we allowed to release the object, even if the object is globalized
@@ -106,6 +108,18 @@ namespace REFrameworkNET {
 
     generic <typename T>
     T ManagedObject::As() {
-        return ManagedProxy<T>::Create(this);
+        // Don't bother caching if we are not globalized (ephemeral/local objects)
+        if (!IsGlobalized()) {
+            return ManagedProxy<T>::Create(this);
+        }
+
+        if (auto existingProxy = this->GetProxy(T::typeid)) {
+            return (T)existingProxy;
+        }
+
+        auto result = ManagedProxy<T>::Create(this);
+
+        this->AddProxy(T::typeid, (IProxy^)result);
+        return result;
     }
 }

csharp-api/REFrameworkNET/ManagedObject.hpp

@@ -336,23 +336,28 @@ public ref class ManagedObject : public REFrameworkNET::UnifiedObject
     generic <typename T>
     virtual T As() override;
 
-    // TODO methods:
-    /*public Void* GetReflectionProperties() {
-        return _original.get_reflection_properties();
-    }*/
+    virtual IProxy^ GetProxy(System::Type^ type) override {
+        if (!IsGlobalized()) {
+            return nullptr;
+        }
 
-    /*public ReflectionProperty GetReflectionPropertyDescriptor(basic_string_view<char\, std::char_traits<char>> name) {
-        return _original.get_reflection_property_descriptor(name);
+        return UnifiedObject::GetProxy(type);
     }
 
-    public ReflectionMethod GetReflectionMethodDescriptor(basic_string_view<char\, std::char_traits<char>> name) {
-        return _original.get_reflection_method_descriptor(name);
-    }*/
+internal:
+    virtual void AddProxy(System::Type^ type, IProxy^ proxy) override {
+        if (!IsGlobalized()) {
+            return;
+        }
+
+        UnifiedObject::AddProxy(type, proxy);
+    }
 
 internal:
     static bool ShuttingDown = false;
 
     void Deinitialize() {
+        m_object = nullptr;
         m_initialized = false;
     }
 

csharp-api/REFrameworkNET/NativeObject.cpp

@@ -8,6 +8,23 @@
 namespace REFrameworkNET {
 generic <typename T>
 T NativeObject::As() {
+    // Cannot cache nullptr objects
+    /*if (this->GetAddress() == 0) {
+        return NativeProxy<T>::Create(this);
+    }
+
+    if (auto existingProxy = this->GetProxy(T::typeid)) {
+        return (T)existingProxy;
+    }
+
+    auto result = NativeProxy<T>::Create(this);
+
+    this->AddProxy(T::typeid, (IProxy^)result);
+    return result;*/
+
+    // Not gonna bother with this for now. Just create a new proxy every time
+    // Reason being, this is not a managed object, so we have no idea if the address
+    // still points to the original object or not. It's better to just create a new one.
     return NativeProxy<T>::Create(this);
 }
 }

csharp-api/REFrameworkNET/PluginManager.cpp

@@ -692,6 +692,7 @@ namespace REFrameworkNET {
                 NativePool<TypeDefinition>::DisplayStats();
                 NativePool<Method>::DisplayStats();
                 NativePool<Field>::DisplayStats();
+                UnifiedObject::ProxyPool::DisplayStats();
 
                 ImGuiNET::ImGui::TreePop();
             }

csharp-api/REFrameworkNET/Proxy.hpp

@@ -74,6 +74,10 @@ public ref class Proxy : public Reflection::DispatchProxy, public IProxy, public
         return Instance->As<T>();
     }
 
+    virtual IProxy^ GetProxy(System::Type^ type) {
+        return Instance->GetProxy(type);
+    }
+
     static T Create(IObject^ target) {
         auto proxy = Reflection::DispatchProxy::Create<T, Proxy<T, T2>^>();
         ((IProxy^)proxy)->SetInstance(target);
@@ -130,6 +134,15 @@ public ref class Proxy : public Reflection::DispatchProxy, public IProxy, public
         return !left->Equals(right);
     }
 
+internal:
+    ~Proxy() {
+        this->!Proxy();
+    }
+
+    !Proxy() {
+
+    }
+
 protected:
     virtual Object^ Invoke(Reflection::MethodInfo^ targetMethod, array<Object^>^ args) override {
         // Get the REFrameworkNET::Attributes::Method attribute from the method
@@ -203,8 +216,18 @@ public ref class Proxy : public Reflection::DispatchProxy, public IProxy, public
             auto iobjectResult = dynamic_cast<REFrameworkNET::IObject^>(result);
 
             if (iobjectResult != nullptr && targetReturnType->IsInterface) {
+                // Caching mechanism to prevent creating multiple proxies for the same object and type so we dont stress the GC
+                if (auto existingProxy = iobjectResult->GetProxy(targetReturnType); existingProxy != nullptr) {
+                    return existingProxy;
+                }
+
                 auto proxy = DispatchProxy::Create(targetReturnType, Proxy<T, T2>::typeid->GetGenericTypeDefinition()->MakeGenericType(T::typeid, result->GetType()));
                 ((IProxy^)proxy)->SetInstance(iobjectResult);
+
+                if (auto unified = dynamic_cast<REFrameworkNET::UnifiedObject^>(iobjectResult); unified != nullptr) {
+                    unified->AddProxy(targetReturnType, (IProxy^)proxy);
+                }
+
                 result = proxy;
                 return result;
             }

csharp-api/REFrameworkNET/UnifiedObject.hpp

@@ -5,6 +5,7 @@
 
 namespace REFrameworkNET {
 ref class TypeDefinition;
+interface class IProxy;
 value struct InvokeRet;
 
 // UnifiedObject is the base class that ManagedObject and NativeObject will derive from
@@ -22,8 +23,11 @@ public ref class UnifiedObject abstract : public System::Dynamic::DynamicObject,
 
     generic <typename T>
     virtual T As() abstract = 0;
-    
-    // Shared methods
+
+    virtual IProxy^ GetProxy(System::Type^ type) {
+        return ProxyPool::GetIfExists(this, type);
+    }
+
     virtual bool HandleInvokeMember_Internal(System::String^ methodName, array<System::Object^>^ args, System::Object^% result);
     virtual bool HandleInvokeMember_Internal(uint32_t methodIndex, array<System::Object^>^ args, System::Object^% result);
     virtual bool HandleInvokeMember_Internal(System::Object^ methodObj, array<System::Object^>^ args, System::Object^% result);
@@ -104,5 +108,116 @@ public ref class UnifiedObject abstract : public System::Dynamic::DynamicObject,
     virtual System::Collections::IEnumerator^ GetEnumerator() {
         return gcnew REFrameworkNET::ObjectEnumerator(this);
     }
+
+internal:
+    using WeakProxy = System::WeakReference<IProxy^>;
+
+    generic <typename T>
+    T AsCached() {
+        auto strongProxy = GetProxy(T::typeid);
+
+        if (strongProxy != nullptr) {
+            return (T)strongProxy;
+        }
+
+        T instance = As<T>();
+        //m_proxies->TryAdd(T::typeid, gcnew WeakProxy((IProxy^)instance));
+        ProxyPool::Add(this, T::typeid, (IProxy^)instance);
+
+        return instance;
+    }
+
+    virtual void AddProxy(System::Type^ type, IProxy^ proxy) {
+        //m_proxies->TryAdd(type, gcnew WeakProxy(proxy));
+        ProxyPool::Add(this, type, proxy);
+    }
+
+protected:
+    // It's weak because internally the proxy will hold a strong reference to the object
+    /*System::Collections::Concurrent::ConcurrentDictionary<System::Type^, WeakProxy^>^ m_proxies
+        = gcnew System::Collections::Concurrent::ConcurrentDictionary<System::Type^, WeakProxy^>(System::Environment::ProcessorCount * 2, 8);*/
+
+internal:
+    // Using a proxy cache that is separate from the object itself
+    // because holding weak references in the object itself is asking for trouble
+    ref class ProxyPool {
+    internal:
+        using WeakT = System::WeakReference<IProxy^>;
+
+        static WeakT^ AddValueFactory(System::Type^ key, IProxy^ arg) {
+            return gcnew WeakT(arg);
+        }
+
+        static System::Func<System::Type^, IProxy^, WeakT^>^ addValueFactory = gcnew System::Func<System::Type^, IProxy^, WeakT^>(AddValueFactory);
+
+        static WeakT^ UpdateFactory(System::Type^ key, WeakT^ value, IProxy^ arg) {
+            return gcnew WeakT(arg);
+        }
+
+        static System::Func<System::Type^, WeakT^, IProxy^, WeakT^>^ updateFactory = gcnew System::Func<System::Type^, WeakT^, IProxy^, WeakT^>(UpdateFactory);
+
+        static IProxy^ GetIfExists(IObject^ obj, System::Type^ type) {
+            const auto addr = obj->GetAddress();
+
+            if (addr == 0) {
+                return nullptr;
+            }
+
+            InternalDict^ dict = nullptr;
+            if (!s_cache->TryGetValue(addr, dict)) {
+                return nullptr;
+            }
+
+            WeakT^ weak = nullptr;
+            if (!dict->TryGetValue(type, weak)) {
+                return nullptr;
+            }
+
+            IProxy^ target = nullptr;
+            if (!weak->TryGetTarget(target)) {
+                return nullptr;
+            }
+
+            return target;
+        }
+
+        static void Add(IObject^ obj, System::Type^ type, IProxy^ proxy) {
+            InternalDict^ dict = nullptr;
+            const auto hashcode = obj->GetAddress();
+
+            if (hashcode == 0) {
+                return;
+            }
+
+            if (!s_cache->TryGetValue(hashcode, dict)) {
+                dict = gcnew InternalDict(System::Environment::ProcessorCount * 2, 2);
+                s_cache->TryAdd(hashcode, dict);
+            }
+
+            dict->AddOrUpdate(type, addValueFactory, updateFactory, proxy);
+        }
+
+        static void Remove(IObject^ obj) {
+            InternalDict^ dict = nullptr;
+            s_cache->TryRemove(obj->GetAddress(), dict);
+        }
+
+        static void Clear() {
+            s_cache->Clear();
+        }
+
+        static void DisplayStats() {
+            if (ImGuiNET::ImGui::TreeNode("ProxyPool")) {
+                ImGuiNET::ImGui::Text("Cache size: " + s_cache->Count.ToString());
+                ImGuiNET::ImGui::TreePop();
+            }
+        }
+
+    private:
+        // Not using the actual object as the key so that we can avoid holding strong references to the objects
+        using InternalDict = System::Collections::Concurrent::ConcurrentDictionary<System::Type^, WeakT^>;
+        using DictT = System::Collections::Concurrent::ConcurrentDictionary<uintptr_t, InternalDict^>;
+        static DictT^ s_cache = gcnew DictT(System::Environment::ProcessorCount * 2, 8192);
+    };
 };
 }