Initialize prim store vecs with estimated capacity need.

Record the used size of the prim store vecs that can't be retained
after each scene build, and use this as a capacity estimate for
those arrays next time we build a scene.

webrender/src/display_list_flattener.rs

@@ -25,7 +25,7 @@ use internal_types::{FastHashMap, FastHashSet};
 use picture::{Picture3DContext, PictureCompositeMode, PicturePrimitive, PrimitiveList};
 use prim_store::{BrushKind, BrushPrimitive, PrimitiveInstance, PrimitiveDataInterner, PrimitiveKeyKind};
 use prim_store::{ImageSource, PrimitiveOpacity, PrimitiveKey, PrimitiveSceneData, PrimitiveInstanceKind};
-use prim_store::{BorderSource, PrimitiveContainer, PrimitiveDataHandle, PrimitiveStore};
+use prim_store::{BorderSource, PrimitiveContainer, PrimitiveDataHandle, PrimitiveStore, PrimitiveStoreStats};
 use prim_store::{OpacityBinding, ScrollNodeAndClipChain, PictureIndex, register_prim_chase_id};
 use render_backend::{DocumentView};
 use resource_cache::{FontInstanceMap, ImageRequest};
@@ -170,6 +170,7 @@ impl<'a> DisplayListFlattener<'a> {
         frame_builder_config: &FrameBuilderConfig,
         new_scene: &mut Scene,
         resources: &mut DocumentResources,
+        prim_store_stats: &PrimitiveStoreStats,
     ) -> FrameBuilder {
         // We checked that the root pipeline is available on the render backend.
         let root_pipeline_id = scene.root_pipeline_id.unwrap();
@@ -190,7 +191,7 @@ impl<'a> DisplayListFlattener<'a> {
             pending_shadow_items: VecDeque::new(),
             sc_stack: Vec::new(),
             pipeline_clip_chain_stack: vec![ClipChainId::NONE],
-            prim_store: PrimitiveStore::new(),
+            prim_store: PrimitiveStore::new(&prim_store_stats),
             clip_store: ClipStore::new(),
             resources,
             prim_count_estimate: 0,

webrender/src/frame_builder.rs

@@ -14,6 +14,8 @@ use hit_test::{HitTester, HitTestingRun};
 use internal_types::{FastHashMap, PlaneSplitter};
 use picture::{PictureSurface, PictureUpdateState, SurfaceInfo, ROOT_SURFACE_INDEX, SurfaceIndex};
 use prim_store::{PrimitiveStore, SpaceMapper, PictureIndex, PrimitiveDebugId, PrimitiveScratchBuffer};
+#[cfg(feature = "replay")]
+use prim_store::{PrimitiveStoreStats};
 use profiler::{FrameProfileCounters, GpuCacheProfileCounters, TextureCacheProfileCounters};
 use render_backend::{FrameResources, FrameStamp};
 use render_task::{RenderTask, RenderTaskId, RenderTaskLocation, RenderTaskTree};
@@ -138,7 +140,7 @@ impl FrameBuilder {
     pub fn empty() -> Self {
         FrameBuilder {
             hit_testing_runs: Vec::new(),
-            prim_store: PrimitiveStore::new(),
+            prim_store: PrimitiveStore::new(&PrimitiveStoreStats::empty()),
             clip_store: ClipStore::new(),
             screen_rect: DeviceIntRect::zero(),
             window_size: DeviceIntSize::zero(),

webrender/src/prim_store.rs

@@ -1935,7 +1935,7 @@ impl PrimitiveScratchBuffer {
     pub fn new() -> Self {
         PrimitiveScratchBuffer {
             clip_mask_instances: Vec::new(),
-            glyph_keys: GlyphKeyStorage::new(),
+            glyph_keys: GlyphKeyStorage::new(0),
         }
     }
 
@@ -1953,18 +1953,45 @@ impl PrimitiveScratchBuffer {
     }
 }
 
+#[cfg_attr(feature = "capture", derive(Serialize))]
+#[cfg_attr(feature = "replay", derive(Deserialize))]
+#[derive(Clone, Debug)]
+pub struct PrimitiveStoreStats {
+    primitive_count: usize,
+    picture_count: usize,
+    text_run_count: usize,
+}
+
+impl PrimitiveStoreStats {
+    pub fn empty() -> Self {
+        PrimitiveStoreStats {
+            primitive_count: 0,
+            picture_count: 0,
+            text_run_count: 0,
+        }
+    }
+}
+
 pub struct PrimitiveStore {
     pub primitives: Vec<Primitive>,
     pub pictures: Vec<PicturePrimitive>,
     pub text_runs: TextRunStorage,
 }
 
 impl PrimitiveStore {
-    pub fn new() -> PrimitiveStore {
+    pub fn new(stats: &PrimitiveStoreStats) -> PrimitiveStore {
         PrimitiveStore {
-            primitives: Vec::new(),
-            pictures: Vec::new(),
-            text_runs: TextRunStorage::new(),
+            primitives: Vec::with_capacity(stats.primitive_count),
+            pictures: Vec::with_capacity(stats.picture_count),
+            text_runs: TextRunStorage::new(stats.text_run_count),
+        }
+    }
+
+    pub fn get_stats(&self) -> PrimitiveStoreStats {
+        PrimitiveStoreStats {
+            primitive_count: self.primitives.len(),
+            picture_count: self.pictures.len(),
+            text_run_count: self.text_runs.len(),
         }
     }
 

webrender/src/scene_builder.rs

@@ -13,7 +13,7 @@ use clip::{ClipDataInterner, ClipDataUpdateList};
 use clip_scroll_tree::ClipScrollTree;
 use display_list_flattener::DisplayListFlattener;
 use internal_types::{FastHashMap, FastHashSet};
-use prim_store::{PrimitiveDataInterner, PrimitiveDataUpdateList};
+use prim_store::{PrimitiveDataInterner, PrimitiveDataUpdateList, PrimitiveStoreStats};
 use resource_cache::FontInstanceMap;
 use render_backend::DocumentView;
 use renderer::{PipelineInfo, SceneBuilderHooks};
@@ -180,13 +180,15 @@ impl DocumentResources {
 struct Document {
     scene: Scene,
     resources: DocumentResources,
+    prim_store_stats: PrimitiveStoreStats,
 }
 
 impl Document {
     fn new(scene: Scene) -> Self {
         Document {
             scene,
             resources: DocumentResources::new(),
+            prim_store_stats: PrimitiveStoreStats::empty(),
         }
     }
 }
@@ -326,6 +328,7 @@ impl SceneBuilder {
                     &self.config,
                     &mut new_scene,
                     &mut item.doc_resources,
+                    &PrimitiveStoreStats::empty(),
                 );
 
                 let clip_updates = item
@@ -357,6 +360,7 @@ impl SceneBuilder {
                 Document {
                     scene: item.scene,
                     resources: item.doc_resources,
+                    prim_store_stats: PrimitiveStoreStats::empty(),
                 },
             );
 
@@ -432,8 +436,12 @@ impl SceneBuilder {
                     &self.config,
                     &mut new_scene,
                     &mut doc.resources,
+                    &doc.prim_store_stats,
                 );
 
+                // Update the allocation stats for next scene
+                doc.prim_store_stats = frame_builder.prim_store.get_stats();
+
                 // Retrieve the list of updates from the clip interner.
                 let clip_updates = doc
                     .resources

webrender/src/storage.rs

@@ -59,8 +59,14 @@ pub struct Storage<T> {
 }
 
 impl<T> Storage<T> {
-    pub fn new() -> Self {
-        Storage { data: vec![] }
+    pub fn new(initial_capacity: usize) -> Self {
+        Storage {
+            data: Vec::with_capacity(initial_capacity),
+        }
+    }
+
+    pub fn len(&self) -> usize {
+        self.data.len()
     }
 
     pub fn push(&mut self, t: T) -> Index<T> {