pf2 0.3.0 → 0.5.0

data/ext/pf2/src/timer_thread_scheduler.rs

@@ -1,124 +1,39 @@
 #![deny(unsafe_op_in_unsafe_fn)]
 
-use std::ffi::{c_int, c_void, CStr, CString};
+use std::ffi::{c_void, CString};
 use std::mem::ManuallyDrop;
-use std::ptr::null_mut;
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::{Arc, RwLock};
 use std::thread;
-use std::time::Duration;
 
 use rb_sys::*;
 
 use crate::profile::Profile;
 use crate::profile_serializer::ProfileSerializer;
 use crate::sample::Sample;
+use crate::scheduler::Scheduler;
+use crate::session::configuration::{self, Configuration};
 use crate::util::*;
 
 #[derive(Clone, Debug)]
 pub struct TimerThreadScheduler {
-    ruby_threads: Arc<RwLock<Vec<VALUE>>>,
-    interval: Option<Arc<Duration>>,
-    profile: Option<Arc<RwLock<Profile>>>,
+    configuration: Arc<Configuration>,
+    profile: Arc<RwLock<Profile>>,
     stop_requested: Arc<AtomicBool>,
 }
 
 #[derive(Debug)]
 struct PostponedJobArgs {
-    ruby_threads: Arc<RwLock<Vec<VALUE>>>,
+    configuration: Arc<Configuration>,
     profile: Arc<RwLock<Profile>>,
 }
 
