pf2 0.8.0 → 1.0.0.alpha1

data/crates/backtrace-sys2/src/libbacktrace/.gitignore

@@ -1,15 +0,0 @@
-*~
-*.o
-*.lo
-*.a
-*.la
-
-.libs
-Makefile
-backtrace-supported.h
-config.h
-config.log
-config.status
-install-debuginfo-for-buildid.sh
-libtool
-stamp-h1

data/ext/pf2/Cargo.toml

@@ -1,25 +0,0 @@
-[package]
-name = "pf2"
-version = "0.1.0"
-edition = "2021"
-authors = ["Daisuke Aritomo <osyoyu@osyoyu.com>"]
-publish = false
-
-[lib]
-crate-type = ["cdylib"]
-
-[dependencies]
-backtrace-sys2 = { path = "../../crates/backtrace-sys2" }
-env_logger = { version = "0.11.0", optional = true }
-libc = "0.2.149"
-log = "0.4.20"
-rb-sys = { version = "0.9.105", features = ["stable-api"] }
-serde = "1.0.189"
-serde_derive = "1.0.189"
-serde_json = "1.0.107"
-
-[build-dependencies]
-cc = "1.0.83"
-
-[features]
-debug = ["env_logger"]

data/ext/pf2/build.rs

@@ -1,10 +0,0 @@
-use std::env;
-
-fn main() {
-    cc::Build::new().file("src/siginfo_t.c").compile("ccode");
-    cc::Build::new()
-        .flag(format!("-I{}", env::var("DEP_RB_RBCONFIG_RUBYHDRDIR").unwrap()).as_str())
-        .flag(format!("-I{}", env::var("DEP_RB_RBCONFIG_RUBYARCHHDRDIR").unwrap()).as_str())
-        .file("src/ruby_c_api_helper.c")
-        .compile("rubyhelper");
-}

data/ext/pf2/src/backtrace.rs

@@ -1,127 +0,0 @@
-use std::ffi::{c_char, c_int, CStr};
-
-use libc::c_void;
-
-#[derive(Debug)]
-pub struct BacktraceState {
-    ptr: *mut backtrace_sys2::backtrace_state,
-}
-
-unsafe impl Send for BacktraceState {}
-unsafe impl Sync for BacktraceState {}
-
-impl BacktraceState {
-    pub unsafe fn new(ptr: *mut backtrace_sys2::backtrace_state) -> Self {
-        Self { ptr }
-    }
-
-    pub fn as_mut_ptr(&self) -> *mut backtrace_sys2::backtrace_state {
-        self.ptr
-    }
-}
-
-pub struct Backtrace {}
-
-impl Backtrace {
-    pub fn backtrace_simple<F>(
-        state: &BacktraceState,
-        skip: i32,
-        mut on_ok: F,
-        on_error: backtrace_sys2::backtrace_error_callback,
-    ) where
-        F: FnMut(usize) -> c_int,
-    {
-        unsafe {
-            backtrace_sys2::backtrace_simple(
-                state.as_mut_ptr(),
-                skip,
-                Some(Self::backtrace_simple_trampoline::<F>),
-                on_error,
-                &mut on_ok as *mut _ as *mut c_void,
-            );
-        }
-    }
-
-    #[allow(dead_code)] // TODO: Remove this
-    pub fn backtrace_pcinfo<F>(
-        state: &BacktraceState,
-        pc: usize,
-        mut on_ok: F,
-        on_error: backtrace_sys2::backtrace_error_callback,
-    ) where
-        F: FnMut(usize, *const c_char, c_int, *const c_char) -> c_int,
-    {
-        unsafe {
-            backtrace_sys2::backtrace_pcinfo(
-                state.as_mut_ptr(),
-                pc,
-                Some(Self::backtrace_full_trampoline::<F>),
-                on_error,
-                &mut on_ok as *mut _ as *mut c_void,
-            );
-        }
-    }
-
-    pub fn backtrace_syminfo<F>(
-        state: &BacktraceState,
-        pc: usize,
-        mut on_ok: F,
-        on_error: backtrace_sys2::backtrace_error_callback,
-    ) where
-        F: FnMut(usize, *const c_char, usize, usize),
-    {
-        unsafe {
-            backtrace_sys2::backtrace_syminfo(
-                state.as_mut_ptr(),
-                pc,
-                Some(Self::backtrace_syminfo_trampoline::<F>),
-                on_error,
-                &mut on_ok as *mut _ as *mut c_void,
-            );
-        }
-    }
-
-    unsafe extern "C" fn backtrace_full_trampoline<F>(
-        user_data: *mut c_void,
-        pc: usize,
-        filename: *const c_char,
-        lineno: c_int,
-        function: *const c_char,
-    ) -> c_int
-    where
-        F: FnMut(usize, *const c_char, c_int, *const c_char) -> c_int,
-    {
-        let user_data = &mut *(user_data as *mut F);
-        user_data(pc, filename, lineno, function)
-    }
-
-    unsafe extern "C" fn backtrace_simple_trampoline<F>(user_data: *mut c_void, pc: usize) -> c_int
-    where
-        F: FnMut(usize) -> c_int,
-    {
-        let user_data = &mut *(user_data as *mut F);
-        user_data(pc)
-    }
-
-    unsafe extern "C" fn backtrace_syminfo_trampoline<F>(
-        user_data: *mut c_void,
-        pc: usize,
-        symname: *const c_char,
-        symval: usize,
-        symsize: usize,
-    ) where
-        F: FnMut(usize, *const c_char, usize, usize),
-    {
-        let user_data = &mut *(user_data as *mut F);
-        user_data(pc, symname, symval, symsize);
-    }
-
-    pub unsafe extern "C" fn backtrace_error_callback(
-        _data: *mut c_void,
-        msg: *const c_char,
-        errnum: c_int,
-    ) {
-        let msg = unsafe { CStr::from_ptr(msg) };
-        log::debug!("backtrace error: {:?} ({})", msg, errnum);
-    }
-}

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);
-}