SkResourceCache Class Reference

#include <SkResourceCache.h>

Classes
class	Hash
struct	Key
struct	PurgeSharedIDMessage
struct	Rec

Public Types
typedef const Rec *	ID
typedef bool(*	FindVisitor) (const Rec &, void *context)
typedef SkDiscardableMemory *(*	DiscardableFactory) (size_t bytes)
typedef void(*	Visitor) (const Rec &, void *context)

Public Member Functions
	SkResourceCache (DiscardableFactory)
	SkResourceCache (size_t byteLimit)
	~SkResourceCache ()
bool	find (const Key &, FindVisitor, void *context)
void	add (Rec *, void *payload=nullptr)
void	visitAll (Visitor, void *context)
size_t	getTotalBytesUsed () const
size_t	getTotalByteLimit () const
size_t	setSingleAllocationByteLimit (size_t maximumAllocationSize)
size_t	getSingleAllocationByteLimit () const
size_t	getEffectiveSingleAllocationByteLimit () const
size_t	setTotalByteLimit (size_t newLimit)
void	purgeSharedID (uint64_t sharedID)
void	purgeAll ()
DiscardableFactory	discardableFactory () const
SkCachedData *	newCachedData (size_t bytes)
void	dump () const

Static Public Member Functions
static bool	Find (const Key &key, FindVisitor, void *context)
static void	Add (Rec *, void *payload=nullptr)
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	CheckMessages ()
static void	TestDumpMemoryStatistics ()
static void	DumpMemoryStatistics (SkTraceMemoryDump *dump)
static DiscardableFactory	GetDiscardableFactory ()
static SkCachedData *	NewCachedData (size_t bytes)
static void	PostPurgeSharedID (uint64_t sharedID)
static void	Dump ()

Detailed Description

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.).

Definition at line 31 of file SkResourceCache.h.

Member Typedef Documentation

DiscardableFactory

typedef SkDiscardableMemory *(* SkResourceCache::DiscardableFactory) (size_t bytes)

Returns a locked/pinned SkDiscardableMemory instance for the specified number of bytes, or nullptr on failure.

Definition at line 138 of file SkResourceCache.h.

FindVisitor

typedef bool(* SkResourceCache::FindVisitor) (const Rec &, void *context)

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.

Definition at line 132 of file SkResourceCache.h.

ID

typedef const Rec* SkResourceCache::ID

Definition at line 120 of file SkResourceCache.h.

Visitor

typedef void(* SkResourceCache::Visitor) (const Rec &, void *context)

Definition at line 157 of file SkResourceCache.h.

Constructor & Destructor Documentation

SkResourceCache() [1/2]

SkResourceCache::SkResourceCache

(

DiscardableFactory

factory

)

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.

Definition at line 105 of file SkResourceCache.cpp.

        : fPurgeSharedIDInbox(SK_InvalidUniqueID) {
    this->init();
    fDiscardableFactory = factory;
}

SkResourceCache() [2/2]

SkResourceCache::SkResourceCache ( size_t  byteLimit )

explicit

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.

Definition at line 111 of file SkResourceCache.cpp.

        : fPurgeSharedIDInbox(SK_InvalidUniqueID) {
    this->init();
    fTotalByteLimit = byteLimit;
}

~SkResourceCache()

SkResourceCache::~SkResourceCache

(

)

Definition at line 117 of file SkResourceCache.cpp.

                                  {
    Rec* rec = fHead;
    while (rec) {
        Rec* next = rec->fNext;
        delete rec;
        rec = next;
    }
    delete fHash;
}

Member Function Documentation

Add()

void SkResourceCache::Add ( Rec *  rec, void *  payload = nullptr  )

static

Definition at line 546 of file SkResourceCache.cpp.

                                                 {
    SkAutoMutexExclusive am(resource_cache_mutex());
    get_cache()->add(rec, payload);
}

add()

void SkResourceCache::add	(	Rec *	rec,
		void *	payload = nullptr
	)

