Add EventId type that gives additional guarantees on top of StringId.

Author: michaelwoerister

analyzeme/src/event.rs

@@ -104,7 +104,7 @@ impl<'a> Parser<'a> {
 
         self.pos = end;
 
-        if self.full_text[start .. end].iter().any(u8::is_ascii_control) {
+        if self.full_text[start..end].iter().any(u8::is_ascii_control) {
             return self.err("Found ASCII control character in <text>");
         }
 
@@ -166,8 +166,7 @@ mod tests {
 
     #[test]
     fn parse_event_id_n_args() {
-        let (label, args) =
-            Event::parse_event_id(Cow::from("foo\x1earg1\x1earg2\x1earg3"));
+        let (label, args) = Event::parse_event_id(Cow::from("foo\x1earg1\x1earg2\x1earg3"));
 
         assert_eq!(label, "foo");
         assert_eq!(

analyzeme/src/profiling_data.rs

@@ -7,7 +7,7 @@ use measureme::file_header::{
     FILE_MAGIC_EVENT_STREAM,
 };
 use measureme::ByteVecSink;
-use measureme::{ProfilerFiles, RawEvent, SerializationSink, StringTableBuilder};
+use measureme::{EventId, ProfilerFiles, RawEvent, SerializationSink, StringTableBuilder};
 use serde::{Deserialize, Deserializer};
 use std::error::Error;
 use std::fs;
@@ -94,7 +94,9 @@ impl ProfilingData {
 
         let timestamp = Timestamp::from_raw_event(&raw_event, self.metadata.start_time);
 
-        let event_id = string_table.get(raw_event.event_id).to_string();
+        let event_id = string_table
+            .get(raw_event.event_id.to_string_id())
+            .to_string();
         // Parse out the label and arguments from the `event_id`.
         let (label, additional_data) = Event::parse_event_id(event_id);
 
@@ -230,7 +232,7 @@ impl ProfilingDataBuilder {
         F: FnOnce(&mut Self),
     {
         let event_kind = self.string_table.alloc(event_kind);
-        let event_id = self.string_table.alloc(event_id);
+        let event_id = EventId::from_label(self.string_table.alloc(event_id));
 
         inner(self);
 
@@ -251,7 +253,7 @@ impl ProfilingDataBuilder {
         timestamp_nanos: u64,
     ) -> &mut Self {
         let event_kind = self.string_table.alloc(event_kind);
-        let event_id = self.string_table.alloc(event_id);
+        let event_id = EventId::from_label(self.string_table.alloc(event_id));
 
         let raw_event = RawEvent::new_instant(event_kind, event_id, thread_id, timestamp_nanos);
 

analyzeme/src/stringtable.rs

@@ -7,10 +7,10 @@ use measureme::file_header::{
 };
 use measureme::stringtable::{METADATA_STRING_ID, STRING_ID_MASK, TERMINATOR};
 use measureme::{Addr, StringId};
+use memchr::memchr;
 use rustc_hash::FxHashMap;
 use std::borrow::Cow;
 use std::error::Error;
-use memchr::memchr;
 
 fn deserialize_index_entry(bytes: &[u8]) -> (StringId, Addr) {
     (

analyzeme/src/testing_common.rs

@@ -1,6 +1,6 @@
 use crate::timestamp::Timestamp;
 use crate::{Event, ProfilingData};
-use measureme::{EventIdBuilder, Profiler, SerializationSink, StringId};
+use measureme::{EventId, EventIdBuilder, Profiler, SerializationSink, StringId};
 use rustc_hash::FxHashMap;
 use std::borrow::Cow;
 use std::default::Default;
@@ -26,11 +26,7 @@ struct ExpectedEvent {
 }
 
 impl ExpectedEvent {
-    fn new(
-        kind: &'static str,
-        label: &'static str,
-        args: &[&'static str]
-    ) -> ExpectedEvent {
+    fn new(kind: &'static str, label: &'static str, args: &[&'static str]) -> ExpectedEvent {
         ExpectedEvent {
             kind: Cow::from(kind),
             label: Cow::from(label),
@@ -47,21 +43,20 @@ fn generate_profiling_data<S: SerializationSink>(
 ) -> Vec<Event<'static>> {
     let profiler = Arc::new(Profiler::<S>::new(Path::new(filestem)).unwrap());
 
-    let event_id_virtual = StringId::new_virtual(42);
-
+    let event_id_virtual = EventId::from_label(StringId::new_virtual(42));
     let event_id_builder = EventIdBuilder::new(&profiler);
 
-    let event_ids = vec![
+    let event_ids: Vec<(StringId, EventId)> = vec![
         (
             profiler.alloc_string("Generic"),
-            profiler.alloc_string("SomeGenericActivity"),
+            EventId::from_label(profiler.alloc_string("SomeGenericActivity")),
         ),
         (profiler.alloc_string("Query"), event_id_virtual),
         (
             profiler.alloc_string("QueryWithArg"),
             event_id_builder.from_label_and_arg(
                 profiler.alloc_string("AQueryWithArg"),
-                profiler.alloc_string("some_arg")
+                profiler.alloc_string("some_arg"),
             ),
         ),
     ];
@@ -104,7 +99,7 @@ fn generate_profiling_data<S: SerializationSink>(
     // An example of allocating the string contents of an event id that has
     // already been used
     profiler.map_virtual_to_concrete_string(
-        event_id_virtual,
+        event_id_virtual.to_string_id(),
         profiler.alloc_string("SomeQuery")
     );
 
@@ -195,7 +190,7 @@ fn pseudo_invocation<S: SerializationSink>(
     random: usize,
     thread_id: u32,
     recursions_left: usize,
-    event_ids: &[(StringId, StringId)],
+    event_ids: &[(StringId, EventId)],
     expected_events_templates: &[ExpectedEvent],
     expected_events: &mut Vec<Event<'static>>,
 ) {

measureme/src/event_id.rs

@@ -13,10 +13,39 @@ use crate::{Profiler, SerializationSink, StringComponent, StringId};
 /// arguments. Future versions my support other optional suffixes (with a tag
 /// other than '\x11' after the '\x1E' separator), such as a "category".
 
-
 /// The byte used to separate arguments from the label and each other.
 pub const SEPARATOR_BYTE: &str = "\x1E";
 
+/// An `EventId` is a `StringId` with the additional guarantee that the
+/// corresponding string conforms to the event_id grammar.
+#[derive(Clone, Copy, Eq, PartialEq, Hash, Debug)]
+#[repr(C)]
+pub struct EventId(StringId);
+
+impl EventId {
+    pub const INVALID: EventId = EventId(StringId::INVALID);
+
+    #[inline]
+    pub fn to_string_id(self) -> StringId {
+        self.0
+    }
+
+    #[inline]
+    pub fn as_u32(self) -> u32 {
+        self.0.as_u32()
+    }
+
+    #[inline]
+    pub fn from_label(label: StringId) -> EventId {
+        EventId(label)
+    }
+
+    #[inline]
+    pub fn from_virtual(virtual_id: StringId) -> EventId {
+        EventId(virtual_id)
+    }
+}
+
 pub struct EventIdBuilder<'p, S: SerializationSink> {
     profiler: &'p Profiler<S>,
 }
@@ -26,19 +55,20 @@ impl<'p, S: SerializationSink> EventIdBuilder<'p, S> {
         EventIdBuilder { profiler }
     }
 
-    pub fn from_label(&self, label: StringId) -> StringId {
-        // Just forward the string ID, i single identifier is a valid event_id
-        label
+    #[inline]
+    pub fn from_label(&self, label: StringId) -> EventId {
+        // Just forward the string ID, a single identifier is a valid event_id
+        EventId::from_label(label)
     }
 
-    pub fn from_label_and_arg(&self, label: StringId, arg: StringId) -> StringId {
-        self.profiler.alloc_string(&[
+    pub fn from_label_and_arg(&self, label: StringId, arg: StringId) -> EventId {
+        EventId(self.profiler.alloc_string(&[
             // Label
             StringComponent::Ref(label),
             // Seperator and start tag for arg
             StringComponent::Value(SEPARATOR_BYTE),
             // Arg string id
             StringComponent::Ref(arg),
-        ])
+        ]))
     }
 }

measureme/src/lib.rs

@@ -50,7 +50,7 @@ pub mod stringtable;
 
 pub mod rustc;
 
-pub use crate::event_id::EventIdBuilder;
+pub use crate::event_id::{EventId, EventIdBuilder};
 #[cfg(any(not(target_arch = "wasm32"), target_os = "wasi"))]
 pub use crate::file_serialization_sink::FileSerializationSink;
 #[cfg(not(target_arch = "wasm32"))]

measureme/src/profiler.rs

@@ -1,3 +1,4 @@
+use crate::event_id::EventId;
 use crate::file_header::{write_file_header, FILE_MAGIC_EVENT_STREAM};
 use crate::raw_event::RawEvent;
 use crate::serialization::SerializationSink;
@@ -92,7 +93,7 @@ impl<S: SerializationSink> Profiler<S> {
 
     /// Records an event with the given parameters. The event time is computed
     /// automatically.
-    pub fn record_instant_event(&self, event_kind: StringId, event_id: StringId, thread_id: u32) {
+    pub fn record_instant_event(&self, event_kind: StringId, event_id: EventId, thread_id: u32) {
         let raw_event =
             RawEvent::new_instant(event_kind, event_id, thread_id, self.nanos_since_start());
 
@@ -105,7 +106,7 @@ impl<S: SerializationSink> Profiler<S> {
     pub fn start_recording_interval_event<'a>(
         &'a self,
         event_kind: StringId,
-        event_id: StringId,
+        event_id: EventId,
         thread_id: u32,
     ) -> TimingGuard<'a, S> {
         TimingGuard {
@@ -135,7 +136,7 @@ impl<S: SerializationSink> Profiler<S> {
 #[must_use]
 pub struct TimingGuard<'a, S: SerializationSink> {
     profiler: &'a Profiler<S>,
-    event_id: StringId,
+    event_id: EventId,
     event_kind: StringId,
     thread_id: u32,
     start_ns: u64,
@@ -157,11 +158,10 @@ impl<'a, S: SerializationSink> Drop for TimingGuard<'a, S> {
 }
 
 impl<'a, S: SerializationSink> TimingGuard<'a, S> {
-
     /// This method set a new `event_id` right before actually recording the
     /// event.
     #[inline]
-    pub fn finish_with_override_event_id(mut self, event_id: StringId) {
+    pub fn finish_with_override_event_id(mut self, event_id: EventId) {
         self.event_id = event_id;
         // Let's be explicit about it: Dropping the guard will record the event.
         drop(self)