Add RAII-based API for recording events.

Author: michaelwoerister

measureme/src/lib.rs

@@ -21,6 +21,10 @@
 //!   - `thread_id`: a `u64` id of the thread which is recording this event
 //!   - `timestamp_kind`: a [`TimestampKind`] which specifies how this event should be treated by `measureme` tooling
 //!
+//! Alternatively, events can also be recorded via the [`Profiler::start_recording_interval_event()`] method. This
+//! method records a "start" event and returns a `TimingGuard` object that will automatically record
+//! the corresponding "end" event when it is dropped.
+//!
 //! To create a [`StringId`], call one of the string allocation methods:
 //!   - [`Profiler::alloc_string()`]: allocates a string and returns the [`StringId`] that refers to it
 //!   - [`Profiler::alloc_string_with_reserved_id()`]: allocates a string using the specified [`StringId`].
@@ -41,6 +45,7 @@
 //! [`Profiler::alloc_string_with_reserved_id()`]: struct.Profiler.html#method.alloc_string_with_reserved_id
 //! [`Profiler::new()`]: struct.Profiler.html#method.new
 //! [`Profiler::record_event()`]: struct.Profiler.html#method.record_event
+//! [`Profiler::start_recording_interval_event()`]: struct.Profiler.html#method.start_recording_interval_event
 //! [`ProfilingData`]: struct.ProfilingData.html
 //! [`ProfilingData::iter()`]: struct.ProfilingData.html#method.iter
 //! [`ProfilingData::iter_matching_events()`]: struct.ProfilingData.html#method.iter_matching_events
@@ -69,7 +74,7 @@ pub use crate::event::Event;
 pub use crate::file_serialization_sink::FileSerializationSink;
 #[cfg(not(target_arch = "wasm32"))]
 pub use crate::mmap_serialization_sink::MmapSerializationSink;
-pub use crate::profiler::{Profiler, ProfilerFiles};
+pub use crate::profiler::{Profiler, ProfilerFiles, TimingGuard};
 pub use crate::profiling_data::{MatchingEvent, ProfilingData};
 pub use crate::raw_event::{RawEvent, Timestamp, TimestampKind};
 pub use crate::serialization::{Addr, SerializationSink};

measureme/src/profiler.rs

@@ -78,6 +78,8 @@ impl<S: SerializationSink> Profiler<S> {
         self.string_table.alloc(s)
     }
 
+    /// Records an event with the given parameters. The event time is computed
+    /// automatically.
     pub fn record_event(
         &self,
         event_kind: StringId,
@@ -90,17 +92,17 @@ impl<S: SerializationSink> Profiler<S> {
             + duration_since_start.subsec_nanos() as u64;
         let timestamp = Timestamp::new(nanos_since_start, timestamp_kind);
 
+        let raw_event = RawEvent {
+            event_kind,
+            id: event_id,
+            thread_id,
+            timestamp,
+        };
+
         self.event_sink
             .write_atomic(std::mem::size_of::<RawEvent>(), |bytes| {
                 debug_assert_eq!(bytes.len(), std::mem::size_of::<RawEvent>());
 
-                let raw_event = RawEvent {
-                    event_kind,
-                    id: event_id,
-                    thread_id,
-                    timestamp,
-                };
-
                 let raw_event_bytes: &[u8] = unsafe {
                     std::slice::from_raw_parts(
                         &raw_event as *const _ as *const u8,
@@ -111,4 +113,44 @@ impl<S: SerializationSink> Profiler<S> {
                 bytes.copy_from_slice(raw_event_bytes);
             });
     }
+
+    /// Creates a "start" event and returns a `TimingGuard` that will create
+    /// the corresponding "end" event when it is dropped.
+    pub fn start_recording_interval_event<'a>(
+        &'a self,
+        event_kind: StringId,
+        event_id: StringId,
+        thread_id: u64,
+    ) -> TimingGuard<'a, S> {
+        self.record_event(event_kind, event_id, thread_id, TimestampKind::Start);
+
+        TimingGuard {
+            profiler: self,
+            event_id,
+            event_kind,
+            thread_id,
+        }
+    }
+}
+
+/// When dropped, this `TimingGuard` will record an "end" event in the
+/// `Profiler` it was created by.
+#[must_use]
+pub struct TimingGuard<'a, S: SerializationSink> {
+    profiler: &'a Profiler<S>,
+    event_id: StringId,
+    event_kind: StringId,
+    thread_id: u64,
+}
+
+impl<'a, S: SerializationSink> Drop for TimingGuard<'a, S> {
+    #[inline]
+    fn drop(&mut self) {
+        self.profiler.record_event(
+            self.event_kind,
+            self.event_id,
+            self.thread_id,
+            TimestampKind::End
+        );
+    }
 }