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

gpetrou · gpetrou · commit 9b18f2603c6f · 2021-01-08T07:00:19.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,12 +31,12 @@ public void Dispose()
         public void InterruptTest()
         {
             int runSimpleStringReturnValue = int.MinValue;
-            ulong nativeThreadId = 0;
+            ulong nativeThreadID = ulong.MinValue;
             Task.Factory.StartNew(() =>
             {
                 using (Py.GIL())
                 {
-                    nativeThreadId = PythonEngine.GetNativeThreadID();
+                    nativeThreadID = PythonEngine.GetNativeThreadID();
                     runSimpleStringReturnValue = PythonEngine.RunSimpleString(@"
 import time
 
@@ -47,13 +47,15 @@ import time
 
             Thread.Sleep(200);
 
+            Assert.AreNotEqual(ulong.MinValue, nativeThreadID);
+
             using (Py.GIL())
             {
-                int interruptReturnValue = PythonEngine.Interrupt(nativeThreadId);
+                int interruptReturnValue = PythonEngine.Interrupt(nativeThreadID);
                 Assert.AreEqual(1, interruptReturnValue);
             }
 
-            Thread.Sleep(500);
+            Thread.Sleep(300);
 
             Assert.AreEqual(-1, runSimpleStringReturnValue);
         }
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 IntPtr pthread_selfLinux();
-
-        [DllImport("pthread", EntryPoint = "pthread_self", CallingConvention = CallingConvention.Cdecl)]
-        private static extern ulong pthread_selfOSX();
-
         public static ShutdownMode ShutdownMode
         {
             get => Runtime.ShutdownMode;
@@ -582,28 +573,8 @@ public static void Exec(string code, IntPtr? globals = null, IntPtr? locals = nu
         /// <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;
+            dynamic threading = Py.Import("threading");
+            return threading.get_ident();
         }
 
         /// <summary>
@@ -613,22 +584,12 @@ public static ulong GetNativeThreadID()
         /// <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)
         {
-            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_SetAsyncExcLLP64((uint)nativeThreadID, Exceptions.KeyboardInterrupt);
             }
 
-            return Runtime.PyThreadState_SetAsyncExc36NonWindows((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(ulong 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(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);
+        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,12 +31,12 @@ public void Dispose()`
`31`	`31`	`public void InterruptTest()`
`32`	`32`	`{`
`33`	`33`	`int runSimpleStringReturnValue = int.MinValue;`
`34`		`- ulong nativeThreadId = 0;`
	`34`	`+ ulong nativeThreadID = ulong.MinValue;`
`35`	`35`	`Task.Factory.StartNew(() =>`
`36`	`36`	`{`
`37`	`37`	`using (Py.GIL())`
`38`	`38`	`{`
`39`		`- nativeThreadId = PythonEngine.GetNativeThreadID();`
	`39`	`+ nativeThreadID = PythonEngine.GetNativeThreadID();`
`40`	`40`	`runSimpleStringReturnValue = PythonEngine.RunSimpleString(@"`
`41`	`41`	`import time`
`42`	`42`
`@@ -47,13 +47,15 @@ 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`		`- int interruptReturnValue = PythonEngine.Interrupt(nativeThreadId);`
	`54`	`+ int interruptReturnValue = PythonEngine.Interrupt(nativeThreadID);`
`53`	`55`	`Assert.AreEqual(1, interruptReturnValue);`
`54`	`56`	`}`
`55`	`57`
`56`		`- Thread.Sleep(500);`
	`58`	`+ Thread.Sleep(300);`
`57`	`59`
`58`	`60`	`Assert.AreEqual(-1, runSimpleStringReturnValue);`
`59`	`61`	`}`