blob: b790a67ea2b0b784c4f56ccc320c3a9d30441f29 [file] [log] [blame]
/*
* Copyright 2014 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef GrResourceCache_DEFINED
#define GrResourceCache_DEFINED
#include "include/core/SkRefCnt.h"
#include "include/core/SkTypes.h"
#include "include/gpu/GrDirectContext.h"
#include "include/private/base/SkTArray.h"
#include "src/base/SkTDPQueue.h"
#include "src/base/SkTInternalLList.h"
#include "src/core/SkMessageBus.h"
#include "src/core/SkTHash.h"
#include "src/core/SkTMultiMap.h"
#include "src/gpu/ResourceKey.h"
#include "src/gpu/ganesh/GrGpuResource.h"
#include "src/gpu/ganesh/GrGpuResourceCacheAccess.h"
#include "src/gpu/ganesh/GrGpuResourcePriv.h"
class GrCaps;
class GrProxyProvider;
class SkString;
class SkTraceMemoryDump;
class GrTexture;
class GrThreadSafeCache;
namespace skgpu {
class SingleOwner;
}
/**
* 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.
*/
class GrResourceCache {
public:
GrResourceCache(skgpu::SingleOwner* owner,
GrDirectContext::DirectContextID owningContextID,
uint32_t familyID);
~GrResourceCache();
/**
* 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).
*/
template<typename T>
static std::enable_if_t<std::is_base_of_v<GrGpuResource, T>, void>
ReturnResourceFromThread(sk_sp<T>&& resource, GrDirectContext::DirectContextID id) {
UnrefResourceMessage msg(std::move(resource), id);
UnrefResourceMessage::Bus::Post(std::move(msg));
}
// Default maximum number of bytes of gpu memory of budgeted resources in the cache.
static const size_t kDefaultMaxSize = 256 * (1 << 20);
/** Used to access functionality needed by GrGpuResource for lifetime management. */
class ResourceAccess;
ResourceAccess resourceAccess();
/** Unique ID of the owning GrContext. */
uint32_t contextUniqueID() const { return fContextUniqueID; }
/** Sets the max gpu memory byte size of the cache. */
void setLimit(size_t bytes);
/**
* Returns the number of resources.
*/
int getResourceCount() const {
return fPurgeableQueue.count() + fNonpurgeableResources.size();
}
/**
* Returns the number of resources that count against the budget.
*/
int getBudgetedResourceCount() const { return fBudgetedCount; }
/**
* Returns the number of bytes consumed by resources.
*/
size_t getResourceBytes() const { return fBytes; }
/**
* Returns the number of bytes held by unlocked resources which are available for purging.
*/
size_t getPurgeableBytes() const { return fPurgeableBytes; }
/**
* Returns the number of bytes consumed by budgeted resources.
*/
size_t getBudgetedResourceBytes() const { return fBudgetedBytes; }
/**
* Returns the number of bytes consumed by cached resources.
*/
size_t getMaxResourceBytes() const { return fMaxBytes; }
/**
* Abandons the backend API resources owned by all GrGpuResource objects and removes them from
* the cache.
*/
void abandonAll();
/**
* Releases the backend API resources owned by all GrGpuResource objects and removes them from
* the cache.
*/
void releaseAll();
/**
* Find a resource that matches a scratch key.
*/
GrGpuResource* findAndRefScratchResource(const skgpu::ScratchKey& scratchKey);
#ifdef SK_DEBUG
// This is not particularly fast and only used for validation, so debug only.
int countScratchEntriesForKey(const skgpu::ScratchKey& scratchKey) const {
return fScratchMap.countForKey(scratchKey);
}
#endif
/**
* Find a resource that matches a unique key.
*/
GrGpuResource* findAndRefUniqueResource(const skgpu::UniqueKey& key) {
GrGpuResource* resource = fUniqueHash.find(key);
if (resource) {
this->refAndMakeResourceMRU(resource);
}
return resource;
}
/**
* Query whether a unique key exists in the cache.
*/
bool hasUniqueKey(const skgpu::UniqueKey& key) const {
return SkToBool(fUniqueHash.find(key));
}
/** Purges resources to become under budget and processes resources with invalidated unique
keys. */
void purgeAsNeeded();
// Purge unlocked resources. If 'opts' is kScratchResourcesOnly, the purgeable resources
// containing persistent data are spared. If it is kAllResources then all purgeable resources
// will be deleted.
void purgeUnlockedResources(GrPurgeResourceOptions opts) {
this->purgeUnlockedResources(/*purgeTime=*/nullptr, opts);
}
// Purge unlocked resources not used since the passed point in time. If 'opts' is
// kScratchResourcesOnly, the purgeable resources containing persistent data are spared.
// If it is kAllResources then all purgeable resources older than 'purgeTime' will be deleted.
void purgeResourcesNotUsedSince(skgpu::StdSteadyClock::time_point purgeTime,
GrPurgeResourceOptions opts) {
this->purgeUnlockedResources(&purgeTime, opts);
}
/** 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.
*/
bool purgeToMakeHeadroom(size_t desiredHeadroomBytes);
bool overBudget() const { return fBudgetedBytes > fMaxBytes; }
/**
* 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.
*
* @param maxBytesToPurge the desired number of bytes to be purged.
* @param preferScratchResources If true scratch resources will be purged prior to other
* resource types.
*/
void purgeUnlockedResources(size_t bytesToPurge, bool preferScratchResources);
/** Returns true if the cache would like a flush to occur in order to make more resources
purgeable. */
bool requestsFlush() const;
#if GR_CACHE_STATS
struct Stats {
int fTotal;
int fNumPurgeable;
int fNumNonPurgeable;
int fScratch;
int fWrapped;
size_t fUnbudgetedSize;
Stats() { this->reset(); }
void reset() {
fTotal = 0;
fNumPurgeable = 0;
fNumNonPurgeable = 0;
fScratch = 0;
fWrapped = 0;
fUnbudgetedSize = 0;
}
void update(GrGpuResource* resource) {
if (resource->cacheAccess().isScratch()) {
++fScratch;
}
if (resource->resourcePriv().refsWrappedObjects()) {
++fWrapped;
}
if (GrBudgetedType::kBudgeted != resource->resourcePriv().budgetedType()) {
fUnbudgetedSize += resource->gpuMemorySize();
}
}
};
void getStats(Stats*) const;
#if defined(GR_TEST_UTILS)
void dumpStats(SkString*) const;
void dumpStatsKeyValuePairs(
skia_private::TArray<SkString>* keys, skia_private::TArray<double>* value) const;
#endif
#endif // GR_CACHE_STATS
#if defined(GR_TEST_UTILS)
int countUniqueKeysWithTag(const char* tag) const;
void changeTimestamp(uint32_t newTimestamp);
void visitSurfaces(const std::function<void(const GrSurface*, bool purgeable)>&) const;
#endif
// Enumerates all cached resources and dumps their details to traceMemoryDump.
void dumpMemoryStatistics(SkTraceMemoryDump* traceMemoryDump) const;
void setProxyProvider(GrProxyProvider* proxyProvider) { fProxyProvider = proxyProvider; }
void setThreadSafeCache(GrThreadSafeCache* threadSafeCache) {
fThreadSafeCache = threadSafeCache;
}
// It'd be nice if this could be private but SkMessageBus relies on macros to define types that
// require this to be public.
class UnrefResourceMessage {
public:
GrDirectContext::DirectContextID recipient() const { return fRecipient; }
UnrefResourceMessage(UnrefResourceMessage&&) = default;
UnrefResourceMessage& operator=(UnrefResourceMessage&&) = default;
private:
friend class GrResourceCache;
using Bus = SkMessageBus<UnrefResourceMessage,
GrDirectContext::DirectContextID,
/*AllowCopyableMessage=*/false>;
UnrefResourceMessage(sk_sp<GrGpuResource>&& resource,
GrDirectContext::DirectContextID recipient)
: fResource(std::move(resource)), fRecipient(recipient) {}
UnrefResourceMessage(const UnrefResourceMessage&) = delete;
UnrefResourceMessage& operator=(const UnrefResourceMessage&) = delete;
sk_sp<GrGpuResource> fResource;
GrDirectContext::DirectContextID fRecipient;
};
private:
///////////////////////////////////////////////////////////////////////////
/// @name Methods accessible via ResourceAccess
////
void insertResource(GrGpuResource*);
void removeResource(GrGpuResource*);
void notifyARefCntReachedZero(GrGpuResource*, GrGpuResource::LastRemovedRef);
void changeUniqueKey(GrGpuResource*, const skgpu::UniqueKey&);
void removeUniqueKey(GrGpuResource*);
void willRemoveScratchKey(const GrGpuResource*);
void didChangeBudgetStatus(GrGpuResource*);
void refResource(GrGpuResource* resource);
/// @}
void refAndMakeResourceMRU(GrGpuResource*);
void processFreedGpuResources();
void addToNonpurgeableArray(GrGpuResource*);
void removeFromNonpurgeableArray(GrGpuResource*);
bool wouldFit(size_t bytes) const { return fBudgetedBytes+bytes <= fMaxBytes; }
uint32_t getNextTimestamp();
void purgeUnlockedResources(const skgpu::StdSteadyClock::time_point* purgeTime,
GrPurgeResourceOptions opts);
#ifdef SK_DEBUG
bool isInCache(const GrGpuResource* r) const;
void validate() const;
#else
void validate() const {}
#endif
class AutoValidate;
struct ScratchMapTraits {
static const skgpu::ScratchKey& GetKey(const GrGpuResource& r) {
return r.resourcePriv().getScratchKey();
}
static uint32_t Hash(const skgpu::ScratchKey& key) { return key.hash(); }
static void OnFree(GrGpuResource*) { }
};
typedef SkTMultiMap<GrGpuResource, skgpu::ScratchKey, ScratchMapTraits> ScratchMap;
struct UniqueHashTraits {
static const skgpu::UniqueKey& GetKey(const GrGpuResource& r) { return r.getUniqueKey(); }
static uint32_t Hash(const skgpu::UniqueKey& key) { return key.hash(); }
};
typedef SkTDynamicHash<GrGpuResource, skgpu::UniqueKey, UniqueHashTraits> UniqueHash;
static bool CompareTimestamp(GrGpuResource* const& a, GrGpuResource* const& b) {
return a->cacheAccess().timestamp() < b->cacheAccess().timestamp();
}
static int* AccessResourceIndex(GrGpuResource* const& res) {
return res->cacheAccess().accessCacheIndex();
}
typedef SkMessageBus<skgpu::UniqueKeyInvalidatedMessage, uint32_t>::Inbox InvalidUniqueKeyInbox;
typedef SkTDPQueue<GrGpuResource*, CompareTimestamp, AccessResourceIndex> PurgeableQueue;
typedef SkTDArray<GrGpuResource*> ResourceArray;
GrProxyProvider* fProxyProvider = nullptr;
GrThreadSafeCache* fThreadSafeCache = nullptr;
// Whenever a resource is added to the cache or the result of a cache lookup, fTimestamp is
// assigned as the resource's timestamp and then incremented. fPurgeableQueue orders the
// purgeable resources by this value, and thus is used to purge resources in LRU order.
uint32_t fTimestamp = 0;
PurgeableQueue fPurgeableQueue;
ResourceArray fNonpurgeableResources;
// This map holds all resources that can be used as scratch resources.
ScratchMap fScratchMap;
// This holds all resources that have unique keys.
UniqueHash fUniqueHash;
// our budget, used in purgeAsNeeded()
size_t fMaxBytes = kDefaultMaxSize;
#if GR_CACHE_STATS
int fHighWaterCount = 0;
size_t fHighWaterBytes = 0;
int fBudgetedHighWaterCount = 0;
size_t fBudgetedHighWaterBytes = 0;
#endif
// our current stats for all resources
SkDEBUGCODE(int fCount = 0;)
size_t fBytes = 0;
// our current stats for resources that count against the budget
int fBudgetedCount = 0;
size_t fBudgetedBytes = 0;
size_t fPurgeableBytes = 0;
int fNumBudgetedResourcesFlushWillMakePurgeable = 0;
InvalidUniqueKeyInbox fInvalidUniqueKeyInbox;
UnrefResourceMessage::Bus::Inbox fUnrefResourceInbox;
GrDirectContext::DirectContextID fOwningContextID;
uint32_t fContextUniqueID = SK_InvalidUniqueID;
skgpu::SingleOwner* fSingleOwner = nullptr;
// This resource is allowed to be in the nonpurgeable array for the sake of validate() because
// we're in the midst of converting it to purgeable status.
SkDEBUGCODE(GrGpuResource* fNewlyPurgeableResourceForValidation = nullptr;)
};
class GrResourceCache::ResourceAccess {
private:
ResourceAccess(GrResourceCache* cache) : fCache(cache) { }
ResourceAccess(const ResourceAccess& that) : fCache(that.fCache) { }
ResourceAccess& operator=(const ResourceAccess&) = delete;
/**
* Insert a resource into the cache.
*/
void insertResource(GrGpuResource* resource) { fCache->insertResource(resource); }
/**
* Removes a resource from the cache.
*/
void removeResource(GrGpuResource* resource) { fCache->removeResource(resource); }
/**
* Adds a ref to a resource with proper tracking if the resource has 0 refs prior to
* adding the ref.
*/
void refResource(GrGpuResource* resource) { fCache->refResource(resource); }
/**
* Notifications that should be sent to the cache when the ref/io cnt status of resources
* changes.
*/
enum RefNotificationFlags {
/** All types of refs on the resource have reached zero. */
kAllCntsReachedZero_RefNotificationFlag = 0x1,
/** The normal (not pending IO type) ref cnt has reached zero. */
kRefCntReachedZero_RefNotificationFlag = 0x2,
};
/**
* Called by GrGpuResources when they detect one of their ref cnts have reached zero. This may
* either be the main ref or the command buffer usage ref.
*/
void notifyARefCntReachedZero(GrGpuResource* resource,
GrGpuResource::LastRemovedRef removedRef) {
fCache->notifyARefCntReachedZero(resource, removedRef);
}
/**
* Called by GrGpuResources to change their unique keys.
*/
void changeUniqueKey(GrGpuResource* resource, const skgpu::UniqueKey& newKey) {
fCache->changeUniqueKey(resource, newKey);
}
/**
* Called by a GrGpuResource to remove its unique key.
*/
void removeUniqueKey(GrGpuResource* resource) { fCache->removeUniqueKey(resource); }
/**
* Called by a GrGpuResource when it removes its scratch key.
*/
void willRemoveScratchKey(const GrGpuResource* resource) {
fCache->willRemoveScratchKey(resource);
}
/**
* Called by GrGpuResources when they change from budgeted to unbudgeted or vice versa.
*/
void didChangeBudgetStatus(GrGpuResource* resource) { fCache->didChangeBudgetStatus(resource); }
// No taking addresses of this type.
const ResourceAccess* operator&() const;
ResourceAccess* operator&();
GrResourceCache* fCache;
friend class GrGpuResource; // To access all the proxy inline methods.
friend class GrResourceCache; // To create this type.
};
static inline bool SkShouldPostMessageToBus(const GrResourceCache::UnrefResourceMessage& msg,
GrDirectContext::DirectContextID potentialRecipient) {
return potentialRecipient == msg.recipient();
}
inline GrResourceCache::ResourceAccess GrResourceCache::resourceAccess() {
return ResourceAccess(this);
}
#endif