pf2 0.1.0 → 0.3.0

data/ext/pf2/src/lib.rs

@@ -0,0 +1,15 @@
+extern crate serde;
+#[macro_use]
+extern crate serde_derive;
+
+mod ruby_init;
+
+mod backtrace;
+mod profile;
+mod profile_serializer;
+mod ringbuffer;
+mod sample;
+#[cfg(target_os = "linux")]
+mod signal_scheduler;
+mod timer_thread_scheduler;
+mod util;

data/ext/pf2/src/profile.rs

@@ -0,0 +1,65 @@
+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;
+
+// Capacity large enough to hold 1 second worth of samples for 16 threads
+// 16 threads * 20 samples per second * 1 second = 320
+const DEFAULT_RINGBUFFER_CAPACITY: usize = 320;
+
+#[derive(Debug)]
+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(),
+        }
+    }
+
+    pub fn flush_temporary_sample_buffer(&mut self) {
+        while let Some(sample) = self.temporary_sample_buffer.pop() {
+            self.known_values.insert(sample.ruby_thread);
+            for frame in sample.frames.iter() {
+                if frame == &0 {
+                    break;
+                }
+                self.known_values.insert(*frame);
+            }
+            self.samples.push(sample);
+        }
+    }
+
+    pub unsafe fn dmark(&self) {
+        for value in self.known_values.iter() {
+            rb_gc_mark(*value);
+        }
+        self.temporary_sample_buffer.dmark();
+    }
+}

data/ext/pf2/src/profile_serializer.rs

@@ -0,0 +1,204 @@
+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)]
+pub struct ProfileSerializer {
+    threads: HashMap<ThreadId, ThreadProfile>,
+}
+
+type ThreadId = VALUE;
+
+#[derive(Debug, Deserialize, Serialize)]
+struct ThreadProfile {
+    thread_id: ThreadId,
+    stack_tree: StackTreeNode,
+    #[serde(rename = "frames")]
+    frame_table: HashMap<FrameTableId, FrameTableEntry>,
+    samples: Vec<ProfileSample>,
+}
+
+impl ThreadProfile {
+    fn new(thread_id: ThreadId) -> ThreadProfile {
+        ThreadProfile {
+            thread_id,
+            // The root node
+            stack_tree: StackTreeNode {
+                children: HashMap::new(),
+                node_id: 0,
+                frame_id: 0,
+            },
+            frame_table: HashMap::new(),
+            samples: vec![],
+        }
+    }
+}
+
+type StackTreeNodeId = i32;
+
+// Arbitary value which is used inside StackTreeNode.
+// This VALUE should not be dereferenced as a pointer; we're merely using its pointer as a unique value.
+// (Probably should be reconsidered)
+type FrameTableId = VALUE;
+
+#[derive(Debug, Deserialize, Serialize)]
+struct StackTreeNode {
+    // TODO: Maybe a Vec<StackTreeNode> is enough?
+    // There's no particular meaning in using FrameTableId as key
+    children: HashMap<FrameTableId, StackTreeNode>,
+    // An arbitary ID (no particular meaning)
+    node_id: StackTreeNodeId,
+    // ?
+    frame_id: FrameTableId,
+}
+
+#[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 {
+    elapsed_ns: u128,
+    stack_tree_id: StackTreeNodeId,
+}
+
+impl ProfileSerializer {
+    pub fn serialize(profile: &Profile) -> String {
+        let mut sequence = 1;
+
+        let mut serializer = ProfileSerializer {
+            threads: HashMap::new(),
+        };
+
+        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
+                    .entry(sample.ruby_thread)
+                    .or_insert(ThreadProfile::new(sample.ruby_thread));
+
+                // Stack frames, shallow to deep
+                let mut stack_tree = &mut thread_serializer.stack_tree;
+
+                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_entry.id,
+                        };
+                        sequence += 1;
+                        node
+                    });
+
+                    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 {
+                            elapsed_ns,
+                            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);
+                }
+            }
+        }
+
+        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

