Collect used addresses on demand.

Author: mstange

fxprof-processed-profile/src/frame_table.rs

@@ -4,7 +4,7 @@ use crate::category::{CategoryHandle, SubcategoryHandle, SubcategoryIndex};
 use crate::fast_hash_map::FastIndexSet;
 use crate::frame::FrameFlags;
 use crate::func_table::{FuncIndex, FuncKey, FuncTable};
-use crate::global_lib_table::{GlobalLibIndex, GlobalLibTable};
+use crate::global_lib_table::{GlobalLibIndex, UsedLibraryAddressesCollector};
 use crate::native_symbols::NativeSymbolIndex;
 use crate::resource_table::ResourceTable;
 use crate::serialization_helpers::SerializableSingleValueColumn;
@@ -22,31 +22,30 @@ impl FrameInterner {
         Default::default()
     }
 
-    pub fn index_for_frame(
-        &mut self,
-        frame: InternalFrame,
-        global_libs: &mut GlobalLibTable,
-    ) -> usize {
+    pub fn index_for_frame(&mut self, frame: InternalFrame) -> usize {
         let (frame_index, is_new) = self.frame_key_set.insert_full(frame);
 
-        if is_new {
-            if frame
+        if is_new
+            && frame
                 .flags
                 .intersects(FrameFlags::IS_JS | FrameFlags::IS_RELEVANT_FOR_JS)
-            {
-                self.contains_js_frame = true;
-            }
+        {
+            self.contains_js_frame = true;
+        }
+        frame_index
+    }
 
+    pub fn gather_used_rvas(&self, collector: &mut UsedLibraryAddressesCollector) {
+        for frame in &self.frame_key_set {
             if let InternalFrameVariant::Native(NativeFrameData {
                 lib,
                 relative_address,
                 ..
             }) = frame.variant
             {
-                global_libs.add_lib_used_rva(lib, relative_address);
+                collector.add_lib_used_rva(lib, relative_address);
             }
         }
-        frame_index
     }
 
     pub fn contains_js_frame(&self) -> bool {

fxprof-processed-profile/src/global_lib_table.rs

@@ -17,6 +17,10 @@ pub struct GlobalLibTable {
     /// Indexed by `GlobalLibIndex.0`.
     used_libs: Vec<LibraryHandle>, // append-only for stable GlobalLibIndexes
     used_lib_map: FastHashMap<LibraryHandle, GlobalLibIndex>,
+}
+
+#[derive(Debug)]
+pub struct UsedLibraryAddressesCollector {
     /// We keep track of RVA addresses that exist in frames that are assigned to this
     /// library, so that we can potentially provide symbolication info ahead of time.
     /// This is here instead of in `LibraryInfo` because we don't want to serialize it,
@@ -32,7 +36,6 @@ impl GlobalLibTable {
             symbol_tables: FastHashMap::default(),
             used_libs: Vec::new(),
             used_lib_map: FastHashMap::default(),
-            used_libs_seen_rvas: Vec::new(),
         }
     }
 
@@ -55,7 +58,6 @@ impl GlobalLibTable {
             let name_index = string_table.index_for_string(&lib.name);
             let index = GlobalLibIndex(used_libs.len(), name_index);
             used_libs.push(lib_handle);
-            self.used_libs_seen_rvas.push(BTreeSet::new());
             index
         })
     }
@@ -65,14 +67,26 @@ impl GlobalLibTable {
         self.symbol_tables.get(handle).map(|v| &**v)
     }
 
+    pub fn address_collector(&self) -> UsedLibraryAddressesCollector {
+        UsedLibraryAddressesCollector {
+            used_libs_seen_rvas: vec![BTreeSet::new(); self.used_libs.len()],
+        }
+    }
+}
+
+impl UsedLibraryAddressesCollector {
     pub fn add_lib_used_rva(&mut self, index: GlobalLibIndex, address: u32) {
         self.used_libs_seen_rvas[index.0].insert(address);
     }
 
-    pub fn lib_used_rva_iter(&self) -> UsedLibraryAddressesIterator {
+    pub fn into_address_iter(
+        self,
+        global_lib_table: &GlobalLibTable,
+    ) -> UsedLibraryAddressesIterator {
         UsedLibraryAddressesIterator {
             next_used_lib_index: 0,
-            global_lib_table: self,
+            used_libs_seen_rvas_iter: self.used_libs_seen_rvas.into_iter(),
+            global_lib_table,
         }
     }
 }
@@ -110,17 +124,15 @@ pub struct LibraryHandle(usize);
 /// in the profile.
 pub struct UsedLibraryAddressesIterator<'a> {
     next_used_lib_index: usize,
+    used_libs_seen_rvas_iter: std::vec::IntoIter<BTreeSet<u32>>,
     global_lib_table: &'a GlobalLibTable,
 }
 
 impl<'a> Iterator for UsedLibraryAddressesIterator<'a> {
-    type Item = (&'a LibraryInfo, &'a BTreeSet<u32>);
+    type Item = (&'a LibraryInfo, BTreeSet<u32>);
 
     fn next(&mut self) -> Option<Self::Item> {
-        let rvas = self
-            .global_lib_table
-            .used_libs_seen_rvas
-            .get(self.next_used_lib_index)?;
+        let rvas = self.used_libs_seen_rvas_iter.next()?;
 
         let lib_handle = self.global_lib_table.used_libs[self.next_used_lib_index];
         let info = &self.global_lib_table.all_libs[lib_handle.0];

fxprof-processed-profile/src/profile.rs

@@ -647,7 +647,7 @@ impl Profile {
             name,
             source_location: Default::default(),
         };
-        let frame_index = thread.frame_index_for_frame(internal_frame, &mut self.global_libs);
+        let frame_index = thread.frame_index_for_frame(internal_frame);
         FrameHandle(thread_handle, frame_index)
     }
 
@@ -691,7 +691,7 @@ impl Profile {
             source_location,
             flags,
         };
-        let frame_index = thread.frame_index_for_frame(internal_frame, &mut self.global_libs);
+        let frame_index = thread.frame_index_for_frame(internal_frame);
         FrameHandle(thread_handle, frame_index)
     }
 
@@ -771,7 +771,7 @@ impl Profile {
             source_location,
             flags,
         };
-        let frame_index = thread.frame_index_for_frame(internal_frame, &mut self.global_libs);
+        let frame_index = thread.frame_index_for_frame(internal_frame);
         FrameHandle(thread_handle, frame_index)
     }
 
