pf2 0.5.0 → 0.5.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c4b713a9333a657f9b2259cdbae91e9aabde4312c2791a4dce517ce7d30cc46a
-  data.tar.gz: f01a941327ac6f2ce8b116a466a85a3021ffe0f612063b0f1466e7a31b373984
+  metadata.gz: 66bf1eb8d6457621a04819a8d100bdb109bf1fd7b4820eb1423a85dcfb91799c
+  data.tar.gz: b1046c04ae8a2a0630d3bd2ed86c4dc645a9ca42c8038bfaaee0be4c71dbec78
 SHA512:
-  metadata.gz: cf8c6b94d2a2ccee5912388a4f2f43f09612f9f3ba5a4ff10d615c7798bde30eb6061f03a9c79fa1ffe946da5f4a065eeae2bbe75ce1bb99821ce5253cc3ba9f
-  data.tar.gz: 50bd5c325fded53cf1585245469232c3fb184d1b3b893df0deb35a8f5d410046c3c821b1a27d468df6a3bb9ac8e2d7a12011aaa94a8d6889ca013dd4ec1f8eb1
+  metadata.gz: 5e8854a44c477c42dc9baa0a5b2cd95e19cd09a3c41fad0e950e7de6bd88ff90bf6a3d8e7b61c43c966976211047d5ecb6da11fbe5cba6460ab456186856e2b8
+  data.tar.gz: 8d577d2502f38dab61d3ab130f2555b314667c414ec13b2829f2e7fdf0ddf1f114310d560806685145e5ce65f7f24cc50f834f9fc6eb2b1e0d7763b8ebe69d5f

data/CHANGELOG.md

@@ -1,5 +1,18 @@
 ## [Unreleased]
 
+## [0.5.2] - 2024-07-13
+
+### Fixed
+
+- Properly default to TimerThread scheduler on non-Linux environments.
+
+
+## [0.5.1] - 2024-03-25
+
+### Fixed
+
+- Fixed compilation on non-Linux environments.
+
 
 ## [0.5.0] - 2024-03-25
 

data/README.md

