GrResourceCache Class Reference

#include <GrResourceCache.h>

Classes
class	ResourceAccess
class	UnrefResourceMessage

Public Member Functions
	GrResourceCache (skgpu::SingleOwner *owner, GrDirectContext::DirectContextID owningContextID, uint32_t familyID)
	~GrResourceCache ()
ResourceAccess	resourceAccess ()
uint32_t	contextUniqueID () const
void	setLimit (size_t bytes)
int	getResourceCount () const
int	getBudgetedResourceCount () const
size_t	getResourceBytes () const
size_t	getPurgeableBytes () const
size_t	getBudgetedResourceBytes () const
size_t	getMaxResourceBytes () const
void	abandonAll ()
void	releaseAll ()
GrGpuResource *	findAndRefScratchResource (const skgpu::ScratchKey &scratchKey)
GrGpuResource *	findAndRefUniqueResource (const skgpu::UniqueKey &key)
bool	hasUniqueKey (const skgpu::UniqueKey &key) const
void	purgeAsNeeded ()
void	purgeUnlockedResources (GrPurgeResourceOptions opts)
void	purgeResourcesNotUsedSince (skgpu::StdSteadyClock::time_point purgeTime, GrPurgeResourceOptions opts)
bool	purgeToMakeHeadroom (size_t desiredHeadroomBytes)
bool	overBudget () const
void	purgeUnlockedResources (size_t bytesToPurge, bool preferScratchResources)
bool	requestsFlush () const
void	dumpMemoryStatistics (SkTraceMemoryDump *traceMemoryDump) const
void	setProxyProvider (GrProxyProvider *proxyProvider)
void	setThreadSafeCache (GrThreadSafeCache *threadSafeCache)

Static Public Member Functions
template<typename T >
static std::enable_if_t< std::is_base_of_v< GrGpuResource, T >, void >	ReturnResourceFromThread (sk_sp< T > &&resource, GrDirectContext::DirectContextID id)

Static Public Attributes
static const size_t	kDefaultMaxSize = 256 * (1 << 20)

Private Member Functions
	SkDEBUGCODE (int fCount=0;) size_t fBytes=0
Methods accessible via ResourceAccess
/

Detailed Description

Manages the lifetime of all GrGpuResource instances.

Resources may have optionally have two types of keys: 1) A scratch key. This is for resources whose allocations are cached but not their contents. Multiple resources can share the same scratch key. This is so a caller can have two resource instances with the same properties (e.g. multipass rendering that ping-pongs between two temporary surfaces). The scratch key is set at resource creation time and should never change. Resources need not have a scratch key. 2) A unique key. This key's meaning is specific to the domain that created the key. Only one resource may have a given unique key. The unique key can be set, cleared, or changed anytime after resource creation.

A unique key always takes precedence over a scratch key when a resource has both types of keys. If a resource has neither key type then it will be deleted as soon as the last reference to it is dropped.

Definition at line 53 of file GrResourceCache.h.

Constructor & Destructor Documentation

GrResourceCache()

GrResourceCache::GrResourceCache	(	skgpu::SingleOwner *	owner,
		GrDirectContext::DirectContextID	owningContextID,
		uint32_t	familyID
	)

~GrResourceCache()

GrResourceCache::~GrResourceCache

(

)

Definition at line 62 of file GrResourceCache.cpp.

                                  {
    this->releaseAll();
}

Member Function Documentation

abandonAll()

void GrResourceCache::abandonAll

(

)

Abandons the backend API resources owned by all GrGpuResource objects and removes them from the cache.

Definition at line 136 of file GrResourceCache.cpp.

                                 {
    AutoValidate av(this);
 
    while (!fNonpurgeableResources.empty()) {
        GrGpuResource* back = *(fNonpurgeableResources.end() - 1);
        SkASSERT(!back->wasDestroyed());
        back->cacheAccess().abandon();
    }
 
    while (fPurgeableQueue.count()) {
        GrGpuResource* top = fPurgeableQueue.peek();
        SkASSERT(!top->wasDestroyed());
        top->cacheAccess().abandon();
    }
 
    fThreadSafeCache->dropAllRefs();
 
    SkASSERT(!fScratchMap.count());
    SkASSERT(!fUniqueHash.count());
    SkASSERT(!fCount);
    SkASSERT(!this->getResourceCount());
    SkASSERT(!fBytes);
    SkASSERT(!fBudgetedCount);
    SkASSERT(!fBudgetedBytes);
    SkASSERT(!fPurgeableBytes);
}

contextUniqueID()

uint32_t GrResourceCache::contextUniqueID ( ) const

inline

Unique ID of the owning GrContext.

Definition at line 87 of file GrResourceCache.h.

{ return fContextUniqueID; }

dumpMemoryStatistics()

