Allow picture caching to work across scenes (display lists). #3359

gw3583 · 2018-11-27T07:32:06Z

This patch hooks up the primitive interning work with the tile
caching work.

Since we have a uid that guarantees uniqueness of the content of
primitives and clip nodes, we can use that to construct a
(reasonably) efficient hash key for the content of a tile.

Along with some additional information (such as the state of the
transforms used by the tile), we can construct a hash key for
the content of a tile that is stable across new display lists,
even if the shape of the clip-scroll tree changes in ways that
don't affect the tile.

This patch takes advantage of that to retain tiles when a new
scene is built, where the content of a tile would result in
the same output.

This change is

gw3583 · 2018-11-27T07:32:19Z

r? @kvark or @nical

This gives us the ability to cache picture tiles between both frames and scenes.

This is a somewhat more interesting patch than all the previous primitive interning changes :)

Note that it's still not actually hooked up to create pictures with tile caches enabled (in master), so this shouldn't have any effect on current gecko.

Nonetheless, pending try run to be safe:
https://treeherder.mozilla.org/#/jobs?repo=try&revision=0432779ca9a8f9ddd7fb6b5c932b7f72dba6a2b8

kvark

This is a somewhat more interesting patch than all the previous primitive interning changes :)

indeed! :)

a few concerns below

Reviewed 6 of 7 files at r1.
Reviewable status: 6 of 7 files reviewed, 10 unresolved discussions (waiting on @gw3583)

webrender/src/batch.rs, line 1004 at r1 (raw file):

                                        // Check if the tile is visible.
                                        if !tile.is_visible || !tile.in_use {

how is it possible for a tile to be visible but not used?

webrender/src/picture.rs, line 124 at r1 (raw file):

    /// if the content of the tile is the same, but the shape of the
    /// clip-scroll tree changes between scenes in other areas.
    tile_transform_map: FastHashMap<SpatialNodeIndex, TileTransformIndex>,

It's not clear to me why this is needed. My basic understanding was that when a tile is cached for a particular surface, it doesn't depend on the spatial node of this surface, but it depends on all the children spatial nodes that affect primitives intersecting with the tile. Is there ever a case where just checking for is_child() is insufficient or inefficient w.r.t. caching?

webrender/src/picture.rs, line 198 at r1 (raw file):

        resource_cache: &ResourceCache,
    ) -> Option<(TileDescriptor, TextureCacheHandle)> {
        if self.is_valid && resource_cache.texture_cache.is_allocated(&self.handle) {

is it possible for a tile to be valid but not allocated in the texture cache?

webrender/src/picture.rs, line 412 at r1 (raw file):

                None => true,
            };
            self.opacity_bindings.insert(*id, OpacityBindingInfo {

this hashmap is getting grown from zero every time, which is unfortunate. We might want to re-use the existing allocation somehow

webrender/src/picture.rs, line 441 at r1 (raw file):

                if let TransformKey::ScaleOffset(ref mut key) = key {
                    if raster_spatial_node.coordinate_system_id == surface_spatial_node.coordinate_system_id {

We shouldn't compare those and even access the raster_spatial_node and surface_spatial_node directly here. The returned ScaleOffset guarantees that the coordinate systems are matching

webrender/src/picture.rs, line 788 at r1 (raw file):

                    // exact content of this tile.
                    if let Some(handle) = retained_tiles.remove(&tile.descriptor) {
                        // Only use if not evicted from texture cache in the meantime.

if it was evicted, do we still want to request it? I thought we are going to re-render it instead

webrender/src/picture.rs, line 876 at r1 (raw file):

        //           some cases?
        for (_, handle) in retained_tiles.drain() {
            if resource_cache.texture_cache.is_allocated(&handle) {

sounds like mark_unused could be doing the is_allocated check internally

webrender/src/picture.rs, line 1395 at r1 (raw file):

            debug_assert!(tile_cache.old_tiles.is_empty());
            for tile in tile_cache.tiles {
                if let Some((descriptor, texture_handle)) = tile.destroy(resource_cache) {

nit: could be retained_tiles.extend(tile.destroy(resource_cache))

webrender/src/picture.rs, line 2153 at r1 (raw file):

                                        None,
                                        UvRectKind::Rect,
                                        Eviction::Auto,

is this changed because we are now manually tracking the tile cache lifetimes?

webrender/src/prim_store.rs, line 2618 at r1 (raw file):

    /// Destroy an existing primitive store. This is called just before
    /// a primitive store is replaced with a newly built scene.
    pub fn destroy(

for each object with a similar destroy we should consider having some sort of a safeguard check in drop() to ensure that it was destroyed properly


        Allow picture caching to work across scenes (display lists).

This patch hooks up the primitive interning work with the tile caching work. Since we have a uid that guarantees uniqueness of the content of primitives and clip nodes, we can use that to construct a (reasonably) efficient hash key for the content of a tile. Along with some additional information (such as the state of the transforms used by the tile), we can construct a hash key for the content of a tile that is stable across new display lists, even if the shape of the clip-scroll tree changes in ways that don't affect the tile. This patch takes advantage of that to retain tiles when a new scene is built, where the content of a tile would result in the same output.


        Address review comments

gw3583

Reviewable status: 6 of 7 files reviewed, 10 unresolved discussions (waiting on @kvark)

webrender/src/batch.rs, line 1004 at r1 (raw file):