Merge pull request #57 from wesleywiser/store_info

Store some metadata about the profile in a reserved string table slot

Author: wesleywiser

measureme/src/profiler.rs

@@ -1,7 +1,7 @@
 use crate::file_header::{write_file_header, FILE_MAGIC_EVENT_STREAM};
 use crate::raw_event::{RawEvent, Timestamp, TimestampKind};
 use crate::serialization::SerializationSink;
-use crate::stringtable::{SerializableString, StringId, StringTableBuilder};
+use crate::stringtable::{METADATA_STRING_ID, SerializableString, StringId, StringTableBuilder};
 use std::error::Error;
 use std::path::{Path, PathBuf};
 use std::sync::Arc;
@@ -42,11 +42,26 @@ impl<S: SerializationSink> Profiler<S> {
             Arc::new(S::from_path(&paths.string_index_file)?),
         );
 
-        Ok(Profiler {
+        let profiler = Profiler {
             event_sink,
             string_table,
             start_time: Instant::now(),
-        })
+        };
+
+        let mut args = String::new();
+        for arg in std::env::args() {
+            args.push_str(&arg.escape_default().to_string());
+            args.push(' ');
+        }
+
+        profiler.string_table.alloc_metadata(&*format!(
+            r#"{{ "start_time": {}, "process_id": {}, "cmd": "{}" }}"#,
+            std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_nanos(),
+            std::process::id(),
+            args,
+        ));
+
+        Ok(profiler)
     }
 
     #[inline(always)]

measureme/src/stringtable.rs

@@ -11,6 +11,23 @@
 //! content of its components. The content of a `TAG_STR_VAL` is its actual
 //! UTF-8 bytes. The content of a `TAG_STR_REF` is the contents of the entry
 //! it references.
+//!
+//! Each string is referred to via a `StringId`. `StringId`s may be generated in two ways:
+//!     1. Calling `StringTable::alloc()` which returns the `StringId` for the allocated string.
+//!     2. Calling `StringTable::alloc_with_reserved_id()` and `StringId::reserved()`.
+//!
+//! Reserved strings allow you to deduplicate strings by allocating a string once and then referring
+//! to it by id over and over. This is a useful trick for strings which are recorded many times and
+//! it can significantly reduce the size of profile trace files.
+//!
+//! `StringId`s are partitioned according to type:
+//!
+//! > [0 .. MAX_PRE_RESERVED_STRING_ID, METADATA_STRING_ID, .. ]
+//!
+//! From `0` to `MAX_PRE_RESERVED_STRING_ID` are the allowed values for reserved strings.
+//! After `MAX_PRE_RESERVED_STRING_ID`, there is one string id (`METADATA_STRING_ID`) which is used
+//! internally by `measureme` to record additional metadata about the profiling session.
+//! After `METADATA_STRING_ID` are all other `StringId` values.
 
 use crate::file_header::{
     read_file_header, strip_file_header, write_file_header, FILE_MAGIC_STRINGTABLE_DATA,
@@ -47,13 +64,17 @@ const TAG_STR_VAL: u8 = 1;
 /// Marks a component that contains the ID of another string.
 const TAG_STR_REF: u8 = 2;
 
+/// The maximum id value a prereserved string may be.
 const MAX_PRE_RESERVED_STRING_ID: u32 = std::u32::MAX / 2;
 
+/// The id of the profile metadata string entry.
+pub(crate) const METADATA_STRING_ID: u32 = MAX_PRE_RESERVED_STRING_ID + 1;
+
 /// Write-only version of the string table
 pub struct StringTableBuilder<S: SerializationSink> {
     data_sink: Arc<S>,
     index_sink: Arc<S>,
-    id_counter: AtomicU32, // initialized to MAX_PRE_RESERVED_STRING_ID + 1
+    id_counter: AtomicU32, // initialized to METADATA_STRING_ID + 1
 }
 
 /// Anything that implements `SerializableString` can be written to a
@@ -129,7 +150,7 @@ impl<S: SerializationSink> StringTableBuilder<S> {
         StringTableBuilder {
             data_sink,
             index_sink,
-            id_counter: AtomicU32::new(MAX_PRE_RESERVED_STRING_ID + 1),
+            id_counter: AtomicU32::new(METADATA_STRING_ID + 1),
         }
     }
 
@@ -144,10 +165,16 @@ impl<S: SerializationSink> StringTableBuilder<S> {
         id
     }
 
+    pub(crate) fn alloc_metadata<STR: SerializableString + ?Sized>(&self, s: &STR) -> StringId {
+        let id = StringId(METADATA_STRING_ID);
+        self.alloc_unchecked(id, s);
+        id
+    }
+
     #[inline]
     pub fn alloc<STR: SerializableString + ?Sized>(&self, s: &STR) -> StringId {
         let id = StringId(self.id_counter.fetch_add(1, Ordering::SeqCst));
-        debug_assert!(id.0 > MAX_PRE_RESERVED_STRING_ID);
+        debug_assert!(id.0 > METADATA_STRING_ID);
         self.alloc_unchecked(id, s);
         id
     }