Auto merge of #1758 - glennw:small-target, r=kvark

Initialize render targets to the required size, saving memory and clear time.

We have the information available that tells us the worst case
*actual* size requirement for each render pass array texture. Keep
track of that and only create targets of that size.

This is a quite significant GPU memory saving, and also a large
performance win on *some* GPU architectures (seems to be a good
benefit on the Intel GPUs I've tested with).

<!-- 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/1758)
<!-- Reviewable:end -->

Author: bors-servo

webrender/src/renderer.rs

@@ -3040,12 +3040,12 @@ impl Renderer {
             let alpha_target_count = pass.required_target_count(RenderTargetKind::Alpha);
 
             if let Some(texture) = pass.color_texture.as_mut() {
-                debug_assert!(pass.max_color_target_size.width > 0);
-                debug_assert!(pass.max_color_target_size.height > 0);
+                debug_assert!(pass.max_used_color_target_size.width > 0);
+                debug_assert!(pass.max_used_color_target_size.height > 0);
                 self.device.init_texture(
                     texture,
-                    pass.max_color_target_size.width,
-                    pass.max_color_target_size.height,
+                    pass.max_used_color_target_size.width,
+                    pass.max_used_color_target_size.height,
                     ImageFormat::BGRA8,
                     TextureFilter::Linear,
                     RenderTargetMode::RenderTarget,
@@ -3054,12 +3054,12 @@ impl Renderer {
                 );
             }
             if let Some(texture) = pass.alpha_texture.as_mut() {
-                debug_assert!(pass.max_alpha_target_size.width > 0);
-                debug_assert!(pass.max_alpha_target_size.height > 0);
+                debug_assert!(pass.max_used_alpha_target_size.width > 0);
+                debug_assert!(pass.max_used_alpha_target_size.height > 0);
                 self.device.init_texture(
                     texture,
-                    pass.max_alpha_target_size.width,
-                    pass.max_alpha_target_size.height,
+                    pass.max_used_alpha_target_size.width,
+                    pass.max_used_alpha_target_size.height,
                     ImageFormat::A8,
                     TextureFilter::Nearest,
                     RenderTargetMode::RenderTarget,
@@ -3125,17 +3125,17 @@ impl Renderer {
                 for (target_index, target) in pass.alpha_targets.targets.iter().enumerate() {
                     let projection = Transform3D::ortho(
                         0.0,
-                        pass.max_alpha_target_size.width as f32,
+                        pass.max_used_alpha_target_size.width as f32,
                         0.0,
-                        pass.max_alpha_target_size.height as f32,
+                        pass.max_used_alpha_target_size.height as f32,
                         ORTHO_NEAR_PLANE,
                         ORTHO_FAR_PLANE,
                     );
 
                     self.draw_alpha_target(
                         (pass.alpha_texture.as_ref().unwrap(), target_index as i32),
                         target,
-                        pass.max_alpha_target_size,
+                        pass.max_used_alpha_target_size,
                         &projection,
                     );
                 }
@@ -3165,7 +3165,7 @@ impl Renderer {
                             ORTHO_FAR_PLANE,
                         )
                     } else {
-                        size = pass.max_color_target_size;
+                        size = pass.max_used_color_target_size;
                         clear_color = Some([0.0, 0.0, 0.0, 0.0]);
                         projection = Transform3D::ortho(
                             0.0,

webrender/src/tiling.rs

@@ -977,10 +977,18 @@ impl<T: RenderTarget> RenderTargetList<T> {
         gpu_cache: &mut GpuCache,
         render_tasks: &mut RenderTaskTree,
         deferred_resolves: &mut Vec<DeferredResolve>,
-    ) {
+    ) -> DeviceUintSize {
+        let mut max_used_size = DeviceUintSize::zero();
+
         for target in &mut self.targets {
+            let used_rect = target.used_rect();
+            max_used_size.width = cmp::max(max_used_size.width, used_rect.size.width as u32);
+            max_used_size.height = cmp::max(max_used_size.height, used_rect.size.height as u32);
+
             target.build(ctx, gpu_cache, render_tasks, deferred_resolves);
         }
+
+        max_used_size
     }
 
     fn add_task(
@@ -1076,8 +1084,7 @@ impl RenderTarget for ColorRenderTarget {
     fn used_rect(&self) -> DeviceIntRect {
         self.allocator
             .as_ref()
-            .expect("bug: used_rect called on framebuffer")
-            .used_rect
+            .map_or(DeviceIntRect::zero(), |allocator| allocator.used_rect)
     }
 
     fn build(
@@ -1302,8 +1309,10 @@ pub struct RenderPass {
     pub color_texture: Option<Texture>,
     pub alpha_texture: Option<Texture>,
     dynamic_tasks: FastHashMap<RenderTaskKey, DynamicTaskInfo>,
-    pub max_color_target_size: DeviceUintSize,
-    pub max_alpha_target_size: DeviceUintSize,
+    pub color_allocator_size: DeviceUintSize,
+    pub alpha_allocator_size: DeviceUintSize,
+    pub max_used_color_target_size: DeviceUintSize,
+    pub max_used_alpha_target_size: DeviceUintSize,
 }
 
 impl RenderPass {
@@ -1316,8 +1325,10 @@ impl RenderPass {
             color_texture: None,
             alpha_texture: None,
             dynamic_tasks: FastHashMap::default(),
-            max_color_target_size: DeviceUintSize::new(MIN_TARGET_SIZE, MIN_TARGET_SIZE),
-            max_alpha_target_size: DeviceUintSize::new(MIN_TARGET_SIZE, MIN_TARGET_SIZE),
+            color_allocator_size: DeviceUintSize::new(MIN_TARGET_SIZE, MIN_TARGET_SIZE),
+            alpha_allocator_size: DeviceUintSize::new(MIN_TARGET_SIZE, MIN_TARGET_SIZE),
+            max_used_color_target_size: DeviceUintSize::zero(),
+            max_used_alpha_target_size: DeviceUintSize::zero(),
         }
     }
 
@@ -1329,16 +1340,16 @@ impl RenderPass {
     ) {
         match target_kind {
             RenderTargetKind::Color => {
-                self.max_color_target_size.width =
-                    cmp::max(self.max_color_target_size.width, size.width as u32);
-                self.max_color_target_size.height =
-                    cmp::max(self.max_color_target_size.height, size.height as u32);
+                self.color_allocator_size.width =
+                    cmp::max(self.color_allocator_size.width, size.width as u32);
+                self.color_allocator_size.height =
+                    cmp::max(self.color_allocator_size.height, size.height as u32);
             }
             RenderTargetKind::Alpha => {
-                self.max_alpha_target_size.width =
-                    cmp::max(self.max_alpha_target_size.width, size.width as u32);
-                self.max_alpha_target_size.height =
-                    cmp::max(self.max_alpha_target_size.height, size.height as u32);
+                self.alpha_allocator_size.width =
+                    cmp::max(self.alpha_allocator_size.width, size.width as u32);
+                self.alpha_allocator_size.height =
+                    cmp::max(self.alpha_allocator_size.height, size.height as u32);
             }
         }
 
@@ -1396,9 +1407,9 @@ impl RenderPass {
                         let alloc_size = DeviceUintSize::new(size.width as u32, size.height as u32);
                         let (alloc_origin, target_index) = match target_kind {
                             RenderTargetKind::Color => self.color_targets
-                                .allocate(alloc_size, self.max_color_target_size),
+                                .allocate(alloc_size, self.color_allocator_size),
                             RenderTargetKind::Alpha => self.alpha_targets
-                                .allocate(alloc_size, self.max_alpha_target_size),
+                                .allocate(alloc_size, self.alpha_allocator_size),
                         };
 
                         let origin = Some((
@@ -1446,9 +1457,9 @@ impl RenderPass {
             }
         }
 
-        self.color_targets
+        self.max_used_color_target_size = self.color_targets
             .build(ctx, gpu_cache, render_tasks, deferred_resolves);
-        self.alpha_targets
+        self.max_used_alpha_target_size =self.alpha_targets
             .build(ctx, gpu_cache, render_tasks, deferred_resolves);
     }
 }