mstange
diff --git a/‎Cargo.lock‎
Lines changed: 1 addition & 10 deletions b/‎Cargo.lock‎
Lines changed: 1 addition & 10 deletions
diff --git a/‎samply-markers/Cargo.toml‎
Lines changed: 2 additions & 2 deletions b/‎samply-markers/Cargo.toml‎
Lines changed: 2 additions & 2 deletions
diff --git a/‎samply-markers/src/marker/timestamp.rs‎
Lines changed: 10 additions & 16 deletions b/‎samply-markers/src/marker/timestamp.rs‎
Lines changed: 10 additions & 16 deletions
diff --git a/‎samply-markers/src/provider/unix.rs‎
Lines changed: 82 additions & 24 deletions b/‎samply-markers/src/provider/unix.rs‎
Lines changed: 82 additions & 24 deletions
@@ -14,14 +14,14 @@ keywords = ["profiling", "markers", "instrumentation", "tracing", "performance"]
 [features]
 default = []
 enabled = [
+    "dep:itoa",
     "dep:nix",
-    "dep:smallstr",
     "dep:tempfile",
 ]
 
 [target.'cfg(unix)'.dependencies]
+itoa = { version = "1.0.15", optional = true }
 nix = { version = "0.30.1", features = ["mman", "process", "time"], optional = true }
-smallstr = { version = "0.3.1", optional = true }
 tempfile = { version = "3.23.0", optional = true }
 
 [target.'cfg(target_os = "macos")'.dependencies]
 
@@ -38,16 +38,14 @@ impl SamplyTimestamp {
         Self(nanos)
     }
 
-    /// Formats a [`SamplyTimestamp`] without implementing [`std::fmt::Display`].
+    /// Returns the inner nanosecond value.
     ///
-    /// Having a dedicated formatter keeps [`SamplyTimestamp`] opaque, ensuring that it
-    /// cannot be stringified via [`ToString`] and compared.
+    /// This is only exposed within the crate for formatting and testing purposes,
+    /// keeping [`SamplyTimestamp`] opaque to external consumers.
+    #[inline]
     #[cfg(feature = "enabled")]
-    pub(crate) fn fmt<W>(self, writer: &mut W) -> std::fmt::Result
-    where
-        W: std::fmt::Write + ?Sized,
-    {
-        std::fmt::Write::write_fmt(writer, format_args!("{}", self.0))
+    pub(crate) const fn as_nanos(self) -> u64 {
+        self.0
     }
 }
 
