Release method wrapper(split from #958) (#1002)

amos402 · filmor · commit c1190f4397f3 · 2019-12-18T09:03:28.000+01:00
* Add exception helper
* Release memory on ImportHook.Shutdown
* Release ModuleDef when py_clr_module released
* Completely ModuleDef initialization
diff --git a/src/runtime/importhook.cs b/src/runtime/importhook.cs
@@ -23,6 +23,16 @@ internal static void InitializeModuleDef()
                 module_def = ModuleDefOffset.AllocModuleDef("clr");
             }
         }
+
+        internal static void ReleaseModuleDef()
+        {
+            if (module_def == IntPtr.Zero)
+            {
+                return;
+            }
+            ModuleDefOffset.FreeModuleDef(module_def);
+            module_def = IntPtr.Zero;
+        }
 #endif
 
         /// <summary>
@@ -56,9 +66,12 @@ static void InitImport()
             // Python __import__.
             IntPtr builtins = GetNewRefToBuiltins();
             py_import = Runtime.PyObject_GetAttrString(builtins, "__import__");
+            PythonException.ThrowIfIsNull(py_import);
+
             hook = new MethodWrapper(typeof(ImportHook), "__import__", "TernaryFunc");
-            Runtime.PyObject_SetAttrString(builtins, "__import__", hook.ptr);
-            Runtime.XDecref(hook.ptr);
+            int res = Runtime.PyObject_SetAttrString(builtins, "__import__", hook.ptr);
+            PythonException.ThrowIfIsNotZero(res);
+
             Runtime.XDecref(builtins);
         }
 
@@ -69,10 +82,14 @@ static void RestoreImport()
         {
             IntPtr builtins = GetNewRefToBuiltins();
 
-            Runtime.PyObject_SetAttrString(builtins, "__import__", py_import);
+            int res = Runtime.PyObject_SetAttrString(builtins, "__import__", py_import);
+            PythonException.ThrowIfIsNotZero(res);
             Runtime.XDecref(py_import);
             py_import = IntPtr.Zero;
 
+            hook.Release();
+            hook = null;
+
             Runtime.XDecref(builtins);
         }
 
@@ -112,13 +129,26 @@ internal static void Initialize()
         /// </summary>
         internal static void Shutdown()
         {
-            if (Runtime.Py_IsInitialized() != 0)
+            if (Runtime.Py_IsInitialized() == 0)
             {
-                RestoreImport();
+                return;
+            }
 
-                Runtime.XDecref(py_clr_module);
-                Runtime.XDecref(root.pyHandle);
+            RestoreImport();
+
+            bool shouldFreeDef = Runtime.Refcount(py_clr_module) == 1;
+            Runtime.XDecref(py_clr_module);
+            py_clr_module = IntPtr.Zero;
+#if PYTHON3
+            if (shouldFreeDef)
+            {
+                ReleaseModuleDef();
             }
+#endif
+
+            Runtime.XDecref(root.pyHandle);
+            root = null;
+            CLRModule.Reset();
         }
 
         /// <summary>
diff --git a/src/runtime/interop.cs b/src/runtime/interop.cs
@@ -227,7 +227,7 @@ public static IntPtr AllocModuleDef(string modulename)
             byte[] ascii = Encoding.ASCII.GetBytes(modulename);
             int size = name + ascii.Length + 1;
             IntPtr ptr = Marshal.AllocHGlobal(size);
-            for (int i = 0; i < m_free; i += IntPtr.Size)
+            for (int i = 0; i <= m_free; i += IntPtr.Size)
                 Marshal.WriteIntPtr(ptr, i, IntPtr.Zero);
             Marshal.Copy(ascii, 0, (IntPtr)(ptr + name), ascii.Length);
             Marshal.WriteIntPtr(ptr, m_name, (IntPtr)(ptr + name));
diff --git a/src/runtime/methodwrapper.cs b/src/runtime/methodwrapper.cs
@@ -12,6 +12,7 @@ internal class MethodWrapper
     {
         public IntPtr mdef;
         public IntPtr ptr;
+        private bool _disposed = false;
 
         public MethodWrapper(Type type, string name, string funcType = null)
         {
@@ -31,5 +32,21 @@ public IntPtr Call(IntPtr args, IntPtr kw)
         {
             return Runtime.PyCFunction_Call(ptr, args, kw);
         }
+
+        public void Release()
+        {
+            if (_disposed)
+            {
+                return;
+            }
+            _disposed = true;
+            bool freeDef = Runtime.Refcount(ptr) == 1;
+            Runtime.XDecref(ptr);
+            if (freeDef && mdef != IntPtr.Zero)
+            {
+                Runtime.PyMem_Free(mdef);
+                mdef = IntPtr.Zero;
+            }
+        }
     }
 }
diff --git a/src/runtime/moduleobject.cs b/src/runtime/moduleobject.cs
@@ -316,6 +316,11 @@ internal class CLRModule : ModuleObject
         internal static bool _SuppressDocs = false;
         internal static bool _SuppressOverloads = false;
 
+        static CLRModule()
+        {
+            Reset();
+        }
+
         public CLRModule() : base("clr")
         {
             _namespace = string.Empty;
diff --git a/src/runtime/runtime.cs b/src/runtime/runtime.cs
@@ -187,7 +187,6 @@ internal static void Initialize(bool initSigs = false)
 
             IsFinalizing = false;
 
-            CLRModule.Reset();
             GenericUtil.Reset();
             PyScopeManager.Reset();
             ClassManager.Reset();

Original file line number	Diff line number	Diff line change
`@@ -12,6 +12,7 @@ internal class MethodWrapper`
`12`	`12`	`{`
`13`	`13`	`public IntPtr mdef;`
`14`	`14`	`public IntPtr ptr;`
	`15`	`+ private bool _disposed = false;`
`15`	`16`
`16`	`17`	`public MethodWrapper(Type type, string name, string funcType = null)`
`17`	`18`	`{`
`@@ -31,5 +32,21 @@ public IntPtr Call(IntPtr args, IntPtr kw)`
`31`	`32`	`{`
`32`	`33`	`return Runtime.PyCFunction_Call(ptr, args, kw);`
`33`	`34`	`}`
	`35`	`+`
	`36`	`+ public void Release()`
	`37`	`+ {`
	`38`	`+ if (_disposed)`
	`39`	`+ {`
	`40`	`+ return;`
	`41`	`+ }`
	`42`	`+ _disposed = true;`
	`43`	`+ bool freeDef = Runtime.Refcount(ptr) == 1;`
	`44`	`+ Runtime.XDecref(ptr);`
	`45`	`+ if (freeDef && mdef != IntPtr.Zero)`
	`46`	`+ {`
	`47`	`+ Runtime.PyMem_Free(mdef);`
	`48`	`+ mdef = IntPtr.Zero;`
	`49`	`+ }`
	`50`	`+ }`
`34`	`51`	`}`
`35`	`52`	`}`