/*
|
* Copyright 2013 Google Inc.
|
*
|
* Use of this source code is governed by a BSD-style license that can be
|
* found in the LICENSE file.
|
*/
|
|
#ifndef SkResourceCache_DEFINED
|
#define SkResourceCache_DEFINED
|
|
#include "SkBitmap.h"
|
#include "SkMessageBus.h"
|
#include "SkTDArray.h"
|
|
class SkCachedData;
|
class SkDiscardableMemory;
|
class SkTraceMemoryDump;
|
|
/**
|
* Cache object for bitmaps (with possible scale in X Y as part of the key).
|
*
|
* Multiple caches can be instantiated, but each instance is not implicitly
|
* thread-safe, so if a given instance is to be shared across threads, the
|
* caller must manage the access itself (e.g. via a mutex).
|
*
|
* As a convenience, a global instance is also defined, which can be safely
|
* access across threads via the static methods (e.g. FindAndLock, etc.).
|
*/
|
class SkResourceCache {
|
public:
|
struct Key {
|
/** Key subclasses must call this after their own fields and data are initialized.
|
* All fields and data must be tightly packed.
|
* @param nameSpace must be unique per Key subclass.
|
* @param sharedID == 0 means ignore this field, does not support group purging.
|
* @param dataSize is size of fields and data of the subclass, must be a multiple of 4.
|
*/
|
void init(void* nameSpace, uint64_t sharedID, size_t dataSize);
|
|
/** Returns the size of this key. */
|
size_t size() const {
|
return fCount32 << 2;
|
}
|
|
void* getNamespace() const { return fNamespace; }
|
uint64_t getSharedID() const { return ((uint64_t)fSharedID_hi << 32) | fSharedID_lo; }
|
|
// This is only valid after having called init().
|
uint32_t hash() const { return fHash; }
|
|
bool operator==(const Key& other) const {
|
const uint32_t* a = this->as32();
|
const uint32_t* b = other.as32();
|
for (int i = 0; i < fCount32; ++i) { // (This checks fCount == other.fCount first.)
|
if (a[i] != b[i]) {
|
return false;
|
}
|
}
|
return true;
|
}
|
|
private:
|
int32_t fCount32; // local + user contents count32
|
uint32_t fHash;
|
// split uint64_t into hi and lo so we don't force ourselves to pad on 32bit machines.
|
uint32_t fSharedID_lo;
|
uint32_t fSharedID_hi;
|
void* fNamespace; // A unique namespace tag. This is hashed.
|
/* uint32_t fContents32[] */
|
|
const uint32_t* as32() const { return (const uint32_t*)this; }
|
};
|
|
struct Rec {
|
typedef SkResourceCache::Key Key;
|
|
Rec() {}
|
virtual ~Rec() {}
|
|
uint32_t getHash() const { return this->getKey().hash(); }
|
|
virtual const Key& getKey() const = 0;
|
virtual size_t bytesUsed() const = 0;
|
|
// Called if the cache needs to purge/remove/delete the Rec. Default returns true.
|
// Subclass may return false if there are outstanding references to it (e.g. bitmaps).
|
// Will only be deleted/removed-from-the-cache when this returns true.
|
virtual bool canBePurged() { return true; }
|
|
// A rec is first created/initialized, and then added to the cache. As part of the add(),
|
// the cache will callback into the rec with postAddInstall, passing in whatever payload
|
// was passed to add/Add.
|
//
|
// This late-install callback exists because the process of add-ing might end up deleting
|
// the new rec (if an existing rec in the cache has the same key and cannot be purged).
|
// If the new rec will be deleted during add, the pre-existing one (with the same key)
|
// will have postAddInstall() called on it instead, so that either way an "install" will
|
// happen during the add.
|
virtual void postAddInstall(void*) {}
|
|
// for memory usage diagnostics
|
virtual const char* getCategory() const = 0;
|
virtual SkDiscardableMemory* diagnostic_only_getDiscardable() const { return nullptr; }
|
|
private:
|
Rec* fNext;
|
Rec* fPrev;
|
|
friend class SkResourceCache;
|
};
|
|
// Used with SkMessageBus
|
struct PurgeSharedIDMessage {
|
PurgeSharedIDMessage(uint64_t sharedID) : fSharedID(sharedID) {}
|
uint64_t fSharedID;
|
};
|
|
typedef const Rec* ID;
|
|
/**
|
* Callback function for find(). If called, the cache will have found a match for the
|
* specified Key, and will pass in the corresponding Rec, along with a caller-specified
|
* context. The function can read the data in Rec, and copy whatever it likes into context
|
* (casting context to whatever it really is).
|
*
|
* The return value determines what the cache will do with the Rec. If the function returns
|
* true, then the Rec is considered "valid". If false is returned, the Rec will be considered
|
* "stale" and will be purged from the cache.
|
*/
|
typedef bool (*FindVisitor)(const Rec&, void* context);
|
|
/**
|
* Returns a locked/pinned SkDiscardableMemory instance for the specified
|
* number of bytes, or nullptr on failure.
|
*/
|
typedef SkDiscardableMemory* (*DiscardableFactory)(size_t bytes);
|
|
/*
|
* The following static methods are thread-safe wrappers around a global
|
* instance of this cache.
|
*/
|
|
/**
|
* Returns true if the visitor was called on a matching Key, and the visitor returned true.
|
*
|
* Find() will search the cache for the specified Key. If no match is found, return false and
|
* do not call the FindVisitor. If a match is found, return whatever the visitor returns.
|
* Its return value is interpreted to mean:
|
* true : Rec is valid
|
* false : Rec is "stale" -- the cache will purge it.
|
*/
|
static bool Find(const Key& key, FindVisitor, void* context);
|
static void Add(Rec*, void* payload = nullptr);
|
|
typedef void (*Visitor)(const Rec&, void* context);
|
// Call the visitor for every Rec in the cache.
|
static void VisitAll(Visitor, void* context);
|
|
static size_t GetTotalBytesUsed();
|
static size_t GetTotalByteLimit();
|
static size_t SetTotalByteLimit(size_t newLimit);
|
|
static size_t SetSingleAllocationByteLimit(size_t);
|
static size_t GetSingleAllocationByteLimit();
|
static size_t GetEffectiveSingleAllocationByteLimit();
|
|
static void PurgeAll();
|
|
static void TestDumpMemoryStatistics();
|
|
/** Dump memory usage statistics of every Rec in the cache using the
|
SkTraceMemoryDump interface.
|
*/
|
static void DumpMemoryStatistics(SkTraceMemoryDump* dump);
|
|
/**
|
* Returns the DiscardableFactory used by the global cache, or nullptr.
|
*/
|
static DiscardableFactory GetDiscardableFactory();
|
|
static SkCachedData* NewCachedData(size_t bytes);
|
|
static void PostPurgeSharedID(uint64_t sharedID);
|
|
/**
|
* Call SkDebugf() with diagnostic information about the state of the cache
|
*/
|
static void Dump();
|
|
///////////////////////////////////////////////////////////////////////////
|
|
/**
|
* Construct the cache to call DiscardableFactory when it
|
* allocates memory for the pixels. In this mode, the cache has
|
* not explicit budget, and so methods like getTotalBytesUsed()
|
* and getTotalByteLimit() will return 0, and setTotalByteLimit
|
* will ignore its argument and return 0.
|
*/
|
SkResourceCache(DiscardableFactory);
|
|
/**
|
* Construct the cache, allocating memory with malloc, and respect the
|
* byteLimit, purging automatically when a new image is added to the cache
|
* that pushes the total bytesUsed over the limit. Note: The limit can be
|
* changed at runtime with setTotalByteLimit.
|
*/
|
explicit SkResourceCache(size_t byteLimit);
|
~SkResourceCache();
|
|
/**
|
* Returns true if the visitor was called on a matching Key, and the visitor returned true.
|
*
|
* find() will search the cache for the specified Key. If no match is found, return false and
|
* do not call the FindVisitor. If a match is found, return whatever the visitor returns.
|
* Its return value is interpreted to mean:
|
* true : Rec is valid
|
* false : Rec is "stale" -- the cache will purge it.
|
*/
|
bool find(const Key&, FindVisitor, void* context);
|
void add(Rec*, void* payload = nullptr);
|
void visitAll(Visitor, void* context);
|
|
size_t getTotalBytesUsed() const { return fTotalBytesUsed; }
|
size_t getTotalByteLimit() const { return fTotalByteLimit; }
|
|
/**
|
* This is respected by SkBitmapProcState::possiblyScaleImage.
|
* 0 is no maximum at all; this is the default.
|
* setSingleAllocationByteLimit() returns the previous value.
|
*/
|
size_t setSingleAllocationByteLimit(size_t maximumAllocationSize);
|
size_t getSingleAllocationByteLimit() const;
|
// returns the logical single allocation size (pinning against the budget when the cache
|
// is not backed by discardable memory.
|
size_t getEffectiveSingleAllocationByteLimit() const;
|
|
/**
|
* Set the maximum number of bytes available to this cache. If the current
|
* cache exceeds this new value, it will be purged to try to fit within
|
* this new limit.
|
*/
|
size_t setTotalByteLimit(size_t newLimit);
|
|
void purgeSharedID(uint64_t sharedID);
|
|
void purgeAll() {
|
this->purgeAsNeeded(true);
|
}
|
|
DiscardableFactory discardableFactory() const { return fDiscardableFactory; }
|
|
SkCachedData* newCachedData(size_t bytes);
|
|
/**
|
* Call SkDebugf() with diagnostic information about the state of the cache
|
*/
|
void dump() const;
|
|
private:
|
Rec* fHead;
|
Rec* fTail;
|
|
class Hash;
|
Hash* fHash;
|
|
DiscardableFactory fDiscardableFactory;
|
|
size_t fTotalBytesUsed;
|
size_t fTotalByteLimit;
|
size_t fSingleAllocationByteLimit;
|
int fCount;
|
|
SkMessageBus<PurgeSharedIDMessage>::Inbox fPurgeSharedIDInbox;
|
|
void checkMessages();
|
void purgeAsNeeded(bool forcePurge = false);
|
|
// linklist management
|
void moveToHead(Rec*);
|
void addToHead(Rec*);
|
void release(Rec*);
|
void remove(Rec*);
|
|
void init(); // called by constructors
|
|
#ifdef SK_DEBUG
|
void validate() const;
|
#else
|
void validate() const {}
|
#endif
|
};
|
#endif
|
