pf2 0.8.0 → 1.0.0.alpha1

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

data/ext/pf2/src/session.rs

@@ -1,248 +0,0 @@
-pub mod configuration;
-mod new_thread_watcher;
-pub mod ruby_object;
-
-use std::collections::HashSet;
-use std::ffi::{c_int, CStr, CString};
-use std::str::FromStr as _;
-use std::sync::atomic::{AtomicBool, Ordering};
-use std::sync::{Arc, RwLock};
-use std::thread;
-use std::time::Duration;
-
-use rb_sys::*;
-
-use self::configuration::Configuration;
-use self::new_thread_watcher::NewThreadWatcher;
-use crate::profile::Profile;
-use crate::scheduler::Scheduler;
-#[cfg(target_os = "linux")]
-use crate::signal_scheduler::SignalScheduler;
-#[cfg(not(target_os = "linux"))]
-use crate::signal_scheduler_unsupported_platform::SignalScheduler;
-use crate::timer_thread_scheduler::TimerThreadScheduler;
-use crate::util::*;
-
-pub struct Session {
-    pub configuration: Configuration,
-    pub scheduler: Arc<dyn Scheduler>,
-    pub profile: Arc<RwLock<Profile>>,
-    pub running: Arc<AtomicBool>,
-    pub new_thread_watcher: Option<NewThreadWatcher>,
-}
-
-impl Session {
-    pub fn new_from_rb_initialize(argc: c_int, argv: *const VALUE, rbself: VALUE) -> Self {
-        // Parse arguments
-        let kwargs: VALUE = Qnil.into();
-        unsafe {
-            rb_scan_args(argc, argv, cstr!(":"), &kwargs);
-        };
-        let mut kwargs_values: [VALUE; 5] = [Qnil.into(); 5];
-        unsafe {
-            rb_get_kwargs(
-                kwargs,
-                [
-                    rb_intern(cstr!("interval_ms")),
-                    rb_intern(cstr!("threads")),
-                    rb_intern(cstr!("time_mode")),
-                    rb_intern(cstr!("scheduler")),
-                    rb_intern(cstr!("use_experimental_serializer")),
-                ]
-                .as_mut_ptr(),
-                0,
-                5,
-                kwargs_values.as_mut_ptr(),
-            );
-        };
-
-        let interval = Self::parse_option_interval_ms(kwargs_values[0]);
-        let threads = Self::parse_option_threads(kwargs_values[1]);
-        let time_mode = Self::parse_option_time_mode(kwargs_values[2]);
-        let scheduler = Self::parse_option_scheduler(kwargs_values[3]);
-        let use_experimental_serializer =
-            Self::parse_option_use_experimental_serializer(kwargs_values[4]);
-
-        let configuration = Configuration {
-            scheduler,
-            interval,
-            target_ruby_threads: threads.clone(),
-            time_mode,
-            use_experimental_serializer,
-        };
-
-        match configuration.validate() {
-            Ok(_) => {}
-            Err(msg) => unsafe {
-                rb_raise(rb_eArgError, CString::new(msg).unwrap().as_c_str().as_ptr());
-            },
-        };
-
-        // Store configuration as a Ruby Hash for convenience
-        unsafe {
-            rb_iv_set(rbself, cstr!("@configuration"), configuration.to_rb_hash());
-        }
-
-        // Create a new Profile
-        let profile = Arc::new(RwLock::new(Profile::new()));
-
-        // Initialize the specified Scheduler
-        let scheduler: Arc<dyn Scheduler> = match configuration.scheduler {
-            configuration::Scheduler::Signal => {
-                Arc::new(SignalScheduler::new(&configuration, Arc::clone(&profile)))
-            }
-            configuration::Scheduler::TimerThread => {
-                Arc::new(TimerThreadScheduler::new(&configuration, Arc::clone(&profile)))
-            }
-        };
-
-        let running = Arc::new(AtomicBool::new(false));
-
-        let new_thread_watcher = match threads {
-            configuration::Threads::All => {
-                let scheduler = Arc::clone(&scheduler);
-                let running = Arc::clone(&running);
-                Some(NewThreadWatcher::watch(move |thread: VALUE| {
-                    if running.load(Ordering::Relaxed) {
-                        log::debug!("New Ruby thread detected: {:?}", thread);
-                        scheduler.on_new_thread(thread);
-                    }
-                }))
-            }
-            configuration::Threads::Targeted(_) => None,
-        };
-
-        Session { configuration, scheduler, profile, running, new_thread_watcher }
-    }
-
-    fn parse_option_interval_ms(value: VALUE) -> Duration {
-        if value == Qundef as VALUE {
-            // Return default
-            return configuration::DEFAULT_INTERVAL;
-        }
-
-        let interval_ms = unsafe { rb_num2long(value) };
-        Duration::from_millis(interval_ms.try_into().unwrap_or_else(|_| {
-            eprintln!(
-                "[Pf2] Warning: Specified interval ({}) is not valid. Using default value (9ms).",
-                interval_ms
-            );
-            9
-        }))
-    }
-
-    fn parse_option_threads(value: VALUE) -> configuration::Threads {
-        if (value == Qundef as VALUE)
-            || (value == Qnil as VALUE)
-            || (value == unsafe { rb_id2sym(rb_intern(cstr!("all"))) })
-        {
-            return configuration::Threads::All;
-        }
-
-        let mut set: HashSet<VALUE> = HashSet::new();
-        unsafe {
-            for i in 0..RARRAY_LEN(value) {
-                set.insert(rb_ary_entry(value, i));
-            }
-        }
-        configuration::Threads::Targeted(set)
-    }
-
-    fn parse_option_time_mode(value: VALUE) -> configuration::TimeMode {
-        if value == Qundef as VALUE {
-            // Return default
-            return configuration::DEFAULT_TIME_MODE;
-        }
-
-        let specified_mode = unsafe {
-            let mut str = rb_funcall(value, rb_intern(cstr!("to_s")), 0);
-            let ptr = rb_string_value_ptr(&mut str);
-            CStr::from_ptr(ptr).to_str().unwrap()
-        };
-        configuration::TimeMode::from_str(specified_mode).unwrap_or_else(|_| {
-            // Raise an ArgumentError if the mode is invalid
-            unsafe {
-                rb_raise(
-                    rb_eArgError,
-                    cstr!("Invalid time mode. Valid values are 'cpu' and 'wall'."),
-                )
-            }
-        })
-    }
-
-    fn parse_option_scheduler(value: VALUE) -> configuration::Scheduler {
-        if value == Qundef as VALUE {
-            // Return default
-            return configuration::DEFAULT_SCHEDULER;
-        }
-
-        let specified_scheduler = unsafe {
-            let mut str = rb_funcall(value, rb_intern(cstr!("to_s")), 0);
-            let ptr = rb_string_value_ptr(&mut str);
-            CStr::from_ptr(ptr).to_str().unwrap()
-        };
-        let scheduler =
-            configuration::Scheduler::from_str(specified_scheduler).unwrap_or_else(|_| {
-                // Raise an ArgumentError if the mode is invalid
-                unsafe {
-                    rb_raise(
-                        rb_eArgError,
-                        cstr!("Invalid scheduler. Valid values are ':signal' and ':timer_thread'."),
-                    )
-                }
-            });
-
-        // Raise an ArgumentError if the scheduler is not supported on the current platform
-        if !cfg!(target_os = "linux") && scheduler == configuration::Scheduler::Signal {
-            unsafe {
-                rb_raise(rb_eArgError, cstr!("Signal scheduler is not supported on this platform."))
-            }
-        }
-        scheduler
-    }
-
-    fn parse_option_use_experimental_serializer(value: VALUE) -> bool {
-        if value == Qundef as VALUE {
-            return false;
-        }
-        RTEST(value)
-    }
-
-    pub fn start(&mut self) -> VALUE {
-        self.running.store(true, Ordering::Relaxed);
-        self.start_profile_buffer_flusher_thread();
-        self.scheduler.start()
-    }
-
-    fn start_profile_buffer_flusher_thread(&self) {
-        let profile = Arc::clone(&self.profile);
-        let running = Arc::clone(&self.running);
-        log::debug!("flusher: Starting");
-        thread::spawn(move || loop {
-            if !running.load(Ordering::Relaxed) {
-                log::debug!("flusher: Exiting");
-                break;
-            }
-
-            log::trace!("flusher: Flushing temporary sample buffer");
-            match profile.try_write() {
-                Ok(mut profile) => {
-                    profile.flush_temporary_sample_buffer();
-                }
-                Err(_) => {
-                    log::debug!("flusher: Failed to acquire profile lock");
-                }
-            }
-            thread::sleep(Duration::from_millis(500));
-        });
-    }
-
-    pub fn stop(&mut self) -> VALUE {
-        self.running.store(false, Ordering::Relaxed);
-        self.scheduler.stop()
-    }
-
-    pub fn dmark(&self) {
-        self.scheduler.dmark()
-    }
-}

