Share stackTable, frameTable, funcTable, resourceTable and nativeSymbols between threads

docs-developer/CHANGELOG-formats.md

@@ -6,6 +6,10 @@ Note that this is not an exhaustive list. Processed profile format upgraders can
 
 ## Processed profile format
 
+### Version 56
+
+The `stringArray` is now shared across threads. The shared array is stored at `profile.shared.stringArray`.
+
 ### Version 55
 
 Changes to the `MarkerSchema` type which is used for the elements of the array at `profile.meta.markerSchema`:

src/actions/receive-profile.js

@@ -93,10 +93,7 @@ import type {
   PageList,
 } from 'firefox-profiler/types';
 
-import type {
-  FuncToFuncsMap,
-  SymbolicationStepInfo,
-} from '../profile-logic/symbolication';
+import type { SymbolicationStepInfo } from '../profile-logic/symbolication';
 import { assertExhaustiveCheck, ensureExists } from '../utils/flow';
 import { bytesToBase64DataUrl } from 'firefox-profiler/utils/base64';
 import type {
@@ -397,7 +394,7 @@ export function finalizeFullProfileView(
         const thread = profile.threads[threadIndex];
         const { samples, jsAllocations, nativeAllocations } = thread;
         hasSamples = [samples, jsAllocations, nativeAllocations].some((table) =>
-          hasUsefulSamples(table?.stack, thread)
+          hasUsefulSamples(table?.stack, thread, profile.shared)
         );
         if (hasSamples) {
           break;
@@ -477,11 +474,13 @@ export function finalizeOriginProfileView(
       threadIndex < profile.threads.length;
       threadIndex++
     ) {
-      const { frameTable } = profile.threads[threadIndex];
+      const { usedInnerWindowIDs } = profile.threads[threadIndex];
+      if (usedInnerWindowIDs === undefined) {
+        continue;
+      }
 
       let originFound = false;
-      for (let frameIndex = 0; frameIndex < frameTable.length; frameIndex++) {
-        const innerWindowID = frameTable.innerWindowID[frameIndex];
+      for (const innerWindowID of usedInnerWindowIDs) {
         if (innerWindowID === null || innerWindowID === 0) {
           continue;
         }
@@ -790,27 +789,20 @@ export function doneSymbolicating(): Action {
 // reach the screen because it would be invalidated by the next symbolication update.
 // So we queue up symbolication steps and run the update from requestIdleCallback.
 export function bulkProcessSymbolicationSteps(
-  symbolicationStepsPerThread: Map<ThreadIndex, SymbolicationStepInfo[]>
+  symbolicationSteps: SymbolicationStepInfo[]
 ): ThunkAction<void> {
   return (dispatch, getState) => {
-    const { threads } = getProfile(getState());
-    const oldFuncToNewFuncsMaps: Map<ThreadIndex, FuncToFuncsMap> = new Map();
-    const symbolicatedThreads = threads.map((oldThread, threadIndex) => {
-      const symbolicationSteps = symbolicationStepsPerThread.get(threadIndex);
-      if (symbolicationSteps === undefined) {
-        return oldThread;
-      }
-      const { thread, oldFuncToNewFuncsMap } = applySymbolicationSteps(
-        oldThread,
-        symbolicationSteps
-      );
-      oldFuncToNewFuncsMaps.set(threadIndex, oldFuncToNewFuncsMap);
-      return thread;
-    });
+    const profile = getProfile(getState());
+    const { threads, shared, oldFuncToNewFuncsMap } = applySymbolicationSteps(
+      profile.threads,
+      profile.shared,
+      symbolicationSteps
+    );
     dispatch({
       type: 'BULK_SYMBOLICATION',
-      oldFuncToNewFuncsMaps,
-      symbolicatedThreads,
+      oldFuncToNewFuncsMap,
+      symbolicatedShared: shared,
+      symbolicatedThreads: threads,
     });
   };
 }
@@ -832,12 +824,12 @@ if (typeof window === 'object' && window.requestIdleCallback) {
 // Queues up symbolication steps and bulk-processes them from requestIdleCallback,
 // in order to improve UI responsiveness during symbolication.
 class SymbolicationStepQueue {
-  _updates: Map<ThreadIndex, SymbolicationStepInfo[]>;
+  _updates: SymbolicationStepInfo[];
   _updateObservers: Array<() => void>;
   _requestedUpdate: boolean;
 
   constructor() {
-    this._updates = new Map();
+    this._updates = [];
     this._updateObservers = [];
     this._requestedUpdate = false;
   }
@@ -855,7 +847,7 @@ class SymbolicationStepQueue {
   _dispatchUpdate(dispatch) {
     const updates = this._updates;
     const observers = this._updateObservers;
-    this._updates = new Map();
+    this._updates = [];
     this._updateObservers = [];
     this._requestedUpdate = false;
 
@@ -868,17 +860,11 @@ class SymbolicationStepQueue {
 
   enqueueSingleSymbolicationStep(
     dispatch: Dispatch,
-    threadIndex: ThreadIndex,
     symbolicationStepInfo: SymbolicationStepInfo,
     completionHandler: () => void
   ) {
     this._scheduleUpdate(dispatch);
-    let threadSteps = this._updates.get(threadIndex);
-    if (threadSteps === undefined) {
-      threadSteps = [];
-      this._updates.set(threadIndex, threadSteps);
-    }
-    threadSteps.push(symbolicationStepInfo);
+    this._updates.push(symbolicationStepInfo);
     this._updateObservers.push(completionHandler);
   }
 }
@@ -1013,15 +999,11 @@ export async function doSymbolicateProfile(
   await symbolicateProfile(
     profile,
     symbolStore,
-    (
-      threadIndex: ThreadIndex,
-      symbolicationStepInfo: SymbolicationStepInfo
-    ) => {
+    (symbolicationStepInfo: SymbolicationStepInfo) => {
       completionPromises.push(
         new Promise((resolve) => {
           _symbolicationStepQueueSingleton.enqueueSingleSymbolicationStep(
             dispatch,
-            threadIndex,
             symbolicationStepInfo,
             resolve
           );
@@ -1895,7 +1877,7 @@ export function changeTabFilter(tabID: TabID | null): ThunkAction<void> {
         const thread = profile.threads[threadIndex];
         const { samples, jsAllocations, nativeAllocations } = thread;
         hasSamples = [samples, jsAllocations, nativeAllocations].some((table) =>
-          hasUsefulSamples(table?.stack, thread)
+          hasUsefulSamples(table?.stack, thread, profile.shared)
         );
         if (hasSamples) {
           break;

src/app-logic/constants.js

@@ -14,7 +14,7 @@ export const GECKO_PROFILE_VERSION = 31;
 // The current version of the "processed" profile format.
 // Please don't forget to update the processed profile format changelog in
 // `docs-developer/CHANGELOG-formats.md`.
-export const PROCESSED_PROFILE_VERSION = 55;
+export const PROCESSED_PROFILE_VERSION = 57;
 
 // The following are the margin sizes for the left and right of the timeline. Independent
 // components need to share these values.

src/app-logic/url-handling.js

@@ -30,7 +30,7 @@ import type {
   DataSource,
   Pid,
   Profile,
-  RawThread,
+  RawProfileSharedData,
   IndexIntoStackTable,
   TabID,
   TrackIndex,
@@ -995,10 +995,6 @@ const _upgraders: {|
       return;
     }
 
-    // The transform stack is for the selected thread.
-    // At the time this upgrader was written, there was only one selected thread.
-    const thread = profile.threads[selectedThread];
-
     for (let i = 0; i < transforms.length; i++) {
       const transform = transforms[i];
       if (
@@ -1018,7 +1014,7 @@ const _upgraders: {|
       // To be correct, we would need to apply all previous transforms and find
       // the right stack in the filtered thread.
       const callNodeStackIndex = getStackIndexFromVersion3JSCallNodePath(
-        thread,
+        profile.shared,
         transform.callNodePath
       );
       if (callNodeStackIndex === null) {
@@ -1027,7 +1023,7 @@ const _upgraders: {|
       }
       // This property is not writable, make it an "any"
       (transform: any).callNodePath = getVersion4JSCallNodePathFromStackIndex(
-        thread,
+        profile.shared,
         callNodeStackIndex
       );
     }
@@ -1224,8 +1220,7 @@ const _upgraders: {|
       return;
     }
 
-    const threadIndex = selectedThreads[0];
-    const funcTableLength = profile.threads[threadIndex].funcTable.length;
+    const funcTableLength = profile.shared.funcTable.length;
 
     //     cr-{implementation}-{resourceIndex}-{wrongFuncIndex}
     //  -> cr-{implementation}-{resourceIndex}-{correctFuncIndex}
@@ -1268,10 +1263,10 @@ for (const destVersionStr of Object.keys(_upgraders)) {
 // This should only be used for the URL upgrader, typically this
 // operation would use a call node index rather than a stack.
 function getStackIndexFromVersion3JSCallNodePath(
-  thread: RawThread,
+  shared: RawProfileSharedData,
   oldCallNodePath: CallNodePath
 ): IndexIntoStackTable | null {
-  const { stackTable, funcTable, frameTable } = thread;
+  const { stackTable, funcTable, frameTable } = shared;
   const stackIndexDepth: Map<IndexIntoStackTable | null, number> = new Map();
   stackIndexDepth.set(null, -1);
 
@@ -1314,10 +1309,10 @@ function getStackIndexFromVersion3JSCallNodePath(
 // Constructs the new JS CallNodePath from given stackIndex and returns it.
 // This should only be used for the URL upgrader.
 function getVersion4JSCallNodePathFromStackIndex(
-  thread: RawThread,
+  shared: RawProfileSharedData,
   stackIndex: IndexIntoStackTable
 ): CallNodePath {
-  const { funcTable, stackTable, frameTable } = thread;
+  const { funcTable, stackTable, frameTable } = shared;
   const callNodePath = [];
   let nextStackIndex = stackIndex;
   while (nextStackIndex !== null) {

src/components/js-tracer/Chart.js

@@ -15,6 +15,7 @@ import { JsTracerCanvas } from './Canvas';
 import {
   getCommittedRange,
   getPreviewSelection,
+  getStringTable,
 } from 'firefox-profiler/selectors/profile';
 import { selectedThreadSelectors } from 'firefox-profiler/selectors/per-thread';
 import { getSelectedThreadsKey } from 'firefox-profiler/selectors/url-state';
@@ -136,7 +137,7 @@ const JsTracerExpensiveChart = explicitConnect<
 >({
   mapStateToProps: (state, ownProps) => ({
     timeRange: getCommittedRange(state),
-    stringTable: selectedThreadSelectors.getStringTable(state),
+    stringTable: getStringTable(state),
     threadsKey: getSelectedThreadsKey(state),
     previewSelection: getPreviewSelection(state),
     jsTracerTimingRows: ensureExists(

src/profile-logic/active-tab.js

@@ -67,15 +67,20 @@ export function computeActiveTabTracks(
   const screenshots = [];
   const topmostInnerWindowIDs = getTopmostInnerWindowIDs(relevantPages);
   const innerWindowIDToPageMap = _getInnerWindowIDToPageMap(relevantPages);
+  const { stringArray } = profile.shared;
+  const stringTable = StringTable.withBackingArray(stringArray);
+
+  const screenshotNameIndex = stringTable.indexForString(
+    'CompositorScreenshot'
+  );
 
   for (
     let threadIndex = 0;
     threadIndex < profile.threads.length;
     threadIndex++
   ) {
     const thread = profile.threads[threadIndex];
-    const { markers, stringArray } = thread;
-    const stringTable = StringTable.withBackingArray(stringArray);
+    const { markers } = thread;
 
     if (thread.isMainThread) {
       // This is a main thread, there is a possibility that it can be a global
@@ -120,9 +125,6 @@ export function computeActiveTabTracks(
 
     // Check for screenshots.
     const windowIDs: Set<string> = new Set();
-    const screenshotNameIndex = stringTable.indexForString(
-      'CompositorScreenshot'
-    );
     if (screenshotNameIndex !== -1) {
       for (let markerIndex = 0; markerIndex < markers.length; markerIndex++) {
         if (markers.name[markerIndex] === screenshotNameIndex) {
@@ -174,11 +176,12 @@ function isTopmostThread(
   thread: RawThread,
   topmostInnerWindowIDs: Set<InnerWindowID>
 ): boolean {
-  const { frameTable, markers } = thread;
-  for (let frameIndex = 0; frameIndex < frameTable.length; frameIndex++) {
-    const innerWindowID = frameTable.innerWindowID[frameIndex];
-    if (innerWindowID !== null && topmostInnerWindowIDs.has(innerWindowID)) {
-      return true;
+  const { usedInnerWindowIDs, markers } = thread;
+  if (usedInnerWindowIDs !== undefined) {
+    for (const innerWindowID of usedInnerWindowIDs) {
+      if (innerWindowID !== null && topmostInnerWindowIDs.has(innerWindowID)) {
+        return true;
+      }
     }
   }
 
@@ -209,14 +212,13 @@ function _getActiveTabResourceName(
   thread: RawThread,
   innerWindowIDToPageMap: Map<InnerWindowID, Page>
 ): string | null {
-  if (thread.isMainThread) {
+  const { isMainThread, usedInnerWindowIDs } = thread;
+  if (isMainThread && usedInnerWindowIDs !== undefined) {
     // This is a sub-frame.
     // Get the first innerWindowID inside the thread that's also present of innerWindowIDToPageMap.
-    let firstInnerWindowID = ensureExists(thread.frameTable.innerWindowID).find(
+    let firstInnerWindowID = usedInnerWindowIDs.find(
       (innerWindowID) =>
-        innerWindowID &&
-        innerWindowID !== 0 &&
-        innerWindowIDToPageMap.has(innerWindowID)
+        innerWindowID !== 0 && innerWindowIDToPageMap.has(innerWindowID)
     );
     if (firstInnerWindowID === undefined || firstInnerWindowID === null) {
       const markerData = thread.markers.data.find((data) => {

src/profile-logic/data-structures.js

@@ -10,6 +10,7 @@ import {
 
 import type {
   RawThread,
+  RawProfileSharedData,
   RawSamplesTable,
   SamplesTable,
   FrameTable,
@@ -73,6 +74,20 @@ export function getEmptyRawStackTable(): RawStackTable {
   };
 }
 
+export function shallowCloneRawStackTable(
+  stackTable: RawStackTable
+): RawStackTable {
+  return {
+    // Important!
+    // If modifying this structure, please update all callers of this function to ensure
+    // that they are pushing on correctly to the data structure. These pushes may not
+    // be caught by the type system.
+    frame: stackTable.frame.slice(),
+    prefix: stackTable.prefix.slice(),
+    length: stackTable.length,
+  };
+}
+
 /**
  * Returns an empty samples table with eventDelay field instead of responsiveness.
  * eventDelay is a new field and it replaced responsiveness. We should still
@@ -395,12 +410,6 @@ export function getEmptyThread(overrides?: $Shape<RawThread>): RawThread {
     // Creating samples with event delay since it's the new samples table.
     samples: getEmptySamplesTableWithEventDelay(),
     markers: getEmptyRawMarkerTable(),
-    stackTable: getEmptyRawStackTable(),
-    frameTable: getEmptyFrameTable(),
-    stringArray: [],
-    funcTable: getEmptyFuncTable(),
-    resourceTable: getEmptyResourceTable(),
-    nativeSymbols: getEmptyNativeSymbolTable(),
   };
 
   return {
@@ -409,6 +418,17 @@ export function getEmptyThread(overrides?: $Shape<RawThread>): RawThread {
   };
 }
 
+export function getEmptySharedData(): RawProfileSharedData {
+  return {
+    stackTable: getEmptyRawStackTable(),
+    frameTable: getEmptyFrameTable(),
+    funcTable: getEmptyFuncTable(),
+    resourceTable: getEmptyResourceTable(),
+    nativeSymbols: getEmptyNativeSymbolTable(),
+    stringArray: [],
+  };
+}
+
 export function getEmptyProfile(): Profile {
   return {
     meta: {
@@ -436,6 +456,7 @@ export function getEmptyProfile(): Profile {
     },
     libs: [],
     pages: [],
+    shared: getEmptySharedData(),
     threads: [],
   };
 }