pf2 0.5.1 → 0.5.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 29a7c92a2a313dec57af9a3427cd723224f64bf53cf74a488253741e1098c12d
-  data.tar.gz: 4958d188fdddec9fb8143a1b864e9c40d989bbb3360745eb0846687cefc97b9d
+  metadata.gz: 66bf1eb8d6457621a04819a8d100bdb109bf1fd7b4820eb1423a85dcfb91799c
+  data.tar.gz: b1046c04ae8a2a0630d3bd2ed86c4dc645a9ca42c8038bfaaee0be4c71dbec78
 SHA512:
-  metadata.gz: 2a2a7ecd0a4cb0d84f022c3ec1e0844e2c537cfad88f91b0051609006d8c2f4d596f15a1fd259709c97c1ffccbae87e96758a4bcfb70293d88fb44d7888f4071
-  data.tar.gz: 28b108cd63c75d7ead6f34fdd88fdaa867a9601a0217899b024176a4e5508ef9dec7395bf7ae77513de6eb4cc765be90e010146bdd114b989b33359e4ac55068
+  metadata.gz: 5e8854a44c477c42dc9baa0a5b2cd95e19cd09a3c41fad0e950e7de6bd88ff90bf6a3d8e7b61c43c966976211047d5ecb6da11fbe5cba6460ab456186856e2b8
+  data.tar.gz: 8d577d2502f38dab61d3ab130f2555b314667c414ec13b2829f2e7fdf0ddf1f114310d560806685145e5ce65f7f24cc50f834f9fc6eb2b1e0d7763b8ebe69d5f

data/CHANGELOG.md

@@ -1,5 +1,11 @@
 ## [Unreleased]
 
+## [0.5.2] - 2024-07-13
+
+### Fixed
+
+- Properly default to TimerThread scheduler on non-Linux environments.
+
 
 ## [0.5.1] - 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/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

@@ -93,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,
@@ -108,7 +113,7 @@ impl Session {
             configuration,
             scheduler,
             profile,
-            running: Arc::new(AtomicBool::new(false)),
+            running,
             new_thread_watcher,
         }
     }

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/lib/pf2/version.rb

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

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: pf2
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  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