Support samply-markers on macOS

This commit ensures that the `unix.rs` file correctly handles
emitting markers on macOS. I hadn't realized in previous commits
that the functionality was only working on Linux.

It should work on both systems now.

Author: nordzilla

Cargo.lock

@@ -24,6 +24,10 @@ nix = { version = "0.30.1", features = ["mman", "process", "time"], optional = t
 smallstr = { version = "0.3.1", optional = true }
 tempfile = { version = "3.23.0", optional = true }
 
+[target.'cfg(target_os = "macos")'.dependencies]
+libc = "0.2"
+mach2 = "0.4"
+
 [target.'cfg(unix)'.dev-dependencies]
 nix = { version = "0.30.1", features = ["process"] }
 regex = "1.12.2"

samply-markers/Cargo.toml

@@ -7,6 +7,8 @@ use std::num::NonZeroUsize;
 use std::path::Path;
 use std::path::PathBuf;
 use std::sync::LazyLock;
+#[cfg(target_os = "macos")]
+use std::sync::OnceLock;
 
 use crate::marker::SamplyMarker;
 use crate::marker::SamplyTimestamp;
@@ -15,7 +17,9 @@ use crate::provider::WriteMarkerProvider;
 
 use nix::sys::mman::MapFlags;
 use nix::sys::mman::ProtFlags;
+#[cfg(target_os = "linux")]
 use nix::time::ClockId;
+#[cfg(target_os = "linux")]
 use nix::time::clock_gettime;
 
 use smallstr::SmallString;
@@ -35,19 +39,47 @@ thread_local! {
     static MARKER_FILE: RefCell<Option<File>> = RefCell::new(create_marker_file());
 }
 
-/// A monotonic nanosecond timestamp backed by [`ClockId::CLOCK_MONOTONIC`].
+#[cfg(target_os = "macos")]
+static NANOS_PER_TICK: OnceLock<mach2::mach_time::mach_timebase_info> = OnceLock::new();
+
+/// A monotonic nanosecond timestamp implementation.
 pub struct TimestampNowImpl;
 
 impl TimestampNowProvider for TimestampNowImpl {
-    /// Queries `clock_gettime` and converts the result to monotonic nanoseconds.
+    /// Queries the monotonic clock and converts the result to monotonic nanoseconds.
     fn now() -> SamplyTimestamp {
-        let now = clock_gettime(ClockId::CLOCK_MONOTONIC).unwrap();
-
-        // Monotonic nanoseconds should only ever be positive.
-        #[allow(clippy::cast_sign_loss)]
-        SamplyTimestamp::from_monotonic_nanos(
-            now.tv_sec() as u64 * 1_000_000_000 + now.tv_nsec() as u64,
-        )
+        #[cfg(target_os = "linux")]
+        {
+            let now = clock_gettime(ClockId::CLOCK_MONOTONIC).unwrap();
+
+            // Monotonic nanoseconds should only ever be positive.
+            #[allow(clippy::cast_sign_loss)]
+            SamplyTimestamp::from_monotonic_nanos(
+                now.tv_sec() as u64 * 1_000_000_000 + now.tv_nsec() as u64,
+            )
+        }
+
+        // Use mach_absolute_time() to match samply's clock source on macOS.
+        // See https://github.com/mstange/samply/blob/2041b956f650bb92d912990052967d03fef66b75/samply/src/mac/time.rs#L8-L20
+        #[cfg(target_os = "macos")]
+        {
+            use mach2::mach_time;
+
+            let nanos_per_tick = NANOS_PER_TICK.get_or_init(|| {
+                let mut info = mach_time::mach_timebase_info::default();
+                let errno = unsafe { mach_time::mach_timebase_info(&raw mut info) };
+                if errno != 0 || info.denom == 0 {
+                    info.numer = 1;
+                    info.denom = 1;
+                }
+                info
+            });
+
+            let time = unsafe { mach_time::mach_absolute_time() };
+            let nanos = time * u64::from(nanos_per_tick.numer) / u64::from(nanos_per_tick.denom);
+
+            SamplyTimestamp::from_monotonic_nanos(nanos)
+        }
     }
 }
 
@@ -83,12 +115,46 @@ where
     MARKER_FILE.with_borrow_mut(|file| file.as_mut().map(f))
 }
 