Definition at line 157 of file SkResourceCache.cpp.

                                                 {
    this->checkMessages();
 
    SkASSERT(rec);
    // See if we already have this key (racy inserts, etc.)
    if (Rec** preexisting = fHash->find(rec->getKey())) {
        Rec* prev = *preexisting;
        if (prev->canBePurged()) {
            // if it can be purged, the install may fail, so we have to remove it
            this->remove(prev);
        } else {
            // if it cannot be purged, we reuse it and delete the new one
            prev->postAddInstall(payload);
            delete rec;
            return;
        }
    }
 
    this->addToHead(rec);
    fHash->set(rec);
    rec->postAddInstall(payload);
 
    if (gDumpCacheTransactions) {
        SkString bytesStr, totalStr;
        make_size_str(rec->bytesUsed(), &bytesStr);
        make_size_str(fTotalBytesUsed, &totalStr);
        SkDebugf("RC:    add %5s %12p key %08x -- total %5s, count %d\n",
                 bytesStr.c_str(), rec, rec->getHash(), totalStr.c_str(), fCount);
    }
 
    // since the new rec may push us over-budget, we perform a purge check now
    this->purgeAsNeeded();
}

CheckMessages()

void SkResourceCache::CheckMessages ( )

static

Definition at line 536 of file SkResourceCache.cpp.

                                    {
    SkAutoMutexExclusive am(resource_cache_mutex());
    return get_cache()->checkMessages();
}

discardableFactory()

DiscardableFactory SkResourceCache::discardableFactory ( ) const

inline

Definition at line 253 of file SkResourceCache.h.

{ return fDiscardableFactory; }

Dump()

void SkResourceCache::Dump ( )

static

Call SkDebugf() with diagnostic information about the state of the cache

Definition at line 511 of file SkResourceCache.cpp.

                           {
    SkAutoMutexExclusive am(resource_cache_mutex());
    get_cache()->dump();
}

dump()

void SkResourceCache::dump

(

)

const

Call SkDebugf() with diagnostic information about the state of the cache

Definition at line 423 of file SkResourceCache.cpp.

                                 {
    this->validate();
 
    SkDebugf("SkResourceCache: count=%d bytes=%zu %s\n",
             fCount, fTotalBytesUsed, fDiscardableFactory ? "discardable" : "malloc");
}

DumpMemoryStatistics()

void SkResourceCache::DumpMemoryStatistics ( SkTraceMemoryDump *  dump )

static

Dump memory usage statistics of every Rec in the cache using the SkTraceMemoryDump interface.

Definition at line 616 of file SkResourceCache.cpp.

                                                                  {
    // Since resource could be backed by malloc or discardable, the cache always dumps detailed
    // stats to be accurate.
    VisitAll(sk_trace_dump_visitor, dump);
}

find()

bool SkResourceCache::find	(	const Key &	key,
		FindVisitor	visitor,
		void *	context
	)

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.

Definition at line 129 of file SkResourceCache.cpp.

                                                                             {
    this->checkMessages();
 
    if (auto found = fHash->find(key)) {
        Rec* rec = *found;
        if (visitor(*rec, context)) {
            this->moveToHead(rec);  // for our LRU
            return true;
        } else {
            this->remove(rec);  // stale
            return false;
        }
    }
    return false;
}

Find()

bool SkResourceCache::Find ( const Key &  key, FindVisitor  visitor, void *  context  )

static

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.

Definition at line 541 of file SkResourceCache.cpp.

                                                                             {
    SkAutoMutexExclusive am(resource_cache_mutex());
    return get_cache()->find(key, visitor, context);
}

GetDiscardableFactory()

SkResourceCache::DiscardableFactory SkResourceCache::GetDiscardableFactory ( )

static

Returns the DiscardableFactory used by the global cache, or nullptr.

Definition at line 501 of file SkResourceCache.cpp.

                                                                         {
    SkAutoMutexExclusive am(resource_cache_mutex());
    return get_cache()->discardableFactory();
}

GetEffectiveSingleAllocationByteLimit()

