skgpu::graphite::ResourceCache Class Reference

#include <ResourceCache.h>

Inheritance diagram for skgpu::graphite::ResourceCache:

Public Member Functions
	~ResourceCache () override
	ResourceCache (const ResourceCache &)=delete
	ResourceCache (ResourceCache &&)=delete
ResourceCache &	operator= (const ResourceCache &)=delete
ResourceCache &	operator= (ResourceCache &&)=delete
int	getResourceCount () const
void	insertResource (Resource *)
Resource *	findAndRefResource (const GraphiteResourceKey &key, skgpu::Budgeted)
bool	returnResource (Resource *, LastRemovedRef)
void	purgeResourcesNotUsedSince (StdSteadyClock::time_point purgeTime)
void	purgeResources ()
void	shutdown ()
size_t	getMaxBudget () const
size_t	currentBudgetedBytes () const
void	dumpMemoryStatistics (SkTraceMemoryDump *traceMemoryDump) const
ProxyCache *	proxyCache ()
Public Member Functions inherited from SkRefCntBase
	SkRefCntBase ()
virtual	~SkRefCntBase ()
bool	unique () const
void	ref () const
void	unref () const

Static Public Member Functions
static sk_sp< ResourceCache >	Make (SingleOwner *, uint32_t recorderID, size_t maxBytes)

Detailed Description

Definition at line 41 of file ResourceCache.h.

Constructor & Destructor Documentation

~ResourceCache()

skgpu::graphite::ResourceCache::~ResourceCache ( )

override

Definition at line 45 of file ResourceCache.cpp.

                              {
    // The ResourceCache must have been shutdown by the ResourceProvider before it is destroyed.
    SkASSERT(fIsShutdown);
}

ResourceCache() [1/2]

skgpu::graphite::ResourceCache::ResourceCache ( const ResourceCache &  )

delete

ResourceCache() [2/2]

skgpu::graphite::ResourceCache::ResourceCache ( ResourceCache &&  )

delete

Member Function Documentation

currentBudgetedBytes()

size_t skgpu::graphite::ResourceCache::currentBudgetedBytes ( ) const

inline

Definition at line 83 of file ResourceCache.h.

{ return fBudgetedBytes; }

dumpMemoryStatistics()

void skgpu::graphite::ResourceCache::dumpMemoryStatistics

(

SkTraceMemoryDump *

traceMemoryDump

)

const

Definition at line 558 of file ResourceCache.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);
    }
}

findAndRefResource()

Resource * skgpu::graphite::ResourceCache::findAndRefResource	(	const GraphiteResourceKey &	key,
		skgpu::Budgeted	budgeted
	)

Definition at line 126 of file ResourceCache.cpp.

                                                                    {
    ASSERT_SINGLE_OWNER
 
    SkASSERT(key.isValid());
 
    Resource* resource = fResourceMap.find(key);
    if (!resource) {
        // The main reason to call processReturnedResources in this call is to see if there are any
        // resources that we could match with the key. However, there is overhead into calling it.
        // So we only call it if we first failed to find a matching resource.
        if (this->processReturnedResources()) {
            resource = fResourceMap.find(key);
        }
    }
    if (resource) {
        // All resources we pull out of the cache for use should be budgeted
        SkASSERT(resource->budgeted() == skgpu::Budgeted::kYes);
        if (key.shareable() == Shareable::kNo) {
            // If a resource is not shareable (i.e. scratch resource) then we remove it from the map
            // so that it isn't found again.
            fResourceMap.remove(key, resource);
            if (budgeted == skgpu::Budgeted::kNo) {
                resource->makeUnbudgeted();
                fBudgetedBytes -= resource->gpuMemorySize();
            }
            SkDEBUGCODE(resource->fNonShareableInCache = false;)
        } else {
            // Shareable resources should never be requested as non budgeted
            SkASSERT(budgeted == skgpu::Budgeted::kYes);
        }
        this->refAndMakeResourceMRU(resource);
        this->validate();
    }
 
    // processReturnedResources may have added resources back into our budget if they were being
    // using in an SkImage or SkSurface previously. However, instead of calling purgeAsNeeded in
    // processReturnedResources, we delay calling it until now so we don't end up purging a resource
    // we're looking for in this function.
    //
    // We could avoid calling this if we didn't return any resources from processReturnedResources.
    // However, when not overbudget purgeAsNeeded is very cheap. When overbudget there may be some
    // really niche usage patterns that could cause us to never actually return resources to the
    // cache, but still be overbudget due to shared resources. So to be safe we just always call it
    // here.
    this->purgeAsNeeded();
 
    return resource;
}

