raster cache process analysis

Author: JsouLiang

flow/layers/display_list_raster_cache_item.cc

@@ -14,6 +14,7 @@
 #include "flutter/flow/raster_cache_key.h"
 #include "flutter/flow/raster_cache_util.h"
 #include "flutter/flow/skia_gpu_object.h"
+#include "flutter/shell/common/pipeline.h"
 
 namespace flutter {
 
@@ -52,7 +53,7 @@ DisplayListRasterCacheItem::DisplayListRasterCacheItem(
     bool will_change)
     : RasterCacheItem(RasterCacheKeyID(display_list->unique_id(),
                                        RasterCacheKeyType::kDisplayList),
-                      CacheState::kCurrent),
+                      CacheState::kNone),
       display_list_(display_list),
       offset_(offset),
       is_complex_(is_complex),
@@ -81,25 +82,24 @@ void DisplayListRasterCacheItem::PrerollSetup(PrerollContext* context,
     return;
   }
 
+  matrix_ = matrix;
   transformation_matrix_ = matrix;
   transformation_matrix_.preTranslate(offset_.x(), offset_.y());
 
   if (!transformation_matrix_.invert(nullptr)) {
     // The matrix was singular. No point in going further.
     return;
   }
-
-  if (context->raster_cached_entries && context->raster_cache) {
-    context->raster_cached_entries->push_back(this);
-    cache_state_ = CacheState::kCurrent;
-  }
+  cache_state_ = CacheState::kCurrent;
   return;
 }
 
 void DisplayListRasterCacheItem::PrerollFinalize(PrerollContext* context,
                                                  const SkMatrix& matrix) {
   if (cache_state_ == CacheState::kNone || !context->raster_cache ||
-      !context->raster_cached_entries) {
+      !context->raster_cached_entries ||
+      !context->raster_cache->GenerateNewCacheInThisFrame()) {
+    cache_state_ = CacheState::kNone;
     return;
   }
   auto* raster_cache = context->raster_cache;
@@ -114,14 +114,26 @@ void DisplayListRasterCacheItem::PrerollFinalize(PrerollContext* context,
       cache_state_ = CacheState::kNone;
       return;
     }
+    // This display_list can be cached so we should increate the cache count.
+    context->raster_cache->IncreateDisplayListCacheCount();
     context->subtree_can_inherit_opacity = true;
     cache_state_ = CacheState::kCurrent;
   } else {
-    raster_cache->Touch(key_id_, matrix);
+    // if the bounds with the cull rect is not intersect, we only touch the
+    // cache entry. And should not cache the display list
+    cache_state_ = CacheState::kNone;
+    raster_cache->Touch(key_id_, transformation_matrix_);
+    return;
   }
+  // If the display_list can be cached we will add it to cache_entries.
+  context->raster_cached_entries->push_back(this);
   return;
 }
 
