pf2 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 929c0f24675525d7d52bd0293ec45b9383579517119baac5b28da2bfe720d7d5
-  data.tar.gz: e75df94cf2085aea9d218b431e44ccda5f87e537a1c566ea67ae4ef04a03cb8a
+  metadata.gz: d576aec57e600cc77194fabb8c1b7b3c782c4ab76a03ec3b0f24581eb4c317ae
+  data.tar.gz: a290d23df802601977622f1afe39f1f2d6cd92a9350b25d203e97c3b6da6db16
 SHA512:
-  metadata.gz: 2e28b5f4cbb99dc101b7f9a9092b1602d682f1001fa1c86a538d0d966a4c670df5fc5ecb971d8a25e093c3c3bdbe115b772ed40be50b8027cbc09fe6664c1db5
-  data.tar.gz: cf63fc413c60dda6fc0a360d39701cffc36aceeb98dc5d1d92a6e42761fa2ba1d2381e67a9a4af10fcb51fbf6e4b32afc89ff9307370fa542db278c6e76d40ae
+  metadata.gz: a8d72fa4ccb3395f0fdd9203885c1e0cb8a00429597a6dd756e80fb70e0d8092c084992bd9595ee21789a4aaf2550e2284b6d3f81b448dc330088b325d822d85
+  data.tar.gz: 8f93c98574ef7077336232bb1b51a4af1ac4ba2561914a299209a5c2879fe9af3e8998c8df264836f698fea05c8d028f7ae985de3c18e9889f05568ec2740bc1

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 ## [Unreleased]
 
+### Added
+
+- New option: `track_all_threads`
+  - When true, all Threads will be tracked regardless of the `threads` option.
+
+### Removed
+
+- The `track_new_threads` option was removed in favor of the `track_all_threads` option.
+
 
 ## [0.3.0] - 2024-02-05
 

data/README.md

@@ -8,6 +8,7 @@ Notable Capabilites
 
 - Can accurately track multiple Ruby Threads' activity
 - Sampling interval can be set based on per-Thread CPU usage
+- Can record native (C-level) stack traces side-by-side with Ruby traces
 
 Usage
 --------