getMaxBudget()

size_t skgpu::graphite::ResourceCache::getMaxBudget ( ) const

inline

Definition at line 81 of file ResourceCache.h.

{ return fMaxBytes; }

getResourceCount()

int skgpu::graphite::ResourceCache::getResourceCount ( ) const

inline

Definition at line 52 of file ResourceCache.h.

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

insertResource()

void skgpu::graphite::ResourceCache::insertResource

(

Resource *

resource

)

Definition at line 82 of file ResourceCache.cpp.

                                                     {
    ASSERT_SINGLE_OWNER
    SkASSERT(resource);
    SkASSERT(!this->isInCache(resource));
    SkASSERT(!resource->wasDestroyed());
    SkASSERT(!resource->isPurgeable());
    SkASSERT(resource->key().isValid());
    // All resources in the cache are owned. If we track wrapped resources in the cache we'll need
    // to update this check.
    SkASSERT(resource->ownership() == Ownership::kOwned);
 
    // The reason to call processReturnedResources here is to get an accurate accounting of our
    // memory usage as some resources can go from unbudgeted to budgeted when they return. So we
    // want to have them all returned before adding the budget for the new resource in case we need
    // to purge things. However, if the new resource has a memory size of 0, then we just skip
    // returning resources (which has overhead for each call) since the new resource won't be
    // affecting whether we're over or under budget.
    if (resource->gpuMemorySize() > 0) {
        this->processReturnedResources();
    }
 
    resource->registerWithCache(sk_ref_sp(this));
    resource->refCache();
 
    // We must set the timestamp before adding to the array in case the timestamp wraps and we wind
    // up iterating over all the resources that already have timestamps.
    this->setResourceTimestamp(resource, this->getNextTimestamp());
    resource->updateAccessTime();
 
    this->addToNonpurgeableArray(resource);
 
    SkDEBUGCODE(fCount++;)
 
    if (resource->key().shareable() == Shareable::kYes) {
        fResourceMap.insert(resource->key(), resource);
    }
 
    if (resource->budgeted() == skgpu::Budgeted::kYes) {
        fBudgetedBytes += resource->gpuMemorySize();
    }
 
    this->purgeAsNeeded();
}

Make()

sk_sp< ResourceCache > skgpu::graphite::ResourceCache::Make ( SingleOwner *  singleOwner, uint32_t  recorderID, size_t  maxBytes  )

static

Definition at line 26 of file ResourceCache.cpp.

                                                          {
    return sk_sp<ResourceCache>(new ResourceCache(singleOwner, recorderID, maxBytes));
}

operator=() [1/2]

ResourceCache & skgpu::graphite::ResourceCache::operator= ( const ResourceCache &  )

delete

operator=() [2/2]

ResourceCache & skgpu::graphite::ResourceCache::operator= ( ResourceCache &&  )

delete

proxyCache()

ProxyCache * skgpu::graphite::ResourceCache::proxyCache ( )

inline

Definition at line 107 of file ResourceCache.h.

{ return fProxyCache.get(); }

purgeResources()

void skgpu::graphite::ResourceCache::purgeResources

(

)

Definition at line 435 of file ResourceCache.cpp.

                                   {
    ASSERT_SINGLE_OWNER
    this->purgeResources(nullptr);
}

purgeResourcesNotUsedSince()