void GrResourceCache::dumpMemoryStatistics

(

SkTraceMemoryDump *

traceMemoryDump

)

const

Definition at line 723 of file GrResourceCache.cpp.

                                                                                   {
    for (int i = 0; i < fNonpurgeableResources.size(); ++i) {
        fNonpurgeableResources[i]->dumpMemoryStatistics(traceMemoryDump);
    }
    for (int i = 0; i < fPurgeableQueue.count(); ++i) {
        fPurgeableQueue.at(i)->dumpMemoryStatistics(traceMemoryDump);
    }
}

findAndRefScratchResource()

GrGpuResource * GrResourceCache::findAndRefScratchResource

(

const skgpu::ScratchKey &

scratchKey

)

Find a resource that matches a scratch key.

Definition at line 210 of file GrResourceCache.cpp.

                                                                                           {
    SkASSERT(scratchKey.isValid());
 
    GrGpuResource* resource = fScratchMap.find(scratchKey);
    if (resource) {
        fScratchMap.remove(scratchKey, resource);
        this->refAndMakeResourceMRU(resource);
        this->validate();
    }
    return resource;
}

findAndRefUniqueResource()

GrGpuResource * GrResourceCache::findAndRefUniqueResource ( const skgpu::UniqueKey &  key )

inline

Find a resource that matches a unique key.

Definition at line 151 of file GrResourceCache.h.

                                                                       {
        GrGpuResource* resource = fUniqueHash.find(key);
        if (resource) {
            this->refAndMakeResourceMRU(resource);
        }
        return resource;
    }

getBudgetedResourceBytes()

size_t GrResourceCache::getBudgetedResourceBytes ( ) const

inline

Returns the number of bytes consumed by budgeted resources.

Definition at line 117 of file GrResourceCache.h.

{ return fBudgetedBytes; }

getBudgetedResourceCount()

int GrResourceCache::getBudgetedResourceCount ( ) const

inline

Returns the number of resources that count against the budget.

Definition at line 102 of file GrResourceCache.h.

{ return fBudgetedCount; }

getMaxResourceBytes()

size_t GrResourceCache::getMaxResourceBytes ( ) const

inline

Returns the number of bytes consumed by cached resources.

Definition at line 122 of file GrResourceCache.h.

{ return fMaxBytes; }

getPurgeableBytes()

size_t GrResourceCache::getPurgeableBytes ( ) const

inline

Returns the number of bytes held by unlocked resources which are available for purging.

Definition at line 112 of file GrResourceCache.h.

{ return fPurgeableBytes; }

getResourceBytes()

size_t GrResourceCache::getResourceBytes ( ) const

inline

Returns the number of bytes consumed by resources.

Definition at line 107 of file GrResourceCache.h.

{ return fBytes; }

getResourceCount()

int GrResourceCache::getResourceCount ( ) const

inline

Returns the number of resources.

Definition at line 95 of file GrResourceCache.h.

                                 {
        return fPurgeableQueue.count() + fNonpurgeableResources.size();
    }

hasUniqueKey()

bool GrResourceCache::hasUniqueKey ( const skgpu::UniqueKey &  key ) const

inline

Query whether a unique key exists in the cache.

Definition at line 162 of file GrResourceCache.h.

                                                       {
        return SkToBool(fUniqueHash.find(key));
    }

overBudget()

bool GrResourceCache::overBudget ( ) const

inline

Definition at line 190 of file GrResourceCache.h.

{ return fBudgetedBytes > fMaxBytes; }

purgeAsNeeded()

void GrResourceCache::purgeAsNeeded

(

)

Purges resources to become under budget and processes resources with invalidated unique keys.

Definition at line 441 of file GrResourceCache.cpp.

                                    {
    TArray<skgpu::UniqueKeyInvalidatedMessage> invalidKeyMsgs;
    fInvalidUniqueKeyInbox.poll(&invalidKeyMsgs);
    if (!invalidKeyMsgs.empty()) {
        SkASSERT(fProxyProvider);
 
        for (int i = 0; i < invalidKeyMsgs.size(); ++i) {
            if (invalidKeyMsgs[i].inThreadSafeCache()) {
                fThreadSafeCache->remove(invalidKeyMsgs[i].key());
                SkASSERT(!fThreadSafeCache->has(invalidKeyMsgs[i].key()));
            } else {
                fProxyProvider->processInvalidUniqueKey(
                                                    invalidKeyMsgs[i].key(), nullptr,
                                                    GrProxyProvider::InvalidateGPUResource::kYes);
                SkASSERT(!this->findAndRefUniqueResource(invalidKeyMsgs[i].key()));
            }
        }
    }
 
    this->processFreedGpuResources();
 
    bool stillOverbudget = this->overBudget();
    while (stillOverbudget && fPurgeableQueue.count()) {
        GrGpuResource* resource = fPurgeableQueue.peek();
        SkASSERT(resource->resourcePriv().isPurgeable());
        resource->cacheAccess().release();
        stillOverbudget = this->overBudget();
    }
 
    if (stillOverbudget) {
        fThreadSafeCache->dropUniqueRefs(this);
 
        stillOverbudget = this->overBudget();
        while (stillOverbudget && fPurgeableQueue.count()) {
            GrGpuResource* resource = fPurgeableQueue.peek();
            SkASSERT(resource->resourcePriv().isPurgeable());
            resource->cacheAccess().release();
            stillOverbudget = this->overBudget();
        }
    }
 
    this->validate();
}

