flutter::RasterCache Class Reference

#include <raster_cache.h>

Inheritance diagram for flutter::RasterCache:

Classes
struct	CacheInfo
struct	Context

Public Member Functions
std::unique_ptr< RasterCacheResult >	Rasterize (const RasterCache::Context &context, sk_sp< const DlRTree > rtree, const std::function< void(DlCanvas *)> &draw_function, const std::function< void(DlCanvas *, const DlRect &rect)> &draw_checkerboard) const
	RasterCache (size_t access_threshold=3, size_t picture_and_display_list_cache_limit_per_frame=RasterCacheUtil::kDefaultPictureAndDisplayListCacheLimitPerFrame)
virtual	~RasterCache ()=default
bool	Draw (const RasterCacheKeyID &id, DlCanvas &canvas, const DlPaint *paint, bool preserve_rtree=false) const
bool	HasEntry (const RasterCacheKeyID &id, const SkMatrix &) const
void	BeginFrame ()
void	EvictUnusedCacheEntries ()
void	EndFrame ()
void	Clear ()
const RasterCacheMetrics &	picture_metrics () const
const RasterCacheMetrics &	layer_metrics () const
size_t	GetCachedEntriesCount () const
size_t	GetLayerCachedEntriesCount () const
size_t	GetPictureCachedEntriesCount () const
size_t	EstimatePictureCacheByteSize () const
	Estimate how much memory is used by picture raster cache entries in bytes.
size_t	EstimateLayerCacheByteSize () const
	Estimate how much memory is used by layer raster cache entries in bytes.
size_t	access_threshold () const
	Return the number of frames that a picture must be prepared before it will be cached. If the number is 0, then no picture will ever be cached.
bool	GenerateNewCacheInThisFrame () const
CacheInfo	MarkSeen (const RasterCacheKeyID &id, const SkMatrix &matrix, bool visible) const
	The entry whose RasterCacheKey is generated by RasterCacheKeyID and matrix is marked as encountered by the current frame. The entry will be created if it does not exist. Optionally the entry will be marked as visible in the current frame if the caller determines that it intersects the cull rect. The access_count of the entry will be increased if it is visible, or if it was ever visible.
int	GetAccessCount (const RasterCacheKeyID &id, const SkMatrix &matrix) const
bool	UpdateCacheEntry (const RasterCacheKeyID &id, const Context &raster_cache_context, const std::function< void(DlCanvas *)> &render_function, sk_sp< const DlRTree > rtree=nullptr) const

Friends
class	RasterCacheItem
class	LayerRasterCacheItem

Detailed Description

RasterCache is used to cache rasterized layers or display lists to improve performance.

Life cycle of RasterCache methods:

• Preroll stage
  • LayerTree::Preroll - for each Layer in the tree:
    • RasterCacheItem::PrerollSetup At the start of each layer's preroll, add cache items to PrerollContext::raster_cached_entries.
    • RasterCacheItem::PrerollFinalize At the end of each layer's preroll, may mark cache entries as encountered by the current frame.
• Paint stage
  • RasterCache::EvictUnusedCacheEntries Evict cached images that are no longer used.
  • LayerTree::TryToPrepareRasterCache Create cache image for each cache entry if it does not exist.
  • LayerTree::Paint - for each layer in the tree: If layers or display lists are cached as cached images, the method RasterCache::Draw will be used to draw those cache images.
  • RasterCache::EndFrame: Computes used counts and memory then reports cache metrics.

Definition at line 119 of file raster_cache.h.

Constructor & Destructor Documentation

RasterCache()

flutter::RasterCache::RasterCache ( size_t  access_threshold = 3, size_t  picture_and_display_list_cache_limit_per_frame = RasterCacheUtil::kDefaultPictureAndDisplayListCacheLimitPerFrame  )

explicit

Definition at line 74 of file raster_cache.cc.

    : access_threshold_(access_threshold),
      display_list_cache_limit_per_frame_(display_list_cache_limit_per_frame) {}

~RasterCache()

virtual flutter::RasterCache::~RasterCache ( )

virtualdefault

Member Function Documentation

access_threshold()

size_t flutter::RasterCache::access_threshold ( ) const

inline

Return the number of frames that a picture must be prepared before it will be cached. If the number is 0, then no picture will ever be cached.

If the number is one, then it must be prepared and drawn on 1 frame and it will then be cached on the next frame if it is prepared.

