Runtime/Shutdown loop stores old caches and static variables. It's produces bugs when CPython freeing up enough objects.

dse · filmor · commit b0c68e6a662e · 2018-11-14T14:38:47.000+01:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -27,6 +27,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][i434]) for setup.py
 -   Fixed crashes when integrating pythonnet in Unity3d ([#714][i714]),
     related to unloading the Application Domain
diff --git a/src/runtime/assemblymanager.cs b/src/runtime/assemblymanager.cs
@@ -24,14 +24,14 @@ internal class AssemblyManager
         //    than it can end up referring to assemblies that are already unloaded (default behavior after unload appDomain - 
         //     unless LoaderOptimization.MultiDomain is used);
         //    So for multidomain support it is better to have the dict. recreated for each app-domain initialization
-        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 ConcurrentQueue<Assembly> assemblies;
@@ -48,10 +48,7 @@ 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 ConcurrentQueue<Assembly>();
+            assemblies = new AssemblyList(16);
             pypath = new List<string>(16);
 
             AppDomain domain = AppDomain.CurrentDomain;
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
@@ -335,6 +335,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
@@ -281,6 +281,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
@@ -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

Original file line number	Diff line number	Diff line change
`@@ -537,10 +537,15 @@ public void Dispose()`
`537`	`537`
`538`	`538`	`public class PyScopeManager`
`539`	`539`	`{`
`540`		`- public readonly static PyScopeManager Global = new PyScopeManager();`
	`540`	`+ public static PyScopeManager Global;`
`541`	`541`
`542`	`542`	`private Dictionary<string, PyScope> NamedScopes = new Dictionary<string, PyScope>();`
`543`	`543`
	`544`	`+ internal static void Reset()`
	`545`	`+ {`
	`546`	`+ Global = new PyScopeManager();`
	`547`	`+ }`
	`548`	`+`
`544`	`549`	`internal PyScope NewScope(string name)`
`545`	`550`	`{`
`546`	`551`	`if (name == null)`
Original file line number	Diff line number	Diff line change
`@@ -21,6 +21,10 @@ static TypeManager()`
`21`	`21`	`cache = new Dictionary<Type, IntPtr>(128);`
`22`	`22`	`}`
`23`	`23`
	`24`	`+ public static void Reset()`
	`25`	`+ {`
	`26`	`+ cache = new Dictionary<Type, IntPtr>(128);`
	`27`	`+ }`
`24`	`28`
`25`	`29`	`/// <summary>`
`26`	`30`	`/// Given a managed Type derived from ExtensionType, get the handle to`