pf2 0.5.2 → 0.7.0

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

@@ -0,0 +1,325 @@
+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),
+            });
+        }
+    }
+
+    /// 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
+                };
+
+                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_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

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

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

@@ -15,7 +15,7 @@ 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(49);
+pub const DEFAULT_INTERVAL: Duration = Duration::from_millis(9);
 
 #[derive(Clone, Debug)]
 pub struct Configuration {
@@ -23,6 +23,7 @@ pub struct Configuration {
     pub interval: Duration,
     pub time_mode: TimeMode,
     pub target_ruby_threads: Threads,
+    pub use_experimental_serializer: bool,
 }
 
 #[derive(Clone, Debug, PartialEq)]

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

@@ -54,7 +54,7 @@ impl NewThreadWatcher {
 
     unsafe extern "C" fn on_thread_resume(
         _flag: rb_event_flag_t,
-        data: *const rb_internal_thread_event_data,
+        data: *const rb_internal_thread_event_data_t,
         custom_data: *mut c_void,
     ) {
         let ruby_thread: VALUE = unsafe { (*data).thread };

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

@@ -55,11 +55,7 @@ impl SessionRubyObject {
         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),
-        )
+        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) {

data/ext/pf2/src/session.rs

@@ -38,7 +38,7 @@ impl Session {
         unsafe {
             rb_scan_args(argc, argv, cstr!(":"), &kwargs);
         };
-        let mut kwargs_values: [VALUE; 4] = [Qnil.into(); 4];
+        let mut kwargs_values: [VALUE; 5] = [Qnil.into(); 5];
         unsafe {
             rb_get_kwargs(
                 kwargs,
@@ -47,10 +47,11 @@ impl Session {
                     rb_intern(cstr!("threads")),
                     rb_intern(cstr!("time_mode")),
                     rb_intern(cstr!("scheduler")),
+                    rb_intern(cstr!("use_experimental_serializer")),
                 ]
                 .as_mut_ptr(),
                 0,
-                4,
+                5,
                 kwargs_values.as_mut_ptr(),
             );
         };
@@ -59,12 +60,15 @@ impl Session {
         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() {
@@ -87,10 +91,9 @@ impl Session {
             configuration::Scheduler::Signal => {
                 Arc::new(SignalScheduler::new(&configuration, Arc::clone(&profile)))
             }
-            configuration::Scheduler::TimerThread => Arc::new(TimerThreadScheduler::new(
-                &configuration,
-                Arc::clone(&profile),
-            )),
+            configuration::Scheduler::TimerThread => {
+                Arc::new(TimerThreadScheduler::new(&configuration, Arc::clone(&profile)))
+            }
         };
 
         let running = Arc::new(AtomicBool::new(false));
@@ -109,13 +112,7 @@ impl Session {
             configuration::Threads::Targeted(_) => None,
         };
 
-        Session {
-            configuration,
-            scheduler,
-            profile,
-            running,
-            new_thread_watcher,
-        }
+        Session { configuration, scheduler, profile, running, new_thread_watcher }
     }
 
     fn parse_option_interval_ms(value: VALUE) -> Duration {
@@ -127,10 +124,10 @@ impl Session {
         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 (49ms).",
+                "[Pf2] Warning: Specified interval ({}) is not valid. Using default value (9ms).",
                 interval_ms
             );
-            49
+            9
         }))
     }
 
@@ -198,15 +195,19 @@ impl Session {
         // 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."),
-                )
+                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();

data/ext/pf2/src/signal_scheduler.rs

@@ -5,6 +5,7 @@ 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;
@@ -46,6 +47,7 @@ impl Scheduler for SignalScheduler {
         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.");
@@ -56,9 +58,15 @@ impl Scheduler for SignalScheduler {
         let profile = self.profile.try_read().unwrap();
         log::debug!("Number of samples: {}", profile.samples.len());
 
-        let serialized = ProfileSerializer::serialize(&profile);
-        let serialized = CString::new(serialized).unwrap();
-        unsafe { rb_str_new_cstr(serialized.as_ptr()) }
+        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) {
@@ -88,10 +96,7 @@ impl Scheduler for SignalScheduler {
 
 impl SignalScheduler {
     pub fn new(configuration: &Configuration, profile: Arc<RwLock<Profile>>) -> Self {
-        Self {
-            configuration: configuration.clone(),
-            profile,
-        }
+        Self { configuration: configuration.clone(), profile }
     }
 
     // Install signal handler for profiling events to the current process.

data/ext/pf2/src/timer_thread_scheduler.rs

@@ -12,6 +12,7 @@ use crate::profile::Profile;
 use crate::profile_serializer::ProfileSerializer;
 use crate::sample::Sample;
 use crate::scheduler::Scheduler;
+use crate::serialization::serializer::ProfileSerializer2;
 use crate::session::configuration::{self, Configuration};
 use crate::util::*;
 
@@ -61,6 +62,7 @@ impl Scheduler for TimerThreadScheduler {
         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.");
@@ -71,9 +73,15 @@ impl Scheduler for TimerThreadScheduler {
         let profile = self.profile.try_read().unwrap();
         log::debug!("Number of samples: {}", profile.samples.len());
 
-        let serialized = ProfileSerializer::serialize(&profile);
-        let serialized = CString::new(serialized).unwrap();
-        unsafe { rb_str_new_cstr(serialized.as_ptr()) }
+        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) {

data/lib/pf2/cli.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'optparse'
 
 require 'pf2'
@@ -55,7 +57,7 @@ module Pf2
       option_parser.parse!(argv)
 
       profile = JSON.parse(File.read(argv[0]), symbolize_names: true, max_nesting: false)
-      report = JSON.generate(Pf2::Reporter.new(profile).emit)
+      report = JSON.generate(Pf2::Reporter::FirefoxProfiler.new(profile).emit)
 
       if options[:output_file]
         File.write(options[:output_file], report)