-impl TimerThreadScheduler {
-    fn new() -> Self {
-        TimerThreadScheduler {
-            ruby_threads: Arc::new(RwLock::new(vec![])),
-            interval: None,
-            profile: None,
-            stop_requested: Arc::new(AtomicBool::new(false)),
-        }
-    }
-
-    fn initialize(&mut self, argc: c_int, argv: *const VALUE, _rbself: VALUE) -> VALUE {
-        // Parse arguments
-        let kwargs: VALUE = Qnil.into();
-        unsafe {
-            rb_scan_args(argc, argv, cstr!(":"), &kwargs);
-        };
-        let mut kwargs_values: [VALUE; 3] = [Qnil.into(); 3];
-        unsafe {
-            rb_get_kwargs(
-                kwargs,
-                [
-                    rb_intern(cstr!("interval_ms")),
-                    rb_intern(cstr!("threads")),
-                    rb_intern(cstr!("time_mode")),
-                ]
-                .as_mut_ptr(),
-                0,
-                3,
-                kwargs_values.as_mut_ptr(),
-            );
-        };
-        let interval: Duration = if kwargs_values[0] != Qundef as VALUE {
-            let interval_ms = unsafe { rb_num2long(kwargs_values[0]) };
-            Duration::from_millis(interval_ms.try_into().unwrap_or_else(|_| {
-                eprintln!(
-                    "[Pf2] Warning: Specified interval ({}) is not valid. Using default value (49ms).",
-                    interval_ms
-                );
-                49
-            }))
-        } else {
-            Duration::from_millis(49)
-        };
-        let threads: VALUE = if kwargs_values[1] != Qundef as VALUE {
-            kwargs_values[1]
-        } else {
-            unsafe { rb_funcall(rb_cThread, rb_intern(cstr!("list")), 0) }
-        };
-        if kwargs_values[2] != Qundef as VALUE {
-            let specified_mode = unsafe {
-                let mut str = rb_funcall(kwargs_values[2], rb_intern(cstr!("to_s")), 0);
-                let ptr = rb_string_value_ptr(&mut str);
-                CStr::from_ptr(ptr).to_str().unwrap()
-            };
-            if specified_mode != "wall" {
-                // Raise an ArgumentError
-                unsafe {
-                    rb_raise(
-                        rb_eArgError,
-                        cstr!("TimerThreadScheduler only supports :wall mode."),
-                    )
-                }
-            }
-        }
-
-        let mut target_ruby_threads = Vec::new();
-        unsafe {
-            for i in 0..RARRAY_LEN(threads) {
-                let ruby_thread: VALUE = rb_ary_entry(threads, i);
-                target_ruby_threads.push(ruby_thread);
-            }
-        }
-
-        self.interval = Some(Arc::new(interval));
-        self.ruby_threads = Arc::new(RwLock::new(target_ruby_threads.into_iter().collect()));
-
-        Qnil.into()
-    }
-
-    fn start(&mut self, _rbself: VALUE) -> VALUE {
-        // Create Profile
-        let profile = Arc::new(RwLock::new(Profile::new()));
-        self.start_profile_buffer_flusher_thread(&profile);
-
-        // Start monitoring thread
-        let stop_requested = Arc::clone(&self.stop_requested);
-        let interval = Arc::clone(self.interval.as_ref().unwrap());
+impl Scheduler for TimerThreadScheduler {
+    fn start(&self) -> VALUE {
+        // Register the Postponed Job which does the actual work of collecting samples
         let postponed_job_args: Box<PostponedJobArgs> = Box::new(PostponedJobArgs {
-            ruby_threads: Arc::clone(&self.ruby_threads),
-            profile: Arc::clone(&profile),
+            configuration: Arc::clone(&self.configuration),
+            profile: Arc::clone(&self.profile),
         });
         let postponed_job_handle: rb_postponed_job_handle_t = unsafe {
             rb_postponed_job_preregister(
@@ -127,18 +42,79 @@ impl TimerThreadScheduler {
                 Box::into_raw(postponed_job_args) as *mut c_void, // FIXME: leak
             )
         };
+
+        // Start a timer thread that periodically triggers postponed jobs based on configuration
+        let configuration = Arc::clone(&self.configuration);
+        let stop_requested = Arc::clone(&self.stop_requested);
         thread::spawn(move || {
-            Self::thread_main_loop(stop_requested, interval, postponed_job_handle)
+            Self::thread_main_loop(configuration, stop_requested, postponed_job_handle)
         });
 
-        self.profile = Some(profile);
-
         Qtrue.into()
     }
 
+    fn stop(&self) -> VALUE {
+        // Stop the collector thread
+        self.stop_requested.store(true, Ordering::Relaxed);
+
+        // Finalize
+        match self.profile.try_write() {
+            Ok(mut profile) => {
+                profile.flush_temporary_sample_buffer();
+            }
+            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());
+
+        let serialized = ProfileSerializer::serialize(&profile);
+        let serialized = CString::new(serialized).unwrap();
+        unsafe { rb_str_new_cstr(serialized.as_ptr()) }
+    }
+
+    fn on_new_thread(&self, _thread: VALUE) {
+        todo!();
+    }
+
+    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
+        std::mem::size_of::<TimerThreadScheduler>() as size_t
+    }
+}
+
+impl TimerThreadScheduler {
+    pub fn new(configuration: &Configuration, profile: Arc<RwLock<Profile>>) -> Self {
+        Self {
+            configuration: Arc::new(configuration.clone()),
+            profile,
+            stop_requested: Arc::new(AtomicBool::new(false)),
+        }
+
+        // cstr!("TimerThreadScheduler only supports :wall mode."),
+    }
+
     fn thread_main_loop(
+        configuration: Arc<Configuration>,
         stop_requested: Arc<AtomicBool>,
-        interval: Arc<Duration>,
         postponed_job_handle: rb_postponed_job_handle_t,
     ) {
         loop {
@@ -146,37 +122,11 @@ impl TimerThreadScheduler {
                 break;
             }
             unsafe {
+                log::trace!("Triggering postponed job");
                 rb_postponed_job_trigger(postponed_job_handle);
             }
 
-            thread::sleep(*interval);
-        }
-    }
-
-    fn stop(&self, _rbself: VALUE) -> VALUE {
-        // Stop the collector thread
-        self.stop_requested.store(true, Ordering::Relaxed);
-
-        if let Some(profile) = &self.profile {
-            // Finalize
-            match profile.try_write() {
-                Ok(mut profile) => {
-                    profile.flush_temporary_sample_buffer();
-                }
-                Err(_) => {
-                    println!("[pf2 ERROR] stop: Failed to acquire profile lock.");
-                    return Qfalse.into();
-                }
-            }
-
-            let profile = 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()) }
-        } else {
-            panic!("stop() called before start()");
+            thread::sleep(configuration.interval);
         }
     }
 
@@ -196,124 +146,26 @@ impl TimerThreadScheduler {
         };
 
         // Collect stack information from specified Ruby Threads
-        let ruby_threads = args.ruby_threads.try_read().unwrap();
-        for ruby_thread in ruby_threads.iter() {
-            // Check if the thread is still alive
-            if unsafe { rb_funcall(*ruby_thread, rb_intern(cstr!("status")), 0) } == Qfalse as u64 {
-                continue;
-            }
-
-            let sample = Sample::capture(*ruby_thread, &profile.backtrace_state);
-            if profile.temporary_sample_buffer.push(sample).is_err() {
-                log::debug!("Temporary sample buffer full. Dropping sample.");
-            }
-        }
-        unsafe {
-            rb_gc_enable();
-        }
-    }
-
-    fn start_profile_buffer_flusher_thread(&self, profile: &Arc<RwLock<Profile>>) {
-        let profile = Arc::clone(profile);
-        thread::spawn(move || loop {
-            log::trace!("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));
-        });
-    }
-
-    // Ruby Methods
-
-    pub unsafe extern "C" fn rb_initialize(
-        argc: c_int,
-        argv: *const VALUE,
-        rbself: VALUE,
-    ) -> VALUE {
-        let mut collector = Self::get_struct_from(rbself);
-        collector.initialize(argc, argv, rbself)
-    }
-
-    // SampleCollector.start
-    pub unsafe extern "C" fn rb_start(rbself: VALUE) -> VALUE {
-        let mut collector = Self::get_struct_from(rbself);
-        collector.start(rbself)
-    }
-
-    // SampleCollector.stop
-    pub unsafe extern "C" fn rb_stop(rbself: VALUE) -> VALUE {
-        let collector = Self::get_struct_from(rbself);
-        collector.stop(rbself)
-    }
-
-    // Functions for TypedData
-
-    fn get_struct_from(obj: VALUE) -> ManuallyDrop<Box<Self>> {
-        unsafe {
-            let ptr = rb_check_typeddata(obj, &RBDATA);
-            ManuallyDrop::new(Box::from_raw(ptr as *mut TimerThreadScheduler))
-        }
-    }
-
-    #[allow(non_snake_case)]
-    pub unsafe extern "C" fn rb_alloc(_rbself: VALUE) -> VALUE {
-        let collector = TimerThreadScheduler::new();
-
-        unsafe {
-            let rb_mPf2: VALUE = rb_define_module(cstr!("Pf2"));
-            let rb_cTimerThreadScheduler =
-                rb_define_class_under(rb_mPf2, cstr!("TimerThreadScheduler"), rb_cObject);
-
-            rb_data_typed_object_wrap(
-                rb_cTimerThreadScheduler,
-                Box::into_raw(Box::new(collector)) as *mut _ as *mut c_void,
-                &RBDATA,
-            )
-        }
-    }
-
-    unsafe extern "C" fn dmark(ptr: *mut c_void) {
-        unsafe {
-            let collector = ManuallyDrop::new(Box::from_raw(ptr as *mut TimerThreadScheduler));
-            if let Some(profile) = &collector.profile {
-                match profile.read() {
-                    Ok(profile) => {
-                        profile.dmark();
+        match &args.configuration.target_ruby_threads {
+            configuration::Threads::All => todo!(),
+            configuration::Threads::Targeted(threads) => {
+                for ruby_thread in threads.iter() {
+                    // Check if the thread is still alive
+                    if unsafe { rb_funcall(*ruby_thread, rb_intern(cstr!("status")), 0) }
+                        == Qfalse as u64
+                    {
+                        continue;
                     }
-                    Err(_) => {
-                        panic!("[pf2 FATAL] dmark: Failed to acquire profile lock.");
+
+                    let sample = Sample::capture(*ruby_thread, &profile.backtrace_state);
+                    if profile.temporary_sample_buffer.push(sample).is_err() {
+                        log::debug!("Temporary sample buffer full. Dropping sample.");
                     }
                 }
             }
         }
-    }
-    unsafe extern "C" fn dfree(ptr: *mut c_void) {
         unsafe {
-            drop(Box::from_raw(ptr as *mut TimerThreadScheduler));
+            rb_gc_enable();
         }
     }
-    unsafe extern "C" fn dsize(_: *const c_void) -> size_t {
-        // FIXME: Report something better
-        std::mem::size_of::<TimerThreadScheduler>() as size_t
-    }
 }
-
-static mut RBDATA: rb_data_type_t = rb_data_type_t {
-    wrap_struct_name: cstr!("TimerThreadScheduler"),
-    function: rb_data_type_struct__bindgen_ty_1 {
-        dmark: Some(TimerThreadScheduler::dmark),
-        dfree: Some(TimerThreadScheduler::dfree),
-        dsize: Some(TimerThreadScheduler::dsize),
-        dcompact: None,
-        reserved: [null_mut(); 1],
-    },
-    parent: null_mut(),
-    data: null_mut(),
-    flags: 0,
-};

data/lib/pf2/cli.rb

@@ -10,24 +10,51 @@ module Pf2
     end
 
     def run(argv)
+      argv = argv.dup
+      program_name = File.basename($PROGRAM_NAME)
+
+      subcommand = argv.shift
+      case subcommand
+      when 'report'
+        subcommand_report(argv)
+      when 'serve'
+        subcommand_serve(argv)
+      when 'version'
+        puts VERSION
+        return 0
+      when '--help'
+        STDERR.puts <<~__EOS__
+        Usage: #{program_name} COMMAND [options]
+
+        Commands:
+          report    Generate a report from a profile
+          serve     Start an HTTP server alongside a target process
+          version   Show version information
+        __EOS__
+
+        return 1
+      else
+        STDERR.puts "#{program_name}: Unknown subcommand '#{subcommand}'."
+        STDERR.puts "See '#{program_name} --help'"
+        return 1
+      end
+    end
+
+    def subcommand_report(argv)
       options = {}
       option_parser = OptionParser.new do |opts|
-        opts.on('-v', '--version', 'Prints version') do
-          puts Pf2::VERSION
-          exit
-        end
-
+        opts.banner = "Usage: pf2 report [options] COMMAND"
         opts.on('-h', '--help', 'Prints this help') do
           puts opts
+          return 0
         end
-
         opts.on('-o', '--output FILE', 'Output file') do |path|
           options[:output_file] = path
         end
       end
       option_parser.parse!(argv)
 
-      profile = JSON.parse(File.read(ARGV[0]), symbolize_names: true, max_nesting: false)
+      profile = JSON.parse(File.read(argv[0]), symbolize_names: true, max_nesting: false)
       report = JSON.generate(Pf2::Reporter.new(profile).emit)
 
       if options[:output_file]
@@ -38,5 +65,40 @@ module Pf2
 
       return 0
     end
+
+    def subcommand_serve(argv)
+      options = {}
+      option_parser = OptionParser.new do |opts|
+        opts.banner = "Usage: pf2 serve [options] COMMAND"
+        opts.on('-h', '--help', 'Prints this help') do
+          puts opts
+          return 0
+        end
+        opts.on('-b', '--bind ADDRESS', 'Address to bind') do |host|
+          options[:serve_host] = host
+        end
+        opts.on('-p', '--port PORT', '') do |port|
+          options[:serve_port] = port
+        end
+      end
+      option_parser.parse!(argv)
+
+      if argv.size == 0
+        # No subcommand was specified
+        STDERR.puts option_parser.help
+        return 1
+      end
+
+      # Inject the profiler (pf2/serve) into the target process via RUBYOPT (-r).
+      # This will have no effect if the target process is not Ruby.
+      env = {
+        'RUBYOPT' => '-rpf2/serve'
+      }
+      env['PF2_SERVE_HOST'] = options[:serve_host] if options[:serve_host]
+      env['PF2_SERVE_PORT'] = options[:serve_port] if options[:serve_port]
+      exec(env, *argv) # never returns if succesful
+
+      return 1
+    end
   end
 end

data/lib/pf2/reporter.rb

@@ -71,6 +71,8 @@ module Pf2
       end
 
       def emit
+        x = weave_native_stack(@thread[:stack_tree])
+        @thread[:stack_tree] = x
         func_table = build_func_table
         frame_table = build_frame_table
         stack_table = build_stack_table(func_table, frame_table)
@@ -147,13 +149,13 @@ module Pf2
         }
 
         @thread[:frames].each.with_index do |(id, frame), i|
-          ret[:address] << nil
+          ret[:address] << frame[:address].to_s
           ret[:category] << 1
           ret[:subcategory] << 1
           ret[:func] << i # TODO
           ret[:inner_window_id] << nil
           ret[:implementation] << nil
-          ret[:line] << nil
+          ret[:line] << frame[:callsite_lineno]
           ret[:column] << nil
           ret[:optimizations] << nil
           ret[:inline_depth] << 0
@@ -184,8 +186,8 @@ module Pf2
           ret[:is_js] << !native
           ret[:relevant_for_js] << false
           ret[:resource] << -1
-          ret[:file_name] << nil
-          ret[:line_number] << nil
+          ret[:file_name] << string_id(frame[:file_name])
+          ret[:line_number] << frame[:function_first_lineno]
           ret[:column_number] << nil
 
           @func_id_map[id] = i
@@ -195,6 +197,105 @@ module Pf2
         ret
       end
 
+      # "Weave" the native stack into the Ruby stack.
+      #
+      # Strategy:
+      # - Split the stack into Ruby and Native parts
+      # - Start from the root of the Native stack
+      # - Dig in to the native stack until we hit a rb_vm_exec(), which marks a call into Ruby code
+      # - Switch to Ruby stack. Keep digging until we hit a Cfunc call, then switch back to Native stack
+      # - Repeat until we consume the entire stack
+      def weave_native_stack(stack_tree)
+        collected_paths = []
+        tree_to_array_of_paths(stack_tree, @thread[:frames], [], collected_paths)
+        collected_paths = collected_paths.map do |path|
+          next if path.size == 0
+
+          new_path = []
+          new_path << path.shift # root
+
+          # Split the stack into Ruby and Native parts
+          native_path, ruby_path = path.partition do |frame|
+            frame_id = frame[:frame_id]
+            @thread[:frames][frame_id][:entry_type] == 'Native'
+          end
+
+          mode = :native
+
+          loop do
+            break if ruby_path.size == 0 && native_path.size == 0
+
+            case mode
+            when :ruby
+              if ruby_path.size == 0
+                mode = :native
+                next
+              end
+
+              next_node = ruby_path[0]
+              new_path << ruby_path.shift
+              next_node_frame = @thread[:frames][next_node[:frame_id]]
+              if native_path.size > 0
+                # Search the remainder of the native stack for the same address
+                # Note: This isn't a very efficient way for the job... but it still works
+                ruby_addr = next_node_frame[:address]
+                native_path[0..].each do |native_node|
+                  native_addr = @thread[:frames][native_node[:frame_id]][:address]
+                  if ruby_addr && native_addr && ruby_addr == native_addr
+                    # A match has been found. Switch to native mode
+                    mode = :native
+                    break
+                  end
+                end
+              end
+            when :native
+              if native_path.size == 0
+                mode = :ruby
+                next
+              end
+
+              # Dig until we meet a rb_vm_exec
+              next_node = native_path[0]
+              new_path << native_path.shift
+              if @thread[:frames][next_node[:frame_id]][:full_label] =~ /vm_exec_core/ # VM_EXEC in vm_exec.h
+                mode = :ruby
+              end
+            end
+          end
+
+          new_path
+        end
+
+        # reconstruct stack_tree
+        new_stack_tree = array_of_paths_to_tree(collected_paths)
+        new_stack_tree
+      end
+
+      def tree_to_array_of_paths(stack_tree, frames, path, collected_paths)
+        new_path = path + [{ frame_id: stack_tree[:frame_id], node_id: stack_tree[:node_id] }]
+        if stack_tree[:children].empty?
+          collected_paths << new_path
+        else
+          stack_tree[:children].each do |frame_id, child|
+            tree_to_array_of_paths(child, frames, new_path, collected_paths)
+          end
+        end
+      end
+
+      def array_of_paths_to_tree(paths)
+        new_stack_tree = { children: {}, node_id: 0, frame_id: 0 }
+        paths.each do |path|
+          current = new_stack_tree
+          path[1..].each do |frame|
+            frame_id = frame[:frame_id]
+            node_id = frame[:node_id]
+            current[:children][frame_id] ||= { children: {}, node_id: node_id, frame_id: frame_id }
+            current = current[:children][frame_id]
+          end
+        end
+        new_stack_tree
+      end
+
       def build_stack_table(func_table, frame_table)
         ret = {
           frame: [],

data/lib/pf2/serve.rb

@@ -0,0 +1,60 @@
+require 'json'
+require 'logger'
+require 'uri'
+require 'webrick'
+
+require_relative '../pf2'
+require_relative './reporter'
+
+module Pf2
+  class Serve
+    CONFIG = {
+      Host: ENV.fetch('PF2_SERVE_HOST', 'localhost'),
+      Port: ENV.fetch('PF2_SERVE_PORT', '51502').to_i, # 1502 = 0xF2 (as in "Pf2")
+      Logger: Logger.new(nil),
+      AccessLog: [],
+    }
+
+    def self.start
+
+      # Ignore Bundler as in `bundle exec`.
+      if File.basename($PROGRAM_NAME) == 'bundle' && ARGV.first == 'exec'
+        return
+      end
+
+      server = WEBrick::HTTPServer.new(CONFIG)
+      server.mount_proc('/profile') do |req, res|
+        profile = Pf2.stop
+        profile = JSON.parse(profile, symbolize_names: true, max_nesting: false)
+        res.header['Content-Type'] = 'application/json'
+        res.header['Access-Control-Allow-Origin'] = '*'
+        res.body = JSON.generate(Pf2::Reporter.new((profile)).emit)
+        Pf2.start
+      end
+
+      Pf2.start
+
+      Thread.new do
+        hostport = "#{server.config[:Host]}:#{server.config[:Port]}"
+        # Print host:port to trigger VS Code's auto port-forwarding feature
+        STDERR.puts "[Pf2] Listening on #{hostport}."
+        STDERR.puts "[Pf2] Open https://profiler.firefox.com/from-url/#{URI.encode_www_form_component("http://#{hostport}/profile")} for visualization."
+        STDERR.puts ""
+        server.start
+      end
+    end
+
+    def self.at_exit
+      STDERR.puts ""
+      STDERR.puts "[Pf2] Script execution complete (Pf2 server is still listening). Hit Ctrl-C to quit."
+
+      # Allow the user to download the profile after the target program exits
+      sleep
+    end
+  end
+end
+
+Pf2::Serve.start
+at_exit do
+  Pf2::Serve.at_exit
+end