From 23df2d693304824a2ce7ac3d988b0e48fec1c49d Mon Sep 17 00:00:00 2001 From: fmalita Date: Wed, 22 Oct 2014 07:39:08 -0700 Subject: [PATCH] Picture shader resource caching. Replace the current/naive shader caching mechanism with a more general implementation based on SkResourceCache. Caching the bitmap shader itself (as opposed to just the tile bitmap) makes for a chunkier key, but OTOH avoids allocating new shaders on cache hit. R=reed@google.com,mtklein@google.com Review URL: https://codereview.chromium.org/671683004 --- src/core/SkPictureShader.cpp | 141 ++++++++++++++++++++++++++++++++--- src/core/SkPictureShader.h | 10 +-- 2 files changed, 133 insertions(+), 18 deletions(-) diff --git a/src/core/SkPictureShader.cpp b/src/core/SkPictureShader.cpp index 8a16ea3b00..a4928d4fa9 100644 --- a/src/core/SkPictureShader.cpp +++ b/src/core/SkPictureShader.cpp @@ -10,14 +10,130 @@ #include "SkBitmap.h" #include "SkBitmapProcShader.h" #include "SkCanvas.h" +#include "SkDiscardableMemory.h" #include "SkMatrixUtils.h" #include "SkPicture.h" #include "SkReadBuffer.h" +#include "SkResourceCache.h" +#include "SkThread.h" #if SK_SUPPORT_GPU #include "GrContext.h" #endif +struct BitmapShaderKey : public SkResourceCache::Key { +public: + BitmapShaderKey(uint32_t pictureID, + const SkRect& tile, + SkShader::TileMode tmx, + SkShader::TileMode tmy, + const SkSize& scale, + const SkMatrix& localMatrix) + : fPictureID(pictureID) + , fTile(tile) + , fTmx(tmx) + , fTmy(tmy) + , fScale(scale) + , fLocalMatrix(localMatrix) { + + static const size_t keySize = sizeof(fPictureID) + + sizeof(fTile) + + sizeof(fTmx) + sizeof(fTmy) + + sizeof(fScale) + + sizeof(fLocalMatrix); + // This better be packed. + SkASSERT(sizeof(uint32_t) * (&fEndOfStruct - &fPictureID) == keySize); + this->init(keySize); + } + +private: + uint32_t fPictureID; + SkRect fTile; + SkShader::TileMode fTmx, fTmy; + SkSize fScale; + SkMatrix fLocalMatrix; + + SkDEBUGCODE(uint32_t fEndOfStruct;) +}; + +struct BitmapShaderRec : public SkResourceCache::Rec { + BitmapShaderRec(const BitmapShaderKey& key, SkShader* tileShader, size_t bitmapBytes) + : fKey(key) + , fShader(SkRef(tileShader)) + , fBitmapBytes(bitmapBytes) {} + + BitmapShaderKey fKey; + SkAutoTUnref fShader; + size_t fBitmapBytes; + + virtual const Key& getKey() const SK_OVERRIDE { return fKey; } + virtual size_t bytesUsed() const SK_OVERRIDE { + return sizeof(fKey) + sizeof(SkShader) + fBitmapBytes; + } + + static bool Visitor(const SkResourceCache::Rec& baseRec, void* contextShader) { + const BitmapShaderRec& rec = static_cast(baseRec); + SkAutoTUnref* result = reinterpret_cast*>(contextShader); + + result->reset(SkRef(rec.fShader.get())); + return true; + } +}; + +// FIXME: there's considerable boilerplate/duplication here vs. the global resource cache. +SK_DECLARE_STATIC_MUTEX(gBitmapShaderCacheMutex); +static SkResourceCache* gBitmapShaderCache = NULL; + +#ifndef SK_DEFAULT_TILE_CACHE_LIMIT + #define SK_DEFAULT_TILE_CACHE_LIMIT (2 * 1024 * 1024) +#endif + +static void cleanup_cache() { + // We'll clean this up in our own tests, but disable for clients. + // Chrome seems to have funky multi-process things going on in unit tests that + // makes this unsafe to delete when the main process atexit()s. + // SkLazyPtr does the same sort of thing. +#if SK_DEVELOPER + SkDELETE(gBitmapShaderCache); +#endif +} + +/** Must hold gBitmapShaderCacheMutex when calling. */ +static SkResourceCache* cache() { + // gTileCacheMutex is always held when this is called, so we don't need to be fancy in here. + gBitmapShaderCacheMutex.assertHeld(); + if (NULL == gBitmapShaderCache) { +#ifdef SK_USE_DISCARDABLE_SCALEDIMAGECACHE + gBitmapShaderCache = SkNEW_ARGS(SkResourceCache, (SkDiscardableMemory::Create)); +#else + gBitmapShaderCache = SkNEW_ARGS(SkResourceCache, (SK_DEFAULT_TILE_CACHE_LIMIT)); +#endif + atexit(cleanup_cache); + } + return gBitmapShaderCache; +} + +static bool cache_find(const BitmapShaderKey& key, SkAutoTUnref* result) { + SkAutoMutexAcquire am(gBitmapShaderCacheMutex); + return cache()->find(key, BitmapShaderRec::Visitor, result); +} + +static void cache_add(BitmapShaderRec* rec) { + SkAutoMutexAcquire am(gBitmapShaderCacheMutex); + cache()->add(rec); +} + +static bool cache_try_alloc_pixels(SkBitmap* bitmap) { + SkAutoMutexAcquire am(gBitmapShaderCacheMutex); + SkBitmap::Allocator* allocator = cache()->allocator(); + + if (NULL != allocator) { + return allocator->allocPixelRef(bitmap, NULL); + } else { + return bitmap->tryAllocPixels(); + } +} + SkPictureShader::SkPictureShader(const SkPicture* picture, TileMode tmx, TileMode tmy, const SkMatrix* localMatrix, const SkRect* tile) : INHERITED(localMatrix) @@ -103,11 +219,18 @@ SkShader* SkPictureShader::refBitmapShader(const SkMatrix& matrix, const SkMatri SkSize tileScale = SkSize::Make(SkIntToScalar(tileSize.width()) / fTile.width(), SkIntToScalar(tileSize.height()) / fTile.height()); - SkAutoMutexAcquire ama(fCachedBitmapShaderMutex); + SkAutoTUnref tileShader; + BitmapShaderKey key(fPicture->uniqueID(), + fTile, + fTmx, + fTmy, + tileScale, + this->getLocalMatrix()); - if (!fCachedBitmapShader || tileScale != fCachedTileScale) { + if (!cache_find(key, &tileShader)) { SkBitmap bm; - if (!bm.tryAllocN32Pixels(tileSize.width(), tileSize.height())) { + bm.setInfo(SkImageInfo::MakeN32Premul(tileSize)); + if (!cache_try_alloc_pixels(&bm)) { return NULL; } bm.eraseColor(SK_ColorTRANSPARENT); @@ -117,18 +240,14 @@ SkShader* SkPictureShader::refBitmapShader(const SkMatrix& matrix, const SkMatri canvas.translate(fTile.x(), fTile.y()); canvas.drawPicture(fPicture); - fCachedTileScale = tileScale; - SkMatrix shaderMatrix = this->getLocalMatrix(); shaderMatrix.preScale(1 / tileScale.width(), 1 / tileScale.height()); - fCachedBitmapShader.reset(CreateBitmapShader(bm, fTmx, fTmy, &shaderMatrix)); + tileShader.reset(CreateBitmapShader(bm, fTmx, fTmy, &shaderMatrix)); + + cache_add(SkNEW_ARGS(BitmapShaderRec, (key, tileShader.get(), bm.getSize()))); } - // Increment the ref counter inside the mutex to ensure the returned pointer is still valid. - // Otherwise, the pointer may have been overwritten on a different thread before the object's - // ref count was incremented. - fCachedBitmapShader.get()->ref(); - return fCachedBitmapShader; + return tileShader.detach(); } size_t SkPictureShader::contextSize() const { diff --git a/src/core/SkPictureShader.h b/src/core/SkPictureShader.h index 24aa7803c9..a73337722e 100644 --- a/src/core/SkPictureShader.h +++ b/src/core/SkPictureShader.h @@ -43,13 +43,9 @@ private: SkShader* refBitmapShader(const SkMatrix&, const SkMatrix* localMatrix) const; - const SkPicture* fPicture; - SkRect fTile; - TileMode fTmx, fTmy; - - mutable SkMutex fCachedBitmapShaderMutex; - mutable SkAutoTUnref fCachedBitmapShader; - mutable SkSize fCachedTileScale; + const SkPicture* fPicture; + SkRect fTile; + TileMode fTmx, fTmy; class PictureShaderContext : public SkShader::Context { public: