Support richer frame information in fxprof-processed-profile (#525)

Inline depth, both address and symbol name, file / line / column info

Author: mstange

fxprof-processed-profile/src/frame.rs

@@ -1,12 +1,10 @@
 use bitflags::bitflags;
 
-use crate::category::SubcategoryHandle;
 use crate::global_lib_table::LibraryHandle;
-use crate::profile::StringHandle;
 
-/// A part of the information about a single stack frame.
+/// The address information of a stack frame.
 #[derive(Debug, Clone, PartialOrd, Ord, PartialEq, Eq)]
-pub enum Frame {
+pub enum FrameAddress {
     /// A code address taken from the instruction pointer.
     ///
     /// This code address will be resolved to a library-relative address using
@@ -45,20 +43,6 @@ pub enum Frame {
     /// A relative address taken from an adjusted return address which
     /// has already been resolved to a `LibraryHandle`.
     RelativeAddressFromAdjustedReturnAddress(LibraryHandle, u32),
-    /// A string, containing an index returned by
-    /// [`Profile::handle_for_string`](crate::Profile::handle_for_string).
-    Label(StringHandle),
-}
-
-/// All the information about a single stack frame.
-#[derive(Debug, Clone, PartialOrd, Ord, PartialEq, Eq)]
-pub struct FrameInfo {
-    /// The absolute address or label of this frame.
-    pub frame: Frame,
-    /// The subcategory of this frame.
-    pub subcategory: SubcategoryHandle,
-    /// The flags of this frame. Use `FrameFlags::empty()` if unsure.
-    pub flags: FrameFlags,
 }
 
 bitflags! {

fxprof-processed-profile/src/frame_table.rs

@@ -5,19 +5,26 @@ use crate::fast_hash_map::FastHashMap;
 use crate::frame::FrameFlags;
 use crate::func_table::{FuncIndex, FuncTable};
 use crate::global_lib_table::{GlobalLibIndex, GlobalLibTable};
-use crate::native_symbols::{NativeSymbolIndex, NativeSymbols};
+use crate::native_symbols::NativeSymbolIndex;
 use crate::resource_table::ResourceTable;
 use crate::serialization_helpers::SerializableSingleValueColumn;
 use crate::thread_string_table::{ThreadInternalStringIndex, ThreadStringTable};
 
 #[derive(Debug, Clone, Default)]
 pub struct FrameTable {
-    addresses: Vec<Option<u32>>,
-    categories: Vec<CategoryHandle>,
-    subcategories: Vec<SubcategoryIndex>,
-    funcs: Vec<FuncIndex>,
-    native_symbols: Vec<Option<NativeSymbolIndex>>,
-    internal_frame_to_frame_index: FastHashMap<InternalFrame, usize>,
+    name_col: Vec<ThreadInternalStringIndex>,
+    category_col: Vec<CategoryHandle>,
+    subcategory_col: Vec<SubcategoryIndex>,
+    flags_col: Vec<FrameFlags>,
+    file_col: Vec<Option<ThreadInternalStringIndex>>,
+    line_col: Vec<Option<u32>>,
+    column_col: Vec<Option<u32>>,
+    lib_col: Vec<Option<GlobalLibIndex>>,
+    address_col: Vec<Option<u32>>,
+    native_symbol_col: Vec<Option<NativeSymbolIndex>>,
+    inline_depth_col: Vec<u16>,
+    frame_key_to_frame_index: FastHashMap<InternalFrameKey, usize>,
+    contains_js_frame: bool,
 }
 
 impl FrameTable {
@@ -27,91 +34,130 @@ impl FrameTable {
 
     pub fn index_for_frame(
         &mut self,
-        string_table: &mut ThreadStringTable,
-        resource_table: &mut ResourceTable,
-        func_table: &mut FuncTable,
-        native_symbol_table: &mut NativeSymbols,
-        global_libs: &mut GlobalLibTable,
         frame: InternalFrame,
+        global_lib_index_to_thread_string_index: &mut FastHashMap<
+            GlobalLibIndex,
+            ThreadInternalStringIndex,
+        >,
+        global_libs: &mut GlobalLibTable,
+        string_table: &mut ThreadStringTable,
     ) -> usize {
-        let addresses = &mut self.addresses;
-        let funcs = &mut self.funcs;
-        let native_symbols = &mut self.native_symbols;
-        let categories = &mut self.categories;
-        let subcategories = &mut self.subcategories;
-        *self
-            .internal_frame_to_frame_index
-            .entry(frame.clone())
-            .or_insert_with(|| {
-                let frame_index = addresses.len();
-                let (address, location_string_index, native_symbol, resource) = match frame.location
-                {
-                    InternalFrameLocation::UnknownAddress(address) => {
-                        let location_string = format!("0x{address:x}");
-                        let s = string_table.index_for_string(&location_string);
-                        (None, s, None, None)
-                    }
-                    InternalFrameLocation::AddressInLib(address, lib_index) => {
-                        let res =
-                            resource_table.resource_for_lib(lib_index, global_libs, string_table);
-                        let lib = global_libs.get_lib(lib_index).unwrap();
-                        let native_symbol_and_name =
-                            lib.symbol_table.as_deref().and_then(|symbol_table| {
-                                let symbol = symbol_table.lookup(address)?;
-                                Some(
-                                    native_symbol_table.symbol_index_and_string_index_for_symbol(
-                                        lib_index,
-                                        symbol,
-                                        string_table,
-                                    ),
-                                )
-                            });
-                        let (native_symbol, s) = match native_symbol_and_name {
-                            Some((native_symbol, name_string_index)) => {
-                                (Some(native_symbol), name_string_index)
-                            }
-                            None => {
-                                // This isn't in the pre-provided symbol table, and we know it's in a library.
-                                global_libs.add_lib_used_rva(lib_index, address);
-
-                                let location_string = format!("0x{address:x}");
-                                (None, string_table.index_for_string(&location_string))
-                            }
-                        };
-                        (Some(address), s, native_symbol, Some(res))
-                    }
-                    InternalFrameLocation::Label(string_index) => (None, string_index, None, None),
-                };
-                let func_index =
-                    func_table.index_for_func(location_string_index, resource, frame.flags);
-                let SubcategoryHandle(category, subcategory) = frame.subcategory;
-                addresses.push(address);
-                categories.push(category);
-                subcategories.push(subcategory);
-                funcs.push(func_index);
-                native_symbols.push(native_symbol);
-                frame_index
+        if let Some(index) = self.frame_key_to_frame_index.get(&frame.key) {
+            return *index;
+        }
+
+        let flags = frame.key.flags;
+
+        let frame_index = self.name_col.len();
+        let SubcategoryHandle(category, subcategory) = frame.key.subcategory;
+        self.name_col.push(frame.name);
+        self.category_col.push(category);
+        self.subcategory_col.push(subcategory);
+        self.flags_col.push(flags);
+
+        match frame.key.variant {
+            InternalFrameKeyVariant::Label {
+                file_path,
+                line,
+                col,
+                ..
+            } => {
+                self.file_col.push(file_path);
+                self.line_col.push(line);
+                self.column_col.push(col);
+                self.lib_col.push(None);
+                self.address_col.push(None);
+                self.native_symbol_col.push(None);
+                self.inline_depth_col.push(0);
+            }
+            InternalFrameKeyVariant::Native {
+                lib,
+                relative_address,
+                inline_depth,
+            } => {
+                self.file_col.push(None);
+                self.line_col.push(None);
+                self.column_col.push(None);
+                self.lib_col.push(Some(lib));
+                self.address_col.push(Some(relative_address));
+                self.native_symbol_col.push(frame.native_symbol);
+                self.inline_depth_col.push(inline_depth);
+
+                global_libs.add_lib_used_rva(lib, relative_address);
+
+                global_lib_index_to_thread_string_index
+                    .entry(lib)
+                    .or_insert_with(|| {
+                        let lib_name = &global_libs.get_lib(lib).unwrap().name;
+                        string_table.index_for_string(lib_name)
+                    });
+            }
+        }
+
+        self.frame_key_to_frame_index.insert(frame.key, frame_index);
+
+        if flags.intersects(FrameFlags::IS_JS | FrameFlags::IS_RELEVANT_FOR_JS) {
+            self.contains_js_frame = true;
+        }
+
+        frame_index
+    }
+
+    pub fn contains_js_frame(&self) -> bool {
+        self.contains_js_frame
+    }
+
+    pub fn get_serializable_tables(
+        &self,
+        global_lib_index_to_thread_string_index: &FastHashMap<
+            GlobalLibIndex,
+            ThreadInternalStringIndex,
+        >,
+    ) -> (SerializableFrameTable<'_>, FuncTable, ResourceTable) {
+        let mut func_table = FuncTable::new();
+        let mut resource_table = ResourceTable::new();
+        let func_col = self
+            .name_col
+            .iter()
+            .cloned()
+            .zip(self.flags_col.iter().cloned())
+            .zip(self.lib_col.iter().cloned())
+            .zip(self.file_col.iter().cloned())
+            .map(|(((name, flags), lib), file)| {
+                let resource = lib.map(|lib| {
+                    resource_table.resource_for_lib(lib, global_lib_index_to_thread_string_index)
+                });
+                func_table.index_for_func(name, file, resource, flags)
             })
+            .collect();
+        (
+            SerializableFrameTable(self, func_col),
+            func_table,
+            resource_table,
+        )
     }
 }
 
-impl Serialize for FrameTable {
+pub struct SerializableFrameTable<'a>(&'a FrameTable, Vec<FuncIndex>);
+
+impl Serialize for SerializableFrameTable<'_> {
     fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
-        let len = self.addresses.len();
+        let SerializableFrameTable(table, func_col) = self;
+        let len = table.name_col.len();
         let mut map = serializer.serialize_map(None)?;
         map.serialize_entry("length", &len)?;
         map.serialize_entry(
             "address",
-            &SerializableFrameTableAddressColumn(&self.addresses),
+            &SerializableFrameTableAddressColumn(&table.address_col),
         )?;
-        map.serialize_entry("inlineDepth", &SerializableSingleValueColumn(0u32, len))?;
-        map.serialize_entry("category", &self.categories)?;
-        map.serialize_entry("subcategory", &self.subcategories)?;
-        map.serialize_entry("func", &self.funcs)?;
-        map.serialize_entry("nativeSymbol", &self.native_symbols)?;
+        map.serialize_entry("inlineDepth", &table.inline_depth_col)?;
+        map.serialize_entry("category", &table.category_col)?;
+        map.serialize_entry("subcategory", &table.subcategory_col)?;
+        map.serialize_entry("func", func_col)?;
+        map.serialize_entry("nativeSymbol", &table.native_symbol_col)?;
         map.serialize_entry("innerWindowID", &SerializableSingleValueColumn(0, len))?;
-        map.serialize_entry("line", &SerializableSingleValueColumn((), len))?;
-        map.serialize_entry("column", &SerializableSingleValueColumn((), len))?;
+        map.serialize_entry("line", &table.line_col)?;
+        map.serialize_entry("column", &table.column_col)?;
         map.end()
     }
 }
@@ -133,14 +179,49 @@ impl Serialize for SerializableFrameTableAddressColumn<'_> {
 
 #[derive(Debug, Clone, PartialOrd, Ord, PartialEq, Eq, Hash)]
 pub struct InternalFrame {
-    pub location: InternalFrameLocation,
+    pub key: InternalFrameKey,
+    pub name: ThreadInternalStringIndex,
+    pub native_symbol: Option<NativeSymbolIndex>, // only used when key.variant is InternalFrameKeyVariant::Native
+    pub file_path: Option<ThreadInternalStringIndex>,
+    pub line: Option<u32>,
+    pub col: Option<u32>,
+}
+
+#[derive(Debug, Clone, Copy, PartialOrd, Ord, PartialEq, Eq, Hash)]
+pub struct InternalFrameKey {
+    pub variant: InternalFrameKeyVariant,
     pub subcategory: SubcategoryHandle,
     pub flags: FrameFlags,
 }
 
+#[derive(Debug, Clone, Copy, PartialOrd, Ord, PartialEq, Eq, Hash)]
+pub enum InternalFrameKeyVariant {
+    Label {
+        name: ThreadInternalStringIndex,
+        file_path: Option<ThreadInternalStringIndex>,
+        line: Option<u32>,
+        col: Option<u32>,
+    },
+    Native {
+        lib: GlobalLibIndex,
+        relative_address: u32,
+        inline_depth: u16,
+    },
+}
+
+impl InternalFrameKeyVariant {
+    pub fn new_label(name: ThreadInternalStringIndex) -> Self {
+        InternalFrameKeyVariant::Label {
+            name,
+            file_path: None,
+            line: None,
+            col: None,
+        }
+    }
+}
+
 #[derive(Debug, Clone, PartialOrd, Ord, PartialEq, Eq, Hash)]
-pub enum InternalFrameLocation {
-    UnknownAddress(u64),
-    AddressInLib(u32, GlobalLibIndex),
-    Label(ThreadInternalStringIndex),
+pub enum InternalFrameAddress {
+    Unknown(u64),
+    InLib(u32, GlobalLibIndex),
 }