pf2 0.9.0 → 0.10.0

data/ext/pf2/src/serialization/profile.rs

@@ -1,48 +0,0 @@
-#[derive(Clone, Deserialize, Serialize)]
-pub struct Profile {
-    pub samples: Vec<Sample>,
-    pub locations: Vec<Location>,
-    pub functions: Vec<Function>,
-    pub start_timestamp_ns: u128,
-    pub duration_ns: u128,
-}
-
-pub type LocationIndex = usize;
-pub type FunctionIndex = usize;
-
-/// Sample
-#[derive(Clone, Serialize, Deserialize)]
-pub struct Sample {
-    /// The stack leading to this sample.
-    /// The leaf node will be stored at `stack[0]`.
-    pub stack: Vec<LocationIndex>,
-    pub native_stack: Vec<LocationIndex>,
-    pub ruby_thread_id: Option<u64>,
-    pub elapsed_ns: u64,
-}
-
-/// Location represents a location (line) in the source code when a sample was captured.
-#[derive(Clone, PartialEq, Serialize, Deserialize)]
-pub struct Location {
-    pub function_index: FunctionIndex,
-    pub lineno: i32,
-    pub address: Option<usize>,
-}
-
-/// Function represents a Ruby method or a C function in the profile.
-#[derive(Clone, PartialEq, Serialize, Deserialize)]
-pub struct Function {
-    pub implementation: FunctionImplementation,
-    pub name: Option<String>, // unique key
-    pub filename: Option<String>,
-    /// The first line number in the method/function definition.
-    /// For the actual location (line) which was hit during sample capture, refer to `Location.lineno`.
-    pub start_lineno: Option<i32>,
-    pub start_address: Option<usize>,
-}
-
-#[derive(Clone, PartialEq, Serialize, Deserialize)]
-pub enum FunctionImplementation {
-    Ruby,
-    Native,
-}

data/ext/pf2/src/serialization/serializer.rs

