blob: 7b0abc1d2a19337a49f4f477dba5cb2dd50d77aa [file] [log] [blame]
commit-bot@chromium.orgc28f5552013-08-08 22:55:21 +00001/*
2 * Copyright 2013 Google Inc.
3 *
4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
6 */
7
bsalomon3f324322015-04-08 11:01:54 -07008// Include here to ensure SK_SUPPORT_GPU is set correctly before it is examined.
9#include "SkTypes.h"
10
commit-bot@chromium.orgc28f5552013-08-08 22:55:21 +000011#if SK_SUPPORT_GPU
Brian Salomon5e150852017-03-22 14:53:13 -040012#include <thread>
bsalomonbcf0a522014-10-08 08:40:09 -070013#include "GrContext.h"
Greg Daniel7ef28f32017-04-20 16:41:55 +000014#include "GrContextPriv.h"
commit-bot@chromium.orgc28f5552013-08-08 22:55:21 +000015#include "GrContextFactory.h"
bsalomonbcf0a522014-10-08 08:40:09 -070016#include "GrGpu.h"
bsalomon3582d3e2015-02-13 14:20:05 -080017#include "GrGpuResourceCacheAccess.h"
18#include "GrGpuResourcePriv.h"
Robert Phillips0bd24dc2018-01-16 08:06:32 -050019#include "GrProxyProvider.h"
Robert Phillipsc0192e32017-09-21 12:00:26 -040020#include "GrRenderTargetPriv.h"
bsalomon0ea80f42015-02-11 10:49:59 -080021#include "GrResourceCache.h"
bsalomon473addf2015-10-02 07:49:05 -070022#include "GrResourceProvider.h"
bsalomon6dc6f5f2015-06-18 09:12:16 -070023#include "GrTest.h"
Robert Phillips646e4292017-06-13 12:44:56 -040024#include "GrTexture.h"
25
bsalomonbcf0a522014-10-08 08:40:09 -070026#include "SkCanvas.h"
bsalomon71cb0c22014-11-14 12:10:14 -080027#include "SkGr.h"
28#include "SkMessageBus.h"
Robert Phillipsd6214d42016-11-07 08:23:48 -050029#include "SkMipMap.h"
reed69f6f002014-09-18 06:09:44 -070030#include "SkSurface.h"
tfarina@chromium.org4ee16bf2014-01-10 22:08:27 +000031#include "Test.h"
commit-bot@chromium.orgc28f5552013-08-08 22:55:21 +000032
33static const int gWidth = 640;
34static const int gHeight = 480;
35
36////////////////////////////////////////////////////////////////////////////////
bsalomon68d91342016-04-12 09:59:58 -070037DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ResourceCacheCache, reporter, ctxInfo) {
bsalomon8b7451a2016-05-11 06:33:06 -070038 GrContext* context = ctxInfo.grContext();
kkinnunen15302832015-12-01 04:35:26 -080039 GrSurfaceDesc desc;
Brian Osman777b5632016-10-14 09:16:21 -040040 desc.fConfig = kRGBA_8888_GrPixelConfig;
kkinnunen15302832015-12-01 04:35:26 -080041 desc.fFlags = kRenderTarget_GrSurfaceFlag;
42 desc.fWidth = gWidth;
43 desc.fHeight = gHeight;
44 SkImageInfo info = SkImageInfo::MakeN32Premul(gWidth, gHeight);
reede8f30622016-03-23 18:59:25 -070045 auto surface(SkSurface::MakeRenderTarget(context, SkBudgeted::kNo, info));
kkinnunen15302832015-12-01 04:35:26 -080046 SkCanvas* canvas = surface->getCanvas();
47
commit-bot@chromium.orgc28f5552013-08-08 22:55:21 +000048 const SkIRect size = SkIRect::MakeWH(gWidth, gHeight);
49
50 SkBitmap src;
mike@reedtribe.orgdeee4962014-02-13 14:41:43 +000051 src.allocN32Pixels(size.width(), size.height());
commit-bot@chromium.orgc28f5552013-08-08 22:55:21 +000052 src.eraseColor(SK_ColorBLACK);
Mike Reedf0ffb892017-10-03 14:47:21 -040053 size_t srcSize = src.computeByteSize();
commit-bot@chromium.orgc28f5552013-08-08 22:55:21 +000054
commit-bot@chromium.org95c20032014-05-09 14:29:32 +000055 size_t initialCacheSize;
halcanary96fcdcc2015-08-27 07:41:13 -070056 context->getResourceCacheUsage(nullptr, &initialCacheSize);
commit-bot@chromium.orgc28f5552013-08-08 22:55:21 +000057
58 int oldMaxNum;
59 size_t oldMaxBytes;
commit-bot@chromium.org95c20032014-05-09 14:29:32 +000060 context->getResourceCacheLimits(&oldMaxNum, &oldMaxBytes);
skia.committer@gmail.com17f1ae62013-08-09 07:01:22 +000061
commit-bot@chromium.orgc28f5552013-08-08 22:55:21 +000062 // Set the cache limits so we can fit 10 "src" images and the
63 // max number of textures doesn't matter
64 size_t maxCacheSize = initialCacheSize + 10*srcSize;
commit-bot@chromium.org95c20032014-05-09 14:29:32 +000065 context->setResourceCacheLimits(1000, maxCacheSize);
commit-bot@chromium.orgc28f5552013-08-08 22:55:21 +000066
67 SkBitmap readback;
mike@reedtribe.orgdeee4962014-02-13 14:41:43 +000068 readback.allocN32Pixels(size.width(), size.height());
commit-bot@chromium.orgc28f5552013-08-08 22:55:21 +000069
70 for (int i = 0; i < 100; ++i) {
71 canvas->drawBitmap(src, 0, 0);
Mike Reedf1942192017-07-21 14:24:29 -040072 surface->readPixels(readback, 0, 0);
commit-bot@chromium.orgc28f5552013-08-08 22:55:21 +000073
74 // "modify" the src texture
75 src.notifyPixelsChanged();
76
commit-bot@chromium.org95c20032014-05-09 14:29:32 +000077 size_t curCacheSize;
halcanary96fcdcc2015-08-27 07:41:13 -070078 context->getResourceCacheUsage(nullptr, &curCacheSize);
commit-bot@chromium.orgc28f5552013-08-08 22:55:21 +000079
80 // we should never go over the size limit
81 REPORTER_ASSERT(reporter, curCacheSize <= maxCacheSize);
82 }
83
commit-bot@chromium.org95c20032014-05-09 14:29:32 +000084 context->setResourceCacheLimits(oldMaxNum, oldMaxBytes);
commit-bot@chromium.orgc28f5552013-08-08 22:55:21 +000085}
86
bsalomon11abd8d2016-10-14 08:13:48 -070087static bool is_rendering_and_not_angle_es3(sk_gpu_test::GrContextFactory::ContextType type) {
88 if (type == sk_gpu_test::GrContextFactory::kANGLE_D3D11_ES3_ContextType ||
89 type == sk_gpu_test::GrContextFactory::kANGLE_GL_ES3_ContextType) {
90 return false;
91 }
92 return sk_gpu_test::GrContextFactory::IsRenderingContext(type);
93}
94
Robert Phillipsc0192e32017-09-21 12:00:26 -040095static GrStencilAttachment* get_SB(GrRenderTarget* rt) {
96 return rt->renderTargetPriv().getStencilAttachment();
97}
98
99static sk_sp<GrRenderTarget> create_RT_with_SB(GrResourceProvider* provider,
100 int size, int sampleCount, SkBudgeted budgeted) {
101 GrSurfaceDesc desc;
102 desc.fFlags = kRenderTarget_GrSurfaceFlag;
Robert Phillipsc0192e32017-09-21 12:00:26 -0400103 desc.fWidth = size;
104 desc.fHeight = size;
105 desc.fConfig = kRGBA_8888_GrPixelConfig;
106 desc.fSampleCnt = sampleCount;
107
108 sk_sp<GrTexture> tex(provider->createTexture(desc, budgeted));
109 if (!tex || !tex->asRenderTarget()) {
110 return nullptr;
111 }
112
113 if (!provider->attachStencilAttachment(tex->asRenderTarget())) {
114 return nullptr;
115 }
116 SkASSERT(get_SB(tex->asRenderTarget()));
117
118 return sk_ref_sp(tex->asRenderTarget());
119}
120
bsalomon11abd8d2016-10-14 08:13:48 -0700121// This currently fails on ES3 ANGLE contexts
122DEF_GPUTEST_FOR_CONTEXTS(ResourceCacheStencilBuffers, &is_rendering_and_not_angle_es3, reporter,
Robert Phillipsec325342017-10-30 18:02:48 +0000123 ctxInfo, nullptr) {
bsalomon8b7451a2016-05-11 06:33:06 -0700124 GrContext* context = ctxInfo.grContext();
Eric Karl5c779752017-05-08 12:02:07 -0700125 if (context->caps()->avoidStencilBuffers()) {
126 return;
127 }
Robert Phillipsc0192e32017-09-21 12:00:26 -0400128
Robert Phillips6be756b2018-01-16 15:07:54 -0500129 GrResourceProvider* resourceProvider = context->contextPriv().resourceProvider();
Robert Phillipsc0192e32017-09-21 12:00:26 -0400130
Brian Salomonbdecacf2018-02-02 20:32:49 -0500131 sk_sp<GrRenderTarget> smallRT0 = create_RT_with_SB(resourceProvider, 4, 1, SkBudgeted::kYes);
Robert Phillipsc0192e32017-09-21 12:00:26 -0400132 REPORTER_ASSERT(reporter, smallRT0);
133
134 {
135 // Two budgeted RTs with the same desc should share a stencil buffer.
Brian Salomonbdecacf2018-02-02 20:32:49 -0500136 sk_sp<GrRenderTarget> smallRT1 = create_RT_with_SB(resourceProvider, 4, 1, SkBudgeted::kYes);
137 REPORTER_ASSERT(reporter, smallRT1);
Robert Phillipsc0192e32017-09-21 12:00:26 -0400138
Brian Salomonbdecacf2018-02-02 20:32:49 -0500139 REPORTER_ASSERT(reporter, get_SB(smallRT0.get()) == get_SB(smallRT1.get()));
bsalomon6bc1b5f2015-02-23 09:06:38 -0800140 }
141
Robert Phillipsc0192e32017-09-21 12:00:26 -0400142 {
143 // An unbudgeted RT with the same desc should also share.
Brian Salomonbdecacf2018-02-02 20:32:49 -0500144 sk_sp<GrRenderTarget> smallRT2 = create_RT_with_SB(resourceProvider, 4, 1, SkBudgeted::kNo);
Robert Phillipsc0192e32017-09-21 12:00:26 -0400145 REPORTER_ASSERT(reporter, smallRT2);
146
147 REPORTER_ASSERT(reporter, get_SB(smallRT0.get()) == get_SB(smallRT2.get()));
bsalomon6bc1b5f2015-02-23 09:06:38 -0800148 }
149
Robert Phillipsc0192e32017-09-21 12:00:26 -0400150 {
151 // An RT with a much larger size should not share.
Brian Salomonbdecacf2018-02-02 20:32:49 -0500152 sk_sp<GrRenderTarget> bigRT = create_RT_with_SB(resourceProvider, 400, 1, SkBudgeted::kNo);
Robert Phillipsc0192e32017-09-21 12:00:26 -0400153 REPORTER_ASSERT(reporter, bigRT);
bsalomon02a44a42015-02-19 09:09:00 -0800154
Robert Phillipsc0192e32017-09-21 12:00:26 -0400155 REPORTER_ASSERT(reporter, get_SB(smallRT0.get()) != get_SB(bigRT.get()));
bsalomon6bc1b5f2015-02-23 09:06:38 -0800156 }
bsalomon02a44a42015-02-19 09:09:00 -0800157
Brian Salomonbdecacf2018-02-02 20:32:49 -0500158 int smallSampleCount = context->caps()->getRenderTargetSampleCount(2, kRGBA_8888_GrPixelConfig);
159 if (smallSampleCount > 1) {
mtklein5f939ab2016-03-16 10:28:35 -0700160 // An RT with a different sample count should not share.
Robert Phillips6be756b2018-01-16 15:07:54 -0500161 sk_sp<GrRenderTarget> smallMSAART0 = create_RT_with_SB(resourceProvider, 4,
162 smallSampleCount, SkBudgeted::kNo);
bsalomonb602d4d2015-02-19 12:05:58 -0800163#ifdef SK_BUILD_FOR_ANDROID
164 if (!smallMSAART0) {
165 // The nexus player seems to fail to create MSAA textures.
166 return;
167 }
Robert Phillipsc0192e32017-09-21 12:00:26 -0400168#else
169 REPORTER_ASSERT(reporter, smallMSAART0);
bsalomonb602d4d2015-02-19 12:05:58 -0800170#endif
Robert Phillipsc0192e32017-09-21 12:00:26 -0400171
172 REPORTER_ASSERT(reporter, get_SB(smallRT0.get()) != get_SB(smallMSAART0.get()));
173
174 {
175 // A second MSAA RT should share with the first MSAA RT.
Robert Phillips6be756b2018-01-16 15:07:54 -0500176 sk_sp<GrRenderTarget> smallMSAART1 = create_RT_with_SB(resourceProvider, 4,
177 smallSampleCount,
Robert Phillipsc0192e32017-09-21 12:00:26 -0400178 SkBudgeted::kNo);
179 REPORTER_ASSERT(reporter, smallMSAART1);
180
181 REPORTER_ASSERT(reporter, get_SB(smallMSAART0.get()) == get_SB(smallMSAART1.get()));
bsalomon6bc1b5f2015-02-23 09:06:38 -0800182 }
Robert Phillipsc0192e32017-09-21 12:00:26 -0400183
Brian Salomonbdecacf2018-02-02 20:32:49 -0500184 // But one with a larger sample count should not. (Also check that the two requests didn't
185 // rounded up to the same actual sample count or else they could share.).
186 int bigSampleCount =
187 context->caps()->getRenderTargetSampleCount(5, kRGBA_8888_GrPixelConfig);
188 if (bigSampleCount > 0 && bigSampleCount != smallSampleCount) {
Robert Phillips6be756b2018-01-16 15:07:54 -0500189 sk_sp<GrRenderTarget> smallMSAART2 = create_RT_with_SB(resourceProvider, 4,
190 bigSampleCount,
Robert Phillipsc0192e32017-09-21 12:00:26 -0400191 SkBudgeted::kNo);
192 REPORTER_ASSERT(reporter, smallMSAART2);
193
194 REPORTER_ASSERT(reporter, get_SB(smallMSAART0.get()) != get_SB(smallMSAART2.get()));
bsalomon02a44a42015-02-19 09:09:00 -0800195 }
196 }
197}
198
bsalomon68d91342016-04-12 09:59:58 -0700199DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ResourceCacheWrappedResources, reporter, ctxInfo) {
bsalomon8b7451a2016-05-11 06:33:06 -0700200 GrContext* context = ctxInfo.grContext();
Robert Phillips6be756b2018-01-16 15:07:54 -0500201 GrResourceProvider* resourceProvider = context->contextPriv().resourceProvider();
Robert Phillipsf35fd8d2018-01-22 10:48:15 -0500202 GrGpu* gpu = context->contextPriv().getGpu();
jvanvertheeb8d992015-07-15 10:16:56 -0700203 // this test is only valid for GL
204 if (!gpu || !gpu->glContextForTesting()) {
bsalomon6dc6f5f2015-06-18 09:12:16 -0700205 return;
206 }
207
Robert Phillipsd21b2a52017-12-12 13:01:25 -0500208 GrBackendTexture backendTextures[2];
bsalomon6dc6f5f2015-06-18 09:12:16 -0700209 static const int kW = 100;
210 static const int kH = 100;
jvanverth672bb7f2015-07-13 07:19:57 -0700211
Robert Phillipsd21b2a52017-12-12 13:01:25 -0500212 backendTextures[0] = gpu->createTestingOnlyBackendTexture(nullptr, kW, kH,
213 kRGBA_8888_GrPixelConfig,
214 false, GrMipMapped::kNo);
215 backendTextures[1] = gpu->createTestingOnlyBackendTexture(nullptr, kW, kH,
216 kRGBA_8888_GrPixelConfig,
217 false, GrMipMapped::kNo);
Greg Daniel5366e592018-01-10 09:57:53 -0500218 REPORTER_ASSERT(reporter, backendTextures[0].isValid());
219 REPORTER_ASSERT(reporter, backendTextures[1].isValid());
220 if (!backendTextures[0].isValid() || !backendTextures[1].isValid()) {
221 return;
222 }
jvanverth672bb7f2015-07-13 07:19:57 -0700223
bsalomon6dc6f5f2015-06-18 09:12:16 -0700224 context->resetContext();
225
Robert Phillips6be756b2018-01-16 15:07:54 -0500226 sk_sp<GrTexture> borrowed(resourceProvider->wrapBackendTexture(
Robert Phillipsd21b2a52017-12-12 13:01:25 -0500227 backendTextures[0], kBorrow_GrWrapOwnership));
bsalomon6dc6f5f2015-06-18 09:12:16 -0700228
Robert Phillips6be756b2018-01-16 15:07:54 -0500229 sk_sp<GrTexture> adopted(resourceProvider->wrapBackendTexture(
Robert Phillipsd21b2a52017-12-12 13:01:25 -0500230 backendTextures[1], kAdopt_GrWrapOwnership));
bsalomon6dc6f5f2015-06-18 09:12:16 -0700231
Brian Osman85d34b22017-05-10 12:06:26 -0400232 REPORTER_ASSERT(reporter, borrowed != nullptr && adopted != nullptr);
233 if (!borrowed || !adopted) {
bsalomon6dc6f5f2015-06-18 09:12:16 -0700234 return;
235 }
236
halcanary96fcdcc2015-08-27 07:41:13 -0700237 borrowed.reset(nullptr);
238 adopted.reset(nullptr);
bsalomon6dc6f5f2015-06-18 09:12:16 -0700239
240 context->flush();
241
Robert Phillipsd21b2a52017-12-12 13:01:25 -0500242 bool borrowedIsAlive = gpu->isTestingOnlyBackendTexture(backendTextures[0]);
243 bool adoptedIsAlive = gpu->isTestingOnlyBackendTexture(backendTextures[1]);
bsalomon6dc6f5f2015-06-18 09:12:16 -0700244
245 REPORTER_ASSERT(reporter, borrowedIsAlive);
246 REPORTER_ASSERT(reporter, !adoptedIsAlive);
247
Brian Salomone64b0642018-03-07 11:47:54 -0500248 if (borrowedIsAlive) {
Brian Salomon26102cb2018-03-09 09:33:19 -0500249 gpu->deleteTestingOnlyBackendTexture(backendTextures[0]);
Brian Salomone64b0642018-03-07 11:47:54 -0500250 }
251 if (adoptedIsAlive) {
Brian Salomon26102cb2018-03-09 09:33:19 -0500252 gpu->deleteTestingOnlyBackendTexture(backendTextures[1]);
Brian Salomone64b0642018-03-07 11:47:54 -0500253 }
bsalomon6dc6f5f2015-06-18 09:12:16 -0700254
255 context->resetContext();
256}
257
bsalomon6d3fe022014-07-25 08:35:45 -0700258class TestResource : public GrGpuResource {
bsalomon1c60dfe2015-01-21 09:32:40 -0800259 enum ScratchConstructor { kScratchConstructor };
commit-bot@chromium.orgc6658042014-01-15 23:09:01 +0000260public:
robertphillips6e83ac72015-08-13 05:19:14 -0700261 static const size_t kDefaultSize = 100;
mtklein5f939ab2016-03-16 10:28:35 -0700262
bsalomon1c60dfe2015-01-21 09:32:40 -0800263 /** Property that distinctly categorizes the resource.
264 * For example, textures have width, height, ... */
bsalomon23e619c2015-02-06 11:54:28 -0800265 enum SimulatedProperty { kA_SimulatedProperty, kB_SimulatedProperty };
bsalomon1c60dfe2015-01-21 09:32:40 -0800266
kkinnunen2e6055b2016-04-22 01:48:29 -0700267 TestResource(GrGpu* gpu, SkBudgeted budgeted = SkBudgeted::kYes, size_t size = kDefaultSize)
268 : INHERITED(gpu)
halcanary96fcdcc2015-08-27 07:41:13 -0700269 , fToDelete(nullptr)
bsalomon1c60dfe2015-01-21 09:32:40 -0800270 , fSize(size)
kkinnunen2e6055b2016-04-22 01:48:29 -0700271 , fProperty(kA_SimulatedProperty)
272 , fIsScratch(false) {
bsalomon5236cf42015-01-14 10:42:08 -0800273 ++fNumAlive;
kkinnunen2e6055b2016-04-22 01:48:29 -0700274 this->registerWithCache(budgeted);
bsalomon5236cf42015-01-14 10:42:08 -0800275 }
276
kkinnunen2e6055b2016-04-22 01:48:29 -0700277 static TestResource* CreateScratch(GrGpu* gpu, SkBudgeted budgeted,
278 SimulatedProperty property) {
279 return new TestResource(gpu, budgeted, property, kScratchConstructor);
bsalomondace19e2014-11-17 07:34:06 -0800280 }
kkinnunen2e6055b2016-04-22 01:48:29 -0700281 static TestResource* CreateWrapped(GrGpu* gpu, size_t size = kDefaultSize) {
282 return new TestResource(gpu, size);
commit-bot@chromium.orgc6658042014-01-15 23:09:01 +0000283 }
284
Brian Salomond3b65972017-03-22 12:05:03 -0400285 ~TestResource() override {
bsalomon33435572014-11-05 14:47:41 -0800286 --fNumAlive;
bsalomon71cb0c22014-11-14 12:10:14 -0800287 SkSafeUnref(fToDelete);
commit-bot@chromium.orgc6658042014-01-15 23:09:01 +0000288 }
289
commit-bot@chromium.org11c6b392014-05-05 19:09:13 +0000290 void setSize(size_t size) {
291 fSize = size;
292 this->didChangeGpuMemorySize();
293 }
294
bsalomon33435572014-11-05 14:47:41 -0800295 static int NumAlive() { return fNumAlive; }
commit-bot@chromium.orgc6658042014-01-15 23:09:01 +0000296
bsalomon71cb0c22014-11-14 12:10:14 -0800297 void setUnrefWhenDestroyed(TestResource* resource) {
298 SkRefCnt_SafeAssign(fToDelete, resource);
commit-bot@chromium.orgc6658042014-01-15 23:09:01 +0000299 }
300
bsalomon1c60dfe2015-01-21 09:32:40 -0800301 static void ComputeScratchKey(SimulatedProperty property, GrScratchKey* key) {
302 static GrScratchKey::ResourceType t = GrScratchKey::GenerateResourceType();
303 GrScratchKey::Builder builder(key, t, kScratchKeyFieldCnt);
bsalomon24db3b12015-01-23 04:24:04 -0800304 for (int i = 0; i < kScratchKeyFieldCnt; ++i) {
305 builder[i] = static_cast<uint32_t>(i + property);
bsalomon1c60dfe2015-01-21 09:32:40 -0800306 }
307 }
308
309 static size_t ExpectedScratchKeySize() {
310 return sizeof(uint32_t) * (kScratchKeyFieldCnt + GrScratchKey::kMetaDataCnt);
311 }
commit-bot@chromium.orgc6658042014-01-15 23:09:01 +0000312private:
bsalomon24db3b12015-01-23 04:24:04 -0800313 static const int kScratchKeyFieldCnt = 6;
bsalomon1c60dfe2015-01-21 09:32:40 -0800314
kkinnunen2e6055b2016-04-22 01:48:29 -0700315 TestResource(GrGpu* gpu, SkBudgeted budgeted, SimulatedProperty property, ScratchConstructor)
316 : INHERITED(gpu)
halcanary96fcdcc2015-08-27 07:41:13 -0700317 , fToDelete(nullptr)
bsalomon1c60dfe2015-01-21 09:32:40 -0800318 , fSize(kDefaultSize)
kkinnunen2e6055b2016-04-22 01:48:29 -0700319 , fProperty(property)
320 , fIsScratch(true) {
bsalomon1c60dfe2015-01-21 09:32:40 -0800321 ++fNumAlive;
kkinnunen2e6055b2016-04-22 01:48:29 -0700322 this->registerWithCache(budgeted);
323 }
324
325 // Constructor for simulating resources that wrap backend objects.
326 TestResource(GrGpu* gpu, size_t size)
327 : INHERITED(gpu)
328 , fToDelete(nullptr)
329 , fSize(size)
330 , fProperty(kA_SimulatedProperty)
331 , fIsScratch(false) {
332 ++fNumAlive;
333 this->registerWithCacheWrapped();
334 }
335
336 void computeScratchKey(GrScratchKey* key) const override {
337 if (fIsScratch) {
338 ComputeScratchKey(fProperty, key);
339 }
bsalomon1c60dfe2015-01-21 09:32:40 -0800340 }
341
mtklein36352bf2015-03-25 18:17:31 -0700342 size_t onGpuMemorySize() const override { return fSize; }
bsalomon69ed47f2014-11-12 11:13:39 -0800343
commit-bot@chromium.orgc6658042014-01-15 23:09:01 +0000344 TestResource* fToDelete;
commit-bot@chromium.org11c6b392014-05-05 19:09:13 +0000345 size_t fSize;
bsalomon33435572014-11-05 14:47:41 -0800346 static int fNumAlive;
bsalomon1c60dfe2015-01-21 09:32:40 -0800347 SimulatedProperty fProperty;
kkinnunen2e6055b2016-04-22 01:48:29 -0700348 bool fIsScratch;
bsalomon6d3fe022014-07-25 08:35:45 -0700349 typedef GrGpuResource INHERITED;
commit-bot@chromium.orgc6658042014-01-15 23:09:01 +0000350};
bsalomon33435572014-11-05 14:47:41 -0800351int TestResource::fNumAlive = 0;
commit-bot@chromium.orgc6658042014-01-15 23:09:01 +0000352
bsalomonc2f35b72015-01-23 07:19:22 -0800353class Mock {
354public:
355 Mock(int maxCnt, size_t maxBytes) {
Greg Daniel02611d92017-07-25 10:05:01 -0400356 fContext = GrContext::MakeMock(nullptr);
bsalomonc2f35b72015-01-23 07:19:22 -0800357 SkASSERT(fContext);
358 fContext->setResourceCacheLimits(maxCnt, maxBytes);
Robert Phillips6be756b2018-01-16 15:07:54 -0500359 GrResourceCache* cache = fContext->contextPriv().getResourceCache();
bsalomon0ea80f42015-02-11 10:49:59 -0800360 cache->purgeAllUnlocked();
361 SkASSERT(0 == cache->getResourceCount() && 0 == cache->getResourceBytes());
bsalomon71cb0c22014-11-14 12:10:14 -0800362 }
bsalomonc2f35b72015-01-23 07:19:22 -0800363
Robert Phillips6be756b2018-01-16 15:07:54 -0500364 GrResourceCache* cache() { return fContext->contextPriv().getResourceCache(); }
bsalomonc2f35b72015-01-23 07:19:22 -0800365
Hal Canary342b7ac2016-11-04 11:49:42 -0400366 GrContext* context() { return fContext.get(); }
bsalomonc2f35b72015-01-23 07:19:22 -0800367
368private:
Hal Canary342b7ac2016-11-04 11:49:42 -0400369 sk_sp<GrContext> fContext;
bsalomonc2f35b72015-01-23 07:19:22 -0800370};
371
372static void test_no_key(skiatest::Reporter* reporter) {
373 Mock mock(10, 30000);
374 GrContext* context = mock.context();
bsalomon0ea80f42015-02-11 10:49:59 -0800375 GrResourceCache* cache = mock.cache();
Robert Phillipsf35fd8d2018-01-22 10:48:15 -0500376 GrGpu* gpu = context->contextPriv().getGpu();
bsalomon71cb0c22014-11-14 12:10:14 -0800377
378 // Create a bunch of resources with no keys
Robert Phillipsf35fd8d2018-01-22 10:48:15 -0500379 TestResource* a = new TestResource(gpu);
380 TestResource* b = new TestResource(gpu);
381 TestResource* c = new TestResource(gpu);
382 TestResource* d = new TestResource(gpu);
bsalomon71cb0c22014-11-14 12:10:14 -0800383 a->setSize(11);
384 b->setSize(12);
385 c->setSize(13);
386 d->setSize(14);
387
388 REPORTER_ASSERT(reporter, 4 == TestResource::NumAlive());
bsalomon0ea80f42015-02-11 10:49:59 -0800389 REPORTER_ASSERT(reporter, 4 == cache->getResourceCount());
bsalomon71cb0c22014-11-14 12:10:14 -0800390 REPORTER_ASSERT(reporter, a->gpuMemorySize() + b->gpuMemorySize() + c->gpuMemorySize() +
bsalomon0ea80f42015-02-11 10:49:59 -0800391 d->gpuMemorySize() == cache->getResourceBytes());
bsalomon71cb0c22014-11-14 12:10:14 -0800392
393 // Should be safe to purge without deleting the resources since we still have refs.
bsalomon0ea80f42015-02-11 10:49:59 -0800394 cache->purgeAllUnlocked();
bsalomon71cb0c22014-11-14 12:10:14 -0800395 REPORTER_ASSERT(reporter, 4 == TestResource::NumAlive());
396
bsalomon8718aaf2015-02-19 07:24:21 -0800397 // Since the resources have neither unique nor scratch keys, delete immediately upon unref.
bsalomon71cb0c22014-11-14 12:10:14 -0800398
399 a->unref();
400 REPORTER_ASSERT(reporter, 3 == TestResource::NumAlive());
bsalomon0ea80f42015-02-11 10:49:59 -0800401 REPORTER_ASSERT(reporter, 3 == cache->getResourceCount());
bsalomon71cb0c22014-11-14 12:10:14 -0800402 REPORTER_ASSERT(reporter, b->gpuMemorySize() + c->gpuMemorySize() + d->gpuMemorySize() ==
bsalomon0ea80f42015-02-11 10:49:59 -0800403 cache->getResourceBytes());
bsalomon71cb0c22014-11-14 12:10:14 -0800404
405 c->unref();
406 REPORTER_ASSERT(reporter, 2 == TestResource::NumAlive());
bsalomon0ea80f42015-02-11 10:49:59 -0800407 REPORTER_ASSERT(reporter, 2 == cache->getResourceCount());
bsalomon71cb0c22014-11-14 12:10:14 -0800408 REPORTER_ASSERT(reporter, b->gpuMemorySize() + d->gpuMemorySize() ==
bsalomon0ea80f42015-02-11 10:49:59 -0800409 cache->getResourceBytes());
bsalomon71cb0c22014-11-14 12:10:14 -0800410
411 d->unref();
412 REPORTER_ASSERT(reporter, 1 == TestResource::NumAlive());
bsalomon0ea80f42015-02-11 10:49:59 -0800413 REPORTER_ASSERT(reporter, 1 == cache->getResourceCount());
414 REPORTER_ASSERT(reporter, b->gpuMemorySize() == cache->getResourceBytes());
bsalomon71cb0c22014-11-14 12:10:14 -0800415
416 b->unref();
417 REPORTER_ASSERT(reporter, 0 == TestResource::NumAlive());
bsalomon0ea80f42015-02-11 10:49:59 -0800418 REPORTER_ASSERT(reporter, 0 == cache->getResourceCount());
419 REPORTER_ASSERT(reporter, 0 == cache->getResourceBytes());
bsalomon71cb0c22014-11-14 12:10:14 -0800420}
421
bsalomon24db3b12015-01-23 04:24:04 -0800422// Each integer passed as a template param creates a new domain.
Brian Salomon1090da62017-01-06 12:04:19 -0500423template <int>
424static void make_unique_key(GrUniqueKey* key, int data, const char* tag = nullptr) {
bsalomon8718aaf2015-02-19 07:24:21 -0800425 static GrUniqueKey::Domain d = GrUniqueKey::GenerateDomain();
Brian Salomon1090da62017-01-06 12:04:19 -0500426 GrUniqueKey::Builder builder(key, d, 1, tag);
bsalomon24db3b12015-01-23 04:24:04 -0800427 builder[0] = data;
428}
429
bsalomon84c8e622014-11-17 09:33:27 -0800430static void test_budgeting(skiatest::Reporter* reporter) {
bsalomonc2f35b72015-01-23 07:19:22 -0800431 Mock mock(10, 300);
432 GrContext* context = mock.context();
bsalomon0ea80f42015-02-11 10:49:59 -0800433 GrResourceCache* cache = mock.cache();
Robert Phillipsf35fd8d2018-01-22 10:48:15 -0500434 GrGpu* gpu = context->contextPriv().getGpu();
bsalomondace19e2014-11-17 07:34:06 -0800435
bsalomon8718aaf2015-02-19 07:24:21 -0800436 GrUniqueKey uniqueKey;
437 make_unique_key<0>(&uniqueKey, 0);
bsalomondace19e2014-11-17 07:34:06 -0800438
bsalomon8718aaf2015-02-19 07:24:21 -0800439 // Create a scratch, a unique, and a wrapped resource
bsalomon1c60dfe2015-01-21 09:32:40 -0800440 TestResource* scratch =
Robert Phillipsf35fd8d2018-01-22 10:48:15 -0500441 TestResource::CreateScratch(gpu, SkBudgeted::kYes, TestResource::kB_SimulatedProperty);
bsalomondace19e2014-11-17 07:34:06 -0800442 scratch->setSize(10);
Robert Phillipsf35fd8d2018-01-22 10:48:15 -0500443 TestResource* unique = new TestResource(gpu);
bsalomon8718aaf2015-02-19 07:24:21 -0800444 unique->setSize(11);
bsalomonf99e9612015-02-19 08:24:16 -0800445 unique->resourcePriv().setUniqueKey(uniqueKey);
Robert Phillipsf35fd8d2018-01-22 10:48:15 -0500446 TestResource* wrapped = TestResource::CreateWrapped(gpu);
bsalomon5236cf42015-01-14 10:42:08 -0800447 wrapped->setSize(12);
Robert Phillipsf35fd8d2018-01-22 10:48:15 -0500448 TestResource* unbudgeted = new TestResource(gpu, SkBudgeted::kNo);
bsalomon84c8e622014-11-17 09:33:27 -0800449 unbudgeted->setSize(13);
bsalomondace19e2014-11-17 07:34:06 -0800450
Brian Osman0562eb92017-05-08 11:16:39 -0400451 // Make sure we can add a unique key to the wrapped resource
bsalomon8718aaf2015-02-19 07:24:21 -0800452 GrUniqueKey uniqueKey2;
453 make_unique_key<0>(&uniqueKey2, 1);
bsalomonf99e9612015-02-19 08:24:16 -0800454 wrapped->resourcePriv().setUniqueKey(uniqueKey2);
Brian Osman0562eb92017-05-08 11:16:39 -0400455 GrGpuResource* wrappedViaKey = cache->findAndRefUniqueResource(uniqueKey2);
456 REPORTER_ASSERT(reporter, wrappedViaKey != nullptr);
457
458 // Remove the extra ref we just added.
459 wrappedViaKey->unref();
bsalomondace19e2014-11-17 07:34:06 -0800460
461 // Make sure sizes are as we expect
bsalomon0ea80f42015-02-11 10:49:59 -0800462 REPORTER_ASSERT(reporter, 4 == cache->getResourceCount());
bsalomon8718aaf2015-02-19 07:24:21 -0800463 REPORTER_ASSERT(reporter, scratch->gpuMemorySize() + unique->gpuMemorySize() +
bsalomon84c8e622014-11-17 09:33:27 -0800464 wrapped->gpuMemorySize() + unbudgeted->gpuMemorySize() ==
bsalomon0ea80f42015-02-11 10:49:59 -0800465 cache->getResourceBytes());
466 REPORTER_ASSERT(reporter, 2 == cache->getBudgetedResourceCount());
bsalomon8718aaf2015-02-19 07:24:21 -0800467 REPORTER_ASSERT(reporter, scratch->gpuMemorySize() + unique->gpuMemorySize() ==
bsalomon0ea80f42015-02-11 10:49:59 -0800468 cache->getBudgetedResourceBytes());
Derek Sollenbergeree479142017-05-24 11:41:33 -0400469 REPORTER_ASSERT(reporter, 0 == cache->getPurgeableBytes());
bsalomondace19e2014-11-17 07:34:06 -0800470
bsalomon63c992f2015-01-23 12:47:59 -0800471 // Our refs mean that the resources are non purgeable.
bsalomon0ea80f42015-02-11 10:49:59 -0800472 cache->purgeAllUnlocked();
473 REPORTER_ASSERT(reporter, 4 == cache->getResourceCount());
bsalomon8718aaf2015-02-19 07:24:21 -0800474 REPORTER_ASSERT(reporter, scratch->gpuMemorySize() + unique->gpuMemorySize() +
bsalomon84c8e622014-11-17 09:33:27 -0800475 wrapped->gpuMemorySize() + unbudgeted->gpuMemorySize() ==
bsalomon0ea80f42015-02-11 10:49:59 -0800476 cache->getResourceBytes());
477 REPORTER_ASSERT(reporter, 2 == cache->getBudgetedResourceCount());
bsalomon8718aaf2015-02-19 07:24:21 -0800478 REPORTER_ASSERT(reporter, scratch->gpuMemorySize() + unique->gpuMemorySize() ==
bsalomon0ea80f42015-02-11 10:49:59 -0800479 cache->getBudgetedResourceBytes());
Derek Sollenbergeree479142017-05-24 11:41:33 -0400480 REPORTER_ASSERT(reporter, 0 == cache->getPurgeableBytes());
bsalomondace19e2014-11-17 07:34:06 -0800481
482 // Unreffing the wrapped resource should free it right away.
483 wrapped->unref();
bsalomon0ea80f42015-02-11 10:49:59 -0800484 REPORTER_ASSERT(reporter, 3 == cache->getResourceCount());
bsalomon8718aaf2015-02-19 07:24:21 -0800485 REPORTER_ASSERT(reporter, scratch->gpuMemorySize() + unique->gpuMemorySize() +
bsalomon0ea80f42015-02-11 10:49:59 -0800486 unbudgeted->gpuMemorySize() == cache->getResourceBytes());
Derek Sollenbergeree479142017-05-24 11:41:33 -0400487 REPORTER_ASSERT(reporter, 0 == cache->getPurgeableBytes());
bsalomondace19e2014-11-17 07:34:06 -0800488
bsalomon84c8e622014-11-17 09:33:27 -0800489 // Now try freeing the budgeted resources first
Robert Phillipsf35fd8d2018-01-22 10:48:15 -0500490 wrapped = TestResource::CreateWrapped(gpu);
bsalomondace19e2014-11-17 07:34:06 -0800491 scratch->setSize(12);
bsalomon8718aaf2015-02-19 07:24:21 -0800492 unique->unref();
Derek Sollenbergeree479142017-05-24 11:41:33 -0400493 REPORTER_ASSERT(reporter, 11 == cache->getPurgeableBytes());
bsalomon0ea80f42015-02-11 10:49:59 -0800494 cache->purgeAllUnlocked();
495 REPORTER_ASSERT(reporter, 3 == cache->getResourceCount());
bsalomon84c8e622014-11-17 09:33:27 -0800496 REPORTER_ASSERT(reporter, scratch->gpuMemorySize() + wrapped->gpuMemorySize() +
bsalomon0ea80f42015-02-11 10:49:59 -0800497 unbudgeted->gpuMemorySize() == cache->getResourceBytes());
498 REPORTER_ASSERT(reporter, 1 == cache->getBudgetedResourceCount());
499 REPORTER_ASSERT(reporter, scratch->gpuMemorySize() == cache->getBudgetedResourceBytes());
Derek Sollenbergeree479142017-05-24 11:41:33 -0400500 REPORTER_ASSERT(reporter, 0 == cache->getPurgeableBytes());
bsalomondace19e2014-11-17 07:34:06 -0800501
502 scratch->unref();
Derek Sollenbergeree479142017-05-24 11:41:33 -0400503 REPORTER_ASSERT(reporter, 12 == cache->getPurgeableBytes());
bsalomon0ea80f42015-02-11 10:49:59 -0800504 cache->purgeAllUnlocked();
505 REPORTER_ASSERT(reporter, 2 == cache->getResourceCount());
bsalomon84c8e622014-11-17 09:33:27 -0800506 REPORTER_ASSERT(reporter, unbudgeted->gpuMemorySize() + wrapped->gpuMemorySize() ==
bsalomon0ea80f42015-02-11 10:49:59 -0800507 cache->getResourceBytes());
508 REPORTER_ASSERT(reporter, 0 == cache->getBudgetedResourceCount());
509 REPORTER_ASSERT(reporter, 0 == cache->getBudgetedResourceBytes());
Derek Sollenbergeree479142017-05-24 11:41:33 -0400510 REPORTER_ASSERT(reporter, 0 == cache->getPurgeableBytes());
bsalomondace19e2014-11-17 07:34:06 -0800511
512 wrapped->unref();
bsalomon0ea80f42015-02-11 10:49:59 -0800513 REPORTER_ASSERT(reporter, 1 == cache->getResourceCount());
514 REPORTER_ASSERT(reporter, unbudgeted->gpuMemorySize() == cache->getResourceBytes());
515 REPORTER_ASSERT(reporter, 0 == cache->getBudgetedResourceCount());
516 REPORTER_ASSERT(reporter, 0 == cache->getBudgetedResourceBytes());
Derek Sollenbergeree479142017-05-24 11:41:33 -0400517 REPORTER_ASSERT(reporter, 0 == cache->getPurgeableBytes());
bsalomon84c8e622014-11-17 09:33:27 -0800518
519 unbudgeted->unref();
bsalomon0ea80f42015-02-11 10:49:59 -0800520 REPORTER_ASSERT(reporter, 0 == cache->getResourceCount());
521 REPORTER_ASSERT(reporter, 0 == cache->getResourceBytes());
522 REPORTER_ASSERT(reporter, 0 == cache->getBudgetedResourceCount());
523 REPORTER_ASSERT(reporter, 0 == cache->getBudgetedResourceBytes());
Derek Sollenbergeree479142017-05-24 11:41:33 -0400524 REPORTER_ASSERT(reporter, 0 == cache->getPurgeableBytes());
bsalomondace19e2014-11-17 07:34:06 -0800525}
526
bsalomon5236cf42015-01-14 10:42:08 -0800527static void test_unbudgeted(skiatest::Reporter* reporter) {
bsalomonc2f35b72015-01-23 07:19:22 -0800528 Mock mock(10, 30000);
529 GrContext* context = mock.context();
bsalomon0ea80f42015-02-11 10:49:59 -0800530 GrResourceCache* cache = mock.cache();
Robert Phillipsf35fd8d2018-01-22 10:48:15 -0500531 GrGpu* gpu = context->contextPriv().getGpu();
bsalomon5236cf42015-01-14 10:42:08 -0800532
bsalomon8718aaf2015-02-19 07:24:21 -0800533 GrUniqueKey uniqueKey;
534 make_unique_key<0>(&uniqueKey, 0);
bsalomon5236cf42015-01-14 10:42:08 -0800535
536 TestResource* scratch;
bsalomon8718aaf2015-02-19 07:24:21 -0800537 TestResource* unique;
bsalomon5236cf42015-01-14 10:42:08 -0800538 TestResource* wrapped;
539 TestResource* unbudgeted;
540
541 // A large uncached or wrapped resource shouldn't evict anything.
Robert Phillipsf35fd8d2018-01-22 10:48:15 -0500542 scratch = TestResource::CreateScratch(gpu, SkBudgeted::kYes,
kkinnunen2e6055b2016-04-22 01:48:29 -0700543 TestResource::kB_SimulatedProperty);
544
bsalomon5236cf42015-01-14 10:42:08 -0800545 scratch->setSize(10);
546 scratch->unref();
bsalomon0ea80f42015-02-11 10:49:59 -0800547 REPORTER_ASSERT(reporter, 1 == cache->getResourceCount());
548 REPORTER_ASSERT(reporter, 10 == cache->getResourceBytes());
549 REPORTER_ASSERT(reporter, 1 == cache->getBudgetedResourceCount());
550 REPORTER_ASSERT(reporter, 10 == cache->getBudgetedResourceBytes());
Derek Sollenbergeree479142017-05-24 11:41:33 -0400551 REPORTER_ASSERT(reporter, 10 == cache->getPurgeableBytes());
bsalomon5236cf42015-01-14 10:42:08 -0800552
Robert Phillipsf35fd8d2018-01-22 10:48:15 -0500553 unique = new TestResource(gpu);
bsalomon8718aaf2015-02-19 07:24:21 -0800554 unique->setSize(11);
bsalomonf99e9612015-02-19 08:24:16 -0800555 unique->resourcePriv().setUniqueKey(uniqueKey);
bsalomon8718aaf2015-02-19 07:24:21 -0800556 unique->unref();
bsalomon0ea80f42015-02-11 10:49:59 -0800557 REPORTER_ASSERT(reporter, 2 == cache->getResourceCount());
558 REPORTER_ASSERT(reporter, 21 == cache->getResourceBytes());
559 REPORTER_ASSERT(reporter, 2 == cache->getBudgetedResourceCount());
560 REPORTER_ASSERT(reporter, 21 == cache->getBudgetedResourceBytes());
Derek Sollenbergeree479142017-05-24 11:41:33 -0400561 REPORTER_ASSERT(reporter, 21 == cache->getPurgeableBytes());
bsalomon5236cf42015-01-14 10:42:08 -0800562
bsalomon0ea80f42015-02-11 10:49:59 -0800563 size_t large = 2 * cache->getResourceBytes();
Robert Phillipsf35fd8d2018-01-22 10:48:15 -0500564 unbudgeted = new TestResource(gpu, SkBudgeted::kNo, large);
bsalomon0ea80f42015-02-11 10:49:59 -0800565 REPORTER_ASSERT(reporter, 3 == cache->getResourceCount());
566 REPORTER_ASSERT(reporter, 21 + large == cache->getResourceBytes());
567 REPORTER_ASSERT(reporter, 2 == cache->getBudgetedResourceCount());
568 REPORTER_ASSERT(reporter, 21 == cache->getBudgetedResourceBytes());
Derek Sollenbergeree479142017-05-24 11:41:33 -0400569 REPORTER_ASSERT(reporter, 21 == cache->getPurgeableBytes());
bsalomon5236cf42015-01-14 10:42:08 -0800570
571 unbudgeted->unref();
bsalomon0ea80f42015-02-11 10:49:59 -0800572 REPORTER_ASSERT(reporter, 2 == cache->getResourceCount());
573 REPORTER_ASSERT(reporter, 21 == cache->getResourceBytes());
574 REPORTER_ASSERT(reporter, 2 == cache->getBudgetedResourceCount());
575 REPORTER_ASSERT(reporter, 21 == cache->getBudgetedResourceBytes());
Derek Sollenbergeree479142017-05-24 11:41:33 -0400576 REPORTER_ASSERT(reporter, 21 == cache->getPurgeableBytes());
bsalomon5236cf42015-01-14 10:42:08 -0800577
Robert Phillipsf35fd8d2018-01-22 10:48:15 -0500578 wrapped = TestResource::CreateWrapped(gpu, large);
bsalomon0ea80f42015-02-11 10:49:59 -0800579 REPORTER_ASSERT(reporter, 3 == cache->getResourceCount());
580 REPORTER_ASSERT(reporter, 21 + large == cache->getResourceBytes());
581 REPORTER_ASSERT(reporter, 2 == cache->getBudgetedResourceCount());
582 REPORTER_ASSERT(reporter, 21 == cache->getBudgetedResourceBytes());
Derek Sollenbergeree479142017-05-24 11:41:33 -0400583 REPORTER_ASSERT(reporter, 21 == cache->getPurgeableBytes());
bsalomon5236cf42015-01-14 10:42:08 -0800584
585 wrapped->unref();
bsalomon0ea80f42015-02-11 10:49:59 -0800586 REPORTER_ASSERT(reporter, 2 == cache->getResourceCount());
587 REPORTER_ASSERT(reporter, 21 == cache->getResourceBytes());
588 REPORTER_ASSERT(reporter, 2 == cache->getBudgetedResourceCount());
589 REPORTER_ASSERT(reporter, 21 == cache->getBudgetedResourceBytes());
Derek Sollenbergeree479142017-05-24 11:41:33 -0400590 REPORTER_ASSERT(reporter, 21 == cache->getPurgeableBytes());
bsalomon5236cf42015-01-14 10:42:08 -0800591
bsalomon0ea80f42015-02-11 10:49:59 -0800592 cache->purgeAllUnlocked();
593 REPORTER_ASSERT(reporter, 0 == cache->getResourceCount());
594 REPORTER_ASSERT(reporter, 0 == cache->getResourceBytes());
595 REPORTER_ASSERT(reporter, 0 == cache->getBudgetedResourceCount());
596 REPORTER_ASSERT(reporter, 0 == cache->getBudgetedResourceBytes());
Derek Sollenbergeree479142017-05-24 11:41:33 -0400597 REPORTER_ASSERT(reporter, 0 == cache->getPurgeableBytes());
bsalomon5236cf42015-01-14 10:42:08 -0800598}
599
bsalomon3582d3e2015-02-13 14:20:05 -0800600// This method can't be static because it needs to friended in GrGpuResource::CacheAccess.
601void test_unbudgeted_to_scratch(skiatest::Reporter* reporter);
602/*static*/ void test_unbudgeted_to_scratch(skiatest::Reporter* reporter) {
bsalomonc2f35b72015-01-23 07:19:22 -0800603 Mock mock(10, 300);
604 GrContext* context = mock.context();
bsalomon0ea80f42015-02-11 10:49:59 -0800605 GrResourceCache* cache = mock.cache();
Robert Phillipsf35fd8d2018-01-22 10:48:15 -0500606 GrGpu* gpu = context->contextPriv().getGpu();
bsalomonc2f35b72015-01-23 07:19:22 -0800607
608 TestResource* resource =
Robert Phillipsf35fd8d2018-01-22 10:48:15 -0500609 TestResource::CreateScratch(gpu, SkBudgeted::kNo, TestResource::kA_SimulatedProperty);
bsalomonc2f35b72015-01-23 07:19:22 -0800610 GrScratchKey key;
bsalomon23e619c2015-02-06 11:54:28 -0800611 TestResource::ComputeScratchKey(TestResource::kA_SimulatedProperty, &key);
bsalomonc2f35b72015-01-23 07:19:22 -0800612
613 size_t size = resource->gpuMemorySize();
614 for (int i = 0; i < 2; ++i) {
615 // Since this resource is unbudgeted, it should not be reachable as scratch.
bsalomon3582d3e2015-02-13 14:20:05 -0800616 REPORTER_ASSERT(reporter, resource->resourcePriv().getScratchKey() == key);
bsalomonc2f35b72015-01-23 07:19:22 -0800617 REPORTER_ASSERT(reporter, !resource->cacheAccess().isScratch());
bsalomon5ec26ae2016-02-25 08:33:02 -0800618 REPORTER_ASSERT(reporter, SkBudgeted::kNo == resource->resourcePriv().isBudgeted());
halcanary96fcdcc2015-08-27 07:41:13 -0700619 REPORTER_ASSERT(reporter, nullptr == cache->findAndRefScratchResource(key, TestResource::kDefaultSize, 0));
bsalomon0ea80f42015-02-11 10:49:59 -0800620 REPORTER_ASSERT(reporter, 1 == cache->getResourceCount());
621 REPORTER_ASSERT(reporter, size == cache->getResourceBytes());
622 REPORTER_ASSERT(reporter, 0 == cache->getBudgetedResourceCount());
623 REPORTER_ASSERT(reporter, 0 == cache->getBudgetedResourceBytes());
Derek Sollenbergeree479142017-05-24 11:41:33 -0400624 REPORTER_ASSERT(reporter, 0 == cache->getPurgeableBytes());
bsalomonc2f35b72015-01-23 07:19:22 -0800625
626 // Once it is unrefed, it should become available as scratch.
627 resource->unref();
bsalomon0ea80f42015-02-11 10:49:59 -0800628 REPORTER_ASSERT(reporter, 1 == cache->getResourceCount());
629 REPORTER_ASSERT(reporter, size == cache->getResourceBytes());
630 REPORTER_ASSERT(reporter, 1 == cache->getBudgetedResourceCount());
631 REPORTER_ASSERT(reporter, size == cache->getBudgetedResourceBytes());
Derek Sollenbergeree479142017-05-24 11:41:33 -0400632 REPORTER_ASSERT(reporter, size == cache->getPurgeableBytes());
robertphillips6e83ac72015-08-13 05:19:14 -0700633 resource = static_cast<TestResource*>(cache->findAndRefScratchResource(key, TestResource::kDefaultSize, 0));
bsalomonc2f35b72015-01-23 07:19:22 -0800634 REPORTER_ASSERT(reporter, resource);
bsalomon3582d3e2015-02-13 14:20:05 -0800635 REPORTER_ASSERT(reporter, resource->resourcePriv().getScratchKey() == key);
bsalomonc2f35b72015-01-23 07:19:22 -0800636 REPORTER_ASSERT(reporter, resource->cacheAccess().isScratch());
bsalomon5ec26ae2016-02-25 08:33:02 -0800637 REPORTER_ASSERT(reporter, SkBudgeted::kYes == resource->resourcePriv().isBudgeted());
bsalomonc2f35b72015-01-23 07:19:22 -0800638
639 if (0 == i) {
mtklein5f939ab2016-03-16 10:28:35 -0700640 // If made unbudgeted, it should return to original state: ref'ed and unbudgeted. Try
bsalomonc2f35b72015-01-23 07:19:22 -0800641 // the above tests again.
bsalomon3582d3e2015-02-13 14:20:05 -0800642 resource->resourcePriv().makeUnbudgeted();
bsalomonc2f35b72015-01-23 07:19:22 -0800643 } else {
644 // After the second time around, try removing the scratch key
bsalomon3582d3e2015-02-13 14:20:05 -0800645 resource->resourcePriv().removeScratchKey();
bsalomon0ea80f42015-02-11 10:49:59 -0800646 REPORTER_ASSERT(reporter, 1 == cache->getResourceCount());
647 REPORTER_ASSERT(reporter, size == cache->getResourceBytes());
648 REPORTER_ASSERT(reporter, 1 == cache->getBudgetedResourceCount());
649 REPORTER_ASSERT(reporter, size == cache->getBudgetedResourceBytes());
Derek Sollenbergeree479142017-05-24 11:41:33 -0400650 REPORTER_ASSERT(reporter, 0 == cache->getPurgeableBytes());
bsalomon3582d3e2015-02-13 14:20:05 -0800651 REPORTER_ASSERT(reporter, !resource->resourcePriv().getScratchKey().isValid());
bsalomonc2f35b72015-01-23 07:19:22 -0800652 REPORTER_ASSERT(reporter, !resource->cacheAccess().isScratch());
bsalomon5ec26ae2016-02-25 08:33:02 -0800653 REPORTER_ASSERT(reporter, SkBudgeted::kYes == resource->resourcePriv().isBudgeted());
bsalomonc2f35b72015-01-23 07:19:22 -0800654
655 // now when it is unrefed it should die since it has no key.
656 resource->unref();
bsalomon0ea80f42015-02-11 10:49:59 -0800657 REPORTER_ASSERT(reporter, 0 == cache->getResourceCount());
658 REPORTER_ASSERT(reporter, 0 == cache->getResourceBytes());
659 REPORTER_ASSERT(reporter, 0 == cache->getBudgetedResourceCount());
660 REPORTER_ASSERT(reporter, 0 == cache->getBudgetedResourceBytes());
Derek Sollenbergeree479142017-05-24 11:41:33 -0400661 REPORTER_ASSERT(reporter, 0 == cache->getPurgeableBytes());
bsalomonc2f35b72015-01-23 07:19:22 -0800662 }
bsalomon8b79d232014-11-10 10:19:06 -0800663 }
bsalomonc2f35b72015-01-23 07:19:22 -0800664}
665
666static void test_duplicate_scratch_key(skiatest::Reporter* reporter) {
667 Mock mock(5, 30000);
668 GrContext* context = mock.context();
bsalomon0ea80f42015-02-11 10:49:59 -0800669 GrResourceCache* cache = mock.cache();
Robert Phillipsf35fd8d2018-01-22 10:48:15 -0500670 GrGpu* gpu = context->contextPriv().getGpu();
bsalomon8b79d232014-11-10 10:19:06 -0800671
bsalomon8b79d232014-11-10 10:19:06 -0800672 // Create two resources that have the same scratch key.
Robert Phillipsf35fd8d2018-01-22 10:48:15 -0500673 TestResource* a = TestResource::CreateScratch(gpu,
kkinnunen2e6055b2016-04-22 01:48:29 -0700674 SkBudgeted::kYes,
bsalomon23e619c2015-02-06 11:54:28 -0800675 TestResource::kB_SimulatedProperty);
Robert Phillipsf35fd8d2018-01-22 10:48:15 -0500676 TestResource* b = TestResource::CreateScratch(gpu,
kkinnunen2e6055b2016-04-22 01:48:29 -0700677 SkBudgeted::kYes,
bsalomon23e619c2015-02-06 11:54:28 -0800678 TestResource::kB_SimulatedProperty);
bsalomon8b79d232014-11-10 10:19:06 -0800679 a->setSize(11);
680 b->setSize(12);
bsalomon1c60dfe2015-01-21 09:32:40 -0800681 GrScratchKey scratchKey1;
bsalomon23e619c2015-02-06 11:54:28 -0800682 TestResource::ComputeScratchKey(TestResource::kA_SimulatedProperty, &scratchKey1);
bsalomon1c60dfe2015-01-21 09:32:40 -0800683 // Check for negative case consistency. (leaks upon test failure.)
halcanary96fcdcc2015-08-27 07:41:13 -0700684 REPORTER_ASSERT(reporter, nullptr == cache->findAndRefScratchResource(scratchKey1, TestResource::kDefaultSize, 0));
bsalomon1c60dfe2015-01-21 09:32:40 -0800685
686 GrScratchKey scratchKey;
bsalomon23e619c2015-02-06 11:54:28 -0800687 TestResource::ComputeScratchKey(TestResource::kB_SimulatedProperty, &scratchKey);
bsalomon1c60dfe2015-01-21 09:32:40 -0800688
bsalomon0ea80f42015-02-11 10:49:59 -0800689 // Scratch resources are registered with GrResourceCache just by existing. There are 2.
bsalomon8b79d232014-11-10 10:19:06 -0800690 REPORTER_ASSERT(reporter, 2 == TestResource::NumAlive());
bsalomon0ea80f42015-02-11 10:49:59 -0800691 SkDEBUGCODE(REPORTER_ASSERT(reporter, 2 == cache->countScratchEntriesForKey(scratchKey));)
692 REPORTER_ASSERT(reporter, 2 == cache->getResourceCount());
bsalomon71cb0c22014-11-14 12:10:14 -0800693 REPORTER_ASSERT(reporter, a->gpuMemorySize() + b->gpuMemorySize() ==
bsalomon0ea80f42015-02-11 10:49:59 -0800694 cache->getResourceBytes());
bsalomon8b79d232014-11-10 10:19:06 -0800695
bsalomon63c992f2015-01-23 12:47:59 -0800696 // Our refs mean that the resources are non purgeable.
bsalomon0ea80f42015-02-11 10:49:59 -0800697 cache->purgeAllUnlocked();
bsalomon8b79d232014-11-10 10:19:06 -0800698 REPORTER_ASSERT(reporter, 2 == TestResource::NumAlive());
bsalomon0ea80f42015-02-11 10:49:59 -0800699 REPORTER_ASSERT(reporter, 2 == cache->getResourceCount());
bsalomon8b79d232014-11-10 10:19:06 -0800700
701 // Unref but don't purge
702 a->unref();
703 b->unref();
704 REPORTER_ASSERT(reporter, 2 == TestResource::NumAlive());
bsalomon0ea80f42015-02-11 10:49:59 -0800705 SkDEBUGCODE(REPORTER_ASSERT(reporter, 2 == cache->countScratchEntriesForKey(scratchKey));)
bsalomon8b79d232014-11-10 10:19:06 -0800706
bsalomon63c992f2015-01-23 12:47:59 -0800707 // Purge again. This time resources should be purgeable.
bsalomon0ea80f42015-02-11 10:49:59 -0800708 cache->purgeAllUnlocked();
bsalomon8b79d232014-11-10 10:19:06 -0800709 REPORTER_ASSERT(reporter, 0 == TestResource::NumAlive());
bsalomon0ea80f42015-02-11 10:49:59 -0800710 REPORTER_ASSERT(reporter, 0 == cache->getResourceCount());
711 SkDEBUGCODE(REPORTER_ASSERT(reporter, 0 == cache->countScratchEntriesForKey(scratchKey));)
bsalomon8b79d232014-11-10 10:19:06 -0800712}
713
bsalomon10e23ca2014-11-25 05:52:06 -0800714static void test_remove_scratch_key(skiatest::Reporter* reporter) {
bsalomonc2f35b72015-01-23 07:19:22 -0800715 Mock mock(5, 30000);
716 GrContext* context = mock.context();
bsalomon0ea80f42015-02-11 10:49:59 -0800717 GrResourceCache* cache = mock.cache();
Robert Phillipsf35fd8d2018-01-22 10:48:15 -0500718 GrGpu* gpu = context->contextPriv().getGpu();
bsalomon10e23ca2014-11-25 05:52:06 -0800719
bsalomon10e23ca2014-11-25 05:52:06 -0800720 // Create two resources that have the same scratch key.
Robert Phillipsf35fd8d2018-01-22 10:48:15 -0500721 TestResource* a = TestResource::CreateScratch(gpu, SkBudgeted::kYes,
bsalomon23e619c2015-02-06 11:54:28 -0800722 TestResource::kB_SimulatedProperty);
Robert Phillipsf35fd8d2018-01-22 10:48:15 -0500723 TestResource* b = TestResource::CreateScratch(gpu, SkBudgeted::kYes,
bsalomon23e619c2015-02-06 11:54:28 -0800724 TestResource::kB_SimulatedProperty);
bsalomon10e23ca2014-11-25 05:52:06 -0800725 a->unref();
726 b->unref();
727
bsalomon1c60dfe2015-01-21 09:32:40 -0800728 GrScratchKey scratchKey;
729 // Ensure that scratch key lookup is correct for negative case.
bsalomon23e619c2015-02-06 11:54:28 -0800730 TestResource::ComputeScratchKey(TestResource::kA_SimulatedProperty, &scratchKey);
bsalomon1c60dfe2015-01-21 09:32:40 -0800731 // (following leaks upon test failure).
halcanary96fcdcc2015-08-27 07:41:13 -0700732 REPORTER_ASSERT(reporter, cache->findAndRefScratchResource(scratchKey, TestResource::kDefaultSize, 0) == nullptr);
bsalomon1c60dfe2015-01-21 09:32:40 -0800733
bsalomon0ea80f42015-02-11 10:49:59 -0800734 // Scratch resources are registered with GrResourceCache just by existing. There are 2.
bsalomon23e619c2015-02-06 11:54:28 -0800735 TestResource::ComputeScratchKey(TestResource::kB_SimulatedProperty, &scratchKey);
bsalomon10e23ca2014-11-25 05:52:06 -0800736 REPORTER_ASSERT(reporter, 2 == TestResource::NumAlive());
bsalomon0ea80f42015-02-11 10:49:59 -0800737 SkDEBUGCODE(REPORTER_ASSERT(reporter, 2 == cache->countScratchEntriesForKey(scratchKey));)
738 REPORTER_ASSERT(reporter, 2 == cache->getResourceCount());
bsalomon10e23ca2014-11-25 05:52:06 -0800739
740 // Find the first resource and remove its scratch key
741 GrGpuResource* find;
robertphillips6e83ac72015-08-13 05:19:14 -0700742 find = cache->findAndRefScratchResource(scratchKey, TestResource::kDefaultSize, 0);
bsalomon3582d3e2015-02-13 14:20:05 -0800743 find->resourcePriv().removeScratchKey();
bsalomon10e23ca2014-11-25 05:52:06 -0800744 // It's still alive, but not cached by scratch key anymore
745 REPORTER_ASSERT(reporter, 2 == TestResource::NumAlive());
bsalomon0ea80f42015-02-11 10:49:59 -0800746 SkDEBUGCODE(REPORTER_ASSERT(reporter, 1 == cache->countScratchEntriesForKey(scratchKey));)
747 REPORTER_ASSERT(reporter, 2 == cache->getResourceCount());
bsalomon10e23ca2014-11-25 05:52:06 -0800748
749 // The cache should immediately delete it when it's unrefed since it isn't accessible.
750 find->unref();
751 REPORTER_ASSERT(reporter, 1 == TestResource::NumAlive());
bsalomon0ea80f42015-02-11 10:49:59 -0800752 SkDEBUGCODE(REPORTER_ASSERT(reporter, 1 == cache->countScratchEntriesForKey(scratchKey));)
753 REPORTER_ASSERT(reporter, 1 == cache->getResourceCount());
bsalomon10e23ca2014-11-25 05:52:06 -0800754
755 // Repeat for the second resource.
robertphillips6e83ac72015-08-13 05:19:14 -0700756 find = cache->findAndRefScratchResource(scratchKey, TestResource::kDefaultSize, 0);
bsalomon3582d3e2015-02-13 14:20:05 -0800757 find->resourcePriv().removeScratchKey();
bsalomon10e23ca2014-11-25 05:52:06 -0800758 REPORTER_ASSERT(reporter, 1 == TestResource::NumAlive());
bsalomon0ea80f42015-02-11 10:49:59 -0800759 SkDEBUGCODE(REPORTER_ASSERT(reporter, 0 == cache->countScratchEntriesForKey(scratchKey));)
760 REPORTER_ASSERT(reporter, 1 == cache->getResourceCount());
bsalomon10e23ca2014-11-25 05:52:06 -0800761
762 // Should be able to call this multiple times with no problem.
bsalomon3582d3e2015-02-13 14:20:05 -0800763 find->resourcePriv().removeScratchKey();
bsalomon10e23ca2014-11-25 05:52:06 -0800764 REPORTER_ASSERT(reporter, 1 == TestResource::NumAlive());
bsalomon0ea80f42015-02-11 10:49:59 -0800765 SkDEBUGCODE(REPORTER_ASSERT(reporter, 0 == cache->countScratchEntriesForKey(scratchKey));)
766 REPORTER_ASSERT(reporter, 1 == cache->getResourceCount());
bsalomon10e23ca2014-11-25 05:52:06 -0800767
768 find->unref();
769 REPORTER_ASSERT(reporter, 0 == TestResource::NumAlive());
bsalomon0ea80f42015-02-11 10:49:59 -0800770 SkDEBUGCODE(REPORTER_ASSERT(reporter, 0 == cache->countScratchEntriesForKey(scratchKey));)
771 REPORTER_ASSERT(reporter, 0 == cache->getResourceCount());
bsalomon10e23ca2014-11-25 05:52:06 -0800772}
773
bsalomon1c60dfe2015-01-21 09:32:40 -0800774static void test_scratch_key_consistency(skiatest::Reporter* reporter) {
bsalomonc2f35b72015-01-23 07:19:22 -0800775 Mock mock(5, 30000);
776 GrContext* context = mock.context();
bsalomon0ea80f42015-02-11 10:49:59 -0800777 GrResourceCache* cache = mock.cache();
Robert Phillipsf35fd8d2018-01-22 10:48:15 -0500778 GrGpu* gpu = context->contextPriv().getGpu();
bsalomon1c60dfe2015-01-21 09:32:40 -0800779
780 // Create two resources that have the same scratch key.
Robert Phillipsf35fd8d2018-01-22 10:48:15 -0500781 TestResource* a = TestResource::CreateScratch(gpu, SkBudgeted::kYes,
bsalomon23e619c2015-02-06 11:54:28 -0800782 TestResource::kB_SimulatedProperty);
Robert Phillipsf35fd8d2018-01-22 10:48:15 -0500783 TestResource* b = TestResource::CreateScratch(gpu, SkBudgeted::kYes,
bsalomon23e619c2015-02-06 11:54:28 -0800784 TestResource::kB_SimulatedProperty);
bsalomon1c60dfe2015-01-21 09:32:40 -0800785 a->unref();
786 b->unref();
787
788 GrScratchKey scratchKey;
789 // Ensure that scratch key comparison and assignment is consistent.
790 GrScratchKey scratchKey1;
bsalomon23e619c2015-02-06 11:54:28 -0800791 TestResource::ComputeScratchKey(TestResource::kA_SimulatedProperty, &scratchKey1);
bsalomon1c60dfe2015-01-21 09:32:40 -0800792 GrScratchKey scratchKey2;
bsalomon23e619c2015-02-06 11:54:28 -0800793 TestResource::ComputeScratchKey(TestResource::kB_SimulatedProperty, &scratchKey2);
bsalomon1c60dfe2015-01-21 09:32:40 -0800794 REPORTER_ASSERT(reporter, scratchKey1.size() == TestResource::ExpectedScratchKeySize());
795 REPORTER_ASSERT(reporter, scratchKey1 != scratchKey2);
796 REPORTER_ASSERT(reporter, scratchKey2 != scratchKey1);
797 scratchKey = scratchKey1;
798 REPORTER_ASSERT(reporter, scratchKey.size() == TestResource::ExpectedScratchKeySize());
799 REPORTER_ASSERT(reporter, scratchKey1 == scratchKey);
800 REPORTER_ASSERT(reporter, scratchKey == scratchKey1);
801 REPORTER_ASSERT(reporter, scratchKey2 != scratchKey);
802 REPORTER_ASSERT(reporter, scratchKey != scratchKey2);
803 scratchKey = scratchKey2;
804 REPORTER_ASSERT(reporter, scratchKey.size() == TestResource::ExpectedScratchKeySize());
805 REPORTER_ASSERT(reporter, scratchKey1 != scratchKey);
806 REPORTER_ASSERT(reporter, scratchKey != scratchKey1);
807 REPORTER_ASSERT(reporter, scratchKey2 == scratchKey);
808 REPORTER_ASSERT(reporter, scratchKey == scratchKey2);
809
810 // Ensure that scratch key lookup is correct for negative case.
bsalomon23e619c2015-02-06 11:54:28 -0800811 TestResource::ComputeScratchKey(TestResource::kA_SimulatedProperty, &scratchKey);
bsalomon1c60dfe2015-01-21 09:32:40 -0800812 // (following leaks upon test failure).
halcanary96fcdcc2015-08-27 07:41:13 -0700813 REPORTER_ASSERT(reporter, cache->findAndRefScratchResource(scratchKey, TestResource::kDefaultSize, 0) == nullptr);
bsalomon1c60dfe2015-01-21 09:32:40 -0800814
815 // Find the first resource with a scratch key and a copy of a scratch key.
bsalomon23e619c2015-02-06 11:54:28 -0800816 TestResource::ComputeScratchKey(TestResource::kB_SimulatedProperty, &scratchKey);
robertphillips6e83ac72015-08-13 05:19:14 -0700817 GrGpuResource* find = cache->findAndRefScratchResource(scratchKey, TestResource::kDefaultSize, 0);
halcanary96fcdcc2015-08-27 07:41:13 -0700818 REPORTER_ASSERT(reporter, find != nullptr);
bsalomon1c60dfe2015-01-21 09:32:40 -0800819 find->unref();
820
821 scratchKey2 = scratchKey;
robertphillips6e83ac72015-08-13 05:19:14 -0700822 find = cache->findAndRefScratchResource(scratchKey2, TestResource::kDefaultSize, 0);
halcanary96fcdcc2015-08-27 07:41:13 -0700823 REPORTER_ASSERT(reporter, find != nullptr);
bsalomon1c60dfe2015-01-21 09:32:40 -0800824 REPORTER_ASSERT(reporter, find == a || find == b);
825
robertphillips6e83ac72015-08-13 05:19:14 -0700826 GrGpuResource* find2 = cache->findAndRefScratchResource(scratchKey2, TestResource::kDefaultSize, 0);
halcanary96fcdcc2015-08-27 07:41:13 -0700827 REPORTER_ASSERT(reporter, find2 != nullptr);
bsalomon1c60dfe2015-01-21 09:32:40 -0800828 REPORTER_ASSERT(reporter, find2 == a || find2 == b);
829 REPORTER_ASSERT(reporter, find2 != find);
830 find2->unref();
831 find->unref();
832}
833
bsalomon8718aaf2015-02-19 07:24:21 -0800834static void test_duplicate_unique_key(skiatest::Reporter* reporter) {
bsalomonc2f35b72015-01-23 07:19:22 -0800835 Mock mock(5, 30000);
836 GrContext* context = mock.context();
bsalomon0ea80f42015-02-11 10:49:59 -0800837 GrResourceCache* cache = mock.cache();
Robert Phillipsf35fd8d2018-01-22 10:48:15 -0500838 GrGpu* gpu = context->contextPriv().getGpu();
commit-bot@chromium.orgc6658042014-01-15 23:09:01 +0000839
bsalomon8718aaf2015-02-19 07:24:21 -0800840 GrUniqueKey key;
841 make_unique_key<0>(&key, 0);
mtklein5f939ab2016-03-16 10:28:35 -0700842
bsalomon8718aaf2015-02-19 07:24:21 -0800843 // Create two resources that we will attempt to register with the same unique key.
Robert Phillipsf35fd8d2018-01-22 10:48:15 -0500844 TestResource* a = new TestResource(gpu);
bsalomon8b79d232014-11-10 10:19:06 -0800845 a->setSize(11);
mtklein5f939ab2016-03-16 10:28:35 -0700846
bsalomonf99e9612015-02-19 08:24:16 -0800847 // Set key on resource a.
848 a->resourcePriv().setUniqueKey(key);
849 REPORTER_ASSERT(reporter, a == cache->findAndRefUniqueResource(key));
850 a->unref();
bsalomon71cb0c22014-11-14 12:10:14 -0800851
bsalomonf99e9612015-02-19 08:24:16 -0800852 // Make sure that redundantly setting a's key works.
853 a->resourcePriv().setUniqueKey(key);
854 REPORTER_ASSERT(reporter, a == cache->findAndRefUniqueResource(key));
bsalomon8b79d232014-11-10 10:19:06 -0800855 a->unref();
bsalomon0ea80f42015-02-11 10:49:59 -0800856 REPORTER_ASSERT(reporter, 1 == cache->getResourceCount());
857 REPORTER_ASSERT(reporter, a->gpuMemorySize() == cache->getResourceBytes());
bsalomon71cb0c22014-11-14 12:10:14 -0800858 REPORTER_ASSERT(reporter, 1 == TestResource::NumAlive());
859
bsalomonf99e9612015-02-19 08:24:16 -0800860 // Create resource b and set the same key. It should replace a's unique key cache entry.
Robert Phillipsf35fd8d2018-01-22 10:48:15 -0500861 TestResource* b = new TestResource(gpu);
bsalomonf99e9612015-02-19 08:24:16 -0800862 b->setSize(12);
863 b->resourcePriv().setUniqueKey(key);
864 REPORTER_ASSERT(reporter, b == cache->findAndRefUniqueResource(key));
865 b->unref();
866
867 // Still have two resources because a is still reffed.
868 REPORTER_ASSERT(reporter, 2 == cache->getResourceCount());
869 REPORTER_ASSERT(reporter, a->gpuMemorySize() + b->gpuMemorySize() == cache->getResourceBytes());
870 REPORTER_ASSERT(reporter, 2 == TestResource::NumAlive());
871
872 a->unref();
873 // Now a should be gone.
874 REPORTER_ASSERT(reporter, 1 == cache->getResourceCount());
875 REPORTER_ASSERT(reporter, b->gpuMemorySize() == cache->getResourceBytes());
876 REPORTER_ASSERT(reporter, 1 == TestResource::NumAlive());
877
878 // Now replace b with c, but make sure c can start with one unique key and change it to b's key.
879 // Also make b be unreffed when replacement occurs.
880 b->unref();
Robert Phillipsf35fd8d2018-01-22 10:48:15 -0500881 TestResource* c = new TestResource(gpu);
bsalomonf99e9612015-02-19 08:24:16 -0800882 GrUniqueKey differentKey;
883 make_unique_key<0>(&differentKey, 1);
884 c->setSize(13);
885 c->resourcePriv().setUniqueKey(differentKey);
886 REPORTER_ASSERT(reporter, 2 == cache->getResourceCount());
887 REPORTER_ASSERT(reporter, b->gpuMemorySize() + c->gpuMemorySize() == cache->getResourceBytes());
888 REPORTER_ASSERT(reporter, 2 == TestResource::NumAlive());
889 // c replaces b and b should be immediately purged.
890 c->resourcePriv().setUniqueKey(key);
891 REPORTER_ASSERT(reporter, 1 == cache->getResourceCount());
892 REPORTER_ASSERT(reporter, c->gpuMemorySize() == cache->getResourceBytes());
893 REPORTER_ASSERT(reporter, 1 == TestResource::NumAlive());
894
895 // c shouldn't be purged because it is ref'ed.
bsalomon0ea80f42015-02-11 10:49:59 -0800896 cache->purgeAllUnlocked();
bsalomonf99e9612015-02-19 08:24:16 -0800897 REPORTER_ASSERT(reporter, 1 == cache->getResourceCount());
898 REPORTER_ASSERT(reporter, c->gpuMemorySize() == cache->getResourceBytes());
899 REPORTER_ASSERT(reporter, 1 == TestResource::NumAlive());
900
901 // Drop the ref on c, it should be kept alive because it has a unique key.
902 c->unref();
903 REPORTER_ASSERT(reporter, 1 == cache->getResourceCount());
904 REPORTER_ASSERT(reporter, c->gpuMemorySize() == cache->getResourceBytes());
905 REPORTER_ASSERT(reporter, 1 == TestResource::NumAlive());
906
907 // Verify that we can find c, then remove its unique key. It should get purged immediately.
908 REPORTER_ASSERT(reporter, c == cache->findAndRefUniqueResource(key));
909 c->resourcePriv().removeUniqueKey();
910 c->unref();
bsalomon0ea80f42015-02-11 10:49:59 -0800911 REPORTER_ASSERT(reporter, 0 == cache->getResourceCount());
912 REPORTER_ASSERT(reporter, 0 == cache->getResourceBytes());
bsalomon33435572014-11-05 14:47:41 -0800913 REPORTER_ASSERT(reporter, 0 == TestResource::NumAlive());
senorblanco84cd6212015-08-04 10:01:58 -0700914
915 {
916 GrUniqueKey key2;
917 make_unique_key<0>(&key2, 0);
Robert Phillipsf35fd8d2018-01-22 10:48:15 -0500918 sk_sp<TestResource> d(new TestResource(gpu));
senorblanco84cd6212015-08-04 10:01:58 -0700919 int foo = 4132;
bungeman38d909e2016-08-02 14:40:46 -0700920 key2.setCustomData(SkData::MakeWithCopy(&foo, sizeof(foo)));
senorblanco84cd6212015-08-04 10:01:58 -0700921 d->resourcePriv().setUniqueKey(key2);
922 }
923
924 GrUniqueKey key3;
925 make_unique_key<0>(&key3, 0);
Hal Canary342b7ac2016-11-04 11:49:42 -0400926 sk_sp<GrGpuResource> d2(cache->findAndRefUniqueResource(key3));
senorblanco84cd6212015-08-04 10:01:58 -0700927 REPORTER_ASSERT(reporter, *(int*) d2->getUniqueKey().getCustomData()->data() == 4132);
commit-bot@chromium.orgc6658042014-01-15 23:09:01 +0000928}
929
bsalomon8b79d232014-11-10 10:19:06 -0800930static void test_purge_invalidated(skiatest::Reporter* reporter) {
bsalomonc2f35b72015-01-23 07:19:22 -0800931 Mock mock(5, 30000);
932 GrContext* context = mock.context();
bsalomon0ea80f42015-02-11 10:49:59 -0800933 GrResourceCache* cache = mock.cache();
Robert Phillipsf35fd8d2018-01-22 10:48:15 -0500934 GrGpu* gpu = context->contextPriv().getGpu();
bsalomon8b79d232014-11-10 10:19:06 -0800935
bsalomon8718aaf2015-02-19 07:24:21 -0800936 GrUniqueKey key1, key2, key3;
937 make_unique_key<0>(&key1, 1);
938 make_unique_key<0>(&key2, 2);
939 make_unique_key<0>(&key3, 3);
mtklein5f939ab2016-03-16 10:28:35 -0700940
bsalomon23e619c2015-02-06 11:54:28 -0800941 // Add three resources to the cache. Only c is usable as scratch.
Robert Phillipsf35fd8d2018-01-22 10:48:15 -0500942 TestResource* a = new TestResource(gpu);
943 TestResource* b = new TestResource(gpu);
944 TestResource* c = TestResource::CreateScratch(gpu, SkBudgeted::kYes,
bsalomon23e619c2015-02-06 11:54:28 -0800945 TestResource::kA_SimulatedProperty);
bsalomon8718aaf2015-02-19 07:24:21 -0800946 a->resourcePriv().setUniqueKey(key1);
947 b->resourcePriv().setUniqueKey(key2);
948 c->resourcePriv().setUniqueKey(key3);
bsalomon8b79d232014-11-10 10:19:06 -0800949 a->unref();
bsalomon23e619c2015-02-06 11:54:28 -0800950 // hold b until *after* the message is sent.
bsalomon8b79d232014-11-10 10:19:06 -0800951 c->unref();
952
bsalomon8718aaf2015-02-19 07:24:21 -0800953 REPORTER_ASSERT(reporter, cache->hasUniqueKey(key1));
954 REPORTER_ASSERT(reporter, cache->hasUniqueKey(key2));
955 REPORTER_ASSERT(reporter, cache->hasUniqueKey(key3));
bsalomon8b79d232014-11-10 10:19:06 -0800956 REPORTER_ASSERT(reporter, 3 == TestResource::NumAlive());
bsalomon23e619c2015-02-06 11:54:28 -0800957
bsalomon8718aaf2015-02-19 07:24:21 -0800958 typedef GrUniqueKeyInvalidatedMessage Msg;
959 typedef SkMessageBus<GrUniqueKeyInvalidatedMessage> Bus;
bsalomon23e619c2015-02-06 11:54:28 -0800960
961 // Invalidate two of the three, they should be purged and no longer accessible via their keys.
962 Bus::Post(Msg(key1));
963 Bus::Post(Msg(key2));
bsalomon0ea80f42015-02-11 10:49:59 -0800964 cache->purgeAsNeeded();
bsalomon23e619c2015-02-06 11:54:28 -0800965 // a should be deleted now, but we still have a ref on b.
bsalomon8718aaf2015-02-19 07:24:21 -0800966 REPORTER_ASSERT(reporter, !cache->hasUniqueKey(key1));
967 REPORTER_ASSERT(reporter, !cache->hasUniqueKey(key2));
bsalomon23e619c2015-02-06 11:54:28 -0800968 REPORTER_ASSERT(reporter, 2 == TestResource::NumAlive());
bsalomon8718aaf2015-02-19 07:24:21 -0800969 REPORTER_ASSERT(reporter, cache->hasUniqueKey(key3));
bsalomon8b79d232014-11-10 10:19:06 -0800970
971 // Invalidate the third.
bsalomon23e619c2015-02-06 11:54:28 -0800972 Bus::Post(Msg(key3));
bsalomon0ea80f42015-02-11 10:49:59 -0800973 cache->purgeAsNeeded();
bsalomon23e619c2015-02-06 11:54:28 -0800974 // we still have a ref on b, c should be recycled as scratch.
975 REPORTER_ASSERT(reporter, 2 == TestResource::NumAlive());
bsalomon8718aaf2015-02-19 07:24:21 -0800976 REPORTER_ASSERT(reporter, !cache->hasUniqueKey(key3));
bsalomon71cb0c22014-11-14 12:10:14 -0800977
bsalomon23e619c2015-02-06 11:54:28 -0800978 // make b purgeable. It should be immediately deleted since it has no key.
979 b->unref();
980 REPORTER_ASSERT(reporter, 1 == TestResource::NumAlive());
981
982 // Make sure we actually get to c via it's scratch key, before we say goodbye.
983 GrScratchKey scratchKey;
984 TestResource::ComputeScratchKey(TestResource::kA_SimulatedProperty, &scratchKey);
robertphillips6e83ac72015-08-13 05:19:14 -0700985 GrGpuResource* scratch = cache->findAndRefScratchResource(scratchKey, TestResource::kDefaultSize, 0);
bsalomon23e619c2015-02-06 11:54:28 -0800986 REPORTER_ASSERT(reporter, scratch == c);
987 SkSafeUnref(scratch);
988
989 // Get rid of c.
bsalomon0ea80f42015-02-11 10:49:59 -0800990 cache->purgeAllUnlocked();
robertphillips6e83ac72015-08-13 05:19:14 -0700991 scratch = cache->findAndRefScratchResource(scratchKey, TestResource::kDefaultSize, 0);
bsalomon71cb0c22014-11-14 12:10:14 -0800992 REPORTER_ASSERT(reporter, 0 == TestResource::NumAlive());
bsalomon0ea80f42015-02-11 10:49:59 -0800993 REPORTER_ASSERT(reporter, 0 == cache->getResourceCount());
994 REPORTER_ASSERT(reporter, 0 == cache->getResourceBytes());
bsalomon23e619c2015-02-06 11:54:28 -0800995 REPORTER_ASSERT(reporter, !scratch);
996 SkSafeUnref(scratch);
bsalomon8b79d232014-11-10 10:19:06 -0800997}
998
bsalomon71cb0c22014-11-14 12:10:14 -0800999static void test_cache_chained_purge(skiatest::Reporter* reporter) {
bsalomonc2f35b72015-01-23 07:19:22 -08001000 Mock mock(3, 30000);
1001 GrContext* context = mock.context();
bsalomon0ea80f42015-02-11 10:49:59 -08001002 GrResourceCache* cache = mock.cache();
Robert Phillipsf35fd8d2018-01-22 10:48:15 -05001003 GrGpu* gpu = context->contextPriv().getGpu();
bsalomon8b79d232014-11-10 10:19:06 -08001004
bsalomon8718aaf2015-02-19 07:24:21 -08001005 GrUniqueKey key1, key2;
1006 make_unique_key<0>(&key1, 1);
1007 make_unique_key<0>(&key2, 2);
commit-bot@chromium.orgbd58feb2014-01-17 17:56:21 +00001008
Robert Phillipsf35fd8d2018-01-22 10:48:15 -05001009 TestResource* a = new TestResource(gpu);
1010 TestResource* b = new TestResource(gpu);
bsalomon8718aaf2015-02-19 07:24:21 -08001011 a->resourcePriv().setUniqueKey(key1);
1012 b->resourcePriv().setUniqueKey(key2);
bsalomon820dd6c2014-11-05 12:09:45 -08001013
bsalomonc2f35b72015-01-23 07:19:22 -08001014 // Make a cycle
1015 a->setUnrefWhenDestroyed(b);
1016 b->setUnrefWhenDestroyed(a);
bsalomon71cb0c22014-11-14 12:10:14 -08001017
bsalomonc2f35b72015-01-23 07:19:22 -08001018 REPORTER_ASSERT(reporter, 2 == TestResource::NumAlive());
bsalomon33435572014-11-05 14:47:41 -08001019
bsalomonc2f35b72015-01-23 07:19:22 -08001020 a->unref();
1021 b->unref();
bsalomon8b79d232014-11-10 10:19:06 -08001022
bsalomonc2f35b72015-01-23 07:19:22 -08001023 REPORTER_ASSERT(reporter, 2 == TestResource::NumAlive());
bsalomon8b79d232014-11-10 10:19:06 -08001024
bsalomon0ea80f42015-02-11 10:49:59 -08001025 cache->purgeAllUnlocked();
bsalomonc2f35b72015-01-23 07:19:22 -08001026 REPORTER_ASSERT(reporter, 2 == TestResource::NumAlive());
bsalomon8b79d232014-11-10 10:19:06 -08001027
bsalomonc2f35b72015-01-23 07:19:22 -08001028 // Break the cycle
halcanary96fcdcc2015-08-27 07:41:13 -07001029 a->setUnrefWhenDestroyed(nullptr);
bsalomonc2f35b72015-01-23 07:19:22 -08001030 REPORTER_ASSERT(reporter, 2 == TestResource::NumAlive());
bsalomon33435572014-11-05 14:47:41 -08001031
bsalomon0ea80f42015-02-11 10:49:59 -08001032 cache->purgeAllUnlocked();
bsalomonc2f35b72015-01-23 07:19:22 -08001033 REPORTER_ASSERT(reporter, 0 == TestResource::NumAlive());
commit-bot@chromium.orgbd58feb2014-01-17 17:56:21 +00001034}
1035
bsalomon8b79d232014-11-10 10:19:06 -08001036static void test_resource_size_changed(skiatest::Reporter* reporter) {
bsalomon8718aaf2015-02-19 07:24:21 -08001037 GrUniqueKey key1, key2;
1038 make_unique_key<0>(&key1, 1);
1039 make_unique_key<0>(&key2, 2);
commit-bot@chromium.org11c6b392014-05-05 19:09:13 +00001040
1041 // Test changing resources sizes (both increase & decrease).
1042 {
bsalomonc2f35b72015-01-23 07:19:22 -08001043 Mock mock(3, 30000);
1044 GrContext* context = mock.context();
bsalomon0ea80f42015-02-11 10:49:59 -08001045 GrResourceCache* cache = mock.cache();
Robert Phillipsf35fd8d2018-01-22 10:48:15 -05001046 GrGpu* gpu = context->contextPriv().getGpu();
commit-bot@chromium.org11c6b392014-05-05 19:09:13 +00001047
Robert Phillipsf35fd8d2018-01-22 10:48:15 -05001048 TestResource* a = new TestResource(gpu);
bsalomon8718aaf2015-02-19 07:24:21 -08001049 a->resourcePriv().setUniqueKey(key1);
commit-bot@chromium.org11c6b392014-05-05 19:09:13 +00001050 a->unref();
1051
Robert Phillipsf35fd8d2018-01-22 10:48:15 -05001052 TestResource* b = new TestResource(gpu);
bsalomon8718aaf2015-02-19 07:24:21 -08001053 b->resourcePriv().setUniqueKey(key2);
commit-bot@chromium.org11c6b392014-05-05 19:09:13 +00001054 b->unref();
1055
bsalomon0ea80f42015-02-11 10:49:59 -08001056 REPORTER_ASSERT(reporter, 200 == cache->getResourceBytes());
1057 REPORTER_ASSERT(reporter, 2 == cache->getResourceCount());
bsalomon8b79d232014-11-10 10:19:06 -08001058 {
Hal Canary342b7ac2016-11-04 11:49:42 -04001059 sk_sp<TestResource> find2(
bsalomon8718aaf2015-02-19 07:24:21 -08001060 static_cast<TestResource*>(cache->findAndRefUniqueResource(key2)));
bsalomon8b79d232014-11-10 10:19:06 -08001061 find2->setSize(200);
Hal Canary342b7ac2016-11-04 11:49:42 -04001062 sk_sp<TestResource> find1(
bsalomon8718aaf2015-02-19 07:24:21 -08001063 static_cast<TestResource*>(cache->findAndRefUniqueResource(key1)));
bsalomon8b79d232014-11-10 10:19:06 -08001064 find1->setSize(50);
1065 }
commit-bot@chromium.org11c6b392014-05-05 19:09:13 +00001066
bsalomon0ea80f42015-02-11 10:49:59 -08001067 REPORTER_ASSERT(reporter, 250 == cache->getResourceBytes());
1068 REPORTER_ASSERT(reporter, 2 == cache->getResourceCount());
commit-bot@chromium.org11c6b392014-05-05 19:09:13 +00001069 }
1070
1071 // Test increasing a resources size beyond the cache budget.
1072 {
bsalomonc2f35b72015-01-23 07:19:22 -08001073 Mock mock(2, 300);
1074 GrContext* context = mock.context();
bsalomon0ea80f42015-02-11 10:49:59 -08001075 GrResourceCache* cache = mock.cache();
Robert Phillipsf35fd8d2018-01-22 10:48:15 -05001076 GrGpu* gpu = context->contextPriv().getGpu();
commit-bot@chromium.org11c6b392014-05-05 19:09:13 +00001077
Robert Phillipsf35fd8d2018-01-22 10:48:15 -05001078 TestResource* a = new TestResource(gpu);
bsalomon8b79d232014-11-10 10:19:06 -08001079 a->setSize(100);
bsalomon8718aaf2015-02-19 07:24:21 -08001080 a->resourcePriv().setUniqueKey(key1);
commit-bot@chromium.org11c6b392014-05-05 19:09:13 +00001081 a->unref();
1082
Robert Phillipsf35fd8d2018-01-22 10:48:15 -05001083 TestResource* b = new TestResource(gpu);
bsalomon8b79d232014-11-10 10:19:06 -08001084 b->setSize(100);
bsalomon8718aaf2015-02-19 07:24:21 -08001085 b->resourcePriv().setUniqueKey(key2);
commit-bot@chromium.org11c6b392014-05-05 19:09:13 +00001086 b->unref();
1087
bsalomon0ea80f42015-02-11 10:49:59 -08001088 REPORTER_ASSERT(reporter, 200 == cache->getResourceBytes());
1089 REPORTER_ASSERT(reporter, 2 == cache->getResourceCount());
commit-bot@chromium.org11c6b392014-05-05 19:09:13 +00001090
bsalomon8b79d232014-11-10 10:19:06 -08001091 {
Hal Canary342b7ac2016-11-04 11:49:42 -04001092 sk_sp<TestResource> find2(static_cast<TestResource*>(
bsalomon8718aaf2015-02-19 07:24:21 -08001093 cache->findAndRefUniqueResource(key2)));
bsalomon8b79d232014-11-10 10:19:06 -08001094 find2->setSize(201);
1095 }
bsalomon8718aaf2015-02-19 07:24:21 -08001096 REPORTER_ASSERT(reporter, !cache->hasUniqueKey(key1));
commit-bot@chromium.org11c6b392014-05-05 19:09:13 +00001097
bsalomon0ea80f42015-02-11 10:49:59 -08001098 REPORTER_ASSERT(reporter, 201 == cache->getResourceBytes());
1099 REPORTER_ASSERT(reporter, 1 == cache->getResourceCount());
commit-bot@chromium.org11c6b392014-05-05 19:09:13 +00001100 }
commit-bot@chromium.org11c6b392014-05-05 19:09:13 +00001101}
1102
bsalomonddf30e62015-02-19 11:38:44 -08001103static void test_timestamp_wrap(skiatest::Reporter* reporter) {
1104 static const int kCount = 50;
1105 static const int kBudgetCnt = kCount / 2;
1106 static const int kLockedFreq = 8;
1107 static const int kBudgetSize = 0x80000000;
1108
1109 SkRandom random;
1110
1111 // Run the test 2*kCount times;
1112 for (int i = 0; i < 2 * kCount; ++i ) {
1113 Mock mock(kBudgetCnt, kBudgetSize);
1114 GrContext* context = mock.context();
1115 GrResourceCache* cache = mock.cache();
Robert Phillipsf35fd8d2018-01-22 10:48:15 -05001116 GrGpu* gpu = context->contextPriv().getGpu();
bsalomonddf30e62015-02-19 11:38:44 -08001117
1118 // Pick a random number of resources to add before the timestamp will wrap.
1119 cache->changeTimestamp(SK_MaxU32 - random.nextULessThan(kCount + 1));
1120
1121 static const int kNumToPurge = kCount - kBudgetCnt;
1122
1123 SkTDArray<int> shouldPurgeIdxs;
1124 int purgeableCnt = 0;
1125 SkTDArray<GrGpuResource*> resourcesToUnref;
1126
1127 // Add kCount resources, holding onto resources at random so we have a mix of purgeable and
1128 // unpurgeable resources.
1129 for (int j = 0; j < kCount; ++j) {
1130 GrUniqueKey key;
1131 make_unique_key<0>(&key, j);
1132
Robert Phillipsf35fd8d2018-01-22 10:48:15 -05001133 TestResource* r = new TestResource(gpu);
bsalomonddf30e62015-02-19 11:38:44 -08001134 r->resourcePriv().setUniqueKey(key);
1135 if (random.nextU() % kLockedFreq) {
1136 // Make this is purgeable.
1137 r->unref();
1138 ++purgeableCnt;
1139 if (purgeableCnt <= kNumToPurge) {
1140 *shouldPurgeIdxs.append() = j;
1141 }
1142 } else {
1143 *resourcesToUnref.append() = r;
1144 }
1145 }
1146
1147 // Verify that the correct resources were purged.
1148 int currShouldPurgeIdx = 0;
1149 for (int j = 0; j < kCount; ++j) {
1150 GrUniqueKey key;
1151 make_unique_key<0>(&key, j);
1152 GrGpuResource* res = cache->findAndRefUniqueResource(key);
1153 if (currShouldPurgeIdx < shouldPurgeIdxs.count() &&
1154 shouldPurgeIdxs[currShouldPurgeIdx] == j) {
1155 ++currShouldPurgeIdx;
halcanary96fcdcc2015-08-27 07:41:13 -07001156 REPORTER_ASSERT(reporter, nullptr == res);
bsalomonddf30e62015-02-19 11:38:44 -08001157 } else {
halcanary96fcdcc2015-08-27 07:41:13 -07001158 REPORTER_ASSERT(reporter, nullptr != res);
bsalomonddf30e62015-02-19 11:38:44 -08001159 }
1160 SkSafeUnref(res);
1161 }
1162
1163 for (int j = 0; j < resourcesToUnref.count(); ++j) {
1164 resourcesToUnref[j]->unref();
1165 }
1166 }
1167}
1168
bsalomon3f324322015-04-08 11:01:54 -07001169static void test_flush(skiatest::Reporter* reporter) {
1170 Mock mock(1000000, 1000000);
1171 GrContext* context = mock.context();
1172 GrResourceCache* cache = mock.cache();
Robert Phillipsf35fd8d2018-01-22 10:48:15 -05001173 GrGpu* gpu = context->contextPriv().getGpu();
bsalomon3f324322015-04-08 11:01:54 -07001174
1175 // The current cache impl will round the max flush count to the next power of 2. So we choose a
1176 // power of two here to keep things simpler.
1177 static const int kFlushCount = 16;
1178 cache->setLimits(1000000, 1000000, kFlushCount);
1179
1180 {
1181 // Insert a resource and send a flush notification kFlushCount times.
1182 for (int i = 0; i < kFlushCount; ++i) {
Robert Phillipsf35fd8d2018-01-22 10:48:15 -05001183 TestResource* r = new TestResource(gpu);
bsalomon3f324322015-04-08 11:01:54 -07001184 GrUniqueKey k;
1185 make_unique_key<1>(&k, i);
1186 r->resourcePriv().setUniqueKey(k);
1187 r->unref();
bsalomonb77a9072016-09-07 10:02:04 -07001188 cache->notifyFlushOccurred(GrResourceCache::kExternal);
bsalomon3f324322015-04-08 11:01:54 -07001189 }
1190
1191 // Send flush notifications to the cache. Each flush should purge the oldest resource.
bsalomone2e87f32016-09-22 12:42:11 -07001192 for (int i = 0; i < kFlushCount; ++i) {
1193 cache->notifyFlushOccurred(GrResourceCache::kExternal);
bsalomon3f324322015-04-08 11:01:54 -07001194 REPORTER_ASSERT(reporter, kFlushCount - i - 1 == cache->getResourceCount());
1195 for (int j = 0; j < i; ++j) {
1196 GrUniqueKey k;
1197 make_unique_key<1>(&k, j);
1198 GrGpuResource* r = cache->findAndRefUniqueResource(k);
1199 REPORTER_ASSERT(reporter, !SkToBool(r));
1200 SkSafeUnref(r);
1201 }
bsalomon3f324322015-04-08 11:01:54 -07001202 }
1203
1204 REPORTER_ASSERT(reporter, 0 == cache->getResourceCount());
1205 cache->purgeAllUnlocked();
1206 }
1207
1208 // Do a similar test but where we leave refs on some resources to prevent them from being
1209 // purged.
1210 {
1211 GrGpuResource* refedResources[kFlushCount >> 1];
1212 for (int i = 0; i < kFlushCount; ++i) {
Robert Phillipsf35fd8d2018-01-22 10:48:15 -05001213 TestResource* r = new TestResource(gpu);
bsalomon3f324322015-04-08 11:01:54 -07001214 GrUniqueKey k;
1215 make_unique_key<1>(&k, i);
1216 r->resourcePriv().setUniqueKey(k);
1217 // Leave a ref on every other resource, beginning with the first.
1218 if (SkToBool(i & 0x1)) {
1219 refedResources[i/2] = r;
1220 } else {
1221 r->unref();
1222 }
bsalomonb77a9072016-09-07 10:02:04 -07001223 cache->notifyFlushOccurred(GrResourceCache::kExternal);
bsalomon3f324322015-04-08 11:01:54 -07001224 }
1225
1226 for (int i = 0; i < kFlushCount; ++i) {
1227 // Should get a resource purged every other flush.
bsalomonb77a9072016-09-07 10:02:04 -07001228 cache->notifyFlushOccurred(GrResourceCache::kExternal);
bsalomone2e87f32016-09-22 12:42:11 -07001229 REPORTER_ASSERT(reporter, kFlushCount - i/2 - 1 == cache->getResourceCount());
bsalomon3f324322015-04-08 11:01:54 -07001230 }
1231
1232 // Unref all the resources that we kept refs on in the first loop.
1233 for (int i = 0; i < kFlushCount >> 1; ++i) {
1234 refedResources[i]->unref();
1235 }
1236
bsalomone2e87f32016-09-22 12:42:11 -07001237 // After kFlushCount + 1 flushes they all will have sat in the purgeable queue for
1238 // kFlushCount full flushes.
1239 for (int i = 0; i < kFlushCount + 1; ++i) {
bsalomon3f324322015-04-08 11:01:54 -07001240 REPORTER_ASSERT(reporter, kFlushCount >> 1 == cache->getResourceCount());
bsalomonb77a9072016-09-07 10:02:04 -07001241 cache->notifyFlushOccurred(GrResourceCache::kExternal);
bsalomon3f324322015-04-08 11:01:54 -07001242 }
1243 REPORTER_ASSERT(reporter, 0 == cache->getResourceCount());
1244
1245 cache->purgeAllUnlocked();
1246 }
1247
1248 REPORTER_ASSERT(reporter, 0 == cache->getResourceCount());
bsalomondc438982016-08-31 11:53:49 -07001249
1250 // Verify that calling flush() on a GrContext with nothing to do will not trigger resource
1251 // eviction.
1252 context->flush();
1253 for (int i = 0; i < 10; ++i) {
Robert Phillipsf35fd8d2018-01-22 10:48:15 -05001254 TestResource* r = new TestResource(gpu);
bsalomondc438982016-08-31 11:53:49 -07001255 GrUniqueKey k;
1256 make_unique_key<1>(&k, i);
1257 r->resourcePriv().setUniqueKey(k);
1258 r->unref();
1259 }
1260 REPORTER_ASSERT(reporter, 10 == cache->getResourceCount());
1261 for (int i = 0; i < 10 * kFlushCount; ++i) {
1262 context->flush();
1263 }
1264 REPORTER_ASSERT(reporter, 10 == cache->getResourceCount());
bsalomon3f324322015-04-08 11:01:54 -07001265}
1266
Brian Salomon5e150852017-03-22 14:53:13 -04001267static void test_time_purge(skiatest::Reporter* reporter) {
1268 Mock mock(1000000, 1000000);
1269 GrContext* context = mock.context();
1270 GrResourceCache* cache = mock.cache();
Robert Phillipsf35fd8d2018-01-22 10:48:15 -05001271 GrGpu* gpu = context->contextPriv().getGpu();
Brian Salomon5e150852017-03-22 14:53:13 -04001272
1273 static constexpr int kCnts[] = {1, 10, 1024};
1274 auto nowish = []() {
1275 // We sleep so that we ensure we get a value that is greater than the last call to
1276 // GrStdSteadyClock::now().
1277 std::this_thread::sleep_for(GrStdSteadyClock::duration(5));
1278 auto result = GrStdSteadyClock::now();
1279 // Also sleep afterwards so we don't get this value again.
1280 std::this_thread::sleep_for(GrStdSteadyClock::duration(5));
1281 return result;
1282 };
1283
1284 for (int cnt : kCnts) {
1285 std::unique_ptr<GrStdSteadyClock::time_point[]> timeStamps(
1286 new GrStdSteadyClock::time_point[cnt]);
1287 {
1288 // Insert resources and get time points between each addition.
1289 for (int i = 0; i < cnt; ++i) {
Robert Phillipsf35fd8d2018-01-22 10:48:15 -05001290 TestResource* r = new TestResource(gpu);
Brian Salomon5e150852017-03-22 14:53:13 -04001291 GrUniqueKey k;
1292 make_unique_key<1>(&k, i);
1293 r->resourcePriv().setUniqueKey(k);
1294 r->unref();
1295 timeStamps.get()[i] = nowish();
1296 }
1297
1298 // Purge based on the time points between resource additions. Each purge should remove
1299 // the oldest resource.
1300 for (int i = 0; i < cnt; ++i) {
1301 cache->purgeResourcesNotUsedSince(timeStamps[i]);
1302 REPORTER_ASSERT(reporter, cnt - i - 1 == cache->getResourceCount());
1303 for (int j = 0; j < i; ++j) {
1304 GrUniqueKey k;
1305 make_unique_key<1>(&k, j);
1306 GrGpuResource* r = cache->findAndRefUniqueResource(k);
1307 REPORTER_ASSERT(reporter, !SkToBool(r));
1308 SkSafeUnref(r);
1309 }
1310 }
1311
1312 REPORTER_ASSERT(reporter, 0 == cache->getResourceCount());
1313 cache->purgeAllUnlocked();
1314 }
1315
1316 // Do a similar test but where we leave refs on some resources to prevent them from being
1317 // purged.
1318 {
1319 std::unique_ptr<GrGpuResource* []> refedResources(new GrGpuResource*[cnt / 2]);
1320 for (int i = 0; i < cnt; ++i) {
Robert Phillipsf35fd8d2018-01-22 10:48:15 -05001321 TestResource* r = new TestResource(gpu);
Brian Salomon5e150852017-03-22 14:53:13 -04001322 GrUniqueKey k;
1323 make_unique_key<1>(&k, i);
1324 r->resourcePriv().setUniqueKey(k);
1325 // Leave a ref on every other resource, beginning with the first.
1326 if (SkToBool(i & 0x1)) {
1327 refedResources.get()[i / 2] = r;
1328 } else {
1329 r->unref();
1330 }
1331 timeStamps.get()[i] = nowish();
1332 }
1333
1334 for (int i = 0; i < cnt; ++i) {
1335 // Should get a resource purged every other frame.
1336 cache->purgeResourcesNotUsedSince(timeStamps[i]);
1337 REPORTER_ASSERT(reporter, cnt - i / 2 - 1 == cache->getResourceCount());
1338 }
1339
1340 // Unref all the resources that we kept refs on in the first loop.
1341 for (int i = 0; i < (cnt / 2); ++i) {
1342 refedResources.get()[i]->unref();
1343 cache->purgeResourcesNotUsedSince(nowish());
1344 REPORTER_ASSERT(reporter, cnt / 2 - i - 1 == cache->getResourceCount());
1345 }
1346
1347 cache->purgeAllUnlocked();
1348 }
1349
1350 REPORTER_ASSERT(reporter, 0 == cache->getResourceCount());
1351
1352 // Verify that calling flush() on a GrContext with nothing to do will not trigger resource
1353 // eviction
1354 context->flush();
1355 for (int i = 0; i < 10; ++i) {
Robert Phillipsf35fd8d2018-01-22 10:48:15 -05001356 TestResource* r = new TestResource(gpu);
Brian Salomon5e150852017-03-22 14:53:13 -04001357 GrUniqueKey k;
1358 make_unique_key<1>(&k, i);
1359 r->resourcePriv().setUniqueKey(k);
1360 r->unref();
1361 }
1362 REPORTER_ASSERT(reporter, 10 == cache->getResourceCount());
1363 context->flush();
1364 REPORTER_ASSERT(reporter, 10 == cache->getResourceCount());
1365 cache->purgeResourcesNotUsedSince(nowish());
1366 REPORTER_ASSERT(reporter, 0 == cache->getResourceCount());
1367 }
1368}
1369
Derek Sollenberger5480a182017-05-25 16:43:59 -04001370static void test_partial_purge(skiatest::Reporter* reporter) {
1371 Mock mock(6, 100);
1372 GrContext* context = mock.context();
1373 GrResourceCache* cache = mock.cache();
Robert Phillipsf35fd8d2018-01-22 10:48:15 -05001374 GrGpu* gpu = context->contextPriv().getGpu();
Derek Sollenberger5480a182017-05-25 16:43:59 -04001375
1376 enum TestsCase {
1377 kOnlyScratch_TestCase = 0,
1378 kPartialScratch_TestCase = 1,
1379 kAllScratch_TestCase = 2,
1380 kPartial_TestCase = 3,
1381 kAll_TestCase = 4,
1382 kNone_TestCase = 5,
1383 kEndTests_TestCase = kNone_TestCase + 1
1384 };
1385
1386 for (int testCase = 0; testCase < kEndTests_TestCase; testCase++) {
1387
1388 GrUniqueKey key1, key2, key3;
1389 make_unique_key<0>(&key1, 1);
1390 make_unique_key<0>(&key2, 2);
1391 make_unique_key<0>(&key3, 3);
1392
1393 // Add three unique resources to the cache.
Robert Phillipsf35fd8d2018-01-22 10:48:15 -05001394 TestResource *unique1 = new TestResource(gpu);
1395 TestResource *unique2 = new TestResource(gpu);
1396 TestResource *unique3 = new TestResource(gpu);
Derek Sollenberger5480a182017-05-25 16:43:59 -04001397
1398 unique1->resourcePriv().setUniqueKey(key1);
1399 unique2->resourcePriv().setUniqueKey(key2);
1400 unique3->resourcePriv().setUniqueKey(key3);
1401
1402 unique1->setSize(10);
1403 unique2->setSize(11);
1404 unique3->setSize(12);
1405
1406 // Add two scratch resources to the cache.
Robert Phillipsf35fd8d2018-01-22 10:48:15 -05001407 TestResource *scratch1 = TestResource::CreateScratch(gpu, SkBudgeted::kYes,
Derek Sollenberger5480a182017-05-25 16:43:59 -04001408 TestResource::kA_SimulatedProperty);
Robert Phillipsf35fd8d2018-01-22 10:48:15 -05001409 TestResource *scratch2 = TestResource::CreateScratch(gpu, SkBudgeted::kYes,
Derek Sollenberger5480a182017-05-25 16:43:59 -04001410 TestResource::kB_SimulatedProperty);
1411 scratch1->setSize(13);
1412 scratch2->setSize(14);
1413
1414
1415 REPORTER_ASSERT(reporter, 5 == cache->getBudgetedResourceCount());
1416 REPORTER_ASSERT(reporter, 60 == cache->getBudgetedResourceBytes());
1417 REPORTER_ASSERT(reporter, 0 == cache->getPurgeableBytes());
1418
1419 // Add resources to the purgeable queue
1420 unique1->unref();
1421 scratch1->unref();
1422 unique2->unref();
1423 scratch2->unref();
1424 unique3->unref();
1425
1426 REPORTER_ASSERT(reporter, 5 == cache->getBudgetedResourceCount());
1427 REPORTER_ASSERT(reporter, 60 == cache->getBudgetedResourceBytes());
1428 REPORTER_ASSERT(reporter, 60 == cache->getPurgeableBytes());
1429
1430 switch(testCase) {
1431 case kOnlyScratch_TestCase: {
1432 context->purgeUnlockedResources(14, true);
1433 REPORTER_ASSERT(reporter, 3 == cache->getBudgetedResourceCount());
1434 REPORTER_ASSERT(reporter, 33 == cache->getBudgetedResourceBytes());
1435 break;
1436 }
1437 case kPartialScratch_TestCase: {
1438 context->purgeUnlockedResources(3, true);
1439 REPORTER_ASSERT(reporter, 4 == cache->getBudgetedResourceCount());
1440 REPORTER_ASSERT(reporter, 47 == cache->getBudgetedResourceBytes());
1441 break;
1442 }
1443 case kAllScratch_TestCase: {
1444 context->purgeUnlockedResources(50, true);
1445 REPORTER_ASSERT(reporter, 0 == cache->getBudgetedResourceCount());
1446 REPORTER_ASSERT(reporter, 0 == cache->getBudgetedResourceBytes());
1447 break;
1448 }
1449 case kPartial_TestCase: {
1450 context->purgeUnlockedResources(13, false);
1451 REPORTER_ASSERT(reporter, 3 == cache->getBudgetedResourceCount());
1452 REPORTER_ASSERT(reporter, 37 == cache->getBudgetedResourceBytes());
1453 break;
1454 }
1455 case kAll_TestCase: {
1456 context->purgeUnlockedResources(50, false);
1457 REPORTER_ASSERT(reporter, 0 == cache->getBudgetedResourceCount());
1458 REPORTER_ASSERT(reporter, 0 == cache->getBudgetedResourceBytes());
1459 break;
1460 }
1461 case kNone_TestCase: {
1462 context->purgeUnlockedResources(0, true);
1463 context->purgeUnlockedResources(0, false);
1464 REPORTER_ASSERT(reporter, 5 == cache->getBudgetedResourceCount());
1465 REPORTER_ASSERT(reporter, 60 == cache->getBudgetedResourceBytes());
1466 REPORTER_ASSERT(reporter, 60 == cache->getPurgeableBytes());
1467 break;
1468 }
1469 };
1470
1471 // ensure all are purged before the next
Robert Phillips0c4b7b12018-03-06 08:20:37 -05001472 context->contextPriv().purgeAllUnlockedResources_ForTesting();
Derek Sollenberger5480a182017-05-25 16:43:59 -04001473 REPORTER_ASSERT(reporter, 0 == cache->getBudgetedResourceCount());
1474 REPORTER_ASSERT(reporter, 0 == cache->getPurgeableBytes());
1475
1476 }
1477}
1478
bsalomon10e23ca2014-11-25 05:52:06 -08001479static void test_large_resource_count(skiatest::Reporter* reporter) {
bsalomon10e23ca2014-11-25 05:52:06 -08001480 // Set the cache size to double the resource count because we're going to create 2x that number
1481 // resources, using two different key domains. Add a little slop to the bytes because we resize
1482 // down to 1 byte after creating the resource.
bsalomonc2f35b72015-01-23 07:19:22 -08001483 static const int kResourceCnt = 2000;
bsalomon10e23ca2014-11-25 05:52:06 -08001484
bsalomonc2f35b72015-01-23 07:19:22 -08001485 Mock mock(2 * kResourceCnt, 2 * kResourceCnt + 1000);
1486 GrContext* context = mock.context();
bsalomon0ea80f42015-02-11 10:49:59 -08001487 GrResourceCache* cache = mock.cache();
Robert Phillipsf35fd8d2018-01-22 10:48:15 -05001488 GrGpu* gpu = context->contextPriv().getGpu();
bsalomon10e23ca2014-11-25 05:52:06 -08001489
1490 for (int i = 0; i < kResourceCnt; ++i) {
bsalomon8718aaf2015-02-19 07:24:21 -08001491 GrUniqueKey key1, key2;
1492 make_unique_key<1>(&key1, i);
1493 make_unique_key<2>(&key2, i);
bsalomon10e23ca2014-11-25 05:52:06 -08001494
bsalomon24db3b12015-01-23 04:24:04 -08001495 TestResource* resource;
1496
Robert Phillipsf35fd8d2018-01-22 10:48:15 -05001497 resource = new TestResource(gpu);
bsalomon8718aaf2015-02-19 07:24:21 -08001498 resource->resourcePriv().setUniqueKey(key1);
bsalomon10e23ca2014-11-25 05:52:06 -08001499 resource->setSize(1);
1500 resource->unref();
1501
Robert Phillipsf35fd8d2018-01-22 10:48:15 -05001502 resource = new TestResource(gpu);
bsalomon8718aaf2015-02-19 07:24:21 -08001503 resource->resourcePriv().setUniqueKey(key2);
bsalomon10e23ca2014-11-25 05:52:06 -08001504 resource->setSize(1);
1505 resource->unref();
1506 }
1507
1508 REPORTER_ASSERT(reporter, TestResource::NumAlive() == 2 * kResourceCnt);
Derek Sollenbergeree479142017-05-24 11:41:33 -04001509 REPORTER_ASSERT(reporter, cache->getPurgeableBytes() == 2 * kResourceCnt);
bsalomon0ea80f42015-02-11 10:49:59 -08001510 REPORTER_ASSERT(reporter, cache->getBudgetedResourceBytes() == 2 * kResourceCnt);
1511 REPORTER_ASSERT(reporter, cache->getBudgetedResourceCount() == 2 * kResourceCnt);
1512 REPORTER_ASSERT(reporter, cache->getResourceBytes() == 2 * kResourceCnt);
1513 REPORTER_ASSERT(reporter, cache->getResourceCount() == 2 * kResourceCnt);
bsalomon10e23ca2014-11-25 05:52:06 -08001514 for (int i = 0; i < kResourceCnt; ++i) {
bsalomon8718aaf2015-02-19 07:24:21 -08001515 GrUniqueKey key1, key2;
1516 make_unique_key<1>(&key1, i);
1517 make_unique_key<2>(&key2, i);
bsalomon24db3b12015-01-23 04:24:04 -08001518
bsalomon8718aaf2015-02-19 07:24:21 -08001519 REPORTER_ASSERT(reporter, cache->hasUniqueKey(key1));
1520 REPORTER_ASSERT(reporter, cache->hasUniqueKey(key2));
bsalomon10e23ca2014-11-25 05:52:06 -08001521 }
1522
bsalomon0ea80f42015-02-11 10:49:59 -08001523 cache->purgeAllUnlocked();
bsalomon10e23ca2014-11-25 05:52:06 -08001524 REPORTER_ASSERT(reporter, TestResource::NumAlive() == 0);
Derek Sollenbergeree479142017-05-24 11:41:33 -04001525 REPORTER_ASSERT(reporter, cache->getPurgeableBytes() == 0);
bsalomon0ea80f42015-02-11 10:49:59 -08001526 REPORTER_ASSERT(reporter, cache->getBudgetedResourceBytes() == 0);
1527 REPORTER_ASSERT(reporter, cache->getBudgetedResourceCount() == 0);
1528 REPORTER_ASSERT(reporter, cache->getResourceBytes() == 0);
1529 REPORTER_ASSERT(reporter, cache->getResourceCount() == 0);
bsalomon10e23ca2014-11-25 05:52:06 -08001530
1531 for (int i = 0; i < kResourceCnt; ++i) {
bsalomon8718aaf2015-02-19 07:24:21 -08001532 GrUniqueKey key1, key2;
1533 make_unique_key<1>(&key1, i);
1534 make_unique_key<2>(&key2, i);
bsalomon24db3b12015-01-23 04:24:04 -08001535
bsalomon8718aaf2015-02-19 07:24:21 -08001536 REPORTER_ASSERT(reporter, !cache->hasUniqueKey(key1));
1537 REPORTER_ASSERT(reporter, !cache->hasUniqueKey(key2));
bsalomon10e23ca2014-11-25 05:52:06 -08001538 }
1539}
1540
senorblanco84cd6212015-08-04 10:01:58 -07001541static void test_custom_data(skiatest::Reporter* reporter) {
1542 GrUniqueKey key1, key2;
1543 make_unique_key<0>(&key1, 1);
1544 make_unique_key<0>(&key2, 2);
1545 int foo = 4132;
bungeman38d909e2016-08-02 14:40:46 -07001546 key1.setCustomData(SkData::MakeWithCopy(&foo, sizeof(foo)));
senorblanco84cd6212015-08-04 10:01:58 -07001547 REPORTER_ASSERT(reporter, *(int*) key1.getCustomData()->data() == 4132);
1548 REPORTER_ASSERT(reporter, key2.getCustomData() == nullptr);
1549
1550 // Test that copying a key also takes a ref on its custom data.
1551 GrUniqueKey key3 = key1;
1552 REPORTER_ASSERT(reporter, *(int*) key3.getCustomData()->data() == 4132);
1553}
1554
bsalomonc6363ef2015-09-24 07:07:40 -07001555static void test_abandoned(skiatest::Reporter* reporter) {
1556 Mock mock(10, 300);
1557 GrContext* context = mock.context();
Robert Phillipsf35fd8d2018-01-22 10:48:15 -05001558 GrGpu* gpu = context->contextPriv().getGpu();
1559
1560 sk_sp<GrGpuResource> resource(new TestResource(gpu));
bsalomonc6363ef2015-09-24 07:07:40 -07001561 context->abandonContext();
1562
1563 REPORTER_ASSERT(reporter, resource->wasDestroyed());
1564
1565 // Call all the public methods on resource in the abandoned state. They shouldn't crash.
1566
robertphillips8abb3702016-08-31 14:04:06 -07001567 resource->uniqueID();
bsalomonc6363ef2015-09-24 07:07:40 -07001568 resource->getUniqueKey();
1569 resource->wasDestroyed();
1570 resource->gpuMemorySize();
1571 resource->getContext();
1572
1573 resource->abandon();
1574 resource->resourcePriv().getScratchKey();
1575 resource->resourcePriv().isBudgeted();
1576 resource->resourcePriv().makeBudgeted();
1577 resource->resourcePriv().makeUnbudgeted();
1578 resource->resourcePriv().removeScratchKey();
1579 GrUniqueKey key;
1580 make_unique_key<0>(&key, 1);
1581 resource->resourcePriv().setUniqueKey(key);
1582 resource->resourcePriv().removeUniqueKey();
1583}
1584
Brian Salomon1090da62017-01-06 12:04:19 -05001585static void test_tags(skiatest::Reporter* reporter) {
1586#ifdef SK_DEBUG
1587 // We will insert 1 resource with tag "tag1", 2 with "tag2", and so on, up through kLastTagIdx.
1588 static constexpr int kLastTagIdx = 10;
1589 static constexpr int kNumResources = kLastTagIdx * (kLastTagIdx + 1) / 2;
1590
1591 Mock mock(kNumResources, kNumResources * TestResource::kDefaultSize);
1592 GrContext* context = mock.context();
1593 GrResourceCache* cache = mock.cache();
Robert Phillipsf35fd8d2018-01-22 10:48:15 -05001594 GrGpu* gpu = context->contextPriv().getGpu();
Brian Salomon1090da62017-01-06 12:04:19 -05001595
1596 SkString tagStr;
1597 int tagIdx = 0;
1598 int currTagCnt = 0;
1599
1600 for (int i = 0; i < kNumResources; ++i, ++currTagCnt) {
Robert Phillipsf35fd8d2018-01-22 10:48:15 -05001601 sk_sp<GrGpuResource> resource(new TestResource(gpu));
Brian Salomon1090da62017-01-06 12:04:19 -05001602 GrUniqueKey key;
1603 if (currTagCnt == tagIdx) {
1604 tagIdx += 1;
1605 currTagCnt = 0;
1606 tagStr.printf("tag%d", tagIdx);
1607 }
1608 make_unique_key<1>(&key, i, tagStr.c_str());
1609 resource->resourcePriv().setUniqueKey(key);
1610 }
1611 SkASSERT(kLastTagIdx == tagIdx);
1612 SkASSERT(currTagCnt == kLastTagIdx);
1613
1614 // Test i = 0 to exercise unused tag string.
1615 for (int i = 0; i <= kLastTagIdx; ++i) {
1616 tagStr.printf("tag%d", i);
1617 REPORTER_ASSERT(reporter, cache->countUniqueKeysWithTag(tagStr.c_str()) == i);
1618 }
1619#endif
1620}
1621
Brian Salomondcfca432017-11-15 15:48:03 -05001622DEF_GPUTEST(ResourceCacheMisc, reporter, /* options */) {
bsalomon8b79d232014-11-10 10:19:06 -08001623 // The below tests create their own mock contexts.
bsalomon71cb0c22014-11-14 12:10:14 -08001624 test_no_key(reporter);
bsalomon84c8e622014-11-17 09:33:27 -08001625 test_budgeting(reporter);
bsalomon5236cf42015-01-14 10:42:08 -08001626 test_unbudgeted(reporter);
bsalomonc2f35b72015-01-23 07:19:22 -08001627 test_unbudgeted_to_scratch(reporter);
bsalomon8718aaf2015-02-19 07:24:21 -08001628 test_duplicate_unique_key(reporter);
bsalomon8b79d232014-11-10 10:19:06 -08001629 test_duplicate_scratch_key(reporter);
bsalomon10e23ca2014-11-25 05:52:06 -08001630 test_remove_scratch_key(reporter);
bsalomon1c60dfe2015-01-21 09:32:40 -08001631 test_scratch_key_consistency(reporter);
bsalomon8b79d232014-11-10 10:19:06 -08001632 test_purge_invalidated(reporter);
bsalomon71cb0c22014-11-14 12:10:14 -08001633 test_cache_chained_purge(reporter);
bsalomon8b79d232014-11-10 10:19:06 -08001634 test_resource_size_changed(reporter);
bsalomonddf30e62015-02-19 11:38:44 -08001635 test_timestamp_wrap(reporter);
bsalomon3f324322015-04-08 11:01:54 -07001636 test_flush(reporter);
Brian Salomon5e150852017-03-22 14:53:13 -04001637 test_time_purge(reporter);
Derek Sollenberger5480a182017-05-25 16:43:59 -04001638 test_partial_purge(reporter);
bsalomon10e23ca2014-11-25 05:52:06 -08001639 test_large_resource_count(reporter);
senorblanco84cd6212015-08-04 10:01:58 -07001640 test_custom_data(reporter);
bsalomonc6363ef2015-09-24 07:07:40 -07001641 test_abandoned(reporter);
Brian Salomon1090da62017-01-06 12:04:19 -05001642 test_tags(reporter);
commit-bot@chromium.orgc28f5552013-08-08 22:55:21 +00001643}
1644
Robert Phillipsd6214d42016-11-07 08:23:48 -05001645////////////////////////////////////////////////////////////////////////////////
Brian Osman32342f02017-03-04 08:12:46 -05001646static sk_sp<GrTexture> make_normal_texture(GrResourceProvider* provider,
Robert Phillipsfe0253f2018-03-16 16:47:25 -04001647 GrSurfaceDescFlags descFlags,
Robert Phillipsd6214d42016-11-07 08:23:48 -05001648 int width, int height,
1649 int sampleCnt) {
1650 GrSurfaceDesc desc;
Robert Phillipsfe0253f2018-03-16 16:47:25 -04001651 desc.fFlags = descFlags;
Robert Phillipsd6214d42016-11-07 08:23:48 -05001652 desc.fWidth = width;
1653 desc.fHeight = height;
1654 desc.fConfig = kRGBA_8888_GrPixelConfig;
1655 desc.fSampleCnt = sampleCnt;
1656
Robert Phillipse78b7252017-04-06 07:59:41 -04001657 return provider->createTexture(desc, SkBudgeted::kYes);
Robert Phillipsd6214d42016-11-07 08:23:48 -05001658}
1659
Robert Phillips0bd24dc2018-01-16 08:06:32 -05001660static sk_sp<GrTextureProxy> make_mipmap_proxy(GrProxyProvider* proxyProvider,
Robert Phillipsfe0253f2018-03-16 16:47:25 -04001661 GrSurfaceDescFlags descFlags,
Robert Phillipse78b7252017-04-06 07:59:41 -04001662 int width, int height,
1663 int sampleCnt) {
Robert Phillipsd6214d42016-11-07 08:23:48 -05001664 GrSurfaceDesc desc;
Robert Phillipsfe0253f2018-03-16 16:47:25 -04001665 desc.fFlags = descFlags;
Robert Phillipsd6214d42016-11-07 08:23:48 -05001666 desc.fWidth = width;
1667 desc.fHeight = height;
1668 desc.fConfig = kRGBA_8888_GrPixelConfig;
1669 desc.fSampleCnt = sampleCnt;
Robert Phillipsd6214d42016-11-07 08:23:48 -05001670
Robert Phillipsfe0253f2018-03-16 16:47:25 -04001671 auto origin = (descFlags & kRenderTarget_GrSurfaceFlag) ? kBottomLeft_GrSurfaceOrigin
1672 : kTopLeft_GrSurfaceOrigin;
Brian Salomon2a4f9832018-03-03 22:43:43 -05001673
1674 return proxyProvider->createMipMapProxy(desc, origin, SkBudgeted::kYes);
Robert Phillipsd6214d42016-11-07 08:23:48 -05001675}
1676
1677// Exercise GrSurface::gpuMemorySize for different combos of MSAA, RT-only,
1678// Texture-only, both-RT-and-Texture and MIPmapped
1679DEF_GPUTEST_FOR_RENDERING_CONTEXTS(GPUMemorySize, reporter, ctxInfo) {
1680 GrContext* context = ctxInfo.grContext();
Robert Phillips1afd4cd2018-01-08 13:40:32 -05001681 GrProxyProvider* proxyProvider = context->contextPriv().proxyProvider();
Robert Phillips6be756b2018-01-16 15:07:54 -05001682 GrResourceProvider* resourceProvider = context->contextPriv().resourceProvider();
Robert Phillipsd6214d42016-11-07 08:23:48 -05001683
Robert Phillipsd6214d42016-11-07 08:23:48 -05001684 static const int kSize = 64;
1685
Robert Phillipsd6214d42016-11-07 08:23:48 -05001686 // Normal versions
Robert Phillipse78b7252017-04-06 07:59:41 -04001687 {
1688 sk_sp<GrTexture> tex;
Robert Phillipsd6214d42016-11-07 08:23:48 -05001689
Brian Salomonbdecacf2018-02-02 20:32:49 -05001690 tex = make_normal_texture(resourceProvider, kRenderTarget_GrSurfaceFlag, kSize, kSize, 1);
Robert Phillipse78b7252017-04-06 07:59:41 -04001691 size_t size = tex->gpuMemorySize();
1692 REPORTER_ASSERT(reporter, kSize*kSize*4 == size);
1693
Brian Salomonbdecacf2018-02-02 20:32:49 -05001694 size_t sampleCount =
1695 (size_t)context->caps()->getRenderTargetSampleCount(4, kRGBA_8888_GrPixelConfig);
Greg Daniel81e7bf82017-07-19 14:47:42 -04001696 if (sampleCount >= 4) {
Robert Phillips1afd4cd2018-01-08 13:40:32 -05001697 tex = make_normal_texture(resourceProvider, kRenderTarget_GrSurfaceFlag, kSize, kSize,
Greg Daniel81e7bf82017-07-19 14:47:42 -04001698 sampleCount);
Robert Phillipse78b7252017-04-06 07:59:41 -04001699 size = tex->gpuMemorySize();
Greg Daniel81e7bf82017-07-19 14:47:42 -04001700 REPORTER_ASSERT(reporter,
1701 kSize*kSize*4 == size || // msaa4 failed
1702 kSize*kSize*4*sampleCount == size || // auto-resolving
1703 kSize*kSize*4*(sampleCount+1) == size); // explicit resolve buffer
Robert Phillipse78b7252017-04-06 07:59:41 -04001704 }
1705
Brian Salomonbdecacf2018-02-02 20:32:49 -05001706 tex = make_normal_texture(resourceProvider, kNone_GrSurfaceFlags, kSize, kSize, 1);
Robert Phillipsd6214d42016-11-07 08:23:48 -05001707 size = tex->gpuMemorySize();
Robert Phillipse78b7252017-04-06 07:59:41 -04001708 REPORTER_ASSERT(reporter, kSize*kSize*4 == size);
Robert Phillipsd6214d42016-11-07 08:23:48 -05001709 }
1710
Robert Phillipsd6214d42016-11-07 08:23:48 -05001711
1712 // Mipmapped versions
Brian Osman48c99192017-06-02 08:45:06 -04001713 if (context->caps()->mipMapSupport()) {
Robert Phillipse78b7252017-04-06 07:59:41 -04001714 sk_sp<GrTextureProxy> proxy;
Robert Phillipsd6214d42016-11-07 08:23:48 -05001715
Brian Salomonbdecacf2018-02-02 20:32:49 -05001716 proxy = make_mipmap_proxy(proxyProvider, kRenderTarget_GrSurfaceFlag, kSize, kSize, 1);
Robert Phillipse78b7252017-04-06 07:59:41 -04001717 size_t size = proxy->gpuMemorySize();
1718 REPORTER_ASSERT(reporter, kSize*kSize*4+(kSize*kSize*4)/3 == size);
1719
Brian Salomonbdecacf2018-02-02 20:32:49 -05001720 size_t sampleCount =
1721 (size_t)context->caps()->getRenderTargetSampleCount(4, kRGBA_8888_GrPixelConfig);
Greg Daniel81e7bf82017-07-19 14:47:42 -04001722 if (sampleCount >= 4) {
Robert Phillips1afd4cd2018-01-08 13:40:32 -05001723 proxy = make_mipmap_proxy(proxyProvider, kRenderTarget_GrSurfaceFlag, kSize, kSize,
Greg Daniel81e7bf82017-07-19 14:47:42 -04001724 sampleCount);
Robert Phillipse78b7252017-04-06 07:59:41 -04001725 size = proxy->gpuMemorySize();
1726 REPORTER_ASSERT(reporter,
Greg Daniel81e7bf82017-07-19 14:47:42 -04001727 kSize*kSize*4+(kSize*kSize*4)/3 == size || // msaa4 failed
1728 kSize*kSize*4*sampleCount+(kSize*kSize*4)/3 == size || // auto-resolving
1729 kSize*kSize*4*(sampleCount+1)+(kSize*kSize*4)/3 == size); // explicit resolve buffer
Robert Phillipse78b7252017-04-06 07:59:41 -04001730 }
Robert Phillips1b352562017-04-05 18:56:21 +00001731
Brian Salomonbdecacf2018-02-02 20:32:49 -05001732 proxy = make_mipmap_proxy(proxyProvider, kNone_GrSurfaceFlags, kSize, kSize, 1);
Robert Phillipse78b7252017-04-06 07:59:41 -04001733 size = proxy->gpuMemorySize();
1734 REPORTER_ASSERT(reporter, kSize*kSize*4+(kSize*kSize*4)/3 == size);
1735 }
Robert Phillipsd6214d42016-11-07 08:23:48 -05001736}
1737
commit-bot@chromium.orgc28f5552013-08-08 22:55:21 +00001738#endif