From af7700265b74123d8ad3de6dde0c21545453140b Mon Sep 17 00:00:00 2001 From: Eric Karl Date: Mon, 19 Mar 2018 13:04:03 -0700 Subject: Allow SkTraceMemoryDump to exclude wrapped objects Allow SkTraceMemoryDump to exclude wrapped objects from dumps. This helps avoid duplicate dumping when Skia is wrapping an external object which is already dumped externally. Bug: 795358 Change-Id: Icbda96b564c81b958d40f74693280ac7d5ba7332 Reviewed-on: https://skia-review.googlesource.com/114681 Reviewed-by: Brian Salomon Commit-Queue: Eric Karl --- tests/TraceMemoryDumpTest.cpp | 156 ++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 149 insertions(+), 7 deletions(-) (limited to 'tests/TraceMemoryDumpTest.cpp') diff --git a/tests/TraceMemoryDumpTest.cpp b/tests/TraceMemoryDumpTest.cpp index a8cdbfeb55..5cae99bca6 100644 --- a/tests/TraceMemoryDumpTest.cpp +++ b/tests/TraceMemoryDumpTest.cpp @@ -9,16 +9,32 @@ #include "Test.h" +// These tests are currently GPU-speicifc. +#if SK_SUPPORT_GPU +#include "GrContextPriv.h" +#include "GrRenderTarget.h" +#include "GrTexture.h" +#include "gl/GrGLBuffer.h" +#include "gl/GrGLDefines.h" +#include "gl/GrGLGpu.h" + /* * Build test for SkTraceMemoryDump. */ class TestSkTraceMemoryDump : public SkTraceMemoryDump { public: - TestSkTraceMemoryDump() { } + TestSkTraceMemoryDump(bool shouldDumpWrappedObjects) + : fShouldDumpWrappedObjects(shouldDumpWrappedObjects) {} ~TestSkTraceMemoryDump() override { } void dumpNumericValue(const char* dumpName, const char* valueName, const char* units, - uint64_t value) override { } + uint64_t value) override { + // Only count "size" dumps, others are just providing metadata. + if (SkString("size") == SkString(valueName)) { + ++fNumDumpedObjects; + fDumpedObjectsSize += value; + } + } void setMemoryBacking(const char* dumpName, const char* backingType, const char* backingObjectId) override { } void setDiscardableMemoryBacking( @@ -27,12 +43,138 @@ public: LevelOfDetail getRequestedDetails() const override { return SkTraceMemoryDump::kObjectsBreakdowns_LevelOfDetail; } + bool shouldDumpWrappedObjects() const override { return fShouldDumpWrappedObjects; } + + size_t numDumpedObjects() const { return fNumDumpedObjects; } + size_t dumpedObjectsSize() const { return fDumpedObjectsSize; } + +private: + bool fShouldDumpWrappedObjects; + size_t fNumDumpedObjects = 0; + size_t fDumpedObjectsSize = 0; }; -DEF_TEST(SkTraceMemoryDump, reporter) { - TestSkTraceMemoryDump x; - x.dumpNumericValue("foobar", "size", "bytes", 42); - if (x.getRequestedDetails() == SkTraceMemoryDump::kObjectsBreakdowns_LevelOfDetail) { - x.dumpNumericValue("foobar/object1", "size", "bytes", 23); +void ValidateMemoryDumps(skiatest::Reporter* reporter, GrContext* context, size_t size, + bool isOwned) { + TestSkTraceMemoryDump dump_with_wrapped(true /* shouldDumpWrappedObjects */); + context->dumpMemoryStatistics(&dump_with_wrapped); + REPORTER_ASSERT(reporter, 1 == dump_with_wrapped.numDumpedObjects()); + REPORTER_ASSERT(reporter, size == dump_with_wrapped.dumpedObjectsSize()); + + TestSkTraceMemoryDump dump_no_wrapped(false /* shouldDumpWrappedObjects */); + context->dumpMemoryStatistics(&dump_no_wrapped); + if (isOwned) { + REPORTER_ASSERT(reporter, 1 == dump_no_wrapped.numDumpedObjects()); + REPORTER_ASSERT(reporter, size == dump_no_wrapped.dumpedObjectsSize()); + } else { + REPORTER_ASSERT(reporter, 0 == dump_no_wrapped.numDumpedObjects()); + REPORTER_ASSERT(reporter, 0 == dump_no_wrapped.dumpedObjectsSize()); } } + +DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(SkTraceMemoryDump_ownedGLBuffer, reporter, ctxInfo) { + GrContext* context = ctxInfo.grContext(); + GrGLGpu* gpu = static_cast(context->contextPriv().getGpu()); + const size_t kMemorySize = 1024; + sk_sp buffer( + GrGLBuffer::Create(gpu, kMemorySize, kVertex_GrBufferType, kDynamic_GrAccessPattern)); + + ValidateMemoryDumps(reporter, context, kMemorySize, true /* isOwned */); +} + +DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(SkTraceMemoryDump_ownedGLTexture, reporter, ctxInfo) { + GrContext* context = ctxInfo.grContext(); + GrGLGpu* gpu = static_cast(context->contextPriv().getGpu()); + + GrSurfaceDesc desc; + desc.fFlags = kNone_GrSurfaceFlags; + desc.fWidth = 64; + desc.fHeight = 64; + desc.fConfig = kRGBA_8888_GrPixelConfig; + desc.fSampleCnt = 1; + + GrGLTextureInfo glInfo; + glInfo.fTarget = GR_GL_TEXTURE_2D; + glInfo.fID = 7; // Arbitrary, we don't actually use the texture. + glInfo.fFormat = GR_GL_RGBA8; + + GrGLTexture::IDDesc idDesc; + idDesc.fInfo = glInfo; + idDesc.fOwnership = GrBackendObjectOwnership::kOwned; + + auto texture = sk_make_sp(gpu, SkBudgeted::kNo, desc, idDesc, + GrMipMapsStatus::kNotAllocated); + + ValidateMemoryDumps(reporter, context, texture->gpuMemorySize(), true /* isOwned */); +} + +DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(SkTraceMemoryDump_unownedGLTexture, reporter, ctxInfo) { + GrContext* context = ctxInfo.grContext(); + GrGLGpu* gpu = static_cast(context->contextPriv().getGpu()); + + GrSurfaceDesc desc; + desc.fFlags = kNone_GrSurfaceFlags; + desc.fWidth = 64; + desc.fHeight = 64; + desc.fConfig = kRGBA_8888_GrPixelConfig; + desc.fSampleCnt = 1; + + GrGLTextureInfo glInfo; + glInfo.fTarget = GR_GL_TEXTURE_2D; + glInfo.fID = 7; // Arbitrary, we don't actually use the texture. + glInfo.fFormat = GR_GL_RGBA8; + + GrGLTexture::IDDesc idDesc; + idDesc.fInfo = glInfo; + idDesc.fOwnership = GrBackendObjectOwnership::kBorrowed; + + auto texture = GrGLTexture::MakeWrapped(gpu, desc, GrMipMapsStatus::kNotAllocated, idDesc); + + ValidateMemoryDumps(reporter, context, texture->gpuMemorySize(), false /* isOwned */); +} + +DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(SkTraceMemoryDump_ownedGLRenderTarget, reporter, ctxInfo) { + GrContext* context = ctxInfo.grContext(); + GrGLGpu* gpu = static_cast(context->contextPriv().getGpu()); + + GrSurfaceDesc sd; + sd.fFlags = kRenderTarget_GrSurfaceFlag; + sd.fWidth = 64; + sd.fHeight = 64; + sd.fConfig = kRGBA_8888_GrPixelConfig; + + GrGLRenderTarget::IDDesc iddesc; + iddesc.fRTFBOID = 20; + iddesc.fRTFBOOwnership = GrBackendObjectOwnership::kOwned; + iddesc.fTexFBOID = GrGLRenderTarget::kUnresolvableFBOID; + iddesc.fMSColorRenderbufferID = 22; + iddesc.fIsMixedSampled = false; + + sk_sp rt = GrGLRenderTarget::MakeWrapped(gpu, sd, iddesc, 0); + + ValidateMemoryDumps(reporter, context, rt->gpuMemorySize(), true /* isOwned */); +} + +DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(SkTraceMemoryDump_unownedGLRenderTarget, reporter, ctxInfo) { + GrContext* context = ctxInfo.grContext(); + GrGLGpu* gpu = static_cast(context->contextPriv().getGpu()); + + GrSurfaceDesc sd; + sd.fFlags = kRenderTarget_GrSurfaceFlag; + sd.fWidth = 64; + sd.fHeight = 64; + sd.fConfig = kRGBA_8888_GrPixelConfig; + + GrGLRenderTarget::IDDesc iddesc; + iddesc.fRTFBOID = 20; + iddesc.fRTFBOOwnership = GrBackendObjectOwnership::kBorrowed; + iddesc.fTexFBOID = GrGLRenderTarget::kUnresolvableFBOID; + iddesc.fMSColorRenderbufferID = 22; + iddesc.fIsMixedSampled = false; + + sk_sp rt = GrGLRenderTarget::MakeWrapped(gpu, sd, iddesc, 0); + + ValidateMemoryDumps(reporter, context, rt->gpuMemorySize(), false /* isOwned */); +} + +#endif -- cgit v1.2.3