@@ -1,329 +0,0 @@
-use std::ffi::{c_char, CStr, CString};
-
-use rb_sys::*;
-
-use super::profile::{
-    Function, FunctionImplementation, FunctionIndex, Location, LocationIndex, Profile, Sample,
-};
-use crate::backtrace::Backtrace;
-use crate::util::{cstr, RTEST};
-
-pub struct ProfileSerializer2 {
-    profile: Profile,
-}
-
-impl ProfileSerializer2 {
-    pub fn new() -> ProfileSerializer2 {
-        ProfileSerializer2 {
-            profile: Profile {
-                start_timestamp_ns: 0,
-                duration_ns: 0,
-                samples: vec![],
-                locations: vec![],
-                functions: vec![],
-            },
-        }
-    }
-
-    pub fn serialize(&mut self, source: &crate::profile::Profile) {
-        // Fill in meta fields
-        self.profile.start_timestamp_ns =
-            source.start_timestamp.duration_since(std::time::UNIX_EPOCH).unwrap().as_nanos();
-        self.profile.duration_ns =
-            source.end_instant.unwrap().duration_since(source.start_instant).as_nanos();
-
-        // Create a Sample for each sample collected
-        for sample in source.samples.iter() {
-            // Iterate over the Ruby stack
-            let mut stack: Vec<LocationIndex> = vec![];
-            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 function = Self::extract_function_from_ruby_frame(frame);
-
-                let function_index = self.function_index_for(function);
-                let location_index = self.location_index_for(function_index, lineno);
-                stack.push(location_index);
-            }
-
-            // Iterate over the native stack
-            let mut native_stack: Vec<LocationIndex> = vec![];
-            let native_stack_depth = sample.c_backtrace_pcs[0];
-            for i in 1..(native_stack_depth - 1) {
-                let pc = sample.c_backtrace_pcs[i];
-                let function = Self::extract_function_from_native_pc(pc, source);
-
-                let function_index = self.function_index_for(function);
-                let location_index = self.location_index_for(function_index, 0);
-                native_stack.push(location_index);
-            }
-
-            self.profile.samples.push(Sample {
-                stack,
-                native_stack,
-                ruby_thread_id: Some(sample.ruby_thread),
-                elapsed_ns: sample.timestamp.duration_since(source.start_instant).as_nanos() as u64,
-            });
-        }
-    }
-
-    /// Returns the index of the function in `functions`.
-    /// Calling this method will modify `self.profile` in place.
-    fn function_index_for(&mut self, function: Function) -> FunctionIndex {
-        match self.profile.functions.iter_mut().position(|f| *f == function) {
-            Some(index) => index,
-            None => {
-                self.profile.functions.push(function);
-                self.profile.functions.len() - 1
-            }
-        }
-    }
-
-    /// Returns the index of the location in `locations`.
-    /// Calling this method will modify `self.profile` in place.
-    fn location_index_for(&mut self, function_index: FunctionIndex, lineno: i32) -> LocationIndex {
-        // Build a Location based on (1) the Function and (2) the actual line hit during sampling.
-        let location = Location { function_index, lineno, address: None };
-        match self.profile.locations.iter_mut().position(|l| *l == location) {
-            Some(index) => index,
-            None => {
-                self.profile.locations.push(location);
-                self.profile.locations.len() - 1
-            }
-        }
-    }
-
-    /// Build a Function from a Ruby frame.
-    fn extract_function_from_ruby_frame(frame: VALUE) -> Function {
-        unsafe {
-            let mut frame_full_label: VALUE = rb_profile_frame_full_label(frame);
-            let frame_full_label: Option<String> = if RTEST(frame_full_label) {
-                Some(
-                    CStr::from_ptr(rb_string_value_cstr(&mut frame_full_label))
-                        .to_str()
-                        .unwrap()
-                        .to_owned(),
-                )
-            } else {
-                None
-            };
-
-            let mut frame_path: VALUE = rb_profile_frame_path(frame);
-            let frame_path: Option<String> = if RTEST(frame_path) {
-                Some(
-                    CStr::from_ptr(rb_string_value_cstr(&mut frame_path))
-                        .to_str()
-                        .unwrap()
-                        .to_owned(),
-                )
-            } else {
-                None
-            };
-
-            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
-            };
-
-            let start_address = Self::get_underlying_c_function_address(frame);
-
-            Function {
-                implementation: FunctionImplementation::Ruby,
-                name: frame_full_label,
-                filename: frame_path,
-                start_lineno: frame_first_lineno,
-                start_address,
-            }
-        }
-    }
-
-    fn get_underlying_c_function_address(frame: VALUE) -> Option<usize> {
-        unsafe {
-            let cme = frame as *mut crate::ruby_internal_apis::rb_callable_method_entry_struct;
-            let cme = &*cme; // *mut to reference
-
-            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
-            }
-        }
-    }
-
-    /// Build a Function from a PC (program counter) obtained by libbacktrace.
-    fn extract_function_from_native_pc(pc: usize, source: &crate::profile::Profile) -> Function {
-        // Obtain the function name and address using libbacktrace
-        let mut function: Option<Function> = None;
-        Backtrace::backtrace_syminfo(
-            &source.backtrace_state,
-            pc,
-            |_pc: usize, symname: *const c_char, symval: usize, _symsize: usize| unsafe {
-                function = Some(Function {
-                    implementation: FunctionImplementation::Native,
-                    name: if symname.is_null() {
-                        None
-                    } else {
-                        Some(CStr::from_ptr(symname).to_str().unwrap().to_owned())
-                    },
-                    filename: None,
-                    start_lineno: None,
-                    start_address: Some(symval),
-                });
-            },
-            Some(Backtrace::backtrace_error_callback),
-        );
-        function.unwrap()
-    }
-
-    pub fn to_ruby_hash(&self) -> VALUE {
-        unsafe {
-            let hash: VALUE = rb_hash_new();
-
-            // profile[:start_timestamp_ns]
-            rb_hash_aset(
-                hash,
-                rb_id2sym(rb_intern(cstr!("start_timestamp_ns"))),
-                rb_int2inum(self.profile.start_timestamp_ns as isize),
-            );
-            // profile[:duration_ns]
-            rb_hash_aset(
-                hash,
-                rb_id2sym(rb_intern(cstr!("duration_ns"))),
-                rb_int2inum(self.profile.duration_ns as isize),
-            );
-
-            // profile[:samples]
-            let samples: VALUE = rb_ary_new();
-            for sample in self.profile.samples.iter() {
-                // sample[:stack]
-                let stack: VALUE = rb_ary_new();
-                for &location_index in sample.stack.iter() {
-                    rb_ary_push(stack, rb_int2inum(location_index as isize));
-                }
-                // sample[:native_stack]
-                let native_stack: VALUE = rb_ary_new();
-                for &location_index in sample.native_stack.iter() {
-                    rb_ary_push(native_stack, rb_int2inum(location_index as isize));
-                }
-                // sample[:ruby_thread_id]
-                let ruby_thread_id = if let Some(ruby_thread_id) = sample.ruby_thread_id {
-                    rb_int2inum(ruby_thread_id as isize)
-                } else {
-                    Qnil as VALUE
-                };
-                // sample[:elapsed_ns]
-                let elapsed_ns = rb_ull2inum(sample.elapsed_ns);
-
-                let sample_hash: VALUE = rb_hash_new();
-                rb_hash_aset(sample_hash, rb_id2sym(rb_intern(cstr!("stack"))), stack);
-                rb_hash_aset(
-                    sample_hash,
-                    rb_id2sym(rb_intern(cstr!("native_stack"))),
-                    native_stack,
-                );
-                rb_hash_aset(
-                    sample_hash,
-                    rb_id2sym(rb_intern(cstr!("ruby_thread_id"))),
-                    ruby_thread_id,
-                );
-                rb_hash_aset(sample_hash, rb_id2sym(rb_intern(cstr!("elapsed_ns"))), elapsed_ns);
-
-                rb_ary_push(samples, sample_hash);
-            }
-            rb_hash_aset(hash, rb_id2sym(rb_intern(cstr!("samples"))), samples);
-
-            // profile[:locations]
-            let locations = rb_ary_new();
-            for location in self.profile.locations.iter() {
-                let location_hash: VALUE = rb_hash_new();
-                // location[:function_index]
-                rb_hash_aset(
-                    location_hash,
-                    rb_id2sym(rb_intern(cstr!("function_index"))),
-                    rb_int2inum(location.function_index as isize),
-                );
-                // location[:lineno]
-                rb_hash_aset(
-                    location_hash,
-                    rb_id2sym(rb_intern(cstr!("lineno"))),
-                    rb_int2inum(location.lineno as isize),
-                );
-                // location[:address]
-                rb_hash_aset(
-                    location_hash,
-                    rb_id2sym(rb_intern(cstr!("address"))),
-                    if let Some(address) = location.address {
-                        rb_int2inum(address as isize)
-                    } else {
-                        Qnil as VALUE
-                    },
-                );
-                rb_ary_push(locations, location_hash);
-            }
-            rb_hash_aset(hash, rb_id2sym(rb_intern(cstr!("locations"))), locations);
-
-            // profile[:functions]
-            let functions = rb_ary_new();
-            for function in self.profile.functions.iter() {
-                let function_hash: VALUE = rb_hash_new();
-                // function[:implementation]
-                rb_hash_aset(
-                    function_hash,
-                    rb_id2sym(rb_intern(cstr!("implementation"))),
-                    match function.implementation {
-                        FunctionImplementation::Ruby => rb_id2sym(rb_intern(cstr!("ruby"))),
-                        FunctionImplementation::Native => rb_id2sym(rb_intern(cstr!("native"))),
-                    },
-                );
-
-                // function[:name]
-                let name: VALUE = match &function.name {
-                    Some(name) => {
-                        let cstring = CString::new(name.as_str()).unwrap();
-                        rb_str_new_cstr(cstring.as_ptr())
-                    }
-                    None => Qnil as VALUE,
-                };
-                rb_hash_aset(function_hash, rb_id2sym(rb_intern(cstr!("name"))), name);
-                // function[:filename]
-                let filename: VALUE = match &function.filename {
-                    Some(filename) => {
-                        let cstring = CString::new(filename.as_str()).unwrap();
-                        rb_str_new_cstr(cstring.as_ptr())
-                    }
-                    None => Qnil as VALUE,
-                };
-                rb_hash_aset(function_hash, rb_id2sym(rb_intern(cstr!("filename"))), filename);
-                // function[:start_lineno]
-                rb_hash_aset(
-                    function_hash,
-                    rb_id2sym(rb_intern(cstr!("start_lineno"))),
-                    if let Some(start_lineno) = function.start_lineno {
-                        rb_int2inum(start_lineno as isize)
-                    } else {
-                        Qnil as VALUE
-                    },
-                );
-                // function[:start_address]
-                rb_hash_aset(
-                    function_hash,
-                    rb_id2sym(rb_intern(cstr!("start_address"))),
-                    if let Some(start_address) = function.start_address {
-                        rb_int2inum(start_address as isize)
-                    } else {
-                        Qnil as VALUE
-                    },
-                );
-                rb_ary_push(functions, function_hash);
-            }
-            rb_hash_aset(hash, rb_id2sym(rb_intern(cstr!("functions"))), functions);
-
-            hash
-        }
-    }
-}