@@ -58,7 +58,7 @@ File.write("my_program.pf2profile", profile)
 Profiles can be visualized using the [Firefox Profiler](https://profiler.firefox.com/).
 
 ```console
-$ pf2 -o report.json my_program.pf2profile
+$ pf2 report -o report.json my_program.pf2profile
 ```
 
 ### Configuration
@@ -108,9 +108,9 @@ Schedulers determine when to execute sample collection, based on configuration (
 
 #### SignalScheduler (Linux-only)
 
-The first is the `SignalScheduler`, based on POSIX timers. Pf2 will use this scheduler when possible. SignalScheduler creates a POSIX timer for each Ruby Thread (the underlying pthread to be more accurate) using `timer_create(3)`. This leaves the actual time-keeping to the OS, which is capable of tracking accurate per-thread CPU time usage.
+The first is the `SignalScheduler`, based on POSIX timers. Pf2 will use this scheduler when possible. SignalScheduler creates a POSIX timer for each Ruby Thread (the underlying pthread to be more accurate) using `timer_create(2)`. This leaves the actual time-keeping to the OS, which is capable of tracking accurate per-thread CPU time usage.
 
-When the specified interval has arrived (the timer has _expired_), the OS delivers us a SIGALRM (note: Unlike `setitimer(2)`, `timer_create(3)` allows us to choose which signal to be delivered, and Pf2 uses SIGALRM regardless of time mode). This is why the scheduler is named SignalScheduler.
+When the specified interval has arrived (the timer has _expired_), the OS delivers us a SIGALRM (note: Unlike `setitimer(2)`, `timer_create(2)` allows us to choose which signal to be delivered, and Pf2 uses SIGALRM regardless of time mode). This is why the scheduler is named SignalScheduler.
 
 Signals are directed to Ruby Threads' underlying pthread, effectively "pausing" the Thread's activity. This routing is done using `SIGEV_THREAD_ID`, which is a Linux-only feature. Sample collection is done in the signal handler, which is expected to be more _accurate_, capturing the paused Thread's activity.
 

data/ext/pf2/src/lib.rs

@@ -13,6 +13,8 @@ mod scheduler;
 mod session;
 #[cfg(target_os = "linux")]
 mod signal_scheduler;
+#[cfg(not(target_os = "linux"))]
+mod signal_scheduler_unsupported_platform;
 mod timer_thread_scheduler;
 mod util;
 

data/ext/pf2/src/ruby_internal_apis.rs

@@ -1,13 +1,20 @@
 #![allow(non_snake_case)]
 #![allow(non_camel_case_types)]
 
-use libc::{clockid_t, pthread_getcpuclockid, pthread_t};
+use libc::{clockid_t, pthread_t};
 use rb_sys::{rb_check_typeddata, rb_data_type_struct, RTypedData, VALUE};
 use std::ffi::{c_char, c_int, c_void};
 use std::mem::MaybeUninit;
 
-// Types and structs from Ruby 3.4.0.
+#[cfg(target_os = "linux")]
+use libc::pthread_getcpuclockid;
+
+#[cfg(not(target_os = "linux"))]
+pub unsafe fn pthread_getcpuclockid(thread: pthread_t, clk_id: *mut clockid_t) -> c_int {
+    unimplemented!()
+}
 
+// Types and structs from Ruby 3.4.0.
 #[repr(C)]
 pub struct rb_callable_method_entry_struct {
     /* same fields with rb_method_entry_t */

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

@@ -6,9 +6,16 @@ use rb_sys::*;
 
 use crate::util::cstr;
 
+#[cfg(target_os = "linux")]
 pub const DEFAULT_SCHEDULER: Scheduler = Scheduler::Signal;
-pub const DEFAULT_INTERVAL: Duration = Duration::from_millis(49);
+#[cfg(target_os = "linux")]
 pub const DEFAULT_TIME_MODE: TimeMode = TimeMode::CpuTime;
+#[cfg(not(target_os = "linux"))]
+pub const DEFAULT_SCHEDULER: Scheduler = Scheduler::TimerThread;
+#[cfg(not(target_os = "linux"))]
+pub const DEFAULT_TIME_MODE: TimeMode = TimeMode::WallTime;
+
+pub const DEFAULT_INTERVAL: Duration = Duration::from_millis(49);
 
 #[derive(Clone, Debug)]
 pub struct Configuration {

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

@@ -1,7 +1,7 @@
 use std::ffi::{c_int, c_void};
 use std::mem;
 use std::mem::ManuallyDrop;
-use std::ptr::null_mut;
+use std::ptr::{addr_of, null_mut};
 
 use rb_sys::*;
 
@@ -43,7 +43,7 @@ impl SessionRubyObject {
     // Extract the SessionRubyObject struct from a Ruby object
     unsafe fn get_struct_from(obj: VALUE) -> ManuallyDrop<Box<Self>> {
         unsafe {
-            let ptr = rb_check_typeddata(obj, &RBDATA);
+            let ptr = rb_check_typeddata(obj, addr_of!(RBDATA));
             ManuallyDrop::new(Box::from_raw(ptr as *mut SessionRubyObject))
         }
     }
@@ -55,7 +55,11 @@ 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, &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

@@ -16,7 +16,10 @@ use self::configuration::Configuration;
 use self::new_thread_watcher::NewThreadWatcher;
 use crate::profile::Profile;
 use crate::scheduler::Scheduler;
+#[cfg(target_os = "linux")]
 use crate::signal_scheduler::SignalScheduler;
+#[cfg(not(target_os = "linux"))]
+use crate::signal_scheduler_unsupported_platform::SignalScheduler;
 use crate::timer_thread_scheduler::TimerThreadScheduler;
 use crate::util::*;
 
@@ -90,12 +93,17 @@ impl Session {
             )),
         };
 
+        let running = Arc::new(AtomicBool::new(false));
+
         let new_thread_watcher = match threads {
             configuration::Threads::All => {
                 let scheduler = Arc::clone(&scheduler);
+                let running = Arc::clone(&running);
                 Some(NewThreadWatcher::watch(move |thread: VALUE| {
-                    log::debug!("New Ruby thread detected: {:?}", thread);
-                    scheduler.on_new_thread(thread);
+                    if running.load(Ordering::Relaxed) {
+                        log::debug!("New Ruby thread detected: {:?}", thread);
+                        scheduler.on_new_thread(thread);
+                    }
                 }))
             }
             configuration::Threads::Targeted(_) => None,
@@ -105,7 +113,7 @@ impl Session {
             configuration,
             scheduler,
             profile,
-            running: Arc::new(AtomicBool::new(false)),
+            running,
             new_thread_watcher,
         }
     }
@@ -176,15 +184,27 @@ impl Session {
             let ptr = rb_string_value_ptr(&mut str);
             CStr::from_ptr(ptr).to_str().unwrap()
         };
-        configuration::Scheduler::from_str(specified_scheduler).unwrap_or_else(|_| {
-            // Raise an ArgumentError if the mode is invalid
+        let scheduler =
+            configuration::Scheduler::from_str(specified_scheduler).unwrap_or_else(|_| {
+                // Raise an ArgumentError if the mode is invalid
+                unsafe {
+                    rb_raise(
+                        rb_eArgError,
+                        cstr!("Invalid scheduler. Valid values are ':signal' and ':timer_thread'."),
+                    )
+                }
+            });
+
+        // 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!("Invalid scheduler. Valid values are ':signal' and ':timer_thread'."),
+                    cstr!("Signal scheduler is not supported on this platform."),
                 )
             }
-        })
+        }
+        scheduler
     }
 
     pub fn start(&mut self) -> VALUE {

data/ext/pf2/src/signal_scheduler.rs

@@ -103,6 +103,7 @@ impl SignalScheduler {
         if err != 0 {
             panic!("sigaction failed: {}", err);
         }
+        log::debug!("Signal handler installed");
     }
 
     // Respond to the signal and collect a sample.

data/ext/pf2/src/signal_scheduler_unsupported_platform.rs

@@ -0,0 +1,39 @@
+use std::sync::{Arc, RwLock};
+
+use crate::profile::Profile;
+use crate::scheduler::Scheduler;
+use crate::session::configuration::Configuration;
+
+pub struct SignalScheduler {}
+
+impl Scheduler for SignalScheduler {
+    fn start(&self) -> rb_sys::VALUE {
+        unimplemented!()
+    }
+
+    fn stop(&self) -> rb_sys::VALUE {
+        unimplemented!()
+    }
+
+    fn on_new_thread(&self, thread: rb_sys::VALUE) {
+        unimplemented!()
+    }
+
+    fn dmark(&self) {
+        unimplemented!()
+    }
+
+    fn dfree(&self) {
+        unimplemented!()
+    }
+
+    fn dsize(&self) -> rb_sys::size_t {
+        unimplemented!()
+    }
+}
+
+impl SignalScheduler {
+    pub fn new(configuration: &Configuration, profile: Arc<RwLock<Profile>>) -> Self {
+        unimplemented!()
+    }
+}

data/lib/pf2/version.rb

@@ -1,3 +1,3 @@
 module Pf2
-  VERSION = '0.5.0'
+  VERSION = '0.5.2'
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: pf2
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.5.2
 platform: ruby
 authors:
 - Daisuke Aritomo
 bindir: exe
 cert_chain: []
-date: 2024-03-24 00:00:00.000000000 Z
+date: 2024-07-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
@@ -177,6 +177,7 @@ files:
 - ext/pf2/src/session/ruby_object.rs
 - ext/pf2/src/siginfo_t.c
 - ext/pf2/src/signal_scheduler.rs
+- ext/pf2/src/signal_scheduler_unsupported_platform.rs
 - ext/pf2/src/timer_thread_scheduler.rs
 - ext/pf2/src/util.rs
 - lib/pf2.rb