void skgpu::graphite::ResourceCache::purgeResourcesNotUsedSince

(

StdSteadyClock::time_point

purgeTime

)

Definition at line 430 of file ResourceCache.cpp.

                                                                                 {
    ASSERT_SINGLE_OWNER
    this->purgeResources(&purgeTime);
}

returnResource()

bool skgpu::graphite::ResourceCache::returnResource	(	Resource *	resource,
		LastRemovedRef	removedRef
	)

Definition at line 191 of file ResourceCache.cpp.

                                                                                {
    // We should never be trying to return a LastRemovedRef of kCache.
    SkASSERT(removedRef != LastRemovedRef::kCache);
    SkAutoMutexExclusive locked(fReturnMutex);
    if (fIsShutdown) {
        return false;
    }
 
    SkASSERT(resource);
 
    // When a non-shareable resource's CB and Usage refs are both zero, give it a chance prepare
    // itself to be reused. On Dawn/WebGPU we use this to remap kXferCpuToGpu buffers asynchronously
    // so that they are already mapped before they come out of the cache again.
    if (resource->shouldDeleteASAP() == Resource::DeleteASAP::kNo &&
        resource->key().shareable() == Shareable::kNo &&
        removedRef == LastRemovedRef::kUsage) {
        resource->prepareForReturnToCache([resource] { resource->initialUsageRef(); });
        // Check if resource was re-ref'ed. In that case exit without adding to the queue.
        if (resource->hasUsageRef()) {
            return true;
        }
    }
 
    // We only allow one instance of a Resource to be in the return queue at a time. We do this so
    // that the ReturnQueue stays small and quick to process.
    //
    // Because we take CacheRefs to all Resources added to the ReturnQueue, we would be safe if we
    // decided to have multiple instances of a Resource. Even if an earlier returned instance of a
    // Resource triggers that Resource to get purged from the cache, the Resource itself wouldn't
    // get deleted until we drop all the CacheRefs in this ReturnQueue.
    if (*resource->accessReturnIndex() >= 0) {
        // If the resource is already in the return queue we promote the LastRemovedRef to be
        // kUsage if that is what is returned here.
        if (removedRef == LastRemovedRef::kUsage) {
            SkASSERT(*resource->accessReturnIndex() < (int)fReturnQueue.size());
            fReturnQueue[*resource->accessReturnIndex()].second = removedRef;
        }
        return true;
    }
#ifdef SK_DEBUG
    for (auto& nextResource : fReturnQueue) {
        SkASSERT(nextResource.first != resource);
    }
#endif
 
    fReturnQueue.push_back(std::make_pair(resource, removedRef));
    *resource->accessReturnIndex() = fReturnQueue.size() - 1;
    resource->refCache();
    return true;
}

shutdown()

void skgpu::graphite::ResourceCache::shutdown

(

)

Definition at line 50 of file ResourceCache.cpp.

                             {
    ASSERT_SINGLE_OWNER
 
    SkASSERT(!fIsShutdown);
 
    {
        SkAutoMutexExclusive locked(fReturnMutex);
        fIsShutdown = true;
    }
    if (fProxyCache) {
        fProxyCache->purgeAll();
    }
 
    this->processReturnedResources();
 
    while (fNonpurgeableResources.size()) {
        Resource* back = *(fNonpurgeableResources.end() - 1);
        SkASSERT(!back->wasDestroyed());
        this->removeFromNonpurgeableArray(back);
        back->unrefCache();
    }
 
    while (fPurgeableQueue.count()) {
        Resource* top = fPurgeableQueue.peek();
        SkASSERT(!top->wasDestroyed());
        this->removeFromPurgeableQueue(top);
        top->unrefCache();
    }
 
    TRACE_EVENT_INSTANT0("skia.gpu.cache", TRACE_FUNC, TRACE_EVENT_SCOPE_THREAD);
}

---

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

• third_party/skia/src/gpu/graphite/ResourceCache.h
• third_party/skia/src/gpu/graphite/ResourceCache.cpp