size_t SkResourceCache::GetEffectiveSingleAllocationByteLimit ( )

static

Definition at line 526 of file SkResourceCache.cpp.

                                                              {
    SkAutoMutexExclusive am(resource_cache_mutex());
    return get_cache()->getEffectiveSingleAllocationByteLimit();
}

getEffectiveSingleAllocationByteLimit()

size_t SkResourceCache::getEffectiveSingleAllocationByteLimit

(

)

const

Definition at line 440 of file SkResourceCache.cpp.

                                                                    {
    // fSingleAllocationByteLimit == 0 means the caller is asking for our default
    size_t limit = fSingleAllocationByteLimit;
 
    // if we're not discardable (i.e. we are fixed-budget) then cap the single-limit
    // to our budget.
    if (nullptr == fDiscardableFactory) {
        if (0 == limit) {
            limit = fTotalByteLimit;
        } else {
            limit = std::min(limit, fTotalByteLimit);
        }
    }
    return limit;
}

GetSingleAllocationByteLimit()

size_t SkResourceCache::GetSingleAllocationByteLimit ( )

static

Definition at line 521 of file SkResourceCache.cpp.

                                                     {
    SkAutoMutexExclusive am(resource_cache_mutex());
    return get_cache()->getSingleAllocationByteLimit();
}

getSingleAllocationByteLimit()

size_t SkResourceCache::getSingleAllocationByteLimit

(

)

const

Definition at line 436 of file SkResourceCache.cpp.

                                                           {
    return fSingleAllocationByteLimit;
}

GetTotalByteLimit()

size_t SkResourceCache::GetTotalByteLimit ( )

static

Definition at line 491 of file SkResourceCache.cpp.

                                          {
    SkAutoMutexExclusive am(resource_cache_mutex());
    return get_cache()->getTotalByteLimit();
}

getTotalByteLimit()

size_t SkResourceCache::getTotalByteLimit ( ) const

inline

Definition at line 227 of file SkResourceCache.h.

{ return fTotalByteLimit; }

GetTotalBytesUsed()

size_t SkResourceCache::GetTotalBytesUsed ( )

static

Definition at line 486 of file SkResourceCache.cpp.

                                          {
    SkAutoMutexExclusive am(resource_cache_mutex());
    return get_cache()->getTotalBytesUsed();
}

getTotalBytesUsed()

size_t SkResourceCache::getTotalBytesUsed ( ) const

inline

Definition at line 226 of file SkResourceCache.h.

{ return fTotalBytesUsed; }

NewCachedData()

SkCachedData * SkResourceCache::NewCachedData ( size_t  bytes )

static

Definition at line 506 of file SkResourceCache.cpp.

                                                         {
    SkAutoMutexExclusive am(resource_cache_mutex());
    return get_cache()->newCachedData(bytes);
}

newCachedData()

SkCachedData * SkResourceCache::newCachedData

(

size_t

bytes

)

Definition at line 306 of file SkResourceCache.cpp.

                                                         {
    this->checkMessages();
 
    if (fDiscardableFactory) {
        SkDiscardableMemory* dm = fDiscardableFactory(bytes);
        return dm ? new SkCachedData(bytes, dm) : nullptr;
    } else {
        return new SkCachedData(sk_malloc_throw(bytes), bytes);
    }
}

PostPurgeSharedID()

void SkResourceCache::PostPurgeSharedID ( uint64_t  sharedID )

static

Definition at line 556 of file SkResourceCache.cpp.

                                                         {
    if (sharedID) {
        SkMessageBus<PurgeSharedIDMessage, uint32_t>::Post(PurgeSharedIDMessage(sharedID));
    }
}

PurgeAll()

void SkResourceCache::PurgeAll ( )

static

Definition at line 531 of file SkResourceCache.cpp.

                               {
    SkAutoMutexExclusive am(resource_cache_mutex());
    return get_cache()->purgeAll();
}

purgeAll()

void SkResourceCache::purgeAll ( )

inline

Definition at line 249 of file SkResourceCache.h.

                    {
        this->purgeAsNeeded(true);
    }

