pf2 0.9.0 → 1.0.0.alpha1

data/ext/pf2/src/lib.rs

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

data/ext/pf2/src/profile.rs

@@ -1,69 +0,0 @@
-use std::time::{Instant, SystemTime};
-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: SystemTime,
-    pub start_instant: Instant,
-    pub end_instant: Option<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: SystemTime::now(),
-            start_instant: Instant::now(),
-            end_instant: None,
-            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

@@ -1,241 +0,0 @@
-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;
-use crate::util::RTEST;
-
-#[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,
-    file_name: Option<String>,
-    function_first_lineno: Option<i32>,
-    callsite_lineno: Option<i32>,
-    address: Option<usize>,
-}
-
-#[derive(Debug, Deserialize, Serialize)]
-enum FrameTableEntryType {
-    Ruby,
-    Native,
-}
-
-// Represents leaf (末端)
-#[derive(Debug, Deserialize, Serialize)]
-struct ProfileSample {
-    elapsed_ns: u128,
-    stack_tree_id: StackTreeNodeId,
-}
-
-struct NativeFunctionFrame {
-    pub symbol_name: String,
-    pub address: Option<usize>,
-}
-
-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
-
-                let mut c_stack: Vec<NativeFunctionFrame> = vec![];
-                // Rebuild the original backtrace (including inlined functions) from the PC.
-                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(NativeFunctionFrame {
-                                    symbol_name: "(no symbol information)".to_owned(),
-                                    address: None,
-                                });
-                            } else {
-                                c_stack.push(NativeFunctionFrame {
-                                    symbol_name: CStr::from_ptr(symname)
-                                        .to_str()
-                                        .unwrap()
-                                        .to_owned(),
-                                    address: Some(symval),
-                                });
-                            }
-                        },
-                        Some(Backtrace::backtrace_error_callback),
-                    );
-                }
-                for frame in c_stack.iter() {
-                    if frame.symbol_name.contains("pf2") {
-                        // Skip Pf2-related frames
-                        continue;
-                    }
-
-                    merged_stack.push(FrameTableEntry {
-                        id: calculate_id_for_c_frame(&frame.symbol_name),
-                        entry_type: FrameTableEntryType::Native,
-                        full_label: frame.symbol_name.clone(),
-                        file_name: None,
-                        function_first_lineno: None,
-                        callsite_lineno: None,
-                        address: frame.address,
-                    });
-                }
-
-                // 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];
-                    let lineno: i32 = sample.linenos[i as usize];
-                    let address: Option<usize> = {
-                        let cme = frame
-                            as *mut crate::ruby_internal_apis::rb_callable_method_entry_struct;
-                        let cme = &*cme;
-
-                        if (*(cme.def)).type_ == 1 {
-                            // The cme is a Cfunc
-                            Some((*(cme.def)).cfunc.func as usize)
-                        } else {
-                            // The cme is an ISeq (Ruby code) or some other type
-                            None
-                        }
-                    };
-                    let mut frame_full_label: VALUE = rb_profile_frame_full_label(frame);
-                    let frame_full_label: String = if RTEST(frame_full_label) {
-                        CStr::from_ptr(rb_string_value_cstr(&mut frame_full_label))
-                            .to_str()
-                            .unwrap()
-                            .to_owned()
-                    } else {
-                        "(unknown)".to_owned()
-                    };
-                    let mut frame_path: VALUE = rb_profile_frame_path(frame);
-                    let frame_path: String = if RTEST(frame_path) {
-                        CStr::from_ptr(rb_string_value_cstr(&mut frame_path))
-                            .to_str()
-                            .unwrap()
-                            .to_owned()
-                    } else {
-                        "(unknown)".to_owned()
-                    };
-                    let frame_first_lineno: VALUE = rb_profile_frame_first_lineno(frame);
-                    let frame_first_lineno: Option<i32> = if RTEST(frame_first_lineno) {
-                        Some(rb_num2int(frame_first_lineno).try_into().unwrap())
-                    } else {
-                        None
-                    };
-                    merged_stack.push(FrameTableEntry {
-                        id: frame,
-                        entry_type: FrameTableEntryType::Ruby,
-                        full_label: frame_full_label,
-                        file_name: Some(frame_path),
-                        function_first_lineno: frame_first_lineno,
-                        callsite_lineno: Some(lineno),
-                        address,
-                    });
-                }
-
-                // 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_instant).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

