perf(profiling): drop unnecessary mapping ID (#925)

* perf(profiling): drop unnecessary mapping ID

This allows Location.mapping_id=0 in the final pprof, and since that's
the default for the field, it can be omitted altogether from the
profile. This shrinks every location entry on-wire by a few bytes
before compression.

* perf(profiling): optimize for zero-mapping

Author: morrisonlevi

profiling/src/internal/location.rs

@@ -10,7 +10,7 @@ use super::*;
 ///    struct.
 #[derive(Copy, Clone, Debug, Eq, PartialEq, Hash, PartialOrd, Ord)]
 pub struct Location {
-    pub mapping_id: MappingId,
+    pub mapping_id: Option<MappingId>,
     pub function_id: FunctionId,
     pub address: u64,
     pub line: i64,
@@ -26,7 +26,7 @@ impl PprofItem for Location {
     fn to_pprof(&self, id: Self::Id) -> Self::PprofMessage {
         pprof::Location {
             id: id.to_raw_id(),
-            mapping_id: self.mapping_id.to_raw_id(),
+            mapping_id: self.mapping_id.map(MappingId::into_raw_id).unwrap_or(0),
             address: self.address,
             lines: vec![pprof::Line {
                 function_id: self.function_id.to_raw_id(),

profiling/src/internal/profile/fuzz_tests.rs

@@ -277,7 +277,13 @@ fn assert_samples_eq(
             // `small_non_zero_pprof_id()` function which guarantees that the id stored in pprof
             // is +1 of the index in the vector of Locations in internal::Profile.
             let location = &profile.locations[*loc_id as usize - 1];
-            let mapping = &profile.mappings[location.mapping_id as usize - 1];
+
+            // PHP, Python, and Ruby don't use mappings, so allow for zero id.
+            let mapping = if location.mapping_id != 0 {
+                profile.mappings[location.mapping_id as usize - 1]
+            } else {
+                Default::default()
+            };
             // internal::Location::to_pprof() always creates a single line.
             assert!(location.lines.len() == 1);
             let line = location.lines[0];

profiling/src/internal/profile/mod.rs

@@ -467,33 +467,72 @@ impl Profile {
         })
     }
 
-    fn add_mapping(&mut self, mapping: &api::Mapping) -> MappingId {
+    fn add_mapping(&mut self, mapping: &api::Mapping) -> Option<MappingId> {
+        #[inline]
+        fn is_zero_mapping(mapping: &api::Mapping) -> bool {
+            // - PHP, Python, and Ruby use a mapping only as required.
+            // - .NET uses only the filename.
+            // - The native profiler uses all fields.
+            // We strike a balance for optimizing for the dynamic languages
+            // and the others by mixing branches and branchless programming.
+            let filename = mapping.filename.len();
+            let build_id = mapping.build_id.len();
+            if 0 != (filename | build_id) {
+                return false;
+            }
+
+            let memory_start = mapping.memory_start;
+            let memory_limit = mapping.memory_limit;
+            let file_offset = mapping.file_offset;
+            0 == (memory_start | memory_limit | file_offset)
+        }
+
+        if is_zero_mapping(mapping) {
+            return None;
+        }
+
         let filename = self.intern(mapping.filename);
         let build_id = self.intern(mapping.build_id);
 
-        self.mappings.dedup(Mapping {
+        Some(self.mappings.dedup(Mapping {
             memory_start: mapping.memory_start,
             memory_limit: mapping.memory_limit,
             file_offset: mapping.file_offset,
             filename,
             build_id,
-        })
+        }))
     }
 
     fn add_string_id_mapping(
         &mut self,
         mapping: &api::StringIdMapping,
-    ) -> anyhow::Result<MappingId> {
+    ) -> anyhow::Result<Option<MappingId>> {
+        #[inline]
+        fn is_zero_mapping(mapping: &api::StringIdMapping) -> bool {
+            // See the other is_zero_mapping for more info, but only Ruby is
+            // using this API at the moment, so we optimize for the whole
+            // thing being a zero representation.
+            let memory_start = mapping.memory_start;
+            let memory_limit = mapping.memory_limit;
+            let file_offset = mapping.file_offset;
+            let strings = (mapping.filename.value | mapping.build_id.value) as u64;
+            0 == (memory_start | memory_limit | file_offset | strings)
+        }
+
+        if is_zero_mapping(mapping) {
+            return Ok(None);
+        }
+
         let filename = self.resolve(mapping.filename)?;
         let build_id = self.resolve(mapping.build_id)?;
 
-        Ok(self.mappings.dedup(Mapping {
+        Ok(Some(self.mappings.dedup(Mapping {
             memory_start: mapping.memory_start,
             memory_limit: mapping.memory_limit,
             file_offset: mapping.file_offset,
             filename,
             build_id,
-        }))
+        })))
     }
 
     fn add_stacktrace(&mut self, locations: Vec<LocationId>) -> StackTraceId {