purgeSharedID()

void SkResourceCache::purgeSharedID

(

uint64_t

sharedID

)

Definition at line 248 of file SkResourceCache.cpp.

                                                     {
    if (0 == sharedID) {
        return;
    }
 
#ifdef SK_TRACK_PURGE_SHAREDID_HITRATE
    gPurgeCallCounter += 1;
    bool found = false;
#endif
    // go backwards, just like purgeAsNeeded, just to make the code similar.
    // could iterate either direction and still be correct.
    Rec* rec = fTail;
    while (rec) {
        Rec* prev = rec->fPrev;
        if (rec->getKey().getSharedID() == sharedID) {
            // even though the "src" is now dead, caches could still be in-flight, so
            // we have to check if it can be removed.
            if (rec->canBePurged()) {
                this->remove(rec);
            }
#ifdef SK_TRACK_PURGE_SHAREDID_HITRATE
            found = true;
#endif
        }
        rec = prev;
    }
 
#ifdef SK_TRACK_PURGE_SHAREDID_HITRATE
    if (found) {
        gPurgeHitCounter += 1;
    }
 
    SkDebugf("PurgeShared calls=%d hits=%d rate=%g\n", gPurgeCallCounter, gPurgeHitCounter,
             gPurgeHitCounter * 100.0 / gPurgeCallCounter);
#endif
}

setSingleAllocationByteLimit()

size_t SkResourceCache::setSingleAllocationByteLimit

(

size_t

maximumAllocationSize

)

This is respected by SkBitmapProcState::possiblyScaleImage. 0 is no maximum at all; this is the default. setSingleAllocationByteLimit() returns the previous value.

Definition at line 430 of file SkResourceCache.cpp.

                                                                    {
    size_t oldLimit = fSingleAllocationByteLimit;
    fSingleAllocationByteLimit = newLimit;
    return oldLimit;
}

SetSingleAllocationByteLimit()

size_t SkResourceCache::SetSingleAllocationByteLimit ( size_t  size )

static

Definition at line 516 of file SkResourceCache.cpp.

                                                                {
    SkAutoMutexExclusive am(resource_cache_mutex());
    return get_cache()->setSingleAllocationByteLimit(size);
}

SetTotalByteLimit()

size_t SkResourceCache::SetTotalByteLimit ( size_t  newLimit )

static

Definition at line 496 of file SkResourceCache.cpp.

                                                         {
    SkAutoMutexExclusive am(resource_cache_mutex());
    return get_cache()->setTotalByteLimit(newLimit);
}

setTotalByteLimit()

size_t SkResourceCache::setTotalByteLimit

(

size_t

newLimit

)

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.

Definition at line 297 of file SkResourceCache.cpp.

                                                         {
    size_t prevLimit = fTotalByteLimit;
    fTotalByteLimit = newLimit;
    if (newLimit < prevLimit) {
        this->purgeAsNeeded();
    }
    return prevLimit;
}

TestDumpMemoryStatistics()

void SkResourceCache::TestDumpMemoryStatistics ( )

static

Definition at line 596 of file SkResourceCache.cpp.

                                               {
    VisitAll(dump_visitor, nullptr);
}

VisitAll()

void SkResourceCache::VisitAll ( Visitor  visitor, void *  context  )

static

Definition at line 551 of file SkResourceCache.cpp.

                                                             {
    SkAutoMutexExclusive am(resource_cache_mutex());
    get_cache()->visitAll(visitor, context);
}

visitAll()

void SkResourceCache::visitAll	(	Visitor	visitor,
		void *	context
	)

Definition at line 285 of file SkResourceCache.cpp.

                                                             {
    // go backwards, just like purgeAsNeeded, just to make the code similar.
    // could iterate either direction and still be correct.
    Rec* rec = fTail;
    while (rec) {
        visitor(*rec, context);
        rec = rec->fPrev;
    }
}

---

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

• third_party/skia/src/core/SkResourceCache.h
• third_party/skia/src/core/SkResourceCache.cpp