Speed up computeDeduplicatedCallNodeInfo with a bloom filter.

Author: mstange

src/profile-logic/profile-data.js

@@ -54,7 +54,6 @@ import type {
   IndexIntoStackTable,
   IndexIntoResourceTable,
   IndexIntoNativeSymbolTable,
-  IndexIntoDeduplicatedCallNodeTable,
   DeduplicatedCallNodeInfo,
   ThreadIndex,
   Category,
@@ -1219,58 +1218,127 @@ export function getTimingsForCallNodeIndex(
   return { forPath: pathTimings, rootTime };
 }
 
+function _hash32(val: number): number {
+  const rotated1 = val << 5;
+  const rotated2 = val >> 27;
+  const rotated = rotated1 | rotated2;
+  const xored = rotated ^ val;
+  return (xored * 0x9e_37_79_b9) | 0;
+}
+
 export function computeDeduplicatedCallNodeInfo(
   callNodeInfo: CallNodeInfo
 ): DeduplicatedCallNodeInfo {
   const callNodeTable = callNodeInfo.getNonInvertedCallNodeTable();
 
-  let len = 0;
-  const prefixCol: IndexIntoDeduplicatedCallNodeTable[] = [];
-  const funcCol: IndexIntoFuncTable[] = [];
-
   const callNodeCount = callNodeTable.length;
+  const funcCol = callNodeTable.func;
+  const prefixCol = callNodeTable.prefix;
+  const newPrefixCol = new Int32Array(callNodeCount);
+  const bloomBitsCol1 = new Int32Array(callNodeCount);
+  const bloomBitsCol2 = new Int32Array(callNodeCount);
+  const bloomBitsCol3 = new Int32Array(callNodeCount);
+  const bloomBitsCol4 = new Int32Array(callNodeCount);
+
   const callNodeIndexToDeduplicatedCallNodeIndex = new Uint32Array(
     callNodeCount
   );
 
+  const funcBloomBits = new Int32Array(4);
   for (let callNodeIndex = 0; callNodeIndex < callNodeCount; callNodeIndex++) {
-    const originalPrefix = callNodeTable.prefix[callNodeIndex];
-    const func = callNodeTable.func[callNodeIndex];
-    let prefix = -1;
-    if (originalPrefix !== -1) {
-      prefix = callNodeIndexToDeduplicatedCallNodeIndex[originalPrefix];
-
-      // Check if `func` is present in the prefix's call path.
-      let prefixHasFunc = false;
-      for (
-        let dedupAnc = prefix;
-        dedupAnc !== -1;
-        dedupAnc = prefixCol[dedupAnc]
-      ) {
-        if (funcCol[dedupAnc] === func) {
-          prefixHasFunc = true;
-          break;
+    const prefix = prefixCol[callNodeIndex];
+    const func = funcCol[callNodeIndex];
+
+    const funcHash = _hash32(func);
+    const funcHashBitIndex1 = funcHash % 32;
+    const funcHashBitIndex2 = (funcHash >> 5) % 32;
+    // const funcHashBitIndex3 = (funcHash >> 10) % 32;
+    const funcHashBit1 = 1 << funcHashBitIndex1;
+    const funcHashBit2 = 1 << funcHashBitIndex2;
+    // const funcHashBit3 = 1 << funcHashBitIndex3;
+    const funcBitDistributor1 = (funcHash >> 15) & 0b11;
+    const funcBitDistributor2 = (funcHash >> 17) & 0b11;
+    // const funcBitDistributor3 = (funcHash >> 19) & 0b11;
+
+    funcBloomBits[0] = 0;
+    funcBloomBits[1] = 0;
+    funcBloomBits[2] = 0;
+    funcBloomBits[3] = 0;
+    funcBloomBits[funcBitDistributor1] |= funcHashBit1;
+    funcBloomBits[funcBitDistributor2] |= funcHashBit2;
+    // funcBloomBits[funcBitDistributor3] |= funcHashBit3;
+
+    const funcBloomBits1 = funcBloomBits[0];
+    const funcBloomBits2 = funcBloomBits[1];
+    const funcBloomBits3 = funcBloomBits[2];
+    const funcBloomBits4 = funcBloomBits[3];
+
+    let prefixBloomBits1 = 0;
+    let prefixBloomBits2 = 0;
+    let prefixBloomBits3 = 0;
+    let prefixBloomBits4 = 0;
+    let newPrefix = -1;
+    if (prefix !== -1) {
+      newPrefix = callNodeIndexToDeduplicatedCallNodeIndex[prefix];
+      prefixBloomBits1 = bloomBitsCol1[newPrefix];
+      prefixBloomBits2 = bloomBitsCol2[newPrefix];
+      prefixBloomBits3 = bloomBitsCol3[newPrefix];
+      prefixBloomBits4 = bloomBitsCol4[newPrefix];
+
+      // Check if `func` is present in the newPrefix's call path.
+      let funcIsAlreadyPresentInPrefix = false;
+
+      const hashMatched =
+        (prefixBloomBits1 & funcBloomBits1) === funcBloomBits1 &&
+        (prefixBloomBits2 & funcBloomBits2) === funcBloomBits2 &&
+        (prefixBloomBits3 & funcBloomBits3) === funcBloomBits3 &&
+        (prefixBloomBits4 & funcBloomBits4) === funcBloomBits4;
+      if (hashMatched) {
+        let dedupIndex = newPrefix;
+        for (let j = 0; ; j++) {
+          if (funcCol[dedupIndex] === func) {
+            funcIsAlreadyPresentInPrefix = true;
+            break;
+          }
+          dedupIndex = newPrefixCol[dedupIndex];
+          if (
+            dedupIndex === -1 ||
+            (j % 2 === 0 &&
+              ((bloomBitsCol1[dedupIndex] & funcBloomBits1) !==
+                funcBloomBits1 ||
+                (bloomBitsCol2[dedupIndex] & funcBloomBits2) !==
+                  funcBloomBits2 ||
+                (bloomBitsCol3[dedupIndex] & funcBloomBits3) !==
+                  funcBloomBits3 ||
+                (bloomBitsCol4[dedupIndex] & funcBloomBits4) !==
+                  funcBloomBits4))
+          ) {
+            break;
+          }
         }
       }
-
-      if (prefixHasFunc) {
+      if (funcIsAlreadyPresentInPrefix) {
         // Drop this node.
-        callNodeIndexToDeduplicatedCallNodeIndex[callNodeIndex] = prefix;
+        callNodeIndexToDeduplicatedCallNodeIndex[callNodeIndex] = newPrefix;
         continue;
       }
     }
 
     // Create a node in the deduplicated call node table.
-    const newIndex = len++;
-    prefixCol[newIndex] = prefix;
-    funcCol[newIndex] = func;
-    callNodeIndexToDeduplicatedCallNodeIndex[callNodeIndex] = newIndex;
+    newPrefixCol[callNodeIndex] = newPrefix;
+    bloomBitsCol1[callNodeIndex] = prefixBloomBits1 | funcBloomBits1;
+    bloomBitsCol2[callNodeIndex] = prefixBloomBits2 | funcBloomBits2;
+    bloomBitsCol3[callNodeIndex] = prefixBloomBits3 | funcBloomBits3;
+    bloomBitsCol4[callNodeIndex] = prefixBloomBits4 | funcBloomBits4;
+    callNodeIndexToDeduplicatedCallNodeIndex[callNodeIndex] = callNodeIndex;
   }
 
+  // console.log({bloomBitsCol1: bloomBitsCol1.slice(0, 1000).map((num) => num.toString(2)) });
+
   const deduplicatedCallNodeTable = {
-    length: len,
-    prefix: new Int32Array(prefixCol),
-    func: new Uint32Array(funcCol),
+    length: callNodeCount,
+    prefix: newPrefixCol,
+    func: funcCol,
   };
 
   return {

src/selectors/per-thread/stack-sample.js

@@ -45,11 +45,11 @@ import type {
   ThreadsKey,
   SelfAndTotal,
   CallNodeSelfAndSummary,
+  DeduplicatedCallNodeInfo,
 } from 'firefox-profiler/types';
 import type {
   CallNodeInfo,
   CallNodeInfoInverted,
-  DeduplicatedCallNodeInfo,
 } from 'firefox-profiler/profile-logic/call-node-info';
 
 import type { ThreadSelectorsPerThread } from './thread';

src/types/profile-derived.js

@@ -130,7 +130,7 @@ export type DeduplicatedCallNodeInfo = {|
 export type DeduplicatedCallNodeTable = {|
   length: number,
   prefix: Int32Array,
-  func: Uint32Array,
+  func: Int32Array,
 |};
 
 export type LineNumber = number;