Auto merge of #394 - pcwalton:image-caching, r=pcwalton

Cache images from frame to frame.

Images are cached for one frame; if they are not used the next frame, they're
freed.

Author: bors-servo

content/src/pattern.rs

@@ -53,6 +53,10 @@ pub struct Image {
     is_opaque: bool,
 }
 
+/// Unique identifier for an image.
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
+pub struct ImageHash(pub u64);
+
 bitflags! {
     pub struct PatternFlags: u8 {
         const REPEAT_X      = 0x01;
@@ -185,6 +189,13 @@ impl Image {
     pub fn is_opaque(&self) -> bool {
         self.is_opaque
     }
+
+    #[inline]
+    pub fn get_hash(&self) -> ImageHash {
+        let mut hasher = DefaultHasher::new();
+        self.hash(&mut hasher);
+        ImageHash(hasher.finish())
+    }
 }
 
 impl PatternSource {

examples/canvas_nanovg/src/main.rs

@@ -1541,6 +1541,9 @@ fn main() {
     let mut cpu_graph = PerfGraph::new(GraphStyle::MS, "CPU Time");
     let mut gpu_graph = PerfGraph::new(GraphStyle::MS, "GPU Time");
 
+    // Initialize scene proxy.
+    let mut scene = SceneProxy::new(renderer.mode().level, RayonExecutor);
+
     // Enter the main loop.
     let mut exit = false;
     while !exit {
@@ -1569,9 +1572,7 @@ fn main() {
 
         // Render the canvas to screen.
         let canvas = context.into_canvas();
-        let mut scene = SceneProxy::from_scene(canvas.into_scene(),
-                                               renderer.mode().level,
-                                               RayonExecutor);
+        scene.replace_scene(canvas.into_scene());
         scene.build_and_render(&mut renderer, BuildOptions::default());
 
         // Present the rendered canvas via `surfman`.

renderer/src/allocator.rs

@@ -18,7 +18,7 @@ const ATLAS_TEXTURE_LENGTH: u32 = 1024;
 
 #[derive(Clone, Debug)]
 pub struct TextureAllocator {
-    pages: Vec<TexturePage>,
+    pages: Vec<Option<TexturePage>>,
 }
 
 #[derive(Clone, Debug)]
@@ -71,40 +71,87 @@ impl TextureAllocator {
         }
 
         // Try to add to each atlas.
+        let mut first_free_page_index = self.pages.len();
         for (page_index, page) in self.pages.iter_mut().enumerate() {
-            match page.allocator {
-                TexturePageAllocator::Image { .. } => {}
-                TexturePageAllocator::Atlas(ref mut allocator) => {
-                    if let Some(rect) = allocator.allocate(requested_size) {
-                        return TextureLocation { page: TexturePageId(page_index as u32), rect };
+            match *page {
+                Some(ref mut page) => {
+                    match page.allocator {
+                        TexturePageAllocator::Image { .. } => {}
+                        TexturePageAllocator::Atlas(ref mut allocator) => {
+                            if let Some(rect) = allocator.allocate(requested_size) {
+                                return TextureLocation {
+                                    page: TexturePageId(page_index as u32),
+                                    rect
+                                };
+                            }
+                        }
                     }
                 }
+                None => first_free_page_index = first_free_page_index.min(page_index),
             }
         }
 
         // Add a new atlas.
-        let page = TexturePageId(self.pages.len() as u32);
+        let page = self.get_first_free_page_id();
         let mut allocator = TextureAtlasAllocator::new();
         let rect = allocator.allocate(requested_size).expect("Allocation failed!");
-        self.pages.push(TexturePage {
+        while (page.0 as usize) >= self.pages.len() {
+            self.pages.push(None);
+        }
+        self.pages[page.0 as usize] = Some(TexturePage {
             is_new: true,
             allocator: TexturePageAllocator::Atlas(allocator),
         });
         TextureLocation { page, rect }
     }
 
     pub fn allocate_image(&mut self, requested_size: Vector2I) -> TextureLocation {
-        let page = TexturePageId(self.pages.len() as u32);
+        let page = self.get_first_free_page_id();
         let rect = RectI::new(Vector2I::default(), requested_size);
-        self.pages.push(TexturePage {
+        while (page.0 as usize) >= self.pages.len() {
+            self.pages.push(None);
+        }
+        self.pages[page.0 as usize] = Some(TexturePage {
             is_new: true,
             allocator: TexturePageAllocator::Image { size: rect.size() },
         });
         TextureLocation { page, rect }
     }
 
+    fn get_first_free_page_id(&self) -> TexturePageId {
+        for (page_index, page) in self.pages.iter().enumerate() {
+            if page.is_none() {
+                return TexturePageId(page_index as u32);
+            }
+        }
+        TexturePageId(self.pages.len() as u32)
+    }
+
+    pub fn free(&mut self, location: TextureLocation) {
+        //println!("free({:?})", location);
+        match self.pages[location.page.0 as usize]
+                  .as_mut()
+                  .expect("Texture page is not allocated!")
+                  .allocator {
+            TexturePageAllocator::Image { size } => {
+                debug_assert_eq!(location.rect, RectI::new(Vector2I::default(), size));
+            }
+            TexturePageAllocator::Atlas(ref mut atlas_allocator) => {
+                atlas_allocator.free(location.rect);
+                if !atlas_allocator.is_empty() {
+                    // Keep the page around.
+                    return;
+                }
+            }
+        }
+
+        // If we got here, free the page.
+        // TODO(pcwalton): Actually tell the renderer to free this page!
+        self.pages[location.page.0 as usize] = None;
+    }
+
     pub fn page_size(&self, page_id: TexturePageId) -> Vector2I {
-        match self.pages[page_id.0 as usize].allocator {
+        match self.pages[page_id.0 as usize].as_ref().expect("No such texture page!").allocator {
             TexturePageAllocator::Atlas(ref atlas) => Vector2I::splat(atlas.size as i32),
             TexturePageAllocator::Image { size, .. } => size,
         }
@@ -115,16 +162,23 @@ impl TextureAllocator {
     }
 
     pub fn page_is_new(&self, page_id: TexturePageId) -> bool {
-        self.pages[page_id.0 as usize].is_new
+        self.pages[page_id.0 as usize].as_ref().expect("No such texture page!").is_new
     }
 
-    pub fn mark_page_as_allocated(&mut self, page_id: TexturePageId) {
-        self.pages[page_id.0 as usize].is_new = false;
+    pub fn mark_all_pages_as_allocated(&mut self) {
+        for page in &mut self.pages {
+            if let Some(ref mut page) = *page {
+                page.is_new = false;
+            }
+        }
     }
 
-    #[inline]
-    pub fn page_count(&self) -> u32 {
-        self.pages.len() as u32
+    pub fn page_ids(&self) -> TexturePageIter {
+        let mut first_index = 0;
+        while first_index < self.pages.len() && self.pages[first_index].is_none() {
+            first_index += 1;
+        }
+        TexturePageIter { allocator: self, next_index: first_index }
     }
 }
 
@@ -147,7 +201,6 @@ impl TextureAtlasAllocator {
     }
 
     #[inline]
-    #[allow(dead_code)]
     fn free(&mut self, rect: RectI) {
         let requested_length = rect.width() as u32;
         self.root.free(Vector2I::default(), self.size, rect.origin(), requested_length)
@@ -285,6 +338,30 @@ impl TreeNode {
     }
 }
 
+pub struct TexturePageIter<'a> {
+    allocator: &'a TextureAllocator,
+    next_index: usize,
+}
+
+impl<'a> Iterator for TexturePageIter<'a> {
+    type Item = TexturePageId;
+    fn next(&mut self) -> Option<TexturePageId> {
+        let next_id = if self.next_index >= self.allocator.pages.len() {
+            None
+        } else {
+            Some(TexturePageId(self.next_index as u32))
+        };
+        loop {
+            self.next_index += 1;
+            if self.next_index >= self.allocator.pages.len() ||
+                    self.allocator.pages[self.next_index as usize].is_some() {
+                break;
+            }
+        }
+        next_id
+    }
+}
+
 #[cfg(test)]
 mod test {
     use pathfinder_geometry::vector::vec2i;

renderer/src/builder.rs

@@ -175,7 +175,7 @@ impl<'a, 'b, 'c, 'd> SceneBuilder<'a, 'b, 'c, 'd> {
             render_commands,
             paint_metadata,
             render_target_metadata: _,
-        } = self.scene.build_paint_info(render_transform);
+        } = self.scene.build_paint_info(&mut self.sink.paint_texture_manager, render_transform);
         for render_command in render_commands {
             self.sink.listener.send(render_command);
         }