pf2 0.2.0 → 0.3.0

data/ext/pf2/src/profile.rs

@@ -1,8 +1,11 @@
-use std::collections::HashSet;
 use std::time::Instant;
+use std::{collections::HashSet, ptr::null_mut};
 
 use rb_sys::*;
 
+use backtrace_sys2::backtrace_create_state;
+
+use super::backtrace::{Backtrace, BacktraceState};
 use super::ringbuffer::Ringbuffer;
 use super::sample::Sample;
 
@@ -15,15 +18,27 @@ pub struct Profile {
     pub start_timestamp: Instant,
     pub samples: Vec<Sample>,
     pub temporary_sample_buffer: Ringbuffer,
+    pub backtrace_state: BacktraceState,
     known_values: HashSet<VALUE>,
 }
 
 impl Profile {
     pub fn new() -> Self {
+        let backtrace_state = unsafe {
+            let ptr = backtrace_create_state(
+                null_mut(),
+                1,
+                Some(Backtrace::backtrace_error_callback),
+                null_mut(),
+            );
+            BacktraceState::new(ptr)
+        };
+
         Self {
             start_timestamp: Instant::now(),
             samples: vec![],
             temporary_sample_buffer: Ringbuffer::new(DEFAULT_RINGBUFFER_CAPACITY),
+            backtrace_state,
             known_values: HashSet::new(),
         }
     }

data/ext/pf2/src/profile_serializer.rs

@@ -1,7 +1,10 @@
-use std::{collections::HashMap, ffi::CStr};
+use std::collections::HashMap;
+use std::ffi::{c_char, CStr};
+use std::hash::Hasher;
 
 use rb_sys::*;
 
+use crate::backtrace::Backtrace;
 use crate::profile::Profile;
 
 #[derive(Debug, Deserialize, Serialize)]
@@ -56,9 +59,17 @@ struct StackTreeNode {
 
 #[derive(Debug, Deserialize, Serialize)]
 struct FrameTableEntry {
+    id: FrameTableId,
+    entry_type: FrameTableEntryType,
     full_label: String,
 }
 
+#[derive(Debug, Deserialize, Serialize)]
+enum FrameTableEntryType {
+    Ruby,
+    Native,
+}
+
 // Represents leaf (末端)
 #[derive(Debug, Deserialize, Serialize)]
 struct ProfileSample {
@@ -77,6 +88,73 @@ impl ProfileSerializer {
         unsafe {
             // Process each sample
             for sample in profile.samples.iter() {
+                let mut merged_stack: Vec<FrameTableEntry> = vec![];
+
+                // Process C-level stack
+
+                // A vec to keep the "programmer's" C stack trace.
+                // A single PC may be mapped to multiple inlined frames,
+                // so we keep the expanded stack frame in this Vec.
+                let mut c_stack: Vec<String> = vec![];
+                for i in 0..sample.c_backtrace_pcs[0] {
+                    let pc = sample.c_backtrace_pcs[i + 1];
+                    Backtrace::backtrace_syminfo(
+                        &profile.backtrace_state,
+                        pc,
+                        |_pc: usize, symname: *const c_char, _symval: usize, _symsize: usize| {
+                            if symname.is_null() {
+                                c_stack.push("(no symbol information)".to_owned());
+                            } else {
+                                c_stack.push(CStr::from_ptr(symname).to_str().unwrap().to_owned());
+                            }
+                        },
+                        Some(Backtrace::backtrace_error_callback),
+                    );
+                }
+
+                // Strip the C stack trace:
+                // - Remove Pf2-related frames which are always captured
+                // - Remove frames below rb_vm_exec
+                let mut reached_ruby = false;
+                c_stack.retain(|frame| {
+                    if reached_ruby {
+                        return false;
+                    }
+                    if frame.contains("pf2") {
+                        return false;
+                    }
+                    if frame.contains("rb_vm_exec") || frame.contains("vm_call_cfunc_with_frame") {
+                        reached_ruby = true;
+                        return false;
+                    }
+                    true
+                });
+
+                for frame in c_stack.iter() {
+                    merged_stack.push(FrameTableEntry {
+                        id: calculate_id_for_c_frame(frame),
+                        entry_type: FrameTableEntryType::Native,
+                        full_label: frame.to_string(),
+                    });
+                }
+
+                // Process Ruby-level stack
+
+                let ruby_stack_depth = sample.line_count;
+                for i in 0..ruby_stack_depth {
+                    let frame: VALUE = sample.frames[i as usize];
+                    merged_stack.push(FrameTableEntry {
+                        id: frame,
+                        entry_type: FrameTableEntryType::Ruby,
+                        full_label: CStr::from_ptr(rb_string_value_cstr(
+                            &mut rb_profile_frame_full_label(frame),
+                        ))
+                        .to_str()
+                        .unwrap()
+                        .to_owned(),
+                    });
+                }
+
                 // Find the Thread profile for this sample
                 let thread_serializer = serializer
                     .threads
@@ -86,34 +164,18 @@ impl ProfileSerializer {
                 // Stack frames, shallow to deep
                 let mut stack_tree = &mut thread_serializer.stack_tree;
 
-                for i in (0..(sample.line_count - 1)).rev() {
-                    let frame = sample.frames[i as usize];
-
-                    // Register frame metadata to frame table, if not registered yet
-                    let frame_table_id: FrameTableId = frame;
-                    thread_serializer
-                        .frame_table
-                        .entry(frame_table_id)
-                        .or_insert(FrameTableEntry {
-                            full_label: CStr::from_ptr(rb_string_value_cstr(
-                                &mut rb_profile_frame_full_label(frame),
-                            ))
-                            .to_str()
-                            .unwrap()
-                            .to_string(),
-                        });
-
-                    stack_tree = stack_tree.children.entry(frame_table_id).or_insert({
+                while let Some(frame_table_entry) = merged_stack.pop() {
+                    stack_tree = stack_tree.children.entry(frame_table_entry.id).or_insert({
                         let node = StackTreeNode {
                             children: HashMap::new(),
                             node_id: sequence,
-                            frame_id: frame_table_id,
+                            frame_id: frame_table_entry.id,
                         };
                         sequence += 1;
                         node
                     });
 
-                    if i == 0 {
+                    if merged_stack.is_empty() {
                         // This is the leaf node, record a Sample
                         let elapsed_ns = (sample.timestamp - profile.start_timestamp).as_nanos();
                         thread_serializer.samples.push(ProfileSample {
@@ -121,6 +183,12 @@ impl ProfileSerializer {
                             stack_tree_id: stack_tree.node_id,
                         });
                     }
+
+                    // Register frame metadata to frame table, if not registered yet
+                    thread_serializer
+                        .frame_table
+                        .entry(frame_table_entry.id)
+                        .or_insert(frame_table_entry);
                 }
             }
         }
@@ -128,3 +196,9 @@ impl ProfileSerializer {
         serde_json::to_string(&serializer).unwrap()
     }
 }
+
+fn calculate_id_for_c_frame<T: std::hash::Hash>(t: &T) -> FrameTableId {
+    let mut s = std::collections::hash_map::DefaultHasher::new();
+    t.hash(&mut s);
+    s.finish()
+}

data/ext/pf2/src/ringbuffer.rs

@@ -71,6 +71,7 @@ mod tests {
             line_count: 0,
             frames: [0; 500],
             linenos: [0; 500],
+            c_backtrace_pcs: [0; 1001],
         };
         let sample2 = Sample {
             ruby_thread: 2,
@@ -78,6 +79,7 @@ mod tests {
             line_count: 0,
             frames: [0; 500],
             linenos: [0; 500],
+            c_backtrace_pcs: [0; 1001],
         };
 
         ringbuffer.push(sample1).unwrap();
@@ -97,6 +99,7 @@ mod tests {
             line_count: 0,
             frames: [0; 500],
             linenos: [0; 500],
+            c_backtrace_pcs: [0; 1001],
         };
         let sample2 = Sample {
             ruby_thread: 2,
@@ -104,6 +107,7 @@ mod tests {
             line_count: 0,
             frames: [0; 500],
             linenos: [0; 500],
+            c_backtrace_pcs: [0; 1001],
         };
 
         ringbuffer.push(sample1).unwrap();
@@ -119,6 +123,7 @@ mod tests {
             line_count: 0,
             frames: [0; 500],
             linenos: [0; 500],
+            c_backtrace_pcs: [0; 1001],
         };
         let sample2 = Sample {
             ruby_thread: 2,
@@ -126,6 +131,7 @@ mod tests {
             line_count: 0,
             frames: [0; 500],
             linenos: [0; 500],
+            c_backtrace_pcs: [0; 1001],
         };
         let sample3 = Sample {
             ruby_thread: 3,
@@ -133,6 +139,7 @@ mod tests {
             line_count: 0,
             frames: [0; 500],
             linenos: [0; 500],
+            c_backtrace_pcs: [0; 1001],
         };
 
         ringbuffer.push(sample1).unwrap();

data/ext/pf2/src/ruby_init.rs

@@ -26,16 +26,22 @@ extern "C" fn Init_pf2() {
             let rb_mPf2_SignalScheduler =
                 rb_define_class_under(rb_mPf2, cstr!("SignalScheduler"), rb_cObject);
             rb_define_alloc_func(rb_mPf2_SignalScheduler, Some(SignalScheduler::rb_alloc));
+            rb_define_method(
+                rb_mPf2_SignalScheduler,
+                cstr!("initialize"),
+                Some(to_ruby_cfunc_with_args(SignalScheduler::rb_initialize)),
+                -1,
+            );
             rb_define_method(
                 rb_mPf2_SignalScheduler,
                 cstr!("start"),
-                Some(to_ruby_cfunc3(SignalScheduler::rb_start)),
-                2,
+                Some(to_ruby_cfunc_with_no_args(SignalScheduler::rb_start)),
+                0,
             );
             rb_define_method(
                 rb_mPf2_SignalScheduler,
                 cstr!("stop"),
-                Some(to_ruby_cfunc1(SignalScheduler::rb_stop)),
+                Some(to_ruby_cfunc_with_no_args(SignalScheduler::rb_stop)),
                 0,
             );
         }
@@ -46,16 +52,22 @@ extern "C" fn Init_pf2() {
             rb_mPf2_TimerThreadScheduler,
             Some(TimerThreadScheduler::rb_alloc),
         );
+        rb_define_method(
+            rb_mPf2_TimerThreadScheduler,
+            cstr!("initialize"),
+            Some(to_ruby_cfunc_with_args(TimerThreadScheduler::rb_initialize)),
+            -1,
+        );
         rb_define_method(
             rb_mPf2_TimerThreadScheduler,
             cstr!("start"),
-            Some(to_ruby_cfunc3(TimerThreadScheduler::rb_start)),
-            2,
+            Some(to_ruby_cfunc_with_no_args(TimerThreadScheduler::rb_start)),
+            0,
         );
         rb_define_method(
             rb_mPf2_TimerThreadScheduler,
             cstr!("stop"),
-            Some(to_ruby_cfunc1(TimerThreadScheduler::rb_stop)),
+            Some(to_ruby_cfunc_with_no_args(TimerThreadScheduler::rb_stop)),
             0,
         );
     }

data/ext/pf2/src/sample.rs

@@ -2,7 +2,10 @@ use std::time::Instant;
 
 use rb_sys::*;
 
+use crate::backtrace::{Backtrace, BacktraceState};
+
 const MAX_STACK_DEPTH: usize = 500;
+const MAX_C_STACK_DEPTH: usize = 1000;
 
 #[derive(Debug, PartialEq)]
 pub struct Sample {
@@ -11,18 +14,36 @@ pub struct Sample {
     pub line_count: i32,
     pub frames: [VALUE; MAX_STACK_DEPTH],
     pub linenos: [i32; MAX_STACK_DEPTH],
+    pub c_backtrace_pcs: [usize; MAX_C_STACK_DEPTH + 1],
 }
 
 impl Sample {
     // Nearly async-signal-safe
     // (rb_profile_thread_frames isn't defined as a-s-s)
-    pub fn capture(ruby_thread: VALUE) -> Self {
+    pub fn capture(ruby_thread: VALUE, backtrace_state: &BacktraceState) -> Self {
+        let mut c_backtrace_pcs = [0; MAX_C_STACK_DEPTH + 1];
+
+        Backtrace::backtrace_simple(
+            backtrace_state,
+            0,
+            |pc: usize| -> i32 {
+                if c_backtrace_pcs[0] >= MAX_C_STACK_DEPTH {
+                    return 1;
+                }
+                c_backtrace_pcs[0] += 1;
+                c_backtrace_pcs[c_backtrace_pcs[0]] = pc;
+                0
+            },
+            Some(Backtrace::backtrace_error_callback),
+        );
+
         let mut sample = Sample {
             ruby_thread,
             timestamp: Instant::now(),
             line_count: 0,
             frames: [0; MAX_STACK_DEPTH],
             linenos: [0; MAX_STACK_DEPTH],
+            c_backtrace_pcs,
         };
         unsafe {
             sample.line_count = rb_profile_thread_frames(

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

@@ -1,8 +1,15 @@
+use std::collections::HashSet;
 use std::str::FromStr;
+use std::time::Duration;
+
+use rb_sys::VALUE;
 
 #[derive(Clone, Debug)]
 pub struct Configuration {
+    pub interval: Duration,
     pub time_mode: TimeMode,
+    pub target_ruby_threads: HashSet<VALUE>,
+    pub track_new_threads: bool,
 }
 
 #[derive(Clone, Debug)]

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

@@ -23,7 +23,6 @@ pub struct TimerInstaller {
 
 struct Internal {
     configuration: Configuration,
-    target_ruby_threads: HashSet<VALUE>,
     registered_pthread_ids: HashSet<libc::pthread_t>,
     kernel_thread_id_to_ruby_thread_map: HashMap<libc::pid_t, VALUE>,
     profile: Arc<RwLock<Profile>>,
@@ -34,14 +33,11 @@ impl TimerInstaller {
     // The callback should create a timer for the thread.
     pub fn install_timer_to_ruby_threads(
         configuration: Configuration,
-        ruby_threads: &HashSet<VALUE>,
         profile: Arc<RwLock<Profile>>,
-        track_new_threads: bool,
     ) {
         let registrar = Self {
             internal: Box::new(Mutex::new(Internal {
-                configuration,
-                target_ruby_threads: ruby_threads.clone(),
+                configuration: configuration.clone(),
                 registered_pthread_ids: HashSet::new(),
                 kernel_thread_id_to_ruby_thread_map: HashMap::new(),
                 profile,
@@ -60,7 +56,7 @@ impl TimerInstaller {
             rb_thread_create(Some(Self::do_nothing), null_mut());
         };
 
-        if track_new_threads {
+        if configuration.track_new_threads {
             unsafe {
                 rb_internal_thread_add_event_hook(
                     Some(Self::on_thread_start),
@@ -88,7 +84,11 @@ impl TimerInstaller {
 
         // Check if the current thread is a target Ruby Thread
         let current_ruby_thread: VALUE = unsafe { (*data).thread };
-        if !internal.target_ruby_threads.contains(&current_ruby_thread) {
+        if !internal
+            .configuration
+            .target_ruby_threads
+            .contains(&current_ruby_thread)
+        {
             return;
         }
 
@@ -129,7 +129,10 @@ impl TimerInstaller {
         let mut internal = internal.lock().unwrap();
 
         let current_ruby_thread: VALUE = unsafe { (*data).thread };
-        internal.target_ruby_threads.insert(current_ruby_thread);
+        internal
+            .configuration
+            .target_ruby_threads
+            .insert(current_ruby_thread);
     }
 
     // Creates a new POSIX timer which invocates sampling for the thread that called this function.
@@ -162,31 +165,35 @@ impl TimerInstaller {
         // 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 10 ms of CPU time
+        // Create and configure timer to fire every _interval_ ms of CPU time
         let mut timer: libc::timer_t = unsafe { mem::zeroed() };
-        match configuration.time_mode {
-            crate::signal_scheduler::TimeMode::CpuTime => {
-                let err = unsafe {
-                    libc::timer_create(libc::CLOCK_THREAD_CPUTIME_ID, &mut sigevent, &mut timer)
-                };
-                if err != 0 {
-                    panic!("timer_create failed: {}", err);
-                }
-            }
-            crate::signal_scheduler::TimeMode::WallTime => {
-                todo!("WallTime is not supported yet");
-            }
+        let clockid = match configuration.time_mode {
+            crate::signal_scheduler::TimeMode::CpuTime => libc::CLOCK_THREAD_CPUTIME_ID,
+            crate::signal_scheduler::TimeMode::WallTime => libc::CLOCK_MONOTONIC,
         };
-        let mut its: libc::itimerspec = unsafe { mem::zeroed() };
-        its.it_interval.tv_sec = 0;
-        its.it_interval.tv_nsec = 10_000_000; // 10 ms
-        its.it_value.tv_sec = 0;
-        its.it_value.tv_nsec = 10_000_000;
-        let err = unsafe { libc::timer_settime(timer, 0, &its, null_mut()) };
+        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 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);
     }
+
+    fn duration_to_itimerspec(duration: &std::time::Duration) -> libc::itimerspec {
+        let nanos = duration.as_nanos();
+        let seconds_part: i64 = (nanos / 1_000_000_000).try_into().unwrap();
+        let nanos_part: i64 = (nanos % 1_000_000_000).try_into().unwrap();
+
+        let mut its: libc::itimerspec = unsafe { mem::zeroed() };
+        its.it_interval.tv_sec = seconds_part;
+        its.it_interval.tv_nsec = nanos_part;
+        its.it_value.tv_sec = seconds_part;
+        its.it_value.tv_nsec = nanos_part;
+        its
+    }
 }

data/ext/pf2/src/signal_scheduler.rs

@@ -11,8 +11,9 @@ use crate::sample::Sample;
 
 use core::panic;
 use std::collections::HashSet;
-use std::ffi::{c_int, c_void, CString};
+use std::ffi::{c_int, c_void, CStr, CString};
 use std::mem::ManuallyDrop;
+use std::str::FromStr;
 use std::sync::{Arc, RwLock};
 use std::thread;
 use std::time::Duration;
@@ -24,7 +25,7 @@ use crate::util::*;
 
 #[derive(Debug)]
 pub struct SignalScheduler {
-    configuration: configuration::Configuration,
+    configuration: Option<configuration::Configuration>,
     profile: Option<Arc<RwLock<Profile>>>,
 }
 
@@ -36,37 +37,100 @@ pub struct SignalHandlerArgs {
 impl SignalScheduler {
     fn new() -> Self {
         Self {
-            configuration: Configuration {
-                time_mode: TimeMode::CpuTime,
-            },
+            configuration: None,
             profile: None,
         }
     }
 
-    fn start(
-        &mut self,
-        _rbself: VALUE,
-        ruby_threads_rary: VALUE,
-        track_new_threads: VALUE,
-    ) -> VALUE {
-        let track_new_threads = RTEST(track_new_threads);
-
-        let profile = Arc::new(RwLock::new(Profile::new()));
-        self.start_profile_buffer_flusher_thread(&profile);
-        self.install_signal_handler();
+    fn initialize(&mut self, argc: c_int, argv: *const VALUE, _rbself: VALUE) -> VALUE {
+        // Parse arguments
+        let kwargs: VALUE = Qnil.into();
+        unsafe {
+            rb_scan_args(argc, argv, cstr!(":"), &kwargs);
+        };
+        let mut kwargs_values: [VALUE; 4] = [Qnil.into(); 4];
+        unsafe {
+            rb_get_kwargs(
+                kwargs,
+                [
+                    rb_intern(cstr!("interval_ms")),
+                    rb_intern(cstr!("threads")),
+                    rb_intern(cstr!("time_mode")),
+                    rb_intern(cstr!("track_new_threads")),
+                ]
+                .as_mut_ptr(),
+                0,
+                4,
+                kwargs_values.as_mut_ptr(),
+            );
+        };
+        let interval: Duration = if kwargs_values[0] != Qundef as VALUE {
+            let interval_ms = unsafe { rb_num2long(kwargs_values[0]) };
+            Duration::from_millis(interval_ms.try_into().unwrap_or_else(|_| {
+                eprintln!(
+                    "[Pf2] Warning: Specified interval ({}) is not valid. Using default value (49ms).",
+                    interval_ms
+                );
+                49
+            }))
+        } else {
+            Duration::from_millis(49)
+        };
+        let threads: VALUE = if kwargs_values[1] != Qundef as VALUE {
+            kwargs_values[1]
+        } else {
+            unsafe { rb_funcall(rb_cThread, rb_intern(cstr!("list")), 0) }
+        };
+        let time_mode: configuration::TimeMode = if kwargs_values[2] != Qundef as VALUE {
+            let specified_mode = unsafe {
+                let mut str = rb_funcall(kwargs_values[2], rb_intern(cstr!("to_s")), 0);
+                let ptr = rb_string_value_ptr(&mut str);
+                CStr::from_ptr(ptr).to_str().unwrap()
+            };
+            configuration::TimeMode::from_str(specified_mode).unwrap_or_else(|_| {
+                // Raise an ArgumentError
+                unsafe {
+                    rb_raise(
+                        rb_eArgError,
+                        cstr!("Invalid time mode. Valid values are 'cpu' and 'wall'."),
+                    )
+                }
+            })
+        } else {
+            configuration::TimeMode::CpuTime
+        };
+        let track_new_threads: bool = if kwargs_values[3] != Qundef as VALUE {
+            RTEST(kwargs_values[3])
+        } else {
+            false
+        };
 
         let mut target_ruby_threads = HashSet::new();
         unsafe {
-            for i in 0..RARRAY_LEN(ruby_threads_rary) {
-                let ruby_thread: VALUE = rb_ary_entry(ruby_threads_rary, i);
+            for i in 0..RARRAY_LEN(threads) {
+                let ruby_thread: VALUE = rb_ary_entry(threads, i);
                 target_ruby_threads.insert(ruby_thread);
             }
         }
+
+        self.configuration = Some(Configuration {
+            interval,
+            target_ruby_threads,
+            time_mode,
+            track_new_threads,
+        });
+
+        Qnil.into()
+    }
+
+    fn start(&mut self, _rbself: VALUE) -> VALUE {
+        let profile = Arc::new(RwLock::new(Profile::new()));
+        self.start_profile_buffer_flusher_thread(&profile);
+        self.install_signal_handler();
+
         TimerInstaller::install_timer_to_ruby_threads(
-            self.configuration.clone(),
-            &target_ruby_threads,
+            self.configuration.as_ref().unwrap().clone(), // FIXME: don't clone
             Arc::clone(&profile),
-            track_new_threads,
         );
 
         self.profile = Some(profile);
@@ -132,7 +196,7 @@ impl SignalScheduler {
             }
         };
 
-        let sample = Sample::capture(args.context_ruby_thread); // NOT async-signal-safe
+        let sample = Sample::capture(args.context_ruby_thread, &profile.backtrace_state); // NOT async-signal-safe
         if profile.temporary_sample_buffer.push(sample).is_err() {
             log::debug!("Temporary sample buffer full. Dropping sample.");
         }
@@ -156,13 +220,18 @@ impl SignalScheduler {
 
     // Ruby Methods
 
-    pub unsafe extern "C" fn rb_start(
+    pub unsafe extern "C" fn rb_initialize(
+        argc: c_int,
+        argv: *const VALUE,
         rbself: VALUE,
-        ruby_threads: VALUE,
-        track_new_threads: VALUE,
     ) -> VALUE {
         let mut collector = unsafe { Self::get_struct_from(rbself) };
-        collector.start(rbself, ruby_threads, track_new_threads)
+        collector.initialize(argc, argv, rbself)
+    }
+
+    pub unsafe extern "C" fn rb_start(rbself: VALUE) -> VALUE {
+        let mut collector = unsafe { Self::get_struct_from(rbself) };
+        collector.start(rbself)
     }
 
     pub unsafe extern "C" fn rb_stop(rbself: VALUE) -> VALUE {