[PERF] evaluation: zonify evaluation

This commit improves evaluation time from 5% to 20% on regular spreadsheet,
depending on the spreadsheet. And even from 99% on some pathological cases

Benchmark: https://www.odoo.com/odoo/documents/d9dGIrjZRTSa9nf153wEIwo9e4c5

Let’s say you have two formulas that depend on the same reference:

A1: =C1 
A2: =C1

In the FormulaDependencyGraph, both dependencies are added independently.
Specifically, the R-tree data structure ends up with two separate entries:
C1 -> A1 and C1 -> A2.

Ideally, the internal R-tree structure should group these dependencies into a
single node in the tree:

C1 -> [A1, A2] or even C1 -> [A1:A2] because they can be grouped into a single
zone.

When this pattern occurs frequently, the R-tree becomes huged (and unbalanced)
therefore sub-optimal.
- Huge: lots and lots of individual positions
- Unbalanced: this is common when using individual pivot formulas
(e.g., for spreadsheet pivots), where each PIVOT.VALUE formula depends on the
same range—the pivot dataset.

With this commit, the dependencies R-Tree maps bounding boxes to zones, instead
of bounding boxes to positions.
To take advantage of this grouping, the entire evaluation process now uses
zones as much as possible.

closes #7360

Task: 4936229
Signed-off-by: Rémi Rahir (rar) <rar@odoo.com>
Signed-off-by: Lucas Lefèvre (lul) <lul@odoo.com>

Author: LucasLefevre

demo/data.js

