Remove maxCount resource cache limit
Change-Id: I0f1064c8433d69e24ca3d5b970c99d539dc1dadd
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/238442
Commit-Queue: Robert Phillips <robertphillips@google.com>
Reviewed-by: Brian Salomon <bsalomon@google.com>
diff --git a/src/gpu/GrContext.cpp b/src/gpu/GrContext.cpp
index 4e927fc..78e302f 100644
--- a/src/gpu/GrContext.cpp
+++ b/src/gpu/GrContext.cpp
@@ -298,20 +298,29 @@
//////////////////////////////////////////////////////////////////////////////
-// DDL TODO: remove 'maxResources'
void GrContext::getResourceCacheLimits(int* maxResources, size_t* maxResourceBytes) const {
ASSERT_SINGLE_OWNER
if (maxResources) {
- *maxResources = fResourceCache->getMaxResourceCount();
+ *maxResources = -1;
}
if (maxResourceBytes) {
- *maxResourceBytes = fResourceCache->getMaxResourceBytes();
+ *maxResourceBytes = this->getResourceCacheLimit();
}
}
-void GrContext::setResourceCacheLimits(int maxResources, size_t maxResourceBytes) {
+size_t GrContext::getResourceCacheLimit() const {
ASSERT_SINGLE_OWNER
- fResourceCache->setLimits(maxResources, maxResourceBytes);
+ return fResourceCache->getMaxResourceBytes();
+}
+
+void GrContext::setResourceCacheLimits(int unused, size_t maxResourceBytes) {
+ ASSERT_SINGLE_OWNER
+ this->setResourceCacheLimit(maxResourceBytes);
+}
+
+void GrContext::setResourceCacheLimit(size_t maxResourceBytes) {
+ ASSERT_SINGLE_OWNER
+ fResourceCache->setLimit(maxResourceBytes);
}
//////////////////////////////////////////////////////////////////////////////
diff --git a/src/gpu/GrResourceCache.cpp b/src/gpu/GrResourceCache.cpp
index 0f7deb3..4a31a8e 100644
--- a/src/gpu/GrResourceCache.cpp
+++ b/src/gpu/GrResourceCache.cpp
@@ -123,8 +123,7 @@
this->releaseAll();
}
-void GrResourceCache::setLimits(int count, size_t bytes) {
- fMaxCount = count;
+void GrResourceCache::setLimit(size_t bytes) {
fMaxBytes = bytes;
this->purgeAsNeeded();
}
@@ -489,8 +488,7 @@
if (!resource->resourcePriv().refsWrappedObjects() &&
resource->resourcePriv().getScratchKey().isValid()) {
// We won't purge an existing resource to make room for this one.
- if (fBudgetedCount < fMaxCount &&
- fBudgetedBytes + resource->gpuMemorySize() <= fMaxBytes) {
+ if (this->wouldFit(resource->gpuMemorySize())) {
resource->resourcePriv().makeBudgeted();
return;
}
@@ -807,14 +805,13 @@
this->getStats(&stats);
- float countUtilization = (100.f * fBudgetedCount) / fMaxCount;
float byteUtilization = (100.f * fBudgetedBytes) / fMaxBytes;
- out->appendf("Budget: %d items %d bytes\n", fMaxCount, (int)fMaxBytes);
+ out->appendf("Budget: %d bytes\n", (int)fMaxBytes);
out->appendf("\t\tEntry Count: current %d"
- " (%d budgeted, %d wrapped, %d locked, %d scratch %.2g%% full), high %d\n",
+ " (%d budgeted, %d wrapped, %d locked, %d scratch), high %d\n",
stats.fTotal, fBudgetedCount, stats.fWrapped, stats.fNumNonPurgeable,
- stats.fScratch, countUtilization, fHighWaterCount);
+ stats.fScratch, fHighWaterCount);
out->appendf("\t\tEntry Bytes: current %d (budgeted %d, %.2g%% full, %d unbudgeted) high %d\n",
SkToInt(fBytes), SkToInt(fBudgetedBytes), byteUtilization,
SkToInt(stats.fUnbudgetedSize), SkToInt(fHighWaterBytes));
diff --git a/src/gpu/GrResourceCache.h b/src/gpu/GrResourceCache.h
index 3734d39..5dee9ec 100644
--- a/src/gpu/GrResourceCache.h
+++ b/src/gpu/GrResourceCache.h
@@ -59,8 +59,6 @@
GrResourceCache(const GrCaps*, GrSingleOwner* owner, uint32_t contextUniqueID);
~GrResourceCache();
- // Default maximum number of budgeted resources in the cache.
- static const int kDefaultMaxCount = 2 * (1 << 12);
// Default maximum number of bytes of gpu memory of budgeted resources in the cache.
static const size_t kDefaultMaxSize = 96 * (1 << 20);
@@ -71,8 +69,8 @@
/** Unique ID of the owning GrContext. */
uint32_t contextUniqueID() const { return fContextUniqueID; }
- /** Sets the cache limits in terms of number of resources and max gpu memory byte size. */
- void setLimits(int count, size_t bytes);
+ /** Sets the max gpu memory byte size of the cache. */
+ void setLimit(size_t bytes);
/**
* Returns the number of resources.
@@ -102,11 +100,6 @@
size_t getBudgetedResourceBytes() const { return fBudgetedBytes; }
/**
- * Returns the cached resources count budget.
- */
- int getMaxResourceCount() const { return fMaxCount; }
-
- /**
* Returns the number of bytes consumed by cached resources.
*/
size_t getMaxResourceBytes() const { return fMaxBytes; }
@@ -177,7 +170,7 @@
/** Purge all resources not used since the passed in time. */
void purgeResourcesNotUsedSince(GrStdSteadyClock::time_point);
- bool overBudget() const { return fBudgetedBytes > fMaxBytes || fBudgetedCount > fMaxCount; }
+ bool overBudget() const { return fBudgetedBytes > fMaxBytes; }
/**
* Purge unlocked resources from the cache until the the provided byte count has been reached
@@ -273,9 +266,7 @@
void addToNonpurgeableArray(GrGpuResource*);
void removeFromNonpurgeableArray(GrGpuResource*);
- bool wouldFit(size_t bytes) {
- return fBudgetedBytes+bytes <= fMaxBytes && fBudgetedCount+1 <= fMaxCount;
- }
+ bool wouldFit(size_t bytes) const { return fBudgetedBytes+bytes <= fMaxBytes; }
uint32_t getNextTimestamp();
@@ -353,7 +344,6 @@
UniqueHash fUniqueHash;
// our budget, used in purgeAsNeeded()
- int fMaxCount = kDefaultMaxCount;
size_t fMaxBytes = kDefaultMaxSize;
#if GR_CACHE_STATS
diff --git a/src/gpu/SkGpuDevice.cpp b/src/gpu/SkGpuDevice.cpp
index 1919248..f65f184 100644
--- a/src/gpu/SkGpuDevice.cpp
+++ b/src/gpu/SkGpuDevice.cpp
@@ -726,8 +726,7 @@
// assumption here is that sw bitmap size is a good proxy for its size as
// a texture
size_t bmpSize = area * sizeof(SkPMColor); // assume 32bit pixels
- size_t cacheSize;
- fContext->getResourceCacheLimits(nullptr, &cacheSize);
+ size_t cacheSize = fContext->getResourceCacheLimit();
if (bmpSize < cacheSize / 2) {
return false;
}
diff --git a/src/gpu/vk/GrVkSecondaryCBDrawContext.cpp b/src/gpu/vk/GrVkSecondaryCBDrawContext.cpp
index 3a72b2a..971f71d 100644
--- a/src/gpu/vk/GrVkSecondaryCBDrawContext.cpp
+++ b/src/gpu/vk/GrVkSecondaryCBDrawContext.cpp
@@ -78,9 +78,7 @@
GrRenderTargetContext* rtc = fDevice->accessRenderTargetContext();
GrContext* ctx = fDevice->context();
- int maxResourceCount;
- size_t maxResourceBytes;
- ctx->getResourceCacheLimits(&maxResourceCount, &maxResourceBytes);
+ size_t maxResourceBytes = ctx->getResourceCacheLimit();
// We current don't support textured GrVkSecondaryCBDrawContexts.
SkASSERT(!rtc->asTextureProxy());
@@ -123,9 +121,7 @@
// As long as the current state in the context allows for greater or equal resources,
// we allow the DDL to be replayed.
// DDL TODO: should we just remove the resource check and ignore the cache limits on playback?
- int maxResourceCount;
- size_t maxResourceBytes;
- ctx->getResourceCacheLimits(&maxResourceCount, &maxResourceBytes);
+ size_t maxResourceBytes = ctx->getResourceCacheLimit();
if (characterization.isTextureable()) {
// We don't support textureable DDL when rendering to a GrVkSecondaryCBDrawContext.