Add reporting for texture memory.

Author: bholley

webrender/src/device/gl.rs

@@ -487,6 +487,17 @@ impl Texture {
         self.last_frame_used == 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/renderer.rs

@@ -896,6 +896,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)]
@@ -4176,15 +4191,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;
     }
 }