pf2 0.6.0 → 0.7.0

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

@@ -1,9 +1,12 @@
-use std::ffi::CStr;
+use std::ffi::{c_char, CStr, CString};
 
 use rb_sys::*;
 
-use super::profile::{Function, FunctionImplementation, Location, LocationIndex, Profile, Sample};
-use crate::util::RTEST;
+use super::profile::{
+    Function, FunctionImplementation, FunctionIndex, Location, LocationIndex, Profile, Sample,
+};
+use crate::backtrace::Backtrace;
+use crate::util::{cstr, RTEST};
 
 pub struct ProfileSerializer2 {
     profile: Profile,
@@ -22,77 +25,66 @@ impl ProfileSerializer2 {
         }
     }
 
-    pub fn serialize(&mut self, source: &crate::profile::Profile) -> String {
+    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();
+        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() {
-            let mut stack: Vec<LocationIndex> = vec![];
-
             // 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);
 
-                // Get the Location corresponding to the frame.
-                let location_index = self.process_ruby_frame(frame, lineno);
-
+                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),
             });
         }
-
-        serde_json::to_string(&self.profile).unwrap()
     }
 
-    /// Process a collected Ruby frame.
+    /// Returns the index of the function in `functions`.
     /// Calling this method will modify `self.profile` in place.
-    ///
-    /// Returns the index of the location in `locations`.
-    fn process_ruby_frame(&mut self, frame: VALUE, lineno: i32) -> LocationIndex {
-        // Build a Function corresponding to the frame, and get the index in `functions`
-        let function = Self::extract_function_from_frame(frame);
-        let function_index = match self
-            .profile
-            .functions
-            .iter_mut()
-            .position(|f| *f == function)
-        {
+    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,
-        };
-        // Get the index of the location in `locations`
-        match self
-            .profile
-            .locations
-            .iter_mut()
-            .position(|l| *l == location)
-        {
+        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);
@@ -101,7 +93,8 @@ impl ProfileSerializer2 {
         }
     }
 
