add cache for storing past fetched tiles that are not used

src/core/src/app.rs

@@ -542,7 +542,7 @@ where
                                 self.request_redraw = true;
                             }
                         } else {
-                            //al_core::log("discard tex sub");
+                            self.downloader.cache_rsc(Resource::Tile(tile));
                         }
                         num_tile_received += 1;
                     }

src/core/src/downloader/mod.rs

@@ -443,26 +443,34 @@ impl TileDownloader {
     }*/
 }*/
 
-use crate::{survey::Url};
-
+use crate::survey::Url;
 use std::collections::HashSet;
 pub struct Downloader {
     // Current requests
     requests: Vec<RequestType>,
     queried_urls: HashSet<Url>,
+
+    cache: Cache<Url, Resource>,
+    queried_cached_urls: HashSet<Url>,
 }
 
+use crate::fifo_cache::Cache;
+
 use query::Query;
 use request::{RequestType, Resource};
 
+
 impl Downloader {
     pub fn new() -> Downloader {
         let requests = Vec::with_capacity(32);
         let queried_urls = HashSet::with_capacity(64);
-
+        let cache = Cache::new();
+        let queried_cached_urls = HashSet::with_capacity(64);
         Self {
             requests,
             queried_urls,
+            cache,
+            queried_cached_urls
         }
     }
 
@@ -476,66 +484,28 @@ impl Downloader {
         //self.tiles_to_req.clear();
 
         let url = query.url();
-        let not_already_requested = !self.queried_urls.contains(url);
+        if self.cache.contains(url) {
+            self.queried_cached_urls.insert(url.to_string());
+            false
+        } else {
+            let not_already_requested = !self.queried_urls.contains(url);
 
-        // The cell is not already requested
-        if not_already_requested || force_request {
-            /*if tile.is_root() {
-                self.base_tiles_to_req.push(tile);
-            } else {
-                self.tiles_to_req.push(tile);
-            }*/
-            self.queried_urls.insert(url.to_string());
-
-            let request = T::Request::from(query);
-            self.requests.push(request.into());
-        }
-
-        not_already_requested
-    }
-
-    /*pub fn try_sending_tile_requests(&mut self, surveys: &ImageSurveys) -> Result<(), JsValue> {
-        // Try sending the fits tile requests
-        let mut is_remaining_req =
-            !self.tiles_to_req.is_empty() || !self.base_tiles_to_req.is_empty();
-
-        let mut downloader_overloaded = false;
-
-        while is_remaining_req && !downloader_overloaded {
-            let mut base_tile_requested = false;
-            let tile = if let Some(base_tile) = self.base_tiles_to_req.last() {
-                base_tile_requested = true;
-                base_tile
-            } else {
-                self.tiles_to_req.last().unwrap()
-            };
-            //let tile = self.tiles_to_req.last();
-
-            if let Some(available_req) = self.requests.check_send(tile.format.clone()) {
-                let tile = if base_tile_requested {
-                    // Send in priority requests to get the base tiles
-                    self.base_tiles_to_req.pop().unwrap()
+            // The cell is not already requested
+            if not_already_requested || force_request {
+                /*if tile.is_root() {
+                    self.base_tiles_to_req.push(tile);
                 } else {
-                    // Otherwise requests the other tiles
-                    self.tiles_to_req.pop().unwrap()
-                };
-                //let tile = self.tiles_to_req.pop().unwrap();
-
-                is_remaining_req =
-                    !self.tiles_to_req.is_empty() || !self.base_tiles_to_req.is_empty();
-                //is_remaining_req = !self.tiles_to_req.is_empty();
-                self.requested_tiles.insert(tile.clone());
-
-                available_req.fetch(&tile, surveys)?;
-            } else {
-                // We have to wait for more requests
-                // to be available
-                downloader_overloaded = true;
+                    self.tiles_to_req.push(tile);
+                }*/
+                self.queried_urls.insert(url.to_string());
+    
+                let request = T::Request::from(query);
+                self.requests.push(request.into());
             }
+    
+            not_already_requested
         }
-
-        Ok(())
-    }*/
+    }
 
     pub fn get_received_resources(&mut self) -> Vec<Resource> {
         let mut rscs = vec![];
@@ -562,6 +532,17 @@ impl Downloader {
             self.queried_urls.remove(&url);
         }
 
+        for url in self.queried_cached_urls.iter() {
+            let rsc = self.cache.extract(url).unwrap();
+            rscs.push(rsc);
+        }
+
+        self.queried_cached_urls.clear();
+
         rscs
     }
+
+    pub fn cache_rsc(&mut self, rsc: Resource) {
+        self.cache.insert(rsc.url().clone(), rsc);
+    }
 }

