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 SkRect &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 ()
void	SetCheckboardCacheImages (bool checkerboard)
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 116 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 71 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 216 of file raster_cache.h.

{ return access_threshold_; }

BeginFrame()

void flutter::RasterCache::BeginFrame

(

)

Definition at line 193 of file raster_cache.cc.

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

Clear()

void flutter::RasterCache::Clear

(

)

Definition at line 237 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 174 of file raster_cache.cc.

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

EndFrame()

void flutter::RasterCache::EndFrame

(

)

Definition at line 232 of file raster_cache.cc.

                           {
  UpdateMetrics();
  TraceStatsToTimeline();
}

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 292 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;
}

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 303 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;
}

EvictUnusedCacheEntries()

void flutter::RasterCache::EvictUnusedCacheEntries

(

)

Definition at line 212 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);
  }
}

GenerateNewCacheInThisFrame()

bool flutter::RasterCache::GenerateNewCacheInThisFrame ( ) const

inline

Definition at line 218 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 155 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;
}

GetCachedEntriesCount()

size_t flutter::RasterCache::GetCachedEntriesCount

(

)

const

Definition at line 243 of file raster_cache.cc.

                                                {
  return cache_.size();
}

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 247 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;
}

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 257 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;
}

HasEntry()

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

Definition at line 165 of file raster_cache.cc.

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

layer_metrics()

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

inline

Definition at line 172 of file raster_cache.h.

{ return layer_metrics_; }

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 142 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};
}

picture_metrics()

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

inline

Definition at line 171 of file raster_cache.h.

{ return picture_metrics_; }

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 SkRect &rect)> &	draw_checkerboard
	)		const

Note

Procedure doesn't copy all closures.

Definition at line 77 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(matrix);
  draw_function(&canvas);
 
  if (checkerboard_images_) {
    draw_checkerboard(&canvas, context.logical_rect);
  }
 
  auto image = DlImage::Make(surface->makeImageSnapshot());
  return std::make_unique<RasterCacheResult>(
      image, context.logical_rect, context.flow_type, std::move(rtree));
}

SetCheckboardCacheImages()

void flutter::RasterCache::SetCheckboardCacheImages

(

bool

checkerboard

)

Definition at line 267 of file raster_cache.cc.

                                                            {
  if (checkerboard_images_ == checkerboard) {
    return;
  }
 
  checkerboard_images_ = checkerboard;
 
  // Clear all existing entries so previously rasterized items (with or without
  // a checkerboard) will be refreshed in subsequent passes.
  Clear();
}

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 116 of file raster_cache.cc.

                                      {
  RasterCacheKey key = RasterCacheKey(id, raster_cache_context.matrix);
  Entry& entry = cache_[key];
  if (!entry.image) {
    void (*func)(DlCanvas*, const SkRect& 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;
}

Friends And Related Symbol Documentation

LayerRasterCacheItem

friend class LayerRasterCacheItem

friend

Definition at line 272 of file raster_cache.h.

RasterCacheItem

friend class RasterCacheItem

friend

Definition at line 271 of file raster_cache.h.

---

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

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