v0

Author: zhengyu123

ddprof-lib/src/main/cpp/javaApi.cpp

@@ -133,15 +133,11 @@ Java_com_datadoghq_profiler_JavaProfiler_getSamples(JNIEnv *env,
 // We direct corresponding JNI calls to JavaCritical to make sure the parameters/return value
 // still compatible in the event of signature changes in the future.
 extern "C" DLLEXPORT void JNICALL
-JavaCritical_com_datadoghq_profiler_JavaProfiler_filterThreadAdd0() {
+JavaCritical_com_datadoghq_profiler_JavaProfiler_filterThreadAdd0(jlong java_tid) {
   ProfiledThread *current = ProfiledThread::current();
   if (unlikely(current == nullptr)) {
     return;
   }
-  int tid = current->tid();
-  if (unlikely(tid < 0)) {
-    return;
-  }
   ThreadFilter *thread_filter = Profiler::instance()->threadFilter();
   if (unlikely(!thread_filter->enabled())) {
     return;
@@ -158,7 +154,7 @@ JavaCritical_com_datadoghq_profiler_JavaProfiler_filterThreadAdd0() {
   if (unlikely(slot_id == -1)) {
     return;  // Failed to register thread
   }
-  thread_filter->add(tid, slot_id);
+  thread_filter->add(java_tid, slot_id);
 }
 
 extern "C" DLLEXPORT void JNICALL
@@ -167,10 +163,6 @@ JavaCritical_com_datadoghq_profiler_JavaProfiler_filterThreadRemove0() {
   if (unlikely(current == nullptr)) {
     return;
   }
-  int tid = current->tid();
-  if (unlikely(tid < 0)) {
-    return;
-  }
   ThreadFilter *thread_filter = Profiler::instance()->threadFilter();
   if (unlikely(!thread_filter->enabled())) {
     return;
@@ -187,8 +179,9 @@ JavaCritical_com_datadoghq_profiler_JavaProfiler_filterThreadRemove0() {
 
 extern "C" DLLEXPORT void JNICALL
 Java_com_datadoghq_profiler_JavaProfiler_filterThreadAdd0(JNIEnv *env,
-                                                          jclass unused) {
-  JavaCritical_com_datadoghq_profiler_JavaProfiler_filterThreadAdd0();
+                                                          jclass unused,
+                                                          jlong java_tid) {
+  JavaCritical_com_datadoghq_profiler_JavaProfiler_filterThreadAdd0(java_tid);
 }
 
 extern "C" DLLEXPORT void JNICALL

ddprof-lib/src/main/cpp/threadFilter.cpp

@@ -163,7 +163,7 @@ bool ThreadFilter::accept(SlotID slot_id) const {
     return false;
 }
 
-void ThreadFilter::add(int tid, SlotID slot_id) {
+void ThreadFilter::add(long tid, SlotID slot_id) {
     // PRECONDITION: slot_id must be from registerThread() or negative
     // Undefined behavior for invalid positive slot_ids (performance optimization)
     if (slot_id < 0) return;

ddprof-lib/src/main/cpp/threadFilter.h

@@ -45,7 +45,7 @@ class ThreadFilter {
     bool enabled() const;
     // Hot path methods - slot_id MUST be from registerThread(), undefined behavior otherwise
     bool accept(SlotID slot_id) const;
-    void add(int tid, SlotID slot_id);
+    void add(long tid, SlotID slot_id);
     void remove(SlotID slot_id);
     void collect(std::vector<int>& tids) const;
 
@@ -55,7 +55,7 @@ class ThreadFilter {
 private:
     // Optimized slot structure with padding to avoid false sharing
     struct alignas(DEFAULT_CACHE_LINE_SIZE) Slot {
-        std::atomic<int> value{-1};
+        std::atomic<long> value{-1};
         char padding[DEFAULT_CACHE_LINE_SIZE - sizeof(value)];  // Pad to cache line size
     };
     static_assert(sizeof(Slot) == DEFAULT_CACHE_LINE_SIZE, "Slot must be exactly one cache line");

ddprof-lib/src/main/cpp/threadState.cpp

@@ -0,0 +1,104 @@
+/*
+ * Copyright 2026 Datadog, Inc
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <cassert>
+#include "threadState.inline.h"
+#include "vmStructs.h"
+
+ThreadStateResolver* ThreadStateResolver::INSTANCE = nullptr;
+
+void ThreadStateResolver::initialize() {
+    if (VM::isHotspot()) {
+        INSTANCE = new VMStructsThreadStateResolver();
+    } else {
+        INSTANCE = new JNIThreadStateResolver();
+    }
+}
+
+VMStructsThreadStateResolver::VMStructsThreadStateResolver() {
+    assert(VM::isHotspot());
+}
+
+OSThreadState VMStructsThreadStateResolver::resolveThreadState(jthread thread) {
+    JNIEnv* jni = VM::jni();
+    VMThread* vm_thread = VMThread::fromJavaThread(jni, thread);
+    // Thread no longer reachable
+    if (vm_thread == nullptr) {
+        return  OSThreadState::TERMINATED;
+    }
+
+    int raw_thread_state = vm_thread->state();
+    bool is_initialized = raw_thread_state >= JVMJavaThreadState::_thread_in_native &&
+                          raw_thread_state < JVMJavaThreadState::_thread_max_state;
+    if (!is_initialized) {
+        return OSThreadState::UNKNOWN;
+    }
+
+    OSThreadState state = OSThreadState::UNKNOWN;
+    OSThreadState os_state = vm_thread->osThreadState();
+    if (os_state == OSThreadState::UNKNOWN) {
+      state = OSThreadState::RUNNABLE;
+    } else {
+      state = os_state;
+    }
+    return state;
+}
+
+ExecutionMode VMStructsThreadStateResolver::resolveThreadExecutionMode(jthread thread) {
+    JNIEnv* jni = VM::jni();
+    VMThread* vm_thread = VMThread::fromJavaThread(jni, thread);
+    return getThreadExecutionMode(vm_thread);
+}
+
+
+JNIThreadStateResolver::JNIThreadStateResolver() {
+    assert(VM::isOpenJ9() || VM::isZing());
+
+    JNIEnv* jni = VM::jni();
+    jclass thread_class = jni->FindClass("java/lang/Thread");
+    jclass thread_state_class = jni->FindClass("java/lang/Thread$State");
+    assert(thread_class != nullptr);
+    assert(thread_state_class != nullptr);
+
+    _thread_get_state_id = jni->GetMethodID(thread_class, "getState", "()Ljava/lang/Thread$State;");
+    assert(_thread_get_state_id != nullptr);
+    _state_ordinal_id = jni->GetMethodID(thread_state_class, "ordinal", "()I");
+    assert(_state_ordinal_id != nullptr);
+}
+
+OSThreadState JNIThreadStateResolver::resolveThreadState(jthread thread) {
+    JNIEnv* jni = VM::jni();
+    jobject state = jni->CallObjectMethod(thread, _thread_get_state_id);
+    int ordinal = jni->CallIntMethod(state, _state_ordinal_id);
+    return ordinal2ThreadState(ordinal);
+}
+
+ExecutionMode JNIThreadStateResolver::resolveThreadExecutionMode(jthread thread) {
+    return ExecutionMode::JAVA;
+}
+
+OSThreadState JNIThreadStateResolver::ordinal2ThreadState(int ordinal) {
+    switch(ordinal) {
+        case 0: return OSThreadState::NEW;
+        case 1: return OSThreadState::RUNNABLE;
+        case 2: return OSThreadState::MONITOR_WAIT;
+        case 3:
+        case 4: return OSThreadState::OBJECT_WAIT;
+        case 5: return OSThreadState::TERMINATED;
+        default: assert(false);
+    }
+    return OSThreadState::UNKNOWN;
+}

ddprof-lib/src/main/cpp/threadState.h

@@ -66,8 +66,46 @@ static ExecutionMode convertJvmExecutionState(int state) {
  *         ExecutionMode::JVM for JVM internal threads,
  *         or the appropriate execution mode for Java threads
  */
- class VMThread;
+class VMThread;
 
 inline ExecutionMode getThreadExecutionMode();
+inline ExecutionMode getThreadExecutionMode(VMThread* thread);
+
+// The helper classes to resolve thread state.
+class ThreadStateResolver {
+private:
+    static ThreadStateResolver* INSTANCE;
+
+public:
+    // Must be called at initialization phase, in single-threaded mode,
+    // after resolving JVM type
+    static void initialize();
+
+    static ThreadStateResolver* getInstance() { return INSTANCE; }
+
+    virtual OSThreadState resolveThreadState(jthread thread) = 0;
+    virtual ExecutionMode resolveThreadExecutionMode(jthread thread) = 0;
+};
+
+// Hotspot JVM uses VMStructs to resolve thread state and execution mode
+class VMStructsThreadStateResolver : public ThreadStateResolver {
+public:
+    VMStructsThreadStateResolver();
+    OSThreadState resolveThreadState(jthread thread);
+    ExecutionMode resolveThreadExecutionMode(jthread thread);
+};
+
+// J9 and Zing use JNI to resolve thread state and execution mode
+class JNIThreadStateResolver : public ThreadStateResolver {
+private:
+    jmethodID   _thread_get_state_id;
+    jmethodID   _state_ordinal_id;
+public:
+    JNIThreadStateResolver();
+    OSThreadState resolveThreadState(jthread thread);
+    ExecutionMode resolveThreadExecutionMode(jthread thread);
+private:
+    static OSThreadState ordinal2ThreadState(int ordinal);
+};
 
 #endif // JAVA_PROFILER_LIBRARY_THREAD_STATE_H

ddprof-lib/src/main/cpp/threadState.inline.h

@@ -7,14 +7,15 @@
 #include "thread.h"
 #include <stdio.h>
 
-inline ExecutionMode getThreadExecutionMode() {
-  VMThread* vm_thread = VMThread::current();
+inline ExecutionMode getThreadExecutionMode(VMThread* vm_thread) {
+  // This is hotspot JVM specific implementation
+  assert(VM::isHotspot());
+
   // Not a JVM thread - native thread, e.g. thread launched by JNI code
   if (vm_thread == nullptr) {
     return ExecutionMode::NATIVE;
   }
 
-  
   ProfiledThread *prof_thread = ProfiledThread::currentSignalSafe();
   bool is_java_thread = prof_thread != nullptr && prof_thread->isJavaThread();
 
@@ -29,10 +30,15 @@ inline ExecutionMode getThreadExecutionMode() {
     return is_java_thread ? convertJvmExecutionState(raw_thread_state)
                         : ExecutionMode::JVM;
   } else {
-    // It is a JVM internal thread, may or may not be a Java thread, 
+    // It is a JVM internal thread, may or may not be a Java thread,
     // e.g. Compiler thread or GC thread, etc
     return ExecutionMode::JVM;
   }
 }
 
+inline ExecutionMode getThreadExecutionMode() {
+  VMThread* vm_thread = VMThread::current();
+  return getThreadExecutionMode(vm_thread);
+}
+
 #endif // JAVA_PROFILER_LIBRARY_THREAD_STATE_INLINE_H

ddprof-lib/src/main/cpp/vmEntry.cpp

@@ -15,6 +15,7 @@
 #include "os.h"
 #include "profiler.h"
 #include "safeAccess.h"
+#include "threadState.h"
 #include "vmStructs.h"
 #include <dlfcn.h>
 #include <stdlib.h>
@@ -375,6 +376,9 @@ bool VM::initProfilerBridge(JavaVM *vm, bool attach) {
     return false;
   }
 
+  // Initialize thread state resolver
+  ThreadStateResolver::initialize();
+
   CodeCache *lib = openJvmLibrary();
   if (lib == nullptr) {
     return false;

ddprof-lib/src/main/cpp/wallClock.cpp

@@ -160,6 +160,9 @@ void WallClockASGCT::initialize(Arguments& args) {
  * We have to be extremely careful when accessing thread's data, so it may not be valid.
  */
 void WallClockJVMTI::timerLoop() {
+
+TEST_LOG("VMTI::timerLoop()");
+
     // Check for enablement before attaching/dettaching the current thread
   if (!isEnabled()) {
     return;
@@ -170,6 +173,7 @@ void WallClockJVMTI::timerLoop() {
     return;
   }
 
+
   // Notice:
   // We want to cache threads that are captured by collectThread(), so that we can
   // clean them up in cleanThreadRefs().
@@ -180,6 +184,21 @@ void WallClockJVMTI::timerLoop() {
 
   // Attach to JVM as the first step
   VM::attachThread("Datadog Profiler Wallclock Sampler");
+
+  jthread self;
+  jvmtiError error;
+
+  if ((error = jvmti->GetCurrentThread(&self)) != JVMTI_ERROR_NONE) {
+  TEST_LOG("GetCurrentThread failed, %d", (int)error);
+    return;
+  }
+
+  JNIEnv* jni = VM::jni();
+  jclass thread_class = jni->FindClass("java/lang/Thread");
+  assert(thread_class != nullptr);
+  jmethodID thread_getId = jni->GetMethodID(thread_class, "getId", "()J");
+  assert(thread_getId != nullptr);
+
   auto collectThreads = [&](std::vector<ThreadEntry>& threads) {
       jvmtiEnv* jvmti = VM::jvmti();
       if (jvmti == nullptr) {
@@ -191,11 +210,8 @@ void WallClockJVMTI::timerLoop() {
         return;
       }
 
-      JNIEnv* jni = VM::jni();
-
       ThreadFilter* threadFilter = Profiler::instance()->threadFilter();
       bool do_filter = threadFilter->enabled();
-      int self = OS::threadId();
 
       // If filtering is enabled, collect the filtered TIDs first
       std::vector<int> filtered_tids;
@@ -207,46 +223,30 @@ void WallClockJVMTI::timerLoop() {
 
       for (int i = 0; i < threads_count; i++) {
         jthread thread = threads_ptr[i];
-        if (thread != nullptr) {
-          VMThread* nThread = VMThread::fromJavaThread(jni, thread);
-          if (nThread == nullptr) {
-            continue;
-          }
-          int tid = nThread->osThreadId();
-          if (tid != self && (!do_filter ||
+        if (thread == self) continue;
+        long tid = jni->CallLongMethod(thread, thread_getId);
+
+        if (!do_filter ||
                // Use binary search to efficiently find if tid is in filtered_tids
-               std::binary_search(filtered_tids.begin(), filtered_tids.end(), tid))) {
-            threads.push_back({nThread, thread, tid});
-          }
+               std::binary_search(filtered_tids.begin(), filtered_tids.end(), tid)) {
+            threads.push_back({thread, tid});
         }
       }
     };
 
+  ThreadStateResolver* const resolver = ThreadStateResolver::getInstance();
+
   auto sampleThreads = [&](ThreadEntry& thread_entry, int& num_failures, int& threads_already_exited, int& permission_denied) {
     static jint max_stack_depth = (jint)Profiler::instance()->max_stack_depth();
 
     ExecutionEvent event;
-    VMThread* vm_thread = thread_entry.native;
-    int raw_thread_state = vm_thread->state();
-    bool is_initialized = raw_thread_state >= JVMJavaThreadState::_thread_in_native &&
-                          raw_thread_state < JVMJavaThreadState::_thread_max_state;
-    OSThreadState state = OSThreadState::UNKNOWN;
-    ExecutionMode mode = ExecutionMode::UNKNOWN;
-    if (vm_thread == nullptr || !is_initialized) {
+    jthread thread = thread_entry.java;
+
+    event._thread_state = resolver->resolveThreadState(thread);
+    if (event._thread_state == OSThreadState::TERMINATED) {
         return false;
     }
-    OSThreadState os_state = vm_thread->osThreadState();
-    if (os_state == OSThreadState::TERMINATED) {
-      return false;
-    } else if (os_state == OSThreadState::UNKNOWN) {
-      state = OSThreadState::RUNNABLE;
-    } else {
-      state = os_state;
-    }
-    mode = getThreadExecutionMode();
-
-    event._thread_state = state;
-    event._execution_mode = mode;
+    event._execution_mode = resolver->resolveThreadExecutionMode(thread);
     event._weight =  1;
 
     Profiler::instance()->recordJVMTISample(1, thread_entry.tid, thread_entry.java, BCI_WALL, &event, false);