Add GetNativeThreadID method in PythonEngine and different PyThreadSt…

…ate_SetAsyncExc calls for OS and Python version
pythonnet · lostmsu · Jan 21, 2021 · Dec 26, 2020 · Dec 27, 2020 · Dec 27, 2020
commit d07cd05e9c738f4f62cf91d4e1fc83283c704730
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -11,10 +11,14 @@ This document follows the conventions laid out in [Keep a CHANGELOG][].
 
 -   Ability to instantiate new .NET arrays using `Array[T](dim1, dim2, ...)` syntax
 <<<<<<< HEAD
+<<<<<<< HEAD
 -   Python operator method will call C# operator method for supported binary and unary operators ([#1324][p1324]).
 =======
 -   Add Interrupt method in PythonEngine
 >>>>>>> Add Interrupt method in PythonEngine
+=======
+-   Add GetNativeThreadID and Interrupt methods in PythonEngine
+>>>>>>> Add GetNativeThreadID method in PythonEngine and different PyThreadState_SetAsyncExc calls for OS and Python version
 
 ### Changed
 -   Drop support for Python 2, 3.4, and 3.5

diff --git a/src/embed_tests/TestInterrupt.cs b/src/embed_tests/TestInterrupt.cs
@@ -1,6 +1,5 @@
 
 using System;
-using System.Runtime.InteropServices;
 using System.Threading;
 using System.Threading.Tasks;
 
@@ -14,15 +13,6 @@ public class TestInterrupt
     {
         private IntPtr _threadState;
 
-        [DllImport("Kernel32", EntryPoint = "GetCurrentThreadId", ExactSpelling = true)]
-        private static extern uint GetCurrentThreadId();
-
-        [DllImport("libc", EntryPoint = "pthread_self")]
-        private static extern IntPtr pthread_selfLinux();
-
-        [DllImport("pthread", EntryPoint = "pthread_self", CallingConvention = CallingConvention.Cdecl)]
-        private static extern ulong pthread_selfOSX();
-
         [OneTimeSetUp]
         public void SetUp()
         {
@@ -44,21 +34,9 @@ public void InterruptTest()
             ulong nativeThreadId = 0;
             Task.Factory.StartNew(() =>
             {
-                if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
-                {
-                    nativeThreadId = GetCurrentThreadId();
-                }
-                else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
-                {
-                    nativeThreadId = (ulong)pthread_selfLinux();
-                }
-                else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
-                {
-                    nativeThreadId = pthread_selfOSX();
-                }
-
                 using (Py.GIL())
                 {
+                    nativeThreadId = PythonEngine.GetNativeThreadID();
                     runSimpleStringReturnValue = PythonEngine.RunSimpleString(@"
 import time
 
@@ -75,7 +53,7 @@ import time
                 Assert.AreEqual(1, interruptReturnValue);
             }
 
-            Thread.Sleep(300);
+            Thread.Sleep(500);
 
             Assert.AreEqual(-1, runSimpleStringReturnValue);
         }

diff --git a/src/runtime/pythonengine.cs b/src/runtime/pythonengine.cs
@@ -12,6 +12,15 @@ namespace Python.Runtime
     /// </summary>
     public class PythonEngine : IDisposable
     {
+        [DllImport("Kernel32", EntryPoint = "GetCurrentThreadId", ExactSpelling = true)]
+        private static extern uint GetCurrentThreadId();
+
+        [DllImport("libc", EntryPoint = "pthread_self")]
+        private static extern IntPtr pthread_selfLinux();
+
+        [DllImport("pthread", EntryPoint = "pthread_self", CallingConvention = CallingConvention.Cdecl)]
+        private static extern ulong pthread_selfOSX();
+
         public static ShutdownMode ShutdownMode
         {
             get => Runtime.ShutdownMode;
@@ -567,14 +576,59 @@ public static void Exec(string code, IntPtr? globals = null, IntPtr? locals = nu
             }
         }
 
+        /// <summary>
+        /// Gets the native thread ID.
+        /// </summary>
+        /// <returns>The native thread ID.</returns>
+        public static ulong GetNativeThreadID()
+        {
+            if (Runtime.PyVersion >= new Version(3, 8))
+            {
+                dynamic threading = Py.Import("threading");
+                return threading.get_native_id();
+            }
+
+            if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+            {
+                return GetCurrentThreadId();
+            }
+
+            if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
+            {
+                return (ulong)pthread_selfLinux();
+            }
+
+            if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
+            {
+                return pthread_selfOSX();
+            }
+
+            return 0;
+        }
+
         /// <summary>
         /// Interrupts the execution of a thread.
         /// </summary>
-        /// <param name="nativeThreadId">The native thread id.</param>
+        /// <param name="nativeThreadID">The native thread ID.</param>
         /// <returns>The number of thread states modified; this is normally one, but will be zero if the thread id isn’t found.</returns>
-        public static int Interrupt(ulong nativeThreadId)
+        public static int Interrupt(ulong nativeThreadID)
         {
-            return Runtime.PyThreadState_SetAsyncExc(nativeThreadId, Exceptions.KeyboardInterrupt);
+            if (Runtime.PyVersion >= new Version(3, 7))
+            {
+                if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+                {
+                    return Runtime.PyThreadState_SetAsyncExc37Windows(nativeThreadID, Exceptions.KeyboardInterrupt);
+                }
+
+                return Runtime.PyThreadState_SetAsyncExc37NonWindows((UIntPtr)nativeThreadID, Exceptions.KeyboardInterrupt);
+            }
+
+            if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+            {
+                return Runtime.PyThreadState_SetAsyncExc36Windows((long)nativeThreadID, Exceptions.KeyboardInterrupt);
+            }
+
+            return Runtime.PyThreadState_SetAsyncExc36NonWindows((IntPtr)nativeThreadID, Exceptions.KeyboardInterrupt);
         }
 
         /// <summary>

diff --git a/src/runtime/runtime.cs b/src/runtime/runtime.cs
@@ -2143,8 +2143,17 @@ internal static void Py_CLEAR(ref IntPtr ob)
         [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern int Py_AddPendingCall(IntPtr func, IntPtr arg);
 
-        [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
-        internal static extern int PyThreadState_SetAsyncExc(ulong id, IntPtr exc);
+        [DllImport(_PythonDll, EntryPoint = "PyThreadState_SetAsyncExc", CallingConvention = CallingConvention.Cdecl)]
+        internal static extern int PyThreadState_SetAsyncExc37Windows(ulong id, IntPtr exc);
+
+        [DllImport(_PythonDll, EntryPoint = "PyThreadState_SetAsyncExc", CallingConvention = CallingConvention.Cdecl)]
+        internal static extern int PyThreadState_SetAsyncExc36Windows(long id, IntPtr exc);
+
+        [DllImport(_PythonDll, EntryPoint = "PyThreadState_SetAsyncExc", CallingConvention = CallingConvention.Cdecl)]
+        internal static extern int PyThreadState_SetAsyncExc37NonWindows(UIntPtr id, IntPtr exc);
+
+        [DllImport(_PythonDll, EntryPoint = "PyThreadState_SetAsyncExc", CallingConvention = CallingConvention.Cdecl)]
+        internal static extern int PyThreadState_SetAsyncExc36NonWindows(IntPtr id, IntPtr exc);
 
         [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern int Py_MakePendingCalls();