data/ext/pf2/src/serialization.rs

@@ -1,2 +0,0 @@
-pub mod profile;
-pub mod serializer;

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

@@ -1,114 +0,0 @@
-use std::collections::HashSet;
-use std::str::FromStr;
-use std::time::Duration;
-
-use rb_sys::*;
-
-use crate::util::cstr;
-
-#[cfg(target_os = "linux")]
-pub const DEFAULT_SCHEDULER: Scheduler = Scheduler::Signal;
-#[cfg(target_os = "linux")]
-pub const DEFAULT_TIME_MODE: TimeMode = TimeMode::CpuTime;
-#[cfg(not(target_os = "linux"))]
-pub const DEFAULT_SCHEDULER: Scheduler = Scheduler::TimerThread;
-#[cfg(not(target_os = "linux"))]
-pub const DEFAULT_TIME_MODE: TimeMode = TimeMode::WallTime;
-
-pub const DEFAULT_INTERVAL: Duration = Duration::from_millis(9);
-
-#[derive(Clone, Debug)]
-pub struct Configuration {
-    pub scheduler: Scheduler,
-    pub interval: Duration,
-    pub time_mode: TimeMode,
-    pub target_ruby_threads: Threads,
-    pub use_experimental_serializer: bool,
-}
-
-#[derive(Clone, Debug, PartialEq)]
-pub enum Scheduler {
-    Signal,
-    TimerThread,
-}
-
-impl FromStr for Scheduler {
-    type Err = ();
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        match s {
-            "signal" => Ok(Self::Signal),
-            "timer_thread" => Ok(Self::TimerThread),
-            _ => Err(()),
-        }
-    }
-}
-
-#[derive(Clone, Debug, PartialEq)]
-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(()),
-        }
-    }
-}
-
-#[derive(Clone, Debug, PartialEq)]
-pub enum Threads {
-    All,
-    Targeted(HashSet<VALUE>),
-}
-
-impl Configuration {
-    pub fn validate(&self) -> Result<(), String> {
-        if self.scheduler == Scheduler::TimerThread && self.time_mode == TimeMode::CpuTime {
-            return Err("TimerThread scheduler does not support `time_mode: :cpu`.".to_owned());
-        }
-        if self.scheduler == Scheduler::TimerThread && self.target_ruby_threads == Threads::All {
-            return Err(concat!(
-                "TimerThread scheduler does not support `threads: :all` at the moment. ",
-                "Consider using `threads: Thread.list` for watching all threads at profiler start."
-            )
-            .to_owned());
-        }
-
-        Ok(())
-    }
-
-    pub fn to_rb_hash(&self) -> VALUE {
-        let hash: VALUE = unsafe { rb_hash_new() };
-        unsafe {
-            rb_hash_aset(
-                hash,
-                rb_id2sym(rb_intern(cstr!("scheduler"))),
-                rb_id2sym(rb_intern(match self.scheduler {
-                    Scheduler::Signal => cstr!("signal"),
-                    Scheduler::TimerThread => cstr!("timer_thread"),
-                })),
-            );
-            rb_hash_aset(
-                hash,
-                rb_id2sym(rb_intern(cstr!("interval_ms"))),
-                rb_int2inum(self.interval.as_millis().try_into().unwrap()),
-            );
-            rb_hash_aset(
-                hash,
-                rb_id2sym(rb_intern(cstr!("time_mode"))),
-                rb_id2sym(rb_intern(match self.time_mode {
-                    TimeMode::CpuTime => cstr!("cpu"),
-                    TimeMode::WallTime => cstr!("wall"),
-                })),
-            );
-        }
-        hash
-    }
-}

