pf2 0.1.0 → 0.2.0

data/ext/pf2/src/signal_scheduler.rs

@@ -0,0 +1,242 @@
+#![deny(unsafe_op_in_unsafe_fn)]
+
+mod configuration;
+mod timer_installer;
+
+use self::configuration::{Configuration, TimeMode};
+use self::timer_installer::TimerInstaller;
+use crate::profile::Profile;
+use crate::profile_serializer::ProfileSerializer;
+use crate::sample::Sample;
+
+use core::panic;
+use std::collections::HashSet;
+use std::ffi::{c_int, c_void, CString};
+use std::mem::ManuallyDrop;
+use std::sync::{Arc, RwLock};
+use std::thread;
+use std::time::Duration;
+use std::{mem, ptr::null_mut};
+
+use rb_sys::*;
+
+use crate::util::*;
+
+#[derive(Debug)]
+pub struct SignalScheduler {
+    configuration: configuration::Configuration,
+    profile: Option<Arc<RwLock<Profile>>>,
+}
+
+pub struct SignalHandlerArgs {
+    profile: Arc<RwLock<Profile>>,
+    context_ruby_thread: VALUE,
+}
+
+impl SignalScheduler {
+    fn new() -> Self {
+        Self {
+            configuration: Configuration {
+                time_mode: TimeMode::CpuTime,
+            },
+            profile: None,
+        }
+    }
+
+    fn start(
+        &mut self,
+        _rbself: VALUE,
+        ruby_threads_rary: VALUE,
+        track_new_threads: VALUE,
+    ) -> VALUE {
+        let track_new_threads = RTEST(track_new_threads);
+
+        let profile = Arc::new(RwLock::new(Profile::new()));
+        self.start_profile_buffer_flusher_thread(&profile);
+        self.install_signal_handler();
+
+        let mut target_ruby_threads = HashSet::new();
+        unsafe {
+            for i in 0..RARRAY_LEN(ruby_threads_rary) {
+                let ruby_thread: VALUE = rb_ary_entry(ruby_threads_rary, i);
+                target_ruby_threads.insert(ruby_thread);
+            }
+        }
+        TimerInstaller::install_timer_to_ruby_threads(
+            self.configuration.clone(),
+            &target_ruby_threads,
+            Arc::clone(&profile),
+            track_new_threads,
+        );
+
+        self.profile = Some(profile);
+
+        Qtrue.into()
+    }
+
+    fn stop(&mut self, _rbself: VALUE) -> VALUE {
+        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()");
+        }
+    }
+
+    // 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);
+        }
+    }
+
+    // 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); // NOT async-signal-safe
+        if profile.temporary_sample_buffer.push(sample).is_err() {
+            log::debug!("Temporary sample buffer full. Dropping sample.");
+        }
+    }
+
+    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_start(
+        rbself: VALUE,
+        ruby_threads: VALUE,
+        track_new_threads: VALUE,
+    ) -> VALUE {
+        let mut collector = unsafe { Self::get_struct_from(rbself) };
+        collector.start(rbself, ruby_threads, track_new_threads)
+    }
+
+    pub unsafe extern "C" fn rb_stop(rbself: VALUE) -> VALUE {
+        let mut collector = unsafe { Self::get_struct_from(rbself) };
+        collector.stop(rbself)
+    }
+
+    // Functions for TypedData
+
+    // Extract the SignalScheduler struct from a Ruby object
+    unsafe 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 SignalScheduler))
+        }
+    }
+
+    #[allow(non_snake_case)]
+    pub unsafe extern "C" fn rb_alloc(_rbself: VALUE) -> VALUE {
+        let collector = Box::new(SignalScheduler::new());
+        unsafe { Arc::increment_strong_count(&collector) };
+
+        unsafe {
+            let rb_mPf2: VALUE = rb_define_module(cstr!("Pf2"));
+            let rb_cSignalScheduler =
+                rb_define_class_under(rb_mPf2, cstr!("SignalScheduler"), rb_cObject);
+
+            // "Wrap" the SignalScheduler struct into a Ruby object
+            rb_data_typed_object_wrap(
+                rb_cSignalScheduler,
+                Box::into_raw(collector) 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 SignalScheduler));
+            if let Some(profile) = &collector.profile {
+                match profile.read() {
+                    Ok(profile) => {
+                        profile.dmark();
+                    }
+                    Err(_) => {
+                        panic!("[pf2 FATAL] dmark: Failed to acquire profile lock.");
+                    }
+                }
+            }
+        }
+    }
+
+    unsafe extern "C" fn dfree(ptr: *mut c_void) {
+        unsafe {
+            drop(Box::from_raw(ptr as *mut SignalScheduler));
+        }
+    }
+
+    unsafe extern "C" fn dsize(_: *const c_void) -> size_t {
+        // FIXME: Report something better
+        mem::size_of::<SignalScheduler>() as size_t
+    }
+}
+
+static mut RBDATA: rb_data_type_t = rb_data_type_t {
+    wrap_struct_name: cstr!("SignalScheduler"),
+    function: rb_data_type_struct__bindgen_ty_1 {
+        dmark: Some(SignalScheduler::dmark),
+        dfree: Some(SignalScheduler::dfree),
+        dsize: Some(SignalScheduler::dsize),
+        dcompact: None,
+        reserved: [null_mut(); 1],
+    },
+    parent: null_mut(),
+    data: null_mut(),
+    flags: 0,
+};

