Use the tile set to render static profiles

src/app.rs

@@ -11,7 +11,7 @@ use serde::{Deserialize, Serialize};
 
 use crate::data::{
     DataSourceInfo, EntryID, EntryIndex, EntryInfo, Field, ItemMeta, ItemUID, SlotMetaTileData,
-    SlotTileData, SummaryTileData, TileID, UtilPoint,
+    SlotTileData, SummaryTileData, TileID, TileSet, UtilPoint,
 };
 use crate::deferred_data::{CountingDeferredDataSource, DeferredDataSource};
 use crate::timestamp::{Interval, Timestamp, TimestampParseError};
@@ -111,10 +111,14 @@ struct Config {
 
     // This is just for the local profile
     interval: Interval,
+    tile_set: TileSet,
 
     data_source: CountingDeferredDataSource<Box<dyn DeferredDataSource>>,
 
     search_state: SearchState,
+
+    last_request_interval: Option<Interval>,
+    request_tile_cache: Vec<TileID>,
 }
 
 struct Window {
@@ -1095,27 +1099,63 @@ impl SearchState {
 }
 
 impl Config {
-    fn new(data_source: Box<dyn DeferredDataSource>, info: &DataSourceInfo) -> Self {
+    fn new(data_source: Box<dyn DeferredDataSource>, info: DataSourceInfo) -> Self {
         let max_node = info.entry_info.nodes();
         let interval = info.interval;
+        let tile_set = info.tile_set;
 
         Self {
             min_node: 0,
             max_node,
             interval,
+            tile_set,
             data_source: CountingDeferredDataSource::new(data_source),
             search_state: SearchState::default(),
+            last_request_interval: None,
+            request_tile_cache: Vec::new(),
         }
     }
 
     fn request_tiles(&mut self, request_interval: Interval) -> Vec<TileID> {
-        // For now, always return a single tile
-        vec![TileID(request_interval)]
+        if self.last_request_interval == Some(request_interval) {
+            return self.request_tile_cache.clone();
+        }
+
+        if self.tile_set.tiles.is_empty() {
+            // For dynamic profiles, just return the request as one tile.
+            self.request_tile_cache = vec![TileID(request_interval)];
+            return self.request_tile_cache.clone();
+        }
+
+        // We're in a static profile. Estimate the best zoom level, where
+        // "best" minimizes the ratio of the tile size to request size.
+        let request_duration = request_interval.duration_ns();
+        let chosen_level = self
+            .tile_set
+            .tiles
+            .iter()
+            .min_by_key(|level| {
+                let d = level.first().unwrap().0.duration_ns();
+                if d < request_duration {
+                    request_duration / d
+                } else {
+                    d / request_duration
+                }
+            })
+            .unwrap();
+
+        // Now filter to just tiles overlapping the requested interval.
+        self.request_tile_cache = chosen_level
+            .iter()
+            .filter(|tile| request_interval.overlaps(tile.0))
+            .copied()
+            .collect();
+        self.request_tile_cache.clone()
     }
 }
 
 impl Window {
-    fn new(data_source: Box<dyn DeferredDataSource>, info: &DataSourceInfo, index: u64) -> Self {
+    fn new(data_source: Box<dyn DeferredDataSource>, info: DataSourceInfo, index: u64) -> Self {
         Self {
             panel: Panel::new(&info.entry_info, EntryID::root()),
             index,
@@ -1665,7 +1705,7 @@ impl eframe::App for ProfApp {
             // We made one request, so we know there is always zero or one
             // elements in this list.
             if let Some(info) = source.get_infos().pop() {
-                let window = Window::new(source, &info, windows.len() as u64);
+                let window = Window::new(source, info, windows.len() as u64);
                 if windows.is_empty() {
                     cx.total_interval = window.config.interval;
                 } else {

src/archive_data.rs

@@ -107,15 +107,13 @@ impl<T: DeferredDataSource> DataSourceArchiveWriter<T> {
     }
 
     fn check_info(&mut self) -> Option<DataSourceInfo> {
-        let mut result = self.data_source.get_infos();
-        if result.is_empty() {
-            return None;
-        }
-        assert_eq!(result.len(), 1);
-        let result = result.pop().unwrap();
+        // We requested this once, so we know we'll get zero or one result
+        self.data_source.get_infos().pop()
+    }
+
+    fn write_info(&mut self, info: DataSourceInfo) {
         let path = self.path.join("info");
-        spawn_write(path, result.clone());
-        Some(result)
+        spawn_write(path, info);
     }
 
     fn write_summary_tiles(&mut self) {
@@ -154,11 +152,6 @@ impl<T: DeferredDataSource> DataSourceArchiveWriter<T> {
         }
     }
 
-    fn write_tile_set(&mut self, tile_set: TileSet) {
-        let path = self.path.join("tile_set");
-        spawn_write(path, tile_set);
-    }
-
     pub fn write(mut self) -> io::Result<()> {
         self.path = create_unique_dir(&self.path, self.force)?;
         create_dir(self.path.join("summary_tile"))?;
@@ -170,7 +163,7 @@ impl<T: DeferredDataSource> DataSourceArchiveWriter<T> {
         while info.is_none() {
             info = self.check_info();
         }
-        let info = info.unwrap();
+        let mut info = info.unwrap();
 
         let entry_ids = walk_entry_list(&info.entry_info);
         for entry_id in &entry_ids {
@@ -186,6 +179,9 @@ impl<T: DeferredDataSource> DataSourceArchiveWriter<T> {
             }
         }
 
+        // For now, this only works on dynamic data sources
+        assert!(info.tile_set.tiles.is_empty());
+
         let mut tile_set = Vec::new();
 
         for level in 0..=self.levels {
@@ -224,7 +220,9 @@ impl<T: DeferredDataSource> DataSourceArchiveWriter<T> {
             tile_set.push(tile_ids);
         }
 
-        self.write_tile_set(TileSet { tiles: tile_set });
+        info.tile_set = TileSet { tiles: tile_set };
+
+        self.write_info(info);
 
         Ok(())
     }

src/data.rs

@@ -22,6 +22,7 @@ pub enum EntryIndex {
 pub struct DataSourceInfo {
     pub entry_info: EntryInfo,
     pub interval: Interval,
+    pub tile_set: TileSet,
 }
 
 #[derive(Debug, Clone, Deserialize, Serialize)]
@@ -124,15 +125,13 @@ pub struct SlotMetaTile {
 
 pub trait DataSource {
     fn fetch_info(&self) -> DataSourceInfo;
-    fn fetch_tile_set(&self) -> TileSet;
     fn fetch_summary_tile(&self, entry_id: &EntryID, tile_id: TileID) -> SummaryTile;
     fn fetch_slot_tile(&self, entry_id: &EntryID, tile_id: TileID) -> SlotTile;
     fn fetch_slot_meta_tile(&self, entry_id: &EntryID, tile_id: TileID) -> SlotMetaTile;
 }
 
 pub trait DataSourceMut {
     fn fetch_info(&mut self) -> DataSourceInfo;
-    fn fetch_tile_set(&mut self) -> TileSet;
     fn fetch_summary_tile(&mut self, entry_id: &EntryID, tile_id: TileID) -> SummaryTile;
     fn fetch_slot_tile(&mut self, entry_id: &EntryID, tile_id: TileID) -> SlotTile;
     fn fetch_slot_meta_tile(&mut self, entry_id: &EntryID, tile_id: TileID) -> SlotMetaTile;
@@ -142,9 +141,6 @@ impl<T: DataSource> DataSourceMut for T {
     fn fetch_info(&mut self) -> DataSourceInfo {
         DataSource::fetch_info(self)
     }
-    fn fetch_tile_set(&mut self) -> TileSet {
-        DataSource::fetch_tile_set(self)
-    }
     fn fetch_summary_tile(&mut self, entry_id: &EntryID, tile_id: TileID) -> SummaryTile {
         DataSource::fetch_summary_tile(self, entry_id, tile_id)
     }

src/deferred_data.rs

@@ -1,12 +1,10 @@
 use crate::data::{
-    DataSourceInfo, DataSourceMut, EntryID, SlotMetaTile, SlotTile, SummaryTile, TileID, TileSet,
+    DataSourceInfo, DataSourceMut, EntryID, SlotMetaTile, SlotTile, SummaryTile, TileID,
 };
 
 pub trait DeferredDataSource {
     fn fetch_info(&mut self);
     fn get_infos(&mut self) -> Vec<DataSourceInfo>;
-    fn fetch_tile_set(&mut self);
-    fn get_tile_sets(&mut self) -> Vec<TileSet>;
     fn fetch_summary_tile(&mut self, entry_id: &EntryID, tile_id: TileID);
     fn get_summary_tiles(&mut self) -> Vec<SummaryTile>;
     fn fetch_slot_tile(&mut self, entry_id: &EntryID, tile_id: TileID);
@@ -18,7 +16,6 @@ pub trait DeferredDataSource {
 pub struct DeferredDataSourceWrapper<T: DataSourceMut> {
     data_source: T,
     infos: Vec<DataSourceInfo>,
-    tile_sets: Vec<TileSet>,
     summary_tiles: Vec<SummaryTile>,
     slot_tiles: Vec<SlotTile>,
     slot_meta_tiles: Vec<SlotMetaTile>,
@@ -29,7 +26,6 @@ impl<T: DataSourceMut> DeferredDataSourceWrapper<T> {
         Self {
             data_source,
             infos: Vec::new(),
-            tile_sets: Vec::new(),
             summary_tiles: Vec::new(),
             slot_tiles: Vec::new(),
             slot_meta_tiles: Vec::new(),
@@ -46,14 +42,6 @@ impl<T: DataSourceMut> DeferredDataSource for DeferredDataSourceWrapper<T> {
         std::mem::take(&mut self.infos)
     }
 
-    fn fetch_tile_set(&mut self) {
-        self.tile_sets.push(self.data_source.fetch_tile_set());
-    }
-
-    fn get_tile_sets(&mut self) -> Vec<TileSet> {
-        std::mem::take(&mut self.tile_sets)
-    }
-
     fn fetch_summary_tile(&mut self, entry_id: &EntryID, tile_id: TileID) {
         self.summary_tiles
             .push(self.data_source.fetch_summary_tile(entry_id, tile_id));
@@ -122,16 +110,6 @@ impl<T: DeferredDataSource> DeferredDataSource for CountingDeferredDataSource<T>
         self.finish_request(result)
     }
 
-    fn fetch_tile_set(&mut self) {
-        self.start_request();
-        self.data_source.fetch_tile_set()
-    }
-
-    fn get_tile_sets(&mut self) -> Vec<TileSet> {
-        let result = self.data_source.get_tile_sets();
-        self.finish_request(result)
-    }
-
     fn fetch_summary_tile(&mut self, entry_id: &EntryID, tile_id: TileID) {
         self.start_request();
         self.data_source.fetch_summary_tile(entry_id, tile_id)
@@ -172,14 +150,6 @@ impl DeferredDataSource for Box<dyn DeferredDataSource> {
         self.as_mut().get_infos()
     }
 
-    fn fetch_tile_set(&mut self) {
-        self.as_mut().fetch_tile_set()
-    }
-
-    fn get_tile_sets(&mut self) -> Vec<TileSet> {
-        self.as_mut().get_tile_sets()
-    }
-
     fn fetch_summary_tile(&mut self, entry_id: &EntryID, tile_id: TileID) {
         self.as_mut().fetch_summary_tile(entry_id, tile_id)
     }

src/http/client.rs

@@ -11,7 +11,7 @@ use serde::Deserialize;
 
 use url::Url;
 
-use crate::data::{DataSourceInfo, EntryID, SlotMetaTile, SlotTile, SummaryTile, TileID, TileSet};
+use crate::data::{DataSourceInfo, EntryID, SlotMetaTile, SlotTile, SummaryTile, TileID};
 use crate::deferred_data::DeferredDataSource;
 use crate::http::fetch::{fetch, DataSourceResponse};
 use crate::http::schema::TileRequestRef;
@@ -20,7 +20,6 @@ pub struct HTTPClientDataSource {
     pub baseurl: Url,
     pub client: Client,
     infos: Arc<Mutex<Vec<DataSourceInfo>>>,
-    tile_sets: Arc<Mutex<Vec<TileSet>>>,
     summary_tiles: Arc<Mutex<Vec<SummaryTile>>>,
     slot_tiles: Arc<Mutex<Vec<SlotTile>>>,
     slot_meta_tiles: Arc<Mutex<Vec<SlotMetaTile>>>,
@@ -32,7 +31,6 @@ impl HTTPClientDataSource {
             baseurl,
             client: ClientBuilder::new().build().unwrap(),
             infos: Arc::new(Mutex::new(Vec::new())),
-            tile_sets: Arc::new(Mutex::new(Vec::new())),
             summary_tiles: Arc::new(Mutex::new(Vec::new())),
             slot_tiles: Arc::new(Mutex::new(Vec::new())),
             slot_meta_tiles: Arc::new(Mutex::new(Vec::new())),
@@ -61,28 +59,19 @@ impl HTTPClientDataSource {
 
 impl DeferredDataSource for HTTPClientDataSource {
     fn fetch_info(&mut self) {
-        let url = self.baseurl.join("/info").expect("invalid baseurl");
+        let url = self.baseurl.join("info").expect("invalid baseurl");
         self.request::<DataSourceInfo>(url, self.infos.clone());
     }
 
     fn get_infos(&mut self) -> Vec<DataSourceInfo> {
         std::mem::take(&mut self.infos.lock().unwrap())
     }
 
-    fn fetch_tile_set(&mut self) {
-        let url = self.baseurl.join("/tile_set").expect("invalid baseurl");
-        self.request::<TileSet>(url, self.tile_sets.clone());
-    }
-
-    fn get_tile_sets(&mut self) -> Vec<TileSet> {
-        std::mem::take(&mut self.tile_sets.lock().unwrap())
-    }
-
     fn fetch_summary_tile(&mut self, entry_id: &EntryID, tile_id: TileID) {
         let req = TileRequestRef { entry_id, tile_id };
         let url = self
             .baseurl
-            .join("/summary_tile/")
+            .join("summary_tile/")
             .and_then(|u| u.join(&req.to_slug()))
             .expect("invalid baseurl");
         self.request::<SummaryTile>(url, self.summary_tiles.clone());
@@ -96,7 +85,7 @@ impl DeferredDataSource for HTTPClientDataSource {
         let req = TileRequestRef { entry_id, tile_id };
         let url = self
             .baseurl
-            .join("/slot_tile/")
+            .join("slot_tile/")
             .and_then(|u| u.join(&req.to_slug()))
             .expect("invalid baseurl");
         self.request::<SlotTile>(url, self.slot_tiles.clone());
@@ -110,7 +99,7 @@ impl DeferredDataSource for HTTPClientDataSource {
         let req = TileRequestRef { entry_id, tile_id };
         let url = self
             .baseurl
-            .join("/slot_meta_tile/")
+            .join("slot_meta_tile/")
             .and_then(|u| u.join(&req.to_slug()))
             .expect("invalid baseurl");
         self.request::<SlotMetaTile>(url, self.slot_meta_tiles.clone());

src/http/server.rs

@@ -26,12 +26,6 @@ async fn fetch_info(state: web::Data<AppState>) -> Result<impl Responder> {
     Ok(web::Json(result))
 }
 
-#[get("/tile_set")]
-async fn fetch_tile_set(state: web::Data<AppState>) -> Result<impl Responder> {
-    let result = state.data_source.fetch_tile_set();
-    Ok(web::Json(result))
-}
-
 #[get("/summary_tile/{entry_id}/{tile_id}")]
 async fn fetch_summary_tile(
     req: web::Path<TileRequestPath>,
@@ -108,7 +102,6 @@ impl DataSourceHTTPServer {
                 .wrap(cors)
                 .app_data(state.clone())
                 .service(fetch_info)
-                .service(fetch_tile_set)
                 .service(fetch_summary_tile)
                 .service(fetch_slot_tile)
                 .service(fetch_slot_meta_tile)

src/main.rs

@@ -260,13 +260,10 @@ impl DataSourceMut for RandomDataSource {
         DataSourceInfo {
             entry_info: self.entry_info().clone(),
             interval: self.interval(),
+            tile_set: TileSet::default(),
         }
     }
 
-    fn fetch_tile_set(&mut self) -> TileSet {
-        TileSet::default()
-    }
-
     fn fetch_summary_tile(&mut self, entry_id: &EntryID, tile_id: TileID) -> SummaryTile {
         let utilization = self.generate_summary(entry_id);