performance: Optimize tiles iterator in layers

Use hash maps and reduce allocations and number of iterations whereever
possible in the `update_displayed_tiles` method. This reduces the time
it takes to execute this method by ~50% in complex cases, which reduces
the lag a lot when zooming out with tilted camera.

Author: Maximkaaa

Cargo.toml

@@ -72,6 +72,7 @@ lyon = "1"
 maybe-sync = "0.1"
 nalgebra = "0.32"
 num-traits = "0.2"
+ordered_hash_map = "0.5"
 parking_lot = "0.12"
 prost = "0.12"
 prost-build = "0.12"

galileo/Cargo.toml

@@ -40,6 +40,7 @@ log = { workspace = true }
 lyon = { workspace = true, features = ["serialization"] }
 nalgebra = { workspace = true }
 num-traits = { workspace = true }
+ordered_hash_map = { workspace = true }
 parking_lot = { workspace = true }
 quick_cache = { workspace = true }
 raw-window-handle = { workspace = true, optional = true }

galileo/src/layer/raster_tile_layer/mod.rs

@@ -160,7 +160,7 @@ impl Layer for RasterTileLayer {
 
         let displayed_tiles = self.tile_container.tiles.lock();
         let to_render: Vec<_> = displayed_tiles
-            .iter()
+            .values()
             .filter_map(|v| {
                 let tile_bbox = self.tile_schema.tile_bbox(v.index)?;
                 let offset = Vector2::new(tile_bbox.x_min() as f32, tile_bbox.y_max() as f32);

galileo/src/layer/tiles.rs

@@ -1,7 +1,10 @@
+use std::hash::Hash;
 use std::sync::atomic::{AtomicU64, Ordering};
 use std::sync::Arc;
 use std::time::Duration;
 
+use ahash::HashSet;
+use ordered_hash_map::OrderedHashMap;
 use parking_lot::Mutex;
 
 use crate::render::PackedBundle;
@@ -31,18 +34,18 @@ pub(crate) trait TileProvider<StyleId> {
 
 pub(crate) struct TilesContainer<StyleId, Provider>
 where
-    StyleId: Copy,
+    StyleId: Copy + Hash + Eq,
     Provider: TileProvider<StyleId>,
 {
-    pub(crate) tiles: Mutex<Vec<DisplayedTile<StyleId>>>,
+    pub(crate) tiles: Mutex<OrderedHashMap<(WrappingTileIndex, StyleId), DisplayedTile<StyleId>>>,
     tile_schema: TileSchema,
     pub(crate) tile_provider: Provider,
     pub fade_in_duration: AtomicU64,
 }
 
 impl<StyleId, Provider> TilesContainer<StyleId, Provider>
 where
-    StyleId: Copy + PartialEq,
+    StyleId: Copy + Hash + Eq,
     Provider: TileProvider<StyleId>,
 {
     pub(crate) fn new(tile_schema: TileSchema, tile_provider: Provider) -> Self {
@@ -62,19 +65,20 @@ where
         let mut displayed_tiles = self.tiles.lock();
 
         let mut needed_tiles = vec![];
+        let mut tile_indices = HashSet::default();
         let mut to_substitute = vec![];
 
         let now = web_time::Instant::now();
         let fade_in_time = self.fade_in_duration();
         let mut requires_redraw = false;
 
         for index in needed_indices {
-            if let Some(displayed) = displayed_tiles
-                .iter_mut()
-                .find(|displayed| displayed.index == index && displayed.style_id == style_id)
-            {
+            if let Some(mut displayed) = displayed_tiles.remove(&(index, style_id)) {
                 if !displayed.is_opaque() {
-                    to_substitute.push(index);
+                    if let Some(bbox) = self.tile_schema.tile_bbox(index) {
+                        to_substitute.push(bbox);
+                    }
+
                     let fade_in_secs = fade_in_time.as_secs_f64();
                     displayed.opacity = if fade_in_secs > 0.001 {
                         ((now.duration_since(displayed.displayed_at)).as_secs_f64() / fade_in_secs)
@@ -86,9 +90,14 @@ where
                 }
 
                 needed_tiles.push(displayed.clone());
+                tile_indices.insert((index, style_id));
             } else {
                 match self.tile_provider.get_tile(index.into(), style_id) {
-                    None => to_substitute.push(index),
+                    None => {
+                        if let Some(bbox) = self.tile_schema.tile_bbox(index) {
+                            to_substitute.push(bbox);
+                        }
+                    }
                     Some(bundle) => {
                         let opacity = if self.requires_animation() { 0.0 } else { 1.0 };
                         needed_tiles.push(DisplayedTile {
@@ -98,39 +107,46 @@ where
                             opacity,
                             displayed_at: now,
                         });
-                        to_substitute.push(index);
+                        tile_indices.insert((index, style_id));
+
+                        if let Some(bbox) = self.tile_schema.tile_bbox(index) {
+                            to_substitute.push(bbox);
+                        }
+
                         requires_redraw = true;
                     }
                 }
             }
         }
 
-        let mut new_displayed = vec![];
-        for displayed in displayed_tiles.iter() {
-            if needed_tiles
-                .iter()
-                .any(|new| new.index == displayed.index && new.style_id == displayed.style_id)
-            {
-                continue;
-            }
-
-            let Some(displayed_bbox) = self.tile_schema.tile_bbox(displayed.index) else {
-                continue;
-            };
+        let mut new_displayed = OrderedHashMap::new();
+        let mut selected = Vec::with_capacity(displayed_tiles.len());
 
-            for subst in &to_substitute {
-                let Some(subst_bbox) = self.tile_schema.tile_bbox(*subst) else {
+        for subst_bbox in &to_substitute {
+            for key in displayed_tiles.keys() {
+                let Some(displayed_bbox) = self.tile_schema.tile_bbox(key.0) else {
                     continue;
                 };
 
-                if displayed_bbox.intersects(subst_bbox) {
-                    new_displayed.push(displayed.clone());
-                    break;
+                if displayed_bbox.intersects(*subst_bbox) {
+                    selected.push(*key);
                 }
             }
+
+            for key in &selected {
+                let Some(tile) = displayed_tiles.remove(key) else {
+                    continue;
+                };
+
+                new_displayed.insert(*key, tile);
+            }
+
+            selected.clear();
         }
 
-        new_displayed.append(&mut needed_tiles);
+        for tile in needed_tiles {
+            new_displayed.insert((tile.index, tile.style_id), tile);
+        }
         *displayed_tiles = new_displayed;
 
         requires_redraw

galileo/src/layer/vector_tile_layer/mod.rs

@@ -71,7 +71,7 @@ impl Layer for VectorTileLayer {
         let displayed_tiles = self.displayed_tiles.tiles.lock();
         let to_render: Vec<_> =
             std::iter::once(BundleToDraw::with_opacity(&*background_bundle, 1.0))
-                .chain(displayed_tiles.iter().filter_map(|v| {
+                .chain(displayed_tiles.values().filter_map(|v| {
                     let bbox = self.tile_schema.tile_bbox(v.index)?;
                     Some(BundleToDraw::new(
                         &*v.bundle,