data/ext/pf2/src/timer_thread_scheduler.rs

@@ -0,0 +1,243 @@
+#![deny(unsafe_op_in_unsafe_fn)]
+
+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::util::*;
+
+#[derive(Clone, Debug)]
+pub struct TimerThreadScheduler {
+    ruby_threads: Arc<RwLock<Vec<VALUE>>>,
+    profile: Option<Arc<RwLock<Profile>>>,
+    stop_requested: Arc<AtomicBool>,
+}
+
+#[derive(Debug)]
+struct PostponedJobArgs {
+    ruby_threads: Arc<RwLock<Vec<VALUE>>>,
+    profile: Arc<RwLock<Profile>>,
+}
+
+impl TimerThreadScheduler {
+    fn new() -> Self {
+        TimerThreadScheduler {
+            ruby_threads: Arc::new(RwLock::new(vec![])),
+            profile: None,
+            stop_requested: Arc::new(AtomicBool::new(false)),
+        }
+    }
+
+    fn start(&mut self, _rbself: VALUE, ruby_threads: VALUE) -> VALUE {
+        // Register threads
+        let stored_threads = &mut self.ruby_threads.try_write().unwrap();
+        unsafe {
+            for i in 0..RARRAY_LEN(ruby_threads) {
+                stored_threads.push(rb_ary_entry(ruby_threads, i));
+            }
+        }
+
+        // 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 postponed_job_args: Box<PostponedJobArgs> = Box::new(PostponedJobArgs {
+            ruby_threads: Arc::clone(&self.ruby_threads),
+            profile: Arc::clone(&profile),
+        });
+        let postponed_job_handle: rb_postponed_job_handle_t = unsafe {
+            rb_postponed_job_preregister(
+                0,
+                Some(Self::postponed_job),
+                Box::into_raw(postponed_job_args) as *mut c_void, // FIXME: leak
+            )
+        };
+        thread::spawn(move || Self::thread_main_loop(stop_requested, postponed_job_handle));
+
+        self.profile = Some(profile);
+
+        Qtrue.into()
+    }
+
+    fn thread_main_loop(
+        stop_requested: Arc<AtomicBool>,
+        postponed_job_handle: rb_postponed_job_handle_t,
+    ) {
+        loop {
+            if stop_requested.fetch_and(true, Ordering::Relaxed) {
+                break;
+            }
+            unsafe {
+                rb_postponed_job_trigger(postponed_job_handle);
+            }
+            // sleep for 50 ms
+            thread::sleep(Duration::from_millis(50));
+        }
+    }
+
+    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()");
+        }
+    }
+
+    unsafe extern "C" fn postponed_job(ptr: *mut c_void) {
+        unsafe {
+            rb_gc_disable();
+        }
+        let args = unsafe { ManuallyDrop::new(Box::from_raw(ptr as *mut PostponedJobArgs)) };
+
+        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;
+            }
+        };
+
+        // 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);
+            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
+
+    // SampleCollector.start
+    pub unsafe extern "C" fn rb_start(rbself: VALUE, ruby_threads: VALUE, _: VALUE) -> VALUE {
+        let mut collector = Self::get_struct_from(rbself);
+        collector.start(rbself, ruby_threads)
+    }
+
+    // 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();
+                    }
+                    Err(_) => {
+                        panic!("[pf2 FATAL] dmark: Failed to acquire profile lock.");
+                    }
+                }
+            }
+        }
+    }
+    unsafe extern "C" fn dfree(ptr: *mut c_void) {
+        unsafe {
+            drop(Box::from_raw(ptr as *mut TimerThreadScheduler));
+        }
+    }
+    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/ext/pf2/src/util.rs