data/ext/pf2/src/session/new_thread_watcher.rs

@@ -1,80 +0,0 @@
-use std::collections::HashSet;
-use std::ffi::c_void;
-use std::mem::ManuallyDrop;
-use std::ptr::null_mut;
-use std::rc::Rc;
-use std::sync::Mutex;
-
-use rb_sys::*;
-
-/// A helper to watch new Ruby threads.
-///
-/// `NewThreadWatcher` operates on the Events Hooks API.
-/// Instead of relying on the `THREAD_EVENT_STARTED` event, it combines the
-/// `THREAD_EVENT_RESUMED` event and an internal _known-threads_ record.
-///
-/// This is to support operations requiring the underlying pthread. Ruby Threads
-/// are not guaranteed to be fully initialized at the time
-/// `THREAD_EVENT_STARTED` is triggered; i.e. the underlying pthread has not
-/// been created yet and `Thread#native_thread_id` returns `nil`.
-pub struct NewThreadWatcher {
-    inner: Rc<Mutex<Inner>>,
-    event_hook: *mut rb_internal_thread_event_hook_t,
-}
-
-struct Inner {
-    known_threads: HashSet<VALUE>,
-    on_new_thread: Box<dyn Fn(VALUE)>,
-}
-
-impl NewThreadWatcher {
-    pub fn watch<F>(callback: F) -> Self
-    where
-        F: Fn(VALUE) + 'static,
-    {
-        let mut watcher = Self {
-            inner: Rc::new(Mutex::new(Inner {
-                known_threads: HashSet::new(),
-                on_new_thread: Box::new(callback),
-            })),
-            event_hook: null_mut(),
-        };
-
-        let inner_ptr = Rc::into_raw(Rc::clone(&watcher.inner));
-        unsafe {
-            watcher.event_hook = rb_internal_thread_add_event_hook(
-                Some(Self::on_thread_resume),
-                RUBY_INTERNAL_THREAD_EVENT_RESUMED,
-                inner_ptr as *mut c_void,
-            );
-        };
-
-        watcher
-    }
-
-    unsafe extern "C" fn on_thread_resume(
-        _flag: rb_event_flag_t,
-        data: *const rb_internal_thread_event_data_t,
-        custom_data: *mut c_void,
-    ) {
-        let ruby_thread: VALUE = unsafe { (*data).thread };
-
-        // A pointer to Box<Inner> is passed as custom_data
-        let inner = unsafe { ManuallyDrop::new(Box::from_raw(custom_data as *mut Mutex<Inner>)) };
-        let mut inner = inner.lock().unwrap();
-
-        if !inner.known_threads.contains(&ruby_thread) {
-            inner.known_threads.insert(ruby_thread);
-            (inner.on_new_thread)(ruby_thread);
-        }
-    }
-}
-
-impl Drop for NewThreadWatcher {
-    fn drop(&mut self) {
-        log::trace!("Cleaning up event hook");
-        unsafe {
-            rb_internal_thread_remove_event_hook(self.event_hook);
-        }
-    }
-}