@@ -1153,7 +1153,11 @@ impl Profile {
     /// Returns an iterator with information about which native library addresses
     /// are used by any stack frames stored in this profile.
     pub fn lib_used_rva_iter(&self) -> UsedLibraryAddressesIterator {
-        self.global_libs.lib_used_rva_iter()
+        let mut collector = self.global_libs.address_collector();
+        for thread in &self.threads {
+            thread.gather_used_rvas(&mut collector);
+        }
+        collector.into_address_iter(&self.global_libs)
     }
 
     fn resolve_frame_address(

fxprof-processed-profile/src/thread.rs

@@ -6,7 +6,7 @@ use serde::ser::{SerializeMap, Serializer};
 use crate::cpu_delta::CpuDelta;
 use crate::fast_hash_map::FastHashSet;
 use crate::frame_table::{FrameInterner, InternalFrame};
-use crate::global_lib_table::{GlobalLibIndex, GlobalLibTable};
+use crate::global_lib_table::{GlobalLibIndex, UsedLibraryAddressesCollector};
 use crate::marker_table::MarkerTable;
 use crate::markers::InternalMarkerSchema;
 use crate::native_symbols::{NativeSymbolIndex, NativeSymbols};
@@ -109,12 +109,8 @@ impl Thread {
             .get_native_symbol_name(native_symbol_index)
     }
 
-    pub fn frame_index_for_frame(
-        &mut self,
-        frame: InternalFrame,
-        global_libs: &mut GlobalLibTable,
-    ) -> usize {
-        self.frame_interner.index_for_frame(frame, global_libs)
+    pub fn frame_index_for_frame(&mut self, frame: InternalFrame) -> usize {
+        self.frame_interner.index_for_frame(frame)
     }
 
     pub fn stack_index_for_stack(&mut self, prefix: Option<usize>, frame: usize) -> usize {
@@ -191,6 +187,10 @@ impl Thread {
         self.frame_interner.contains_js_frame()
     }
 
+    pub fn gather_used_rvas(&self, collector: &mut UsedLibraryAddressesCollector) {
+        self.frame_interner.gather_used_rvas(collector);
+    }
+
     pub fn cmp_for_json_order(&self, other: &Thread) -> Ordering {
         let ordering = (!self.is_main).cmp(&(!other.is_main));
         if ordering != Ordering::Equal {

samply/src/shared/symbol_precog.rs

@@ -357,7 +357,7 @@ pub fn presymbolicate(
                         .as_ref()
                         .map(|id| wholesym::CodeId::from_str(id).expect("bad codeid")),
                 };
-                let rvas: Vec<u32> = rvas.iter().copied().collect();
+                let rvas: Vec<u32> = rvas.into_iter().collect();
                 (lib_info, rvas)
             })
             .collect();