+bool DisplayListRasterCacheItem::Touch(const PaintContext* context) const {
+  return context->raster_cache->Touch(key_id_, transformation_matrix_);
+}
+
 bool DisplayListRasterCacheItem::Draw(const PaintContext& context,
                                       const SkPaint* paint) const {
   return Draw(context, context.leaf_nodes_canvas, paint);
@@ -133,31 +145,24 @@ bool DisplayListRasterCacheItem::Draw(const PaintContext& context,
   if (!context.raster_cache || !canvas) {
     return false;
   }
-  if (cache_state_ == CacheState::kCurrent) {
-    return context.raster_cache->Draw(key_id_, *canvas, paint);
-  }
-  // This display_list doesn't cache itself, this only increase the entry
-  // access_count;
-  context.raster_cache->Touch(key_id_, canvas->getTotalMatrix());
-  return false;
+  return context.raster_cache->Draw(key_id_, *canvas, paint);
 }
 
 static const auto* flow_type = "RasterCacheFlow::DisplayList";
 
 bool DisplayListRasterCacheItem::TryToPrepareRasterCache(
-    const PaintContext& context,
-    bool parent_cached) const {
+    const PaintContext& context) const {
   // If we don't have raster_cache we should not cache the current display_list.
   // If the current node's ancestor has been cached we also should not cache the
   // current node. In the current frame, the raster_cache will collect all
   // display_list or picture_list to calculate the memory they used, we
   // shouldn't cache the current node if the memory is more significant than the
   // limit.
-  if (cache_state_ == kNone || !context.raster_cache || parent_cached ||
-      !context.raster_cache->GenerateNewCacheInThisFrame()) {
+  if (cache_state_ == kNone || !context.raster_cache) {
     return false;
   }
-  SkRect bounds = display_list_->bounds().makeOffset(offset_.x(), offset_.y());
+
+  SkRect bounds = display_list_->bounds();
   RasterCache::Context r_context = {
       // clang-format off
       .gr_context         = context.gr_context,
@@ -168,10 +173,10 @@ bool DisplayListRasterCacheItem::TryToPrepareRasterCache(
       .checkerboard       = context.checkerboard_offscreen_layers,
       // clang-format on
   };
-  return context.raster_cache->UpdateCacheEntry(
-      GetId().value(), r_context,
-      [display_list = display_list_](SkCanvas* canvas) {
+  return context.raster_cache->UpdateDisplayListCacheEntry(
+      key_id_, r_context, [display_list = display_list_](SkCanvas* canvas) {
         display_list->RenderTo(canvas);
+        return true;
       });
 }
 }  // namespace flutter

flow/layers/display_list_raster_cache_item.h

@@ -38,14 +38,15 @@ class DisplayListRasterCacheItem : public RasterCacheItem {
   void PrerollFinalize(PrerollContext* context,
                        const SkMatrix& matrix) override;
 
+  bool Touch(const PaintContext* context) const override;
+
   bool Draw(const PaintContext& context, const SkPaint* paint) const override;
 
   bool Draw(const PaintContext& context,
             SkCanvas* canvas,
             const SkPaint* paint) const override;
 
-  bool TryToPrepareRasterCache(const PaintContext& context,
-                               bool parent_cached = false) const override;
+  bool TryToPrepareRasterCache(const PaintContext& context) const override;
 
   void ModifyMatrix(SkPoint offset) const {
     matrix_ = matrix_.preTranslate(offset.x(), offset.y());

flow/layers/layer_raster_cache_item.cc

@@ -3,6 +3,7 @@
 // found in the LICENSE file.
 
 #include "flutter/flow/layers/layer_raster_cache_item.h"
+#include <cstddef>
 #include "flutter/flow/layers/container_layer.h"
 #include "flutter/flow/raster_cache_item.h"
 
@@ -42,18 +43,11 @@ void LayerRasterCacheItem::PrerollFinalize(PrerollContext* context,
   if (!context->raster_cache || !context->raster_cached_entries) {
     return;
   }
-  // We've marked the cache entry that we would like to cache so it stays
-  // alive, but if the following conditions apply then we need to set our
-  // state back to kDoNotCache so that we don't populate the entry later.
-  if (context->has_platform_view || context->has_texture_layer ||
-      !SkRect::Intersects(context->cull_rect, layer_->paint_bounds())) {
-    return;
-  }
   child_items_ = context->raster_cached_entries->size() - child_items_;
+  // Determine cache current layer or cache children.
   if (num_cache_attempts_ >= layer_cached_threshold_) {
     // the layer can be cached
     cache_state_ = CacheState::kCurrent;
-    context->raster_cache->MarkSeen(key_id_, matrix_);
   } else {
     num_cache_attempts_++;
     // access current layer
@@ -67,9 +61,25 @@ void LayerRasterCacheItem::PrerollFinalize(PrerollContext* context,
                                    RasterCacheKeyType::kLayerChildren);
       }
       cache_state_ = CacheState::kChildren;
-      context->raster_cache->MarkSeen(layer_children_id_.value(), matrix_);
     }
   }
+  // We've marked the cache entry that we would like to cache so it stays
+  // alive, but if the following conditions apply then we need to set our
+  // state back to kDoNotCache so that we don't populate the entry later.
+  if (context->has_platform_view || context->has_texture_layer ||
+      !SkRect::Intersects(context->cull_rect, layer_->paint_bounds())) {
+    if (cache_state_ != CacheState::kNone) {
+      // Only touch the entry, do not to cache the layer or children.
+      context->raster_cache->Touch(GetId().value(), matrix_);
+      cache_state_ = CacheState::kNone;
+    }
+    return;
+  }
+  // The layer can be cache, so we should create a entry.
+  if (cache_state_ != CacheState::kNone) {
+    // Create Cache entry
+    context->raster_cache->MarkSeen(GetId().value(), matrix_);
+  }
 }
 
 std::optional<RasterCacheKeyID> LayerRasterCacheItem::GetId() const {
@@ -111,19 +121,20 @@ bool Rasterize(RasterCacheItem::CacheState cache_state,
           .leaf_nodes_canvas             = canvas,
           .gr_context                    = paint_context.gr_context,
           .dst_color_space               = paint_context.dst_color_space,
-          .view_embedder                 = paint_context.view_embedder,
+          .view_embedder                 = nullptr,
           .raster_time                   = paint_context.raster_time,
           .ui_time                       = paint_context.ui_time,
           .texture_registry              = paint_context.texture_registry,
-          .raster_cache                  = paint_context.raster_cache,
+          .raster_cache                  = layer->subtree_has_platform_view() ? nullptr: paint_context.raster_cache,
           .checkerboard_offscreen_layers = paint_context.checkerboard_offscreen_layers,
           .frame_device_pixel_ratio      = paint_context.frame_device_pixel_ratio,
       // clang-format on
   };
-
   switch (cache_state) {
     case RasterCacheItem::CacheState::kCurrent:
-      FML_DCHECK(layer->needs_painting(context));
+      if (!layer->needs_painting(context)) {
+        return false;
+      }
       layer->Paint(context);
       break;
     case RasterCacheItem::CacheState::kChildren:
@@ -138,9 +149,9 @@ bool Rasterize(RasterCacheItem::CacheState cache_state,
 
 static const auto* flow_type = "RasterCacheFlow::Layer";
 
-bool LayerRasterCacheItem::TryToPrepareRasterCache(const PaintContext& context,
-                                                   bool parent_cached) const {
-  if (!context.raster_cache || parent_cached) {
+bool LayerRasterCacheItem::TryToPrepareRasterCache(
+    const PaintContext& context) const {
+  if (!context.raster_cache) {
     return false;
   }
   if (cache_state_ != kNone) {
@@ -159,7 +170,7 @@ bool LayerRasterCacheItem::TryToPrepareRasterCache(const PaintContext& context,
           GetId().value(), r_context,
           [ctx = context, cache_state = cache_state_,
            layer = layer_](SkCanvas* canvas) {
-            Rasterize(cache_state, layer, ctx, canvas);
+            return Rasterize(cache_state, layer, ctx, canvas);
           });
     }
   }
@@ -171,23 +182,17 @@ bool LayerRasterCacheItem::Draw(const PaintContext& context,
   return Draw(context, context.leaf_nodes_canvas, paint);
 }
 
+bool LayerRasterCacheItem::Touch(const PaintContext* context) const {
+  return context->raster_cache->Touch(GetId().value(), matrix_);
+}
+
 bool LayerRasterCacheItem::Draw(const PaintContext& context,
                                 SkCanvas* canvas,
                                 const SkPaint* paint) const {
-  if (!context.raster_cache || !canvas) {
+  if (!context.raster_cache || !canvas || cache_state_ == CacheState::kNone) {
     return false;
   }
-  switch (cache_state_) {
-    case RasterCacheItem::kNone:
-      return false;
-    case RasterCacheItem::kCurrent: {
-      return context.raster_cache->Draw(key_id_, *canvas, paint);
-    }
-    case RasterCacheItem::kChildren: {
-      return context.raster_cache->Draw(layer_children_id_.value(), *canvas,
-                                        paint);
-    }
-  }
+  return context.raster_cache->Draw(GetId().value(), *canvas, paint);
 }
 
 }  // namespace flutter

flow/layers/layer_raster_cache_item.h

@@ -8,7 +8,9 @@
 #include <memory>
 #include <optional>
 
+#include "flutter/flow/raster_cache.h"
 #include "flutter/flow/raster_cache_item.h"
+#include "include/core/SkCanvas.h"
 
 namespace flutter {
 
@@ -38,12 +40,13 @@ class LayerRasterCacheItem : public RasterCacheItem {
 
   bool Draw(const PaintContext& context, const SkPaint* paint) const override;
 
+  bool Touch(const PaintContext* context) const override;
+
   bool Draw(const PaintContext& context,
             SkCanvas* canvas,
             const SkPaint* paint) const override;
 
-  bool TryToPrepareRasterCache(const PaintContext& context,
-                               bool parent_cached = false) const override;
+  bool TryToPrepareRasterCache(const PaintContext& context) const override;
 
   void MarkCacheChildren() { can_cache_children_ = true; }
 

flow/layers/layer_tree.cc

@@ -84,12 +84,13 @@ void LayerTree::TryToRasterCache(
       // try to cache current layer
       // If parent failed to cache, just proceed to the next entry
       // cache current entry, this entry's parent must not cache
-      if (item->TryToPrepareRasterCache(*paint_context, false)) {
+      if (item->TryToPrepareRasterCache(*paint_context)) {
         // if parent cached, then foreach child layer to touch them.
         for (unsigned j = 0; j < item->child_items(); j++) {
           auto* child_item = raster_cached_items[i + j + 1];
           if (child_item->need_caching()) {
-            child_item->TryToPrepareRasterCache(*paint_context, true);
+            // If parent has cached, we only touch this cache entry.
+            child_item->Touch(paint_context);
           }
         }
         i += item->child_items() + 1;

flow/raster_cache.cc

@@ -51,7 +51,7 @@ RasterCache::RasterCache(size_t access_threshold,
 /// @note Procedure doesn't copy all closures.
 std::unique_ptr<RasterCacheResult> RasterCache::Rasterize(
     const RasterCache::Context& context,
-    const std::function<void(SkCanvas*)>& draw_function) {
+    const std::function<bool(SkCanvas*)>& draw_function) {
   TRACE_EVENT0("flutter", "RasterCachePopulate");
 
   SkRect dest_rect =
@@ -76,7 +76,10 @@ std::unique_ptr<RasterCacheResult> RasterCache::Rasterize(
   canvas->clear(SK_ColorTRANSPARENT);
   canvas->translate(-dest_rect.left(), -dest_rect.top());
   canvas->concat(context.matrix);
-  draw_function(canvas);
+
+  if (!draw_function(canvas)) {
+    return nullptr;
+  }
 
   if (context.checkerboard) {
     DrawCheckerboard(canvas, context.logical_rect);
@@ -89,23 +92,26 @@ std::unique_ptr<RasterCacheResult> RasterCache::Rasterize(
 bool RasterCache::UpdateCacheEntry(
     const RasterCacheKeyID& id,
     const Context& raster_cache_context,
-    const std::function<void(SkCanvas*)>& render_function) const {
+    const std::function<bool(SkCanvas*)>& render_function) const {
   RasterCacheKey key = RasterCacheKey(id, raster_cache_context.matrix);
   Entry& entry = cache_[key];
   entry.used_this_frame = true;
   if (!entry.image) {
     entry.image = Rasterize(raster_cache_context, render_function);
-    if (entry.image != nullptr) {
-      switch (id.type()) {
-        case RasterCacheKeyType::kDisplayList: {
-          display_list_cached_this_frame_++;
-          break;
-        }
-        default:
-          break;
-      }
-      return true;
-    }
+  }
+  return entry.image != nullptr;
+}
+
+bool RasterCache::UpdateDisplayListCacheEntry(
+    const RasterCacheKeyID& id,
+    const Context& raster_cache_context,
+    const std::function<bool(SkCanvas*)>& render_function) const {
+  RasterCacheKey key = RasterCacheKey(id, raster_cache_context.matrix);
+  Entry& entry = cache_[key];
+  entry.used_this_frame = true;
+  if (!entry.image) {
+    entry.image = Rasterize(raster_cache_context, render_function);
+    return true;
   }
   return entry.image != nullptr;
 }
@@ -130,6 +136,15 @@ int RasterCache::MarkSeen(const RasterCacheKeyID& id,
   return entry.access_count;
 }
 
+void RasterCache::Erasure(const RasterCacheKeyID& id,
+                          const SkMatrix& matrix) const {
+  RasterCacheKey cache_key = RasterCacheKey(id, matrix);
+  auto it = cache_.find(cache_key);
+  if (it != cache_.end()) {
+    cache_.erase(it);
+  }
+}
+
 bool RasterCache::HasEntry(const RasterCacheKeyID& id,
                            const SkMatrix& matrix) const {
   RasterCacheKey key = RasterCacheKey(id, matrix);