Build frame table columns during serialization.

Author: mstange

fxprof-processed-profile/src/frame_table.rs

@@ -8,27 +8,16 @@ use crate::global_lib_table::{GlobalLibIndex, GlobalLibTable};
 use crate::native_symbols::NativeSymbolIndex;
 use crate::resource_table::ResourceTable;
 use crate::serialization_helpers::SerializableSingleValueColumn;
-use crate::string_table::{ProfileStringTable, StringHandle};
+use crate::string_table::StringHandle;
 use crate::SourceLocation;
 
 #[derive(Debug, Clone, Default)]
-pub struct FrameTable {
-    func_table: FuncTable,
-    resource_table: ResourceTable,
-
-    func_col: Vec<FuncIndex>,
-    category_col: Vec<CategoryHandle>,
-    subcategory_col: Vec<SubcategoryIndex>,
-    line_col: Vec<Option<u32>>,
-    column_col: Vec<Option<u32>>,
-    address_col: Vec<Option<u32>>,
-    native_symbol_col: Vec<Option<NativeSymbolIndex>>,
-    inline_depth_col: Vec<u16>,
-
+pub struct FrameInterner {
     frame_key_set: FastIndexSet<InternalFrame>,
+    contains_js_frame: bool,
 }
 
-impl FrameTable {
+impl FrameInterner {
     pub fn new() -> Self {
         Default::default()
     }
@@ -37,86 +26,119 @@ impl FrameTable {
         &mut self,
         frame: InternalFrame,
         global_libs: &mut GlobalLibTable,
-        string_table: &mut ProfileStringTable,
     ) -> usize {
         let (frame_index, is_new) = self.frame_key_set.insert_full(frame);
 
-        if !is_new {
-            return frame_index;
-        }
-
-        let func_key = frame.func_key();
-        let func = self.func_table.index_for_func(
-            func_key,
-            &mut self.resource_table,
-            global_libs,
-            string_table,
-        );
-
-        self.func_col.push(func);
-        let SubcategoryHandle(category, subcategory) = frame.subcategory;
-        self.category_col.push(category);
-        self.subcategory_col.push(subcategory);
-        self.line_col.push(frame.source_location.line);
-        self.column_col.push(frame.source_location.col);
-
-        match frame.variant {
-            InternalFrameVariant::Label => {
-                self.address_col.push(None);
-                self.native_symbol_col.push(None);
-                self.inline_depth_col.push(0);
+        if is_new {
+            if frame
+                .flags
+                .intersects(FrameFlags::IS_JS | FrameFlags::IS_RELEVANT_FOR_JS)
+            {
+                self.contains_js_frame = true;
             }
-            InternalFrameVariant::Native(NativeFrameData {
+
+            if let InternalFrameVariant::Native(NativeFrameData {
                 lib,
-                native_symbol,
                 relative_address,
-                inline_depth,
-            }) => {
+                ..
+            }) = frame.variant
+            {
                 global_libs.add_lib_used_rva(lib, relative_address);
-
-                self.address_col.push(Some(relative_address));
-                self.native_symbol_col.push(native_symbol);
-                self.inline_depth_col.push(inline_depth);
             }
         }
-
         frame_index
     }
 
     pub fn contains_js_frame(&self) -> bool {
-        self.func_table.contains_js_func()
+        self.contains_js_frame
     }
 
-    pub fn get_serializable_tables(
-        &self,
-    ) -> (SerializableFrameTable<'_>, &'_ FuncTable, &'_ ResourceTable) {
-        (
-            SerializableFrameTable(self),
-            &self.func_table,
-            &self.resource_table,
-        )
+    pub fn create_tables(&self) -> (FrameTable, FuncTable, ResourceTable) {
+        let len = self.frame_key_set.len();
+        let mut func_col = Vec::with_capacity(len);
+        let mut category_col = Vec::with_capacity(len);
+        let mut subcategory_col = Vec::with_capacity(len);
+        let mut line_col = Vec::with_capacity(len);
+        let mut column_col = Vec::with_capacity(len);
+        let mut address_col = Vec::with_capacity(len);
+        let mut native_symbol_col = Vec::with_capacity(len);
+        let mut inline_depth_col = Vec::with_capacity(len);
+
+        let mut func_table = FuncTable::default();
+        let mut resource_table = ResourceTable::default();
+
+        for frame in &self.frame_key_set {
+            let func_key = frame.func_key();
+            let func = func_table.index_for_func(func_key, &mut resource_table);
+
+            func_col.push(func);
+            let SubcategoryHandle(category, subcategory) = frame.subcategory;
+            category_col.push(category);
+            subcategory_col.push(subcategory);
+            line_col.push(frame.source_location.line);
+            column_col.push(frame.source_location.col);
+
+            match frame.variant {
+                InternalFrameVariant::Label => {
+                    address_col.push(None);
+                    native_symbol_col.push(None);
+                    inline_depth_col.push(0);
+                }
+                InternalFrameVariant::Native(NativeFrameData {
+                    native_symbol,
+                    relative_address,
+                    inline_depth,
+                    ..
+                }) => {
+                    address_col.push(Some(relative_address));
+                    native_symbol_col.push(native_symbol);
+                    inline_depth_col.push(inline_depth);
+                }
+            }
+        }
+
+        let frame_table = FrameTable {
+            func_col,
+            category_col,
+            subcategory_col,
+            line_col,
+            column_col,
+            address_col,
+            native_symbol_col,
+            inline_depth_col,
+        };
+
+        (frame_table, func_table, resource_table)
     }
 }
 
-pub struct SerializableFrameTable<'a>(&'a FrameTable);
+pub struct FrameTable {
+    func_col: Vec<FuncIndex>,
+    category_col: Vec<CategoryHandle>,
+    subcategory_col: Vec<SubcategoryIndex>,
+    line_col: Vec<Option<u32>>,
+    column_col: Vec<Option<u32>>,
+    address_col: Vec<Option<u32>>,
+    native_symbol_col: Vec<Option<NativeSymbolIndex>>,
+    inline_depth_col: Vec<u16>,
+}
 
-impl Serialize for SerializableFrameTable<'_> {
+impl Serialize for FrameTable {
     fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
-        let SerializableFrameTable(table) = self;
-        let len = table.func_col.len();
+        let len = self.func_col.len();
         let mut map = serializer.serialize_map(None)?;
         map.serialize_entry("length", &len)?;
-        map.serialize_entry("func", &table.func_col)?;
-        map.serialize_entry("category", &table.category_col)?;
-        map.serialize_entry("subcategory", &table.subcategory_col)?;
-        map.serialize_entry("line", &table.line_col)?;
-        map.serialize_entry("column", &table.column_col)?;
+        map.serialize_entry("func", &self.func_col)?;
+        map.serialize_entry("category", &self.category_col)?;
+        map.serialize_entry("subcategory", &self.subcategory_col)?;
+        map.serialize_entry("line", &self.line_col)?;
+        map.serialize_entry("column", &self.column_col)?;
         map.serialize_entry(
             "address",
-            &SerializableFrameTableAddressColumn(&table.address_col),
+            &SerializableFrameTableAddressColumn(&self.address_col),
         )?;
-        map.serialize_entry("nativeSymbol", &table.native_symbol_col)?;
-        map.serialize_entry("inlineDepth", &table.inline_depth_col)?;
+        map.serialize_entry("nativeSymbol", &self.native_symbol_col)?;
+        map.serialize_entry("inlineDepth", &self.inline_depth_col)?;
         map.serialize_entry("innerWindowID", &SerializableSingleValueColumn(0, len))?;
         map.end()
     }

fxprof-processed-profile/src/func_table.rs

@@ -2,10 +2,10 @@ use serde::ser::{Serialize, SerializeMap, SerializeSeq, Serializer};
 
 use crate::fast_hash_map::FastIndexSet;
 use crate::frame::FrameFlags;
-use crate::global_lib_table::{GlobalLibIndex, GlobalLibTable};
+use crate::global_lib_table::GlobalLibIndex;
 use crate::resource_table::{ResourceIndex, ResourceTable};
 use crate::serialization_helpers::SerializableSingleValueColumn;
-use crate::string_table::{ProfileStringTable, StringHandle};
+use crate::string_table::StringHandle;
 
 #[derive(Debug, Clone, Default)]
 pub struct FuncTable {
@@ -15,8 +15,6 @@ pub struct FuncTable {
     flags: Vec<FrameFlags>,
 
     func_key_set: FastIndexSet<FuncKey>,
-
-    contains_js_func: bool,
 }
 
 #[derive(Debug, Clone, Copy, PartialOrd, Ord, PartialEq, Eq, Hash)]
@@ -32,8 +30,6 @@ impl FuncTable {
         &mut self,
         func_key: FuncKey,
         resource_table: &mut ResourceTable,
-        global_libs: &mut GlobalLibTable,
-        string_table: &mut ProfileStringTable,
     ) -> FuncIndex {
         let (index, is_new) = self.func_key_set.insert_full(func_key);
 
@@ -49,24 +45,15 @@ impl FuncTable {
             flags,
         } = func_key;
 
-        let resource =
-            lib.map(|lib| resource_table.resource_for_lib(lib, global_libs, string_table));
+        let resource = lib.map(|lib| resource_table.resource_for_lib(lib));
 
         self.names.push(name);
         self.files.push(file_path);
         self.resources.push(resource);
         self.flags.push(flags);
 
-        if flags.intersects(FrameFlags::IS_JS | FrameFlags::IS_RELEVANT_FOR_JS) {
-            self.contains_js_func = true;
-        }
-
         func_index
     }
-
-    pub fn contains_js_func(&self) -> bool {
-        self.contains_js_func
-    }
 }
 
 #[derive(Debug, Clone, Copy, PartialOrd, Ord, PartialEq, Eq, Hash)]

fxprof-processed-profile/src/global_lib_table.rs

@@ -4,7 +4,8 @@ use std::sync::Arc;
 use serde::ser::{Serialize, Serializer};
 
 use crate::fast_hash_map::{FastHashMap, FastIndexSet};
-use crate::{LibraryInfo, SymbolTable};
+use crate::string_table::ProfileStringTable;
+use crate::{LibraryInfo, StringHandle, SymbolTable};
 
 #[derive(Debug)]
 pub struct GlobalLibTable {
@@ -43,21 +44,22 @@ impl GlobalLibTable {
         self.symbol_tables.insert(library, symbol_table);
     }
 
-    pub fn index_for_used_lib(&mut self, lib_handle: LibraryHandle) -> GlobalLibIndex {
+    pub fn index_for_used_lib(
+        &mut self,
+        lib_handle: LibraryHandle,
+        string_table: &mut ProfileStringTable,
+    ) -> GlobalLibIndex {
         let used_libs = &mut self.used_libs;
         *self.used_lib_map.entry(lib_handle).or_insert_with(|| {
-            let index = GlobalLibIndex(used_libs.len());
+            let lib = self.all_libs.get_index(lib_handle.0).unwrap();
+            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
         })
     }
 
-    pub fn get_lib(&self, index: GlobalLibIndex) -> Option<&LibraryInfo> {
-        let handle = self.used_libs.get(index.0)?;
-        self.all_libs.get_index(handle.0)
-    }
-
     pub fn get_lib_symbol_table(&self, index: GlobalLibIndex) -> Option<&SymbolTable> {
         let handle = self.used_libs.get(index.0)?;
         self.symbol_tables.get(handle).map(|v| &**v)
@@ -84,14 +86,20 @@ impl Serialize for GlobalLibTable {
 /// An index for a *used* library, i.e. a library for which there exists at
 /// least one frame in any process's frame table which refers to this lib.
 #[derive(Debug, Clone, Copy, PartialOrd, Ord, PartialEq, Eq, Hash)]
-pub struct GlobalLibIndex(usize);
+pub struct GlobalLibIndex(usize, StringHandle);
 
 impl Serialize for GlobalLibIndex {
     fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
         serializer.serialize_u32(self.0 as u32)
     }
 }
 
+impl GlobalLibIndex {
+    pub fn name_string_index(&self) -> StringHandle {
+        self.1
+    }
+}
+
 /// The handle for a library, obtained from [`Profile::add_lib`](crate::Profile::add_lib).
 #[derive(Debug, Clone, Copy, PartialOrd, Ord, PartialEq, Eq, Hash)]
 pub struct LibraryHandle(usize);

fxprof-processed-profile/src/process.rs

@@ -4,6 +4,7 @@ use std::hash::Hash;
 use crate::frame_table::InternalFrameAddress;
 use crate::global_lib_table::{GlobalLibTable, LibraryHandle};
 use crate::lib_mappings::LibMappings;
+use crate::string_table::ProfileStringTable;
 use crate::Timestamp;
 
 /// A thread. Can be created with [`Profile::add_thread`](crate::Profile::add_thread).
@@ -90,6 +91,7 @@ impl Process {
         &mut self,
         global_libs: &mut GlobalLibTable,
         kernel_libs: &mut LibMappings<LibraryHandle>,
+        string_table: &mut ProfileStringTable,
         address: u64,
     ) -> InternalFrameAddress {
         // Try to find the address in the kernel libs first, and then in the process libs.
@@ -98,7 +100,7 @@ impl Process {
             .or_else(|| self.libs.convert_address(address))
         {
             Some((relative_address, lib_handle)) => {
-                let global_lib_index = global_libs.index_for_used_lib(*lib_handle);
+                let global_lib_index = global_libs.index_for_used_lib(*lib_handle, string_table);
                 InternalFrameAddress::InLib(relative_address, global_lib_index)
             }
             None => InternalFrameAddress::Unknown(address),