@@ -1,150 +0,0 @@
-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_c_api_helper.c

@@ -1,6 +0,0 @@
-#include <ruby.h>
-
-VALUE rb_ull2num(unsigned long long n) {
-    if (POSFIXABLE(n)) return LONG2FIX((long)n);
-    return rb_ull2inum(n);
-}

data/ext/pf2/src/ruby_init.rs

@@ -1,40 +0,0 @@
-#![deny(unsafe_op_in_unsafe_fn)]
-
-use rb_sys::*;
-
-use crate::session::ruby_object::SessionRubyObject;
-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"));
-
-        let rb_mPf2_Session = rb_define_class_under(rb_mPf2, cstr!("Session"), rb_cObject);
-        rb_define_alloc_func(rb_mPf2_Session, Some(SessionRubyObject::rb_alloc));
-        rb_define_method(
-            rb_mPf2_Session,
-            cstr!("initialize"),
-            Some(to_ruby_cfunc_with_args(SessionRubyObject::rb_initialize)),
-            -1,
-        );
-        rb_define_method(
-            rb_mPf2_Session,
-            cstr!("start"),
-            Some(to_ruby_cfunc_with_no_args(SessionRubyObject::rb_start)),
-            0,
-        );
-        rb_define_method(
-            rb_mPf2_Session,
-            cstr!("stop"),
-            Some(to_ruby_cfunc_with_no_args(SessionRubyObject::rb_stop)),
-            0,
-        );
-    }
-}

data/ext/pf2/src/ruby_internal_apis.rs

@@ -1,77 +0,0 @@
-#![allow(non_snake_case)]
-#![allow(non_camel_case_types)]
-
-use libc::{clockid_t, pthread_t};
-use rb_sys::{rb_check_typeddata, rb_data_type_struct, RTypedData, VALUE};
-use std::ffi::{c_char, c_int, c_void};
-use std::mem::MaybeUninit;
-
-#[cfg(target_os = "linux")]
-use libc::pthread_getcpuclockid;
-
-#[cfg(not(target_os = "linux"))]
-pub unsafe fn pthread_getcpuclockid(thread: pthread_t, clk_id: *mut clockid_t) -> c_int {
-    unimplemented!()
-}
-
-// Types and structs from Ruby 3.4.0.
-#[repr(C)]
-pub struct rb_callable_method_entry_struct {
-    /* same fields with rb_method_entry_t */
-    pub flags: VALUE,
-    _padding_defined_class: VALUE,
-    pub def: *mut rb_method_definition_struct,
-    // ...
-}
-
-#[repr(C)]
-pub struct rb_method_definition_struct {
-    pub type_: c_int,
-    _padding: [c_char; 4],
-    pub cfunc: rb_method_cfunc_struct,
-    // ...
-}
-
-#[repr(C)]
-pub struct rb_method_cfunc_struct {
-    pub func: *mut c_void,
-    // ...
-}
-
-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

@@ -1,67 +0,0 @@
-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],
-    /// First element represents the backtrace 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/scheduler.rs

@@ -1,10 +0,0 @@
-use rb_sys::{size_t, VALUE};
-
-pub trait Scheduler {
-    fn start(&self) -> VALUE;
-    fn stop(&self) -> VALUE;
-    fn on_new_thread(&self, thread: VALUE);
-    fn dmark(&self);
-    fn dfree(&self);
-    fn dsize(&self) -> size_t;
-}