Definition at line 217 of file raster_cache.h.

{ return access_threshold_; }

Referenced by flutter::testing::MockRasterCache::AddMockPicture().

BeginFrame()

void flutter::RasterCache::BeginFrame

(

)

Definition at line 196 of file raster_cache.cc.

                             {
  display_list_cached_this_frame_ = 0;
  picture_metrics_ = {};
  layer_metrics_ = {};
}

Referenced by flutter::TEST(), flutter::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), and flutter::testing::TEST().

Clear()

void flutter::RasterCache::Clear

(

)

Definition at line 240 of file raster_cache.cc.

                        {
  cache_.clear();
  picture_metrics_ = {};
  layer_metrics_ = {};
}

Draw()

bool flutter::RasterCache::Draw	(	const RasterCacheKeyID &	id,
		DlCanvas &	canvas,
		const DlPaint *	paint,
		bool	preserve_rtree = false
	)		const

Definition at line 177 of file raster_cache.cc.

                                                  {
  auto it = cache_.find(RasterCacheKey(id, ToSkMatrix(canvas.GetMatrix())));
  if (it == cache_.end()) {
    return false;
  }
 
  Entry& entry = it->second;
 
  if (entry.image) {
    entry.image->draw(canvas, paint, preserve_rtree);
    return true;
  }
 
  return false;
}

References flutter::DlCanvas::GetMatrix(), and flutter::ToSkMatrix().

Referenced by flutter::testing::TEST(), and flutter::testing::TEST().

EndFrame()

void flutter::RasterCache::EndFrame

(

)

Definition at line 235 of file raster_cache.cc.

                           {
  UpdateMetrics();
  TraceStatsToTimeline();
}

Referenced by flutter::TEST(), flutter::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), flutter::testing::TEST(), and flutter::testing::TEST().

EstimateLayerCacheByteSize()

size_t flutter::RasterCache::EstimateLayerCacheByteSize

(

)

const

Estimate how much memory is used by layer raster cache entries in bytes.

Only SkImage's memory usage is counted as other objects are often much smaller compared to SkImage. SkImageInfo::computeMinByteSize is used to estimate the SkImage memory usage.

Definition at line 283 of file raster_cache.cc.

                                                     {
  size_t layer_cache_bytes = 0;
  for (const auto& item : cache_) {
    if (item.first.kind() == RasterCacheKeyKind::kLayerMetrics &&
        item.second.image) {
      layer_cache_bytes += item.second.image->image_bytes();
    }
  }
  return layer_cache_bytes;
}

References flutter::kLayerMetrics.

Referenced by flutter::TEST(), and flutter::TEST().

EstimatePictureCacheByteSize()

size_t flutter::RasterCache::EstimatePictureCacheByteSize

(

)

const

Estimate how much memory is used by picture raster cache entries in bytes.

Only SkImage's memory usage is counted as other objects are often much smaller compared to SkImage. SkImageInfo::computeMinByteSize is used to estimate the SkImage memory usage.

Definition at line 294 of file raster_cache.cc.

                                                       {
  size_t picture_cache_bytes = 0;
  for (const auto& item : cache_) {
    if (item.first.kind() == RasterCacheKeyKind::kDisplayListMetrics &&
        item.second.image) {
      picture_cache_bytes += item.second.image->image_bytes();
    }
  }
  return picture_cache_bytes;
}

References flutter::kDisplayListMetrics.

Referenced by flutter::TEST(), flutter::TEST(), and flutter::testing::TEST().

EvictUnusedCacheEntries()

void flutter::RasterCache::EvictUnusedCacheEntries

(

)

Definition at line 215 of file raster_cache.cc.

                                          {
  std::vector<RasterCacheKey::Map<Entry>::iterator> dead;
 
  for (auto it = cache_.begin(); it != cache_.end(); ++it) {
    Entry& entry = it->second;
    if (!entry.encountered_this_frame) {
      dead.push_back(it);
    }
  }
 
  for (auto it : dead) {
    if (it->second.image) {
      RasterCacheMetrics& metrics = GetMetricsForKind(it->first.kind());
      metrics.eviction_count++;
      metrics.eviction_bytes += it->second.image->image_bytes();
    }
    cache_.erase(it);
  }
}

References flutter::RasterCacheMetrics::eviction_bytes, and flutter::RasterCacheMetrics::eviction_count.