-    fn extract_function_from_frame(frame: VALUE) -> Function {
+    /// 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) {
@@ -134,13 +127,199 @@ impl ProfileSerializer2 {
                 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: None,
+                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/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

@@ -91,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));
@@ -113,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 {
@@ -202,10 +195,7 @@ 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

data/ext/pf2/src/signal_scheduler.rs

@@ -58,13 +58,15 @@ impl Scheduler for SignalScheduler {
         let profile = self.profile.try_read().unwrap();
         log::debug!("Number of samples: {}", profile.samples.len());
 
-        let serialized = if self.configuration.use_experimental_serializer {
-            ProfileSerializer2::new().serialize(&profile)
+        if self.configuration.use_experimental_serializer {
+            let mut ser = ProfileSerializer2::new();
+            ser.serialize(&profile);
+            ser.to_ruby_hash()
         } else {
-            ProfileSerializer::serialize(&profile)
-        };
-        let serialized = CString::new(serialized).unwrap();
-        unsafe { rb_str_new_cstr(serialized.as_ptr()) }
+            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) {
@@ -94,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

@@ -73,13 +73,15 @@ impl Scheduler for TimerThreadScheduler {
         let profile = self.profile.try_read().unwrap();
         log::debug!("Number of samples: {}", profile.samples.len());
 
-        let serialized = if self.configuration.use_experimental_serializer {
-            ProfileSerializer2::new().serialize(&profile)
+        if self.configuration.use_experimental_serializer {
+            let mut ser = ProfileSerializer2::new();
+            ser.serialize(&profile);
+            ser.to_ruby_hash()
         } else {
-            ProfileSerializer::serialize(&profile)
-        };
-        let serialized = CString::new(serialized).unwrap();
-        unsafe { rb_str_new_cstr(serialized.as_ptr()) }
+            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'

data/lib/pf2/reporter/firefox_profiler.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'json'
 
 module Pf2

data/lib/pf2/reporter/stack_weaver.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Pf2
+  module Reporter
+    class StackWeaver
+      def initialize(profile)
+        @profile = profile
+      end
+
+      def weave(ruby_stack, native_stack)
+        ruby_stack = ruby_stack.dup
+        native_stack = native_stack.dup
+
+        weaved_stack = []
+
+        current_stack = :native
+        loop do
+          break if ruby_stack.size == 0 && native_stack.size == 0
+          case current_stack
+          when :ruby
+            if ruby_stack.size == 0 # We've reached the end of the Ruby stack
+              current_stack = :native
+              next
+            end
+
+            location_index = ruby_stack.pop
+            weaved_stack.unshift(location_index)
+
+            current_stack = :native if should_switch_to_native?(location_index, native_stack.dup)
+
+          when :native
+            if native_stack.size == 0 # We've reached the end of the native stack
+              current_stack = :ruby
+              next
+            end
+
+            location_index = native_stack.pop
+            weaved_stack.unshift(location_index)
+
+            current_stack = :ruby if should_switch_to_ruby?(location_index)
+          end
+        end
+
+        weaved_stack
+      end
+
+      # @param [Integer] location_index
+      # @param [Array<Integer>] native_stack_remainder
+      def should_switch_to_native?(location_index, native_stack_remainder)
+        location = @profile[:locations][location_index]
+        function = @profile[:functions][location[:function_index]]
+        raise if function[:implementation] != :ruby # assert
+
+        # Is the current Ruby function a cfunc?
+        return false if function[:start_address] == nil
+
+        # Does a corresponding native function exist in the remainder of the native stack?
+        loop do
+          break if native_stack_remainder.size == 0
+          n_location_index = native_stack_remainder.pop
+          n_location = @profile[:locations][n_location_index]
+          n_function = @profile[:functions][n_location[:function_index]]
+
+          return true if function[:start_address] == n_function[:start_address]
+        end
+
+        false
+      end
+
+      def should_switch_to_ruby?(location_index)
+        location = @profile[:locations][location_index]
+        function = @profile[:functions][location[:function_index]]
+        raise if function[:implementation] != :native # assert
+
+        # If the next function is a vm_exec_core() (= VM_EXEC in vm_exec.h),
+        # we switch to the Ruby stack.
+        function[:name] == 'vm_exec_core'
+      end
+    end
+  end
+end

data/lib/pf2/reporter.rb

@@ -1,5 +1,4 @@
-require_relative './reporter/firefox_profiler'
+# frozen_string_literal: true
 
-module Pf2
-  module Reporter; end
-end
+require_relative './reporter/stack_weaver'
+require_relative './reporter/firefox_profiler'

data/lib/pf2/serve.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'json'
 require 'logger'
 require 'uri'

data/lib/pf2/session.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Pf2
   class Session
     attr_reader :configuration

data/lib/pf2/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Pf2
-  VERSION = '0.6.0'
+  VERSION = '0.7.0'
 end

data/lib/pf2.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'pf2/pf2'
 require_relative 'pf2/session'
 require_relative 'pf2/version'
@@ -18,7 +20,8 @@ module Pf2
     raise ArgumentError, "block required" unless block_given?
     start(threads: Thread.list)
     yield
-    stop
+    result = stop
     @@session = nil # let GC clean up the session
+    result
   end
 end

data/rustfmt.toml

@@ -0,0 +1 @@
+use_small_heuristics = "Max"

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: pf2
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Daisuke Aritomo
 bindir: exe
 cert_chain: []
-date: 2024-07-14 00:00:00.000000000 Z
+date: 2025-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
@@ -27,16 +27,16 @@ dependencies:
   name: rb_sys
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - '='
       - !ruby/object:Gem::Version
-        version: 0.9.63
+        version: 0.9.105
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - '='
       - !ruby/object:Gem::Version
-        version: 0.9.63
+        version: 0.9.105
 - !ruby/object:Gem::Dependency
   name: webrick
   requirement: !ruby/object:Gem::Requirement
@@ -126,12 +126,7 @@ files:
 - crates/backtrace-sys2/src/libbacktrace/install-sh
 - crates/backtrace-sys2/src/libbacktrace/instrumented_alloc.c
 - crates/backtrace-sys2/src/libbacktrace/internal.h
-- crates/backtrace-sys2/src/libbacktrace/libtool.m4
 - crates/backtrace-sys2/src/libbacktrace/ltmain.sh
-- crates/backtrace-sys2/src/libbacktrace/ltoptions.m4
-- crates/backtrace-sys2/src/libbacktrace/ltsugar.m4
-- crates/backtrace-sys2/src/libbacktrace/ltversion.m4
-- crates/backtrace-sys2/src/libbacktrace/lt~obsolete.m4
 - crates/backtrace-sys2/src/libbacktrace/macho.c
 - crates/backtrace-sys2/src/libbacktrace/missing
 - crates/backtrace-sys2/src/libbacktrace/mmap.c
@@ -187,9 +182,11 @@ files:
 - lib/pf2/cli.rb
 - lib/pf2/reporter.rb
 - lib/pf2/reporter/firefox_profiler.rb
+- lib/pf2/reporter/stack_weaver.rb
 - lib/pf2/serve.rb
 - lib/pf2/session.rb
 - lib/pf2/version.rb
+- rustfmt.toml
 homepage: https://github.com/osyoyu/pf2
 licenses:
 - MIT
@@ -212,7 +209,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.0.dev
+rubygems_version: 3.6.2
 specification_version: 4
 summary: Yet another Ruby profiler
 test_files: []