Use get_ident and LLP64 and LP64 in DllImport names and ulong in public methods and assert nativeThreadID value

gpetrou · gpetrou · commit ce3d6b4278f6 · 2021-01-08T06:56:18.000Z
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -10,15 +10,8 @@ This document follows the conventions laid out in [Keep a CHANGELOG][].
 ### Added
 
 -   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
@@ -31,7 +31,7 @@ public void Dispose()
         public void InterruptTest()
         {
             int runSimpleStringReturnValue = int.MinValue;
-            uint nativeThreadID = uint.MinValue;
+            ulong nativeThreadID = ulong.MinValue;
             Task.Factory.StartNew(() =>
             {
                 using (Py.GIL())
@@ -47,6 +47,8 @@ import time
 
             Thread.Sleep(200);
 
+            Assert.AreNotEqual(ulong.MinValue, nativeThreadID);
+
             using (Py.GIL())
             {
                 int interruptReturnValue = PythonEngine.Interrupt(nativeThreadID);
diff --git a/src/runtime/pythonengine.cs b/src/runtime/pythonengine.cs
@@ -12,15 +12,6 @@ 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 UIntPtr pthread_selfLinux();
-
-        [DllImport("pthread", EntryPoint = "pthread_self", CallingConvention = CallingConvention.Cdecl)]
-        private static extern uint pthread_selfOSX();
-
         public static ShutdownMode ShutdownMode
         {
             get => Runtime.ShutdownMode;
@@ -580,55 +571,25 @@ public static void Exec(string code, IntPtr? globals = null, IntPtr? locals = nu
         /// Gets the native thread ID.
         /// </summary>
         /// <returns>The native thread ID.</returns>
-        public static uint GetNativeThreadID()
+        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 pthread_selfLinux().ToUInt32();
-            }
-
-            if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
-            {
-                return pthread_selfOSX();
-            }
-
-            throw new InvalidOperationException("Could not retrieve native thread ID.");
+            dynamic threading = Py.Import("threading");
+            return threading.get_ident();
         }
 
         /// <summary>
         /// Interrupts the execution of a thread.
         /// </summary>
         /// <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(uint nativeThreadID)
+        public static int Interrupt(ulong nativeThreadID)
         {
-            if (Runtime.PyVersion >= new Version(3, 7))
-            {
-                if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
-                {
-                    return Runtime.PyThreadState_SetAsyncExc37Windows(nativeThreadID, Exceptions.KeyboardInterrupt);
-                }
-
-                return Runtime.PyThreadState_SetAsyncExc37NonWindows(new UIntPtr(nativeThreadID), Exceptions.KeyboardInterrupt);
-            }
-
             if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
             {
-                return Runtime.PyThreadState_SetAsyncExc36Windows((int)nativeThreadID, Exceptions.KeyboardInterrupt);
+                return Runtime.PyThreadState_SetAsyncExcLLP64((uint)nativeThreadID, Exceptions.KeyboardInterrupt);
             }
 
-            return Runtime.PyThreadState_SetAsyncExc36NonWindows(new IntPtr(nativeThreadID), Exceptions.KeyboardInterrupt);
+            return Runtime.PyThreadState_SetAsyncExcLP64(nativeThreadID, Exceptions.KeyboardInterrupt);
         }
 
         /// <summary>
diff --git a/src/runtime/runtime.cs b/src/runtime/runtime.cs
@@ -2147,16 +2147,10 @@ internal static void Py_CLEAR(ref IntPtr ob)
         internal static extern int Py_AddPendingCall(IntPtr func, IntPtr arg);
 
         [DllImport(_PythonDll, EntryPoint = "PyThreadState_SetAsyncExc", CallingConvention = CallingConvention.Cdecl)]
-        internal static extern int PyThreadState_SetAsyncExc37Windows(uint id, IntPtr exc);
+        internal static extern int PyThreadState_SetAsyncExcLLP64(uint id, IntPtr exc);
 
         [DllImport(_PythonDll, EntryPoint = "PyThreadState_SetAsyncExc", CallingConvention = CallingConvention.Cdecl)]
-        internal static extern int PyThreadState_SetAsyncExc36Windows(int 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);
+        internal static extern int PyThreadState_SetAsyncExcLP64(ulong id, IntPtr exc);
 
         [DllImport(_PythonDll, CallingConvention = CallingConvention.Cdecl)]
         internal static extern int Py_MakePendingCalls();

Original file line number	Diff line number	Diff line change
`@@ -31,7 +31,7 @@ public void Dispose()`
`31`	`31`	`public void InterruptTest()`
`32`	`32`	`{`
`33`	`33`	`int runSimpleStringReturnValue = int.MinValue;`
`34`		`- uint nativeThreadID = uint.MinValue;`
	`34`	`+ ulong nativeThreadID = ulong.MinValue;`
`35`	`35`	`Task.Factory.StartNew(() =>`
`36`	`36`	`{`
`37`	`37`	`using (Py.GIL())`
`@@ -47,6 +47,8 @@ import time`
`47`	`47`
`48`	`48`	`Thread.Sleep(200);`
`49`	`49`
	`50`	`+ Assert.AreNotEqual(ulong.MinValue, nativeThreadID);`
	`51`	`+`
`50`	`52`	`using (Py.GIL())`
`51`	`53`	`{`
`52`	`54`	`int interruptReturnValue = PythonEngine.Interrupt(nativeThreadID);`