[GR-40333] Adding Thread#native_thread_id method

PullRequest: truffleruby/3648

Author: horakivo

CHANGELOG.md

@@ -78,6 +78,7 @@ Compatibility:
 * `Module` methods `#private`, `#public`, `#protected`, `#module_function` now returns their arguments like in CRuby 3.1 (#2733, @horakivo)
 * `Kernel#exit!`, killing Fibers and internal errors do not run code in `ensure` clauses anymore, the same as CRuby (@eregon).
 * Implement `UnboundMethod#original_name` (@paracycle, @nirvdrum).
+* Implement `Thread#native_thread_id` method (#2733, @horakivo).
 
 Performance:
 

mx.truffleruby/mx_truffleruby.py

@@ -114,7 +114,6 @@ def contents(self, result):
         ruby_options = [
             '--experimental-options',
             '--building-core-cexts',
-            '--platform-native-interrupt=false', # no librubysignal in the ruby home yet
             '--launcher=' + result,
             '--disable-gems',
             '--disable-rubyopt',

spec/ruby/core/thread/native_thread_id_spec.rb

@@ -1,17 +1,30 @@
 require_relative '../../spec_helper'
 
-if ruby_version_is "3.1" and Thread.method_defined?(:native_thread_id)
-  # This method is very platform specific
+ruby_version_is "3.1" do
+  platform_is :linux, :darwin, :windows, :freebsd do
+    describe "Thread#native_thread_id" do
+      it "returns an integer when the thread is alive" do
+        Thread.current.native_thread_id.should be_kind_of(Integer)
+      end
 
-  describe "Thread#native_thread_id" do
-    it "returns an integer when the thread is alive" do
-      Thread.current.native_thread_id.should be_kind_of(Integer)
-    end
+      it "returns nil when the thread is not running" do
+        t = Thread.new {}
+        t.join
+        t.native_thread_id.should == nil
+      end
+
+      it "each thread has different native thread id" do
+        t = Thread.new { sleep }
+        Thread.pass until t.stop?
+        main_thread_id = Thread.current.native_thread_id
+        t_thread_id = t.native_thread_id
 
-    it "returns nil when the thread is not running" do
-      t = Thread.new {}
-      t.join
-      t.native_thread_id.should == nil
+        t_thread_id.should be_kind_of(Integer)
+        main_thread_id.should_not == t_thread_id
+        t.run
+        t.join
+        t.native_thread_id.should == nil
+      end
     end
   end
 end

spec/tags/core/thread/native_thread_id_tags.txt

@@ -10,6 +10,8 @@
 #include "org_truffleruby_signal_LibRubySignal.h"
 #include <pthread.h>
 #include <signal.h>
+#include <unistd.h>
+#include <sys/syscall.h>
 
 _Static_assert(sizeof(pthread_t) == sizeof(jlong), "Expected sizeof(pthread_t) == sizeof(jlong)");
 
@@ -33,3 +35,13 @@ JNIEXPORT jint JNICALL Java_org_truffleruby_signal_LibRubySignal_sendSIGVTALRMTo
   pthread_t pthread_id = (pthread_t) threadID;
   return pthread_kill(pthread_id, SIGVTALRM);
 }
+
+JNIEXPORT jlong JNICALL Java_org_truffleruby_signal_LibRubySignal_getNativeThreadID(JNIEnv *env, jclass clazz) {
+  #ifdef __APPLE__
+      uint64_t native_id;
+      pthread_threadid_np(NULL, &native_id);
+  #elif defined(__linux__)
+      pid_t native_id = (pid_t) syscall(SYS_gettid);
+  #endif
+      return (jlong) native_id;
+}

src/main/c/rubysignal/src/rubysignal.c

@@ -59,6 +59,8 @@ public final class RubyThread extends RubyDynamicObject implements ObjectGraphNo
     boolean reportOnException;
     boolean abortOnException;
     public volatile Thread thread = null;
+    /** Either nil or long */
+    public volatile Object nativeThreadId = Nil.INSTANCE;
     volatile RubyException exception = null;
     volatile Object value = null;
     public final AtomicBoolean wakeUp = new AtomicBoolean(false);

src/main/java/org/truffleruby/core/thread/RubyThread.java

@@ -85,6 +85,7 @@ public class ThreadManager {
     private final ConcurrentWeakSet<Thread> rubyManagedThreads = new ConcurrentWeakSet<>();
 
     private boolean nativeInterrupt;
+    private boolean useLibRubySignal;
     private Timer nativeInterruptTimer;
     private ThreadLocal<Interrupter> nativeCallInterrupter;
 
@@ -95,9 +96,13 @@ public ThreadManager(RubyContext context, RubyLanguage language) {
     }
 
     public void initialize() {
-        nativeInterrupt = context.getOptions().NATIVE_INTERRUPT && language.getRubyHome() != null;
-        if (nativeInterrupt) {
+        useLibRubySignal = context.getOptions().NATIVE_PLATFORM && !context.getOptions().BUILDING_CORE_CEXTS &&
+                language.getRubyHome() != null;
+        nativeInterrupt = context.getOptions().NATIVE_INTERRUPT && useLibRubySignal;
+        if (useLibRubySignal) {
             LibRubySignal.loadLibrary(language.getRubyHome());
+        }
+        if (nativeInterrupt) {
             LibRubySignal.setupSIGVTALRMEmptySignalHandler();
 
             nativeInterruptTimer = new Timer("Ruby-NativeCallInterrupt-Timer", true);
@@ -407,6 +412,11 @@ public void startForeignThread(RubyThread rubyThread, Thread javaThread) {
     }
 
     public void start(RubyThread thread, Thread javaThread) {
+        final var isSameThread = javaThread == Thread.currentThread();
+        if (isSameThread && useLibRubySignal) {
+            thread.nativeThreadId = LibRubySignal.getNativeThreadID();
+        }
+
         thread.thread = javaThread;
         thread.ioBuffer = context.getOptions().NATIVE_PLATFORM ? Pointer.getNullBuffer(context) : null;
         registerThread(thread);
@@ -424,6 +434,7 @@ public void cleanup(RubyThread thread, Thread javaThread) {
 
     /** We cannot call this from {@link RubyLanguage#disposeThread} because that's called under a context lock. */
     private void cleanupKillOtherFibers(RubyThread thread) {
+        thread.nativeThreadId = Nil.INSTANCE;
         thread.status = ThreadStatus.DEAD;
         context.fiberManager.killOtherFibers(thread);
     }

src/main/java/org/truffleruby/core/thread/ThreadManager.java

@@ -580,6 +580,15 @@ protected Object status(RubyThread self) {
 
     }
 
+    @CoreMethod(names = "native_thread_id")
+    public abstract static class NativeThreadIdNode extends CoreMethodArrayArgumentsNode {
+
+        @Specialization
+        protected Object nativeThreadId(RubyThread self) {
+            return self.nativeThreadId;
+        }
+    }
+
     @CoreMethod(names = "stop?")
     public abstract static class StopNode extends CoreMethodArrayArgumentsNode {
 

src/main/java/org/truffleruby/core/thread/ThreadNodes.java

@@ -24,4 +24,6 @@ public static void loadLibrary(String rubyHome) {
 
     public static native int sendSIGVTALRMToThread(long thread);
 
+    public static native long getNativeThreadID();
+
 }