pythonnet · dmitriyse · Aug 31, 2017 · Sep 2, 2017 · Sep 2, 2017 · Sep 2, 2017
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -8,7 +8,8 @@ This document follows the conventions laid out in [Keep a CHANGELOG][].
 ## [unreleased][]
 
 ### Added
-
+-   Improved performance. String marshaling between python and clr now cached. 
+    Cache reduces GC pressure and saves from extensive memory copying.
 -   Added support for embedding python into dotnet core 2.0 (NetStandard 2.0)
 -   Added new build system (pythonnet.15.sln) based on dotnetcore-sdk/xplat(crossplatform msbuild).
     Currently there two side-by-side build systems that produces the same output (net40) from the same sources.

diff --git a/src/embed_tests/Python.EmbeddingTest.csproj b/src/embed_tests/Python.EmbeddingTest.csproj
@@ -104,6 +104,7 @@
     <Compile Include="TestPyWith.cs" />
     <Compile Include="TestRuntime.cs" />
     <Compile Include="TestPyScope.cs" />
+    <Compile Include="TestsSuite.cs" />
     <Compile Include="TestTypeManager.cs" />
     <Compile Include="GlobalTestsSetup.cs" />
   </ItemGroup>

diff --git a/src/embed_tests/TestPythonEngineProperties.cs b/src/embed_tests/TestPythonEngineProperties.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Diagnostics;
 using NUnit.Framework;
 using Python.Runtime;
 

diff --git a/src/embed_tests/TestRuntime.cs b/src/embed_tests/TestRuntime.cs
@@ -34,7 +34,7 @@ public static void PlatformCache()
 
             // Don't shut down the runtime: if the python engine was initialized
             // but not shut down by another test, we'd end up in a bad state.
-	}
+	      }
 
         [Test]
         public static void Py_IsInitializedValue()

diff --git a/src/embed_tests/TestsSuite.cs b/src/embed_tests/TestsSuite.cs
@@ -0,0 +1,18 @@
+using NUnit.Framework;
+using Python.Runtime;
+
+namespace Python.EmbeddingTest
+{
+    [SetUpFixture]
+    public class TestsSuite
+    {
+        [OneTimeTearDown]
+        public void FinalCleanup()
+        {
+            if (PythonEngine.IsInitialized)
+            {
+                PythonEngine.Shutdown();
+            }
+        }
+    }
+}
diff --git a/src/runtime/CustomMarshaler.cs b/src/runtime/CustomMarshaler.cs
@@ -18,7 +18,7 @@ public object MarshalNativeToManaged(IntPtr pNativeData)
 
         public abstract IntPtr MarshalManagedToNative(object managedObj);
 
-        public void CleanUpNativeData(IntPtr pNativeData)
+        public virtual void CleanUpNativeData(IntPtr pNativeData)
         {
             Marshal.FreeHGlobal(pNativeData);
         }
@@ -44,7 +44,12 @@ internal class UcsMarshaler : MarshalerBase
         private static readonly MarshalerBase Instance = new UcsMarshaler();
         private static readonly Encoding PyEncoding = Runtime.PyEncoding;
 
-        public override IntPtr MarshalManagedToNative(object managedObj)
+        private const int MaxStringLength = 100;
+        private const int MaxItemSize = 4 * (MaxStringLength + 1);
+        private static readonly EncodedStringsFifoDictionary EncodedStringsDictionary =
+            new EncodedStringsFifoDictionary(10000, MaxItemSize);
+
+        public override unsafe IntPtr MarshalManagedToNative(object managedObj)
         {
             var s = managedObj as string;
 
@@ -53,16 +58,36 @@ public override IntPtr MarshalManagedToNative(object managedObj)
                 return IntPtr.Zero;
             }
 
-            byte[] bStr = PyEncoding.GetBytes(s + "\0");
-            IntPtr mem = Marshal.AllocHGlobal(bStr.Length);
-            try
+            IntPtr mem;
+            int stringBytesCount;
+            if (s.Length <= MaxStringLength)
             {
-                Marshal.Copy(bStr, 0, mem, bStr.Length);
+                if (EncodedStringsDictionary.TryGetValue(s, out mem))
+                {
+                    return mem;
+                }
+
+                stringBytesCount = PyEncoding.GetByteCount(s);
+                mem = EncodedStringsDictionary.AddUnsafe(s);
             }
-            catch (Exception)
+            else
             {
-                Marshal.FreeHGlobal(mem);
-                throw;
+                stringBytesCount = PyEncoding.GetByteCount(s);
+                mem = Marshal.AllocHGlobal(stringBytesCount + 4);
+            }
+
+            fixed (char* str = s)
+            {
+                try
+                {
+                    PyEncoding.GetBytes(str, s.Length, (byte*)mem, stringBytesCount);
+                }
+                catch
+                {
+                    // Do nothing with this. Very strange problem.
+                }
+
+                *(int*)(mem + stringBytesCount) = 0;
             }
 
             return mem;
@@ -106,6 +131,14 @@ public static int GetUnicodeByteLength(IntPtr p)
             }
         }
 