src/core/src/downloader/request/blank.rs

@@ -149,6 +149,7 @@ impl From<query::PixelMetadata> for PixelMetadataRequest {
 pub struct PixelMetadata {
     pub value: Metadata,
     pub hips_url: String,
+    pub url: String,
 }
 
 impl<'a> From<&'a PixelMetadataRequest> for Option<PixelMetadata> {
@@ -156,7 +157,7 @@ impl<'a> From<&'a PixelMetadataRequest> for Option<PixelMetadata> {
         let PixelMetadataRequest {
             request,
             hips_url,
-            ..
+            url,
         } = request;
         if request.is_resolved() {
             let Request::<Metadata> {
@@ -166,7 +167,8 @@ impl<'a> From<&'a PixelMetadataRequest> for Option<PixelMetadata> {
             // It will always be resolved and found as we will request a well know tile (Norder0/Tile0)
             Some(PixelMetadata {
                 hips_url: hips_url.clone(),
-                value: data.lock().unwrap().unwrap().clone()
+                url: url.to_string(),
+                value: data.lock().unwrap().unwrap().clone(),
             })
         } else {
             None

src/core/src/downloader/request/mod.rs

@@ -122,3 +122,13 @@ pub enum Resource {
     Allsky(Allsky),
     PixelMetadata(PixelMetadata)
 }
+
+impl Resource {
+    pub fn url(&self) -> &Url {
+        match self {
+            Resource::Tile(tile) => tile.get_url(),
+            Resource::Allsky(allsky) => allsky.get_url(),
+            Resource::PixelMetadata(PixelMetadata { url, ..}) => url, 
+        }
+    }
+}

src/core/src/fifo_cache.rs

@@ -0,0 +1,41 @@
+use std::collections::{HashMap, VecDeque};
+
+pub struct Cache<K, V> {
+    data: HashMap<K, V>,
+    order: VecDeque<K>,
+}
+
+const SIZE_RESOURCE_CACHE: usize = 256;
+
+use std::hash::Hash;
+impl<K, V> Cache<K, V>
+where
+    K: Clone + std::cmp::Eq + Hash
+{
+    pub fn new() -> Self {
+        let data = HashMap::with_capacity(SIZE_RESOURCE_CACHE);
+        let order = VecDeque::with_capacity(SIZE_RESOURCE_CACHE);
+        Cache {
+            data,
+            order
+        }
+    }
+
+    pub fn insert(&mut self, key: K, val: V) {
+        if self.order.len() == SIZE_RESOURCE_CACHE {
+            let k = self.order.pop_front().unwrap();
+            self.data.remove(&k);
+        }
+
+        self.data.insert(key.clone(), val);
+        self.order.push_back(key);
+    }
+
+    pub fn extract(&mut self, key: &K) -> Option<V> {
+        self.data.remove(key)
+    }
+
+    pub fn contains(&self, key: &K) -> bool {
+        self.data.contains_key(key)
+    }
+}

src/core/src/lib.rs

@@ -43,6 +43,7 @@ mod shader;
 mod survey;
 mod tile_fetcher;
 mod time;
+mod fifo_cache;
 
 use crate::{
     camera::CameraViewPort, colormap::Colormaps, math::lonlat::LonLatT, shader::ShaderManager, time::DeltaTime,

src/core/src/survey/mod.rs

@@ -338,7 +338,6 @@ pub fn get_raytracer_shader<'a, P: Projection>(
 //const MAX_NUM_CELLS_TO_DRAW: usize = 768;
 use cgmath::{Vector3, Vector4};
 use render::rasterizer::uv::{TileCorner, TileUVW};
-use al_api::coo_system::CooSystem;
 //#[cfg(feature = "webgl1")]
 fn add_vertices_grid<P: Projection>(
     cell: &HEALPixCell,
@@ -1061,19 +1060,6 @@ impl ImageSurveys {
         }
     }
 
-    pub fn last(&self) -> Option<&ImageSurvey> {
-        if let Some(last_rendered_layer) = self.layers.last() {
-            let url = self
-                .urls
-                .get(last_rendered_layer)
-                .expect("Url from layer name not found.");
-
-            self.surveys.get(url)
-        } else {
-            None
-        }
-    }
-
     pub fn reset_frame(&mut self) {
         for survey in self.surveys.values_mut() {
             survey.reset_frame();

src/core/src/utils.rs

@@ -34,4 +34,4 @@ pub unsafe fn transmute_boxed_slice<I, O>(s: Box<[I]>) -> Box<[O]> {
     let out_slice_ptr = std::slice::from_raw_parts_mut(in_slice_ptr as *mut O, new_len);
 
     Box::from_raw(out_slice_ptr)
-}
+}