Clean up handling of intervals

Author: rylev

analyzeme/src/event.rs

@@ -1,7 +1,7 @@
 use crate::event_payload::EventPayload;
 use memchr::memchr;
 use std::borrow::Cow;
-use std::time::{Duration, SystemTime};
+use std::time::Duration;
 
 #[derive(Clone, Eq, PartialEq, Hash, Debug)]
 pub struct Event<'a> {
@@ -23,14 +23,6 @@ impl<'a> Event<'a> {
         self.payload.duration()
     }
 
-    pub fn start(&self) -> SystemTime {
-        self.payload.start()
-    }
-
-    pub fn end(&self) -> SystemTime {
-        self.payload.end()
-    }
-
     pub(crate) fn parse_event_id(event_id: Cow<'a, str>) -> (Cow<'a, str>, Vec<Cow<'a, str>>) {
         let event_id = match event_id {
             Cow::Owned(s) => Cow::Owned(s.into_bytes()),

analyzeme/src/event_payload.rs

@@ -39,9 +39,7 @@ impl EventPayload {
 
     pub fn duration(&self) -> Option<Duration> {
         match *self {
-            EventPayload::Timestamp(Timestamp::Interval { start, end }) => {
-                end.duration_since(start).ok()
-            }
+            EventPayload::Timestamp(t) => t.duration(),
             _ => None,
         }
     }
@@ -58,20 +56,6 @@ impl EventPayload {
         matches!(self, &Self::Integer(_))
     }
 
-    pub fn start(&self) -> SystemTime {
-        match *self {
-            Self::Timestamp(t) => t.start(),
-            _ => unreachable!(),
-        }
-    }
-
-    pub fn end(&self) -> SystemTime {
-        match *self {
-            Self::Timestamp(t) => t.end(),
-            _ => unreachable!(),
-        }
-    }
-
     pub fn timestamp(&self) -> Option<Timestamp> {
         match self {
             Self::Timestamp(t) => Some(*t),
@@ -123,4 +107,11 @@ impl Timestamp {
             Timestamp::Instant(t) => t,
         }
     }
+
+    pub fn duration(&self) -> Option<Duration> {
+        match *self {
+            Timestamp::Interval { start, end } => end.duration_since(start).ok(),
+            _ => None,
+        }
+    }
 }

analyzeme/src/lightweight_event.rs

@@ -27,12 +27,14 @@ impl<'a> LightweightEvent<'a> {
         self.payload.duration()
     }
 
-    pub fn start(&self) -> SystemTime {
-        self.payload.start()
+    // Returns start time if event is a timestamp
+    pub fn start(&self) -> Option<SystemTime> {
+        self.payload.timestamp().map(|t| t.start())
     }
 
-    pub fn end(&self) -> SystemTime {
-        self.payload.end()
+    // Returns end time if event is a timestamp
+    pub fn end(&self) -> Option<SystemTime> {
+        self.payload.timestamp().map(|t| t.end())
     }
 
     pub fn timestamp(&self) -> Option<Timestamp> {

analyzeme/src/stack_collapse.rs

@@ -26,17 +26,19 @@ pub fn collapse_stacks<'a>(profiling_data: &ProfilingData) -> FxHashMap<String,
         .rev()
         .filter(|e| e.payload.is_interval())
     {
+        let start = current_event.start().unwrap();
+        let end = current_event.end().unwrap();
         let thread = threads
             .entry(current_event.thread_id)
             .or_insert(PerThreadState {
                 stack: Vec::new(),
                 stack_id: "rustc".to_owned(),
-                start: current_event.start(),
-                end: current_event.end(),
+                start,
+                end,
                 total_event_time_nanos: 0,
             });
 
-        thread.start = cmp::min(thread.start, current_event.start());
+        thread.start = cmp::min(thread.start, start);
 
         // Pop all events from the stack that are not parents of the
         // current event.

crox/src/main.rs

@@ -152,7 +152,7 @@ fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
 
         // Chrome does not seem to like how many QueryCacheHit events we generate
         // only handle Interval events for now
-        for event in data.iter().filter(|e| !e.payload.is_instant()) {
+        for event in data.iter().filter(|e| e.payload.is_interval()) {
             let duration = event.duration().unwrap();
             if let Some(minimum_duration) = opt.minimum_duration {
                 if duration.as_micros() < minimum_duration {
@@ -164,7 +164,7 @@ fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
                 name: full_event.label.clone().into_owned(),
                 category: full_event.event_kind.clone().into_owned(),
                 event_type: EventType::Complete,
-                timestamp: event.payload.start().duration_since(UNIX_EPOCH).unwrap(),
+                timestamp: event.start().unwrap().duration_since(UNIX_EPOCH).unwrap(),
                 duration,
                 process_id: data.metadata.process_id,
                 thread_id: *thread_to_collapsed_thread

mmview/src/main.rs

@@ -18,7 +18,7 @@ fn main() -> Result<(), Box<dyn Error + Send + Sync>> {
 
     let data = ProfilingData::new(&opt.file_prefix)?;
 
-    if let Some(global_start_time) = data.iter().map(|e| e.payload.start()).min() {
+    if let Some(global_start_time) = data.iter().filter_map(|e| e.start()).min() {
         for event in data.iter() {
             if let Some(thread_id) = opt.thread_id {
                 if event.thread_id != thread_id {