@@ -83,16 +81,12 @@ mod test {
 
     #[test]
     #[cfg(feature = "enabled")]
-    fn fmt_writes_correctly() {
+    fn as_nanos_returns_correct_value() {
         let time = SamplyTimestamp::from_monotonic_nanos(9876543210);
-        let mut buffer = String::new();
-
-        let result = time.fmt(&mut buffer);
-        assert!(result.is_ok(), "Expected the fmt operation to succeed.");
-
         assert_eq!(
-            buffer, "9876543210",
-            "Expected the buffer to contain the formatted timestamp."
+            time.as_nanos(),
+            9876543210,
+            "Expected as_nanos to return the underlying nanosecond value."
         );
     }
 
 
@@ -2,6 +2,7 @@
 
 use std::cell::RefCell;
 use std::fs::File;
+use std::io::BufWriter;
 use std::io::Write;
 use std::num::NonZeroUsize;
 use std::path::Path;
@@ -22,10 +23,36 @@ use nix::time::ClockId;
 #[cfg(target_os = "linux")]
 use nix::time::clock_gettime;
 
-use smallstr::SmallString;
 use tempfile::TempDir;
 use tempfile::tempdir;
 
+/// A wrapper around [`std::io::BufWriter`] that flushes on drop to ensure data is written.
+///
+/// This is used in conjunction with [`std::thread_local!`] to ensure that buffers are
+/// flushed when the thread exits.
+struct FlushOnDrop(BufWriter<File>);
+
+impl Drop for FlushOnDrop {
+    fn drop(&mut self) {
+        if let Err(e) = self.0.flush() {
+            eprintln!("samply-markers: failed to flush marker-file buffer: {e}");
+        }
+    }
+}
+
+impl std::ops::Deref for FlushOnDrop {
+    type Target = BufWriter<File>;
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl std::ops::DerefMut for FlushOnDrop {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+
 /// A lazily created directory that holds per-thread mmapped marker files.
 static MARKERS_DIR: LazyLock<Option<PathBuf>> = LazyLock::new(|| {
     tempdir()
@@ -35,8 +62,8 @@ static MARKERS_DIR: LazyLock<Option<PathBuf>> = LazyLock::new(|| {
 });
 
 thread_local! {
-    /// A thread-local file used to append marker lines that samply will ingest.
-    static MARKER_FILE: RefCell<Option<File>> = RefCell::new(create_marker_file());
+    /// A thread-local buffered writer used to append marker lines that samply will ingest.
+    static MARKER_FILE: RefCell<Option<FlushOnDrop>> = RefCell::new(create_marker_file());
 }
 
 #[cfg(target_os = "macos")]
@@ -47,10 +74,12 @@ pub struct TimestampNowImpl;
 
 impl TimestampNowProvider for TimestampNowImpl {
     /// Queries the monotonic clock and converts the result to monotonic nanoseconds.
+    #[inline]
     fn now() -> SamplyTimestamp {
         #[cfg(target_os = "linux")]
         {
-            let now = clock_gettime(ClockId::CLOCK_MONOTONIC).unwrap();
+            let now = clock_gettime(ClockId::CLOCK_MONOTONIC)
+                .expect("samply-markers: unable to get time from CLOCK_MONOTONIC");
 
             // Monotonic nanoseconds should only ever be positive.
             #[allow(clippy::cast_sign_loss)]
@@ -94,15 +123,23 @@ pub struct WriteMarkerImpl;
 
 impl WriteMarkerProvider for WriteMarkerImpl {
     /// Serializes the marker to the thread-local file, creating it on demand.
+    #[inline]
     fn write_marker(start: SamplyTimestamp, end: SamplyTimestamp, marker: &SamplyMarker) {
-        let mut s = SmallString::<[u8; 64]>::new();
-        start.fmt(&mut s).unwrap();
-        s.push(' ');
-        end.fmt(&mut s).unwrap();
-        s.push(' ');
-        s.push_str(marker.name());
-        s.push('\n');
-        let _ = with_marker_file(|f| f.write_all(s.as_bytes()));
+        let () = MARKER_FILE.with_borrow_mut(|file| {
+            if let Some(f) = file.as_mut() {
+                // Use stack-allocated itoa buffers to format timestamps without heap allocation.
+                // Format: "{start_ns} {end_ns} {marker_name}\n"
+                let mut start_buf = itoa::Buffer::new();
+                let mut end_buf = itoa::Buffer::new();
+
+                let _ = f.write_all(start_buf.format(start.as_nanos()).as_bytes());
+                let _ = f.write_all(b" ");
+                let _ = f.write_all(end_buf.format(end.as_nanos()).as_bytes());
+                let _ = f.write_all(b" ");
+                let _ = f.write_all(marker.name().as_bytes());
+                let _ = f.write_all(b"\n");
+            }
+        });
     }
 }
 
@@ -111,16 +148,6 @@ fn markers_dir() -> Option<&'static Path> {
     Some(LazyLock::force(&MARKERS_DIR).as_ref()?)
 }
 
-/// Executes the provided closure with a mutable handle to the thread-local marker file.
-///
-/// Returns [`None`] when the file could not be prepared.
-fn with_marker_file<F, R>(f: F) -> Option<R>
-where
-    F: FnOnce(&mut File) -> R,
-{
-    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 {
@@ -159,7 +186,7 @@ fn get_thread_id() -> u32 {
 }
 
 /// Creates a new mmapped marker file for the current thread.
-fn create_marker_file() -> Option<File> {
+fn create_marker_file() -> Option<FlushOnDrop> {
     let file_name = markers_dir()?.join(format!(
         "marker-{}-{}.txt",
         nix::unistd::getpid().as_raw(),
@@ -216,5 +243,36 @@ fn create_marker_file() -> Option<File> {
     })
     .ok()?;
 
-    Some(file)
+    // I benchmarked the buffer size with hyperfine, using the Fibonacci example
+    // given n = 30, which generates about 2.7 million markers per run.
+    //
+    // Ubuntu results:
+    // ------------------------------------------
+    //     4 KiB: 470.9 ms ± 1.2 ms (5.3% slower)
+    //     8 KiB: 457.4 ms ± 2.1 ms (2.2% slower)
+    //    16 KiB: 451.0 ms ± 1.3 ms (0.8% slower)
+    //    32 KiB: 447.6 ms ± 1.5 ms (0.1% slower)
+    //    64 KiB: 447.4 ms ± 2.9 ms (optimal speed)
+    //   128 KiB: 448.6 ms ± 1.1 ms (0.3% slower)
+    //   256 KiB: 450.5 ms ± 1.4 ms (0.7% slower)
+    //   512 KiB: 450.1 ms ± 1.1 ms (0.6% slower)
+    //  1024 KiB: 449.9 ms ± 2.6 ms (0.6% slower)
+    //
+    // macOS results:
+    // ------------------------------------------
+    //     4 KiB: 303.0 ms ± 2.5 ms (43.9% slower)
+    //     8 KiB: 258.3 ms ± 1.2 ms (22.6% slower)
+    //    16 KiB: 236.4 ms ± 1.2 ms (12.2% slower)
+    //    32 KiB: 223.4 ms ± 0.7 ms (06.0% slower)
+    //    64 KiB: 217.2 ms ± 1.2 ms (03.1% slower)
+    //   128 KiB: 213.3 ms ± 0.7 ms (01.3% slower)
+    //   256 KiB: 211.9 ms ± 1.3 ms (00.6% slower)
+    //   512 KiB: 210.6 ms ± 0.7 ms (optimal speed)
+    //  1024 KiB: 210.7 ms ± 0.7 ms (00.0% slower)
+    //
+    // Even though macOS benefitted from a larger buffer size,
+    // I feel like a 512 KiB buffer per thread feels like overkill.
+    //
+    // 64 KiB feels like a good balance based on this benchmark.
+    Some(FlushOnDrop(BufWriter::with_capacity(64 * 1024, file)))
 }