123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404 |
- /*
- * Copyright 2017 Google Inc.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
- #include "include/core/SkTypes.h"
- #include "tests/Test.h"
- #include "include/gpu/GrTexture.h"
- #include "src/gpu/GrContextPriv.h"
- #include "src/gpu/GrDeinstantiateProxyTracker.h"
- #include "src/gpu/GrGpu.h"
- #include "src/gpu/GrProxyProvider.h"
- #include "src/gpu/GrResourceAllocator.h"
- #include "src/gpu/GrResourceProvider.h"
- #include "src/gpu/GrSurfaceProxyPriv.h"
- #include "src/gpu/GrTextureProxy.h"
- #include "include/core/SkSurface.h"
- struct ProxyParams {
- int fSize;
- GrRenderable fRenderable;
- GrColorType fColorType;
- SkBackingFit fFit;
- int fSampleCnt;
- GrSurfaceOrigin fOrigin;
- SkBudgeted fBudgeted;
- // TODO: do we care about mipmapping
- };
- static sk_sp<GrSurfaceProxy> make_deferred(GrProxyProvider* proxyProvider, const GrCaps* caps,
- const ProxyParams& p) {
- GrPixelConfig config = GrColorTypeToPixelConfig(p.fColorType);
- GrSurfaceDesc desc;
- desc.fWidth = p.fSize;
- desc.fHeight = p.fSize;
- desc.fConfig = config;
- const GrBackendFormat format = caps->getBackendFormatFromColorType(p.fColorType);
- return proxyProvider->createProxy(format, desc, p.fRenderable, p.fSampleCnt, p.fOrigin, p.fFit,
- p.fBudgeted, GrProtected::kNo);
- }
- static sk_sp<GrSurfaceProxy> make_backend(GrContext* context, const ProxyParams& p,
- GrBackendTexture* backendTex) {
- GrProxyProvider* proxyProvider = context->priv().proxyProvider();
- SkColorType skColorType = GrColorTypeToSkColorType(p.fColorType);
- SkASSERT(SkColorType::kUnknown_SkColorType != skColorType);
- *backendTex = context->createBackendTexture(p.fSize, p.fSize, skColorType,
- SkColors::kTransparent,
- GrMipMapped::kNo, GrRenderable::kNo,
- GrProtected::kNo);
- if (!backendTex->isValid()) {
- return nullptr;
- }
- return proxyProvider->wrapBackendTexture(*backendTex, p.fColorType, p.fOrigin,
- kBorrow_GrWrapOwnership, GrWrapCacheable::kNo,
- kRead_GrIOType);
- }
- static void cleanup_backend(GrContext* context, const GrBackendTexture& backendTex) {
- context->deleteBackendTexture(backendTex);
- }
- // Basic test that two proxies with overlapping intervals and compatible descriptors are
- // assigned different GrSurfaces.
- static void overlap_test(skiatest::Reporter* reporter, GrResourceProvider* resourceProvider,
- sk_sp<GrSurfaceProxy> p1, sk_sp<GrSurfaceProxy> p2,
- bool expectedResult) {
- GrDeinstantiateProxyTracker deinstantiateTracker;
- GrResourceAllocator alloc(resourceProvider, &deinstantiateTracker SkDEBUGCODE(, 1));
- alloc.addInterval(p1.get(), 0, 4, GrResourceAllocator::ActualUse::kYes);
- alloc.incOps();
- alloc.addInterval(p2.get(), 1, 2, GrResourceAllocator::ActualUse::kYes);
- alloc.incOps();
- alloc.markEndOfOpList(0);
- alloc.determineRecyclability();
- int startIndex, stopIndex;
- GrResourceAllocator::AssignError error;
- alloc.assign(&startIndex, &stopIndex, &error);
- REPORTER_ASSERT(reporter, GrResourceAllocator::AssignError::kNoError == error);
- REPORTER_ASSERT(reporter, p1->peekSurface());
- REPORTER_ASSERT(reporter, p2->peekSurface());
- bool doTheBackingStoresMatch = p1->underlyingUniqueID() == p2->underlyingUniqueID();
- REPORTER_ASSERT(reporter, expectedResult == doTheBackingStoresMatch);
- }
- // Test various cases when two proxies do not have overlapping intervals.
- // This mainly acts as a test of the ResourceAllocator's free pool.
- static void non_overlap_test(skiatest::Reporter* reporter, GrResourceProvider* resourceProvider,
- sk_sp<GrSurfaceProxy> p1, sk_sp<GrSurfaceProxy> p2,
- bool expectedResult) {
- GrDeinstantiateProxyTracker deinstantiateTracker;
- GrResourceAllocator alloc(resourceProvider, &deinstantiateTracker SkDEBUGCODE(, 1));
- alloc.incOps();
- alloc.incOps();
- alloc.incOps();
- alloc.incOps();
- alloc.incOps();
- alloc.incOps();
- alloc.addInterval(p1.get(), 0, 2, GrResourceAllocator::ActualUse::kYes);
- alloc.addInterval(p2.get(), 3, 5, GrResourceAllocator::ActualUse::kYes);
- alloc.markEndOfOpList(0);
- alloc.determineRecyclability();
- int startIndex, stopIndex;
- GrResourceAllocator::AssignError error;
- alloc.assign(&startIndex, &stopIndex, &error);
- REPORTER_ASSERT(reporter, GrResourceAllocator::AssignError::kNoError == error);
- REPORTER_ASSERT(reporter, p1->peekSurface());
- REPORTER_ASSERT(reporter, p2->peekSurface());
- bool doTheBackingStoresMatch = p1->underlyingUniqueID() == p2->underlyingUniqueID();
- REPORTER_ASSERT(reporter, expectedResult == doTheBackingStoresMatch);
- }
- DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ResourceAllocatorTest, reporter, ctxInfo) {
- const GrCaps* caps = ctxInfo.grContext()->priv().caps();
- GrProxyProvider* proxyProvider = ctxInfo.grContext()->priv().proxyProvider();
- GrResourceProvider* resourceProvider = ctxInfo.grContext()->priv().resourceProvider();
- struct TestCase {
- ProxyParams fP1;
- ProxyParams fP2;
- bool fExpectation;
- };
- constexpr GrRenderable kRT = GrRenderable::kYes;
- constexpr GrRenderable kNotRT = GrRenderable::kNo;
- constexpr bool kShare = true;
- constexpr bool kDontShare = false;
- // Non-RT GrSurfaces are never recycled on some platforms.
- bool kConditionallyShare = resourceProvider->caps()->reuseScratchTextures();
- const GrColorType kRGBA = GrColorType::kRGBA_8888;
- const GrColorType kBGRA = GrColorType::kBGRA_8888;
- const SkBackingFit kE = SkBackingFit::kExact;
- const SkBackingFit kA = SkBackingFit::kApprox;
- const GrSurfaceOrigin kTL = kTopLeft_GrSurfaceOrigin;
- const GrSurfaceOrigin kBL = kBottomLeft_GrSurfaceOrigin;
- const SkBudgeted kNotB = SkBudgeted::kNo;
- //--------------------------------------------------------------------------------------------
- TestCase gOverlappingTests[] = {
- //----------------------------------------------------------------------------------------
- // Two proxies with overlapping intervals and compatible descriptors should never share
- // RT version
- { { 64, kRT, kRGBA, kA, 1, kTL, kNotB }, { 64, kRT, kRGBA, kA, 1, kTL, kNotB }, kDontShare },
- // non-RT version
- { { 64, kNotRT, kRGBA, kA, 1, kTL, kNotB }, { 64, kNotRT, kRGBA, kA, 1, kTL, kNotB }, kDontShare },
- };
- for (auto test : gOverlappingTests) {
- sk_sp<GrSurfaceProxy> p1 = make_deferred(proxyProvider, caps, test.fP1);
- sk_sp<GrSurfaceProxy> p2 = make_deferred(proxyProvider, caps, test.fP2);
- overlap_test(reporter, resourceProvider, std::move(p1), std::move(p2), test.fExpectation);
- }
- int k2 = ctxInfo.grContext()->priv().caps()->getRenderTargetSampleCount(
- 2, kRGBA_8888_GrPixelConfig);
- int k4 = ctxInfo.grContext()->priv().caps()->getRenderTargetSampleCount(
- 4, kRGBA_8888_GrPixelConfig);
- //--------------------------------------------------------------------------------------------
- TestCase gNonOverlappingTests[] = {
- //----------------------------------------------------------------------------------------
- // Two non-overlapping intervals w/ compatible proxies should share
- // both same size & approx
- { { 64, kRT, kRGBA, kA, 1, kTL, kNotB }, { 64, kRT, kRGBA, kA, 1, kTL, kNotB }, kShare },
- { { 64, kNotRT, kRGBA, kA, 1, kTL, kNotB }, { 64, kNotRT, kRGBA, kA, 1, kTL, kNotB }, kConditionallyShare },
- // diffs sizes but still approx
- { { 64, kRT, kRGBA, kA, 1, kTL, kNotB }, { 50, kRT, kRGBA, kA, 1, kTL, kNotB }, kShare },
- { { 64, kNotRT, kRGBA, kA, 1, kTL, kNotB }, { 50, kNotRT, kRGBA, kA, 1, kTL, kNotB }, kConditionallyShare },
- // sames sizes but exact
- { { 64, kRT, kRGBA, kE, 1, kTL, kNotB }, { 64, kRT, kRGBA, kE, 1, kTL, kNotB }, kShare },
- { { 64, kNotRT, kRGBA, kE, 1, kTL, kNotB }, { 64, kNotRT, kRGBA, kE, 1, kTL, kNotB }, kConditionallyShare },
- //----------------------------------------------------------------------------------------
- // Two non-overlapping intervals w/ different exact sizes should not share
- { { 56, kRT, kRGBA, kE, 1, kTL, kNotB }, { 54, kRT, kRGBA, kE, 1, kTL, kNotB }, kDontShare },
- // Two non-overlapping intervals w/ _very different_ approx sizes should not share
- { { 255, kRT, kRGBA, kA, 1, kTL, kNotB }, { 127, kRT, kRGBA, kA, 1, kTL, kNotB }, kDontShare },
- // Two non-overlapping intervals w/ different MSAA sample counts should not share
- { { 64, kRT, kRGBA, kA, k2, kTL, kNotB },{ 64, kRT, kRGBA, kA, k4,kTL, kNotB}, k2 == k4 },
- // Two non-overlapping intervals w/ different configs should not share
- { { 64, kRT, kRGBA, kA, 1, kTL, kNotB }, { 64, kRT, kBGRA, kA, 1, kTL, kNotB }, kDontShare },
- // Two non-overlapping intervals w/ different RT classifications should never share
- { { 64, kRT, kRGBA, kA, 1, kTL, kNotB }, { 64, kNotRT, kRGBA, kA, 1, kTL, kNotB }, kDontShare },
- { { 64, kNotRT, kRGBA, kA, 1, kTL, kNotB }, { 64, kRT, kRGBA, kA, 1, kTL, kNotB }, kDontShare },
- // Two non-overlapping intervals w/ different origins should share
- { { 64, kRT, kRGBA, kA, 1, kTL, kNotB }, { 64, kRT, kRGBA, kA, 1, kBL, kNotB }, kShare },
- };
- for (auto test : gNonOverlappingTests) {
- sk_sp<GrSurfaceProxy> p1 = make_deferred(proxyProvider, caps, test.fP1);
- sk_sp<GrSurfaceProxy> p2 = make_deferred(proxyProvider, caps, test.fP2);
- if (!p1 || !p2) {
- continue; // creation can fail (i.e., for msaa4 on iOS)
- }
- non_overlap_test(reporter, resourceProvider, std::move(p1), std::move(p2),
- test.fExpectation);
- }
- {
- // Wrapped backend textures should never be reused
- TestCase t[1] = {
- { { 64, kNotRT, kRGBA, kE, 1, kTL, kNotB }, { 64, kNotRT, kRGBA, kE, 1, kTL, kNotB }, kDontShare }
- };
- GrBackendTexture backEndTex;
- sk_sp<GrSurfaceProxy> p1 = make_backend(ctxInfo.grContext(), t[0].fP1, &backEndTex);
- sk_sp<GrSurfaceProxy> p2 = make_deferred(proxyProvider, caps, t[0].fP2);
- non_overlap_test(reporter, resourceProvider, std::move(p1), std::move(p2),
- t[0].fExpectation);
- cleanup_backend(ctxInfo.grContext(), backEndTex);
- }
- }
- static void draw(GrContext* context) {
- SkImageInfo ii = SkImageInfo::Make(1024, 1024, kRGBA_8888_SkColorType, kPremul_SkAlphaType);
- sk_sp<SkSurface> s = SkSurface::MakeRenderTarget(context, SkBudgeted::kYes,
- ii, 1, kTopLeft_GrSurfaceOrigin, nullptr);
- SkCanvas* c = s->getCanvas();
- c->clear(SK_ColorBLACK);
- }
- DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ResourceAllocatorStressTest, reporter, ctxInfo) {
- GrContext* context = ctxInfo.grContext();
- int maxNum;
- size_t maxBytes;
- context->getResourceCacheLimits(&maxNum, &maxBytes);
- context->setResourceCacheLimits(0, 0); // We'll always be overbudget
- draw(context);
- draw(context);
- draw(context);
- draw(context);
- context->flush();
- context->setResourceCacheLimits(maxNum, maxBytes);
- }
- sk_sp<GrSurfaceProxy> make_lazy(GrProxyProvider* proxyProvider, const GrCaps* caps,
- const ProxyParams& p, bool deinstantiate) {
- GrPixelConfig config = GrColorTypeToPixelConfig(p.fColorType);
- GrSurfaceDesc desc;
- desc.fWidth = p.fSize;
- desc.fHeight = p.fSize;
- desc.fConfig = config;
- SkBackingFit fit = p.fFit;
- auto callback = [fit, desc, p](GrResourceProvider* resourceProvider) {
- sk_sp<GrTexture> texture;
- if (fit == SkBackingFit::kApprox) {
- texture = resourceProvider->createApproxTexture(
- desc, p.fRenderable, p.fSampleCnt, GrProtected::kNo,
- GrResourceProvider::Flags::kNoPendingIO);
- } else {
- texture = resourceProvider->createTexture(desc, p.fRenderable, p.fSampleCnt,
- SkBudgeted::kNo, GrProtected::kNo,
- GrResourceProvider::Flags::kNoPendingIO);
- }
- return GrSurfaceProxy::LazyInstantiationResult(std::move(texture));
- };
- const GrBackendFormat format = caps->getBackendFormatFromColorType(p.fColorType);
- auto lazyType = deinstantiate ? GrSurfaceProxy::LazyInstantiationType ::kDeinstantiate
- : GrSurfaceProxy::LazyInstantiationType ::kSingleUse;
- GrInternalSurfaceFlags flags = GrInternalSurfaceFlags::kNone;
- return proxyProvider->createLazyProxy(callback, format, desc, p.fRenderable, p.fSampleCnt,
- p.fOrigin, GrMipMapped::kNo, flags, p.fFit, p.fBudgeted,
- GrProtected::kNo, lazyType);
- }
- DEF_GPUTEST_FOR_RENDERING_CONTEXTS(LazyDeinstantiation, reporter, ctxInfo) {
- GrContext* context = ctxInfo.grContext();
- GrResourceProvider* resourceProvider = ctxInfo.grContext()->priv().resourceProvider();
- ProxyParams texParams;
- texParams.fFit = SkBackingFit::kExact;
- texParams.fOrigin = kTopLeft_GrSurfaceOrigin;
- texParams.fColorType = GrColorType::kRGBA_8888;
- texParams.fRenderable = GrRenderable::kNo;
- texParams.fSampleCnt = 1;
- texParams.fSize = 100;
- texParams.fBudgeted = SkBudgeted::kNo;
- auto proxyProvider = context->priv().proxyProvider();
- auto caps = context->priv().caps();
- auto p0 = make_lazy(proxyProvider, caps, texParams, true);
- auto p1 = make_lazy(proxyProvider, caps, texParams, false);
- ProxyParams rtParams = texParams;
- rtParams.fRenderable = GrRenderable::kYes;
- rtParams.fFit = SkBackingFit::kApprox;
- auto p2 = make_lazy(proxyProvider, caps, rtParams, true);
- auto p3 = make_lazy(proxyProvider, caps, rtParams, false);
- GrDeinstantiateProxyTracker deinstantiateTracker;
- {
- GrResourceAllocator alloc(resourceProvider, &deinstantiateTracker SkDEBUGCODE(, 1));
- alloc.addInterval(p0.get(), 0, 1, GrResourceAllocator::ActualUse::kNo);
- alloc.addInterval(p1.get(), 0, 1, GrResourceAllocator::ActualUse::kNo);
- alloc.addInterval(p2.get(), 0, 1, GrResourceAllocator::ActualUse::kNo);
- alloc.addInterval(p3.get(), 0, 1, GrResourceAllocator::ActualUse::kNo);
- alloc.incOps();
- alloc.markEndOfOpList(0);
- alloc.determineRecyclability();
- int startIndex, stopIndex;
- GrResourceAllocator::AssignError error;
- alloc.assign(&startIndex, &stopIndex, &error);
- }
- deinstantiateTracker.deinstantiateAllProxies();
- REPORTER_ASSERT(reporter, !p0->isInstantiated());
- REPORTER_ASSERT(reporter, p1->isInstantiated());
- REPORTER_ASSERT(reporter, !p2->isInstantiated());
- REPORTER_ASSERT(reporter, p3->isInstantiated());
- }
- // Set up so there are two opLists that need to be flushed but the resource allocator thinks
- // it is over budget. The two opLists should be flushed separately and the opList indices
- // returned from assign should be correct.
- DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ResourceAllocatorOverBudgetTest, reporter, ctxInfo) {
- GrContext* context = ctxInfo.grContext();
- const GrCaps* caps = context->priv().caps();
- GrProxyProvider* proxyProvider = context->priv().proxyProvider();
- GrResourceProvider* resourceProvider = context->priv().resourceProvider();
- int origMaxNum;
- size_t origMaxBytes;
- context->getResourceCacheLimits(&origMaxNum, &origMaxBytes);
- // Force the resource allocator to always believe it is over budget
- context->setResourceCacheLimits(0, 0);
- const ProxyParams params = { 64, GrRenderable::kNo, GrColorType::kRGBA_8888,
- SkBackingFit::kExact, 1, kTopLeft_GrSurfaceOrigin,
- SkBudgeted::kYes };
- {
- sk_sp<GrSurfaceProxy> p1 = make_deferred(proxyProvider, caps, params);
- sk_sp<GrSurfaceProxy> p2 = make_deferred(proxyProvider, caps, params);
- sk_sp<GrSurfaceProxy> p3 = make_deferred(proxyProvider, caps, params);
- sk_sp<GrSurfaceProxy> p4 = make_deferred(proxyProvider, caps, params);
- GrDeinstantiateProxyTracker deinstantiateTracker;
- GrResourceAllocator alloc(resourceProvider, &deinstantiateTracker SkDEBUGCODE(, 2));
- alloc.addInterval(p1.get(), 0, 0, GrResourceAllocator::ActualUse::kYes);
- alloc.incOps();
- alloc.addInterval(p2.get(), 1, 1, GrResourceAllocator::ActualUse::kYes);
- alloc.incOps();
- alloc.markEndOfOpList(0);
- alloc.addInterval(p3.get(), 2, 2, GrResourceAllocator::ActualUse::kYes);
- alloc.incOps();
- alloc.addInterval(p4.get(), 3, 3, GrResourceAllocator::ActualUse::kYes);
- alloc.incOps();
- alloc.markEndOfOpList(1);
- int startIndex, stopIndex;
- GrResourceAllocator::AssignError error;
- alloc.determineRecyclability();
- alloc.assign(&startIndex, &stopIndex, &error);
- REPORTER_ASSERT(reporter, GrResourceAllocator::AssignError::kNoError == error);
- REPORTER_ASSERT(reporter, 0 == startIndex && 1 == stopIndex);
- alloc.assign(&startIndex, &stopIndex, &error);
- REPORTER_ASSERT(reporter, GrResourceAllocator::AssignError::kNoError == error);
- REPORTER_ASSERT(reporter, 1 == startIndex && 2 == stopIndex);
- }
- context->setResourceCacheLimits(origMaxNum, origMaxBytes);
- }
|