GrResourceKey resourceKey = GrStencilBuffer::ComputeKey(sb->width(),
sb->height(),
sb->numSamples());
- fTextureCache->create(resourceKey, sb);
+ fTextureCache->addResource(resourceKey, sb);
}
GrStencilBuffer* GrContext::findStencilBuffer(int width, int height,
}
if (NULL != texture) {
- fTextureCache->create(resourceKey, texture);
+ fTextureCache->addResource(resourceKey, texture);
}
return texture;
do {
GrResourceKey key = GrTexture::ComputeKey(fGpu, NULL, desc, cacheData, true);
- resource = fTextureCache->find(key);
+ // Ensure we have exclusive access to the texture so future 'find' calls don't return it
+ resource = fTextureCache->find(key, GrResourceCache::kHide_OwnershipFlag);
// if we miss, relax the fit of the flags...
// then try doubling width... then height.
if (NULL != resource || kExact_ScratchTexMatch == match) {
texture->desc(),
cacheData,
true);
- fTextureCache->create(key, texture);
+ // Make the resource exclusive so future 'find' calls don't return it
+ fTextureCache->addResource(key, texture, GrResourceCache::kHide_OwnershipFlag);
resource = texture;
}
}
- // If the caller gives us the same desc twice we don't want to return the
- // same texture the second time (unless it was previously released). So
- // make it exclusive to hide it from future searches.
- if (NULL != resource) {
- fTextureCache->makeExclusive(resource->getCacheEntry());
- }
-
return static_cast<GrTexture*>(resource);
}
fCache.remove(entry->fKey, entry);
// remove from our llist
- this->internalDetach(entry, false);
+ this->internalDetach(entry);
delete entry;
}
}
void GrResourceCache::internalDetach(GrResourceEntry* entry,
- bool clientDetach) {
+ BudgetBehaviors behavior) {
fList.remove(entry);
// update our stats
- if (clientDetach) {
+ if (kIgnore_BudgetBehavior == behavior) {
fClientDetachedCount += 1;
fClientDetachedBytes += entry->resource()->sizeInBytes();
#endif
} else {
+ GrAssert(kAccountFor_BudgetBehavior == behavior);
+
fEntryCount -= 1;
fEntryBytes -= entry->resource()->sizeInBytes();
}
}
void GrResourceCache::attachToHead(GrResourceEntry* entry,
- bool clientReattach) {
+ BudgetBehaviors behavior) {
fList.addToHead(entry);
// update our stats
- if (clientReattach) {
+ if (kIgnore_BudgetBehavior == behavior) {
fClientDetachedCount -= 1;
fClientDetachedBytes -= entry->resource()->sizeInBytes();
} else {
+ GrAssert(kAccountFor_BudgetBehavior == behavior);
+
fEntryCount += 1;
fEntryBytes += entry->resource()->sizeInBytes();
}
}
-GrResource* GrResourceCache::find(const GrResourceKey& key) {
+// This functor just searches for an entry with only a single ref (from
+// the texture cache itself). Presumably in this situation no one else
+// is relying on the texture.
+class GrTFindUnreffedFunctor {
+public:
+ bool operator()(const GrResourceEntry* entry) const {
+ return 1 == entry->resource()->getRefCnt();
+ }
+};
+
+GrResource* GrResourceCache::find(const GrResourceKey& key, uint32_t ownershipFlags) {
GrAutoResourceCacheValidate atcv(this);
- GrResourceEntry* entry = fCache.find(key);
+ GrResourceEntry* entry = NULL;
+
+ if (ownershipFlags & kNoOtherOwners_OwnershipFlag) {
+ GrTFindUnreffedFunctor functor;
+
+ entry = fCache.find<GrTFindUnreffedFunctor>(key, functor);
+ } else {
+ entry = fCache.find(key);
+ }
+
if (NULL == entry) {
return NULL;
}
- this->internalDetach(entry, false);
- this->attachToHead(entry, false);
+ if (ownershipFlags & kHide_OwnershipFlag) {
+ this->makeExclusive(entry);
+ } else {
+ // Make this resource MRU
+ this->internalDetach(entry);
+ this->attachToHead(entry);
+ }
return entry->fResource;
}
return NULL != fCache.find(key);
}
-void GrResourceCache::create(const GrResourceKey& key, GrResource* resource) {
+void GrResourceCache::addResource(const GrResourceKey& key,
+ GrResource* resource,
+ uint32_t ownershipFlags) {
GrAssert(NULL == resource->getCacheEntry());
// we don't expect to create new resources during a purge. In theory
// this could cause purgeAsNeeded() into an infinite loop (e.g.
GrResourceEntry* entry = SkNEW_ARGS(GrResourceEntry, (key, resource));
resource->setCacheEntry(entry);
- this->attachToHead(entry, false);
+ this->attachToHead(entry);
fCache.insert(key, entry);
#if GR_DUMP_TEXTURE_UPLOAD
GrPrintf("--- add resource to cache %p, count=%d bytes= %d %d\n",
entry, fEntryCount, resource->sizeInBytes(), fEntryBytes);
#endif
+
+ if (ownershipFlags & kHide_OwnershipFlag) {
+ this->makeExclusive(entry);
+ }
+
}
void GrResourceCache::makeExclusive(GrResourceEntry* entry) {
GrAutoResourceCacheValidate atcv(this);
- this->internalDetach(entry, true);
+ // When scratch textures are detached (to hide them from future finds) they
+ // still count against the resource budget
+ this->internalDetach(entry, kIgnore_BudgetBehavior);
fCache.remove(entry->key(), entry);
#if GR_DEBUG
#endif
if (entry->resource()->isValid()) {
- attachToHead(entry, true);
+ // Since scratch textures still count against the cache budget even
+ // when they have been removed from the cache, re-adding them doesn't
+ // alter the budget information.
+ attachToHead(entry, kIgnore_BudgetBehavior);
fCache.insert(entry->key(), entry);
} else {
this->removeInvalidResource(entry);
fCache.remove(entry->key(), entry);
// remove from our llist
- this->internalDetach(entry, false);
+ this->internalDetach(entry);
#if GR_DUMP_TEXTURE_UPLOAD
GrPrintf("--- ~resource from cache %p [%d %d]\n",
*/
size_t getCachedResourceBytes() const { return fEntryBytes; }
+ // For a found or added resource to be completely exclusive to the caller
+ // both the kNoOtherOwners and kHide flags need to be specified
+ enum OwnershipFlags {
+ kNoOtherOwners_OwnershipFlag = 0x1, // found/added resource has no other owners
+ kHide_OwnershipFlag = 0x2 // found/added resource is hidden from future 'find's
+ };
+
/**
* Search for an entry with the same Key. If found, return it.
* If not found, return null.
+ * If ownershipFlags includes kNoOtherOwners and a resource is returned
+ * then that resource has no other refs to it.
+ * If ownershipFlags includes kHide and a resource is returned then that
+ * resource will not be returned from future 'find' calls until it is
+ * 'freed' (and recycled) or makeNonExclusive is called.
+ * For a resource to be completely exclusive to a caller both kNoOtherOwners
+ * and kHide must be specified.
*/
- GrResource* find(const GrResourceKey& key);
+ GrResource* find(const GrResourceKey& key,
+ uint32_t ownershipFlags = 0);
/**
- * Create a new cache entry, based on the provided key and resource, and
- * return it.
+ * Add the new resource to the cache (by creating a new cache entry based
+ * on the provided key and resource).
*
* Ownership of the resource is transferred to the resource cache,
* which will unref() it when it is purged or deleted.
+ *
+ * If ownershipFlags includes kHide, subsequent calls to 'find' will not
+ * return 'resource' until it is 'freed' (and recycled) or makeNonExclusive
+ * is called.
*/
- void create(const GrResourceKey&, GrResource*);
+ void addResource(const GrResourceKey& key,
+ GrResource* resource,
+ uint32_t ownershipFlags = 0);
/**
* Determines if the cache contains an entry matching a key. If a matching
#endif
private:
- void internalDetach(GrResourceEntry*, bool);
- void attachToHead(GrResourceEntry*, bool);
+ enum BudgetBehaviors {
+ kAccountFor_BudgetBehavior,
+ kIgnore_BudgetBehavior
+ };
+
+ void internalDetach(GrResourceEntry*, BudgetBehaviors behavior = kAccountFor_BudgetBehavior);
+ void attachToHead(GrResourceEntry*, BudgetBehaviors behavior = kAccountFor_BudgetBehavior);
void removeInvalidResource(GrResourceEntry* entry);
projects / platform / upstream / libSkiaSharp.git / commitdiff