pf2 0.2.0 → 0.4.0

data/ext/pf2/src/signal_scheduler/timer_installer.rs

@@ -1,32 +1,28 @@
-use std::collections::HashMap;
+use std::collections::HashSet;
 use std::ffi::c_void;
 use std::mem;
 use std::mem::ManuallyDrop;
 use std::ptr::null_mut;
+use std::sync::Arc;
 use std::sync::{Mutex, RwLock};
-use std::{collections::HashSet, sync::Arc};
 
 use rb_sys::*;
 
-use crate::signal_scheduler::SignalHandlerArgs;
-
 use super::configuration::Configuration;
 use crate::profile::Profile;
+use crate::ruby_internal_apis::rb_thread_getcpuclockid;
+use crate::signal_scheduler::{cstr, SignalHandlerArgs};
 
-// We could avoid deferring the timer creation by combining pthread_getcpuclockid(3) and timer_create(2) here,
-// but we're not doing so since (1) Ruby does not expose the pthread_self() of a Ruby Thread
-// (which is actually stored in th->nt->thread_id), and (2) pthread_getcpuclockid(3) is not portable
-// in the first place (e.g. not available on macOS).
+#[derive(Debug)]
 pub struct TimerInstaller {
-    internal: Box<Mutex<Internal>>,
+    inner: Box<Mutex<Inner>>,
 }
 