data/ext/pf2/src/siginfo_t.c

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

data/ext/pf2/src/signal_scheduler.rs

@@ -1,201 +0,0 @@
-#![deny(unsafe_op_in_unsafe_fn)]
-
-use crate::profile::Profile;
-use crate::profile_serializer::ProfileSerializer;
-use crate::ruby_internal_apis::rb_thread_getcpuclockid;
-use crate::sample::Sample;
-use crate::scheduler::Scheduler;
-use crate::serialization::serializer::ProfileSerializer2;
-use crate::session::configuration::{self, Configuration};
-
-use core::panic;
-use std::ffi::{c_int, c_void, CString};
-use std::mem::ManuallyDrop;
-use std::sync::{Arc, RwLock};
-use std::{mem, ptr::null_mut};
-
-use rb_sys::*;
-
-use crate::util::*;
-
-#[derive(Debug)]
-pub struct SignalScheduler {
-    configuration: Configuration,
-    profile: Arc<RwLock<Profile>>,
-}
-
-pub struct SignalHandlerArgs {
-    profile: Arc<RwLock<Profile>>,
-    context_ruby_thread: VALUE,
-}
-
-impl Scheduler for SignalScheduler {
-    fn start(&self) -> VALUE {
-        self.install_signal_handler();
-
-        if let configuration::Threads::Targeted(threads) = &self.configuration.target_ruby_threads {
-            for ruby_thread in threads.iter() {
-                self.install_timer_to_ruby_thread(*ruby_thread);
-            }
-        }
-
-        Qtrue.into()
-    }
-
-    fn stop(&self) -> VALUE {
-        // Finalize
-        match self.profile.try_write() {
-            Ok(mut profile) => {
-                profile.flush_temporary_sample_buffer();
-                profile.end_instant = Some(std::time::Instant::now());
-            }
-            Err(_) => {
-                println!("[pf2 ERROR] stop: Failed to acquire profile lock.");
-                return Qfalse.into();
-            }
-        }
-
-        let profile = self.profile.try_read().unwrap();
-        log::debug!("Number of samples: {}", profile.samples.len());
-
-        if self.configuration.use_experimental_serializer {
-            let mut ser = ProfileSerializer2::new();
-            ser.serialize(&profile);
-            ser.to_ruby_hash()
-        } else {
-            let serialized = ProfileSerializer::serialize(&profile);
-            let string = CString::new(serialized).unwrap();
-            unsafe { rb_str_new_cstr(string.as_ptr()) }
-        }
-    }
-
-    fn on_new_thread(&self, thread: VALUE) {
-        self.install_timer_to_ruby_thread(thread);
-    }
-
-    fn dmark(&self) {
-        match self.profile.read() {
-            Ok(profile) => unsafe {
-                profile.dmark();
-            },
-            Err(_) => {
-                panic!("[pf2 FATAL] dmark: Failed to acquire profile lock.");
-            }
-        }
-    }
-
-    fn dfree(&self) {
-        // No-op
-    }
-
-    fn dsize(&self) -> size_t {
-        // FIXME: Report something better
-        mem::size_of::<Self>() as size_t
-    }
-}
-
-impl SignalScheduler {
-    pub fn new(configuration: &Configuration, profile: Arc<RwLock<Profile>>) -> Self {
-        Self { configuration: configuration.clone(), profile }
-    }
-
-    // Install signal handler for profiling events to the current process.
-    fn install_signal_handler(&self) {
-        let mut sa: libc::sigaction = unsafe { mem::zeroed() };
-        sa.sa_sigaction = Self::signal_handler as usize;
-        sa.sa_flags = libc::SA_SIGINFO;
-        let err = unsafe { libc::sigaction(libc::SIGALRM, &sa, null_mut()) };
-        if err != 0 {
-            panic!("sigaction failed: {}", err);
-        }
-        log::debug!("Signal handler installed");
-    }
-
-    // Respond to the signal and collect a sample.
-    // This function is called when a timer fires.
-    //
-    // Expected to be async-signal-safe, but the current implementation is not.
-    extern "C" fn signal_handler(
-        _sig: c_int,
-        info: *mut libc::siginfo_t,
-        _ucontext: *mut libc::ucontext_t,
-    ) {
-        let args = unsafe {
-            let ptr = extract_si_value_sival_ptr(info) as *mut SignalHandlerArgs;
-            ManuallyDrop::new(Box::from_raw(ptr))
-        };
-
-        let mut profile = match args.profile.try_write() {
-            Ok(profile) => profile,
-            Err(_) => {
-                // FIXME: Do we want to properly collect GC samples? I don't know yet.
-                log::trace!("Failed to acquire profile lock (garbage collection possibly in progress). Dropping sample.");
-                return;
-            }
-        };
-
-        let sample = Sample::capture(args.context_ruby_thread, &profile.backtrace_state); // NOT async-signal-safe
-        if profile.temporary_sample_buffer.push(sample).is_err() {
-            log::debug!("Temporary sample buffer full. Dropping sample.");
-        }
-    }
-
-    fn install_timer_to_ruby_thread(&self, ruby_thread: VALUE) {
-        // NOTE: This Box never gets dropped
-        let signal_handler_args = Box::new(SignalHandlerArgs {
-            profile: Arc::clone(&self.profile),
-            context_ruby_thread: ruby_thread,
-        });
-
-        // rb_funcall deadlocks when called within a THREAD_EVENT_STARTED hook
-        let kernel_thread_id: i32 = i32::try_from(unsafe {
-            rb_num2int(rb_funcall(
-                ruby_thread,
-                rb_intern(cstr!("native_thread_id")), // kernel thread ID
-                0,
-            ))
-        })
-        .unwrap();
-
-        // Create a signal event
-        let mut sigevent: libc::sigevent = unsafe { mem::zeroed() };
-        // Note: SIGEV_THREAD_ID is Linux-specific. In other platforms, we would need to
-        // "trampoline" the signal as any pthread can receive the signal.
-        sigevent.sigev_notify = libc::SIGEV_THREAD_ID;
-        sigevent.sigev_notify_thread_id = kernel_thread_id;
-        sigevent.sigev_signo = libc::SIGALRM;
-        // Pass required args to the signal handler
-        sigevent.sigev_value.sival_ptr = Box::into_raw(signal_handler_args) as *mut c_void;
-
-        // Create and configure timer to fire every _interval_ ms of CPU time
-        let mut timer: libc::timer_t = unsafe { mem::zeroed() };
-        let clockid = match self.configuration.time_mode {
-            configuration::TimeMode::CpuTime => unsafe { rb_thread_getcpuclockid(ruby_thread) },
-            configuration::TimeMode::WallTime => libc::CLOCK_MONOTONIC,
-        };
-        let err = unsafe { libc::timer_create(clockid, &mut sigevent, &mut timer) };
-        if err != 0 {
-            panic!("timer_create failed: {}", err);
-        }
-        let itimerspec = Self::duration_to_itimerspec(&self.configuration.interval);
-        let err = unsafe { libc::timer_settime(timer, 0, &itimerspec, null_mut()) };
-        if err != 0 {
-            panic!("timer_settime failed: {}", err);
-        }
-
-        log::debug!("timer registered for thread {}", ruby_thread);
-    }
-
-    fn duration_to_itimerspec(duration: &std::time::Duration) -> libc::itimerspec {
-        let nanos = duration.as_nanos();
-        let seconds_part: i64 = (nanos / 1_000_000_000).try_into().unwrap();
-        let nanos_part: i64 = (nanos % 1_000_000_000).try_into().unwrap();
-
-        let mut its: libc::itimerspec = unsafe { mem::zeroed() };
-        its.it_interval.tv_sec = seconds_part;
-        its.it_interval.tv_nsec = nanos_part;
-        its.it_value.tv_sec = seconds_part;
-        its.it_value.tv_nsec = nanos_part;
-        its
-    }
-}

data/ext/pf2/src/signal_scheduler_unsupported_platform.rs

@@ -1,39 +0,0 @@
-use std::sync::{Arc, RwLock};
-
-use crate::profile::Profile;
-use crate::scheduler::Scheduler;
-use crate::session::configuration::Configuration;
-
-pub struct SignalScheduler {}
-
-impl Scheduler for SignalScheduler {
-    fn start(&self) -> rb_sys::VALUE {
-        unimplemented!()
-    }
-
-    fn stop(&self) -> rb_sys::VALUE {
-        unimplemented!()
-    }
-
-    fn on_new_thread(&self, thread: rb_sys::VALUE) {
-        unimplemented!()
-    }
-
-    fn dmark(&self) {
-        unimplemented!()
-    }
-
-    fn dfree(&self) {
-        unimplemented!()
-    }
-
-    fn dsize(&self) -> rb_sys::size_t {
-        unimplemented!()
-    }
-}
-
-impl SignalScheduler {
-    pub fn new(configuration: &Configuration, profile: Arc<RwLock<Profile>>) -> Self {
-        unimplemented!()
-    }
-}