ResourceAllocatorTest.cpp 18 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404
  1. /*
  2. * Copyright 2017 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. #include "include/core/SkTypes.h"
  8. #include "tests/Test.h"
  9. #include "include/gpu/GrTexture.h"
  10. #include "src/gpu/GrContextPriv.h"
  11. #include "src/gpu/GrDeinstantiateProxyTracker.h"
  12. #include "src/gpu/GrGpu.h"
  13. #include "src/gpu/GrProxyProvider.h"
  14. #include "src/gpu/GrResourceAllocator.h"
  15. #include "src/gpu/GrResourceProvider.h"
  16. #include "src/gpu/GrSurfaceProxyPriv.h"
  17. #include "src/gpu/GrTextureProxy.h"
  18. #include "include/core/SkSurface.h"
  19. struct ProxyParams {
  20. int fSize;
  21. GrRenderable fRenderable;
  22. GrColorType fColorType;
  23. SkBackingFit fFit;
  24. int fSampleCnt;
  25. GrSurfaceOrigin fOrigin;
  26. SkBudgeted fBudgeted;
  27. // TODO: do we care about mipmapping
  28. };
  29. static sk_sp<GrSurfaceProxy> make_deferred(GrProxyProvider* proxyProvider, const GrCaps* caps,
  30. const ProxyParams& p) {
  31. GrPixelConfig config = GrColorTypeToPixelConfig(p.fColorType);
  32. GrSurfaceDesc desc;
  33. desc.fWidth = p.fSize;
  34. desc.fHeight = p.fSize;
  35. desc.fConfig = config;
  36. const GrBackendFormat format = caps->getBackendFormatFromColorType(p.fColorType);
  37. return proxyProvider->createProxy(format, desc, p.fRenderable, p.fSampleCnt, p.fOrigin, p.fFit,
  38. p.fBudgeted, GrProtected::kNo);
  39. }
  40. static sk_sp<GrSurfaceProxy> make_backend(GrContext* context, const ProxyParams& p,
  41. GrBackendTexture* backendTex) {
  42. GrProxyProvider* proxyProvider = context->priv().proxyProvider();
  43. SkColorType skColorType = GrColorTypeToSkColorType(p.fColorType);
  44. SkASSERT(SkColorType::kUnknown_SkColorType != skColorType);
  45. *backendTex = context->createBackendTexture(p.fSize, p.fSize, skColorType,
  46. SkColors::kTransparent,
  47. GrMipMapped::kNo, GrRenderable::kNo,
  48. GrProtected::kNo);
  49. if (!backendTex->isValid()) {
  50. return nullptr;
  51. }
  52. return proxyProvider->wrapBackendTexture(*backendTex, p.fColorType, p.fOrigin,
  53. kBorrow_GrWrapOwnership, GrWrapCacheable::kNo,
  54. kRead_GrIOType);
  55. }
  56. static void cleanup_backend(GrContext* context, const GrBackendTexture& backendTex) {
  57. context->deleteBackendTexture(backendTex);
  58. }
  59. // Basic test that two proxies with overlapping intervals and compatible descriptors are
  60. // assigned different GrSurfaces.
  61. static void overlap_test(skiatest::Reporter* reporter, GrResourceProvider* resourceProvider,
  62. sk_sp<GrSurfaceProxy> p1, sk_sp<GrSurfaceProxy> p2,
  63. bool expectedResult) {
  64. GrDeinstantiateProxyTracker deinstantiateTracker;
  65. GrResourceAllocator alloc(resourceProvider, &deinstantiateTracker SkDEBUGCODE(, 1));
  66. alloc.addInterval(p1.get(), 0, 4, GrResourceAllocator::ActualUse::kYes);
  67. alloc.incOps();
  68. alloc.addInterval(p2.get(), 1, 2, GrResourceAllocator::ActualUse::kYes);
  69. alloc.incOps();
  70. alloc.markEndOfOpList(0);
  71. alloc.determineRecyclability();
  72. int startIndex, stopIndex;
  73. GrResourceAllocator::AssignError error;
  74. alloc.assign(&startIndex, &stopIndex, &error);
  75. REPORTER_ASSERT(reporter, GrResourceAllocator::AssignError::kNoError == error);
  76. REPORTER_ASSERT(reporter, p1->peekSurface());
  77. REPORTER_ASSERT(reporter, p2->peekSurface());
  78. bool doTheBackingStoresMatch = p1->underlyingUniqueID() == p2->underlyingUniqueID();
  79. REPORTER_ASSERT(reporter, expectedResult == doTheBackingStoresMatch);
  80. }
  81. // Test various cases when two proxies do not have overlapping intervals.
  82. // This mainly acts as a test of the ResourceAllocator's free pool.
  83. static void non_overlap_test(skiatest::Reporter* reporter, GrResourceProvider* resourceProvider,
  84. sk_sp<GrSurfaceProxy> p1, sk_sp<GrSurfaceProxy> p2,
  85. bool expectedResult) {
  86. GrDeinstantiateProxyTracker deinstantiateTracker;
  87. GrResourceAllocator alloc(resourceProvider, &deinstantiateTracker SkDEBUGCODE(, 1));
  88. alloc.incOps();
  89. alloc.incOps();
  90. alloc.incOps();
  91. alloc.incOps();
  92. alloc.incOps();
  93. alloc.incOps();
  94. alloc.addInterval(p1.get(), 0, 2, GrResourceAllocator::ActualUse::kYes);
  95. alloc.addInterval(p2.get(), 3, 5, GrResourceAllocator::ActualUse::kYes);
  96. alloc.markEndOfOpList(0);
  97. alloc.determineRecyclability();
  98. int startIndex, stopIndex;
  99. GrResourceAllocator::AssignError error;
  100. alloc.assign(&startIndex, &stopIndex, &error);
  101. REPORTER_ASSERT(reporter, GrResourceAllocator::AssignError::kNoError == error);
  102. REPORTER_ASSERT(reporter, p1->peekSurface());
  103. REPORTER_ASSERT(reporter, p2->peekSurface());
  104. bool doTheBackingStoresMatch = p1->underlyingUniqueID() == p2->underlyingUniqueID();
  105. REPORTER_ASSERT(reporter, expectedResult == doTheBackingStoresMatch);
  106. }
  107. DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ResourceAllocatorTest, reporter, ctxInfo) {
  108. const GrCaps* caps = ctxInfo.grContext()->priv().caps();
  109. GrProxyProvider* proxyProvider = ctxInfo.grContext()->priv().proxyProvider();
  110. GrResourceProvider* resourceProvider = ctxInfo.grContext()->priv().resourceProvider();
  111. struct TestCase {
  112. ProxyParams fP1;
  113. ProxyParams fP2;
  114. bool fExpectation;
  115. };
  116. constexpr GrRenderable kRT = GrRenderable::kYes;
  117. constexpr GrRenderable kNotRT = GrRenderable::kNo;
  118. constexpr bool kShare = true;
  119. constexpr bool kDontShare = false;
  120. // Non-RT GrSurfaces are never recycled on some platforms.
  121. bool kConditionallyShare = resourceProvider->caps()->reuseScratchTextures();
  122. const GrColorType kRGBA = GrColorType::kRGBA_8888;
  123. const GrColorType kBGRA = GrColorType::kBGRA_8888;
  124. const SkBackingFit kE = SkBackingFit::kExact;
  125. const SkBackingFit kA = SkBackingFit::kApprox;
  126. const GrSurfaceOrigin kTL = kTopLeft_GrSurfaceOrigin;
  127. const GrSurfaceOrigin kBL = kBottomLeft_GrSurfaceOrigin;
  128. const SkBudgeted kNotB = SkBudgeted::kNo;
  129. //--------------------------------------------------------------------------------------------
  130. TestCase gOverlappingTests[] = {
  131. //----------------------------------------------------------------------------------------
  132. // Two proxies with overlapping intervals and compatible descriptors should never share
  133. // RT version
  134. { { 64, kRT, kRGBA, kA, 1, kTL, kNotB }, { 64, kRT, kRGBA, kA, 1, kTL, kNotB }, kDontShare },
  135. // non-RT version
  136. { { 64, kNotRT, kRGBA, kA, 1, kTL, kNotB }, { 64, kNotRT, kRGBA, kA, 1, kTL, kNotB }, kDontShare },
  137. };
  138. for (auto test : gOverlappingTests) {
  139. sk_sp<GrSurfaceProxy> p1 = make_deferred(proxyProvider, caps, test.fP1);
  140. sk_sp<GrSurfaceProxy> p2 = make_deferred(proxyProvider, caps, test.fP2);
  141. overlap_test(reporter, resourceProvider, std::move(p1), std::move(p2), test.fExpectation);
  142. }
  143. int k2 = ctxInfo.grContext()->priv().caps()->getRenderTargetSampleCount(
  144. 2, kRGBA_8888_GrPixelConfig);
  145. int k4 = ctxInfo.grContext()->priv().caps()->getRenderTargetSampleCount(
  146. 4, kRGBA_8888_GrPixelConfig);
  147. //--------------------------------------------------------------------------------------------
  148. TestCase gNonOverlappingTests[] = {
  149. //----------------------------------------------------------------------------------------
  150. // Two non-overlapping intervals w/ compatible proxies should share
  151. // both same size & approx
  152. { { 64, kRT, kRGBA, kA, 1, kTL, kNotB }, { 64, kRT, kRGBA, kA, 1, kTL, kNotB }, kShare },
  153. { { 64, kNotRT, kRGBA, kA, 1, kTL, kNotB }, { 64, kNotRT, kRGBA, kA, 1, kTL, kNotB }, kConditionallyShare },
  154. // diffs sizes but still approx
  155. { { 64, kRT, kRGBA, kA, 1, kTL, kNotB }, { 50, kRT, kRGBA, kA, 1, kTL, kNotB }, kShare },
  156. { { 64, kNotRT, kRGBA, kA, 1, kTL, kNotB }, { 50, kNotRT, kRGBA, kA, 1, kTL, kNotB }, kConditionallyShare },
  157. // sames sizes but exact
  158. { { 64, kRT, kRGBA, kE, 1, kTL, kNotB }, { 64, kRT, kRGBA, kE, 1, kTL, kNotB }, kShare },
  159. { { 64, kNotRT, kRGBA, kE, 1, kTL, kNotB }, { 64, kNotRT, kRGBA, kE, 1, kTL, kNotB }, kConditionallyShare },
  160. //----------------------------------------------------------------------------------------
  161. // Two non-overlapping intervals w/ different exact sizes should not share
  162. { { 56, kRT, kRGBA, kE, 1, kTL, kNotB }, { 54, kRT, kRGBA, kE, 1, kTL, kNotB }, kDontShare },
  163. // Two non-overlapping intervals w/ _very different_ approx sizes should not share
  164. { { 255, kRT, kRGBA, kA, 1, kTL, kNotB }, { 127, kRT, kRGBA, kA, 1, kTL, kNotB }, kDontShare },
  165. // Two non-overlapping intervals w/ different MSAA sample counts should not share
  166. { { 64, kRT, kRGBA, kA, k2, kTL, kNotB },{ 64, kRT, kRGBA, kA, k4,kTL, kNotB}, k2 == k4 },
  167. // Two non-overlapping intervals w/ different configs should not share
  168. { { 64, kRT, kRGBA, kA, 1, kTL, kNotB }, { 64, kRT, kBGRA, kA, 1, kTL, kNotB }, kDontShare },
  169. // Two non-overlapping intervals w/ different RT classifications should never share
  170. { { 64, kRT, kRGBA, kA, 1, kTL, kNotB }, { 64, kNotRT, kRGBA, kA, 1, kTL, kNotB }, kDontShare },
  171. { { 64, kNotRT, kRGBA, kA, 1, kTL, kNotB }, { 64, kRT, kRGBA, kA, 1, kTL, kNotB }, kDontShare },
  172. // Two non-overlapping intervals w/ different origins should share
  173. { { 64, kRT, kRGBA, kA, 1, kTL, kNotB }, { 64, kRT, kRGBA, kA, 1, kBL, kNotB }, kShare },
  174. };
  175. for (auto test : gNonOverlappingTests) {
  176. sk_sp<GrSurfaceProxy> p1 = make_deferred(proxyProvider, caps, test.fP1);
  177. sk_sp<GrSurfaceProxy> p2 = make_deferred(proxyProvider, caps, test.fP2);
  178. if (!p1 || !p2) {
  179. continue; // creation can fail (i.e., for msaa4 on iOS)
  180. }
  181. non_overlap_test(reporter, resourceProvider, std::move(p1), std::move(p2),
  182. test.fExpectation);
  183. }
  184. {
  185. // Wrapped backend textures should never be reused
  186. TestCase t[1] = {
  187. { { 64, kNotRT, kRGBA, kE, 1, kTL, kNotB }, { 64, kNotRT, kRGBA, kE, 1, kTL, kNotB }, kDontShare }
  188. };
  189. GrBackendTexture backEndTex;
  190. sk_sp<GrSurfaceProxy> p1 = make_backend(ctxInfo.grContext(), t[0].fP1, &backEndTex);
  191. sk_sp<GrSurfaceProxy> p2 = make_deferred(proxyProvider, caps, t[0].fP2);
  192. non_overlap_test(reporter, resourceProvider, std::move(p1), std::move(p2),
  193. t[0].fExpectation);
  194. cleanup_backend(ctxInfo.grContext(), backEndTex);
  195. }
  196. }
  197. static void draw(GrContext* context) {
  198. SkImageInfo ii = SkImageInfo::Make(1024, 1024, kRGBA_8888_SkColorType, kPremul_SkAlphaType);
  199. sk_sp<SkSurface> s = SkSurface::MakeRenderTarget(context, SkBudgeted::kYes,
  200. ii, 1, kTopLeft_GrSurfaceOrigin, nullptr);
  201. SkCanvas* c = s->getCanvas();
  202. c->clear(SK_ColorBLACK);
  203. }
  204. DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ResourceAllocatorStressTest, reporter, ctxInfo) {
  205. GrContext* context = ctxInfo.grContext();
  206. int maxNum;
  207. size_t maxBytes;
  208. context->getResourceCacheLimits(&maxNum, &maxBytes);
  209. context->setResourceCacheLimits(0, 0); // We'll always be overbudget
  210. draw(context);
  211. draw(context);
  212. draw(context);
  213. draw(context);
  214. context->flush();
  215. context->setResourceCacheLimits(maxNum, maxBytes);
  216. }
  217. sk_sp<GrSurfaceProxy> make_lazy(GrProxyProvider* proxyProvider, const GrCaps* caps,
  218. const ProxyParams& p, bool deinstantiate) {
  219. GrPixelConfig config = GrColorTypeToPixelConfig(p.fColorType);
  220. GrSurfaceDesc desc;
  221. desc.fWidth = p.fSize;
  222. desc.fHeight = p.fSize;
  223. desc.fConfig = config;
  224. SkBackingFit fit = p.fFit;
  225. auto callback = [fit, desc, p](GrResourceProvider* resourceProvider) {
  226. sk_sp<GrTexture> texture;
  227. if (fit == SkBackingFit::kApprox) {
  228. texture = resourceProvider->createApproxTexture(
  229. desc, p.fRenderable, p.fSampleCnt, GrProtected::kNo,
  230. GrResourceProvider::Flags::kNoPendingIO);
  231. } else {
  232. texture = resourceProvider->createTexture(desc, p.fRenderable, p.fSampleCnt,
  233. SkBudgeted::kNo, GrProtected::kNo,
  234. GrResourceProvider::Flags::kNoPendingIO);
  235. }
  236. return GrSurfaceProxy::LazyInstantiationResult(std::move(texture));
  237. };
  238. const GrBackendFormat format = caps->getBackendFormatFromColorType(p.fColorType);
  239. auto lazyType = deinstantiate ? GrSurfaceProxy::LazyInstantiationType ::kDeinstantiate
  240. : GrSurfaceProxy::LazyInstantiationType ::kSingleUse;
  241. GrInternalSurfaceFlags flags = GrInternalSurfaceFlags::kNone;
  242. return proxyProvider->createLazyProxy(callback, format, desc, p.fRenderable, p.fSampleCnt,
  243. p.fOrigin, GrMipMapped::kNo, flags, p.fFit, p.fBudgeted,
  244. GrProtected::kNo, lazyType);
  245. }
  246. DEF_GPUTEST_FOR_RENDERING_CONTEXTS(LazyDeinstantiation, reporter, ctxInfo) {
  247. GrContext* context = ctxInfo.grContext();
  248. GrResourceProvider* resourceProvider = ctxInfo.grContext()->priv().resourceProvider();
  249. ProxyParams texParams;
  250. texParams.fFit = SkBackingFit::kExact;
  251. texParams.fOrigin = kTopLeft_GrSurfaceOrigin;
  252. texParams.fColorType = GrColorType::kRGBA_8888;
  253. texParams.fRenderable = GrRenderable::kNo;
  254. texParams.fSampleCnt = 1;
  255. texParams.fSize = 100;
  256. texParams.fBudgeted = SkBudgeted::kNo;
  257. auto proxyProvider = context->priv().proxyProvider();
  258. auto caps = context->priv().caps();
  259. auto p0 = make_lazy(proxyProvider, caps, texParams, true);
  260. auto p1 = make_lazy(proxyProvider, caps, texParams, false);
  261. ProxyParams rtParams = texParams;
  262. rtParams.fRenderable = GrRenderable::kYes;
  263. rtParams.fFit = SkBackingFit::kApprox;
  264. auto p2 = make_lazy(proxyProvider, caps, rtParams, true);
  265. auto p3 = make_lazy(proxyProvider, caps, rtParams, false);
  266. GrDeinstantiateProxyTracker deinstantiateTracker;
  267. {
  268. GrResourceAllocator alloc(resourceProvider, &deinstantiateTracker SkDEBUGCODE(, 1));
  269. alloc.addInterval(p0.get(), 0, 1, GrResourceAllocator::ActualUse::kNo);
  270. alloc.addInterval(p1.get(), 0, 1, GrResourceAllocator::ActualUse::kNo);
  271. alloc.addInterval(p2.get(), 0, 1, GrResourceAllocator::ActualUse::kNo);
  272. alloc.addInterval(p3.get(), 0, 1, GrResourceAllocator::ActualUse::kNo);
  273. alloc.incOps();
  274. alloc.markEndOfOpList(0);
  275. alloc.determineRecyclability();
  276. int startIndex, stopIndex;
  277. GrResourceAllocator::AssignError error;
  278. alloc.assign(&startIndex, &stopIndex, &error);
  279. }
  280. deinstantiateTracker.deinstantiateAllProxies();
  281. REPORTER_ASSERT(reporter, !p0->isInstantiated());
  282. REPORTER_ASSERT(reporter, p1->isInstantiated());
  283. REPORTER_ASSERT(reporter, !p2->isInstantiated());
  284. REPORTER_ASSERT(reporter, p3->isInstantiated());
  285. }
  286. // Set up so there are two opLists that need to be flushed but the resource allocator thinks
  287. // it is over budget. The two opLists should be flushed separately and the opList indices
  288. // returned from assign should be correct.
  289. DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ResourceAllocatorOverBudgetTest, reporter, ctxInfo) {
  290. GrContext* context = ctxInfo.grContext();
  291. const GrCaps* caps = context->priv().caps();
  292. GrProxyProvider* proxyProvider = context->priv().proxyProvider();
  293. GrResourceProvider* resourceProvider = context->priv().resourceProvider();
  294. int origMaxNum;
  295. size_t origMaxBytes;
  296. context->getResourceCacheLimits(&origMaxNum, &origMaxBytes);
  297. // Force the resource allocator to always believe it is over budget
  298. context->setResourceCacheLimits(0, 0);
  299. const ProxyParams params = { 64, GrRenderable::kNo, GrColorType::kRGBA_8888,
  300. SkBackingFit::kExact, 1, kTopLeft_GrSurfaceOrigin,
  301. SkBudgeted::kYes };
  302. {
  303. sk_sp<GrSurfaceProxy> p1 = make_deferred(proxyProvider, caps, params);
  304. sk_sp<GrSurfaceProxy> p2 = make_deferred(proxyProvider, caps, params);
  305. sk_sp<GrSurfaceProxy> p3 = make_deferred(proxyProvider, caps, params);
  306. sk_sp<GrSurfaceProxy> p4 = make_deferred(proxyProvider, caps, params);
  307. GrDeinstantiateProxyTracker deinstantiateTracker;
  308. GrResourceAllocator alloc(resourceProvider, &deinstantiateTracker SkDEBUGCODE(, 2));
  309. alloc.addInterval(p1.get(), 0, 0, GrResourceAllocator::ActualUse::kYes);
  310. alloc.incOps();
  311. alloc.addInterval(p2.get(), 1, 1, GrResourceAllocator::ActualUse::kYes);
  312. alloc.incOps();
  313. alloc.markEndOfOpList(0);
  314. alloc.addInterval(p3.get(), 2, 2, GrResourceAllocator::ActualUse::kYes);
  315. alloc.incOps();
  316. alloc.addInterval(p4.get(), 3, 3, GrResourceAllocator::ActualUse::kYes);
  317. alloc.incOps();
  318. alloc.markEndOfOpList(1);
  319. int startIndex, stopIndex;
  320. GrResourceAllocator::AssignError error;
  321. alloc.determineRecyclability();
  322. alloc.assign(&startIndex, &stopIndex, &error);
  323. REPORTER_ASSERT(reporter, GrResourceAllocator::AssignError::kNoError == error);
  324. REPORTER_ASSERT(reporter, 0 == startIndex && 1 == stopIndex);
  325. alloc.assign(&startIndex, &stopIndex, &error);
  326. REPORTER_ASSERT(reporter, GrResourceAllocator::AssignError::kNoError == error);
  327. REPORTER_ASSERT(reporter, 1 == startIndex && 2 == stopIndex);
  328. }
  329. context->setResourceCacheLimits(origMaxNum, origMaxBytes);
  330. }