blob: 02cea9f0a342601bfd502aca216204770784f39d [file] [log] [blame]
/*
* Copyright 2015 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"
#if defined(SK_GL)
#include "include/core/SkRefCnt.h"
#include "include/core/SkSize.h"
#include "include/core/SkString.h"
#include "include/core/SkTraceMemoryDump.h"
#include "include/gpu/GpuTypes.h"
#include "include/gpu/GrDirectContext.h"
#include "include/gpu/gl/GrGLTypes.h"
#include "include/private/gpu/ganesh/GrGLTypesPriv.h"
#include "include/private/gpu/ganesh/GrTypesPriv.h"
#include "src/gpu/ganesh/GrDirectContextPriv.h"
#include "src/gpu/ganesh/gl/GrGLBuffer.h"
#include "src/gpu/ganesh/gl/GrGLDefines_impl.h"
#include "src/gpu/ganesh/gl/GrGLGpu.h"
#include "src/gpu/ganesh/gl/GrGLRenderTarget.h"
#include "src/gpu/ganesh/gl/GrGLTexture.h"
#include "src/gpu/ganesh/gl/GrGLTextureRenderTarget.h"
#include "tests/CtsEnforcement.h"
#include "tests/Test.h"
#include <cstddef>
#include <cstdint>
#include <utility>
class SkDiscardableMemory;
struct GrContextOptions;
/*
* Build test for SkTraceMemoryDump.
*/
class TestSkTraceMemoryDump : public SkTraceMemoryDump {
public:
TestSkTraceMemoryDump(bool shouldDumpWrappedObjects)
: fShouldDumpWrappedObjects(shouldDumpWrappedObjects) {}
~TestSkTraceMemoryDump() override { }
void dumpNumericValue(const char* dumpName, const char* valueName, const char* units,
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(
const char* dumpName,
const SkDiscardableMemory& discardableMemoryObject) override { }
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;
};
void ValidateMemoryDumps(skiatest::Reporter* reporter, GrDirectContext* dContext,
size_t numDumpedObjects, size_t size, bool isOwned) {
// Note than one entry in the dumped objects is expected for the text blob cache.
TestSkTraceMemoryDump dump_with_wrapped(true /* shouldDumpWrappedObjects */);
dContext->dumpMemoryStatistics(&dump_with_wrapped);
REPORTER_ASSERT(reporter, numDumpedObjects == dump_with_wrapped.numDumpedObjects());
REPORTER_ASSERT(reporter, size == dump_with_wrapped.dumpedObjectsSize());
TestSkTraceMemoryDump dump_no_wrapped(false /* shouldDumpWrappedObjects */);
dContext->dumpMemoryStatistics(&dump_no_wrapped);
if (isOwned) {
REPORTER_ASSERT(reporter, numDumpedObjects == dump_no_wrapped.numDumpedObjects());
REPORTER_ASSERT(reporter, size == dump_no_wrapped.dumpedObjectsSize());
} else {
REPORTER_ASSERT(reporter, 1 == dump_no_wrapped.numDumpedObjects());
REPORTER_ASSERT(reporter, 0 == dump_no_wrapped.dumpedObjectsSize());
}
}
DEF_GANESH_TEST_FOR_GL_RENDERING_CONTEXTS(SkTraceMemoryDump_ownedGLBuffer,
reporter,
ctxInfo,
CtsEnforcement::kApiLevel_T) {
auto dContext = ctxInfo.directContext();
GrGLGpu* gpu = static_cast<GrGLGpu*>(dContext->priv().getGpu());
const size_t kMemorySize = 1024;
sk_sp<GrGLBuffer> buffer =
GrGLBuffer::Make(gpu, kMemorySize, GrGpuBufferType::kVertex, kDynamic_GrAccessPattern);
ValidateMemoryDumps(reporter, dContext, 2, kMemorySize, true /* isOwned */);
}
DEF_GANESH_TEST_FOR_GL_RENDERING_CONTEXTS(SkTraceMemoryDump_ownedGLTexture,
reporter,
ctxInfo,
CtsEnforcement::kApiLevel_T) {
auto dContext = ctxInfo.directContext();
GrGLGpu* gpu = static_cast<GrGLGpu*>(dContext->priv().getGpu());
GrGLTexture::Desc desc;
desc.fTarget = GR_GL_TEXTURE_2D;
desc.fID = 7; // Arbitrary, we don't actually use the texture.
desc.fFormat = GrGLFormat::kRGBA8;
desc.fOwnership = GrBackendObjectOwnership::kOwned;
desc.fSize = SkISize::Make(64, 64);
auto texture = sk_make_sp<GrGLTexture>(gpu,
skgpu::Budgeted::kNo,
desc,
GrMipmapStatus::kNotAllocated,
/*label=*/"SkTraceMemoryDump_ownedGLTexture");
ValidateMemoryDumps(reporter, dContext, 2, texture->gpuMemorySize(), true /* isOwned */);
}
DEF_GANESH_TEST_FOR_GL_RENDERING_CONTEXTS(SkTraceMemoryDump_unownedGLTexture,
reporter,
ctxInfo,
CtsEnforcement::kApiLevel_T) {
auto dContext = ctxInfo.directContext();
GrGLGpu* gpu = static_cast<GrGLGpu*>(dContext->priv().getGpu());
GrGLTexture::Desc desc;
desc.fTarget = GR_GL_TEXTURE_2D;
desc.fID = 7; // Arbitrary, we don't actually use the texture.
desc.fFormat = GrGLFormat::kRGBA8;
desc.fOwnership = GrBackendObjectOwnership::kBorrowed;
desc.fSize = SkISize::Make(64, 64);
auto params = sk_make_sp<GrGLTextureParameters>();
auto texture = GrGLTexture::MakeWrapped(gpu,
GrMipmapStatus::kNotAllocated,
desc,
std::move(params),
GrWrapCacheable::kNo,
kRead_GrIOType,
/*label=*/{});
ValidateMemoryDumps(reporter, dContext, 2, texture->gpuMemorySize(), false /* isOwned */);
}
DEF_GANESH_TEST_FOR_GL_RENDERING_CONTEXTS(SkTraceMemoryDump_ownedGLRenderTarget,
reporter,
ctxInfo,
CtsEnforcement::kApiLevel_T) {
auto dContext = ctxInfo.directContext();
GrGLGpu* gpu = static_cast<GrGLGpu*>(dContext->priv().getGpu());
static constexpr auto kSize = SkISize::Make(64, 64);
GrGLRenderTarget::IDs rtIDs;
rtIDs.fMultisampleFBOID = 0;
rtIDs.fRTFBOOwnership = GrBackendObjectOwnership::kOwned;
rtIDs.fSingleSampleFBOID = 20;
rtIDs.fMSColorRenderbufferID = 0;
rtIDs.fTotalMemorySamplesPerPixel = 1;
sk_sp<GrGLRenderTarget> rt = GrGLRenderTarget::MakeWrapped(gpu,
kSize,
GrGLFormat::kRGBA8,
1,
rtIDs,
0,
/*label=*/{});
ValidateMemoryDumps(reporter, dContext, 2, rt->gpuMemorySize(), true /* isOwned */);
}
DEF_GANESH_TEST_FOR_GL_RENDERING_CONTEXTS(SkTraceMemoryDump_unownedGLRenderTarget,
reporter,
ctxInfo,
CtsEnforcement::kApiLevel_T) {
auto dContext = ctxInfo.directContext();
GrGLGpu* gpu = static_cast<GrGLGpu*>(dContext->priv().getGpu());
static constexpr auto kSize = SkISize::Make(64, 64);
GrGLRenderTarget::IDs rtIDs;
rtIDs.fMultisampleFBOID = 12;
rtIDs.fRTFBOOwnership = GrBackendObjectOwnership::kBorrowed;
rtIDs.fSingleSampleFBOID = 0;
rtIDs.fMSColorRenderbufferID = 0;
rtIDs.fTotalMemorySamplesPerPixel = 4;
sk_sp<GrGLRenderTarget> rt = GrGLRenderTarget::MakeWrapped(gpu,
kSize,
GrGLFormat::kRGBA8,
4,
rtIDs,
0,
/*label=*/{});
ValidateMemoryDumps(reporter, dContext, 2, rt->gpuMemorySize(), false /* isOwned */);
}
DEF_GANESH_TEST_FOR_GL_RENDERING_CONTEXTS(SkTraceMemoryDump_ownedGLTextureRenderTarget,
reporter,
ctxInfo,
CtsEnforcement::kApiLevel_T) {
auto dContext = ctxInfo.directContext();
GrGLGpu* gpu = static_cast<GrGLGpu*>(dContext->priv().getGpu());
static constexpr auto kSize = SkISize::Make(64, 64);
GrGLTexture::Desc texDesc;
texDesc.fSize = kSize;
texDesc.fTarget = GR_GL_TEXTURE_2D;
texDesc.fID = 17;
texDesc.fFormat = GrGLFormat::kRGBA8;
texDesc.fOwnership = GrBackendObjectOwnership::kOwned;
GrGLRenderTarget::IDs rtIDs;
rtIDs.fMultisampleFBOID = 12;
rtIDs.fRTFBOOwnership = GrBackendObjectOwnership::kOwned;
rtIDs.fSingleSampleFBOID = 20;
rtIDs.fMSColorRenderbufferID = 22;
rtIDs.fTotalMemorySamplesPerPixel = 9;
auto texRT = sk_make_sp<GrGLTextureRenderTarget>(
gpu,
skgpu::Budgeted::kYes,
8,
texDesc,
rtIDs,
GrMipmapStatus::kNotAllocated,
/*label=*/"SkTraceMemoryDump_ownedGLTextureRenderTarget");
ValidateMemoryDumps(reporter, dContext, 3, texRT->gpuMemorySize(), true /* isOwned */);
}
#endif // defined(SK_GL)