blob: 5b7a67a6484fa523e982640a14396a931598ea38 [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 "SkTypes.h"
9
Brian Salomon5e150852017-03-22 14:53:13 -040010#include <thread>
bsalomonbcf0a522014-10-08 08:40:09 -070011#include "GrContext.h"
Greg Daniel7ef28f32017-04-20 16:41:55 +000012#include "GrContextPriv.h"
commit-bot@chromium.orgc28f5552013-08-08 22:55:21 +000013#include "GrContextFactory.h"
bsalomonbcf0a522014-10-08 08:40:09 -070014#include "GrGpu.h"
bsalomon3582d3e2015-02-13 14:20:05 -080015#include "GrGpuResourceCacheAccess.h"
16#include "GrGpuResourcePriv.h"
Robert Phillips0bd24dc2018-01-16 08:06:32 -050017#include "GrProxyProvider.h"
Robert Phillipsc0192e32017-09-21 12:00:26 -040018#include "GrRenderTargetPriv.h"
bsalomon0ea80f42015-02-11 10:49:59 -080019#include "GrResourceCache.h"
bsalomon473addf2015-10-02 07:49:05 -070020#include "GrResourceProvider.h"
bsalomon6dc6f5f2015-06-18 09:12:16 -070021#include "GrTest.h"
Robert Phillips646e4292017-06-13 12:44:56 -040022#include "GrTexture.h"
23
bsalomonbcf0a522014-10-08 08:40:09 -070024#include "SkCanvas.h"
bsalomon71cb0c22014-11-14 12:10:14 -080025#include "SkGr.h"
26#include "SkMessageBus.h"
Robert Phillipsd6214d42016-11-07 08:23:48 -050027#include "SkMipMap.h"
reed69f6f002014-09-18 06:09:44 -070028#include "SkSurface.h"
tfarina@chromium.org4ee16bf2014-01-10 22:08:27 +000029#include "Test.h"
commit-bot@chromium.orgc28f5552013-08-08 22:55:21 +000030
31static const int gWidth = 640;
32static const int gHeight = 480;
33
34////////////////////////////////////////////////////////////////////////////////
bsalomon68d91342016-04-12 09:59:58 -070035DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ResourceCacheCache, reporter, ctxInfo) {
bsalomon8b7451a2016-05-11 06:33:06 -070036 GrContext* context = ctxInfo.grContext();
kkinnunen15302832015-12-01 04:35:26 -080037 GrSurfaceDesc desc;
Brian Osman777b5632016-10-14 09:16:21 -040038 desc.fConfig = kRGBA_8888_GrPixelConfig;
kkinnunen15302832015-12-01 04:35:26 -080039 desc.fFlags = kRenderTarget_GrSurfaceFlag;
40 desc.fWidth = gWidth;
41 desc.fHeight = gHeight;
42 SkImageInfo info = SkImageInfo::MakeN32Premul(gWidth, gHeight);
reede8f30622016-03-23 18:59:25 -070043 auto surface(SkSurface::MakeRenderTarget(context, SkBudgeted::kNo, info));
kkinnunen15302832015-12-01 04:35:26 -080044 SkCanvas* canvas = surface->getCanvas();
45
commit-bot@chromium.orgc28f5552013-08-08 22:55:21 +000046 const SkIRect size = SkIRect::MakeWH(gWidth, gHeight);
47
48 SkBitmap src;
mike@reedtribe.orgdeee4962014-02-13 14:41:43 +000049 src.allocN32Pixels(size.width(), size.height());
commit-bot@chromium.orgc28f5552013-08-08 22:55:21 +000050 src.eraseColor(SK_ColorBLACK);
Mike Reedf0ffb892017-10-03 14:47:21 -040051 size_t srcSize = src.computeByteSize();
commit-bot@chromium.orgc28f5552013-08-08 22:55:21 +000052
commit-bot@chromium.org95c20032014-05-09 14:29:32 +000053 size_t initialCacheSize;
halcanary96fcdcc2015-08-27 07:41:13 -070054 context->getResourceCacheUsage(nullptr, &initialCacheSize);
commit-bot@chromium.orgc28f5552013-08-08 22:55:21 +000055
56 int oldMaxNum;
57 size_t oldMaxBytes;
commit-bot@chromium.org95c20032014-05-09 14:29:32 +000058 context->getResourceCacheLimits(&oldMaxNum, &oldMaxBytes);
skia.committer@gmail.com17f1ae62013-08-09 07:01:22 +000059
commit-bot@chromium.orgc28f5552013-08-08 22:55:21 +000060 // Set the cache limits so we can fit 10 "src" images and the
61 // max number of textures doesn't matter
62 size_t maxCacheSize = initialCacheSize + 10*srcSize;
commit-bot@chromium.org95c20032014-05-09 14:29:32 +000063 context->setResourceCacheLimits(1000, maxCacheSize);
commit-bot@chromium.orgc28f5552013-08-08 22:55:21 +000064
65 SkBitmap readback;
mike@reedtribe.orgdeee4962014-02-13 14:41:43 +000066 readback.allocN32Pixels(size.width(), size.height());
commit-bot@chromium.orgc28f5552013-08-08 22:55:21 +000067
68 for (int i = 0; i < 100; ++i) {
69 canvas->drawBitmap(src, 0, 0);
Mike Reedf1942192017-07-21 14:24:29 -040070 surface->readPixels(readback, 0, 0);
commit-bot@chromium.orgc28f5552013-08-08 22:55:21 +000071
72 // "modify" the src texture
73 src.notifyPixelsChanged();
74
commit-bot@chromium.org95c20032014-05-09 14:29:32 +000075 size_t curCacheSize;
halcanary96fcdcc2015-08-27 07:41:13 -070076 context->getResourceCacheUsage(nullptr, &curCacheSize);
commit-bot@chromium.orgc28f5552013-08-08 22:55:21 +000077
78 // we should never go over the size limit
79 REPORTER_ASSERT(reporter, curCacheSize <= maxCacheSize);
80 }
81
commit-bot@chromium.org95c20032014-05-09 14:29:32 +000082 context->setResourceCacheLimits(oldMaxNum, oldMaxBytes);
commit-bot@chromium.orgc28f5552013-08-08 22:55:21 +000083}
84
bsalomon11abd8d2016-10-14 08:13:48 -070085static bool is_rendering_and_not_angle_es3(sk_gpu_test::GrContextFactory::ContextType type) {
86 if (type == sk_gpu_test::GrContextFactory::kANGLE_D3D11_ES3_ContextType ||
87 type == sk_gpu_test::GrContextFactory::kANGLE_GL_ES3_ContextType) {
88 return false;
89 }
90 return sk_gpu_test::GrContextFactory::IsRenderingContext(type);
91}
92
Robert Phillipsc0192e32017-09-21 12:00:26 -040093static GrStencilAttachment* get_SB(GrRenderTarget* rt) {
94 return rt->renderTargetPriv().getStencilAttachment();
95}
96
97static sk_sp<GrRenderTarget> create_RT_with_SB(GrResourceProvider* provider,
98 int size, int sampleCount, SkBudgeted budgeted) {
99 GrSurfaceDesc desc;
100 desc.fFlags = kRenderTarget_GrSurfaceFlag;
Robert Phillipsc0192e32017-09-21 12:00:26 -0400101 desc.fWidth = size;
102 desc.fHeight = size;
103 desc.fConfig = kRGBA_8888_GrPixelConfig;
104 desc.fSampleCnt = sampleCount;
105
106 sk_sp<GrTexture> tex(provider->createTexture(desc, budgeted));
107 if (!tex || !tex->asRenderTarget()) {
108 return nullptr;
109 }
110
111 if (!provider->attachStencilAttachment(tex->asRenderTarget())) {
112 return nullptr;
113 }
114 SkASSERT(get_SB(tex->asRenderTarget()));
115
116 return sk_ref_sp(tex->asRenderTarget());
117}
118
bsalomon11abd8d2016-10-14 08:13:48 -0700119// This currently fails on ES3 ANGLE contexts
120DEF_GPUTEST_FOR_CONTEXTS(ResourceCacheStencilBuffers, &is_rendering_and_not_angle_es3, reporter,
Robert Phillipsec325342017-10-30 18:02:48 +0000121 ctxInfo, nullptr) {
bsalomon8b7451a2016-05-11 06:33:06 -0700122 GrContext* context = ctxInfo.grContext();
Brian Salomonc7fe0f72018-05-11 10:14:21 -0400123 if (context->contextPriv().caps()->avoidStencilBuffers()) {
Eric Karl5c779752017-05-08 12:02:07 -0700124 return;
125 }
Robert Phillipsc0192e32017-09-21 12:00:26 -0400126
Robert Phillips6be756b2018-01-16 15:07:54 -0500127 GrResourceProvider* resourceProvider = context->contextPriv().resourceProvider();
Robert Phillipsc0192e32017-09-21 12:00:26 -0400128
Brian Salomonbdecacf2018-02-02 20:32:49 -0500129 sk_sp<GrRenderTarget> smallRT0 = create_RT_with_SB(resourceProvider, 4, 1, SkBudgeted::kYes);
Robert Phillipsc0192e32017-09-21 12:00:26 -0400130 REPORTER_ASSERT(reporter, smallRT0);
131
132 {
133 // Two budgeted RTs with the same desc should share a stencil buffer.
Brian Salomonbdecacf2018-02-02 20:32:49 -0500134 sk_sp<GrRenderTarget> smallRT1 = create_RT_with_SB(resourceProvider, 4, 1, SkBudgeted::kYes);
135 REPORTER_ASSERT(reporter, smallRT1);
Robert Phillipsc0192e32017-09-21 12:00:26 -0400136
Brian Salomonbdecacf2018-02-02 20:32:49 -0500137 REPORTER_ASSERT(reporter, get_SB(smallRT0.get()) == get_SB(smallRT1.get()));
bsalomon6bc1b5f2015-02-23 09:06:38 -0800138 }
139
Robert Phillipsc0192e32017-09-21 12:00:26 -0400140 {
141 // An unbudgeted RT with the same desc should also share.
Brian Salomonbdecacf2018-02-02 20:32:49 -0500142 sk_sp<GrRenderTarget> smallRT2 = create_RT_with_SB(resourceProvider, 4, 1, SkBudgeted::kNo);
Robert Phillipsc0192e32017-09-21 12:00:26 -0400143 REPORTER_ASSERT(reporter, smallRT2);
144
145 REPORTER_ASSERT(reporter, get_SB(smallRT0.get()) == get_SB(smallRT2.get()));
bsalomon6bc1b5f2015-02-23 09:06:38 -0800146 }
147
Robert Phillipsc0192e32017-09-21 12:00:26 -0400148 {
149 // An RT with a much larger size should not share.
Brian Salomonbdecacf2018-02-02 20:32:49 -0500150 sk_sp<GrRenderTarget> bigRT = create_RT_with_SB(resourceProvider, 400, 1, SkBudgeted::kNo);
Robert Phillipsc0192e32017-09-21 12:00:26 -0400151 REPORTER_ASSERT(reporter, bigRT);
bsalomon02a44a42015-02-19 09:09:00 -0800152
Robert Phillipsc0192e32017-09-21 12:00:26 -0400153 REPORTER_ASSERT(reporter, get_SB(smallRT0.get()) != get_SB(bigRT.get()));
bsalomon6bc1b5f2015-02-23 09:06:38 -0800154 }
bsalomon02a44a42015-02-19 09:09:00 -0800155
Brian Salomonc7fe0f72018-05-11 10:14:21 -0400156 int smallSampleCount =
157 context->contextPriv().caps()->getRenderTargetSampleCount(2, kRGBA_8888_GrPixelConfig);
Brian Salomonbdecacf2018-02-02 20:32:49 -0500158 if (smallSampleCount > 1) {
mtklein5f939ab2016-03-16 10:28:35 -0700159 // An RT with a different sample count should not share.
Robert Phillips6be756b2018-01-16 15:07:54 -0500160 sk_sp<GrRenderTarget> smallMSAART0 = create_RT_with_SB(resourceProvider, 4,
161 smallSampleCount, SkBudgeted::kNo);
bsalomonb602d4d2015-02-19 12:05:58 -0800162#ifdef SK_BUILD_FOR_ANDROID
163 if (!smallMSAART0) {
164 // The nexus player seems to fail to create MSAA textures.
165 return;
166 }
Robert Phillipsc0192e32017-09-21 12:00:26 -0400167#else
168 REPORTER_ASSERT(reporter, smallMSAART0);
bsalomonb602d4d2015-02-19 12:05:58 -0800169#endif
Robert Phillipsc0192e32017-09-21 12:00:26 -0400170
171 REPORTER_ASSERT(reporter, get_SB(smallRT0.get()) != get_SB(smallMSAART0.get()));
172
173 {
174 // A second MSAA RT should share with the first MSAA RT.
Robert Phillips6be756b2018-01-16 15:07:54 -0500175 sk_sp<GrRenderTarget> smallMSAART1 = create_RT_with_SB(resourceProvider, 4,
176 smallSampleCount,
Robert Phillipsc0192e32017-09-21 12:00:26 -0400177 SkBudgeted::kNo);
178 REPORTER_ASSERT(reporter, smallMSAART1);
179
180 REPORTER_ASSERT(reporter, get_SB(smallMSAART0.get()) == get_SB(smallMSAART1.get()));
bsalomon6bc1b5f2015-02-23 09:06:38 -0800181 }
Robert Phillipsc0192e32017-09-21 12:00:26 -0400182
Brian Salomonbdecacf2018-02-02 20:32:49 -0500183 // But one with a larger sample count should not. (Also check that the two requests didn't
184 // rounded up to the same actual sample count or else they could share.).
Brian Salomonc7fe0f72018-05-11 10:14:21 -0400185 int bigSampleCount = context->contextPriv().caps()->getRenderTargetSampleCount(
186 5, kRGBA_8888_GrPixelConfig);
Brian Salomonbdecacf2018-02-02 20:32:49 -0500187 if (bigSampleCount > 0 && bigSampleCount != smallSampleCount) {
Robert Phillips6be756b2018-01-16 15:07:54 -0500188 sk_sp<GrRenderTarget> smallMSAART2 = create_RT_with_SB(resourceProvider, 4,
189 bigSampleCount,
Robert Phillipsc0192e32017-09-21 12:00:26 -0400190 SkBudgeted::kNo);
191 REPORTER_ASSERT(reporter, smallMSAART2);
192
193 REPORTER_ASSERT(reporter, get_SB(smallMSAART0.get()) != get_SB(smallMSAART2.get()));
bsalomon02a44a42015-02-19 09:09:00 -0800194 }
195 }
196}
197
bsalomon68d91342016-04-12 09:59:58 -0700198DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ResourceCacheWrappedResources, reporter, ctxInfo) {
bsalomon8b7451a2016-05-11 06:33:06 -0700199 GrContext* context = ctxInfo.grContext();
Robert Phillips6be756b2018-01-16 15:07:54 -0500200 GrResourceProvider* resourceProvider = context->contextPriv().resourceProvider();
Robert Phillipsf35fd8d2018-01-22 10:48:15 -0500201 GrGpu* gpu = context->contextPriv().getGpu();
jvanvertheeb8d992015-07-15 10:16:56 -0700202 // this test is only valid for GL
203 if (!gpu || !gpu->glContextForTesting()) {
bsalomon6dc6f5f2015-06-18 09:12:16 -0700204 return;
205 }
206
Robert Phillipsd21b2a52017-12-12 13:01:25 -0500207 GrBackendTexture backendTextures[2];
bsalomon6dc6f5f2015-06-18 09:12:16 -0700208 static const int kW = 100;
209 static const int kH = 100;
jvanverth672bb7f2015-07-13 07:19:57 -0700210
Robert Phillipsd21b2a52017-12-12 13:01:25 -0500211 backendTextures[0] = gpu->createTestingOnlyBackendTexture(nullptr, kW, kH,
212 kRGBA_8888_GrPixelConfig,
213 false, GrMipMapped::kNo);
214 backendTextures[1] = gpu->createTestingOnlyBackendTexture(nullptr, kW, kH,
215 kRGBA_8888_GrPixelConfig,
216 false, GrMipMapped::kNo);
Greg Daniel5366e592018-01-10 09:57:53 -0500217 REPORTER_ASSERT(reporter, backendTextures[0].isValid());
218 REPORTER_ASSERT(reporter, backendTextures[1].isValid());
219 if (!backendTextures[0].isValid() || !backendTextures[1].isValid()) {
220 return;
221 }
jvanverth672bb7f2015-07-13 07:19:57 -0700222
bsalomon6dc6f5f2015-06-18 09:12:16 -0700223 context->resetContext();
224
Robert Phillips6be756b2018-01-16 15:07:54 -0500225 sk_sp<GrTexture> borrowed(resourceProvider->wrapBackendTexture(
Robert Phillipsd21b2a52017-12-12 13:01:25 -0500226 backendTextures[0], kBorrow_GrWrapOwnership));
bsalomon6dc6f5f2015-06-18 09:12:16 -0700227
Robert Phillips6be756b2018-01-16 15:07:54 -0500228 sk_sp<GrTexture> adopted(resourceProvider->wrapBackendTexture(
Robert Phillipsd21b2a52017-12-12 13:01:25 -0500229 backendTextures[1], kAdopt_GrWrapOwnership));
bsalomon6dc6f5f2015-06-18 09:12:16 -0700230
Brian Osman85d34b22017-05-10 12:06:26 -0400231 REPORTER_ASSERT(reporter, borrowed != nullptr && adopted != nullptr);
232 if (!borrowed || !adopted) {
bsalomon6dc6f5f2015-06-18 09:12:16 -0700233 return;
234 }
235
halcanary96fcdcc2015-08-27 07:41:13 -0700236 borrowed.reset(nullptr);
237 adopted.reset(nullptr);
bsalomon6dc6f5f2015-06-18 09:12:16 -0700238
239 context->flush();
240
Robert Phillipsd21b2a52017-12-12 13:01:25 -0500241 bool borrowedIsAlive = gpu->isTestingOnlyBackendTexture(backendTextures[0]);
242 bool adoptedIsAlive = gpu->isTestingOnlyBackendTexture(backendTextures[1]);
bsalomon6dc6f5f2015-06-18 09:12:16 -0700243
244 REPORTER_ASSERT(reporter, borrowedIsAlive);
245 REPORTER_ASSERT(reporter, !adoptedIsAlive);
246
Brian Salomone64b0642018-03-07 11:47:54 -0500247 if (borrowedIsAlive) {
Brian Salomon26102cb2018-03-09 09:33:19 -0500248 gpu->deleteTestingOnlyBackendTexture(backendTextures[0]);
Brian Salomone64b0642018-03-07 11:47:54 -0500249 }
250 if (adoptedIsAlive) {
Brian Salomon26102cb2018-03-09 09:33:19 -0500251 gpu->deleteTestingOnlyBackendTexture(backendTextures[1]);
Brian Salomone64b0642018-03-07 11:47:54 -0500252 }
bsalomon6dc6f5f2015-06-18 09:12:16 -0700253
254 context->resetContext();
255}
256
bsalomon6d3fe022014-07-25 08:35:45 -0700257class TestResource : public GrGpuResource {
bsalomon1c60dfe2015-01-21 09:32:40 -0800258 enum ScratchConstructor { kScratchConstructor };
commit-bot@chromium.orgc6658042014-01-15 23:09:01 +0000259public:
robertphillips6e83ac72015-08-13 05:19:14 -0700260 static const size_t kDefaultSize = 100;
mtklein5f939ab2016-03-16 10:28:35 -0700261
bsalomon1c60dfe2015-01-21 09:32:40 -0800262 /** Property that distinctly categorizes the resource.
263 * For example, textures have width, height, ... */
bsalomon23e619c2015-02-06 11:54:28 -0800264 enum SimulatedProperty { kA_SimulatedProperty, kB_SimulatedProperty };
bsalomon1c60dfe2015-01-21 09:32:40 -0800265
kkinnunen2e6055b2016-04-22 01:48:29 -0700266 TestResource(GrGpu* gpu, SkBudgeted budgeted = SkBudgeted::kYes, size_t size = kDefaultSize)
267 : INHERITED(gpu)
halcanary96fcdcc2015-08-27 07:41:13 -0700268 , fToDelete(nullptr)
bsalomon1c60dfe2015-01-21 09:32:40 -0800269 , fSize(size)
kkinnunen2e6055b2016-04-22 01:48:29 -0700270 , fProperty(kA_SimulatedProperty)
271 , fIsScratch(false) {
bsalomon5236cf42015-01-14 10:42:08 -0800272 ++fNumAlive;
kkinnunen2e6055b2016-04-22 01:48:29 -0700273 this->registerWithCache(budgeted);
bsalomon5236cf42015-01-14 10:42:08 -0800274 }
275
kkinnunen2e6055b2016-04-22 01:48:29 -0700276 static TestResource* CreateScratch(GrGpu* gpu, SkBudgeted budgeted,
Greg Danielda86e282018-06-13 09:41:19 -0400277 SimulatedProperty property, size_t size = kDefaultSize) {
278 return new TestResource(gpu, budgeted, property, kScratchConstructor, size);
bsalomondace19e2014-11-17 07:34:06 -0800279 }
kkinnunen2e6055b2016-04-22 01:48:29 -0700280 static TestResource* CreateWrapped(GrGpu* gpu, size_t size = kDefaultSize) {
281 return new TestResource(gpu, size);
commit-bot@chromium.orgc6658042014-01-15 23:09:01 +0000282 }
283
Brian Salomond3b65972017-03-22 12:05:03 -0400284 ~TestResource() override {
bsalomon33435572014-11-05 14:47:41 -0800285 --fNumAlive;
commit-bot@chromium.orgc6658042014-01-15 23:09:01 +0000286 }
287
bsalomon33435572014-11-05 14:47:41 -0800288 static int NumAlive() { return fNumAlive; }
commit-bot@chromium.orgc6658042014-01-15 23:09:01 +0000289
Ben Wagner97c6a0e2018-07-11 14:56:22 -0400290 void setUnrefWhenDestroyed(sk_sp<TestResource> resource) {
291 fToDelete = std::move(resource);
commit-bot@chromium.orgc6658042014-01-15 23:09:01 +0000292 }
293
bsalomon1c60dfe2015-01-21 09:32:40 -0800294 static void ComputeScratchKey(SimulatedProperty property, GrScratchKey* key) {
295 static GrScratchKey::ResourceType t = GrScratchKey::GenerateResourceType();
296 GrScratchKey::Builder builder(key, t, kScratchKeyFieldCnt);
bsalomon24db3b12015-01-23 04:24:04 -0800297 for (int i = 0; i < kScratchKeyFieldCnt; ++i) {
298 builder[i] = static_cast<uint32_t>(i + property);
bsalomon1c60dfe2015-01-21 09:32:40 -0800299 }
300 }
301
302 static size_t ExpectedScratchKeySize() {
303 return sizeof(uint32_t) * (kScratchKeyFieldCnt + GrScratchKey::kMetaDataCnt);
304 }
commit-bot@chromium.orgc6658042014-01-15 23:09:01 +0000305private:
bsalomon24db3b12015-01-23 04:24:04 -0800306 static const int kScratchKeyFieldCnt = 6;
bsalomon1c60dfe2015-01-21 09:32:40 -0800307
Greg Danielda86e282018-06-13 09:41:19 -0400308 TestResource(GrGpu* gpu, SkBudgeted budgeted, SimulatedProperty property, ScratchConstructor,
309 size_t size = kDefaultSize)
kkinnunen2e6055b2016-04-22 01:48:29 -0700310 : INHERITED(gpu)
halcanary96fcdcc2015-08-27 07:41:13 -0700311 , fToDelete(nullptr)
Greg Danielda86e282018-06-13 09:41:19 -0400312 , fSize(size)
kkinnunen2e6055b2016-04-22 01:48:29 -0700313 , fProperty(property)
314 , fIsScratch(true) {
bsalomon1c60dfe2015-01-21 09:32:40 -0800315 ++fNumAlive;
kkinnunen2e6055b2016-04-22 01:48:29 -0700316 this->registerWithCache(budgeted);
317 }
318
319 // Constructor for simulating resources that wrap backend objects.
320 TestResource(GrGpu* gpu, size_t size)
321 : INHERITED(gpu)
322 , fToDelete(nullptr)
323 , fSize(size)
324 , fProperty(kA_SimulatedProperty)
325 , fIsScratch(false) {
326 ++fNumAlive;
327 this->registerWithCacheWrapped();
328 }
329
330 void computeScratchKey(GrScratchKey* key) const override {
331 if (fIsScratch) {
332 ComputeScratchKey(fProperty, key);
333 }
bsalomon1c60dfe2015-01-21 09:32:40 -0800334 }
335
mtklein36352bf2015-03-25 18:17:31 -0700336 size_t onGpuMemorySize() const override { return fSize; }
Derek Sollenbergercf6da8c2018-03-29 13:40:02 -0400337 const char* getResourceType() const override { return "Test"; }
bsalomon69ed47f2014-11-12 11:13:39 -0800338
Ben Wagner97c6a0e2018-07-11 14:56:22 -0400339 sk_sp<TestResource> fToDelete;
commit-bot@chromium.org11c6b392014-05-05 19:09:13 +0000340 size_t fSize;
bsalomon33435572014-11-05 14:47:41 -0800341 static int fNumAlive;
bsalomon1c60dfe2015-01-21 09:32:40 -0800342 SimulatedProperty fProperty;
kkinnunen2e6055b2016-04-22 01:48:29 -0700343 bool fIsScratch;
bsalomon6d3fe022014-07-25 08:35:45 -0700344 typedef GrGpuResource INHERITED;
commit-bot@chromium.orgc6658042014-01-15 23:09:01 +0000345};
bsalomon33435572014-11-05 14:47:41 -0800346int TestResource::fNumAlive = 0;
commit-bot@chromium.orgc6658042014-01-15 23:09:01 +0000347
bsalomonc2f35b72015-01-23 07:19:22 -0800348class Mock {
349public:
350 Mock(int maxCnt, size_t maxBytes) {
Greg Daniel02611d92017-07-25 10:05:01 -0400351 fContext = GrContext::MakeMock(nullptr);
bsalomonc2f35b72015-01-23 07:19:22 -0800352 SkASSERT(fContext);
353 fContext->setResourceCacheLimits(maxCnt, maxBytes);
Robert Phillips6be756b2018-01-16 15:07:54 -0500354 GrResourceCache* cache = fContext->contextPriv().getResourceCache();
bsalomon0ea80f42015-02-11 10:49:59 -0800355 cache->purgeAllUnlocked();
356 SkASSERT(0 == cache->getResourceCount() && 0 == cache->getResourceBytes());
bsalomon71cb0c22014-11-14 12:10:14 -0800357 }
bsalomonc2f35b72015-01-23 07:19:22 -0800358
Robert Phillips6be756b2018-01-16 15:07:54 -0500359 GrResourceCache* cache() { return fContext->contextPriv().getResourceCache(); }
bsalomonc2f35b72015-01-23 07:19:22 -0800360
Hal Canary342b7ac2016-11-04 11:49:42 -0400361 GrContext* context() { return fContext.get(); }
bsalomonc2f35b72015-01-23 07:19:22 -0800362
363private:
Hal Canary342b7ac2016-11-04 11:49:42 -0400364 sk_sp<GrContext> fContext;
bsalomonc2f35b72015-01-23 07:19:22 -0800365};
366
367static void test_no_key(skiatest::Reporter* reporter) {
368 Mock mock(10, 30000);
369 GrContext* context = mock.context();
bsalomon0ea80f42015-02-11 10:49:59 -0800370 GrResourceCache* cache = mock.cache();
Robert Phillipsf35fd8d2018-01-22 10:48:15 -0500371 GrGpu* gpu = context->contextPriv().getGpu();
bsalomon71cb0c22014-11-14 12:10:14 -0800372
373 // Create a bunch of resources with no keys
Greg Danielda86e282018-06-13 09:41:19 -0400374 TestResource* a = new TestResource(gpu, SkBudgeted::kYes, 11);
375 TestResource* b = new TestResource(gpu, SkBudgeted::kYes, 12);
376 TestResource* c = new TestResource(gpu, SkBudgeted::kYes, 13 );
377 TestResource* d = new TestResource(gpu, SkBudgeted::kYes, 14 );
bsalomon71cb0c22014-11-14 12:10:14 -0800378
379 REPORTER_ASSERT(reporter, 4 == TestResource::NumAlive());
bsalomon0ea80f42015-02-11 10:49:59 -0800380 REPORTER_ASSERT(reporter, 4 == cache->getResourceCount());
bsalomon71cb0c22014-11-14 12:10:14 -0800381 REPORTER_ASSERT(reporter, a->gpuMemorySize() + b->gpuMemorySize() + c->gpuMemorySize() +
bsalomon0ea80f42015-02-11 10:49:59 -0800382 d->gpuMemorySize() == cache->getResourceBytes());
bsalomon71cb0c22014-11-14 12:10:14 -0800383
384 // Should be safe to purge without deleting the resources since we still have refs.
bsalomon0ea80f42015-02-11 10:49:59 -0800385 cache->purgeAllUnlocked();
bsalomon71cb0c22014-11-14 12:10:14 -0800386 REPORTER_ASSERT(reporter, 4 == TestResource::NumAlive());
387
bsalomon8718aaf2015-02-19 07:24:21 -0800388 // Since the resources have neither unique nor scratch keys, delete immediately upon unref.
bsalomon71cb0c22014-11-14 12:10:14 -0800389
390 a->unref();
391 REPORTER_ASSERT(reporter, 3 == TestResource::NumAlive());
bsalomon0ea80f42015-02-11 10:49:59 -0800392 REPORTER_ASSERT(reporter, 3 == cache->getResourceCount());
bsalomon71cb0c22014-11-14 12:10:14 -0800393 REPORTER_ASSERT(reporter, b->gpuMemorySize() + c->gpuMemorySize() + d->gpuMemorySize() ==
bsalomon0ea80f42015-02-11 10:49:59 -0800394 cache->getResourceBytes());
bsalomon71cb0c22014-11-14 12:10:14 -0800395
396 c->unref();
397 REPORTER_ASSERT(reporter, 2 == TestResource::NumAlive());
bsalomon0ea80f42015-02-11 10:49:59 -0800398 REPORTER_ASSERT(reporter, 2 == cache->getResourceCount());
bsalomon71cb0c22014-11-14 12:10:14 -0800399 REPORTER_ASSERT(reporter, b->gpuMemorySize() + d->gpuMemorySize() ==
bsalomon0ea80f42015-02-11 10:49:59 -0800400 cache->getResourceBytes());
bsalomon71cb0c22014-11-14 12:10:14 -0800401
402 d->unref();
403 REPORTER_ASSERT(reporter, 1 == TestResource::NumAlive());
bsalomon0ea80f42015-02-11 10:49:59 -0800404 REPORTER_ASSERT(reporter, 1 == cache->getResourceCount());
405 REPORTER_ASSERT(reporter, b->gpuMemorySize() == cache->getResourceBytes());
bsalomon71cb0c22014-11-14 12:10:14 -0800406
407 b->unref();
408 REPORTER_ASSERT(reporter, 0 == TestResource::NumAlive());
bsalomon0ea80f42015-02-11 10:49:59 -0800409 REPORTER_ASSERT(reporter, 0 == cache->getResourceCount());
410 REPORTER_ASSERT(reporter, 0 == cache->getResourceBytes());
bsalomon71cb0c22014-11-14 12:10:14 -0800411}
412
bsalomon24db3b12015-01-23 04:24:04 -0800413// Each integer passed as a template param creates a new domain.
Brian Salomon1090da62017-01-06 12:04:19 -0500414template <int>
415static void make_unique_key(GrUniqueKey* key, int data, const char* tag = nullptr) {
bsalomon8718aaf2015-02-19 07:24:21 -0800416 static GrUniqueKey::Domain d = GrUniqueKey::GenerateDomain();
Brian Salomon1090da62017-01-06 12:04:19 -0500417 GrUniqueKey::Builder builder(key, d, 1, tag);
bsalomon24db3b12015-01-23 04:24:04 -0800418 builder[0] = data;
419}
420
Robert Phillips6eba0632018-03-28 12:25:42 -0400421static void test_purge_unlocked(skiatest::Reporter* reporter) {
422 Mock mock(10, 30000);
423 GrContext* context = mock.context();
424 GrResourceCache* cache = mock.cache();
425 GrGpu* gpu = context->contextPriv().getGpu();
426
427 // Create two resource w/ a unique key and two w/o but all of which have scratch keys.
428 TestResource* a = TestResource::CreateScratch(gpu, SkBudgeted::kYes,
Greg Danielda86e282018-06-13 09:41:19 -0400429 TestResource::kA_SimulatedProperty, 11);
Robert Phillips6eba0632018-03-28 12:25:42 -0400430
431 GrUniqueKey uniqueKey;
432 make_unique_key<0>(&uniqueKey, 0);
433
434 TestResource* b = TestResource::CreateScratch(gpu, SkBudgeted::kYes,
Greg Danielda86e282018-06-13 09:41:19 -0400435 TestResource::kA_SimulatedProperty, 12);
Robert Phillips6eba0632018-03-28 12:25:42 -0400436 b->resourcePriv().setUniqueKey(uniqueKey);
437
438 TestResource* c = TestResource::CreateScratch(gpu, SkBudgeted::kYes,
Greg Danielda86e282018-06-13 09:41:19 -0400439 TestResource::kA_SimulatedProperty, 13);
Robert Phillips6eba0632018-03-28 12:25:42 -0400440
441 GrUniqueKey uniqueKey2;
442 make_unique_key<0>(&uniqueKey2, 1);
443
444 TestResource* d = TestResource::CreateScratch(gpu, SkBudgeted::kYes,
Greg Danielda86e282018-06-13 09:41:19 -0400445 TestResource::kA_SimulatedProperty, 14);
Robert Phillips6eba0632018-03-28 12:25:42 -0400446 d->resourcePriv().setUniqueKey(uniqueKey2);
447
448
449 REPORTER_ASSERT(reporter, 4 == TestResource::NumAlive());
450 REPORTER_ASSERT(reporter, 4 == cache->getResourceCount());
451 REPORTER_ASSERT(reporter, a->gpuMemorySize() + b->gpuMemorySize() + c->gpuMemorySize() +
452 d->gpuMemorySize() == cache->getResourceBytes());
453
454 // Should be safe to purge without deleting the resources since we still have refs.
455 cache->purgeUnlockedResources(false);
456 REPORTER_ASSERT(reporter, 4 == TestResource::NumAlive());
457
458 // Unref them all. Since they all have keys they should remain in the cache.
459
460 a->unref();
461 b->unref();
462 c->unref();
463 d->unref();
464 REPORTER_ASSERT(reporter, 4 == TestResource::NumAlive());
465 REPORTER_ASSERT(reporter, 4 == cache->getResourceCount());
466 REPORTER_ASSERT(reporter, a->gpuMemorySize() + b->gpuMemorySize() + c->gpuMemorySize() +
467 d->gpuMemorySize() == cache->getResourceBytes());
468
469 // Purge only the two scratch resources
470 cache->purgeUnlockedResources(true);
471
472 REPORTER_ASSERT(reporter, 2 == TestResource::NumAlive());
473 REPORTER_ASSERT(reporter, 2 == cache->getResourceCount());
474 REPORTER_ASSERT(reporter, b->gpuMemorySize() + d->gpuMemorySize() ==
475 cache->getResourceBytes());
476
477 // Purge the uniquely keyed resources
478 cache->purgeUnlockedResources(false);
479
480 REPORTER_ASSERT(reporter, 0 == TestResource::NumAlive());
481 REPORTER_ASSERT(reporter, 0 == cache->getResourceCount());
482 REPORTER_ASSERT(reporter, 0 == cache->getResourceBytes());
483}
484
bsalomon84c8e622014-11-17 09:33:27 -0800485static void test_budgeting(skiatest::Reporter* reporter) {
bsalomonc2f35b72015-01-23 07:19:22 -0800486 Mock mock(10, 300);
487 GrContext* context = mock.context();
bsalomon0ea80f42015-02-11 10:49:59 -0800488 GrResourceCache* cache = mock.cache();
Robert Phillipsf35fd8d2018-01-22 10:48:15 -0500489 GrGpu* gpu = context->contextPriv().getGpu();
bsalomondace19e2014-11-17 07:34:06 -0800490
bsalomon8718aaf2015-02-19 07:24:21 -0800491 GrUniqueKey uniqueKey;
492 make_unique_key<0>(&uniqueKey, 0);
bsalomondace19e2014-11-17 07:34:06 -0800493
bsalomon8718aaf2015-02-19 07:24:21 -0800494 // Create a scratch, a unique, and a wrapped resource
bsalomon1c60dfe2015-01-21 09:32:40 -0800495 TestResource* scratch =
Greg Danielda86e282018-06-13 09:41:19 -0400496 TestResource::CreateScratch(gpu, SkBudgeted::kYes, TestResource::kB_SimulatedProperty,
497 10);
498 TestResource* unique = new TestResource(gpu, SkBudgeted::kYes, 11);
bsalomonf99e9612015-02-19 08:24:16 -0800499 unique->resourcePriv().setUniqueKey(uniqueKey);
Greg Danielda86e282018-06-13 09:41:19 -0400500 TestResource* wrapped = TestResource::CreateWrapped(gpu, 12);
501 TestResource* unbudgeted = new TestResource(gpu, SkBudgeted::kNo, 13);
bsalomondace19e2014-11-17 07:34:06 -0800502
Brian Osman0562eb92017-05-08 11:16:39 -0400503 // Make sure we can add a unique key to the wrapped resource
bsalomon8718aaf2015-02-19 07:24:21 -0800504 GrUniqueKey uniqueKey2;
505 make_unique_key<0>(&uniqueKey2, 1);
bsalomonf99e9612015-02-19 08:24:16 -0800506 wrapped->resourcePriv().setUniqueKey(uniqueKey2);
Brian Osman0562eb92017-05-08 11:16:39 -0400507 GrGpuResource* wrappedViaKey = cache->findAndRefUniqueResource(uniqueKey2);
508 REPORTER_ASSERT(reporter, wrappedViaKey != nullptr);
509
510 // Remove the extra ref we just added.
511 wrappedViaKey->unref();
bsalomondace19e2014-11-17 07:34:06 -0800512
513 // Make sure sizes are as we expect
bsalomon0ea80f42015-02-11 10:49:59 -0800514 REPORTER_ASSERT(reporter, 4 == cache->getResourceCount());
bsalomon8718aaf2015-02-19 07:24:21 -0800515 REPORTER_ASSERT(reporter, scratch->gpuMemorySize() + unique->gpuMemorySize() +
bsalomon84c8e622014-11-17 09:33:27 -0800516 wrapped->gpuMemorySize() + unbudgeted->gpuMemorySize() ==
bsalomon0ea80f42015-02-11 10:49:59 -0800517 cache->getResourceBytes());
518 REPORTER_ASSERT(reporter, 2 == cache->getBudgetedResourceCount());
bsalomon8718aaf2015-02-19 07:24:21 -0800519 REPORTER_ASSERT(reporter, scratch->gpuMemorySize() + unique->gpuMemorySize() ==
bsalomon0ea80f42015-02-11 10:49:59 -0800520 cache->getBudgetedResourceBytes());
Derek Sollenbergeree479142017-05-24 11:41:33 -0400521 REPORTER_ASSERT(reporter, 0 == cache->getPurgeableBytes());
bsalomondace19e2014-11-17 07:34:06 -0800522
bsalomon63c992f2015-01-23 12:47:59 -0800523 // Our refs mean that the resources are non purgeable.
bsalomon0ea80f42015-02-11 10:49:59 -0800524 cache->purgeAllUnlocked();
525 REPORTER_ASSERT(reporter, 4 == cache->getResourceCount());
bsalomon8718aaf2015-02-19 07:24:21 -0800526 REPORTER_ASSERT(reporter, scratch->gpuMemorySize() + unique->gpuMemorySize() +
bsalomon84c8e622014-11-17 09:33:27 -0800527 wrapped->gpuMemorySize() + unbudgeted->gpuMemorySize() ==
bsalomon0ea80f42015-02-11 10:49:59 -0800528 cache->getResourceBytes());
529 REPORTER_ASSERT(reporter, 2 == cache->getBudgetedResourceCount());
bsalomon8718aaf2015-02-19 07:24:21 -0800530 REPORTER_ASSERT(reporter, scratch->gpuMemorySize() + unique->gpuMemorySize() ==
bsalomon0ea80f42015-02-11 10:49:59 -0800531 cache->getBudgetedResourceBytes());
Derek Sollenbergeree479142017-05-24 11:41:33 -0400532 REPORTER_ASSERT(reporter, 0 == cache->getPurgeableBytes());
bsalomondace19e2014-11-17 07:34:06 -0800533
534 // Unreffing the wrapped resource should free it right away.
535 wrapped->unref();
bsalomon0ea80f42015-02-11 10:49:59 -0800536 REPORTER_ASSERT(reporter, 3 == cache->getResourceCount());
bsalomon8718aaf2015-02-19 07:24:21 -0800537 REPORTER_ASSERT(reporter, scratch->gpuMemorySize() + unique->gpuMemorySize() +
bsalomon0ea80f42015-02-11 10:49:59 -0800538 unbudgeted->gpuMemorySize() == cache->getResourceBytes());
Derek Sollenbergeree479142017-05-24 11:41:33 -0400539 REPORTER_ASSERT(reporter, 0 == cache->getPurgeableBytes());
bsalomondace19e2014-11-17 07:34:06 -0800540
bsalomon84c8e622014-11-17 09:33:27 -0800541 // Now try freeing the budgeted resources first
Robert Phillipsf35fd8d2018-01-22 10:48:15 -0500542 wrapped = TestResource::CreateWrapped(gpu);
bsalomon8718aaf2015-02-19 07:24:21 -0800543 unique->unref();
Derek Sollenbergeree479142017-05-24 11:41:33 -0400544 REPORTER_ASSERT(reporter, 11 == cache->getPurgeableBytes());
bsalomon0ea80f42015-02-11 10:49:59 -0800545 cache->purgeAllUnlocked();
546 REPORTER_ASSERT(reporter, 3 == cache->getResourceCount());
bsalomon84c8e622014-11-17 09:33:27 -0800547 REPORTER_ASSERT(reporter, scratch->gpuMemorySize() + wrapped->gpuMemorySize() +
bsalomon0ea80f42015-02-11 10:49:59 -0800548 unbudgeted->gpuMemorySize() == cache->getResourceBytes());
549 REPORTER_ASSERT(reporter, 1 == cache->getBudgetedResourceCount());
550 REPORTER_ASSERT(reporter, scratch->gpuMemorySize() == cache->getBudgetedResourceBytes());
Derek Sollenbergeree479142017-05-24 11:41:33 -0400551 REPORTER_ASSERT(reporter, 0 == cache->getPurgeableBytes());
bsalomondace19e2014-11-17 07:34:06 -0800552
553 scratch->unref();
Greg Danielda86e282018-06-13 09:41:19 -0400554 REPORTER_ASSERT(reporter, 10 == cache->getPurgeableBytes());
bsalomon0ea80f42015-02-11 10:49:59 -0800555 cache->purgeAllUnlocked();
556 REPORTER_ASSERT(reporter, 2 == cache->getResourceCount());
bsalomon84c8e622014-11-17 09:33:27 -0800557 REPORTER_ASSERT(reporter, unbudgeted->gpuMemorySize() + wrapped->gpuMemorySize() ==
bsalomon0ea80f42015-02-11 10:49:59 -0800558 cache->getResourceBytes());
559 REPORTER_ASSERT(reporter, 0 == cache->getBudgetedResourceCount());
560 REPORTER_ASSERT(reporter, 0 == cache->getBudgetedResourceBytes());
Derek Sollenbergeree479142017-05-24 11:41:33 -0400561 REPORTER_ASSERT(reporter, 0 == cache->getPurgeableBytes());
bsalomondace19e2014-11-17 07:34:06 -0800562
563 wrapped->unref();
bsalomon0ea80f42015-02-11 10:49:59 -0800564 REPORTER_ASSERT(reporter, 1 == cache->getResourceCount());
565 REPORTER_ASSERT(reporter, unbudgeted->gpuMemorySize() == cache->getResourceBytes());
566 REPORTER_ASSERT(reporter, 0 == cache->getBudgetedResourceCount());
567 REPORTER_ASSERT(reporter, 0 == cache->getBudgetedResourceBytes());
Derek Sollenbergeree479142017-05-24 11:41:33 -0400568 REPORTER_ASSERT(reporter, 0 == cache->getPurgeableBytes());
bsalomon84c8e622014-11-17 09:33:27 -0800569
570 unbudgeted->unref();
bsalomon0ea80f42015-02-11 10:49:59 -0800571 REPORTER_ASSERT(reporter, 0 == cache->getResourceCount());
572 REPORTER_ASSERT(reporter, 0 == cache->getResourceBytes());
573 REPORTER_ASSERT(reporter, 0 == cache->getBudgetedResourceCount());
574 REPORTER_ASSERT(reporter, 0 == cache->getBudgetedResourceBytes());
Derek Sollenbergeree479142017-05-24 11:41:33 -0400575 REPORTER_ASSERT(reporter, 0 == cache->getPurgeableBytes());
bsalomondace19e2014-11-17 07:34:06 -0800576}
577
bsalomon5236cf42015-01-14 10:42:08 -0800578static void test_unbudgeted(skiatest::Reporter* reporter) {
bsalomonc2f35b72015-01-23 07:19:22 -0800579 Mock mock(10, 30000);
580 GrContext* context = mock.context();
bsalomon0ea80f42015-02-11 10:49:59 -0800581 GrResourceCache* cache = mock.cache();
Robert Phillipsf35fd8d2018-01-22 10:48:15 -0500582 GrGpu* gpu = context->contextPriv().getGpu();
bsalomon5236cf42015-01-14 10:42:08 -0800583
bsalomon8718aaf2015-02-19 07:24:21 -0800584 GrUniqueKey uniqueKey;
585 make_unique_key<0>(&uniqueKey, 0);
bsalomon5236cf42015-01-14 10:42:08 -0800586
587 TestResource* scratch;
bsalomon8718aaf2015-02-19 07:24:21 -0800588 TestResource* unique;
bsalomon5236cf42015-01-14 10:42:08 -0800589 TestResource* wrapped;
590 TestResource* unbudgeted;
591
592 // A large uncached or wrapped resource shouldn't evict anything.
Robert Phillipsf35fd8d2018-01-22 10:48:15 -0500593 scratch = TestResource::CreateScratch(gpu, SkBudgeted::kYes,
Greg Danielda86e282018-06-13 09:41:19 -0400594 TestResource::kB_SimulatedProperty, 10);
kkinnunen2e6055b2016-04-22 01:48:29 -0700595
bsalomon5236cf42015-01-14 10:42:08 -0800596 scratch->unref();
bsalomon0ea80f42015-02-11 10:49:59 -0800597 REPORTER_ASSERT(reporter, 1 == cache->getResourceCount());
598 REPORTER_ASSERT(reporter, 10 == cache->getResourceBytes());
599 REPORTER_ASSERT(reporter, 1 == cache->getBudgetedResourceCount());
600 REPORTER_ASSERT(reporter, 10 == cache->getBudgetedResourceBytes());
Derek Sollenbergeree479142017-05-24 11:41:33 -0400601 REPORTER_ASSERT(reporter, 10 == cache->getPurgeableBytes());
bsalomon5236cf42015-01-14 10:42:08 -0800602
Greg Danielda86e282018-06-13 09:41:19 -0400603 unique = new TestResource(gpu, SkBudgeted::kYes, 11);
bsalomonf99e9612015-02-19 08:24:16 -0800604 unique->resourcePriv().setUniqueKey(uniqueKey);
bsalomon8718aaf2015-02-19 07:24:21 -0800605 unique->unref();
bsalomon0ea80f42015-02-11 10:49:59 -0800606 REPORTER_ASSERT(reporter, 2 == cache->getResourceCount());
607 REPORTER_ASSERT(reporter, 21 == cache->getResourceBytes());
608 REPORTER_ASSERT(reporter, 2 == cache->getBudgetedResourceCount());
609 REPORTER_ASSERT(reporter, 21 == cache->getBudgetedResourceBytes());
Derek Sollenbergeree479142017-05-24 11:41:33 -0400610 REPORTER_ASSERT(reporter, 21 == cache->getPurgeableBytes());
bsalomon5236cf42015-01-14 10:42:08 -0800611
bsalomon0ea80f42015-02-11 10:49:59 -0800612 size_t large = 2 * cache->getResourceBytes();
Robert Phillipsf35fd8d2018-01-22 10:48:15 -0500613 unbudgeted = new TestResource(gpu, SkBudgeted::kNo, large);
bsalomon0ea80f42015-02-11 10:49:59 -0800614 REPORTER_ASSERT(reporter, 3 == cache->getResourceCount());
615 REPORTER_ASSERT(reporter, 21 + large == cache->getResourceBytes());
616 REPORTER_ASSERT(reporter, 2 == cache->getBudgetedResourceCount());
617 REPORTER_ASSERT(reporter, 21 == cache->getBudgetedResourceBytes());
Derek Sollenbergeree479142017-05-24 11:41:33 -0400618 REPORTER_ASSERT(reporter, 21 == cache->getPurgeableBytes());
bsalomon5236cf42015-01-14 10:42:08 -0800619
620 unbudgeted->unref();
bsalomon0ea80f42015-02-11 10:49:59 -0800621 REPORTER_ASSERT(reporter, 2 == cache->getResourceCount());
622 REPORTER_ASSERT(reporter, 21 == cache->getResourceBytes());
623 REPORTER_ASSERT(reporter, 2 == cache->getBudgetedResourceCount());
624 REPORTER_ASSERT(reporter, 21 == cache->getBudgetedResourceBytes());
Derek Sollenbergeree479142017-05-24 11:41:33 -0400625 REPORTER_ASSERT(reporter, 21 == cache->getPurgeableBytes());
bsalomon5236cf42015-01-14 10:42:08 -0800626
Robert Phillipsf35fd8d2018-01-22 10:48:15 -0500627 wrapped = TestResource::CreateWrapped(gpu, large);
bsalomon0ea80f42015-02-11 10:49:59 -0800628 REPORTER_ASSERT(reporter, 3 == cache->getResourceCount());
629 REPORTER_ASSERT(reporter, 21 + large == cache->getResourceBytes());
630 REPORTER_ASSERT(reporter, 2 == cache->getBudgetedResourceCount());
631 REPORTER_ASSERT(reporter, 21 == cache->getBudgetedResourceBytes());
Derek Sollenbergeree479142017-05-24 11:41:33 -0400632 REPORTER_ASSERT(reporter, 21 == cache->getPurgeableBytes());
bsalomon5236cf42015-01-14 10:42:08 -0800633
634 wrapped->unref();
bsalomon0ea80f42015-02-11 10:49:59 -0800635 REPORTER_ASSERT(reporter, 2 == cache->getResourceCount());
636 REPORTER_ASSERT(reporter, 21 == cache->getResourceBytes());
637 REPORTER_ASSERT(reporter, 2 == cache->getBudgetedResourceCount());
638 REPORTER_ASSERT(reporter, 21 == cache->getBudgetedResourceBytes());
Derek Sollenbergeree479142017-05-24 11:41:33 -0400639 REPORTER_ASSERT(reporter, 21 == cache->getPurgeableBytes());
bsalomon5236cf42015-01-14 10:42:08 -0800640
bsalomon0ea80f42015-02-11 10:49:59 -0800641 cache->purgeAllUnlocked();
642 REPORTER_ASSERT(reporter, 0 == cache->getResourceCount());
643 REPORTER_ASSERT(reporter, 0 == cache->getResourceBytes());
644 REPORTER_ASSERT(reporter, 0 == cache->getBudgetedResourceCount());
645 REPORTER_ASSERT(reporter, 0 == cache->getBudgetedResourceBytes());
Derek Sollenbergeree479142017-05-24 11:41:33 -0400646 REPORTER_ASSERT(reporter, 0 == cache->getPurgeableBytes());
bsalomon5236cf42015-01-14 10:42:08 -0800647}
648
bsalomon3582d3e2015-02-13 14:20:05 -0800649// This method can't be static because it needs to friended in GrGpuResource::CacheAccess.
650void test_unbudgeted_to_scratch(skiatest::Reporter* reporter);
651/*static*/ void test_unbudgeted_to_scratch(skiatest::Reporter* reporter) {
bsalomonc2f35b72015-01-23 07:19:22 -0800652 Mock mock(10, 300);
653 GrContext* context = mock.context();
bsalomon0ea80f42015-02-11 10:49:59 -0800654 GrResourceCache* cache = mock.cache();
Robert Phillipsf35fd8d2018-01-22 10:48:15 -0500655 GrGpu* gpu = context->contextPriv().getGpu();
bsalomonc2f35b72015-01-23 07:19:22 -0800656
657 TestResource* resource =
Robert Phillipsf35fd8d2018-01-22 10:48:15 -0500658 TestResource::CreateScratch(gpu, SkBudgeted::kNo, TestResource::kA_SimulatedProperty);
bsalomonc2f35b72015-01-23 07:19:22 -0800659 GrScratchKey key;
bsalomon23e619c2015-02-06 11:54:28 -0800660 TestResource::ComputeScratchKey(TestResource::kA_SimulatedProperty, &key);
bsalomonc2f35b72015-01-23 07:19:22 -0800661
662 size_t size = resource->gpuMemorySize();
663 for (int i = 0; i < 2; ++i) {
664 // Since this resource is unbudgeted, it should not be reachable as scratch.
bsalomon3582d3e2015-02-13 14:20:05 -0800665 REPORTER_ASSERT(reporter, resource->resourcePriv().getScratchKey() == key);
bsalomonc2f35b72015-01-23 07:19:22 -0800666 REPORTER_ASSERT(reporter, !resource->cacheAccess().isScratch());
bsalomon5ec26ae2016-02-25 08:33:02 -0800667 REPORTER_ASSERT(reporter, SkBudgeted::kNo == resource->resourcePriv().isBudgeted());
halcanary96fcdcc2015-08-27 07:41:13 -0700668 REPORTER_ASSERT(reporter, nullptr == cache->findAndRefScratchResource(key, TestResource::kDefaultSize, 0));
bsalomon0ea80f42015-02-11 10:49:59 -0800669 REPORTER_ASSERT(reporter, 1 == cache->getResourceCount());
670 REPORTER_ASSERT(reporter, size == cache->getResourceBytes());
671 REPORTER_ASSERT(reporter, 0 == cache->getBudgetedResourceCount());
672 REPORTER_ASSERT(reporter, 0 == cache->getBudgetedResourceBytes());
Derek Sollenbergeree479142017-05-24 11:41:33 -0400673 REPORTER_ASSERT(reporter, 0 == cache->getPurgeableBytes());
bsalomonc2f35b72015-01-23 07:19:22 -0800674
675 // Once it is unrefed, it should become available as scratch.
676 resource->unref();
bsalomon0ea80f42015-02-11 10:49:59 -0800677 REPORTER_ASSERT(reporter, 1 == cache->getResourceCount());
678 REPORTER_ASSERT(reporter, size == cache->getResourceBytes());
679 REPORTER_ASSERT(reporter, 1 == cache->getBudgetedResourceCount());
680 REPORTER_ASSERT(reporter, size == cache->getBudgetedResourceBytes());
Derek Sollenbergeree479142017-05-24 11:41:33 -0400681 REPORTER_ASSERT(reporter, size == cache->getPurgeableBytes());
robertphillips6e83ac72015-08-13 05:19:14 -0700682 resource = static_cast<TestResource*>(cache->findAndRefScratchResource(key, TestResource::kDefaultSize, 0));
bsalomonc2f35b72015-01-23 07:19:22 -0800683 REPORTER_ASSERT(reporter, resource);
bsalomon3582d3e2015-02-13 14:20:05 -0800684 REPORTER_ASSERT(reporter, resource->resourcePriv().getScratchKey() == key);
bsalomonc2f35b72015-01-23 07:19:22 -0800685 REPORTER_ASSERT(reporter, resource->cacheAccess().isScratch());
bsalomon5ec26ae2016-02-25 08:33:02 -0800686 REPORTER_ASSERT(reporter, SkBudgeted::kYes == resource->resourcePriv().isBudgeted());
bsalomonc2f35b72015-01-23 07:19:22 -0800687
688 if (0 == i) {
mtklein5f939ab2016-03-16 10:28:35 -0700689 // If made unbudgeted, it should return to original state: ref'ed and unbudgeted. Try
bsalomonc2f35b72015-01-23 07:19:22 -0800690 // the above tests again.
bsalomon3582d3e2015-02-13 14:20:05 -0800691 resource->resourcePriv().makeUnbudgeted();
bsalomonc2f35b72015-01-23 07:19:22 -0800692 } else {
693 // After the second time around, try removing the scratch key
bsalomon3582d3e2015-02-13 14:20:05 -0800694 resource->resourcePriv().removeScratchKey();
bsalomon0ea80f42015-02-11 10:49:59 -0800695 REPORTER_ASSERT(reporter, 1 == cache->getResourceCount());
696 REPORTER_ASSERT(reporter, size == cache->getResourceBytes());
697 REPORTER_ASSERT(reporter, 1 == cache->getBudgetedResourceCount());
698 REPORTER_ASSERT(reporter, size == cache->getBudgetedResourceBytes());
Derek Sollenbergeree479142017-05-24 11:41:33 -0400699 REPORTER_ASSERT(reporter, 0 == cache->getPurgeableBytes());
bsalomon3582d3e2015-02-13 14:20:05 -0800700 REPORTER_ASSERT(reporter, !resource->resourcePriv().getScratchKey().isValid());
bsalomonc2f35b72015-01-23 07:19:22 -0800701 REPORTER_ASSERT(reporter, !resource->cacheAccess().isScratch());
bsalomon5ec26ae2016-02-25 08:33:02 -0800702 REPORTER_ASSERT(reporter, SkBudgeted::kYes == resource->resourcePriv().isBudgeted());
bsalomonc2f35b72015-01-23 07:19:22 -0800703
704 // now when it is unrefed it should die since it has no key.
705 resource->unref();
bsalomon0ea80f42015-02-11 10:49:59 -0800706 REPORTER_ASSERT(reporter, 0 == cache->getResourceCount());
707 REPORTER_ASSERT(reporter, 0 == cache->getResourceBytes());
708 REPORTER_ASSERT(reporter, 0 == cache->getBudgetedResourceCount());
709 REPORTER_ASSERT(reporter, 0 == cache->getBudgetedResourceBytes());
Derek Sollenbergeree479142017-05-24 11:41:33 -0400710 REPORTER_ASSERT(reporter, 0 == cache->getPurgeableBytes());
bsalomonc2f35b72015-01-23 07:19:22 -0800711 }
bsalomon8b79d232014-11-10 10:19:06 -0800712 }
bsalomonc2f35b72015-01-23 07:19:22 -0800713}
714
715static void test_duplicate_scratch_key(skiatest::Reporter* reporter) {
716 Mock mock(5, 30000);
717 GrContext* context = mock.context();
bsalomon0ea80f42015-02-11 10:49:59 -0800718 GrResourceCache* cache = mock.cache();
Robert Phillipsf35fd8d2018-01-22 10:48:15 -0500719 GrGpu* gpu = context->contextPriv().getGpu();
bsalomon8b79d232014-11-10 10:19:06 -0800720
bsalomon8b79d232014-11-10 10:19:06 -0800721 // Create two resources that have the same scratch key.
Robert Phillipsf35fd8d2018-01-22 10:48:15 -0500722 TestResource* a = TestResource::CreateScratch(gpu,
kkinnunen2e6055b2016-04-22 01:48:29 -0700723 SkBudgeted::kYes,
Greg Danielda86e282018-06-13 09:41:19 -0400724 TestResource::kB_SimulatedProperty, 11);
Robert Phillipsf35fd8d2018-01-22 10:48:15 -0500725 TestResource* b = TestResource::CreateScratch(gpu,
kkinnunen2e6055b2016-04-22 01:48:29 -0700726 SkBudgeted::kYes,
Greg Danielda86e282018-06-13 09:41:19 -0400727 TestResource::kB_SimulatedProperty, 12);
bsalomon1c60dfe2015-01-21 09:32:40 -0800728 GrScratchKey scratchKey1;
bsalomon23e619c2015-02-06 11:54:28 -0800729 TestResource::ComputeScratchKey(TestResource::kA_SimulatedProperty, &scratchKey1);
bsalomon1c60dfe2015-01-21 09:32:40 -0800730 // Check for negative case consistency. (leaks upon test failure.)
halcanary96fcdcc2015-08-27 07:41:13 -0700731 REPORTER_ASSERT(reporter, nullptr == cache->findAndRefScratchResource(scratchKey1, TestResource::kDefaultSize, 0));
bsalomon1c60dfe2015-01-21 09:32:40 -0800732
733 GrScratchKey scratchKey;
bsalomon23e619c2015-02-06 11:54:28 -0800734 TestResource::ComputeScratchKey(TestResource::kB_SimulatedProperty, &scratchKey);
bsalomon1c60dfe2015-01-21 09:32:40 -0800735
bsalomon0ea80f42015-02-11 10:49:59 -0800736 // Scratch resources are registered with GrResourceCache just by existing. There are 2.
bsalomon8b79d232014-11-10 10:19:06 -0800737 REPORTER_ASSERT(reporter, 2 == TestResource::NumAlive());
bsalomon0ea80f42015-02-11 10:49:59 -0800738 SkDEBUGCODE(REPORTER_ASSERT(reporter, 2 == cache->countScratchEntriesForKey(scratchKey));)
739 REPORTER_ASSERT(reporter, 2 == cache->getResourceCount());
bsalomon71cb0c22014-11-14 12:10:14 -0800740 REPORTER_ASSERT(reporter, a->gpuMemorySize() + b->gpuMemorySize() ==
bsalomon0ea80f42015-02-11 10:49:59 -0800741 cache->getResourceBytes());
bsalomon8b79d232014-11-10 10:19:06 -0800742
bsalomon63c992f2015-01-23 12:47:59 -0800743 // Our refs mean that the resources are non purgeable.
bsalomon0ea80f42015-02-11 10:49:59 -0800744 cache->purgeAllUnlocked();
bsalomon8b79d232014-11-10 10:19:06 -0800745 REPORTER_ASSERT(reporter, 2 == TestResource::NumAlive());
bsalomon0ea80f42015-02-11 10:49:59 -0800746 REPORTER_ASSERT(reporter, 2 == cache->getResourceCount());
bsalomon8b79d232014-11-10 10:19:06 -0800747
748 // Unref but don't purge
749 a->unref();
750 b->unref();
751 REPORTER_ASSERT(reporter, 2 == TestResource::NumAlive());
bsalomon0ea80f42015-02-11 10:49:59 -0800752 SkDEBUGCODE(REPORTER_ASSERT(reporter, 2 == cache->countScratchEntriesForKey(scratchKey));)
bsalomon8b79d232014-11-10 10:19:06 -0800753
bsalomon63c992f2015-01-23 12:47:59 -0800754 // Purge again. This time resources should be purgeable.
bsalomon0ea80f42015-02-11 10:49:59 -0800755 cache->purgeAllUnlocked();
bsalomon8b79d232014-11-10 10:19:06 -0800756 REPORTER_ASSERT(reporter, 0 == TestResource::NumAlive());
bsalomon0ea80f42015-02-11 10:49:59 -0800757 REPORTER_ASSERT(reporter, 0 == cache->getResourceCount());
758 SkDEBUGCODE(REPORTER_ASSERT(reporter, 0 == cache->countScratchEntriesForKey(scratchKey));)
bsalomon8b79d232014-11-10 10:19:06 -0800759}
760
bsalomon10e23ca2014-11-25 05:52:06 -0800761static void test_remove_scratch_key(skiatest::Reporter* reporter) {
bsalomonc2f35b72015-01-23 07:19:22 -0800762 Mock mock(5, 30000);
763 GrContext* context = mock.context();
bsalomon0ea80f42015-02-11 10:49:59 -0800764 GrResourceCache* cache = mock.cache();
Robert Phillipsf35fd8d2018-01-22 10:48:15 -0500765 GrGpu* gpu = context->contextPriv().getGpu();
bsalomon10e23ca2014-11-25 05:52:06 -0800766
bsalomon10e23ca2014-11-25 05:52:06 -0800767 // Create two resources that have the same scratch key.
Robert Phillipsf35fd8d2018-01-22 10:48:15 -0500768 TestResource* a = TestResource::CreateScratch(gpu, SkBudgeted::kYes,
bsalomon23e619c2015-02-06 11:54:28 -0800769 TestResource::kB_SimulatedProperty);
Robert Phillipsf35fd8d2018-01-22 10:48:15 -0500770 TestResource* b = TestResource::CreateScratch(gpu, SkBudgeted::kYes,
bsalomon23e619c2015-02-06 11:54:28 -0800771 TestResource::kB_SimulatedProperty);
bsalomon10e23ca2014-11-25 05:52:06 -0800772 a->unref();
773 b->unref();
774
bsalomon1c60dfe2015-01-21 09:32:40 -0800775 GrScratchKey scratchKey;
776 // Ensure that scratch key lookup is correct for negative case.
bsalomon23e619c2015-02-06 11:54:28 -0800777 TestResource::ComputeScratchKey(TestResource::kA_SimulatedProperty, &scratchKey);
bsalomon1c60dfe2015-01-21 09:32:40 -0800778 // (following leaks upon test failure).
halcanary96fcdcc2015-08-27 07:41:13 -0700779 REPORTER_ASSERT(reporter, cache->findAndRefScratchResource(scratchKey, TestResource::kDefaultSize, 0) == nullptr);
bsalomon1c60dfe2015-01-21 09:32:40 -0800780
bsalomon0ea80f42015-02-11 10:49:59 -0800781 // Scratch resources are registered with GrResourceCache just by existing. There are 2.
bsalomon23e619c2015-02-06 11:54:28 -0800782 TestResource::ComputeScratchKey(TestResource::kB_SimulatedProperty, &scratchKey);
bsalomon10e23ca2014-11-25 05:52:06 -0800783 REPORTER_ASSERT(reporter, 2 == TestResource::NumAlive());
bsalomon0ea80f42015-02-11 10:49:59 -0800784 SkDEBUGCODE(REPORTER_ASSERT(reporter, 2 == cache->countScratchEntriesForKey(scratchKey));)
785 REPORTER_ASSERT(reporter, 2 == cache->getResourceCount());
bsalomon10e23ca2014-11-25 05:52:06 -0800786
787 // Find the first resource and remove its scratch key
788 GrGpuResource* find;
robertphillips6e83ac72015-08-13 05:19:14 -0700789 find = cache->findAndRefScratchResource(scratchKey, TestResource::kDefaultSize, 0);
bsalomon3582d3e2015-02-13 14:20:05 -0800790 find->resourcePriv().removeScratchKey();
bsalomon10e23ca2014-11-25 05:52:06 -0800791 // It's still alive, but not cached by scratch key anymore
792 REPORTER_ASSERT(reporter, 2 == TestResource::NumAlive());
bsalomon0ea80f42015-02-11 10:49:59 -0800793 SkDEBUGCODE(REPORTER_ASSERT(reporter, 1 == cache->countScratchEntriesForKey(scratchKey));)
794 REPORTER_ASSERT(reporter, 2 == cache->getResourceCount());
bsalomon10e23ca2014-11-25 05:52:06 -0800795
796 // The cache should immediately delete it when it's unrefed since it isn't accessible.
797 find->unref();
798 REPORTER_ASSERT(reporter, 1 == TestResource::NumAlive());
bsalomon0ea80f42015-02-11 10:49:59 -0800799 SkDEBUGCODE(REPORTER_ASSERT(reporter, 1 == cache->countScratchEntriesForKey(scratchKey));)
800 REPORTER_ASSERT(reporter, 1 == cache->getResourceCount());
bsalomon10e23ca2014-11-25 05:52:06 -0800801
802 // Repeat for the second resource.
robertphillips6e83ac72015-08-13 05:19:14 -0700803 find = cache->findAndRefScratchResource(scratchKey, TestResource::kDefaultSize, 0);
bsalomon3582d3e2015-02-13 14:20:05 -0800804 find->resourcePriv().removeScratchKey();
bsalomon10e23ca2014-11-25 05:52:06 -0800805 REPORTER_ASSERT(reporter, 1 == TestResource::NumAlive());
bsalomon0ea80f42015-02-11 10:49:59 -0800806 SkDEBUGCODE(REPORTER_ASSERT(reporter, 0 == cache->countScratchEntriesForKey(scratchKey));)
807 REPORTER_ASSERT(reporter, 1 == cache->getResourceCount());
bsalomon10e23ca2014-11-25 05:52:06 -0800808
809 // Should be able to call this multiple times with no problem.
bsalomon3582d3e2015-02-13 14:20:05 -0800810 find->resourcePriv().removeScratchKey();
bsalomon10e23ca2014-11-25 05:52:06 -0800811 REPORTER_ASSERT(reporter, 1 == TestResource::NumAlive());
bsalomon0ea80f42015-02-11 10:49:59 -0800812 SkDEBUGCODE(REPORTER_ASSERT(reporter, 0 == cache->countScratchEntriesForKey(scratchKey));)
813 REPORTER_ASSERT(reporter, 1 == cache->getResourceCount());
bsalomon10e23ca2014-11-25 05:52:06 -0800814
815 find->unref();
816 REPORTER_ASSERT(reporter, 0 == TestResource::NumAlive());
bsalomon0ea80f42015-02-11 10:49:59 -0800817 SkDEBUGCODE(REPORTER_ASSERT(reporter, 0 == cache->countScratchEntriesForKey(scratchKey));)
818 REPORTER_ASSERT(reporter, 0 == cache->getResourceCount());
bsalomon10e23ca2014-11-25 05:52:06 -0800819}
820
bsalomon1c60dfe2015-01-21 09:32:40 -0800821static void test_scratch_key_consistency(skiatest::Reporter* reporter) {
bsalomonc2f35b72015-01-23 07:19:22 -0800822 Mock mock(5, 30000);
823 GrContext* context = mock.context();
bsalomon0ea80f42015-02-11 10:49:59 -0800824 GrResourceCache* cache = mock.cache();
Robert Phillipsf35fd8d2018-01-22 10:48:15 -0500825 GrGpu* gpu = context->contextPriv().getGpu();
bsalomon1c60dfe2015-01-21 09:32:40 -0800826
827 // Create two resources that have the same scratch key.
Robert Phillipsf35fd8d2018-01-22 10:48:15 -0500828 TestResource* a = TestResource::CreateScratch(gpu, SkBudgeted::kYes,
bsalomon23e619c2015-02-06 11:54:28 -0800829 TestResource::kB_SimulatedProperty);
Robert Phillipsf35fd8d2018-01-22 10:48:15 -0500830 TestResource* b = TestResource::CreateScratch(gpu, SkBudgeted::kYes,
bsalomon23e619c2015-02-06 11:54:28 -0800831 TestResource::kB_SimulatedProperty);
bsalomon1c60dfe2015-01-21 09:32:40 -0800832 a->unref();
833 b->unref();
834
835 GrScratchKey scratchKey;
836 // Ensure that scratch key comparison and assignment is consistent.
837 GrScratchKey scratchKey1;
bsalomon23e619c2015-02-06 11:54:28 -0800838 TestResource::ComputeScratchKey(TestResource::kA_SimulatedProperty, &scratchKey1);
bsalomon1c60dfe2015-01-21 09:32:40 -0800839 GrScratchKey scratchKey2;
bsalomon23e619c2015-02-06 11:54:28 -0800840 TestResource::ComputeScratchKey(TestResource::kB_SimulatedProperty, &scratchKey2);
bsalomon1c60dfe2015-01-21 09:32:40 -0800841 REPORTER_ASSERT(reporter, scratchKey1.size() == TestResource::ExpectedScratchKeySize());
842 REPORTER_ASSERT(reporter, scratchKey1 != scratchKey2);
843 REPORTER_ASSERT(reporter, scratchKey2 != scratchKey1);
844 scratchKey = scratchKey1;
845 REPORTER_ASSERT(reporter, scratchKey.size() == TestResource::ExpectedScratchKeySize());
846 REPORTER_ASSERT(reporter, scratchKey1 == scratchKey);
847 REPORTER_ASSERT(reporter, scratchKey == scratchKey1);
848 REPORTER_ASSERT(reporter, scratchKey2 != scratchKey);
849 REPORTER_ASSERT(reporter, scratchKey != scratchKey2);
850 scratchKey = scratchKey2;
851 REPORTER_ASSERT(reporter, scratchKey.size() == TestResource::ExpectedScratchKeySize());
852 REPORTER_ASSERT(reporter, scratchKey1 != scratchKey);
853 REPORTER_ASSERT(reporter, scratchKey != scratchKey1);
854 REPORTER_ASSERT(reporter, scratchKey2 == scratchKey);
855 REPORTER_ASSERT(reporter, scratchKey == scratchKey2);
856
857 // Ensure that scratch key lookup is correct for negative case.
bsalomon23e619c2015-02-06 11:54:28 -0800858 TestResource::ComputeScratchKey(TestResource::kA_SimulatedProperty, &scratchKey);
bsalomon1c60dfe2015-01-21 09:32:40 -0800859 // (following leaks upon test failure).
halcanary96fcdcc2015-08-27 07:41:13 -0700860 REPORTER_ASSERT(reporter, cache->findAndRefScratchResource(scratchKey, TestResource::kDefaultSize, 0) == nullptr);
bsalomon1c60dfe2015-01-21 09:32:40 -0800861
862 // Find the first resource with a scratch key and a copy of a scratch key.
bsalomon23e619c2015-02-06 11:54:28 -0800863 TestResource::ComputeScratchKey(TestResource::kB_SimulatedProperty, &scratchKey);
robertphillips6e83ac72015-08-13 05:19:14 -0700864 GrGpuResource* find = cache->findAndRefScratchResource(scratchKey, TestResource::kDefaultSize, 0);
halcanary96fcdcc2015-08-27 07:41:13 -0700865 REPORTER_ASSERT(reporter, find != nullptr);
bsalomon1c60dfe2015-01-21 09:32:40 -0800866 find->unref();
867
868 scratchKey2 = scratchKey;
robertphillips6e83ac72015-08-13 05:19:14 -0700869 find = cache->findAndRefScratchResource(scratchKey2, TestResource::kDefaultSize, 0);
halcanary96fcdcc2015-08-27 07:41:13 -0700870 REPORTER_ASSERT(reporter, find != nullptr);
bsalomon1c60dfe2015-01-21 09:32:40 -0800871 REPORTER_ASSERT(reporter, find == a || find == b);
872
robertphillips6e83ac72015-08-13 05:19:14 -0700873 GrGpuResource* find2 = cache->findAndRefScratchResource(scratchKey2, TestResource::kDefaultSize, 0);
halcanary96fcdcc2015-08-27 07:41:13 -0700874 REPORTER_ASSERT(reporter, find2 != nullptr);
bsalomon1c60dfe2015-01-21 09:32:40 -0800875 REPORTER_ASSERT(reporter, find2 == a || find2 == b);
876 REPORTER_ASSERT(reporter, find2 != find);
877 find2->unref();
878 find->unref();
879}
880
bsalomon8718aaf2015-02-19 07:24:21 -0800881static void test_duplicate_unique_key(skiatest::Reporter* reporter) {
bsalomonc2f35b72015-01-23 07:19:22 -0800882 Mock mock(5, 30000);
883 GrContext* context = mock.context();
bsalomon0ea80f42015-02-11 10:49:59 -0800884 GrResourceCache* cache = mock.cache();
Robert Phillipsf35fd8d2018-01-22 10:48:15 -0500885 GrGpu* gpu = context->contextPriv().getGpu();
commit-bot@chromium.orgc6658042014-01-15 23:09:01 +0000886
bsalomon8718aaf2015-02-19 07:24:21 -0800887 GrUniqueKey key;
888 make_unique_key<0>(&key, 0);
mtklein5f939ab2016-03-16 10:28:35 -0700889
bsalomon8718aaf2015-02-19 07:24:21 -0800890 // Create two resources that we will attempt to register with the same unique key.
Greg Danielda86e282018-06-13 09:41:19 -0400891 TestResource* a = new TestResource(gpu, SkBudgeted::kYes, 11);
mtklein5f939ab2016-03-16 10:28:35 -0700892
bsalomonf99e9612015-02-19 08:24:16 -0800893 // Set key on resource a.
894 a->resourcePriv().setUniqueKey(key);
895 REPORTER_ASSERT(reporter, a == cache->findAndRefUniqueResource(key));
896 a->unref();
bsalomon71cb0c22014-11-14 12:10:14 -0800897
bsalomonf99e9612015-02-19 08:24:16 -0800898 // Make sure that redundantly setting a's key works.
899 a->resourcePriv().setUniqueKey(key);
900 REPORTER_ASSERT(reporter, a == cache->findAndRefUniqueResource(key));
bsalomon8b79d232014-11-10 10:19:06 -0800901 a->unref();
bsalomon0ea80f42015-02-11 10:49:59 -0800902 REPORTER_ASSERT(reporter, 1 == cache->getResourceCount());
903 REPORTER_ASSERT(reporter, a->gpuMemorySize() == cache->getResourceBytes());
bsalomon71cb0c22014-11-14 12:10:14 -0800904 REPORTER_ASSERT(reporter, 1 == TestResource::NumAlive());
905
bsalomonf99e9612015-02-19 08:24:16 -0800906 // Create resource b and set the same key. It should replace a's unique key cache entry.
Greg Danielda86e282018-06-13 09:41:19 -0400907 TestResource* b = new TestResource(gpu, SkBudgeted::kYes, 12);
bsalomonf99e9612015-02-19 08:24:16 -0800908 b->resourcePriv().setUniqueKey(key);
909 REPORTER_ASSERT(reporter, b == cache->findAndRefUniqueResource(key));
910 b->unref();
911
912 // Still have two resources because a is still reffed.
913 REPORTER_ASSERT(reporter, 2 == cache->getResourceCount());
914 REPORTER_ASSERT(reporter, a->gpuMemorySize() + b->gpuMemorySize() == cache->getResourceBytes());
915 REPORTER_ASSERT(reporter, 2 == TestResource::NumAlive());
916
917 a->unref();
918 // Now a should be gone.
919 REPORTER_ASSERT(reporter, 1 == cache->getResourceCount());
920 REPORTER_ASSERT(reporter, b->gpuMemorySize() == cache->getResourceBytes());
921 REPORTER_ASSERT(reporter, 1 == TestResource::NumAlive());
922
923 // Now replace b with c, but make sure c can start with one unique key and change it to b's key.
924 // Also make b be unreffed when replacement occurs.
925 b->unref();
Greg Danielda86e282018-06-13 09:41:19 -0400926 TestResource* c = new TestResource(gpu, SkBudgeted::kYes, 13);
bsalomonf99e9612015-02-19 08:24:16 -0800927 GrUniqueKey differentKey;
928 make_unique_key<0>(&differentKey, 1);
bsalomonf99e9612015-02-19 08:24:16 -0800929 c->resourcePriv().setUniqueKey(differentKey);
930 REPORTER_ASSERT(reporter, 2 == cache->getResourceCount());
931 REPORTER_ASSERT(reporter, b->gpuMemorySize() + c->gpuMemorySize() == cache->getResourceBytes());
932 REPORTER_ASSERT(reporter, 2 == TestResource::NumAlive());
933 // c replaces b and b should be immediately purged.
934 c->resourcePriv().setUniqueKey(key);
935 REPORTER_ASSERT(reporter, 1 == cache->getResourceCount());
936 REPORTER_ASSERT(reporter, c->gpuMemorySize() == cache->getResourceBytes());
937 REPORTER_ASSERT(reporter, 1 == TestResource::NumAlive());
938
939 // c shouldn't be purged because it is ref'ed.
bsalomon0ea80f42015-02-11 10:49:59 -0800940 cache->purgeAllUnlocked();
bsalomonf99e9612015-02-19 08:24:16 -0800941 REPORTER_ASSERT(reporter, 1 == cache->getResourceCount());
942 REPORTER_ASSERT(reporter, c->gpuMemorySize() == cache->getResourceBytes());
943 REPORTER_ASSERT(reporter, 1 == TestResource::NumAlive());
944
945 // Drop the ref on c, it should be kept alive because it has a unique key.
946 c->unref();
947 REPORTER_ASSERT(reporter, 1 == cache->getResourceCount());
948 REPORTER_ASSERT(reporter, c->gpuMemorySize() == cache->getResourceBytes());
949 REPORTER_ASSERT(reporter, 1 == TestResource::NumAlive());
950
951 // Verify that we can find c, then remove its unique key. It should get purged immediately.
952 REPORTER_ASSERT(reporter, c == cache->findAndRefUniqueResource(key));
953 c->resourcePriv().removeUniqueKey();
954 c->unref();
bsalomon0ea80f42015-02-11 10:49:59 -0800955 REPORTER_ASSERT(reporter, 0 == cache->getResourceCount());
956 REPORTER_ASSERT(reporter, 0 == cache->getResourceBytes());
bsalomon33435572014-11-05 14:47:41 -0800957 REPORTER_ASSERT(reporter, 0 == TestResource::NumAlive());
senorblanco84cd6212015-08-04 10:01:58 -0700958
959 {
960 GrUniqueKey key2;
961 make_unique_key<0>(&key2, 0);
Robert Phillipsf35fd8d2018-01-22 10:48:15 -0500962 sk_sp<TestResource> d(new TestResource(gpu));
senorblanco84cd6212015-08-04 10:01:58 -0700963 int foo = 4132;
bungeman38d909e2016-08-02 14:40:46 -0700964 key2.setCustomData(SkData::MakeWithCopy(&foo, sizeof(foo)));
senorblanco84cd6212015-08-04 10:01:58 -0700965 d->resourcePriv().setUniqueKey(key2);
966 }
967
968 GrUniqueKey key3;
969 make_unique_key<0>(&key3, 0);
Hal Canary342b7ac2016-11-04 11:49:42 -0400970 sk_sp<GrGpuResource> d2(cache->findAndRefUniqueResource(key3));
senorblanco84cd6212015-08-04 10:01:58 -0700971 REPORTER_ASSERT(reporter, *(int*) d2->getUniqueKey().getCustomData()->data() == 4132);
commit-bot@chromium.orgc6658042014-01-15 23:09:01 +0000972}
973
bsalomon8b79d232014-11-10 10:19:06 -0800974static void test_purge_invalidated(skiatest::Reporter* reporter) {
bsalomonc2f35b72015-01-23 07:19:22 -0800975 Mock mock(5, 30000);
976 GrContext* context = mock.context();
bsalomon0ea80f42015-02-11 10:49:59 -0800977 GrResourceCache* cache = mock.cache();
Robert Phillipsf35fd8d2018-01-22 10:48:15 -0500978 GrGpu* gpu = context->contextPriv().getGpu();
bsalomon8b79d232014-11-10 10:19:06 -0800979
bsalomon8718aaf2015-02-19 07:24:21 -0800980 GrUniqueKey key1, key2, key3;
981 make_unique_key<0>(&key1, 1);
982 make_unique_key<0>(&key2, 2);
983 make_unique_key<0>(&key3, 3);
mtklein5f939ab2016-03-16 10:28:35 -0700984
bsalomon23e619c2015-02-06 11:54:28 -0800985 // Add three resources to the cache. Only c is usable as scratch.
Robert Phillipsf35fd8d2018-01-22 10:48:15 -0500986 TestResource* a = new TestResource(gpu);
987 TestResource* b = new TestResource(gpu);
988 TestResource* c = TestResource::CreateScratch(gpu, SkBudgeted::kYes,
bsalomon23e619c2015-02-06 11:54:28 -0800989 TestResource::kA_SimulatedProperty);
bsalomon8718aaf2015-02-19 07:24:21 -0800990 a->resourcePriv().setUniqueKey(key1);
991 b->resourcePriv().setUniqueKey(key2);
992 c->resourcePriv().setUniqueKey(key3);
bsalomon8b79d232014-11-10 10:19:06 -0800993 a->unref();
bsalomon23e619c2015-02-06 11:54:28 -0800994 // hold b until *after* the message is sent.
bsalomon8b79d232014-11-10 10:19:06 -0800995 c->unref();
996
bsalomon8718aaf2015-02-19 07:24:21 -0800997 REPORTER_ASSERT(reporter, cache->hasUniqueKey(key1));
998 REPORTER_ASSERT(reporter, cache->hasUniqueKey(key2));
999 REPORTER_ASSERT(reporter, cache->hasUniqueKey(key3));
bsalomon8b79d232014-11-10 10:19:06 -08001000 REPORTER_ASSERT(reporter, 3 == TestResource::NumAlive());
bsalomon23e619c2015-02-06 11:54:28 -08001001
bsalomon8718aaf2015-02-19 07:24:21 -08001002 typedef GrUniqueKeyInvalidatedMessage Msg;
1003 typedef SkMessageBus<GrUniqueKeyInvalidatedMessage> Bus;
bsalomon23e619c2015-02-06 11:54:28 -08001004
1005 // Invalidate two of the three, they should be purged and no longer accessible via their keys.
Brian Salomon238069b2018-07-11 15:58:57 -04001006 Bus::Post(Msg(key1, context->uniqueID()));
1007 Bus::Post(Msg(key2, context->uniqueID()));
bsalomon0ea80f42015-02-11 10:49:59 -08001008 cache->purgeAsNeeded();
bsalomon23e619c2015-02-06 11:54:28 -08001009 // a should be deleted now, but we still have a ref on b.
bsalomon8718aaf2015-02-19 07:24:21 -08001010 REPORTER_ASSERT(reporter, !cache->hasUniqueKey(key1));
1011 REPORTER_ASSERT(reporter, !cache->hasUniqueKey(key2));
bsalomon23e619c2015-02-06 11:54:28 -08001012 REPORTER_ASSERT(reporter, 2 == TestResource::NumAlive());
bsalomon8718aaf2015-02-19 07:24:21 -08001013 REPORTER_ASSERT(reporter, cache->hasUniqueKey(key3));
bsalomon8b79d232014-11-10 10:19:06 -08001014
1015 // Invalidate the third.
Brian Salomon238069b2018-07-11 15:58:57 -04001016 Bus::Post(Msg(key3, context->uniqueID()));
bsalomon0ea80f42015-02-11 10:49:59 -08001017 cache->purgeAsNeeded();
bsalomon23e619c2015-02-06 11:54:28 -08001018 // we still have a ref on b, c should be recycled as scratch.
1019 REPORTER_ASSERT(reporter, 2 == TestResource::NumAlive());
bsalomon8718aaf2015-02-19 07:24:21 -08001020 REPORTER_ASSERT(reporter, !cache->hasUniqueKey(key3));
bsalomon71cb0c22014-11-14 12:10:14 -08001021
bsalomon23e619c2015-02-06 11:54:28 -08001022 // make b purgeable. It should be immediately deleted since it has no key.
1023 b->unref();
1024 REPORTER_ASSERT(reporter, 1 == TestResource::NumAlive());
1025
1026 // Make sure we actually get to c via it's scratch key, before we say goodbye.
1027 GrScratchKey scratchKey;
1028 TestResource::ComputeScratchKey(TestResource::kA_SimulatedProperty, &scratchKey);
robertphillips6e83ac72015-08-13 05:19:14 -07001029 GrGpuResource* scratch = cache->findAndRefScratchResource(scratchKey, TestResource::kDefaultSize, 0);
bsalomon23e619c2015-02-06 11:54:28 -08001030 REPORTER_ASSERT(reporter, scratch == c);
1031 SkSafeUnref(scratch);
1032
1033 // Get rid of c.
bsalomon0ea80f42015-02-11 10:49:59 -08001034 cache->purgeAllUnlocked();
robertphillips6e83ac72015-08-13 05:19:14 -07001035 scratch = cache->findAndRefScratchResource(scratchKey, TestResource::kDefaultSize, 0);
bsalomon71cb0c22014-11-14 12:10:14 -08001036 REPORTER_ASSERT(reporter, 0 == TestResource::NumAlive());
bsalomon0ea80f42015-02-11 10:49:59 -08001037 REPORTER_ASSERT(reporter, 0 == cache->getResourceCount());
1038 REPORTER_ASSERT(reporter, 0 == cache->getResourceBytes());
bsalomon23e619c2015-02-06 11:54:28 -08001039 REPORTER_ASSERT(reporter, !scratch);
1040 SkSafeUnref(scratch);
bsalomon8b79d232014-11-10 10:19:06 -08001041}
1042
bsalomon71cb0c22014-11-14 12:10:14 -08001043static void test_cache_chained_purge(skiatest::Reporter* reporter) {
bsalomonc2f35b72015-01-23 07:19:22 -08001044 Mock mock(3, 30000);
1045 GrContext* context = mock.context();
bsalomon0ea80f42015-02-11 10:49:59 -08001046 GrResourceCache* cache = mock.cache();
Robert Phillipsf35fd8d2018-01-22 10:48:15 -05001047 GrGpu* gpu = context->contextPriv().getGpu();
bsalomon8b79d232014-11-10 10:19:06 -08001048
bsalomon8718aaf2015-02-19 07:24:21 -08001049 GrUniqueKey key1, key2;
1050 make_unique_key<0>(&key1, 1);
1051 make_unique_key<0>(&key2, 2);
commit-bot@chromium.orgbd58feb2014-01-17 17:56:21 +00001052
Ben Wagner97c6a0e2018-07-11 14:56:22 -04001053 sk_sp<TestResource> a(new TestResource(gpu));
1054 sk_sp<TestResource> b(new TestResource(gpu));
bsalomon8718aaf2015-02-19 07:24:21 -08001055 a->resourcePriv().setUniqueKey(key1);
1056 b->resourcePriv().setUniqueKey(key2);
bsalomon820dd6c2014-11-05 12:09:45 -08001057
bsalomonc2f35b72015-01-23 07:19:22 -08001058 // Make a cycle
1059 a->setUnrefWhenDestroyed(b);
1060 b->setUnrefWhenDestroyed(a);
bsalomon71cb0c22014-11-14 12:10:14 -08001061
bsalomonc2f35b72015-01-23 07:19:22 -08001062 REPORTER_ASSERT(reporter, 2 == TestResource::NumAlive());
bsalomon33435572014-11-05 14:47:41 -08001063
Ben Wagner97c6a0e2018-07-11 14:56:22 -04001064 TestResource* unownedA = a.release();
1065 unownedA->unref();
1066 b.reset();
bsalomon8b79d232014-11-10 10:19:06 -08001067
bsalomonc2f35b72015-01-23 07:19:22 -08001068 REPORTER_ASSERT(reporter, 2 == TestResource::NumAlive());
bsalomon8b79d232014-11-10 10:19:06 -08001069
bsalomon0ea80f42015-02-11 10:49:59 -08001070 cache->purgeAllUnlocked();
bsalomonc2f35b72015-01-23 07:19:22 -08001071 REPORTER_ASSERT(reporter, 2 == TestResource::NumAlive());
bsalomon8b79d232014-11-10 10:19:06 -08001072
bsalomonc2f35b72015-01-23 07:19:22 -08001073 // Break the cycle
Ben Wagner97c6a0e2018-07-11 14:56:22 -04001074 unownedA->setUnrefWhenDestroyed(nullptr);
bsalomonc2f35b72015-01-23 07:19:22 -08001075 REPORTER_ASSERT(reporter, 2 == TestResource::NumAlive());
bsalomon33435572014-11-05 14:47:41 -08001076
bsalomon0ea80f42015-02-11 10:49:59 -08001077 cache->purgeAllUnlocked();
bsalomonc2f35b72015-01-23 07:19:22 -08001078 REPORTER_ASSERT(reporter, 0 == TestResource::NumAlive());
commit-bot@chromium.orgbd58feb2014-01-17 17:56:21 +00001079}
1080
bsalomonddf30e62015-02-19 11:38:44 -08001081static void test_timestamp_wrap(skiatest::Reporter* reporter) {
1082 static const int kCount = 50;
1083 static const int kBudgetCnt = kCount / 2;
1084 static const int kLockedFreq = 8;
1085 static const int kBudgetSize = 0x80000000;
1086
1087 SkRandom random;
1088
1089 // Run the test 2*kCount times;
1090 for (int i = 0; i < 2 * kCount; ++i ) {
1091 Mock mock(kBudgetCnt, kBudgetSize);
1092 GrContext* context = mock.context();
1093 GrResourceCache* cache = mock.cache();
Robert Phillipsf35fd8d2018-01-22 10:48:15 -05001094 GrGpu* gpu = context->contextPriv().getGpu();
bsalomonddf30e62015-02-19 11:38:44 -08001095
1096 // Pick a random number of resources to add before the timestamp will wrap.
Ben Wagnerb0897652018-06-15 15:37:57 +00001097 cache->changeTimestamp(UINT32_MAX - random.nextULessThan(kCount + 1));
bsalomonddf30e62015-02-19 11:38:44 -08001098
1099 static const int kNumToPurge = kCount - kBudgetCnt;
1100
1101 SkTDArray<int> shouldPurgeIdxs;
1102 int purgeableCnt = 0;
1103 SkTDArray<GrGpuResource*> resourcesToUnref;
1104
1105 // Add kCount resources, holding onto resources at random so we have a mix of purgeable and
1106 // unpurgeable resources.
1107 for (int j = 0; j < kCount; ++j) {
1108 GrUniqueKey key;
1109 make_unique_key<0>(&key, j);
1110
Robert Phillipsf35fd8d2018-01-22 10:48:15 -05001111 TestResource* r = new TestResource(gpu);
bsalomonddf30e62015-02-19 11:38:44 -08001112 r->resourcePriv().setUniqueKey(key);
1113 if (random.nextU() % kLockedFreq) {
1114 // Make this is purgeable.
1115 r->unref();
1116 ++purgeableCnt;
1117 if (purgeableCnt <= kNumToPurge) {
1118 *shouldPurgeIdxs.append() = j;
1119 }
1120 } else {
1121 *resourcesToUnref.append() = r;
1122 }
1123 }
1124
1125 // Verify that the correct resources were purged.
1126 int currShouldPurgeIdx = 0;
1127 for (int j = 0; j < kCount; ++j) {
1128 GrUniqueKey key;
1129 make_unique_key<0>(&key, j);
1130 GrGpuResource* res = cache->findAndRefUniqueResource(key);
1131 if (currShouldPurgeIdx < shouldPurgeIdxs.count() &&
1132 shouldPurgeIdxs[currShouldPurgeIdx] == j) {
1133 ++currShouldPurgeIdx;
halcanary96fcdcc2015-08-27 07:41:13 -07001134 REPORTER_ASSERT(reporter, nullptr == res);
bsalomonddf30e62015-02-19 11:38:44 -08001135 } else {
halcanary96fcdcc2015-08-27 07:41:13 -07001136 REPORTER_ASSERT(reporter, nullptr != res);
bsalomonddf30e62015-02-19 11:38:44 -08001137 }
1138 SkSafeUnref(res);
1139 }
1140
1141 for (int j = 0; j < resourcesToUnref.count(); ++j) {
1142 resourcesToUnref[j]->unref();
1143 }
1144 }
1145}
1146
bsalomon3f324322015-04-08 11:01:54 -07001147static void test_flush(skiatest::Reporter* reporter) {
1148 Mock mock(1000000, 1000000);
1149 GrContext* context = mock.context();
1150 GrResourceCache* cache = mock.cache();
Robert Phillipsf35fd8d2018-01-22 10:48:15 -05001151 GrGpu* gpu = context->contextPriv().getGpu();
bsalomon3f324322015-04-08 11:01:54 -07001152
1153 // The current cache impl will round the max flush count to the next power of 2. So we choose a
1154 // power of two here to keep things simpler.
1155 static const int kFlushCount = 16;
1156 cache->setLimits(1000000, 1000000, kFlushCount);
1157
1158 {
1159 // Insert a resource and send a flush notification kFlushCount times.
1160 for (int i = 0; i < kFlushCount; ++i) {
Robert Phillipsf35fd8d2018-01-22 10:48:15 -05001161 TestResource* r = new TestResource(gpu);
bsalomon3f324322015-04-08 11:01:54 -07001162 GrUniqueKey k;
1163 make_unique_key<1>(&k, i);
1164 r->resourcePriv().setUniqueKey(k);
1165 r->unref();
bsalomonb77a9072016-09-07 10:02:04 -07001166 cache->notifyFlushOccurred(GrResourceCache::kExternal);
bsalomon3f324322015-04-08 11:01:54 -07001167 }
1168
1169 // Send flush notifications to the cache. Each flush should purge the oldest resource.
bsalomone2e87f32016-09-22 12:42:11 -07001170 for (int i = 0; i < kFlushCount; ++i) {
1171 cache->notifyFlushOccurred(GrResourceCache::kExternal);
bsalomon3f324322015-04-08 11:01:54 -07001172 REPORTER_ASSERT(reporter, kFlushCount - i - 1 == cache->getResourceCount());
1173 for (int j = 0; j < i; ++j) {
1174 GrUniqueKey k;
1175 make_unique_key<1>(&k, j);
1176 GrGpuResource* r = cache->findAndRefUniqueResource(k);
1177 REPORTER_ASSERT(reporter, !SkToBool(r));
1178 SkSafeUnref(r);
1179 }
bsalomon3f324322015-04-08 11:01:54 -07001180 }
1181
1182 REPORTER_ASSERT(reporter, 0 == cache->getResourceCount());
1183 cache->purgeAllUnlocked();
1184 }
1185
1186 // Do a similar test but where we leave refs on some resources to prevent them from being
1187 // purged.
1188 {
1189 GrGpuResource* refedResources[kFlushCount >> 1];
1190 for (int i = 0; i < kFlushCount; ++i) {
Robert Phillipsf35fd8d2018-01-22 10:48:15 -05001191 TestResource* r = new TestResource(gpu);
bsalomon3f324322015-04-08 11:01:54 -07001192 GrUniqueKey k;
1193 make_unique_key<1>(&k, i);
1194 r->resourcePriv().setUniqueKey(k);
1195 // Leave a ref on every other resource, beginning with the first.
1196 if (SkToBool(i & 0x1)) {
1197 refedResources[i/2] = r;
1198 } else {
1199 r->unref();
1200 }
bsalomonb77a9072016-09-07 10:02:04 -07001201 cache->notifyFlushOccurred(GrResourceCache::kExternal);
bsalomon3f324322015-04-08 11:01:54 -07001202 }
1203
1204 for (int i = 0; i < kFlushCount; ++i) {
1205 // Should get a resource purged every other flush.
bsalomonb77a9072016-09-07 10:02:04 -07001206 cache->notifyFlushOccurred(GrResourceCache::kExternal);
bsalomone2e87f32016-09-22 12:42:11 -07001207 REPORTER_ASSERT(reporter, kFlushCount - i/2 - 1 == cache->getResourceCount());
bsalomon3f324322015-04-08 11:01:54 -07001208 }
1209
1210 // Unref all the resources that we kept refs on in the first loop.
1211 for (int i = 0; i < kFlushCount >> 1; ++i) {
1212 refedResources[i]->unref();
1213 }
1214
bsalomone2e87f32016-09-22 12:42:11 -07001215 // After kFlushCount + 1 flushes they all will have sat in the purgeable queue for
1216 // kFlushCount full flushes.
1217 for (int i = 0; i < kFlushCount + 1; ++i) {
bsalomon3f324322015-04-08 11:01:54 -07001218 REPORTER_ASSERT(reporter, kFlushCount >> 1 == cache->getResourceCount());
bsalomonb77a9072016-09-07 10:02:04 -07001219 cache->notifyFlushOccurred(GrResourceCache::kExternal);
bsalomon3f324322015-04-08 11:01:54 -07001220 }
1221 REPORTER_ASSERT(reporter, 0 == cache->getResourceCount());
1222
1223 cache->purgeAllUnlocked();
1224 }
1225
1226 REPORTER_ASSERT(reporter, 0 == cache->getResourceCount());
bsalomondc438982016-08-31 11:53:49 -07001227
1228 // Verify that calling flush() on a GrContext with nothing to do will not trigger resource
1229 // eviction.
1230 context->flush();
1231 for (int i = 0; i < 10; ++i) {
Robert Phillipsf35fd8d2018-01-22 10:48:15 -05001232 TestResource* r = new TestResource(gpu);
bsalomondc438982016-08-31 11:53:49 -07001233 GrUniqueKey k;
1234 make_unique_key<1>(&k, i);
1235 r->resourcePriv().setUniqueKey(k);
1236 r->unref();
1237 }
1238 REPORTER_ASSERT(reporter, 10 == cache->getResourceCount());
1239 for (int i = 0; i < 10 * kFlushCount; ++i) {
1240 context->flush();
1241 }
1242 REPORTER_ASSERT(reporter, 10 == cache->getResourceCount());
bsalomon3f324322015-04-08 11:01:54 -07001243}
1244
Brian Salomon5e150852017-03-22 14:53:13 -04001245static void test_time_purge(skiatest::Reporter* reporter) {
1246 Mock mock(1000000, 1000000);
1247 GrContext* context = mock.context();
1248 GrResourceCache* cache = mock.cache();
Robert Phillipsf35fd8d2018-01-22 10:48:15 -05001249 GrGpu* gpu = context->contextPriv().getGpu();
Brian Salomon5e150852017-03-22 14:53:13 -04001250
1251 static constexpr int kCnts[] = {1, 10, 1024};
1252 auto nowish = []() {
1253 // We sleep so that we ensure we get a value that is greater than the last call to
1254 // GrStdSteadyClock::now().
1255 std::this_thread::sleep_for(GrStdSteadyClock::duration(5));
1256 auto result = GrStdSteadyClock::now();
1257 // Also sleep afterwards so we don't get this value again.
1258 std::this_thread::sleep_for(GrStdSteadyClock::duration(5));
1259 return result;
1260 };
1261
1262 for (int cnt : kCnts) {
1263 std::unique_ptr<GrStdSteadyClock::time_point[]> timeStamps(
1264 new GrStdSteadyClock::time_point[cnt]);
1265 {
1266 // Insert resources and get time points between each addition.
1267 for (int i = 0; i < cnt; ++i) {
Robert Phillipsf35fd8d2018-01-22 10:48:15 -05001268 TestResource* r = new TestResource(gpu);
Brian Salomon5e150852017-03-22 14:53:13 -04001269 GrUniqueKey k;
1270 make_unique_key<1>(&k, i);
1271 r->resourcePriv().setUniqueKey(k);
1272 r->unref();
1273 timeStamps.get()[i] = nowish();
1274 }
1275
1276 // Purge based on the time points between resource additions. Each purge should remove
1277 // the oldest resource.
1278 for (int i = 0; i < cnt; ++i) {
1279 cache->purgeResourcesNotUsedSince(timeStamps[i]);
1280 REPORTER_ASSERT(reporter, cnt - i - 1 == cache->getResourceCount());
1281 for (int j = 0; j < i; ++j) {
1282 GrUniqueKey k;
1283 make_unique_key<1>(&k, j);
1284 GrGpuResource* r = cache->findAndRefUniqueResource(k);
1285 REPORTER_ASSERT(reporter, !SkToBool(r));
1286 SkSafeUnref(r);
1287 }
1288 }
1289
1290 REPORTER_ASSERT(reporter, 0 == cache->getResourceCount());
1291 cache->purgeAllUnlocked();
1292 }
1293
1294 // Do a similar test but where we leave refs on some resources to prevent them from being
1295 // purged.
1296 {
1297 std::unique_ptr<GrGpuResource* []> refedResources(new GrGpuResource*[cnt / 2]);
1298 for (int i = 0; i < cnt; ++i) {
Robert Phillipsf35fd8d2018-01-22 10:48:15 -05001299 TestResource* r = new TestResource(gpu);
Brian Salomon5e150852017-03-22 14:53:13 -04001300 GrUniqueKey k;
1301 make_unique_key<1>(&k, i);
1302 r->resourcePriv().setUniqueKey(k);
1303 // Leave a ref on every other resource, beginning with the first.
1304 if (SkToBool(i & 0x1)) {
1305 refedResources.get()[i / 2] = r;
1306 } else {
1307 r->unref();
1308 }
1309 timeStamps.get()[i] = nowish();
1310 }
1311
1312 for (int i = 0; i < cnt; ++i) {
1313 // Should get a resource purged every other frame.
1314 cache->purgeResourcesNotUsedSince(timeStamps[i]);
1315 REPORTER_ASSERT(reporter, cnt - i / 2 - 1 == cache->getResourceCount());
1316 }
1317
1318 // Unref all the resources that we kept refs on in the first loop.
1319 for (int i = 0; i < (cnt / 2); ++i) {
1320 refedResources.get()[i]->unref();
1321 cache->purgeResourcesNotUsedSince(nowish());
1322 REPORTER_ASSERT(reporter, cnt / 2 - i - 1 == cache->getResourceCount());
1323 }
1324
1325 cache->purgeAllUnlocked();
1326 }
1327
1328 REPORTER_ASSERT(reporter, 0 == cache->getResourceCount());
1329
1330 // Verify that calling flush() on a GrContext with nothing to do will not trigger resource
1331 // eviction
1332 context->flush();
1333 for (int i = 0; i < 10; ++i) {
Robert Phillipsf35fd8d2018-01-22 10:48:15 -05001334 TestResource* r = new TestResource(gpu);
Brian Salomon5e150852017-03-22 14:53:13 -04001335 GrUniqueKey k;
1336 make_unique_key<1>(&k, i);
1337 r->resourcePriv().setUniqueKey(k);
1338 r->unref();
1339 }
1340 REPORTER_ASSERT(reporter, 10 == cache->getResourceCount());
1341 context->flush();
1342 REPORTER_ASSERT(reporter, 10 == cache->getResourceCount());
1343 cache->purgeResourcesNotUsedSince(nowish());
1344 REPORTER_ASSERT(reporter, 0 == cache->getResourceCount());
1345 }
1346}
1347
Derek Sollenberger5480a182017-05-25 16:43:59 -04001348static void test_partial_purge(skiatest::Reporter* reporter) {
1349 Mock mock(6, 100);
1350 GrContext* context = mock.context();
1351 GrResourceCache* cache = mock.cache();
Robert Phillipsf35fd8d2018-01-22 10:48:15 -05001352 GrGpu* gpu = context->contextPriv().getGpu();
Derek Sollenberger5480a182017-05-25 16:43:59 -04001353
1354 enum TestsCase {
1355 kOnlyScratch_TestCase = 0,
1356 kPartialScratch_TestCase = 1,
1357 kAllScratch_TestCase = 2,
1358 kPartial_TestCase = 3,
1359 kAll_TestCase = 4,
1360 kNone_TestCase = 5,
1361 kEndTests_TestCase = kNone_TestCase + 1
1362 };
1363
1364 for (int testCase = 0; testCase < kEndTests_TestCase; testCase++) {
1365
1366 GrUniqueKey key1, key2, key3;
1367 make_unique_key<0>(&key1, 1);
1368 make_unique_key<0>(&key2, 2);
1369 make_unique_key<0>(&key3, 3);
1370
1371 // Add three unique resources to the cache.
Greg Danielda86e282018-06-13 09:41:19 -04001372 TestResource *unique1 = new TestResource(gpu, SkBudgeted::kYes, 10);
1373 TestResource *unique2 = new TestResource(gpu, SkBudgeted::kYes, 11);
1374 TestResource *unique3 = new TestResource(gpu, SkBudgeted::kYes, 12);
Derek Sollenberger5480a182017-05-25 16:43:59 -04001375
1376 unique1->resourcePriv().setUniqueKey(key1);
1377 unique2->resourcePriv().setUniqueKey(key2);
1378 unique3->resourcePriv().setUniqueKey(key3);
1379
Derek Sollenberger5480a182017-05-25 16:43:59 -04001380 // Add two scratch resources to the cache.
Robert Phillipsf35fd8d2018-01-22 10:48:15 -05001381 TestResource *scratch1 = TestResource::CreateScratch(gpu, SkBudgeted::kYes,
Greg Danielda86e282018-06-13 09:41:19 -04001382 TestResource::kA_SimulatedProperty,
1383 13);
Robert Phillipsf35fd8d2018-01-22 10:48:15 -05001384 TestResource *scratch2 = TestResource::CreateScratch(gpu, SkBudgeted::kYes,
Greg Danielda86e282018-06-13 09:41:19 -04001385 TestResource::kB_SimulatedProperty,
1386 14);
Derek Sollenberger5480a182017-05-25 16:43:59 -04001387
1388 REPORTER_ASSERT(reporter, 5 == cache->getBudgetedResourceCount());
1389 REPORTER_ASSERT(reporter, 60 == cache->getBudgetedResourceBytes());
1390 REPORTER_ASSERT(reporter, 0 == cache->getPurgeableBytes());
1391
1392 // Add resources to the purgeable queue
1393 unique1->unref();
1394 scratch1->unref();
1395 unique2->unref();
1396 scratch2->unref();
1397 unique3->unref();
1398
1399 REPORTER_ASSERT(reporter, 5 == cache->getBudgetedResourceCount());
1400 REPORTER_ASSERT(reporter, 60 == cache->getBudgetedResourceBytes());
1401 REPORTER_ASSERT(reporter, 60 == cache->getPurgeableBytes());
1402
1403 switch(testCase) {
1404 case kOnlyScratch_TestCase: {
1405 context->purgeUnlockedResources(14, true);
1406 REPORTER_ASSERT(reporter, 3 == cache->getBudgetedResourceCount());
1407 REPORTER_ASSERT(reporter, 33 == cache->getBudgetedResourceBytes());
1408 break;
1409 }
1410 case kPartialScratch_TestCase: {
1411 context->purgeUnlockedResources(3, true);
1412 REPORTER_ASSERT(reporter, 4 == cache->getBudgetedResourceCount());
1413 REPORTER_ASSERT(reporter, 47 == cache->getBudgetedResourceBytes());
1414 break;
1415 }
1416 case kAllScratch_TestCase: {
1417 context->purgeUnlockedResources(50, true);
1418 REPORTER_ASSERT(reporter, 0 == cache->getBudgetedResourceCount());
1419 REPORTER_ASSERT(reporter, 0 == cache->getBudgetedResourceBytes());
1420 break;
1421 }
1422 case kPartial_TestCase: {
1423 context->purgeUnlockedResources(13, false);
1424 REPORTER_ASSERT(reporter, 3 == cache->getBudgetedResourceCount());
1425 REPORTER_ASSERT(reporter, 37 == cache->getBudgetedResourceBytes());
1426 break;
1427 }
1428 case kAll_TestCase: {
1429 context->purgeUnlockedResources(50, false);
1430 REPORTER_ASSERT(reporter, 0 == cache->getBudgetedResourceCount());
1431 REPORTER_ASSERT(reporter, 0 == cache->getBudgetedResourceBytes());
1432 break;
1433 }
1434 case kNone_TestCase: {
1435 context->purgeUnlockedResources(0, true);
1436 context->purgeUnlockedResources(0, false);
1437 REPORTER_ASSERT(reporter, 5 == cache->getBudgetedResourceCount());
1438 REPORTER_ASSERT(reporter, 60 == cache->getBudgetedResourceBytes());
1439 REPORTER_ASSERT(reporter, 60 == cache->getPurgeableBytes());
1440 break;
1441 }
1442 };
1443
1444 // ensure all are purged before the next
Robert Phillips0c4b7b12018-03-06 08:20:37 -05001445 context->contextPriv().purgeAllUnlockedResources_ForTesting();
Derek Sollenberger5480a182017-05-25 16:43:59 -04001446 REPORTER_ASSERT(reporter, 0 == cache->getBudgetedResourceCount());
1447 REPORTER_ASSERT(reporter, 0 == cache->getPurgeableBytes());
1448
1449 }
1450}
1451
bsalomon10e23ca2014-11-25 05:52:06 -08001452static void test_large_resource_count(skiatest::Reporter* reporter) {
bsalomon10e23ca2014-11-25 05:52:06 -08001453 // Set the cache size to double the resource count because we're going to create 2x that number
1454 // resources, using two different key domains. Add a little slop to the bytes because we resize
1455 // down to 1 byte after creating the resource.
bsalomonc2f35b72015-01-23 07:19:22 -08001456 static const int kResourceCnt = 2000;
bsalomon10e23ca2014-11-25 05:52:06 -08001457
bsalomonc2f35b72015-01-23 07:19:22 -08001458 Mock mock(2 * kResourceCnt, 2 * kResourceCnt + 1000);
1459 GrContext* context = mock.context();
bsalomon0ea80f42015-02-11 10:49:59 -08001460 GrResourceCache* cache = mock.cache();
Robert Phillipsf35fd8d2018-01-22 10:48:15 -05001461 GrGpu* gpu = context->contextPriv().getGpu();
bsalomon10e23ca2014-11-25 05:52:06 -08001462
1463 for (int i = 0; i < kResourceCnt; ++i) {
bsalomon8718aaf2015-02-19 07:24:21 -08001464 GrUniqueKey key1, key2;
1465 make_unique_key<1>(&key1, i);
1466 make_unique_key<2>(&key2, i);
bsalomon10e23ca2014-11-25 05:52:06 -08001467
bsalomon24db3b12015-01-23 04:24:04 -08001468 TestResource* resource;
1469
Greg Danielda86e282018-06-13 09:41:19 -04001470 resource = new TestResource(gpu, SkBudgeted::kYes, 1);
bsalomon8718aaf2015-02-19 07:24:21 -08001471 resource->resourcePriv().setUniqueKey(key1);
bsalomon10e23ca2014-11-25 05:52:06 -08001472 resource->unref();
1473
Greg Danielda86e282018-06-13 09:41:19 -04001474 resource = new TestResource(gpu, SkBudgeted::kYes, 1);
bsalomon8718aaf2015-02-19 07:24:21 -08001475 resource->resourcePriv().setUniqueKey(key2);
bsalomon10e23ca2014-11-25 05:52:06 -08001476 resource->unref();
1477 }
1478
1479 REPORTER_ASSERT(reporter, TestResource::NumAlive() == 2 * kResourceCnt);
Derek Sollenbergeree479142017-05-24 11:41:33 -04001480 REPORTER_ASSERT(reporter, cache->getPurgeableBytes() == 2 * kResourceCnt);
bsalomon0ea80f42015-02-11 10:49:59 -08001481 REPORTER_ASSERT(reporter, cache->getBudgetedResourceBytes() == 2 * kResourceCnt);
1482 REPORTER_ASSERT(reporter, cache->getBudgetedResourceCount() == 2 * kResourceCnt);
1483 REPORTER_ASSERT(reporter, cache->getResourceBytes() == 2 * kResourceCnt);
1484 REPORTER_ASSERT(reporter, cache->getResourceCount() == 2 * kResourceCnt);
bsalomon10e23ca2014-11-25 05:52:06 -08001485 for (int i = 0; i < kResourceCnt; ++i) {
bsalomon8718aaf2015-02-19 07:24:21 -08001486 GrUniqueKey key1, key2;
1487 make_unique_key<1>(&key1, i);
1488 make_unique_key<2>(&key2, i);
bsalomon24db3b12015-01-23 04:24:04 -08001489
bsalomon8718aaf2015-02-19 07:24:21 -08001490 REPORTER_ASSERT(reporter, cache->hasUniqueKey(key1));
1491 REPORTER_ASSERT(reporter, cache->hasUniqueKey(key2));
bsalomon10e23ca2014-11-25 05:52:06 -08001492 }
1493
bsalomon0ea80f42015-02-11 10:49:59 -08001494 cache->purgeAllUnlocked();
bsalomon10e23ca2014-11-25 05:52:06 -08001495 REPORTER_ASSERT(reporter, TestResource::NumAlive() == 0);
Derek Sollenbergeree479142017-05-24 11:41:33 -04001496 REPORTER_ASSERT(reporter, cache->getPurgeableBytes() == 0);
bsalomon0ea80f42015-02-11 10:49:59 -08001497 REPORTER_ASSERT(reporter, cache->getBudgetedResourceBytes() == 0);
1498 REPORTER_ASSERT(reporter, cache->getBudgetedResourceCount() == 0);
1499 REPORTER_ASSERT(reporter, cache->getResourceBytes() == 0);
1500 REPORTER_ASSERT(reporter, cache->getResourceCount() == 0);
bsalomon10e23ca2014-11-25 05:52:06 -08001501
1502 for (int i = 0; i < kResourceCnt; ++i) {
bsalomon8718aaf2015-02-19 07:24:21 -08001503 GrUniqueKey key1, key2;
1504 make_unique_key<1>(&key1, i);
1505 make_unique_key<2>(&key2, i);
bsalomon24db3b12015-01-23 04:24:04 -08001506
bsalomon8718aaf2015-02-19 07:24:21 -08001507 REPORTER_ASSERT(reporter, !cache->hasUniqueKey(key1));
1508 REPORTER_ASSERT(reporter, !cache->hasUniqueKey(key2));
bsalomon10e23ca2014-11-25 05:52:06 -08001509 }
1510}
1511
senorblanco84cd6212015-08-04 10:01:58 -07001512static void test_custom_data(skiatest::Reporter* reporter) {
1513 GrUniqueKey key1, key2;
1514 make_unique_key<0>(&key1, 1);
1515 make_unique_key<0>(&key2, 2);
1516 int foo = 4132;
bungeman38d909e2016-08-02 14:40:46 -07001517 key1.setCustomData(SkData::MakeWithCopy(&foo, sizeof(foo)));
senorblanco84cd6212015-08-04 10:01:58 -07001518 REPORTER_ASSERT(reporter, *(int*) key1.getCustomData()->data() == 4132);
1519 REPORTER_ASSERT(reporter, key2.getCustomData() == nullptr);
1520
1521 // Test that copying a key also takes a ref on its custom data.
1522 GrUniqueKey key3 = key1;
1523 REPORTER_ASSERT(reporter, *(int*) key3.getCustomData()->data() == 4132);
1524}
1525
bsalomonc6363ef2015-09-24 07:07:40 -07001526static void test_abandoned(skiatest::Reporter* reporter) {
1527 Mock mock(10, 300);
1528 GrContext* context = mock.context();
Robert Phillipsf35fd8d2018-01-22 10:48:15 -05001529 GrGpu* gpu = context->contextPriv().getGpu();
1530
1531 sk_sp<GrGpuResource> resource(new TestResource(gpu));
bsalomonc6363ef2015-09-24 07:07:40 -07001532 context->abandonContext();
1533
1534 REPORTER_ASSERT(reporter, resource->wasDestroyed());
1535
1536 // Call all the public methods on resource in the abandoned state. They shouldn't crash.
1537
robertphillips8abb3702016-08-31 14:04:06 -07001538 resource->uniqueID();
bsalomonc6363ef2015-09-24 07:07:40 -07001539 resource->getUniqueKey();
1540 resource->wasDestroyed();
1541 resource->gpuMemorySize();
1542 resource->getContext();
1543
1544 resource->abandon();
1545 resource->resourcePriv().getScratchKey();
1546 resource->resourcePriv().isBudgeted();
1547 resource->resourcePriv().makeBudgeted();
1548 resource->resourcePriv().makeUnbudgeted();
1549 resource->resourcePriv().removeScratchKey();
1550 GrUniqueKey key;
1551 make_unique_key<0>(&key, 1);
1552 resource->resourcePriv().setUniqueKey(key);
1553 resource->resourcePriv().removeUniqueKey();
1554}
1555
Brian Salomon1090da62017-01-06 12:04:19 -05001556static void test_tags(skiatest::Reporter* reporter) {
1557#ifdef SK_DEBUG
1558 // We will insert 1 resource with tag "tag1", 2 with "tag2", and so on, up through kLastTagIdx.
1559 static constexpr int kLastTagIdx = 10;
1560 static constexpr int kNumResources = kLastTagIdx * (kLastTagIdx + 1) / 2;
1561
1562 Mock mock(kNumResources, kNumResources * TestResource::kDefaultSize);
1563 GrContext* context = mock.context();
1564 GrResourceCache* cache = mock.cache();
Robert Phillipsf35fd8d2018-01-22 10:48:15 -05001565 GrGpu* gpu = context->contextPriv().getGpu();
Brian Salomon1090da62017-01-06 12:04:19 -05001566
Derek Sollenbergercf6da8c2018-03-29 13:40:02 -04001567 // tag strings are expected to be long lived
1568 std::vector<SkString> tagStrings;
1569
Brian Salomon1090da62017-01-06 12:04:19 -05001570 SkString tagStr;
1571 int tagIdx = 0;
1572 int currTagCnt = 0;
1573
1574 for (int i = 0; i < kNumResources; ++i, ++currTagCnt) {
Derek Sollenbergercf6da8c2018-03-29 13:40:02 -04001575
Robert Phillipsf35fd8d2018-01-22 10:48:15 -05001576 sk_sp<GrGpuResource> resource(new TestResource(gpu));
Brian Salomon1090da62017-01-06 12:04:19 -05001577 GrUniqueKey key;
1578 if (currTagCnt == tagIdx) {
1579 tagIdx += 1;
1580 currTagCnt = 0;
1581 tagStr.printf("tag%d", tagIdx);
Derek Sollenbergercf6da8c2018-03-29 13:40:02 -04001582 tagStrings.emplace_back(tagStr);
Brian Salomon1090da62017-01-06 12:04:19 -05001583 }
Derek Sollenbergercf6da8c2018-03-29 13:40:02 -04001584 make_unique_key<1>(&key, i, tagStrings.back().c_str());
Brian Salomon1090da62017-01-06 12:04:19 -05001585 resource->resourcePriv().setUniqueKey(key);
1586 }
1587 SkASSERT(kLastTagIdx == tagIdx);
1588 SkASSERT(currTagCnt == kLastTagIdx);
1589
1590 // Test i = 0 to exercise unused tag string.
1591 for (int i = 0; i <= kLastTagIdx; ++i) {
1592 tagStr.printf("tag%d", i);
1593 REPORTER_ASSERT(reporter, cache->countUniqueKeysWithTag(tagStr.c_str()) == i);
1594 }
1595#endif
1596}
1597
Brian Salomondcfca432017-11-15 15:48:03 -05001598DEF_GPUTEST(ResourceCacheMisc, reporter, /* options */) {
bsalomon8b79d232014-11-10 10:19:06 -08001599 // The below tests create their own mock contexts.
bsalomon71cb0c22014-11-14 12:10:14 -08001600 test_no_key(reporter);
Robert Phillips6eba0632018-03-28 12:25:42 -04001601 test_purge_unlocked(reporter);
bsalomon84c8e622014-11-17 09:33:27 -08001602 test_budgeting(reporter);
bsalomon5236cf42015-01-14 10:42:08 -08001603 test_unbudgeted(reporter);
bsalomonc2f35b72015-01-23 07:19:22 -08001604 test_unbudgeted_to_scratch(reporter);
bsalomon8718aaf2015-02-19 07:24:21 -08001605 test_duplicate_unique_key(reporter);
bsalomon8b79d232014-11-10 10:19:06 -08001606 test_duplicate_scratch_key(reporter);
bsalomon10e23ca2014-11-25 05:52:06 -08001607 test_remove_scratch_key(reporter);
bsalomon1c60dfe2015-01-21 09:32:40 -08001608 test_scratch_key_consistency(reporter);
bsalomon8b79d232014-11-10 10:19:06 -08001609 test_purge_invalidated(reporter);
bsalomon71cb0c22014-11-14 12:10:14 -08001610 test_cache_chained_purge(reporter);
bsalomonddf30e62015-02-19 11:38:44 -08001611 test_timestamp_wrap(reporter);
bsalomon3f324322015-04-08 11:01:54 -07001612 test_flush(reporter);
Brian Salomon5e150852017-03-22 14:53:13 -04001613 test_time_purge(reporter);
Derek Sollenberger5480a182017-05-25 16:43:59 -04001614 test_partial_purge(reporter);
bsalomon10e23ca2014-11-25 05:52:06 -08001615 test_large_resource_count(reporter);
senorblanco84cd6212015-08-04 10:01:58 -07001616 test_custom_data(reporter);
bsalomonc6363ef2015-09-24 07:07:40 -07001617 test_abandoned(reporter);
Brian Salomon1090da62017-01-06 12:04:19 -05001618 test_tags(reporter);
commit-bot@chromium.orgc28f5552013-08-08 22:55:21 +00001619}
1620
Robert Phillipsd6214d42016-11-07 08:23:48 -05001621////////////////////////////////////////////////////////////////////////////////
Brian Osman32342f02017-03-04 08:12:46 -05001622static sk_sp<GrTexture> make_normal_texture(GrResourceProvider* provider,
Robert Phillipsfe0253f2018-03-16 16:47:25 -04001623 GrSurfaceDescFlags descFlags,
Robert Phillipsd6214d42016-11-07 08:23:48 -05001624 int width, int height,
1625 int sampleCnt) {
1626 GrSurfaceDesc desc;
Robert Phillipsfe0253f2018-03-16 16:47:25 -04001627 desc.fFlags = descFlags;
Robert Phillipsd6214d42016-11-07 08:23:48 -05001628 desc.fWidth = width;
1629 desc.fHeight = height;
1630 desc.fConfig = kRGBA_8888_GrPixelConfig;
1631 desc.fSampleCnt = sampleCnt;
1632
Robert Phillipse78b7252017-04-06 07:59:41 -04001633 return provider->createTexture(desc, SkBudgeted::kYes);
Robert Phillipsd6214d42016-11-07 08:23:48 -05001634}
1635
Robert Phillips0bd24dc2018-01-16 08:06:32 -05001636static sk_sp<GrTextureProxy> make_mipmap_proxy(GrProxyProvider* proxyProvider,
Robert Phillipsfe0253f2018-03-16 16:47:25 -04001637 GrSurfaceDescFlags descFlags,
Robert Phillipse78b7252017-04-06 07:59:41 -04001638 int width, int height,
1639 int sampleCnt) {
Robert Phillipsd6214d42016-11-07 08:23:48 -05001640 GrSurfaceDesc desc;
Robert Phillipsfe0253f2018-03-16 16:47:25 -04001641 desc.fFlags = descFlags;
Robert Phillipsd6214d42016-11-07 08:23:48 -05001642 desc.fWidth = width;
1643 desc.fHeight = height;
1644 desc.fConfig = kRGBA_8888_GrPixelConfig;
1645 desc.fSampleCnt = sampleCnt;
Robert Phillipsd6214d42016-11-07 08:23:48 -05001646
Robert Phillipsfe0253f2018-03-16 16:47:25 -04001647 auto origin = (descFlags & kRenderTarget_GrSurfaceFlag) ? kBottomLeft_GrSurfaceOrigin
1648 : kTopLeft_GrSurfaceOrigin;
Brian Salomon2a4f9832018-03-03 22:43:43 -05001649
1650 return proxyProvider->createMipMapProxy(desc, origin, SkBudgeted::kYes);
Robert Phillipsd6214d42016-11-07 08:23:48 -05001651}
1652
1653// Exercise GrSurface::gpuMemorySize for different combos of MSAA, RT-only,
1654// Texture-only, both-RT-and-Texture and MIPmapped
1655DEF_GPUTEST_FOR_RENDERING_CONTEXTS(GPUMemorySize, reporter, ctxInfo) {
1656 GrContext* context = ctxInfo.grContext();
Robert Phillips1afd4cd2018-01-08 13:40:32 -05001657 GrProxyProvider* proxyProvider = context->contextPriv().proxyProvider();
Robert Phillips6be756b2018-01-16 15:07:54 -05001658 GrResourceProvider* resourceProvider = context->contextPriv().resourceProvider();
Robert Phillipsd6214d42016-11-07 08:23:48 -05001659
Robert Phillipsd6214d42016-11-07 08:23:48 -05001660 static const int kSize = 64;
1661
Robert Phillipsd6214d42016-11-07 08:23:48 -05001662 // Normal versions
Robert Phillipse78b7252017-04-06 07:59:41 -04001663 {
1664 sk_sp<GrTexture> tex;
Robert Phillipsd6214d42016-11-07 08:23:48 -05001665
Brian Salomonbdecacf2018-02-02 20:32:49 -05001666 tex = make_normal_texture(resourceProvider, kRenderTarget_GrSurfaceFlag, kSize, kSize, 1);
Robert Phillipse78b7252017-04-06 07:59:41 -04001667 size_t size = tex->gpuMemorySize();
1668 REPORTER_ASSERT(reporter, kSize*kSize*4 == size);
1669
Brian Salomonc7fe0f72018-05-11 10:14:21 -04001670 size_t sampleCount = (size_t)context->contextPriv().caps()->getRenderTargetSampleCount(
1671 4, kRGBA_8888_GrPixelConfig);
Greg Daniel81e7bf82017-07-19 14:47:42 -04001672 if (sampleCount >= 4) {
Robert Phillips1afd4cd2018-01-08 13:40:32 -05001673 tex = make_normal_texture(resourceProvider, kRenderTarget_GrSurfaceFlag, kSize, kSize,
Greg Daniel81e7bf82017-07-19 14:47:42 -04001674 sampleCount);
Robert Phillipse78b7252017-04-06 07:59:41 -04001675 size = tex->gpuMemorySize();
Greg Daniel81e7bf82017-07-19 14:47:42 -04001676 REPORTER_ASSERT(reporter,
1677 kSize*kSize*4 == size || // msaa4 failed
1678 kSize*kSize*4*sampleCount == size || // auto-resolving
1679 kSize*kSize*4*(sampleCount+1) == size); // explicit resolve buffer
Robert Phillipse78b7252017-04-06 07:59:41 -04001680 }
1681
Brian Salomonbdecacf2018-02-02 20:32:49 -05001682 tex = make_normal_texture(resourceProvider, kNone_GrSurfaceFlags, kSize, kSize, 1);
Robert Phillipsd6214d42016-11-07 08:23:48 -05001683 size = tex->gpuMemorySize();
Robert Phillipse78b7252017-04-06 07:59:41 -04001684 REPORTER_ASSERT(reporter, kSize*kSize*4 == size);
Robert Phillipsd6214d42016-11-07 08:23:48 -05001685 }
1686
Robert Phillipsd6214d42016-11-07 08:23:48 -05001687
1688 // Mipmapped versions
Brian Salomonc7fe0f72018-05-11 10:14:21 -04001689 if (context->contextPriv().caps()->mipMapSupport()) {
Robert Phillipse78b7252017-04-06 07:59:41 -04001690 sk_sp<GrTextureProxy> proxy;
Robert Phillipsd6214d42016-11-07 08:23:48 -05001691
Brian Salomonbdecacf2018-02-02 20:32:49 -05001692 proxy = make_mipmap_proxy(proxyProvider, kRenderTarget_GrSurfaceFlag, kSize, kSize, 1);
Robert Phillipse78b7252017-04-06 07:59:41 -04001693 size_t size = proxy->gpuMemorySize();
1694 REPORTER_ASSERT(reporter, kSize*kSize*4+(kSize*kSize*4)/3 == size);
1695
Brian Salomonc7fe0f72018-05-11 10:14:21 -04001696 size_t sampleCount = (size_t)context->contextPriv().caps()->getRenderTargetSampleCount(
1697 4, kRGBA_8888_GrPixelConfig);
Greg Daniel81e7bf82017-07-19 14:47:42 -04001698 if (sampleCount >= 4) {
Robert Phillips1afd4cd2018-01-08 13:40:32 -05001699 proxy = make_mipmap_proxy(proxyProvider, kRenderTarget_GrSurfaceFlag, kSize, kSize,
Greg Daniel81e7bf82017-07-19 14:47:42 -04001700 sampleCount);
Robert Phillipse78b7252017-04-06 07:59:41 -04001701 size = proxy->gpuMemorySize();
1702 REPORTER_ASSERT(reporter,
Greg Daniel81e7bf82017-07-19 14:47:42 -04001703 kSize*kSize*4+(kSize*kSize*4)/3 == size || // msaa4 failed
1704 kSize*kSize*4*sampleCount+(kSize*kSize*4)/3 == size || // auto-resolving
1705 kSize*kSize*4*(sampleCount+1)+(kSize*kSize*4)/3 == size); // explicit resolve buffer
Robert Phillipse78b7252017-04-06 07:59:41 -04001706 }
Robert Phillips1b352562017-04-05 18:56:21 +00001707
Brian Salomonbdecacf2018-02-02 20:32:49 -05001708 proxy = make_mipmap_proxy(proxyProvider, kNone_GrSurfaceFlags, kSize, kSize, 1);
Robert Phillipse78b7252017-04-06 07:59:41 -04001709 size = proxy->gpuMemorySize();
1710 REPORTER_ASSERT(reporter, kSize*kSize*4+(kSize*kSize*4)/3 == size);
1711 }
Robert Phillipsd6214d42016-11-07 08:23:48 -05001712}