-struct Internal {
+#[derive(Debug)]
+struct Inner {
     configuration: Configuration,
-    target_ruby_threads: HashSet<VALUE>,
-    registered_pthread_ids: HashSet<libc::pthread_t>,
-    kernel_thread_id_to_ruby_thread_map: HashMap<libc::pid_t, VALUE>,
-    profile: Arc<RwLock<Profile>>,
+    pub profile: Arc<RwLock<Profile>>,
+    known_threads: HashSet<VALUE>,
 }
 
 impl TimerInstaller {
@@ -34,159 +30,116 @@ impl TimerInstaller {
     // The callback should create a timer for the thread.
     pub fn install_timer_to_ruby_threads(
         configuration: Configuration,
-        ruby_threads: &HashSet<VALUE>,
         profile: Arc<RwLock<Profile>>,
-        track_new_threads: bool,
     ) {
-        let registrar = Self {
-            internal: Box::new(Mutex::new(Internal {
-                configuration,
-                target_ruby_threads: ruby_threads.clone(),
-                registered_pthread_ids: HashSet::new(),
-                kernel_thread_id_to_ruby_thread_map: HashMap::new(),
+        let installer = Self {
+            inner: Box::new(Mutex::new(Inner {
+                configuration: configuration.clone(),
                 profile,
+                known_threads: HashSet::new(),
             })),
         };
 
-        let ptr = Box::into_raw(registrar.internal);
-        unsafe {
-            rb_internal_thread_add_event_hook(
-                Some(Self::on_thread_resume),
-                RUBY_INTERNAL_THREAD_EVENT_RESUMED,
-                ptr as *mut c_void,
-            );
-            // Spawn a no-op Thread to fire the event hook
-            // (at least 2 Ruby Threads must be active for the RESUMED hook to be fired)
-            rb_thread_create(Some(Self::do_nothing), null_mut());
-        };
+        if let Ok(mut inner) = installer.inner.try_lock() {
+            for ruby_thread in configuration.target_ruby_threads.iter() {
+                let ruby_thread: VALUE = *ruby_thread;
+                inner.known_threads.insert(ruby_thread);
+                inner.register_timer_to_ruby_thread(ruby_thread);
+            }
+        }
 
-        if track_new_threads {
+        if configuration.track_all_threads {
+            let ptr = Box::into_raw(installer.inner);
             unsafe {
+                // TODO: Clean up this hook when the profiling session ends
                 rb_internal_thread_add_event_hook(
-                    Some(Self::on_thread_start),
-                    RUBY_INTERNAL_THREAD_EVENT_STARTED,
+                    Some(Self::on_thread_resume),
+                    RUBY_INTERNAL_THREAD_EVENT_RESUMED,
                     ptr as *mut c_void,
                 );
             };
         }
     }
 
-    unsafe extern "C" fn do_nothing(_: *mut c_void) -> VALUE {
-        Qnil.into()
-    }
-
-    // Thread resume callback
+    // Thread start callback
     unsafe extern "C" fn on_thread_resume(
         _flag: rb_event_flag_t,
         data: *const rb_internal_thread_event_data,
         custom_data: *mut c_void,
     ) {
-        // The SignalScheduler (as a Ruby obj) should be passed as custom_data
-        let internal =
-            unsafe { ManuallyDrop::new(Box::from_raw(custom_data as *mut Mutex<Internal>)) };
-        let mut internal = internal.lock().unwrap();
-
-        // Check if the current thread is a target Ruby Thread
-        let current_ruby_thread: VALUE = unsafe { (*data).thread };
-        if !internal.target_ruby_threads.contains(&current_ruby_thread) {
-            return;
-        }
-
-        // Check if the current thread is already registered
-        let current_pthread_id = unsafe { libc::pthread_self() };
-        if internal
-            .registered_pthread_ids
-            .contains(&current_pthread_id)
-        {
-            return;
-        }
-
-        // Record the pthread ID of the current thread
-        internal.registered_pthread_ids.insert(current_pthread_id);
-        // Keep a mapping from kernel thread ID to Ruby Thread
-        internal
-            .kernel_thread_id_to_ruby_thread_map
-            .insert(unsafe { libc::gettid() }, current_ruby_thread);
-
-        Self::register_timer_to_current_thread(
-            &internal.configuration,
-            &internal.profile,
-            &internal.kernel_thread_id_to_ruby_thread_map,
-        );
-
-        // TODO: Remove the hook when all threads have been registered
-    }
+        let ruby_thread: VALUE = unsafe { (*data).thread };
 
-    // Thread resume callback
-    unsafe extern "C" fn on_thread_start(
-        _flag: rb_event_flag_t,
-        data: *const rb_internal_thread_event_data,
-        custom_data: *mut c_void,
-    ) {
-        // The SignalScheduler (as a Ruby obj) should be passed as custom_data
-        let internal =
-            unsafe { ManuallyDrop::new(Box::from_raw(custom_data as *mut Mutex<Internal>)) };
-        let mut internal = internal.lock().unwrap();
+        // A pointer to Box<Inner> is passed as custom_data
+        let inner = unsafe { ManuallyDrop::new(Box::from_raw(custom_data as *mut Mutex<Inner>)) };
+        let mut inner = inner.lock().unwrap();
 
-        let current_ruby_thread: VALUE = unsafe { (*data).thread };
-        internal.target_ruby_threads.insert(current_ruby_thread);
+        if !inner.known_threads.contains(&ruby_thread) {
+            inner.known_threads.insert(ruby_thread);
+            // Install a timer for the thread
+            inner.register_timer_to_ruby_thread(ruby_thread);
+        }
     }
+}
 
-    // Creates a new POSIX timer which invocates sampling for the thread that called this function.
-    fn register_timer_to_current_thread(
-        configuration: &Configuration,
-        profile: &Arc<RwLock<Profile>>,
-        kernel_thread_id_to_ruby_thread_map: &HashMap<libc::pid_t, VALUE>,
-    ) {
-        let current_pthread_id = unsafe { libc::pthread_self() };
-        let context_ruby_thread: VALUE = unsafe {
-            *(kernel_thread_id_to_ruby_thread_map
-                .get(&(libc::gettid()))
-                .unwrap())
-        };
-
+impl Inner {
+    fn register_timer_to_ruby_thread(&self, ruby_thread: VALUE) {
         // NOTE: This Box is never dropped
         let signal_handler_args = Box::new(SignalHandlerArgs {
-            profile: Arc::clone(profile),
-            context_ruby_thread,
+            profile: Arc::clone(&self.profile),
+            context_ruby_thread: ruby_thread,
         });
 
+        // rb_funcall deadlocks when called within a THREAD_EVENT_STARTED hook
+        let kernel_thread_id: i32 = i32::try_from(unsafe {
+            rb_num2int(rb_funcall(
+                ruby_thread,
+                rb_intern(cstr!("native_thread_id")), // kernel thread ID
+                0,
+            ))
+        })
+        .unwrap();
+
         // Create a signal event
         let mut sigevent: libc::sigevent = unsafe { mem::zeroed() };
         // Note: SIGEV_THREAD_ID is Linux-specific. In other platforms, we would need to
-        // "tranpoline" the signal as any pthread can receive the signal.
+        // "trampoline" the signal as any pthread can receive the signal.
         sigevent.sigev_notify = libc::SIGEV_THREAD_ID;
-        sigevent.sigev_notify_thread_id =
-            unsafe { libc::syscall(libc::SYS_gettid).try_into().unwrap() }; // The kernel thread ID
+        sigevent.sigev_notify_thread_id = kernel_thread_id;
         sigevent.sigev_signo = libc::SIGALRM;
         // Pass required args to the signal handler
         sigevent.sigev_value.sival_ptr = Box::into_raw(signal_handler_args) as *mut c_void;
 
-        // Create and configure timer to fire every 10 ms of CPU time
+        // Create and configure timer to fire every _interval_ ms of CPU time
         let mut timer: libc::timer_t = unsafe { mem::zeroed() };
-        match configuration.time_mode {
-            crate::signal_scheduler::TimeMode::CpuTime => {
-                let err = unsafe {
-                    libc::timer_create(libc::CLOCK_THREAD_CPUTIME_ID, &mut sigevent, &mut timer)
-                };
-                if err != 0 {
-                    panic!("timer_create failed: {}", err);
-                }
-            }
-            crate::signal_scheduler::TimeMode::WallTime => {
-                todo!("WallTime is not supported yet");
-            }
+        let clockid = match self.configuration.time_mode {
+            crate::signal_scheduler::TimeMode::CpuTime => unsafe {
+                rb_thread_getcpuclockid(ruby_thread)
+            },
+            crate::signal_scheduler::TimeMode::WallTime => libc::CLOCK_MONOTONIC,
         };
-        let mut its: libc::itimerspec = unsafe { mem::zeroed() };
-        its.it_interval.tv_sec = 0;
-        its.it_interval.tv_nsec = 10_000_000; // 10 ms
-        its.it_value.tv_sec = 0;
-        its.it_value.tv_nsec = 10_000_000;
-        let err = unsafe { libc::timer_settime(timer, 0, &its, null_mut()) };
+        let err = unsafe { libc::timer_create(clockid, &mut sigevent, &mut timer) };
+        if err != 0 {
+            panic!("timer_create failed: {}", err);
+        }
+        let itimerspec = Self::duration_to_itimerspec(&self.configuration.interval);
+        let err = unsafe { libc::timer_settime(timer, 0, &itimerspec, null_mut()) };
         if err != 0 {
             panic!("timer_settime failed: {}", err);
         }
 
-        log::debug!("timer registered for thread {}", current_pthread_id);
+        log::debug!("timer registered for thread {}", ruby_thread);
+    }
+
+    fn duration_to_itimerspec(duration: &std::time::Duration) -> libc::itimerspec {
+        let nanos = duration.as_nanos();
+        let seconds_part: i64 = (nanos / 1_000_000_000).try_into().unwrap();
+        let nanos_part: i64 = (nanos % 1_000_000_000).try_into().unwrap();
+
+        let mut its: libc::itimerspec = unsafe { mem::zeroed() };
+        its.it_interval.tv_sec = seconds_part;
+        its.it_interval.tv_nsec = nanos_part;
+        its.it_value.tv_sec = seconds_part;
+        its.it_value.tv_nsec = nanos_part;
+        its
     }
 }

data/ext/pf2/src/signal_scheduler.rs

@@ -11,8 +11,9 @@ use crate::sample::Sample;
 
 use core::panic;
 use std::collections::HashSet;
-use std::ffi::{c_int, c_void, CString};
+use std::ffi::{c_int, c_void, CStr, CString};
 use std::mem::ManuallyDrop;
+use std::str::FromStr;
 use std::sync::{Arc, RwLock};
 use std::thread;
 use std::time::Duration;
@@ -24,7 +25,7 @@ use crate::util::*;
 
 #[derive(Debug)]
 pub struct SignalScheduler {
-    configuration: configuration::Configuration,
+    configuration: Option<configuration::Configuration>,
     profile: Option<Arc<RwLock<Profile>>>,
 }
 
@@ -36,37 +37,100 @@ pub struct SignalHandlerArgs {
 impl SignalScheduler {
     fn new() -> Self {
         Self {
-            configuration: Configuration {
-                time_mode: TimeMode::CpuTime,
-            },
+            configuration: None,
             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();
+    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; 4] = [Qnil.into(); 4];
+        unsafe {
+            rb_get_kwargs(
+                kwargs,
+                [
+                    rb_intern(cstr!("interval_ms")),
+                    rb_intern(cstr!("threads")),
+                    rb_intern(cstr!("time_mode")),
+                    rb_intern(cstr!("track_all_threads")),
+                ]
+                .as_mut_ptr(),
+                0,
+                4,
+                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) }
+        };
+        let time_mode: configuration::TimeMode = 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()
+            };
+            configuration::TimeMode::from_str(specified_mode).unwrap_or_else(|_| {
+                // Raise an ArgumentError
+                unsafe {
+                    rb_raise(
+                        rb_eArgError,
+                        cstr!("Invalid time mode. Valid values are 'cpu' and 'wall'."),
+                    )
+                }
+            })
+        } else {
+            configuration::TimeMode::CpuTime
+        };
+        let track_all_threads: bool = if kwargs_values[3] != Qundef as VALUE {
+            RTEST(kwargs_values[3])
+        } else {
+            false
+        };
 
         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);
+            for i in 0..RARRAY_LEN(threads) {
+                let ruby_thread: VALUE = rb_ary_entry(threads, i);
                 target_ruby_threads.insert(ruby_thread);
             }
         }
+
+        self.configuration = Some(Configuration {
+            interval,
+            target_ruby_threads,
+            time_mode,
+            track_all_threads,
+        });
+
+        Qnil.into()
+    }
+
+    fn start(&mut self, _rbself: VALUE) -> VALUE {
+        let profile = Arc::new(RwLock::new(Profile::new()));
+        self.start_profile_buffer_flusher_thread(&profile);
+        self.install_signal_handler();
+
         TimerInstaller::install_timer_to_ruby_threads(
-            self.configuration.clone(),
-            &target_ruby_threads,
+            self.configuration.as_ref().unwrap().clone(), // FIXME: don't clone
             Arc::clone(&profile),
-            track_new_threads,
         );
 
         self.profile = Some(profile);
@@ -132,7 +196,7 @@ impl SignalScheduler {
             }
         };
 
-        let sample = Sample::capture(args.context_ruby_thread); // NOT async-signal-safe
+        let sample = Sample::capture(args.context_ruby_thread, &profile.backtrace_state); // NOT async-signal-safe
         if profile.temporary_sample_buffer.push(sample).is_err() {
             log::debug!("Temporary sample buffer full. Dropping sample.");
         }
@@ -156,13 +220,18 @@ impl SignalScheduler {
 
     // Ruby Methods
 
-    pub unsafe extern "C" fn rb_start(
+    pub unsafe extern "C" fn rb_initialize(
+        argc: c_int,
+        argv: *const VALUE,
         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)
+        collector.initialize(argc, argv, rbself)
+    }
+
+    pub unsafe extern "C" fn rb_start(rbself: VALUE) -> VALUE {
+        let mut collector = unsafe { Self::get_struct_from(rbself) };
+        collector.start(rbself)
     }
 
     pub unsafe extern "C" fn rb_stop(rbself: VALUE) -> VALUE {

data/ext/pf2/src/timer_thread_scheduler.rs

@@ -1,6 +1,6 @@
 #![deny(unsafe_op_in_unsafe_fn)]
 
-use std::ffi::{c_void, CString};
+use std::ffi::{c_int, c_void, CStr, CString};
 use std::mem::ManuallyDrop;
 use std::ptr::null_mut;
 use std::sync::atomic::{AtomicBool, Ordering};
@@ -18,6 +18,7 @@ use crate::util::*;
 #[derive(Clone, Debug)]
 pub struct TimerThreadScheduler {
     ruby_threads: Arc<RwLock<Vec<VALUE>>>,
+    interval: Option<Arc<Duration>>,
     profile: Option<Arc<RwLock<Profile>>>,
     stop_requested: Arc<AtomicBool>,
 }
@@ -32,26 +33,89 @@ 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 start(&mut self, _rbself: VALUE, ruby_threads: VALUE) -> VALUE {
-        // Register threads
-        let stored_threads = &mut self.ruby_threads.try_write().unwrap();
+    fn initialize(&mut self, argc: c_int, argv: *const VALUE, _rbself: VALUE) -> VALUE {
+        // Parse arguments
+        let kwargs: VALUE = Qnil.into();
         unsafe {
-            for i in 0..RARRAY_LEN(ruby_threads) {
-                stored_threads.push(rb_ary_entry(ruby_threads, i));
+            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());
         let postponed_job_args: Box<PostponedJobArgs> = Box::new(PostponedJobArgs {
             ruby_threads: Arc::clone(&self.ruby_threads),
             profile: Arc::clone(&profile),
@@ -63,7 +127,9 @@ impl TimerThreadScheduler {
                 Box::into_raw(postponed_job_args) as *mut c_void, // FIXME: leak
             )
         };
-        thread::spawn(move || Self::thread_main_loop(stop_requested, postponed_job_handle));
+        thread::spawn(move || {
+            Self::thread_main_loop(stop_requested, interval, postponed_job_handle)
+        });
 
         self.profile = Some(profile);
 
@@ -72,6 +138,7 @@ impl TimerThreadScheduler {
 
     fn thread_main_loop(
         stop_requested: Arc<AtomicBool>,
+        interval: Arc<Duration>,
         postponed_job_handle: rb_postponed_job_handle_t,
     ) {
         loop {
@@ -81,8 +148,8 @@ impl TimerThreadScheduler {
             unsafe {
                 rb_postponed_job_trigger(postponed_job_handle);
             }
-            // sleep for 50 ms
-            thread::sleep(Duration::from_millis(50));
+
+            thread::sleep(*interval);
         }
     }
 
@@ -136,7 +203,7 @@ impl TimerThreadScheduler {
                 continue;
             }
 
-            let sample = Sample::capture(*ruby_thread);
+            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.");
             }
@@ -164,10 +231,19 @@ impl TimerThreadScheduler {
 
     // 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, ruby_threads: VALUE, _: VALUE) -> VALUE {
+    pub unsafe extern "C" fn rb_start(rbself: VALUE) -> VALUE {
         let mut collector = Self::get_struct_from(rbself);
-        collector.start(rbself, ruby_threads)
+        collector.start(rbself)
     }
 
     // SampleCollector.stop

data/ext/pf2/src/util.rs

@@ -13,10 +13,10 @@ 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 {
+pub fn to_ruby_cfunc_with_no_args<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 {
+pub fn to_ruby_cfunc_with_args<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) }
 }
 

data/lib/pf2/reporter.rb

@@ -34,6 +34,11 @@ module Pf2
               color: "red",
               subcategories: ["Code"],
             },
+            {
+              name: "Native",
+              color: "blue",
+              subcategories: ["Code"],
+            },
             {
               name: "Native",
               color: "lightblue",
@@ -68,7 +73,7 @@ module Pf2
       def emit
         func_table = build_func_table
         frame_table = build_frame_table
-        stack_table = build_stack_table
+        stack_table = build_stack_table(func_table, frame_table)
         samples = build_samples
 
         string_table = build_string_table
@@ -173,8 +178,10 @@ module Pf2
         }
 
         @thread[:frames].each.with_index do |(id, frame), i|
-          ret[:name] << string_id(frame[:full_label])
-          ret[:is_js] << false
+          native = (frame[:entry_type] == 'Native')
+          label = "#{native ? "Native: " : ""}#{frame[:full_label]}"
+          ret[:name] << string_id(label)
+          ret[:is_js] << !native
           ret[:relevant_for_js] << false
           ret[:resource] << -1
           ret[:file_name] << nil
@@ -188,7 +195,7 @@ module Pf2
         ret
       end
 
-      def build_stack_table
+      def build_stack_table(func_table, frame_table)
         ret = {
           frame: [],
           category: [],
@@ -205,7 +212,7 @@ module Pf2
 
           prefix, node = queue.shift
           ret[:frame] << @frame_id_map[node[:frame_id]]
-          ret[:category] << 1
+          ret[:category] << (build_string_table[func_table[:name][frame_table[:func][@frame_id_map[node[:frame_id]]]]].start_with?('Native:') ? 2 : 1)
           ret[:subcategory] << nil
           ret[:prefix] << prefix