Load cache of ModuleObject after reload

amos402 · amos402 · commit 183f9d822c17 · 2020-03-08T15:51:00.000+08:00
diff --git a/src/runtime/fieldobject.cs b/src/runtime/fieldobject.cs
@@ -6,6 +6,7 @@ namespace Python.Runtime
     /// <summary>
     /// Implements a Python descriptor type that provides access to CLR fields.
     /// </summary>
+    [Serializable]
     internal class FieldObject : ExtensionType
     {
         private FieldInfo info;
diff --git a/src/runtime/moduleobject.cs b/src/runtime/moduleobject.cs
@@ -17,6 +17,10 @@ internal class ModuleObject : ExtensionType
         [NonSerialized]
         private Dictionary<string, ManagedType> cache;
 
+        [NonSerialized]
+        // FIXME: Used by reload mode, remove it after implement a delay load handler.
+        private bool _cacheInited; 
+
         internal string moduleName;
         internal IntPtr dict;
         protected string _namespace;
@@ -29,6 +33,7 @@ public ModuleObject(string name)
             }
             moduleName = name;
             cache = new Dictionary<string, ManagedType>();
+            _cacheInited = true;
             _namespace = name;
 
             // Use the filename from any of the assemblies just so there's something for
@@ -72,6 +77,11 @@ public ModuleObject(string name)
         /// </summary>
         public ManagedType GetAttribute(string name, bool guess)
         {
+            if (!_cacheInited)
+            {
+                // XXX: Used by reload mode.
+                SetupCacheByDict();
+            }
             ManagedType cached = null;
             cache.TryGetValue(name, out cached);
             if (cached != null)
@@ -116,7 +126,6 @@ public ManagedType GetAttribute(string name, bool guess)
             {
                 c = ClassManager.GetClass(type);
                 StoreAttribute(name, c);
-                c.DecrRefCount();
                 return c;
             }
 
@@ -140,7 +149,6 @@ public ManagedType GetAttribute(string name, bool guess)
                 {
                     c = ClassManager.GetClass(type);
                     StoreAttribute(name, c);
-                    c.DecrRefCount();
                     return c;
                 }
             }
@@ -364,9 +372,34 @@ protected override void OnSave()
         protected override void OnLoad()
         {
             base.OnLoad();
+            // XXX: Set the cache after all objects loaded.
             cache = new Dictionary<string, ManagedType>();
+            _cacheInited = false;
             SetObjectDict(pyHandle, dict);
         }
+
+        private void SetupCacheByDict()
+        {
+            System.Diagnostics.Debug.Assert(!_cacheInited);
+            _cacheInited = true;
+            IntPtr key, value;
+            IntPtr pos;
+            while (Runtime.PyDict_Next(dict, out pos, out key, out value) != 0)
+            {
+                ManagedType obj = GetManagedObject(value);
+                if (obj == null)
+                {
+                    continue;
+                }
+                string name = Runtime.GetManagedString(key);
+                if (cache.ContainsKey(name))
+                {
+                    continue;
+                }
+                Runtime.XIncref(value);
+                cache.Add(name, obj);
+            }
+        }
     }
 
     /// <summary>
diff --git a/src/runtime/runtime.cs b/src/runtime/runtime.cs
@@ -490,6 +490,7 @@ private static void MoveClrInstancesOnwershipToPython()
                 ManagedType obj = entry.Key;
                 if (!objs.ContainsKey(obj))
                 {
+                    System.Diagnostics.Debug.Assert(obj.gcHandle == default);
                     continue;
                 }
                 if (entry.Value == ManagedType.TrackTypes.Extension)
@@ -1675,6 +1676,9 @@ internal static bool PyDict_Check(IntPtr ob)
         [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyDict_New();
 
+        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
+        internal static extern int PyDict_Next(IntPtr p, out IntPtr ppos, out IntPtr pkey, out IntPtr pvalue);
+
         [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern IntPtr PyDictProxy_New(IntPtr dict);
 
@@ -2004,7 +2008,7 @@ internal static IntPtr PyType_GenericAlloc(IntPtr type, long n)
         private static extern IntPtr PyType_GenericAlloc(IntPtr type, IntPtr n);
 
         /// <summary>
-        /// Finalize a type object. This should be called on all type objects to finish their initialization. This function is responsible for adding inherited slots from a type��s base class. Return 0 on success, or return -1 and sets an exception on error.
+        /// Finalize a type object. This should be called on all type objects to finish their initialization. This function is responsible for adding inherited slots from a type’s base class. Return 0 on success, or return -1 and sets an exception on error.
         /// </summary>
         [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern int PyType_Ready(IntPtr type);

Original file line number	Diff line number	Diff line change
`@@ -6,6 +6,7 @@ namespace Python.Runtime`
`6`	`6`	`/// <summary>`
`7`	`7`	`/// Implements a Python descriptor type that provides access to CLR fields.`
`8`	`8`	`/// </summary>`
	`9`	`+ [Serializable]`
`9`	`10`	`internal class FieldObject : ExtensionType`
`10`	`11`	`{`
`11`	`12`	`private FieldInfo info;`