+/// Returns a unique thread identifier for the current thread.
+#[cfg(target_os = "linux")]
+fn get_thread_id() -> u32 {
+    // Thread IDs on Linux are always positive, so the cast from i32 to u32 is safe.
+    #[allow(clippy::cast_sign_loss)]
+    let tid = nix::unistd::gettid().as_raw() as u32;
+
+    tid
+}
+
+/// Returns a unique thread identifier for the current thread.
+#[cfg(target_os = "macos")]
+fn get_thread_id() -> u32 {
+    // Use pthread_threadid_np() to get the current thread's system thread ID.
+    //
+    // This is the simplest way to get our own thread ID. Samply uses thread_info()
+    // instead because it's extracting thread IDs from other processes via mach ports.
+    //
+    // Both approaches return the same underlying system thread ID value.
+    //
+    // See https://github.com/mstange/samply/blob/2041b956f650bb92d912990052967d03fef66b75/samply/src/mac/thread_profiler.rs#L209-L229
+    let mut tid: u64 = 0;
+
+    unsafe {
+        libc::pthread_threadid_np(libc::pthread_self(), &raw mut tid);
+    }
+
+    // Truncate to u32 to match samply's behavior.
+    #[allow(clippy::cast_possible_truncation)]
+    let tid = tid as u32;
+
+    tid
+}
+
 /// Creates a new mmapped marker file for the current thread.
 fn create_marker_file() -> Option<File> {
     let file_name = markers_dir()?.join(format!(
         "marker-{}-{}.txt",
-        nix::unistd::getpid(),
-        nix::unistd::gettid()
+        nix::unistd::getpid().as_raw(),
+        get_thread_id()
     ));
 
     let file = File::options()

samply-markers/src/provider/unix.rs

@@ -9,6 +9,26 @@ use std::thread;
 use regex::Regex;
 use samply_markers::prelude::*;
 
+/// Returns a unique thread identifier for the current thread.
+#[cfg(target_os = "linux")]
+fn get_thread_id() -> u32 {
+    nix::unistd::gettid().as_raw() as u32
+}
+
+/// Returns a unique thread identifier for the current thread.
+#[cfg(target_os = "macos")]
+fn get_thread_id() -> u32 {
+    // Use pthread_threadid_np() to get the thread ID, same as samply does.
+    // This returns a u64 but we cast to u32 to match samply's behavior and
+    // ensure the thread ID fits in the marker filename format.
+    // See samply/src/mac/thread_profiler.rs:228
+    unsafe {
+        let mut tid: u64 = 0;
+        libc::pthread_threadid_np(libc::pthread_self(), &mut tid);
+        tid as u32
+    }
+}
+
 /// Asserts that the marker file for the given PID/TID matches the expected regex pattern(s).
 macro_rules! assert_marker_file {
     // Multiple regex patterns.
@@ -43,7 +63,7 @@ macro_rules! assert_marker_file {
 }
 
 /// Helper function to find marker files for a given PID/TID in the system temp directory
-fn find_marker_file(pid: nix::unistd::Pid, tid: nix::unistd::Pid) -> Option<std::path::PathBuf> {
+fn find_marker_file(pid: u32, tid: u32) -> Option<std::path::PathBuf> {
     let temp_dir = env::temp_dir();
     let pattern = format!("marker-{pid}-{tid}.txt");
 
@@ -73,8 +93,8 @@ fn instant_writes_marker_to_file() {
     samply_marker!({ name: "InstantMarker2" });
     samply_marker!({ name: "InstantMarker3" });
 
-    let pid = nix::unistd::getpid();
-    let tid = nix::unistd::gettid();
+    let pid = nix::unistd::getpid().as_raw() as u32;
+    let tid = get_thread_id();
 
     let contents = assert_marker_file!(
         pid,
@@ -112,8 +132,8 @@ fn interval_writes_marker_to_file() {
         thread::sleep(std::time::Duration::from_millis(4));
     }
 
-    let pid = nix::unistd::getpid();
-    let tid = nix::unistd::gettid();
+    let pid = nix::unistd::getpid().as_raw() as u32;
+    let tid = get_thread_id();
 
     let contents = assert_marker_file!(
         pid,
@@ -170,8 +190,8 @@ fn measure_writes_marker_to_file() {
         "Expected measure to preserve return value."
     );
 
-    let pid = nix::unistd::getpid();
-    let tid = nix::unistd::gettid();
+    let pid = nix::unistd::getpid().as_raw() as u32;
+    let tid = get_thread_id();
 
     let contents = assert_marker_file!(
         pid,
@@ -204,7 +224,7 @@ fn multiple_threads_create_separate_files() {
                 samply_marker!({ name: format!("thread {i} marker C") });
                 thread::sleep(std::time::Duration::from_millis(10));
 
-                nix::unistd::gettid()
+                get_thread_id()
             })
         })
         .collect::<Vec<_>>();
@@ -214,7 +234,7 @@ fn multiple_threads_create_separate_files() {
         .map(|h| h.join().expect("thread panicked"))
         .collect::<Vec<_>>();
 
-    let pid = nix::unistd::getpid();
+    let pid = nix::unistd::getpid().as_raw() as u32;
 
     for tid in tids {
         assert_marker_file!(