Auto merge of #3124 - bholley:texture_memory, r=gw3583

Add memory reporters and eviction for cached textures

Reviewed by Glenn in https://bugzilla.mozilla.org/show_bug.cgi?id=1493196

<!-- Reviewable:start -->
---
This change is [<img src="https://reviewable.io/review_button.svg" height="34" align="absmiddle" alt="Reviewable"/>](https://reviewable.io/reviews/servo/webrender/3124)
<!-- Reviewable:end -->

Author: bors-servo

webrender/src/device/gl.rs

@@ -487,6 +487,23 @@ impl Texture {
         self.last_frame_used == frame_id
     }
 
+    /// Returns true if this texture was used within `threshold` frames of
+    /// the current frame.
+    pub fn used_recently(&self, current_frame_id: FrameId, threshold: usize) -> bool {
+        self.last_frame_used + threshold >= current_frame_id
+    }
+
+    /// Returns the number of bytes (generally in GPU memory) that this texture
+    /// consumes.
+    pub fn size_in_bytes(&self) -> usize {
+        assert!(self.layer_count > 0 || self.width + self.height == 0);
+        let bpp = self.format.bytes_per_pixel() as usize;
+        let w = self.width as usize;
+        let h = self.height as usize;
+        let count = self.layer_count as usize;
+        bpp * w * h * count
+    }
+
     #[cfg(feature = "replay")]
     pub fn into_external(mut self) -> ExternalTexture {
         let ext = ExternalTexture {

webrender/src/internal_types.rs

@@ -151,7 +151,7 @@ pub enum ResultMsg {
     UpdateGpuCache(GpuCacheUpdateList),
     UpdateResources {
         updates: TextureUpdateList,
-        cancel_rendering: bool,
+        memory_pressure: bool,
     },
     PublishPipelineInfo(PipelineInfo),
     PublishDocument(

webrender/src/render_backend.rs

@@ -747,7 +747,7 @@ impl RenderBackend {
                 let pending_update = self.resource_cache.pending_updates();
                 let msg = ResultMsg::UpdateResources {
                     updates: pending_update,
-                    cancel_rendering: true,
+                    memory_pressure: true,
                 };
                 self.result_tx.send(msg).unwrap();
                 self.notifier.wake_up();
@@ -1340,7 +1340,7 @@ impl RenderBackend {
             self.result_tx.send(msg_update_gpu_cache).unwrap();
             let msg_update_resources = ResultMsg::UpdateResources {
                 updates: self.resource_cache.pending_updates(),
-                cancel_rendering: false,
+                memory_pressure: false,
             };
             self.result_tx.send(msg_update_resources).unwrap();
             // Save the texture/glyph/image caches.

webrender/src/renderer.rs

@@ -52,6 +52,7 @@ use record::ApiRecordingReceiver;
 use render_backend::RenderBackend;
 use scene_builder::{SceneBuilder, LowPrioritySceneBuilder};
 use shade::Shaders;
+use smallvec::SmallVec;
 use render_task::{RenderTask, RenderTaskKind, RenderTaskTree};
 use resource_cache::ResourceCache;
 use util::drain_filter;
@@ -786,13 +787,38 @@ impl SourceTextureResolver {
         assert!(self.saved_textures.is_empty());
     }
 
-    fn end_frame(&mut self) {
+    fn end_frame(&mut self, device: &mut Device, frame_id: FrameId) {
         // return the cached targets to the pool
         self.end_pass(None, None);
         // return the global alpha texture
         self.render_target_pool.extend(self.shared_alpha_texture.take());
         // return the saved targets as well
         self.render_target_pool.extend(self.saved_textures.drain(..));
+
+        // GC the render target pool.
+        //
+        // We use a simple scheme whereby we drop any texture that hasn't been used
+        // in the last 30 frames. This should generally prevent any sustained build-
+        // up of unused textures, unless we don't generate frames for a long period.
+        // This can happen when the window is minimized, and we probably want to
+        // flush all the WebRender caches in that case [1].
+        //
+        // [1] https://bugzilla.mozilla.org/show_bug.cgi?id=1494099
+        self.retain_targets(device, |texture| texture.used_recently(frame_id, 30));
+    }
+
+    /// Drops all targets from the render target pool that do not satisfy the predicate.
+    pub fn retain_targets<F: Fn(&Texture) -> bool>(&mut self, device: &mut Device, f: F) {
+        // We can't just use retain() because `Texture` requires manual cleanup.
+        let mut tmp = SmallVec::<[Texture; 8]>::new();
+        for target in self.render_target_pool.drain(..) {
+            if f(&target) {
+                tmp.push(target);
+            } else {
+                device.delete_texture(target);
+            }
+        }
+        self.render_target_pool.extend(tmp);
     }
 
     fn end_pass(
@@ -896,6 +922,21 @@ impl SourceTextureResolver {
             }
         }
     }
+
+    fn report_memory(&self) -> MemoryReport {
+        let mut report = MemoryReport::default();
+
+        // We're reporting GPU memory rather than heap-allocations, so we don't
+        // use size_of_op.
+        for t in self.cache_texture_map.iter() {
+            report.texture_cache_textures += t.size_in_bytes();
+        }
+        for t in self.render_target_pool.iter() {
+            report.render_target_textures += t.size_in_bytes();
+        }
+
+        report
+    }
 }
 
 #[derive(Debug, Copy, Clone, PartialEq)]
@@ -1970,17 +2011,27 @@ impl Renderer {
                 }
                 ResultMsg::UpdateResources {
                     updates,
-                    cancel_rendering,
+                    memory_pressure,
                 } => {
                     self.pending_texture_updates.push(updates);
                     self.device.begin_frame();
                     self.update_texture_cache();
+
+                    // Flush the render target pool on memory pressure.
+                    //
+                    // This needs to be separate from the block below because
+                    // the device module asserts if we delete textures while
+                    // not in a frame.
+                    if memory_pressure {
+                        self.texture_resolver.retain_targets(&mut self.device, |_| false);
+                    }
+
                     self.device.end_frame();
                     // If we receive a `PublishDocument` message followed by this one
                     // within the same update we need to cancel the frame because we
                     // might have deleted the resources in use in the frame due to a
                     // memory pressure event.
-                    if cancel_rendering {
+                    if memory_pressure {
                         self.active_documents.clear();
                     }
                 }
@@ -3869,7 +3920,7 @@ impl Renderer {
             );
         }
 
-        self.texture_resolver.end_frame();
+        self.texture_resolver.end_frame(&mut self.device, frame_id);
 
         #[cfg(feature = "debug_renderer")]
         {
@@ -4176,15 +4227,30 @@ impl Renderer {
     /// Collects a memory report.
     pub fn report_memory(&self) -> MemoryReport {
         let mut report = MemoryReport::default();
+
+        // GPU cache CPU memory.
         if let CacheBus::PixelBuffer{ref cpu_blocks, ..} = self.gpu_cache_texture.bus {
             report.gpu_cache_cpu_mirror += self.size_of(cpu_blocks.as_ptr());
         }
 
+        // GPU cache GPU memory.
+        report.gpu_cache_textures += self.gpu_cache_texture.texture.size_in_bytes();
+
+        // Render task CPU memory.
         for (_id, doc) in &self.active_documents {
             report.render_tasks += self.size_of(doc.frame.render_tasks.tasks.as_ptr());
             report.render_tasks += self.size_of(doc.frame.render_tasks.task_data.as_ptr());
         }
 
+        // Vertex data GPU memory.
+        report.vertex_data_textures += self.prim_header_f_texture.texture.size_in_bytes();
+        report.vertex_data_textures += self.prim_header_i_texture.texture.size_in_bytes();
+        report.vertex_data_textures += self.transforms_texture.texture.size_in_bytes();
+        report.vertex_data_textures += self.render_task_texture.texture.size_in_bytes();
+
+        // Texture cache and render target GPU memory.
+        report += self.texture_resolver.report_memory();
+
         report
     }
 

webrender_api/src/api.rs

@@ -751,6 +751,9 @@ impl PipelineId {
 #[repr(C)]
 #[derive(Clone, Debug, Default, Deserialize, Serialize)]
 pub struct MemoryReport {
+    //
+    // CPU Memory.
+    //
     pub primitive_stores: usize,
     pub clip_stores: usize,
     pub gpu_cache_metadata: usize,
@@ -760,6 +763,13 @@ pub struct MemoryReport {
     pub fonts: usize,
     pub images: usize,
     pub rasterized_blobs: usize,
+    //
+    // GPU memory.
+    //
+    pub gpu_cache_textures: usize,
+    pub vertex_data_textures: usize,
+    pub render_target_textures: usize,
+    pub texture_cache_textures: usize,
 }
 
 impl ::std::ops::AddAssign for MemoryReport {
@@ -773,6 +783,10 @@ impl ::std::ops::AddAssign for MemoryReport {
         self.fonts += other.fonts;
         self.images += other.images;
         self.rasterized_blobs += other.rasterized_blobs;
+        self.gpu_cache_textures += other.gpu_cache_textures;
+        self.vertex_data_textures += other.vertex_data_textures;
+        self.render_target_textures += other.render_target_textures;
+        self.texture_cache_textures += other.texture_cache_textures;
     }
 }