Further optimize cross tile symbol index findMatches

src/symbol/cross_tile_symbol_index.test.ts

@@ -214,7 +214,7 @@ describe('CrossTileSymbolIndex.addLayer', () => {
 
     });
 
-    test('indexes data for findMatches perf', () => {
+    test('matches ids when indexing', () => {
         const index = new CrossTileSymbolIndex();
 
         const mainID = new OverscaledTileID(6, 0, 6, 8, 8);
@@ -223,9 +223,10 @@ describe('CrossTileSymbolIndex.addLayer', () => {
         const mainInstances: any[] = [];
         const childInstances: any[] = [];
 
-        for (let i = 0; i < KDBUSH_THRESHHOLD + 1; i++) {
-            mainInstances.push(makeSymbolInstance(0, 0, ''));
-            childInstances.push(makeSymbolInstance(0, 0, ''));
+        const INSTANCE_COUNT = KDBUSH_THRESHHOLD + 1;
+        for (let i = 0; i < INSTANCE_COUNT; i++) {
+            mainInstances.push(makeSymbolInstance(i, i, ''));
+            childInstances.push(makeSymbolInstance(i, i, ''));
         }
         const mainTile = makeTile(mainID, mainInstances);
         const childTile = makeTile(childID, childInstances);
@@ -234,7 +235,10 @@ describe('CrossTileSymbolIndex.addLayer', () => {
 
         // check that we matched the parent tile
         expect(childInstances[0].crossTileID).toBe(1);
-
+        // all child instances matched a crossTileID from the parent, otherwise
+        // we would have generated a new crossTileID, and the number would
+        // exceed INSTANCE_COUNT
+        expect(Math.max(...childInstances.map(i => i.crossTileID))).toBe(INSTANCE_COUNT);
     });
 });
 

src/symbol/cross_tile_symbol_index.ts

@@ -104,6 +104,8 @@ class TileLayerIndex {
     }) {
         const tolerance = this.tileID.canonical.z < newTileID.canonical.z ? 1 : Math.pow(2, this.tileID.canonical.z - newTileID.canonical.z);
 
+        const symbolKeyToScaledCoordinatesToSymbolInstanceMap = new Map<number, Map<number, SymbolInstance[]>>();
+
         for (let i = 0; i < symbolInstances.length; i++) {
             const symbolInstance = symbolInstances.get(i);
             if (symbolInstance.crossTileID) {
@@ -120,25 +122,21 @@ class TileLayerIndex {
             const scaledSymbolCoord = this.getScaledCoordinates(symbolInstance, newTileID);
 
             if (entry.index) {
-                // Return any symbol with the same keys whose coordinates are within 1
-                // grid unit. (with a 4px grid, this covers a 12px by 12px area)
-                const indexes = entry.index.range(
-                    scaledSymbolCoord.x - tolerance,
-                    scaledSymbolCoord.y - tolerance,
-                    scaledSymbolCoord.x + tolerance,
-                    scaledSymbolCoord.y + tolerance).sort();
-
-                for (const i of indexes) {
-                    const crossTileID = entry.crossTileIDs[i];
-
-                    if (!zoomCrossTileIDs[crossTileID]) {
-                        // Once we've marked ourselves duplicate against this parent symbol,
-                        // don't let any other symbols at the same zoom level duplicate against
-                        // the same parent (see issue #5993)
-                        zoomCrossTileIDs[crossTileID] = true;
-                        symbolInstance.crossTileID = crossTileID;
-                        break;
+                // Build a map keyed by common symbol instance keys, which are also
+                // used to key indexes. For each symbol index key, build a reverse map
+                // of the scaled coordinates back to a set of SymbolInstance that
+                // resolve to that coordinate.
+                const scaledCoordinateId = scaledSymbolCoord.x << 16 | scaledSymbolCoord.y;
+                const existingSymbolKey = symbolKeyToScaledCoordinatesToSymbolInstanceMap.get(symbolInstance.key);
+                if (existingSymbolKey) {
+                    const existingSymbolsAtCoordinate = existingSymbolKey.get(scaledCoordinateId);
+                    if (existingSymbolsAtCoordinate) {
+                        existingSymbolsAtCoordinate.push(symbolInstance);
+                    } else {
+                        existingSymbolKey.set(scaledCoordinateId, [symbolInstance]);
                     }
+                } else {
+                    symbolKeyToScaledCoordinatesToSymbolInstanceMap.set(symbolInstance.key, new Map([[scaledCoordinateId, [symbolInstance]]]));
                 }
             } else if (entry.positions) {
                 for (let i = 0; i < entry.positions.length; i++) {
@@ -160,6 +158,52 @@ class TileLayerIndex {
                 }
             }
         }
+
+        for (const [symbolKey, coordinateMap] of symbolKeyToScaledCoordinatesToSymbolInstanceMap.entries()) {
+            const entry = this._symbolsByKey[symbolKey];
+            if (!entry) {
+                // Shouldn't happen, as we only populate keys in this
+                // map above when an entry exists.
+                continue;
+            }
+
+            if (!entry.index){
+                // Shouldn't happen, as we only populate keys in this
+                // map above when the entry has an index built.
+                continue;
+            }
+
+            for (const [coordinateId, symbolInstancesAtCoordinate] of coordinateMap.entries()) {
+                const x = coordinateId >>> 16;
+                const y = coordinateId % (1 << 16);
+                const indexes = entry.index.range(
+                    x - tolerance,
+                    y - tolerance,
+                    x + tolerance,
+                    y + tolerance);
+
+                // Iterate through cross tile entries at this quadrant _and_
+                // symbol instances and pair them up until one of the lists
+                // runs out. This is faster than re-running a range query
+                // for every symbol instance, as each of these symbol
+                // instances already have the same key, and thus can be
+                // paired with any entry in the index.
+                let i = 0;
+                let j = 0;
+                while (i < entry.crossTileIDs.length && j < Math.min(indexes.length, symbolInstancesAtCoordinate.length)) {
+                    const crossTileID = entry.crossTileIDs[i];
+                    if (!zoomCrossTileIDs[crossTileID]) {
+                        // Once we've marked ourselves duplicate against this parent symbol,
+                        // don't let any other symbols at the same zoom level duplicate against
+                        // the same parent (see issue #5993)
+                        zoomCrossTileIDs[crossTileID] = true;
+                        symbolInstancesAtCoordinate[j].crossTileID = crossTileID;
+                        j++;
+                    }
+                    i++;
+                }
+            }
+        }
     }
 
     getCrossTileIDsLists() {