diff options
22 files changed, 234 insertions, 230 deletions
diff --git a/bench/GrResourceCacheBench.cpp b/bench/GrResourceCacheBench.cpp index e1ec90d511..e30dd3052f 100644 --- a/bench/GrResourceCacheBench.cpp +++ b/bench/GrResourceCacheBench.cpp @@ -14,181 +14,63 @@ #include "GrContext.h" #include "GrGpu.h" #include "GrResourceCache2.h" -#include "GrStencilBuffer.h" -#include "GrTexture.h" -#include "GrTexturePriv.h" #include "SkCanvas.h" enum { - CACHE_SIZE_COUNT = 2048, - CACHE_SIZE_BYTES = 2 * 1024 * 1024, + CACHE_SIZE_COUNT = 4096, }; -class StencilResource : public GrGpuResource { +class BenchResource : public GrGpuResource { public: - SK_DECLARE_INST_COUNT(StencilResource); - StencilResource(GrGpu* gpu, int id) - : INHERITED(gpu, false) - , fID(id) { + SK_DECLARE_INST_COUNT(BenchResource); + BenchResource (GrGpu* gpu) + : INHERITED(gpu, false) { this->registerWithCache(); } - static GrResourceKey ComputeKey(int width, int height, int sampleCnt) { - return GrStencilBuffer::ComputeKey(width, height, sampleCnt); - } - - int fID; - -private: - virtual size_t onGpuMemorySize() const SK_OVERRIDE { - return 100 + ((fID % 1 == 0) ? -5 : 6); - } - - typedef GrGpuResource INHERITED; -}; - -class TextureResource : public GrGpuResource { -public: - SK_DECLARE_INST_COUNT(TextureResource); - TextureResource(GrGpu* gpu, int id) - : INHERITED(gpu, false) - , fID(id) { - this->registerWithCache(); - } - - static GrResourceKey ComputeKey(const GrSurfaceDesc& desc) { + static GrResourceKey ComputeKey(int i) { GrCacheID::Key key; memset(&key, 0, sizeof(key)); - key.fData32[0] = (desc.fWidth) | (desc.fHeight << 16); - key.fData32[1] = desc.fConfig | desc.fSampleCnt << 16; - key.fData32[2] = desc.fFlags; + key.fData32[0] = i; static int gType = GrResourceKey::GenerateResourceType(); static int gDomain = GrCacheID::GenerateDomain(); return GrResourceKey(GrCacheID(gDomain, key), gType, 0); } - int fID; private: - virtual size_t onGpuMemorySize() const SK_OVERRIDE { - return 100 + ((fID % 1 == 0) ? -40 : 33); - } + size_t onGpuMemorySize() const SK_OVERRIDE { return 100; } typedef GrGpuResource INHERITED; }; -static void get_stencil(int i, int* w, int* h, int* s) { - *w = i % 1024; - *h = i * 2 % 1024; - *s = i % 1 == 0 ? 0 : 4; -} - -static void get_texture_desc(int i, GrSurfaceDesc* desc) { - desc->fFlags = kRenderTarget_GrSurfaceFlag | kNoStencil_GrSurfaceFlag; - desc->fWidth = i % 1024; - desc->fHeight = i * 2 % 1024; - desc->fConfig = static_cast<GrPixelConfig>(i % (kLast_GrPixelConfig + 1)); - desc->fSampleCnt = ((i % 2) == 0) ? 0 : 4; -} - static void populate_cache(GrGpu* gpu, int resourceCount) { for (int i = 0; i < resourceCount; ++i) { - int w, h, s; - get_stencil(i, &w, &h, &s); - GrResourceKey key = GrStencilBuffer::ComputeKey(w, h, s); - GrGpuResource* resource = SkNEW_ARGS(StencilResource, (gpu, i)); + GrResourceKey key = BenchResource::ComputeKey(i); + GrGpuResource* resource = SkNEW_ARGS(BenchResource, (gpu)); resource->cacheAccess().setContentKey(key); resource->unref(); } - - for (int i = 0; i < resourceCount; ++i) { - GrSurfaceDesc desc; - get_texture_desc(i, &desc); - GrResourceKey key = TextureResource::ComputeKey(desc); - GrGpuResource* resource = SkNEW_ARGS(TextureResource, (gpu, i)); - resource->cacheAccess().setContentKey(key); - resource->unref(); - } -} - -static void check_cache_contents_or_die(GrResourceCache2* cache, int k) { - // Benchmark find calls that succeed. - { - GrSurfaceDesc desc; - get_texture_desc(k, &desc); - GrResourceKey key = TextureResource::ComputeKey(desc); - SkAutoTUnref<GrGpuResource> item(cache->findAndRefContentResource(key)); - if (!item) { - SkFAIL("cache add does not work as expected"); - return; - } - if (static_cast<TextureResource*>(item.get())->fID != k) { - SkFAIL("cache add does not work as expected"); - return; - } - } - { - int w, h, s; - get_stencil(k, &w, &h, &s); - GrResourceKey key = StencilResource::ComputeKey(w, h, s); - SkAutoTUnref<GrGpuResource> item(cache->findAndRefContentResource(key)); - if (!item) { - SkFAIL("cache add does not work as expected"); - return; - } - if (static_cast<TextureResource*>(item.get())->fID != k) { - SkFAIL("cache add does not work as expected"); - return; - } - } - - // Benchmark also find calls that always fail. - { - GrSurfaceDesc desc; - get_texture_desc(k, &desc); - desc.fHeight |= 1; - GrResourceKey key = TextureResource::ComputeKey(desc); - SkAutoTUnref<GrGpuResource> item(cache->findAndRefContentResource(key)); - if (item) { - SkFAIL("cache add does not work as expected"); - return; - } - } - { - int w, h, s; - get_stencil(k, &w, &h, &s); - h |= 1; - GrResourceKey key = StencilResource::ComputeKey(w, h, s); - SkAutoTUnref<GrGpuResource> item(cache->findAndRefContentResource(key)); - if (item) { - SkFAIL("cache add does not work as expected"); - return; - } - } } class GrResourceCacheBenchAdd : public Benchmark { - enum { - RESOURCE_COUNT = CACHE_SIZE_COUNT / 2, - }; - public: - virtual bool isSuitableFor(Backend backend) SK_OVERRIDE { + bool isSuitableFor(Backend backend) SK_OVERRIDE { return backend == kNonRendering_Backend; } protected: - virtual const char* onGetName() SK_OVERRIDE { + const char* onGetName() SK_OVERRIDE { return "grresourcecache_add"; } - virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE { + void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE { SkAutoTUnref<GrContext> context(GrContext::CreateMockContext()); if (NULL == context) { return; } // Set the cache budget to be very large so no purging occurs. - context->setResourceCacheLimits(2 * RESOURCE_COUNT, 1 << 30); + context->setResourceCacheLimits(CACHE_SIZE_COUNT, 1 << 30); GrResourceCache2* cache2 = context->getResourceCache2(); @@ -199,15 +81,8 @@ protected: GrGpu* gpu = context->getGpu(); for (int i = 0; i < loops; ++i) { - SkASSERT(0 == cache2->getResourceCount() && 0 == cache2->getResourceBytes()); - - populate_cache(gpu, RESOURCE_COUNT); - - // Check that cache works. - for (int k = 0; k < RESOURCE_COUNT; k += 33) { - check_cache_contents_or_die(cache2, k); - } - cache2->purgeAllUnlocked(); + populate_cache(gpu, CACHE_SIZE_COUNT); + SkASSERT(CACHE_SIZE_COUNT == cache2->getResourceCount()); } } @@ -216,46 +91,52 @@ private: }; class GrResourceCacheBenchFind : public Benchmark { - enum { - RESOURCE_COUNT = CACHE_SIZE_COUNT / 2, - }; - public: - virtual bool isSuitableFor(Backend backend) SK_OVERRIDE { + bool isSuitableFor(Backend backend) SK_OVERRIDE { return backend == kNonRendering_Backend; } protected: - virtual const char* onGetName() SK_OVERRIDE { + const char* onGetName() SK_OVERRIDE { return "grresourcecache_find"; } - virtual void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE { - SkAutoTUnref<GrContext> context(GrContext::CreateMockContext()); - if (NULL == context) { + void onPreDraw() SK_OVERRIDE { + fContext.reset(GrContext::CreateMockContext()); + if (!fContext) { return; } // Set the cache budget to be very large so no purging occurs. - context->setResourceCacheLimits(2 * RESOURCE_COUNT, 1 << 30); + fContext->setResourceCacheLimits(CACHE_SIZE_COUNT, 1 << 30); - GrResourceCache2* cache2 = context->getResourceCache2(); + GrResourceCache2* cache2 = fContext->getResourceCache2(); // Make sure the cache is empty. cache2->purgeAllUnlocked(); SkASSERT(0 == cache2->getResourceCount() && 0 == cache2->getResourceBytes()); - GrGpu* gpu = context->getGpu(); + GrGpu* gpu = fContext->getGpu(); - populate_cache(gpu, RESOURCE_COUNT); + populate_cache(gpu, CACHE_SIZE_COUNT); + } + void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE { + if (!fContext) { + return; + } + GrResourceCache2* cache2 = fContext->getResourceCache2(); + SkASSERT(CACHE_SIZE_COUNT == cache2->getResourceCount()); for (int i = 0; i < loops; ++i) { - for (int k = 0; k < RESOURCE_COUNT; ++k) { - check_cache_contents_or_die(cache2, k); + for (int k = 0; k < CACHE_SIZE_COUNT; ++k) { + GrResourceKey key = BenchResource::ComputeKey(k); + SkAutoTUnref<GrGpuResource> resource(cache2->findAndRefContentResource(key)); + SkASSERT(resource); } } } private: + SkAutoTUnref<GrContext> fContext; typedef Benchmark INHERITED; }; diff --git a/expectations/gm/Test-Android-GalaxyS4-SGX544-Arm7-Debug/expected-results.json b/expectations/gm/Test-Android-GalaxyS4-SGX544-Arm7-Debug/expected-results.json index 79c32f0ac8..5b7b400306 100644 --- a/expectations/gm/Test-Android-GalaxyS4-SGX544-Arm7-Debug/expected-results.json +++ b/expectations/gm/Test-Android-GalaxyS4-SGX544-Arm7-Debug/expected-results.json @@ -3857,7 +3857,7 @@ "allowed-digests": [ [ "bitmap-64bitMD5", - 4938590834664658305 + 18165407505633347407 ] ], "reviewed-by-human": true @@ -5852,7 +5852,7 @@ "allowed-digests": [ [ "bitmap-64bitMD5", - 17492314805851855065 + 14771652249910100761 ] ], "reviewed-by-human": true @@ -5970,7 +5970,7 @@ "allowed-digests": [ [ "bitmap-64bitMD5", - 571194008531839949 + 5148862615526465916 ] ], "ignore-failure": false, diff --git a/expectations/gm/Test-Android-GalaxyS4-SGX544-Arm7-Release/expected-results.json b/expectations/gm/Test-Android-GalaxyS4-SGX544-Arm7-Release/expected-results.json index 8ab1e2f777..5072d20803 100644 --- a/expectations/gm/Test-Android-GalaxyS4-SGX544-Arm7-Release/expected-results.json +++ b/expectations/gm/Test-Android-GalaxyS4-SGX544-Arm7-Release/expected-results.json @@ -3857,7 +3857,7 @@ "allowed-digests": [ [ "bitmap-64bitMD5", - 4938590834664658305 + 18165407505633347407 ] ], "reviewed-by-human": true @@ -5844,7 +5844,7 @@ "allowed-digests": [ [ "bitmap-64bitMD5", - 167979044054175148 + 3695575234877280011 ] ], "reviewed-by-human": true @@ -5962,7 +5962,7 @@ "allowed-digests": [ [ "bitmap-64bitMD5", - 9298514044054867967 + 5148862615526465916 ] ], "ignore-failure": false, diff --git a/expectations/gm/Test-Ubuntu12-ShuttleA-GTX660-x86-Debug/expected-results.json b/expectations/gm/Test-Ubuntu12-ShuttleA-GTX660-x86-Debug/expected-results.json index 030afb41e6..2d955b41fc 100644 --- a/expectations/gm/Test-Ubuntu12-ShuttleA-GTX660-x86-Debug/expected-results.json +++ b/expectations/gm/Test-Ubuntu12-ShuttleA-GTX660-x86-Debug/expected-results.json @@ -7059,7 +7059,7 @@ "allowed-digests": [ [ "bitmap-64bitMD5", - 10566742216990551435 + 11009857797348161863 ] ], "reviewed-by-human": true diff --git a/expectations/gm/Test-Ubuntu12-ShuttleA-GTX660-x86-Release/expected-results.json b/expectations/gm/Test-Ubuntu12-ShuttleA-GTX660-x86-Release/expected-results.json index c7d8ba1545..03a5e8fe2c 100644 --- a/expectations/gm/Test-Ubuntu12-ShuttleA-GTX660-x86-Release/expected-results.json +++ b/expectations/gm/Test-Ubuntu12-ShuttleA-GTX660-x86-Release/expected-results.json @@ -7061,7 +7061,7 @@ "allowed-digests": [ [ "bitmap-64bitMD5", - 10566742216990551435 + 11009857797348161863 ] ], "reviewed-by-human": true diff --git a/expectations/gm/Test-Ubuntu12-ShuttleA-GTX660-x86_64-Debug/expected-results.json b/expectations/gm/Test-Ubuntu12-ShuttleA-GTX660-x86_64-Debug/expected-results.json index 75e57f344f..b364463578 100644 --- a/expectations/gm/Test-Ubuntu12-ShuttleA-GTX660-x86_64-Debug/expected-results.json +++ b/expectations/gm/Test-Ubuntu12-ShuttleA-GTX660-x86_64-Debug/expected-results.json @@ -7131,13 +7131,10 @@ "allowed-digests": [ [ "bitmap-64bitMD5", - 10566742216990551435 + 11009857797348161863 ] ], - "bugs": [ - 2325 - ], - "reviewed-by-human": false + "reviewed-by-human": true }, "dashing2_pdf-poppler.png": { "allowed-digests": [ diff --git a/expectations/gm/Test-Ubuntu12-ShuttleA-GTX660-x86_64-Release/expected-results.json b/expectations/gm/Test-Ubuntu12-ShuttleA-GTX660-x86_64-Release/expected-results.json index 44e94cd374..517640fae7 100644 --- a/expectations/gm/Test-Ubuntu12-ShuttleA-GTX660-x86_64-Release/expected-results.json +++ b/expectations/gm/Test-Ubuntu12-ShuttleA-GTX660-x86_64-Release/expected-results.json @@ -7131,13 +7131,10 @@ "allowed-digests": [ [ "bitmap-64bitMD5", - 10566742216990551435 + 11009857797348161863 ] ], - "bugs": [ - 2325 - ], - "reviewed-by-human": false + "reviewed-by-human": true }, "dashing2_pdf-poppler.png": { "allowed-digests": [ diff --git a/expectations/gm/Test-Win8-ShuttleA-GTX660-x86-Release/expected-results.json b/expectations/gm/Test-Win8-ShuttleA-GTX660-x86-Release/expected-results.json index a28354c42d..521399e0ac 100644 --- a/expectations/gm/Test-Win8-ShuttleA-GTX660-x86-Release/expected-results.json +++ b/expectations/gm/Test-Win8-ShuttleA-GTX660-x86-Release/expected-results.json @@ -7116,10 +7116,10 @@ "allowed-digests": [ [ "bitmap-64bitMD5", - 10566742216990551435 + 11009857797348161863 ] ], - "reviewed-by-human": false + "reviewed-by-human": true }, "dashing2_pdf-poppler.png": { "allowed-digests": [ @@ -11911,10 +11911,10 @@ "allowed-digests": [ [ "bitmap-64bitMD5", - 17326560431224736462 + 12821620961617303185 ] ], - "reviewed-by-human": false + "reviewed-by-human": true }, "glyph_pos_n_b_nvprmsaa4.png": { "allowed-digests": [ diff --git a/expectations/gm/Test-Win8-ShuttleA-GTX660-x86_64-Debug/expected-results.json b/expectations/gm/Test-Win8-ShuttleA-GTX660-x86_64-Debug/expected-results.json index 6deffd9898..0dc0fbffdc 100644 --- a/expectations/gm/Test-Win8-ShuttleA-GTX660-x86_64-Debug/expected-results.json +++ b/expectations/gm/Test-Win8-ShuttleA-GTX660-x86_64-Debug/expected-results.json @@ -7116,10 +7116,10 @@ "allowed-digests": [ [ "bitmap-64bitMD5", - 10566742216990551435 + 11009857797348161863 ] ], - "reviewed-by-human": false + "reviewed-by-human": true }, "dashing2_pdf-poppler.png": { "allowed-digests": [ @@ -11911,10 +11911,10 @@ "allowed-digests": [ [ "bitmap-64bitMD5", - 17326560431224736462 + 12821620961617303185 ] ], - "reviewed-by-human": false + "reviewed-by-human": true }, "glyph_pos_n_b_nvprmsaa4.png": { "allowed-digests": [ diff --git a/expectations/gm/Test-Win8-ShuttleA-GTX660-x86_64-Release/expected-results.json b/expectations/gm/Test-Win8-ShuttleA-GTX660-x86_64-Release/expected-results.json index 53cc5e0908..502191a913 100644 --- a/expectations/gm/Test-Win8-ShuttleA-GTX660-x86_64-Release/expected-results.json +++ b/expectations/gm/Test-Win8-ShuttleA-GTX660-x86_64-Release/expected-results.json @@ -7116,10 +7116,10 @@ "allowed-digests": [ [ "bitmap-64bitMD5", - 10566742216990551435 + 11009857797348161863 ] ], - "reviewed-by-human": false + "reviewed-by-human": true }, "dashing2_pdf-poppler.png": { "allowed-digests": [ @@ -11911,10 +11911,10 @@ "allowed-digests": [ [ "bitmap-64bitMD5", - 17326560431224736462 + 12821620961617303185 ] ], - "reviewed-by-human": false + "reviewed-by-human": true }, "glyph_pos_n_b_nvprmsaa4.png": { "allowed-digests": [ diff --git a/include/gpu/GrContext.h b/include/gpu/GrContext.h index b83df45743..c6dd2d7563 100644 --- a/include/gpu/GrContext.h +++ b/include/gpu/GrContext.h @@ -34,7 +34,6 @@ class GrPath; class GrPathRenderer; class GrResourceEntry; class GrResourceCache2; -class GrStencilBuffer; class GrTestTarget; class GrTextContext; class GrTextureParams; @@ -890,13 +889,6 @@ public: void addGpuTraceMarker(const GrGpuTraceMarker* marker); void removeGpuTraceMarker(const GrGpuTraceMarker* marker); - /** - * Stencil buffers add themselves to the cache using addStencilBuffer. findStencilBuffer is - * called to check the cache for a SB that matches an RT's criteria. - */ - void addStencilBuffer(GrStencilBuffer* sb); - GrStencilBuffer* findAndRefStencilBuffer(int width, int height, int sampleCnt); - GrPathRenderer* getPathRenderer( const GrDrawTarget* target, const GrDrawState*, diff --git a/include/gpu/GrGpuResource.h b/include/gpu/GrGpuResource.h index 806a45aa11..659b767616 100644 --- a/include/gpu/GrGpuResource.h +++ b/include/gpu/GrGpuResource.h @@ -223,6 +223,7 @@ private: bool setContentKey(const GrResourceKey& contentKey); void setBudgeted(bool countsAgainstBudget); void notifyIsPurgable() const; + void removeScratchKey(); #ifdef SK_DEBUG friend class GrGpu; // for assert in GrGpu to access getGpu diff --git a/src/gpu/GrContext.cpp b/src/gpu/GrContext.cpp index 657e57da33..607d3c3cc7 100755 --- a/src/gpu/GrContext.cpp +++ b/src/gpu/GrContext.cpp @@ -24,7 +24,6 @@ #include "GrPathUtils.h" #include "GrResourceCache2.h" #include "GrSoftwarePathRenderer.h" -#include "GrStencilBuffer.h" #include "GrStencilAndCoverTextContext.h" #include "GrStrokeInfo.h" #include "GrSurfacePriv.h" @@ -252,22 +251,6 @@ bool GrContext::isTextureInCache(const GrSurfaceDesc& desc, return fResourceCache2->hasContentKey(resourceKey); } -void GrContext::addStencilBuffer(GrStencilBuffer* sb) { - // TODO: Make GrStencilBuffers use the scratch mechanism rather than content keys. - ASSERT_OWNED_RESOURCE(sb); - - GrResourceKey resourceKey = GrStencilBuffer::ComputeKey(sb->width(), - sb->height(), - sb->numSamples()); - SkAssertResult(sb->cacheAccess().setContentKey(resourceKey)); -} - -GrStencilBuffer* GrContext::findAndRefStencilBuffer(int width, int height, int sampleCnt) { - GrResourceKey resourceKey = GrStencilBuffer::ComputeKey(width, height, sampleCnt); - GrGpuResource* resource = this->findAndRefCachedResource(resourceKey); - return static_cast<GrStencilBuffer*>(resource); -} - static void stretch_image(void* dst, int dstW, int dstH, diff --git a/src/gpu/GrGpu.cpp b/src/gpu/GrGpu.cpp index 2bda594b9a..6b742c4cc3 100644 --- a/src/gpu/GrGpu.cpp +++ b/src/gpu/GrGpu.cpp @@ -13,14 +13,12 @@ #include "GrContext.h" #include "GrDrawTargetCaps.h" #include "GrIndexBuffer.h" +#include "GrResourceCache2.h" #include "GrStencilBuffer.h" #include "GrVertexBuffer.h" //////////////////////////////////////////////////////////////////////////////// -#define DEBUG_INVAL_BUFFER 0xdeadcafe -#define DEBUG_INVAL_START_IDX -1 - GrGpu::GrGpu(GrContext* context) : fResetTimestamp(kExpiredTimestamp+1) , fResetBits(kAll_GrBackendState) @@ -78,8 +76,9 @@ GrTexture* GrGpu::createTexture(const GrSurfaceDesc& desc, bool GrGpu::attachStencilBufferToRenderTarget(GrRenderTarget* rt) { SkASSERT(NULL == rt->getStencilBuffer()); - SkAutoTUnref<GrStencilBuffer> sb( - this->getContext()->findAndRefStencilBuffer(rt->width(), rt->height(), rt->numSamples())); + GrResourceKey sbKey = GrStencilBuffer::ComputeKey(rt->width(), rt->height(), rt->numSamples()); + SkAutoTUnref<GrStencilBuffer> sb(static_cast<GrStencilBuffer*>( + this->getContext()->getResourceCache2()->findAndRefScratchResource(sbKey))); if (sb) { rt->setStencilBuffer(sb); bool attached = this->attachStencilBufferToRenderTarget(sb, rt); diff --git a/src/gpu/GrGpuResource.cpp b/src/gpu/GrGpuResource.cpp index 8dbbd83ef5..cc24335184 100644 --- a/src/gpu/GrGpuResource.cpp +++ b/src/gpu/GrGpuResource.cpp @@ -128,6 +128,13 @@ void GrGpuResource::setScratchKey(const GrResourceKey& scratchKey) { fScratchKey = scratchKey; } +void GrGpuResource::removeScratchKey() { + if (!this->wasDestroyed() && !fScratchKey.isNullScratch()) { + get_resource_cache2(fGpu)->resourceAccess().willRemoveScratchKey(this); + fScratchKey = GrResourceKey::NullScratchKey(); + } +} + uint32_t GrGpuResource::CreateUniqueID() { static int32_t gUniqueID = SK_InvalidUniqueID; uint32_t id; diff --git a/src/gpu/GrGpuResourceCacheAccess.h b/src/gpu/GrGpuResourceCacheAccess.h index c55bb07774..e220e5f263 100644 --- a/src/gpu/GrGpuResourceCacheAccess.h +++ b/src/gpu/GrGpuResourceCacheAccess.h @@ -50,6 +50,12 @@ public: const GrResourceKey& getScratchKey() const { return fResource->fScratchKey; } /** + * If the resource has a scratch key, the key will be removed. Since scratch keys are installed + * at resource creation time, this means the resource will never again be used as scratch. + */ + void removeScratchKey() const { fResource->removeScratchKey(); } + + /** * If the resource is currently cached by a content key, the key is returned, otherwise NULL. */ const GrResourceKey* getContentKey() const { diff --git a/src/gpu/GrResourceCache2.cpp b/src/gpu/GrResourceCache2.cpp index d30397337f..39181554d2 100644 --- a/src/gpu/GrResourceCache2.cpp +++ b/src/gpu/GrResourceCache2.cpp @@ -218,6 +218,11 @@ GrGpuResource* GrResourceCache2::findAndRefScratchResource(const GrResourceKey& return resource; } +void GrResourceCache2::willRemoveScratchKey(const GrGpuResource* resource) { + SkASSERT(resource->cacheAccess().isScratch()); + fScratchMap.remove(resource->cacheAccess().getScratchKey(), resource); +} + bool GrResourceCache2::didSetContentKey(GrGpuResource* resource) { SkASSERT(!fPurging); SkASSERT(resource); diff --git a/src/gpu/GrResourceCache2.h b/src/gpu/GrResourceCache2.h index 9331e9dfd3..3c5eea5a3f 100644 --- a/src/gpu/GrResourceCache2.h +++ b/src/gpu/GrResourceCache2.h @@ -161,6 +161,7 @@ private: void notifyPurgable(GrGpuResource*); void didChangeGpuMemorySize(const GrGpuResource*, size_t oldSize); bool didSetContentKey(GrGpuResource*); + void willRemoveScratchKey(const GrGpuResource*); void didChangeBudgetStatus(GrGpuResource*); void makeResourceMRU(GrGpuResource*); /// @} @@ -277,6 +278,12 @@ private: */ bool didSetContentKey(GrGpuResource* resource) { return fCache->didSetContentKey(resource); } + /** + * Called by GrGpuResources when the remove their scratch key. + */ + void willRemoveScratchKey(const GrGpuResource* resource) { + fCache->willRemoveScratchKey(resource); + } /** * Called by GrGpuResources when they change from budgeted to unbudgeted or vice versa. diff --git a/src/gpu/GrStencilBuffer.cpp b/src/gpu/GrStencilBuffer.cpp index 16b0150a4d..5aa56e0717 100644 --- a/src/gpu/GrStencilBuffer.cpp +++ b/src/gpu/GrStencilBuffer.cpp @@ -12,14 +12,10 @@ #include "GrGpu.h" #include "GrResourceCache2.h" -void GrStencilBuffer::transferToCache() { - this->getGpu()->getContext()->addStencilBuffer(this); -} - namespace { // we should never have more than one stencil buffer with same combo of (width,height,samplecount) void gen_cache_id(int width, int height, int sampleCnt, GrCacheID* cacheID) { - static const GrCacheID::Domain gStencilBufferDomain = GrCacheID::GenerateDomain(); + static const GrCacheID::Domain gStencilBufferDomain = GrResourceKey::ScratchDomain(); GrCacheID::Key key; uint32_t* keyData = key.fData32; keyData[0] = width; diff --git a/src/gpu/GrStencilBuffer.h b/src/gpu/GrStencilBuffer.h index 86fef50225..187556bd4c 100644 --- a/src/gpu/GrStencilBuffer.h +++ b/src/gpu/GrStencilBuffer.h @@ -47,9 +47,6 @@ public: !fLastClipStackRect.contains(clipSpaceRect); } - // Places the sb in the cache. The cache takes a ref of the stencil buffer. - void transferToCache(); - static GrResourceKey ComputeKey(int width, int height, int sampleCnt); protected: @@ -60,6 +57,7 @@ protected: , fBits(bits) , fSampleCnt(sampleCnt) , fLastClipStackGenID(SkClipStack::kInvalidGenID) { + this->setScratchKey(ComputeKey(width, height, sampleCnt)); fLastClipStackRect.setEmpty(); } diff --git a/src/gpu/gl/GrGpuGL.cpp b/src/gpu/gl/GrGpuGL.cpp index 9e1f754a82..bb40839f48 100644 --- a/src/gpu/gl/GrGpuGL.cpp +++ b/src/gpu/gl/GrGpuGL.cpp @@ -9,6 +9,7 @@ #include "GrGpuGL.h" #include "GrGLStencilBuffer.h" #include "GrGLTextureRenderTarget.h" +#include "GrGpuResourceCacheAccess.h" #include "GrOptDrawState.h" #include "GrSurfacePriv.h" #include "GrTemplates.h" @@ -1121,8 +1122,7 @@ void inline get_stencil_rb_sizes(const GrGLInterface* gl, } } -bool GrGpuGL::createStencilBufferForRenderTarget(GrRenderTarget* rt, - int width, int height) { +bool GrGpuGL::createStencilBufferForRenderTarget(GrRenderTarget* rt, int width, int height) { // All internally created RTs are also textures. We don't create // SBs for a client's standalone RT (that is a RT that isn't also a texture). @@ -1171,15 +1171,16 @@ bool GrGpuGL::createStencilBufferForRenderTarget(GrRenderTarget* rt, SkAutoTUnref<GrStencilBuffer> sb(SkNEW_ARGS(GrGLStencilBuffer, (this, kIsWrapped, sbID, width, height, samples, format))); - // If we fail we have to create a new render buffer ID since we gave this one to the - // GrGLStencilBuffer object. - sbID = 0; if (this->attachStencilBufferToRenderTarget(sb, rt)) { fLastSuccessfulStencilFmtIdx = sIdx; - sb->transferToCache(); rt->setStencilBuffer(sb); return true; } + // Remove the scratch key from this resource so we don't grab it from the cache ever + // again. + sb->cacheAccess().removeScratchKey(); + // Set this to 0 since we handed the valid ID off to the failed stencil buffer resource. + sbID = 0; } } GL_CALL(DeleteRenderbuffers(1, &sbID)); diff --git a/tests/ResourceCacheTest.cpp b/tests/ResourceCacheTest.cpp index 930bd1217c..f925b07754 100644 --- a/tests/ResourceCacheTest.cpp +++ b/tests/ResourceCacheTest.cpp @@ -313,6 +313,68 @@ static void test_duplicate_scratch_key(skiatest::Reporter* reporter) { SkDEBUGCODE(REPORTER_ASSERT(reporter, 0 == cache2->countScratchEntriesForKey(scratchKey));) } +static void test_remove_scratch_key(skiatest::Reporter* reporter) { + SkAutoTUnref<GrContext> context(GrContext::CreateMockContext()); + REPORTER_ASSERT(reporter, SkToBool(context)); + if (NULL == context) { + return; + } + context->setResourceCacheLimits(5, 30000); + GrResourceCache2* cache2 = context->getResourceCache2(); + cache2->purgeAllUnlocked(); + SkASSERT(0 == cache2->getResourceCount() && 0 == cache2->getResourceBytes()); + + GrCacheID::Key keyData; + memset(&keyData, 0, sizeof(keyData)); + GrCacheID::Domain domain = GrResourceKey::ScratchDomain(); + GrResourceKey::ResourceType t = GrResourceKey::GenerateResourceType(); + GrResourceKey scratchKey(GrCacheID(domain, keyData), t, 0); + + // Create two resources that have the same scratch key. + TestResource* a = new TestResource(context->getGpu(), scratchKey); + TestResource* b = new TestResource(context->getGpu(), scratchKey); + a->unref(); + b->unref(); + + // Scratch resources are registered with GrResourceCache2 just by existing. There are 2. + REPORTER_ASSERT(reporter, 2 == TestResource::NumAlive()); + SkDEBUGCODE(REPORTER_ASSERT(reporter, 2 == cache2->countScratchEntriesForKey(scratchKey));) + REPORTER_ASSERT(reporter, 2 == cache2->getResourceCount()); + + // Find the first resource and remove its scratch key + GrGpuResource* find; + find = cache2->findAndRefScratchResource(scratchKey); + find->cacheAccess().removeScratchKey(); + // It's still alive, but not cached by scratch key anymore + REPORTER_ASSERT(reporter, 2 == TestResource::NumAlive()); + SkDEBUGCODE(REPORTER_ASSERT(reporter, 1 == cache2->countScratchEntriesForKey(scratchKey));) + REPORTER_ASSERT(reporter, 2 == cache2->getResourceCount()); + + // The cache should immediately delete it when it's unrefed since it isn't accessible. + find->unref(); + REPORTER_ASSERT(reporter, 1 == TestResource::NumAlive()); + SkDEBUGCODE(REPORTER_ASSERT(reporter, 1 == cache2->countScratchEntriesForKey(scratchKey));) + REPORTER_ASSERT(reporter, 1 == cache2->getResourceCount()); + + // Repeat for the second resource. + find = cache2->findAndRefScratchResource(scratchKey); + find->cacheAccess().removeScratchKey(); + REPORTER_ASSERT(reporter, 1 == TestResource::NumAlive()); + SkDEBUGCODE(REPORTER_ASSERT(reporter, 0 == cache2->countScratchEntriesForKey(scratchKey));) + REPORTER_ASSERT(reporter, 1 == cache2->getResourceCount()); + + // Should be able to call this multiple times with no problem. + find->cacheAccess().removeScratchKey(); + REPORTER_ASSERT(reporter, 1 == TestResource::NumAlive()); + SkDEBUGCODE(REPORTER_ASSERT(reporter, 0 == cache2->countScratchEntriesForKey(scratchKey));) + REPORTER_ASSERT(reporter, 1 == cache2->getResourceCount()); + + find->unref(); + REPORTER_ASSERT(reporter, 0 == TestResource::NumAlive()); + SkDEBUGCODE(REPORTER_ASSERT(reporter, 0 == cache2->countScratchEntriesForKey(scratchKey));) + REPORTER_ASSERT(reporter, 0 == cache2->getResourceCount()); +} + static void test_duplicate_content_key(skiatest::Reporter* reporter) { SkAutoTUnref<GrContext> context(GrContext::CreateMockContext()); REPORTER_ASSERT(reporter, SkToBool(context)); @@ -569,6 +631,76 @@ static void test_resource_size_changed(skiatest::Reporter* reporter) { } } +static void test_large_resource_count(skiatest::Reporter* reporter) { + SkAutoTUnref<GrContext> context(GrContext::CreateMockContext()); + REPORTER_ASSERT(reporter, SkToBool(context)); + if (NULL == context) { + return; + } + + static const int kResourceCnt = 2000; + // Set the cache size to double the resource count because we're going to create 2x that number + // resources, using two different key domains. Add a little slop to the bytes because we resize + // down to 1 byte after creating the resource. + context->setResourceCacheLimits(2 * kResourceCnt, 2 * kResourceCnt + 1000); + GrResourceCache2* cache2 = context->getResourceCache2(); + cache2->purgeAllUnlocked(); + SkASSERT(0 == cache2->getResourceCount() && 0 == cache2->getResourceBytes()); + + GrCacheID::Domain domain0 = GrCacheID::GenerateDomain(); + GrCacheID::Domain domain1 = GrCacheID::GenerateDomain(); + GrResourceKey::ResourceType t = GrResourceKey::GenerateResourceType(); + + GrCacheID::Key keyData; + memset(&keyData, 0, sizeof(keyData)); + + for (int i = 0; i < kResourceCnt; ++i) { + TestResource* resource; + keyData.fData32[0] = i; + + GrResourceKey key0(GrCacheID(domain0, keyData), t, 0); + resource = SkNEW_ARGS(TestResource, (context->getGpu())); + resource->cacheAccess().setContentKey(key0); + resource->setSize(1); + resource->unref(); + + GrResourceKey key1(GrCacheID(domain1, keyData), t, 0); + resource = SkNEW_ARGS(TestResource, (context->getGpu())); + resource->cacheAccess().setContentKey(key1); + resource->setSize(1); + resource->unref(); + } + + REPORTER_ASSERT(reporter, TestResource::NumAlive() == 2 * kResourceCnt); + REPORTER_ASSERT(reporter, cache2->getBudgetedResourceBytes() == 2 * kResourceCnt); + REPORTER_ASSERT(reporter, cache2->getBudgetedResourceCount() == 2 * kResourceCnt); + REPORTER_ASSERT(reporter, cache2->getResourceBytes() == 2 * kResourceCnt); + REPORTER_ASSERT(reporter, cache2->getResourceCount() == 2 * kResourceCnt); + for (int i = 0; i < kResourceCnt; ++i) { + keyData.fData32[0] = i; + GrResourceKey key0(GrCacheID(domain0, keyData), t, 0); + REPORTER_ASSERT(reporter, cache2->hasContentKey(key0)); + GrResourceKey key1(GrCacheID(domain0, keyData), t, 0); + REPORTER_ASSERT(reporter, cache2->hasContentKey(key1)); + } + + cache2->purgeAllUnlocked(); + REPORTER_ASSERT(reporter, TestResource::NumAlive() == 0); + REPORTER_ASSERT(reporter, cache2->getBudgetedResourceBytes() == 0); + REPORTER_ASSERT(reporter, cache2->getBudgetedResourceCount() == 0); + REPORTER_ASSERT(reporter, cache2->getResourceBytes() == 0); + REPORTER_ASSERT(reporter, cache2->getResourceCount() == 0); + + for (int i = 0; i < kResourceCnt; ++i) { + keyData.fData32[0] = i; + GrResourceKey key0(GrCacheID(domain0, keyData), t, 0); + REPORTER_ASSERT(reporter, !cache2->hasContentKey(key0)); + GrResourceKey key1(GrCacheID(domain0, keyData), t, 0); + REPORTER_ASSERT(reporter, !cache2->hasContentKey(key1)); + } +} + + //////////////////////////////////////////////////////////////////////////////// DEF_GPUTEST(ResourceCache, reporter, factory) { for (int type = 0; type < GrContextFactory::kLastGLContextType; ++type) { @@ -595,9 +727,11 @@ DEF_GPUTEST(ResourceCache, reporter, factory) { test_budgeting(reporter); test_duplicate_content_key(reporter); test_duplicate_scratch_key(reporter); + test_remove_scratch_key(reporter); test_purge_invalidated(reporter); test_cache_chained_purge(reporter); test_resource_size_changed(reporter); + test_large_resource_count(reporter); } #endif |