@@ -0,0 +1,152 @@
+use crate::sample::Sample;
+
+#[derive(Debug)]
+pub struct Ringbuffer {
+    capacity: usize,
+    buffer: Vec<Option<Sample>>,
+    read_index: usize,
+    write_index: usize,
+}
+
+#[derive(Debug, PartialEq)]
+pub enum RingbufferError {
+    Full,
+}
+
+impl Ringbuffer {
+    pub fn new(capacity: usize) -> Self {
+        Self {
+            capacity,
+            buffer: std::iter::repeat_with(|| None)
+                .take(capacity + 1)
+                .collect::<Vec<_>>(),
+            read_index: 0,
+            write_index: 0,
+        }
+    }
+
+    // async-signal-safe
+    pub fn push(&mut self, sample: Sample) -> Result<(), RingbufferError> {
+        let next = (self.write_index + 1) % (self.capacity + 1);
+        if next == self.read_index {
+            return Err(RingbufferError::Full);
+        }
+        self.buffer[self.write_index] = Some(sample);
+        self.write_index = next;
+        Ok(())
+    }
+
+    pub fn pop(&mut self) -> Option<Sample> {
+        if self.read_index == self.write_index {
+            return None;
+        }
+        let sample = self.buffer[self.read_index].take();
+        self.read_index = (self.read_index + 1) % (self.capacity + 1);
+        sample
+    }
+
+    // This will call rb_gc_mark() for capacity * Sample::MAX_STACK_DEPTH * 2 times, which is a lot!
+    pub fn dmark(&self) {
+        for sample in self.buffer.iter().flatten() {
+            unsafe {
+                sample.dmark();
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::time::Instant;
+
+    #[test]
+    fn test_ringbuffer() {
+        let mut ringbuffer = Ringbuffer::new(2);
+        assert_eq!(ringbuffer.pop(), None);
+
+        let sample1 = Sample {
+            ruby_thread: 1,
+            timestamp: Instant::now(),
+            line_count: 0,
+            frames: [0; 500],
+            linenos: [0; 500],
+            c_backtrace_pcs: [0; 1001],
+        };
+        let sample2 = Sample {
+            ruby_thread: 2,
+            timestamp: Instant::now(),
+            line_count: 0,
+            frames: [0; 500],
+            linenos: [0; 500],
+            c_backtrace_pcs: [0; 1001],
+        };
+
+        ringbuffer.push(sample1).unwrap();
+        ringbuffer.push(sample2).unwrap();
+
+        assert_eq!(ringbuffer.pop().unwrap().ruby_thread, 1);
+        assert_eq!(ringbuffer.pop().unwrap().ruby_thread, 2);
+        assert_eq!(ringbuffer.pop(), None);
+    }
+
+    #[test]
+    fn test_ringbuffer_full() {
+        let mut ringbuffer = Ringbuffer::new(1);
+        let sample1 = Sample {
+            ruby_thread: 1,
+            timestamp: Instant::now(),
+            line_count: 0,
+            frames: [0; 500],
+            linenos: [0; 500],
+            c_backtrace_pcs: [0; 1001],
+        };
+        let sample2 = Sample {
+            ruby_thread: 2,
+            timestamp: Instant::now(),
+            line_count: 0,
+            frames: [0; 500],
+            linenos: [0; 500],
+            c_backtrace_pcs: [0; 1001],
+        };
+
+        ringbuffer.push(sample1).unwrap();
+        assert_eq!(ringbuffer.push(sample2), Err(RingbufferError::Full));
+    }
+
+    #[test]
+    fn test_ringbuffer_write_a_lot() {
+        let mut ringbuffer = Ringbuffer::new(2);
+        let sample1 = Sample {
+            ruby_thread: 1,
+            timestamp: Instant::now(),
+            line_count: 0,
+            frames: [0; 500],
+            linenos: [0; 500],
+            c_backtrace_pcs: [0; 1001],
+        };
+        let sample2 = Sample {
+            ruby_thread: 2,
+            timestamp: Instant::now(),
+            line_count: 0,
+            frames: [0; 500],
+            linenos: [0; 500],
+            c_backtrace_pcs: [0; 1001],
+        };
+        let sample3 = Sample {
+            ruby_thread: 3,
+            timestamp: Instant::now(),
+            line_count: 0,
+            frames: [0; 500],
+            linenos: [0; 500],
+            c_backtrace_pcs: [0; 1001],
+        };
+
+        ringbuffer.push(sample1).unwrap();
+        ringbuffer.pop().unwrap();
+        ringbuffer.push(sample2).unwrap();
+        ringbuffer.pop().unwrap();
+        ringbuffer.push(sample3).unwrap();
+        assert_eq!(ringbuffer.pop().unwrap().ruby_thread, 3);
+    }
+}

data/ext/pf2/src/ruby_init.rs

@@ -0,0 +1,74 @@
+#![deny(unsafe_op_in_unsafe_fn)]
+
+use rb_sys::*;
+
+#[cfg(target_os = "linux")]
+use crate::signal_scheduler::SignalScheduler;
+use crate::timer_thread_scheduler::TimerThreadScheduler;
+use crate::util::*;
+
+#[allow(non_snake_case)]
+#[no_mangle]
+extern "C" fn Init_pf2() {
+    #[cfg(feature = "debug")]
+    {
+        env_logger::builder()
+            .format_timestamp(None)
+            .format_module_path(false)
+            .init();
+    }
+
+    unsafe {
+        let rb_mPf2: VALUE = rb_define_module(cstr!("Pf2"));
+
+        #[cfg(target_os = "linux")]
+        {
+            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_cfunc_with_no_args(SignalScheduler::rb_start)),
+                0,
+            );
+            rb_define_method(
+                rb_mPf2_SignalScheduler,
+                cstr!("stop"),
+                Some(to_ruby_cfunc_with_no_args(SignalScheduler::rb_stop)),
+                0,
+            );
+        }
+
+        let rb_mPf2_TimerThreadScheduler =
+            rb_define_class_under(rb_mPf2, cstr!("TimerThreadScheduler"), rb_cObject);
+        rb_define_alloc_func(
+            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_cfunc_with_no_args(TimerThreadScheduler::rb_start)),
+            0,
+        );
+        rb_define_method(
+            rb_mPf2_TimerThreadScheduler,
+            cstr!("stop"),
+            Some(to_ruby_cfunc_with_no_args(TimerThreadScheduler::rb_stop)),
+            0,
+        );
+    }
+}

data/ext/pf2/src/sample.rs

@@ -0,0 +1,66 @@
+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 {
+    pub ruby_thread: VALUE,
+    pub timestamp: Instant,
+    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, 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(
+                ruby_thread,
+                0,
+                2000,
+                sample.frames.as_mut_ptr(),
+                sample.linenos.as_mut_ptr(),
+            );
+        };
+        sample
+    }
+
+    pub unsafe fn dmark(&self) {
+        rb_gc_mark(self.ruby_thread);
+        for frame in self.frames.iter() {
+            rb_gc_mark(*frame);
+        }
+    }
+}

data/ext/pf2/src/siginfo_t.c

@@ -0,0 +1,5 @@
+#include <signal.h>
+
+void *extract_si_value_sival_ptr(siginfo_t *siginfo) {
+  return siginfo->si_value.sival_ptr;
+}

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

@@ -0,0 +1,31 @@
+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)]
+pub enum TimeMode {
+    CpuTime,
+    WallTime,
+}
+
+impl FromStr for TimeMode {
+    type Err = ();
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "cpu" => Ok(Self::CpuTime),
+            "wall" => Ok(Self::WallTime),
+            _ => Err(()),
+        }
+    }
+}