purgeResourcesNotUsedSince()

void GrResourceCache::purgeResourcesNotUsedSince ( skgpu::StdSteadyClock::time_point  purgeTime, GrPurgeResourceOptions  opts  )

inline

Definition at line 180 of file GrResourceCache.h.

                                                                 {
        this->purgeUnlockedResources(&purgeTime, opts);
    }

purgeToMakeHeadroom()

bool GrResourceCache::purgeToMakeHeadroom

(

size_t

desiredHeadroomBytes

)

If it's possible to purge enough resources to get the provided amount of budget headroom, do so and return true. If it's not possible, do nothing and return false.

Definition at line 552 of file GrResourceCache.cpp.

                                                                     {
    AutoValidate av(this);
    if (desiredHeadroomBytes > fMaxBytes) {
        return false;
    }
    if (this->wouldFit(desiredHeadroomBytes)) {
        return true;
    }
    fPurgeableQueue.sort();
 
    size_t projectedBudget = fBudgetedBytes;
    int purgeCnt = 0;
    for (int i = 0; i < fPurgeableQueue.count(); i++) {
        GrGpuResource* resource = fPurgeableQueue.at(i);
        if (GrBudgetedType::kBudgeted == resource->resourcePriv().budgetedType()) {
            projectedBudget -= resource->gpuMemorySize();
        }
        if (projectedBudget + desiredHeadroomBytes <= fMaxBytes) {
            purgeCnt = i + 1;
            break;
        }
    }
    if (purgeCnt == 0) {
        return false;
    }
 
    // Success! Release the resources.
    // Copy to array first so we don't mess with the queue.
    std::vector<GrGpuResource*> resources;
    resources.reserve(purgeCnt);
    for (int i = 0; i < purgeCnt; i++) {
        resources.push_back(fPurgeableQueue.at(i));
    }
    for (GrGpuResource* resource : resources) {
        resource->cacheAccess().release();
    }
    return true;
}

purgeUnlockedResources() [1/2]

void GrResourceCache::purgeUnlockedResources ( GrPurgeResourceOptions  opts )

inline

Definition at line 173 of file GrResourceCache.h.

                                                             {
        this->purgeUnlockedResources(/*purgeTime=*/nullptr, opts);
    }

purgeUnlockedResources() [2/2]

void GrResourceCache::purgeUnlockedResources	(	size_t	bytesToPurge,
		bool	preferScratchResources
	)

Purge unlocked resources from the cache until the the provided byte count has been reached or we have purged all unlocked resources. The default policy is to purge in LRU order, but can be overridden to prefer purging scratch resources (in LRU order) prior to purging other resource types.

Parameters

maxBytesToPurge	the desired number of bytes to be purged.
preferScratchResources	If true scratch resources will be purged prior to other resource types.

Definition at line 591 of file GrResourceCache.cpp.

                                                                                             {
 
    const size_t tmpByteBudget = std::max((size_t)0, fBytes - bytesToPurge);
    bool stillOverbudget = tmpByteBudget < fBytes;
 
    if (preferScratchResources && bytesToPurge < fPurgeableBytes) {
        // Sort the queue
        fPurgeableQueue.sort();
 
        // Make a list of the scratch resources to delete
        SkTDArray<GrGpuResource*> scratchResources;
        size_t scratchByteCount = 0;
        for (int i = 0; i < fPurgeableQueue.count() && stillOverbudget; i++) {
            GrGpuResource* resource = fPurgeableQueue.at(i);
            SkASSERT(resource->resourcePriv().isPurgeable());
            if (!resource->getUniqueKey().isValid()) {
                *scratchResources.append() = resource;
                scratchByteCount += resource->gpuMemorySize();
                stillOverbudget = tmpByteBudget < fBytes - scratchByteCount;
            }
        }
 
        // Delete the scratch resources. This must be done as a separate pass
        // to avoid messing up the sorted order of the queue
        for (int i = 0; i < scratchResources.size(); i++) {
            scratchResources[i]->cacheAccess().release();
        }
        stillOverbudget = tmpByteBudget < fBytes;
 
        this->validate();
    }
 
    // Purge any remaining resources in LRU order
    if (stillOverbudget) {
        const size_t cachedByteCount = fMaxBytes;
        fMaxBytes = tmpByteBudget;
        this->purgeAsNeeded();
        fMaxBytes = cachedByteCount;
    }
}