@@ -0,0 +1,30 @@
+use core::mem::transmute;
+use rb_sys::*;
+use std::ffi::c_void;
+
+// Convert str literal to C string literal
+macro_rules! cstr {
+    ($s:expr) => {
+        concat!($s, "\0").as_ptr() as *const std::ffi::c_char
+    };
+}
+pub(crate) use cstr;
+
+pub type RubyCFunc = unsafe extern "C" fn() -> VALUE;
+
+// TODO: rewrite as macro
+pub fn to_ruby_cfunc1<T>(f: unsafe extern "C" fn(T) -> VALUE) -> RubyCFunc {
+    unsafe { transmute::<unsafe extern "C" fn(T) -> VALUE, RubyCFunc>(f) }
+}
+pub fn to_ruby_cfunc3<T, U, V>(f: unsafe extern "C" fn(T, U, V) -> VALUE) -> RubyCFunc {
+    unsafe { transmute::<unsafe extern "C" fn(T, U, V) -> VALUE, RubyCFunc>(f) }
+}
+
+#[allow(non_snake_case)]
+pub fn RTEST(v: VALUE) -> bool {
+    v != Qfalse as VALUE && v != Qnil as VALUE
+}
+
+extern "C" {
+    pub fn extract_si_value_sival_ptr(info: *mut libc::siginfo_t) -> *mut c_void;
+}

data/lib/pf2/cli.rb

@@ -27,7 +27,7 @@ module Pf2
       end
       option_parser.parse!(argv)
 
-      profile = Marshal.load(IO.binread(ARGV[0]))
+      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]

data/lib/pf2/reporter.rb

@@ -5,7 +5,7 @@ module Pf2
   # https://github.com/firefox-devtools/profiler/blob/main/docs-developer/processed-profile-format.md
   class Reporter
     def initialize(profile)
-      @profile = profile
+      @profile = Reporter.deep_intize_keys(profile)
     end
 
     def inspect
@@ -13,15 +13,15 @@ module Pf2
     end
 
     def emit