Referenced by flutter::LayerTree::Paint(), flutter::TEST(), flutter::TEST(), flutter::testing::TEST(), and flutter::testing::TEST().

GenerateNewCacheInThisFrame()

bool flutter::RasterCache::GenerateNewCacheInThisFrame ( ) const

inline

Definition at line 219 of file raster_cache.h.

                                           {
    // Disabling caching when access_threshold is zero is historic behavior.
    return access_threshold_ != 0 && display_list_cached_this_frame_ <
                                         display_list_cache_limit_per_frame_;
  }

GetAccessCount()

int flutter::RasterCache::GetAccessCount	(	const RasterCacheKeyID &	id,
		const SkMatrix &	matrix
	)		const

Returns the access count (i.e. accesses_since_visible) for the given entry in the cache, or -1 if no such entry exists.

Definition at line 158 of file raster_cache.cc.

                                                              {
  RasterCacheKey key = RasterCacheKey(id, matrix);
  auto entry = cache_.find(key);
  if (entry != cache_.cend()) {
    return entry->second.accesses_since_visible;
  }
  return -1;
}

References key.

GetCachedEntriesCount()

size_t flutter::RasterCache::GetCachedEntriesCount

(

)

const

Definition at line 246 of file raster_cache.cc.

                                                {
  return cache_.size();
}

Referenced by flutter::testing::TEST_F(), and flutter::testing::TEST_F().

GetLayerCachedEntriesCount()

size_t flutter::RasterCache::GetLayerCachedEntriesCount

(

)

const

Return the number of map entries in the layer cache regardless of whether the entries have been populated with an image.

Definition at line 250 of file raster_cache.cc.

                                                     {
  size_t layer_cached_entries_count = 0;
  for (const auto& item : cache_) {
    if (item.first.kind() == RasterCacheKeyKind::kLayerMetrics) {
      layer_cached_entries_count++;
    }
  }
  return layer_cached_entries_count;
}

References flutter::kLayerMetrics.

GetPictureCachedEntriesCount()

size_t flutter::RasterCache::GetPictureCachedEntriesCount

(

)

const

Return the number of map entries in the picture (DisplayList) cache regardless of whether the entries have been populated with an image.

Definition at line 260 of file raster_cache.cc.

                                                       {
  size_t display_list_cached_entries_count = 0;
  for (const auto& item : cache_) {
    if (item.first.kind() == RasterCacheKeyKind::kDisplayListMetrics) {
      display_list_cached_entries_count++;
    }
  }
  return display_list_cached_entries_count;
}

References flutter::kDisplayListMetrics.

HasEntry()

bool flutter::RasterCache::HasEntry	(	const RasterCacheKeyID &	id,
		const SkMatrix &	matrix
	)		const

Definition at line 168 of file raster_cache.cc.

                                                         {
  RasterCacheKey key = RasterCacheKey(id, matrix);
  if (cache_.find(key) != cache_.cend()) {
    return true;
  }
  return false;
}

References key.

layer_metrics()

const RasterCacheMetrics & flutter::RasterCache::layer_metrics ( ) const

inline

Definition at line 173 of file raster_cache.h.

{ return layer_metrics_; }

Referenced by flutter::FrameTimingsRecorder::RecordRasterEnd().

MarkSeen()

RasterCache::CacheInfo flutter::RasterCache::MarkSeen	(	const RasterCacheKeyID &	id,
		const SkMatrix &	matrix,
		bool	visible
	)		const

The entry whose RasterCacheKey is generated by RasterCacheKeyID and matrix is marked as encountered by the current frame. The entry will be created if it does not exist. Optionally the entry will be marked as visible in the current frame if the caller determines that it intersects the cull rect. The access_count of the entry will be increased if it is visible, or if it was ever visible.

Returns

the number of times the entry has been hit since it was created. For a new entry that will be 1 if it is visible, or zero if non-visible.

Definition at line 145 of file raster_cache.cc.

                                                                 {
  RasterCacheKey key = RasterCacheKey(id, matrix);
  Entry& entry = cache_[key];
  entry.encountered_this_frame = true;
  entry.visible_this_frame = visible;
  if (visible || entry.accesses_since_visible > 0) {
    entry.accesses_since_visible++;
  }
  return {entry.accesses_since_visible, entry.image != nullptr};
}

References key.

picture_metrics()

const RasterCacheMetrics & flutter::RasterCache::picture_metrics ( ) const