@@ -3936,15 +3936,16 @@ function computeStringCells(cols, rows) {
 
 function computeSplitVlookup(rows) {
   /*
-* in A1 write =SPLIT("1 2", " ")
-in C1, writ e=B2
-write a VLOOKUP that search in column C --> slow
-* */
+   * in A1 write =SPLIT("1 2", " ")
+   * in C1, write=B2
+   * write a VLOOKUP that search in column C --> slow
+   */
   const cells = {};
-  for (let row = 0; row < rows; row++) {
+  for (let row = 1; row < rows; row++) {
     cells["A" + row] = { content: `=SPLIT("1 2", " ")` };
     cells["C" + row] = { content: `=B${row}` };
-    cells["D" + row] = { content: `=vlookup("2",a1:c${rows},3)` };
+    cells["D" + row] = { content: `=VLOOKUP("2",C1:C${rows},1)` };
+    cells["F" + row] = { content: `=D${row}` };
   }
   return cells;
 }

packages/o-spreadsheet-engine/src/helpers/range.ts

@@ -19,7 +19,7 @@ import {
   UnboundedZone,
   ZoneDimension,
 } from "../types/misc";
-import { Range, RangePart, RangeStringOptions } from "../types/range";
+import { BoundedRange, Range, RangePart, RangeStringOptions } from "../types/range";
 import { numberToLetters } from "./coordinates";
 import { getCanonicalSymbolName, groupConsecutive, largeMax, largeMin } from "./misc";
 import { isRowReference, splitReference } from "./references";
@@ -228,6 +228,11 @@ function getRangeParts(xc: string, zone: UnboundedZone): RangePart[] {
   return parts;
 }
 
+export function positionToBoundedRange(position: CellPosition): BoundedRange {
+  const zone = { left: position.col, top: position.row, right: position.col, bottom: position.row };
+  return { sheetId: position.sheetId, zone };
+}
+
 /**
  * Check that a zone is valid regarding the order of top-bottom and left-right.
  * Left should be smaller than right, top should be smaller than bottom.

packages/o-spreadsheet-engine/src/helpers/recompute_zones.ts

@@ -178,7 +178,35 @@ export function modifyProfiles<T extends Zone | UnboundedZone>( // export for te
   }
 }
 
-function findIndexAndCreateProfile(
+export function profilesContainsZone(
+  profilesStartingPosition: number[],
+  profiles: Map<number, number[]>,
+  zone: Zone
+): boolean {
+  const leftValue = zone.left;
+  const rightValue = zone.right;
+  const topValue = zone.top;
+  const bottomValue = zone.bottom + 1;
+  const leftIndex = binaryPredecessorSearch(profilesStartingPosition, leftValue, 0);
+  const rightIndex = binaryPredecessorSearch(profilesStartingPosition, rightValue, leftIndex);
+  if (leftIndex === -1 || rightIndex === -1) {
+    return false;
+  }
+  for (let i = leftIndex; i <= rightIndex; i++) {
+    const profile = profiles.get(profilesStartingPosition[i])!;
+    const topPredIndex = binaryPredecessorSearch(profile, topValue, 0, true);
+    const bottomSuccIndex = binarySuccessorSearch(profile, bottomValue, 0, true);
+    if (topPredIndex === -1 || topPredIndex % 2 !== 0) {
+      return false;
+    }
+    if (topValue < profile[topPredIndex] || bottomValue > profile[bottomSuccIndex]) {
+      return false;
+    }
+  }
+  return true;
+}
+
+export function findIndexAndCreateProfile(
   profilesStartingPosition: number[],
   profiles: Map<number, number[]>,
   value: number | undefined,
@@ -277,7 +305,17 @@ function modifyProfile(
 
   // add the top and bottom value to the profile and
   // remove all information between the top and bottom index
-  profile.splice(topPredIndex + 1, bottomSuccIndex - topPredIndex - 1, ...newPoints);
+  const toDelete = bottomSuccIndex - topPredIndex - 1;
+  const toInsert = newPoints.length;
+  const start = topPredIndex + 1;
+  // fast path and slow path
+  if (start === profile.length - 1 && toDelete === 1 && toInsert === 1) {
+    // fast path: we just need to replace the last element
+    profile[start] = newPoints[0] ?? newPoints[1];
+  } else {
+    // equivalent but slower and with memory allocation
+    profile.splice(start, toDelete, ...newPoints);
+  }
 }
 
 function removeContiguousProfiles(
@@ -301,7 +339,7 @@ function removeContiguousProfiles(
   }
 }
 
-function constructZonesFromProfiles<T extends UnboundedZone | Zone>(
+export function constructZonesFromProfiles<T extends UnboundedZone | Zone>(
   profilesStartingPosition: number[],
   profiles: Map<number, number[]>
 ): T[] {
@@ -333,8 +371,10 @@ function constructZonesFromProfiles<T extends UnboundedZone | Zone>(
         left,
         bottom,
         right,
-        hasHeader: (bottom === undefined && top !== 0) || (right === undefined && left !== 0),
       };
+      if ((bottom === undefined && top !== 0) || (right === undefined && left !== 0)) {
+        profileZone.hasHeader = true;
+      }
 
       let findCorrespondingZone = false;
       for (let j = pendingZones.length - 1; j >= 0; j--) {

packages/o-spreadsheet-engine/src/helpers/zones.ts

@@ -502,20 +502,6 @@ export function excludeTopLeft(zone: Zone): Zone[] {
   return [leftColumnZone, rightPartZone];
 }
 
-export function aggregatePositionsToZones(positions: Iterable<CellPosition>): {
-  [sheetId: string]: Zone[];
-} {
-  const result: { [sheetId: string]: Zone[] } = {};
-  for (const position of positions) {
-    result[position.sheetId] ??= [];
-    result[position.sheetId].push(positionToZone(position));
-  }
-  for (const sheetId in result) {
-    result[sheetId] = recomputeZones(result[sheetId]);
-  }
-  return result;
-}
-
 /**
  * Array of all positions in the zone.
  */

packages/o-spreadsheet-engine/src/plugins/ui_core_views/cell_evaluation/dependencies_r_tree.ts

@@ -0,0 +1,141 @@
+import { UID } from "../../..";
+import { BoundedRange } from "../../../types/range";
+import { RTreeBoundingBox, RTreeItem, SpreadsheetRTree } from "./r_tree";
+import { RangeSet } from "./range_set";
+
+interface RangeSetItem {
+  boundingBox: RTreeBoundingBox;
+  data: RangeSet;
+}
+
+type RTreeRangeItem = RTreeItem<BoundedRange>;
+
+/**
+ * R-Tree of ranges, mapping zones (r-tree bounding boxes) to ranges (data of the r-tree item).
+ * Ranges associated to the exact same bounding box are grouped together
+ * to reduce the number of nodes in the R-tree.
+ */
+export class DependenciesRTree {
+  private readonly rTree: SpreadsheetRTree<RangeSet>;
+
+  constructor(items: RTreeRangeItem[] = []) {
+    const compactedBoxes = groupSameBoundingBoxes(items);
+    this.rTree = new SpreadsheetRTree(compactedBoxes);
+  }
+
+  insert(item: RTreeRangeItem) {
+    const data = this.rTree.search(item.boundingBox);
+    const itemBoundingBox = item.boundingBox;
+    const exactBoundingBox = data.find(
+      ({ boundingBox }) =>
+        boundingBox.sheetId === itemBoundingBox.sheetId &&
+        boundingBox.zone.left === itemBoundingBox.zone.left &&
+        boundingBox.zone.top === itemBoundingBox.zone.top &&
+        boundingBox.zone.right === itemBoundingBox.zone.right &&
+        boundingBox.zone.bottom === itemBoundingBox.zone.bottom
+    );
+    if (exactBoundingBox) {
+      exactBoundingBox.data.add(item.data);
+    } else {
+      this.rTree.insert({ ...item, data: new RangeSet([item.data]) });
+    }
+  }
+
+  search({ zone, sheetId }: RTreeBoundingBox): RangeSet {
+    const results: RangeSet = new RangeSet();
+    for (const { data } of this.rTree.search({ zone, sheetId })) {
+      results.addMany(data);
+    }
+    return results;
+  }
+
+  remove(item: RTreeRangeItem) {
+    const data = this.rTree.search(item.boundingBox);
+    const itemBoundingBox = item.boundingBox;
+    const exactBoundingBox = data.find(
+      ({ boundingBox }) =>
+        boundingBox.sheetId === itemBoundingBox.sheetId &&
+        boundingBox.zone.left === itemBoundingBox.zone.left &&
+        boundingBox.zone.top === itemBoundingBox.zone.top &&
+        boundingBox.zone.right === itemBoundingBox.zone.right &&
+        boundingBox.zone.bottom === itemBoundingBox.zone.bottom
+    );
+    if (exactBoundingBox) {
+      exactBoundingBox.data.delete(item.data);
+    } else {
+      this.rTree.remove({ ...item, data: new RangeSet([item.data]) });
+    }
+  }
+}
+
+/**
+ * Group together all formulas pointing to the exact same dependency (bounding box).
+ * The goal is to optimize the following case:
+ * - if any cell in B1:B1000 changes, C1 must be recomputed
+ * - if any cell in B1:B1000 changes, C2 must be recomputed
+ * - if any cell in B1:B1000 changes, C3 must be recomputed
+ * ...
+ * - if any cell in B1:B1000 changes, C1000 must be recomputed
+ *
+ * Instead of having 1000 entries in the R-tree, we want to have a single entry
+ * with B1:B1000 (bounding box) pointing to C1:C1000 (formulas).
+ */
+function groupSameBoundingBoxes(items: RTreeRangeItem[]): RangeSetItem[] {
+  // Important: this function must be as fast as possible. It is on the evaluation hot path.
+  let maxCol = 0;
+  let maxRow = 0;
+  for (let i = 0; i < items.length; i++) {
+    const zone = items[i].boundingBox.zone;
+    if (zone.right > maxCol) {
+      maxCol = zone.right;
+    }
+    if (zone.bottom > maxRow) {
+      maxRow = zone.bottom;
+    }
+  }
+  maxCol += 1;
+  maxRow += 1;
+
+  // in most real-world cases, we can use a fast numeric key
+  // but if the zones are too far right or bottom, we fallback to a slower string key
+  const maxPossibleKey = (((maxRow + 1) * maxCol + 1) * maxRow + 1) * maxCol;
+  const useFastKey = maxPossibleKey <= Number.MAX_SAFE_INTEGER;
+  if (!useFastKey) {
+    console.warn("Max col/row size exceeded, using slow zone key");
+  }
+  const groupedByBBox: Record<UID, Record<string, RangeSetItem>> = {};
+  for (const item of items) {
+    const sheetId = item.boundingBox.sheetId;
+    if (!groupedByBBox[sheetId]) {
+      groupedByBBox[sheetId] = {};
+    }
+    const bBox = item.boundingBox.zone;
+    let bBoxKey: number | string = 0;
+    if (useFastKey) {
+      bBoxKey =
+        bBox.left +
+        bBox.top * maxCol +
+        bBox.right * maxCol * maxRow +
+        bBox.bottom * maxCol * maxRow * maxCol;
+    } else {
+      bBoxKey = `${bBox.left},${bBox.top},${bBox.right},${bBox.bottom}`;
+    }
+    if (groupedByBBox[sheetId][bBoxKey]) {
+      const ranges = groupedByBBox[sheetId][bBoxKey].data;
+      ranges.add(item.data);
+    } else {
+      groupedByBBox[sheetId][bBoxKey] = {
+        boundingBox: item.boundingBox,
+        data: new RangeSet([item.data]),
+      };
+    }
+  }
+  const result: RangeSetItem[] = [];
+  for (const sheetId in groupedByBBox) {
+    const map = groupedByBBox[sheetId];
+    for (const key in map) {
+      result.push(map[key]);
+    }
+  }
+  return result;
+}