releaseAll()

void GrResourceCache::releaseAll

(

)

Releases the backend API resources owned by all GrGpuResource objects and removes them from the cache.

Definition at line 163 of file GrResourceCache.cpp.

                                 {
    AutoValidate av(this);
 
    fThreadSafeCache->dropAllRefs();
 
    this->processFreedGpuResources();
 
    SkASSERT(fProxyProvider); // better have called setProxyProvider
    SkASSERT(fThreadSafeCache); // better have called setThreadSafeCache too
 
    // We must remove the uniqueKeys from the proxies here. While they possess a uniqueKey
    // they also have a raw pointer back to this class (which is presumably going away)!
    fProxyProvider->removeAllUniqueKeys();
 
    while (!fNonpurgeableResources.empty()) {
        GrGpuResource* back = *(fNonpurgeableResources.end() - 1);
        SkASSERT(!back->wasDestroyed());
        back->cacheAccess().release();
    }
 
    while (fPurgeableQueue.count()) {
        GrGpuResource* top = fPurgeableQueue.peek();
        SkASSERT(!top->wasDestroyed());
        top->cacheAccess().release();
    }
 
    SkASSERT(!fScratchMap.count());
    SkASSERT(!fUniqueHash.count());
    SkASSERT(!fCount);
    SkASSERT(!this->getResourceCount());
    SkASSERT(!fBytes);
    SkASSERT(!fBudgetedCount);
    SkASSERT(!fBudgetedBytes);
    SkASSERT(!fPurgeableBytes);
}

requestsFlush()

bool GrResourceCache::requestsFlush

(

)

const

Returns true if the cache would like a flush to occur in order to make more resources purgeable.

Definition at line 632 of file GrResourceCache.cpp.

                                          {
    return this->overBudget() && !fPurgeableQueue.count() &&
           fNumBudgetedResourcesFlushWillMakePurgeable > 0;
}

resourceAccess()

GrResourceCache::ResourceAccess GrResourceCache::resourceAccess ( )

inline

Definition at line 487 of file GrResourceCache.h.

                                                                     {
    return ResourceAccess(this);
}

ReturnResourceFromThread()

template<typename T >

static std::enable_if_t< std::is_base_of_v< GrGpuResource, T >, void > GrResourceCache::ReturnResourceFromThread ( sk_sp< T > &&  resource, GrDirectContext::DirectContextID  id  )

inlinestatic

This is used to safely return a resource to the cache when the owner may be on another thread from GrDirectContext. If the context still exists then using this method ensures that the resource is received by the cache for processing (recycling or destruction) on the context's thread.

This is templated as it is rather than simply taking sk_sp<GrGpuResource> in order to enforce that the caller passes an rvalue. If the caller doesn't move its ref into this function then it will retain ownership, defeating the purpose. (Note that sk_sp<GrGpuResource>&& doesn't work either because calling with sk_sp<GrSpecificResource> will create a temporary sk_sp<GrGpuResource> which is an rvalue).

Definition at line 74 of file GrResourceCache.h.

                                                                                     {
        UnrefResourceMessage msg(std::move(resource), id);
        UnrefResourceMessage::Bus::Post(std::move(msg));
    }

setLimit()

void GrResourceCache::setLimit

(

size_t

bytes

)

Sets the max gpu memory byte size of the cache.

Definition at line 66 of file GrResourceCache.cpp.

                                           {
    fMaxBytes = bytes;
    this->purgeAsNeeded();
}

setProxyProvider()

void GrResourceCache::setProxyProvider ( GrProxyProvider *  proxyProvider )

inline

Definition at line 264 of file GrResourceCache.h.

{ fProxyProvider = proxyProvider; }

setThreadSafeCache()

void GrResourceCache::setThreadSafeCache ( GrThreadSafeCache *  threadSafeCache )

inline

Definition at line 265 of file GrResourceCache.h.

                                                                {
        fThreadSafeCache = threadSafeCache;
    }

SkDEBUGCODE()

GrResourceCache::SkDEBUGCODE ( int  fCount = 0; )

privatepure virtual

Member Data Documentation

kDefaultMaxSize

const size_t GrResourceCache::kDefaultMaxSize = 256 * (1 << 20)

static

Definition at line 80 of file GrResourceCache.h.

---

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

• third_party/skia/src/gpu/ganesh/GrResourceCache.h
• third_party/skia/src/gpu/ganesh/GrResourceCache.cpp