Runtime/Shutdown loop stores old caches and static variables. It's pr…

…oduces bugs when CPython freeing up enough objects.
pythonnet · dmitriyse · Aug 31, 2017 · Sep 2, 2017 · Sep 2, 2017 · Sep 2, 2017
commit 9de6f7bd071f60c67b42847f33453c0d5bd61c7a
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -21,6 +21,8 @@ This document follows the conventions laid out in [Keep a CHANGELOG][].
 
 ### Fixed
 
+-   Fixed secondary PythonEngine.Initialize call, all sensitive static variables now reseted.
+    This is a hidden bug. Once python cleaning up enough memory, objects from previous engine run becomes corrupted.
 -   Fixed Visual Studio 2017 compat (#434) for setup.py
 -   Fixed crash on exit of the Python interpreter if a python class
     derived from a .NET class has a `__namespace__` or `__assembly__`

diff --git a/src/runtime/assemblymanager.cs b/src/runtime/assemblymanager.cs
@@ -17,13 +17,14 @@ internal class AssemblyManager
     {
         // modified from event handlers below, potentially triggered from different .NET threads
         // therefore this should be a ConcurrentDictionary
-        private static ConcurrentDictionary<string, ConcurrentDictionary<Assembly, string>> namespaces;
+        private static ConcurrentDictionary<string, ConcurrentDictionary<Assembly, string>> namespaces =
+            new ConcurrentDictionary<string, ConcurrentDictionary<Assembly, string>>();
         //private static Dictionary<string, Dictionary<string, string>> generics;
         private static AssemblyLoadEventHandler lhandler;
         private static ResolveEventHandler rhandler;
 
         // updated only under GIL?
-        private static Dictionary<string, int> probed;
+        private static Dictionary<string, int> probed = new Dictionary<string, int>(32);
 
         // modified from event handlers below, potentially triggered from different .NET threads
         private static AssemblyList assemblies;
@@ -40,9 +41,6 @@ private AssemblyManager()
         /// </summary>
         internal static void Initialize()
         {
-            namespaces = new ConcurrentDictionary<string, ConcurrentDictionary<Assembly, string>>();
-            probed = new Dictionary<string, int>(32);
-            //generics = new Dictionary<string, Dictionary<string, string>>();
             assemblies = new AssemblyList(16);
             pypath = new List<string>(16);
 

diff --git a/src/runtime/classderived.cs b/src/runtime/classderived.cs
@@ -1,8 +1,9 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;
 using System.Reflection.Emit;
+using System.Resources;
 using System.Runtime.InteropServices;
 using System.Threading.Tasks;
 
@@ -32,6 +33,12 @@ static ClassDerivedObject()
             moduleBuilders = new Dictionary<Tuple<string, string>, ModuleBuilder>();
         }
 
+        public static void Reset()
+        {
+            assemblyBuilders = new Dictionary<string, AssemblyBuilder>();
+            moduleBuilders = new Dictionary<Tuple<string, string>, ModuleBuilder>();
+        }
+
         internal ClassDerivedObject(Type tp) : base(tp)
         {
         }

diff --git a/src/runtime/classmanager.cs b/src/runtime/classmanager.cs
@@ -34,6 +34,11 @@ static ClassManager()
             dtype = typeof(MulticastDelegate);
         }
 
+        public static void Reset()
+        {
+            cache = new Dictionary<Type, ClassBase>(128);
+        }
+
         /// <summary>
         /// Return the ClassBase-derived instance that implements a particular
         /// reflected managed type, creating it if it doesn't yet exist.

diff --git a/src/runtime/genericutil.cs b/src/runtime/genericutil.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Resources;
 
 namespace Python.Runtime
 {
@@ -20,6 +21,11 @@ static GenericUtil()
             mapping = new Dictionary<string, Dictionary<string, List<string>>>();
         }
 
+        public static void Reset()
+        {
+            mapping = new Dictionary<string, Dictionary<string, List<string>>>();
+        }
+
         /// <summary>
         /// Register a generic type that appears in a given namespace.
         /// </summary>

diff --git a/src/runtime/moduleobject.cs b/src/runtime/moduleobject.cs
@@ -328,6 +328,17 @@ public CLRModule() : base("clr")
             }
         }
 
+        public static void Reset()
+        {
+            hacked = false;
+            interactive_preload = true;
+            preload = false;
+
+            // XXX Test performance of new features //
+            _SuppressDocs = false;
+            _SuppressOverloads = false;
+        }
+
         /// <summary>
         /// The initializing of the preload hook has to happen as late as
         /// possible since sys.ps1 is created after the CLR module is

diff --git a/src/runtime/pyscope.cs b/src/runtime/pyscope.cs
@@ -537,10 +537,15 @@ public void Dispose()
 
     public class PyScopeManager
     {
-        public readonly static PyScopeManager Global = new PyScopeManager();
+        public static PyScopeManager Global;
 
         private Dictionary<string, PyScope> NamedScopes = new Dictionary<string, PyScope>();
 
+        internal static void Reset()
+        {
+            Global = new PyScopeManager();
+        }
+
         internal PyScope NewScope(string name)
         {
             if (name == null)

diff --git a/src/runtime/runtime.cs b/src/runtime/runtime.cs
@@ -221,6 +221,13 @@ internal static void Initialize()
                 PyEval_InitThreads();
             }
 
+            CLRModule.Reset();
+            GenericUtil.Reset();
+            PyScopeManager.Reset();
+            ClassManager.Reset();
+            ClassDerivedObject.Reset();
+            TypeManager.Reset();
+
             IntPtr op;
             IntPtr dict;
             if (IsPython3)

diff --git a/src/runtime/typemanager.cs b/src/runtime/typemanager.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections;
 using System.Collections.Generic;
 using System.Reflection;
@@ -21,6 +21,10 @@ static TypeManager()
             cache = new Dictionary<Type, IntPtr>(128);
         }
 
+        public static void Reset()
+        {
+            cache = new Dictionary<Type, IntPtr>(128);
+        }
 
         /// <summary>
         /// Given a managed Type derived from ExtensionType, get the handle to