pf2 0.2.0 → 0.4.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/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/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_all_threads: bool,
 }
 
 #[derive(Clone, Debug)]