-      x = {
+      report = {
         meta: {
           interval: 10, # ms; TODO: replace with actual interval
           start_time: 0,
           process_type: 0,
           product: 'ruby',
           stackwalk: 0,
-          version: 19,
-          preprocessed_profile_version: 28,
+          version: 28,
+          preprocessed_profile_version: 47,
           symbolicated: true,
           categories: [
             {
@@ -40,12 +40,13 @@ module Pf2
               subcategories: ["Code"],
             },
           ],
+          marker_schema: [],
         },
         libs: [],
         counters: [],
         threads: @profile[:threads].values.map {|th| ThreadReport.new(th).emit }
       }
-      Reporter.deep_camelize_keys(x)
+      Reporter.deep_camelize_keys(report)
     end
 
     class ThreadReport
@@ -83,7 +84,9 @@ module Pf2
           name: "Thread (tid: #{@thread[:thread_id]})",
           is_main_thread: true,
           is_js_tracer: true,
-          pid: 1,
+          # FIXME: We can fill the correct PID only after we correctly fill is_main_thread
+          # (only one thread could be marked as is_main_thread in a single process)
+          pid: @thread[:thread_id],
           tid: @thread[:thread_id],
           samples: samples,
           markers: markers,
@@ -114,7 +117,7 @@ module Pf2
 
         @thread[:samples].each do |sample|
           ret[:stack] << @stack_tree_id_map[sample[:stack_tree_id]]
-          ret[:time] << sample[:timestamp] / 1000000 # ns -> ms
+          ret[:time] << sample[:elapsed_ns] / 1000000 # ns -> ms
           ret[:duration] << 1
           ret[:event_delay] << 0
         end
@@ -134,6 +137,8 @@ module Pf2
           line: [],
           column: [],
           optimizations: [],
+          inline_depth: [],
+          native_symbol: [],
         }
 
         @thread[:frames].each.with_index do |(id, frame), i|
@@ -146,6 +151,8 @@ module Pf2
           ret[:line] << nil
           ret[:column] << nil
           ret[:optimizations] << nil
+          ret[:inline_depth] << 0
+          ret[:native_symbol] << nil
 
           @frame_id_map[id] = i
         end
@@ -229,6 +236,9 @@ module Pf2
           data: [],
           name: [],
           time: [],
+          start_time: [],
+          end_time: [],
+          phase: [],
           category: [],
           length: 0
         }
@@ -244,17 +254,32 @@ module Pf2
         s.split('_').inject([]) {|buffer, p| buffer.push(buffer.size == 0 ? p : p.capitalize) }.join
       end
 
-      def deep_camelize_keys(value)
+      def deep_transform_keys(value, &block)
         case value
         when Array
-          value.map {|v| deep_camelize_keys(v) }
+          value.map {|v| deep_transform_keys(v, &block) }
         when Hash
-          Hash[value.map {|k, v| [snake_to_camel(k.to_s).to_sym, deep_camelize_keys(v)] }]
+          Hash[value.map {|k, v| [yield(k), deep_transform_keys(v, &block)] }]
         else
           value
         end
       end
+
+      def deep_camelize_keys(value)
+        deep_transform_keys(value) do |key|
+          snake_to_camel(key.to_s).to_sym
+        end
+      end
+
+      def deep_intize_keys(value)
+        deep_transform_keys(value) do |key|
+          if key.to_s.to_i.to_s == key.to_s
+            key.to_s.to_i
+          else
+            key
+          end
+        end
+      end
     end
   end
 end
-

data/lib/pf2/version.rb

@@ -1,3 +1,3 @@
 module Pf2
-  VERSION = '0.1.0'
+  VERSION = '0.2.0'
 end

data/lib/pf2.rb

@@ -4,13 +4,31 @@ require_relative 'pf2/version'
 module Pf2
   class Error < StandardError; end
 
-  @@threads = []
+  def self.default_scheduler_class
+    # SignalScheduler is Linux-only. Use TimerThreadScheduler on other platforms.
+    if defined?(SignalScheduler)
+      SignalScheduler
+    else
+      TimerThreadScheduler
+    end
+  end
+
+  def self.default_scheduler
+    @@default_scheduler ||= default_scheduler_class.new
+  end
+
+  def self.start(...)
+    default_scheduler.start(...)
+  end
 
-  def self.threads
-    @@threads
+  def self.stop(...)
+    default_scheduler.stop(...)
   end
 
-  def self.threads=(th)
-    @@threads = th
+  def self.profile(&block)
+    raise ArgumentError, "block required" unless block_given?
+    start([Thread.current], true)
+    yield
+    stop
   end
 end