data/ext/pf2/src/session/ruby_object.rs

@@ -1,90 +0,0 @@
-use std::ffi::{c_int, c_void};
-use std::mem;
-use std::mem::ManuallyDrop;
-use std::ptr::{addr_of, null_mut};
-
-use rb_sys::*;
-
-use crate::util::cstr;
-
-use super::Session;
-
-pub struct SessionRubyObject {
-    session: Option<Session>,
-}
-
-impl SessionRubyObject {
-    pub unsafe extern "C" fn rb_initialize(
-        argc: c_int,
-        argv: *const VALUE,
-        rbself: VALUE,
-    ) -> VALUE {
-        let mut obj = unsafe { Self::get_struct_from(rbself) };
-        obj.session = Some(Session::new_from_rb_initialize(argc, argv, rbself));
-        Qnil.into()
-    }
-
-    pub unsafe extern "C" fn rb_start(rbself: VALUE) -> VALUE {
-        let mut obj = Self::get_struct_from(rbself);
-        match &mut obj.session {
-            Some(session) => session.start(),
-            None => panic!("Session is not initialized"),
-        }
-    }
-
-    pub unsafe extern "C" fn rb_stop(rbself: VALUE) -> VALUE {
-        let mut obj = Self::get_struct_from(rbself);
-        match &mut obj.session {
-            Some(session) => session.stop(),
-            None => panic!("Session is not initialized"),
-        }
-    }
-
-    // Extract the SessionRubyObject struct from a Ruby object
-    unsafe fn get_struct_from(obj: VALUE) -> ManuallyDrop<Box<Self>> {
-        unsafe {
-            let ptr = rb_check_typeddata(obj, addr_of!(RBDATA));
-            ManuallyDrop::new(Box::from_raw(ptr as *mut SessionRubyObject))
-        }
-    }
-
-    #[allow(non_snake_case)]
-    pub unsafe extern "C" fn rb_alloc(_rbself: VALUE) -> VALUE {
-        let obj = Box::new(SessionRubyObject { session: None });
-
-        let rb_mPf2: VALUE = rb_define_module(cstr!("Pf2"));
-        let rb_cSession = rb_define_class_under(rb_mPf2, cstr!("Session"), rb_cObject);
-        // Wrap the struct into a Ruby object
-        rb_data_typed_object_wrap(rb_cSession, Box::into_raw(obj) as *mut c_void, addr_of!(RBDATA))
-    }
-
-    unsafe extern "C" fn dmark(ptr: *mut c_void) {
-        let obj = ManuallyDrop::new(Box::from_raw(ptr as *mut SessionRubyObject));
-        if let Some(session) = &obj.session {
-            session.dmark()
-        }
-    }
-
-    unsafe extern "C" fn dfree(ptr: *mut c_void) {
-        drop(Box::from_raw(ptr as *mut SessionRubyObject));
-    }
-
-    unsafe extern "C" fn dsize(_: *const c_void) -> size_t {
-        // FIXME: Report something better
-        mem::size_of::<SessionRubyObject>() as size_t
-    }
-}
-
-static mut RBDATA: rb_data_type_t = rb_data_type_t {
-    wrap_struct_name: cstr!("SessionRubyObject"),
-    function: rb_data_type_struct__bindgen_ty_1 {
-        dmark: Some(SessionRubyObject::dmark),
-        dfree: Some(SessionRubyObject::dfree),
-        dsize: Some(SessionRubyObject::dsize),
-        dcompact: None,
-        reserved: [null_mut(); 1],
-    },
-    parent: null_mut(),
-    data: null_mut(),
-    flags: 0,
-};