+        public override void CleanUpNativeData(IntPtr pNativeData)
+        {
+            if (!EncodedStringsDictionary.IsKnownPtr(pNativeData))
+            {
+                base.CleanUpNativeData(pNativeData);
+            }
+        }
+
         /// <summary>
         /// Utility function for Marshaling Unicode on PY3 and AnsiStr on PY2.
         /// Use on functions whose Input signatures changed between PY2/PY3.
@@ -118,11 +151,29 @@ public static int GetUnicodeByteLength(IntPtr p)
         /// <remarks>
         /// You MUST deallocate the IntPtr of the Return when done with it.
         /// </remarks>
-        public static IntPtr Py3UnicodePy2StringtoPtr(string s)
+        public unsafe static IntPtr Py3UnicodePy2StringtoPtr(string s)
         {
-            return Runtime.IsPython3
-                ? Instance.MarshalManagedToNative(s)
-                : Marshal.StringToHGlobalAnsi(s);
+            if (Runtime.IsPython3)
+            {
+                int stringBytesCount = PyEncoding.GetByteCount(s);
+                IntPtr mem = Marshal.AllocHGlobal(stringBytesCount + 4);
+                fixed (char* str = s)
+                {
+                    try
+                    {
+                        PyEncoding.GetBytes(str, s.Length, (byte*)mem, stringBytesCount);
+                    }
+                    catch
+                    {
+                        // Do nothing with this. Very strange problem.
+                    }
+
+                    *(int*)(mem + stringBytesCount) = 0;
+                }
+                return mem;
+            }
+
+            return Marshal.StringToHGlobalAnsi(s);
         }
 
         /// <summary>
@@ -208,7 +259,12 @@ internal class Utf8Marshaler : MarshalerBase
         private static readonly MarshalerBase Instance = new Utf8Marshaler();
         private static readonly Encoding PyEncoding = Encoding.UTF8;
 
-        public override IntPtr MarshalManagedToNative(object managedObj)
+        private const int MaxStringLength = 100;
+
+        private static readonly EncodedStringsFifoDictionary EncodedStringsDictionary =
+            new EncodedStringsFifoDictionary(10000, 4 * (MaxStringLength + 1));
+
+        public override unsafe IntPtr MarshalManagedToNative(object managedObj)
         {
             var s = managedObj as string;
 
@@ -217,21 +273,49 @@ public override IntPtr MarshalManagedToNative(object managedObj)
                 return IntPtr.Zero;
             }
 
-            byte[] bStr = PyEncoding.GetBytes(s + "\0");
-            IntPtr mem = Marshal.AllocHGlobal(bStr.Length);
-            try
+            IntPtr mem;
+            int stringBytesCount;
+            if (s.Length <= MaxStringLength)
             {
-                Marshal.Copy(bStr, 0, mem, bStr.Length);
+                if (EncodedStringsDictionary.TryGetValue(s, out mem))
+                {
+                    return mem;
+                }
+
+                stringBytesCount = PyEncoding.GetByteCount(s);
+                mem = EncodedStringsDictionary.AddUnsafe(s);
             }
-            catch (Exception)
+            else
             {
-                Marshal.FreeHGlobal(mem);
-                throw;
+                stringBytesCount = PyEncoding.GetByteCount(s);
+                mem = Marshal.AllocHGlobal(stringBytesCount + 1);
+            }
+
+            fixed (char* str = s)
+            {
+                try
+                {
+                    PyEncoding.GetBytes(str, s.Length, (byte*)mem, stringBytesCount);
+                }
+                catch
+                {
+                    // Do nothing with this. Very strange problem.
+                }
+
+                ((byte*)mem)[stringBytesCount] = 0;
             }
 
             return mem;
         }
 
