#include "SkImageCache.h"
#include "SkImagePriv.h"
+#if LAZY_CACHE_STATS
+#include "SkThread.h"
+
+int32_t SkLazyPixelRef::gCacheHits;
+int32_t SkLazyPixelRef::gCacheMisses;
+#endif
+
SkLazyPixelRef::SkLazyPixelRef(SkData* data, SkBitmapFactory::DecodeProc proc, SkImageCache* cache)
// Pass NULL for the Mutex so that the default (ring buffer) will be used.
: INHERITED(NULL)
}
SkBitmapFactory::Target target;
// Check to see if the pixels still exist in the cache.
- target.fAddr = SkImageCache::UNINITIALIZED_ID == fCacheId ?
- NULL : fImageCache->pinCache(fCacheId);
- if (NULL == target.fAddr) {
- SkImage::Info info;
- SkASSERT(fData != NULL && fData->size() > 0);
- // FIXME: As an optimization, only do this part once.
- fErrorInDecoding = !fDecodeProc(fData->data(), fData->size(), &info, NULL);
- if (fErrorInDecoding) {
- fCacheId = SkImageCache::UNINITIALIZED_ID;
- return NULL;
+ if (SkImageCache::UNINITIALIZED_ID == fCacheId) {
+ target.fAddr = NULL;
+ } else {
+ target.fAddr = fImageCache->pinCache(fCacheId);
+ if (NULL != target.fAddr) {
+#if LAZY_CACHE_STATS
+ sk_atomic_inc(&gCacheHits);
+#endif
+ return target.fAddr;
}
- // Allocate the memory.
- size_t bytes = ComputeMinRowBytesAndSize(info, &target.fRowBytes);
+#if LAZY_CACHE_STATS
+ sk_atomic_inc(&gCacheMisses);
+#endif
+ }
+ SkASSERT(NULL == target.fAddr);
+ SkImage::Info info;
+ SkASSERT(fData != NULL && fData->size() > 0);
+ // FIXME: As an optimization, only do this part once.
+ fErrorInDecoding = !fDecodeProc(fData->data(), fData->size(), &info, NULL);
+ if (fErrorInDecoding) {
+ fCacheId = SkImageCache::UNINITIALIZED_ID;
+ return NULL;
+ }
+ // Allocate the memory.
+ size_t bytes = ComputeMinRowBytesAndSize(info, &target.fRowBytes);
- target.fAddr = fImageCache->allocAndPinCache(bytes, &fCacheId);
- if (NULL == target.fAddr) {
- // Space could not be allocated.
- fCacheId = SkImageCache::UNINITIALIZED_ID;
- return NULL;
- }
- SkASSERT(SkImageCache::UNINITIALIZED_ID != fCacheId);
- fErrorInDecoding = !fDecodeProc(fData->data(), fData->size(), &info, &target);
- if (fErrorInDecoding) {
- fImageCache->throwAwayCache(fCacheId);
- fCacheId = SkImageCache::UNINITIALIZED_ID;
- return NULL;
- }
+ target.fAddr = fImageCache->allocAndPinCache(bytes, &fCacheId);
+ if (NULL == target.fAddr) {
+ // Space could not be allocated.
+ fCacheId = SkImageCache::UNINITIALIZED_ID;
+ return NULL;
+ }
+ SkASSERT(SkImageCache::UNINITIALIZED_ID != fCacheId);
+ fErrorInDecoding = !fDecodeProc(fData->data(), fData->size(), &info, &target);
+ if (fErrorInDecoding) {
+ fImageCache->throwAwayCache(fCacheId);
+ fCacheId = SkImageCache::UNINITIALIZED_ID;
+ return NULL;
}
return target.fAddr;
}
class SkData;
class SkImageCache;
+#ifdef SK_DEBUG
+ #define LAZY_CACHE_STATS 1
+#elif !defined(LAZY_CACHE_STATS)
+ #define LAZY_CACHE_STATS 0
+#endif
+
/**
* PixelRef which defers decoding until SkBitmap::lockPixels() is called.
*/
intptr_t getCacheId() const { return fCacheId; }
#endif
+#if LAZY_CACHE_STATS
+ static int32_t GetCacheHits() { return gCacheHits; }
+ static int32_t GetCacheMisses() { return gCacheMisses; }
+ static void ResetCacheStats() { gCacheHits = gCacheMisses = 0; }
+#endif
+
// No need to flatten this object. When flattening an SkBitmap, SkOrderedWriteBuffer will check
// the encoded data and write that instead.
// Future implementations of SkFlattenableWriteBuffer will need to special case for
SkImageCache* fImageCache;
intptr_t fCacheId;
+#if LAZY_CACHE_STATS
+ static int32_t gCacheHits;
+ static int32_t gCacheMisses;
+#endif
+
typedef SkPixelRef INHERITED;
};
"times for drawing the whole page. Requires tiled rendering.");
DEFINE_string(timers, "", "[wcgWC]*: Display wall, cpu, gpu, truncated wall or truncated cpu time"
" for each picture.");
+DEFINE_bool(trackDeferredCaching, false, "Only meaningful with --deferImageDecoding and "
+ "LAZY_CACHE_STATS set to true. Report percentage of cache hits when using deferred "
+ "image decoding.");
static char const * const gFilterTypes[] = {
"paint",
#include "SkData.h"
#include "SkLruImageCache.h"
+#include "SkLazyPixelRef.h"
static SkLruImageCache gLruImageCache(1024*1024);
return factory.installPixelRef(data, bitmap);
}
+#if LAZY_CACHE_STATS
+static int32_t gTotalCacheHits;
+static int32_t gTotalCacheMisses;
+#endif
+
static bool run_single_benchmark(const SkString& inputPath,
sk_tools::PictureBenchmark& benchmark) {
SkFILEStream inputStream;
gLogger.logProgress(result);
benchmark.run(picture);
+
+#if LAZY_CACHE_STATS
+ if (FLAGS_trackDeferredCaching) {
+ int32_t cacheHits = SkLazyPixelRef::GetCacheHits();
+ int32_t cacheMisses = SkLazyPixelRef::GetCacheMisses();
+ SkLazyPixelRef::ResetCacheStats();
+ SkDebugf("Cache hit rate: %f\n", (double) cacheHits / (cacheHits + cacheMisses));
+ gTotalCacheHits += cacheHits;
+ gTotalCacheMisses += cacheMisses;
+ }
+#endif
+
return true;
}
const char* filters = FLAGS_filter[0];
const char* colon = strchr(filters, ':');
if (colon) {
- int type = -1;
+ int32_t type = -1;
size_t typeLen = colon - filters;
for (size_t tIndex = 0; tIndex < kFilterTypesCount; ++tIndex) {
if (typeLen == strlen(gFilterTypes[tIndex])
&& !strncmp(filters, gFilterTypes[tIndex], typeLen)) {
- type = tIndex;
+ type = SkToS32(tIndex);
break;
}
}
gLogger.logError(err);
return 1;
}
+#if LAZY_CACHE_STATS
+ if (FLAGS_trackDeferredCaching) {
+ SkDebugf("Total cache hit rate: %f\n",
+ (double) gTotalCacheHits / (gTotalCacheHits + gTotalCacheMisses));
+ }
+#endif
return 0;
}