Optimize upload loop

src/io/scheduler.rs

@@ -215,21 +215,19 @@ impl IOScheduler {
 
     pub fn try_request_tile(
         &mut self,
-        tile_request: TileRequest,
+        coords: &WorldTileCoords,
+        layers: &HashSet<String>,
     ) -> Result<(), SendError<TileRequest>> {
-        let TileRequest { coords, layers } = &tile_request;
-
-        // TODO: Optimize: Dropping TileRequest is expensive
-
         if !self.tile_cache.is_layers_missing(coords, layers) {
             return Ok(());
         }
 
         if let Ok(mut tile_request_state) = self.tile_request_state.try_lock() {
-            let tile_coords = *coords;
-
-            if let Some(id) = tile_request_state.start_tile_request(tile_request) {
-                if let Some(tile_coords) = tile_coords.into_tile(TileAddressingScheme::TMS) {
+            if let Some(id) = tile_request_state.start_tile_request(TileRequest {
+                coords: *coords,
+                layers: layers.clone(),
+            }) {
+                if let Some(tile_coords) = coords.into_tile(TileAddressingScheme::TMS) {
                     info!("new tile request: {}", &tile_coords);
 
                     self.schedule_method
@@ -244,8 +242,8 @@ impl IOScheduler {
     pub fn get_tessellated_layers_at(
         &self,
         coords: &WorldTileCoords,
-        skip_layers: &HashSet<String>,
-    ) -> Vec<LayerResult> {
+        skip_layers: &HashSet<&str>,
+    ) -> Vec<&LayerResult> {
         self.tile_cache
             .get_tessellated_layers_at(coords, skip_layers)
     }

src/io/tile_cache.rs

@@ -28,14 +28,14 @@ impl TileCache {
     pub fn get_tessellated_layers_at(
         &self,
         coords: &WorldTileCoords,
-        skip_layers: &HashSet<String>,
-    ) -> Vec<LayerResult> {
-        let mut ret = Vec::new();
+        skip_layers: &HashSet<&str>,
+    ) -> Vec<&LayerResult> {
+        let mut ret = Vec::with_capacity(10);
 
         if let Some(results) = self.index.get(&coords.build_quad_key()) {
             for result in results {
-                if !skip_layers.contains(&result.layer_name().to_string()) {
-                    ret.push(result.clone());
+                if !skip_layers.contains(&result.layer_name()) {
+                    ret.push(result);
                 }
             }
         }

src/render/buffer_pool.rs

@@ -134,13 +134,15 @@ impl<Q: Queue<B>, B, V: bytemuck::Pod, I: bytemuck::Pod, TM: bytemuck::Pod, FM:
     }
 
     /// FIXME: use an id instead of layer_name to identify tiles
-    pub fn get_loaded_layers_at(&self, coords: &WorldTileCoords) -> HashSet<String> {
-        self.index
-            .get_layers(coords)
-            .unwrap_or(&VecDeque::new())
-            .iter()
-            .map(|entry| entry.style_layer.source_layer.as_ref().unwrap().clone())
-            .collect()
+    pub fn get_loaded_layers_at(&self, coords: &WorldTileCoords) -> HashSet<&str> {
+        if let Some(layers) = self.index.get_layers(coords) {
+            layers
+                .iter()
+                .map(|entry| entry.style_layer.source_layer.as_ref().unwrap().as_str())
+                .collect()
+        } else {
+            HashSet::new()
+        }
     }
 
     /// Allocates

src/render/render_state.rs

@@ -371,11 +371,7 @@ impl RenderState {
                 .collect();
 
             for coords in view_region.iter() {
-                let tile_request = TileRequest {
-                    coords,
-                    layers: source_layers.clone(), // TODO: Optimize: This is expensive
-                };
-                scheduler.try_request_tile(tile_request).unwrap();
+                scheduler.try_request_tile(&coords, &source_layers).unwrap();
             }
         }
 
@@ -418,7 +414,6 @@ impl RenderState {
             for world_coords in view_region.iter() {
                 let loaded_layers = self.buffer_pool.get_loaded_layers_at(&world_coords);
 
-                // TODO: Optimize: Dropping this is expensive
                 let available_layers =
                     scheduler.get_tessellated_layers_at(&world_coords, &loaded_layers);
 

web/webpack.config.js

@@ -92,10 +92,7 @@ module.exports = (env) => ({
             //
             // the mode `development` makes `wasm-pack` build in `debug` mode.
             // the mode `production` makes `wasm-pack` build in `release` mode.
-            // TODO: We always build a production build because a development build runs slow
-            // TODO: The function which is slowing it down is TileProto::decode() which maps the tile proto struct
-            // TODO: into our data structure. (Development: 15s, Production: 60ms)
-            forceMode: "production",
+            // forceMode: "production",
 
             // Controls plugin output verbosity, either 'info' or 'error'.
             // Defaults to 'info'.