@@ -57,7 +58,7 @@ Pf2.start(
   threads: [],            # Array<Thread>: A list of Ruby Threads to be tracked (default: `Thread.list`)
   time_mode: :cpu,        # `:cpu` or `:wall`: The sampling timer's mode
                           # (default: `:cpu` for SignalScheduler, `:wall` for TimerThreadScheduler)
-  track_new_threads: true # Boolean: Whether to automatically track Threads spawned after profiler start
+  track_all_threads: true # Boolean: Whether to track all Threads regardless of `threads` option
                           # (default: false)
 )
 ```

data/ext/pf2/src/backtrace.rs

@@ -42,6 +42,7 @@ impl Backtrace {
         }
     }
 
+    #[allow(dead_code)] // TODO: Remove this
     pub fn backtrace_pcinfo<F>(
         state: &BacktraceState,
         pc: usize,

data/ext/pf2/src/lib.rs

@@ -13,3 +13,5 @@ mod sample;
 mod signal_scheduler;
 mod timer_thread_scheduler;
 mod util;
+
+mod ruby_internal_apis;

data/ext/pf2/src/ruby_internal_apis.rs

@@ -0,0 +1,47 @@
+#![allow(non_snake_case)]
+#![allow(non_camel_case_types)]
+
+use libc::{clockid_t, pthread_getcpuclockid, pthread_t};
+use rb_sys::{rb_check_typeddata, rb_data_type_struct, RTypedData, VALUE};
+use std::ffi::{c_char, c_int};
+use std::mem::MaybeUninit;
+
+// Types and structs from Ruby 3.4.0.
+
+type rb_nativethread_id_t = libc::pthread_t;
+
+#[repr(C)]
+struct rb_native_thread {
+    _padding_serial: [c_char; 4], // rb_atomic_t
+    _padding_vm: *mut c_int,      // struct rb_vm_struct
+    thread_id: rb_nativethread_id_t,
+    // ...
+}
+
+#[repr(C)]
+struct rb_thread_struct {
+    _padding_lt_node: [c_char; 16], // struct ccan_list_node
+    _padding_self: VALUE,
+    _padding_ractor: *mut c_int, // rb_ractor_t
+    _padding_vm: *mut c_int,     // rb_vm_t
+    nt: *mut rb_native_thread,
+    // ...
+}
+type rb_thread_t = rb_thread_struct;
+
+/// Reimplementation of the internal RTYPEDDATA_TYPE macro.
+unsafe fn RTYPEDDATA_TYPE(obj: VALUE) -> *const rb_data_type_struct {
+    let typed: *mut RTypedData = obj as *mut RTypedData;
+    (*typed).type_
+}
+
+unsafe fn rb_thread_ptr(thread: VALUE) -> *mut rb_thread_t {
+    unsafe { rb_check_typeddata(thread, RTYPEDDATA_TYPE(thread)) as *mut rb_thread_t }
+}
+
+pub unsafe fn rb_thread_getcpuclockid(thread: VALUE) -> clockid_t {
+    let mut cid: clockid_t = MaybeUninit::zeroed().assume_init();
+    let pthread_id: pthread_t = (*(*rb_thread_ptr(thread)).nt).thread_id;
+    pthread_getcpuclockid(pthread_id, &mut cid as *mut clockid_t);
+    cid
+}

data/ext/pf2/src/signal_scheduler/configuration.rs

@@ -9,7 +9,7 @@ pub struct Configuration {
     pub interval: Duration,
     pub time_mode: TimeMode,
     pub target_ruby_threads: HashSet<VALUE>,
-    pub track_new_threads: bool,
+    pub track_all_threads: bool,
 }
 
 #[derive(Clone, Debug)]

data/ext/pf2/src/signal_scheduler/timer_installer.rs

@@ -1,31 +1,28 @@
-use std::collections::HashMap;
+use std::collections::HashSet;
 use std::ffi::c_void;
 use std::mem;
 use std::mem::ManuallyDrop;
 use std::ptr::null_mut;
+use std::sync::Arc;
 use std::sync::{Mutex, RwLock};
-use std::{collections::HashSet, sync::Arc};
 
 use rb_sys::*;
 
-use crate::signal_scheduler::SignalHandlerArgs;
-
 use super::configuration::Configuration;
 use crate::profile::Profile;
+use crate::ruby_internal_apis::rb_thread_getcpuclockid;
+use crate::signal_scheduler::{cstr, SignalHandlerArgs};
 
-// We could avoid deferring the timer creation by combining pthread_getcpuclockid(3) and timer_create(2) here,
-// but we're not doing so since (1) Ruby does not expose the pthread_self() of a Ruby Thread
-// (which is actually stored in th->nt->thread_id), and (2) pthread_getcpuclockid(3) is not portable
-// in the first place (e.g. not available on macOS).
+#[derive(Debug)]
 pub struct TimerInstaller {
-    internal: Box<Mutex<Internal>>,
+    inner: Box<Mutex<Inner>>,
 }
 
-struct Internal {
+#[derive(Debug)]
+struct Inner {
     configuration: Configuration,
-    registered_pthread_ids: HashSet<libc::pthread_t>,
-    kernel_thread_id_to_ruby_thread_map: HashMap<libc::pid_t, VALUE>,
-    profile: Arc<RwLock<Profile>>,
+    pub profile: Arc<RwLock<Profile>>,
+    known_threads: HashSet<VALUE>,
 }
 
 impl TimerInstaller {
@@ -35,153 +32,102 @@ impl TimerInstaller {
         configuration: Configuration,
         profile: Arc<RwLock<Profile>>,
     ) {
-        let registrar = Self {
-            internal: Box::new(Mutex::new(Internal {
+        let installer = Self {
+            inner: Box::new(Mutex::new(Inner {
                 configuration: configuration.clone(),
-                registered_pthread_ids: HashSet::new(),
-                kernel_thread_id_to_ruby_thread_map: HashMap::new(),
                 profile,
+                known_threads: HashSet::new(),
             })),
         };
 
-        let ptr = Box::into_raw(registrar.internal);
-        unsafe {
-            rb_internal_thread_add_event_hook(
-                Some(Self::on_thread_resume),
-                RUBY_INTERNAL_THREAD_EVENT_RESUMED,
-                ptr as *mut c_void,
-            );
-            // Spawn a no-op Thread to fire the event hook
-            // (at least 2 Ruby Threads must be active for the RESUMED hook to be fired)
-            rb_thread_create(Some(Self::do_nothing), null_mut());
-        };
+        if let Ok(mut inner) = installer.inner.try_lock() {
+            for ruby_thread in configuration.target_ruby_threads.iter() {
+                let ruby_thread: VALUE = *ruby_thread;
+                inner.known_threads.insert(ruby_thread);
+                inner.register_timer_to_ruby_thread(ruby_thread);
+            }
+        }
 
-        if configuration.track_new_threads {
+        if configuration.track_all_threads {
+            let ptr = Box::into_raw(installer.inner);
             unsafe {
+                // TODO: Clean up this hook when the profiling session ends
                 rb_internal_thread_add_event_hook(
-                    Some(Self::on_thread_start),
-                    RUBY_INTERNAL_THREAD_EVENT_STARTED,
+                    Some(Self::on_thread_resume),
+                    RUBY_INTERNAL_THREAD_EVENT_RESUMED,
                     ptr as *mut c_void,
                 );
             };
         }
     }
 
-    unsafe extern "C" fn do_nothing(_: *mut c_void) -> VALUE {
-        Qnil.into()
-    }
-
-    // Thread resume callback
+    // Thread start callback
     unsafe extern "C" fn on_thread_resume(
         _flag: rb_event_flag_t,
         data: *const rb_internal_thread_event_data,
         custom_data: *mut c_void,
     ) {
-        // The SignalScheduler (as a Ruby obj) should be passed as custom_data
-        let internal =
-            unsafe { ManuallyDrop::new(Box::from_raw(custom_data as *mut Mutex<Internal>)) };
-        let mut internal = internal.lock().unwrap();
-
-        // Check if the current thread is a target Ruby Thread
-        let current_ruby_thread: VALUE = unsafe { (*data).thread };
-        if !internal
-            .configuration
-            .target_ruby_threads
-            .contains(&current_ruby_thread)
-        {
-            return;
-        }
+        let ruby_thread: VALUE = unsafe { (*data).thread };
 
-        // Check if the current thread is already registered
-        let current_pthread_id = unsafe { libc::pthread_self() };
-        if internal
-            .registered_pthread_ids
-            .contains(&current_pthread_id)
-        {
-            return;
-        }
-
-        // Record the pthread ID of the current thread
-        internal.registered_pthread_ids.insert(current_pthread_id);
-        // Keep a mapping from kernel thread ID to Ruby Thread
-        internal
-            .kernel_thread_id_to_ruby_thread_map
-            .insert(unsafe { libc::gettid() }, current_ruby_thread);
-
-        Self::register_timer_to_current_thread(
-            &internal.configuration,
-            &internal.profile,
-            &internal.kernel_thread_id_to_ruby_thread_map,
-        );
-
-        // TODO: Remove the hook when all threads have been registered
-    }
+        // A pointer to Box<Inner> is passed as custom_data
+        let inner = unsafe { ManuallyDrop::new(Box::from_raw(custom_data as *mut Mutex<Inner>)) };
+        let mut inner = inner.lock().unwrap();
 
-    // Thread resume callback
-    unsafe extern "C" fn on_thread_start(
-        _flag: rb_event_flag_t,
-        data: *const rb_internal_thread_event_data,
-        custom_data: *mut c_void,
-    ) {
-        // The SignalScheduler (as a Ruby obj) should be passed as custom_data
-        let internal =
-            unsafe { ManuallyDrop::new(Box::from_raw(custom_data as *mut Mutex<Internal>)) };
-        let mut internal = internal.lock().unwrap();
-
-        let current_ruby_thread: VALUE = unsafe { (*data).thread };
-        internal
-            .configuration
-            .target_ruby_threads
-            .insert(current_ruby_thread);
+        if !inner.known_threads.contains(&ruby_thread) {
+            inner.known_threads.insert(ruby_thread);
+            // Install a timer for the thread
+            inner.register_timer_to_ruby_thread(ruby_thread);
+        }
     }
+}
 
-    // Creates a new POSIX timer which invocates sampling for the thread that called this function.
-    fn register_timer_to_current_thread(
-        configuration: &Configuration,
-        profile: &Arc<RwLock<Profile>>,
-        kernel_thread_id_to_ruby_thread_map: &HashMap<libc::pid_t, VALUE>,
-    ) {
-        let current_pthread_id = unsafe { libc::pthread_self() };
-        let context_ruby_thread: VALUE = unsafe {
-            *(kernel_thread_id_to_ruby_thread_map
-                .get(&(libc::gettid()))
-                .unwrap())
-        };
-
+impl Inner {
+    fn register_timer_to_ruby_thread(&self, ruby_thread: VALUE) {
         // NOTE: This Box is never dropped
         let signal_handler_args = Box::new(SignalHandlerArgs {
-            profile: Arc::clone(profile),
-            context_ruby_thread,
+            profile: Arc::clone(&self.profile),
+            context_ruby_thread: ruby_thread,
         });
 
+        // rb_funcall deadlocks when called within a THREAD_EVENT_STARTED hook
+        let kernel_thread_id: i32 = i32::try_from(unsafe {
+            rb_num2int(rb_funcall(
+                ruby_thread,
+                rb_intern(cstr!("native_thread_id")), // kernel thread ID
+                0,
+            ))
+        })
+        .unwrap();
+
         // Create a signal event
         let mut sigevent: libc::sigevent = unsafe { mem::zeroed() };
         // Note: SIGEV_THREAD_ID is Linux-specific. In other platforms, we would need to
-        // "tranpoline" the signal as any pthread can receive the signal.
+        // "trampoline" the signal as any pthread can receive the signal.
         sigevent.sigev_notify = libc::SIGEV_THREAD_ID;
-        sigevent.sigev_notify_thread_id =
-            unsafe { libc::syscall(libc::SYS_gettid).try_into().unwrap() }; // The kernel thread ID
+        sigevent.sigev_notify_thread_id = kernel_thread_id;
         sigevent.sigev_signo = libc::SIGALRM;
         // Pass required args to the signal handler
         sigevent.sigev_value.sival_ptr = Box::into_raw(signal_handler_args) as *mut c_void;
 
         // Create and configure timer to fire every _interval_ ms of CPU time
         let mut timer: libc::timer_t = unsafe { mem::zeroed() };
-        let clockid = match configuration.time_mode {
-            crate::signal_scheduler::TimeMode::CpuTime => libc::CLOCK_THREAD_CPUTIME_ID,
+        let clockid = match self.configuration.time_mode {
+            crate::signal_scheduler::TimeMode::CpuTime => unsafe {
+                rb_thread_getcpuclockid(ruby_thread)
+            },
             crate::signal_scheduler::TimeMode::WallTime => libc::CLOCK_MONOTONIC,
         };
         let err = unsafe { libc::timer_create(clockid, &mut sigevent, &mut timer) };
         if err != 0 {
             panic!("timer_create failed: {}", err);
         }
-        let itimerspec = Self::duration_to_itimerspec(&configuration.interval);
+        let itimerspec = Self::duration_to_itimerspec(&self.configuration.interval);
         let err = unsafe { libc::timer_settime(timer, 0, &itimerspec, null_mut()) };
         if err != 0 {
             panic!("timer_settime failed: {}", err);
         }
 
-        log::debug!("timer registered for thread {}", current_pthread_id);
+        log::debug!("timer registered for thread {}", ruby_thread);
     }
 
     fn duration_to_itimerspec(duration: &std::time::Duration) -> libc::itimerspec {

data/ext/pf2/src/signal_scheduler.rs

@@ -56,7 +56,7 @@ impl SignalScheduler {
                     rb_intern(cstr!("interval_ms")),
                     rb_intern(cstr!("threads")),
                     rb_intern(cstr!("time_mode")),
-                    rb_intern(cstr!("track_new_threads")),
+                    rb_intern(cstr!("track_all_threads")),
                 ]
                 .as_mut_ptr(),
                 0,
@@ -99,7 +99,7 @@ impl SignalScheduler {
         } else {
             configuration::TimeMode::CpuTime
         };
-        let track_new_threads: bool = if kwargs_values[3] != Qundef as VALUE {
+        let track_all_threads: bool = if kwargs_values[3] != Qundef as VALUE {
             RTEST(kwargs_values[3])
         } else {
             false
@@ -117,7 +117,7 @@ impl SignalScheduler {
             interval,
             target_ruby_threads,
             time_mode,
-            track_new_threads,
+            track_all_threads,
         });
 
         Qnil.into()

data/lib/pf2/version.rb

@@ -1,3 +1,3 @@
 module Pf2
-  VERSION = '0.3.0'
+  VERSION = '0.4.0'
 end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: pf2
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Daisuke Aritomo
-autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-02-05 00:00:00.000000000 Z
+date: 2024-03-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
@@ -52,7 +51,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description:
 email:
 - osyoyu@osyoyu.com
 executables:
@@ -156,6 +154,7 @@ files:
 - ext/pf2/src/profile_serializer.rs
 - ext/pf2/src/ringbuffer.rs
 - ext/pf2/src/ruby_init.rs
+- ext/pf2/src/ruby_internal_apis.rs
 - ext/pf2/src/sample.rs
 - ext/pf2/src/siginfo_t.c
 - ext/pf2/src/signal_scheduler.rs
@@ -175,7 +174,6 @@ metadata:
   homepage_uri: https://github.com/osyoyu/pf2
   source_code_uri: https://github.com/osyoyu/pf2
   changelog_uri: https://github.com/osyoyu/pf2/blob/master/CHANGELOG.md
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -191,7 +189,6 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubygems_version: 3.6.0.dev
-signing_key:
 specification_version: 4
 summary: Yet another Ruby profiler
 test_files: []