inline

Definition at line 172 of file raster_cache.h.

{ return picture_metrics_; }

Referenced by flutter::FrameTimingsRecorder::RecordRasterEnd(), flutter::testing::TEST(), and flutter::testing::TEST().

Rasterize()

std::unique_ptr< RasterCacheResult > flutter::RasterCache::Rasterize	(	const RasterCache::Context &	context,
		sk_sp< const DlRTree >	rtree,
		const std::function< void(DlCanvas *)> &	draw_function,
		const std::function< void(DlCanvas *, const DlRect &rect)> &	draw_checkerboard
	)		const

Note

Procedure doesn't copy all closures.

Definition at line 80 of file raster_cache.cc.

          {
  auto matrix = RasterCacheUtil::GetIntegralTransCTM(context.matrix);
  SkRect dest_rect =
      RasterCacheUtil::GetRoundedOutDeviceBounds(context.logical_rect, matrix);
 
  const SkImageInfo image_info = SkImageInfo::MakeN32Premul(
      dest_rect.width(), dest_rect.height(), context.dst_color_space);
 
  sk_sp<SkSurface> surface =
      context.gr_context
          ? SkSurfaces::RenderTarget(context.gr_context, skgpu::Budgeted::kYes,
                                     image_info)
          : SkSurfaces::Raster(image_info);
 
  if (!surface) {
    return nullptr;
  }
 
  DlSkCanvasAdapter canvas(surface->getCanvas());
  canvas.Clear(DlColor::kTransparent());
 
  canvas.Translate(-dest_rect.left(), -dest_rect.top());
  canvas.Transform(ToDlMatrix(matrix));
  draw_function(&canvas);
 
  if (checkerboard_images_) {
    draw_checkerboard(&canvas, ToDlRect(context.logical_rect));
  }
 
  auto image = DlImageSkia::Make(surface->makeImageSnapshot());
  return std::make_unique<RasterCacheResult>(
      image, context.logical_rect, context.flow_type, std::move(rtree));
}

References flutter::DlCanvas::Clear(), flutter::RasterCache::Context::dst_color_space, flutter::RasterCache::Context::flow_type, flutter::RasterCacheUtil::GetIntegralTransCTM(), flutter::RasterCacheUtil::GetRoundedOutDeviceBounds(), flutter::RasterCache::Context::gr_context, image, flutter::DlColor::kTransparent(), flutter::RasterCache::Context::logical_rect, flutter::DlImageSkia::Make(), flutter::RasterCache::Context::matrix, surface, flutter::ToDlMatrix(), flutter::ToDlRect(), flutter::DlSkCanvasAdapter::Transform(), and flutter::DlSkCanvasAdapter::Translate().

Referenced by UpdateCacheEntry().

UpdateCacheEntry()

bool flutter::RasterCache::UpdateCacheEntry	(	const RasterCacheKeyID &	id,
		const Context &	raster_cache_context,
		const std::function< void(DlCanvas *)> &	render_function,
		sk_sp< const DlRTree >	rtree = nullptr
	)		const

Definition at line 119 of file raster_cache.cc.

                                      {
  RasterCacheKey key = RasterCacheKey(id, raster_cache_context.matrix);
  Entry& entry = cache_[key];
  if (!entry.image) {
    void (*func)(DlCanvas*, const DlRect& rect) = DrawCheckerboard;
    entry.image = Rasterize(raster_cache_context, std::move(rtree),
                            render_function, func);
    if (entry.image != nullptr) {
      switch (id.type()) {
        case RasterCacheKeyType::kDisplayList: {
          display_list_cached_this_frame_++;
          break;
        }
        default:
          break;
      }
      return true;
    }
  }
  return entry.image != nullptr;
}

References flutter::DrawCheckerboard(), flutter::kDisplayList, key, flutter::RasterCache::Context::matrix, Rasterize(), and type.

Referenced by flutter::testing::MockRasterCache::AddMockLayer(), and flutter::testing::MockRasterCache::AddMockPicture().

Friends And Related Symbol Documentation

LayerRasterCacheItem

friend class LayerRasterCacheItem

friend

Definition at line 273 of file raster_cache.h.

RasterCacheItem

friend class RasterCacheItem

friend

Definition at line 272 of file raster_cache.h.

---

The documentation for this class was generated from the following files:

• flow/raster_cache.h
• flow/raster_cache.cc