+        public override void CleanUpNativeData(IntPtr pNativeData)
+        {
+            if (!EncodedStringsDictionary.IsKnownPtr(pNativeData))
+            {
+                base.CleanUpNativeData(pNativeData);
+            }
+        }
+
         public static ICustomMarshaler GetInstance(string cookie)
         {
             return Instance;

diff --git a/src/runtime/Python.Runtime.csproj b/src/runtime/Python.Runtime.csproj
@@ -76,6 +76,12 @@
     <Reference Include="System" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="perf_utils\EncodedStringsFifoDictionary.cs" />
+    <Compile Include="perf_utils\EncodingGetStringPolyfill.cs" />
+    <Compile Include="perf_utils\FifoDictionary.cs" />
+    <Compile Include="perf_utils\RawImmutableMemBlock.cs" />
+    <Compile Include="perf_utils\RawMemoryFifoDictionary.cs" />
+    <Compile Include="perf_utils\RawMemUtils.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="..\SharedAssemblyInfo.cs">
       <Link>Properties\SharedAssemblyInfo.cs</Link>

diff --git a/src/runtime/assemblymanager.cs b/src/runtime/assemblymanager.cs
@@ -27,6 +27,7 @@ internal class AssemblyManager
         //    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 =
             new ConcurrentDictionary<string, ConcurrentDictionary<Assembly, string>>();
+
         //private static Dictionary<string, Dictionary<string, string>> generics;
         private static AssemblyLoadEventHandler lhandler;
         private static ResolveEventHandler rhandler;

diff --git a/src/runtime/perf_utils/EncodedStringsFifoDictionary.cs b/src/runtime/perf_utils/EncodedStringsFifoDictionary.cs
@@ -0,0 +1,73 @@
+using System;
+
+namespace Python.Runtime
+{
+    using System.Runtime.InteropServices;
+
+    public class EncodedStringsFifoDictionary: IDisposable
+    {
+        private readonly FifoDictionary<string, IntPtr> _innerDictionary;
+
+        private readonly IntPtr _rawMemory;
+
+        private readonly int _allocatedSize;
+
+        public EncodedStringsFifoDictionary(int capacity, int maxItemSize)
+        {
+            if (maxItemSize < 1)
+            {
+                throw new ArgumentOutOfRangeException(
+                    nameof(maxItemSize),
+                    "Maximum item size should be non-zero positive.");
+            }
+
+            _innerDictionary = new FifoDictionary<string, IntPtr>(capacity);
+            _allocatedSize = maxItemSize * capacity;
+            _rawMemory = Marshal.AllocHGlobal(_allocatedSize);
+
+            MaxItemSize = maxItemSize;
+        }
+
+        public int MaxItemSize { get; }
+
+        public bool TryGetValue(string key, out IntPtr value)
+        {
+            return _innerDictionary.TryGetValue(key, out value);
+        }
+
+        public IntPtr AddUnsafe(string key)
+        {
+            int nextSlot = _innerDictionary.NextSlotToAdd;
+            IntPtr ptr = _rawMemory + (MaxItemSize * nextSlot);
+            _innerDictionary.AddUnsafe(key, ptr);
+            return ptr;
+        }
+
+        public bool IsKnownPtr(IntPtr ptr)
+        {
+            var uptr = (ulong)ptr;
+            var umem = (ulong)_rawMemory;
+
+            return uptr >= umem && uptr < umem + (ulong)_allocatedSize;
+        }
+
+        private void ReleaseUnmanagedResources()
+        {
+            if (_rawMemory != IntPtr.Zero)
+            {
+                Marshal.FreeHGlobal(_rawMemory);
+            }
+        }
+
+        public void Dispose()
+        {
+            ReleaseUnmanagedResources();
+            GC.SuppressFinalize(this);
+        }
+
+        ~EncodedStringsFifoDictionary()
+        {
+            ReleaseUnmanagedResources();
+        }
+    }
+}
diff --git a/src/runtime/perf_utils/EncodingGetStringPolyfill.cs b/src/runtime/perf_utils/EncodingGetStringPolyfill.cs
@@ -0,0 +1,53 @@
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using System.Runtime.InteropServices;
+using System.Text;
+
+namespace Python.Runtime
+{
+#if !NETSTANDARD
+    /// <summary>
+    /// This polyfill is thread unsafe.
+    /// </summary>
+    [CLSCompliant(false)]
+    public static class EncodingGetStringPolyfill
+    {
+        private static readonly MethodInfo PlatformGetStringMethodInfo =
+            typeof(Encoding).GetMethod(
+                "GetString",
+                BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null,
+                new[]
+                {
+                    typeof(byte*), typeof(int)
+                }, null);
+
+        private static readonly byte[] StdDecodeBuffer = PlatformGetStringMethodInfo == null ? new byte[1024 * 1024] : null;
+
+        private static Dictionary<Encoding, EncodingGetStringUnsafeDelegate> PlatformGetStringMethodsDelegatesCache = new Dictionary<Encoding, EncodingGetStringUnsafeDelegate>();
+
+        private unsafe delegate string EncodingGetStringUnsafeDelegate(byte* pstr, int size);
+
+        public unsafe static string GetString(this Encoding encoding, byte* pstr, int size)
+        {
+            if (PlatformGetStringMethodInfo != null)
+            {
+                EncodingGetStringUnsafeDelegate getStringDelegate;
+                if (!PlatformGetStringMethodsDelegatesCache.TryGetValue(encoding, out getStringDelegate))
+                {
+                    getStringDelegate =
+                        (EncodingGetStringUnsafeDelegate)Delegate.CreateDelegate(
+                            typeof(EncodingGetStringUnsafeDelegate), encoding, PlatformGetStringMethodInfo);
+                    PlatformGetStringMethodsDelegatesCache.Add(encoding, getStringDelegate);
+                }
+                return getStringDelegate(pstr, size);
+            }
+
+            byte[] buffer = size <= StdDecodeBuffer.Length ? StdDecodeBuffer : new byte[size];
+            Marshal.Copy((IntPtr)pstr, buffer, 0, size);
+            return encoding.GetString(buffer, 0, size);
+        }
+    }
+#endif
+
+}
-Original file line number
+Diff line change
@@ Expand Up / @@ -34,7 +34,7 @@ public static void PlatformCache() @@
                 // Don't shut down the runtime: if the python engine was initialized
                 // but not shut down by another test, we'd end up in a bad state.
-    	}
+    	      }
             [Test]
             public static void Py_IsInitializedValue()
@@ Expand Down @@