blob: 0801d03a6c59c31a10ab4266dca935be0b1bc1a1 [file] [log] [blame]
* Copyright 2013 Google Inc.
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
#include "GrTest.h"
#include "GrGpuResourceCacheAccess.h"
#include "GrInOrderDrawBuffer.h"
#include "GrResourceCache.h"
#include "SkString.h"
void GrTestTarget::init(GrContext* ctx, GrDrawTarget* target) {
void GrContext::getTestTarget(GrTestTarget* tar) {
// We could create a proxy GrDrawTarget that passes through to fGpu until ~GrTextTarget() and
// then disconnects. This would help prevent test writers from mixing using the returned
// GrDrawTarget and regular drawing. We could also assert or fail in GrContext drawing methods
// until ~GrTestTarget().
tar->init(this, fDrawBuffer);
void GrContext::setMaxTextureSizeOverride(int maxTextureSizeOverride) {
fMaxTextureSizeOverride = maxTextureSizeOverride;
void GrContext::purgeAllUnlockedResources() {
void GrContext::dumpCacheStats(SkString* out) const {
void GrContext::printCacheStats() const {
SkString out;
SkDebugf("%s", out.c_str());
void GrContext::dumpGpuStats(SkString* out) const {
return fGpu->stats()->dump(out);
void GrContext::printGpuStats() const {
SkString out;
SkDebugf("%s", out.c_str());
void GrGpu::Stats::dump(SkString* out) {
out->appendf("Render Target Binds: %d\n", fRenderTargetBinds);
out->appendf("Shader Compilations: %d\n", fShaderCompilations);
out->appendf("Textures Created: %d\n", fTextureCreates);
out->appendf("Texture Uploads: %d\n", fTextureUploads);
out->appendf("Stencil Buffer Creates: %d\n", fStencilAttachmentCreates);
void GrResourceCache::dumpStats(SkString* out) const {
int locked = fNonpurgeableResources.count();
struct Stats {
int fScratch;
int fWrapped;
size_t fUnbudgetedSize;
Stats() : fScratch(0), fWrapped(0), fUnbudgetedSize(0) {}
void update(GrGpuResource* resource) {
if (resource->cacheAccess().isScratch()) {
if (resource->cacheAccess().isWrapped()) {
if (!resource->resourcePriv().isBudgeted()) {
fUnbudgetedSize += resource->gpuMemorySize();
Stats stats;
for (int i = 0; i < fNonpurgeableResources.count(); ++i) {
for (int i = 0; i < fPurgeableQueue.count(); ++i) {
float countUtilization = (100.f * fBudgetedCount) / fMaxCount;
float byteUtilization = (100.f * fBudgetedBytes) / fMaxBytes;
out->appendf("Budget: %d items %d bytes\n", fMaxCount, (int)fMaxBytes);
out->appendf("\t\tEntry Count: current %d"
" (%d budgeted, %d wrapped, %d locked, %d scratch %.2g%% full), high %d\n",
this->getResourceCount(), fBudgetedCount, stats.fWrapped, locked, stats.fScratch,
countUtilization, fHighWaterCount);
out->appendf("\t\tEntry Bytes: current %d (budgeted %d, %.2g%% full, %d unbudgeted) high %d\n",
SkToInt(fBytes), SkToInt(fBudgetedBytes), byteUtilization,
SkToInt(stats.fUnbudgetedSize), SkToInt(fHighWaterBytes));
void GrResourceCache::changeTimestamp(uint32_t newTimestamp) { fTimestamp = newTimestamp; }
// Code for the mock context. It's built on a mock GrGpu class that does nothing.
#include "GrInOrderDrawBuffer.h"
#include "GrGpu.h"
class GrPipeline;
class MockGpu : public GrGpu {
MockGpu(GrContext* context) : INHERITED(context) { fCaps.reset(SkNEW(GrCaps)); }
~MockGpu() override {}
bool canWriteTexturePixels(const GrTexture*, GrPixelConfig srcConfig) const override {
return true;
bool readPixelsWillPayForYFlip(GrRenderTarget* renderTarget,
int left, int top,
int width, int height,
GrPixelConfig config,
size_t rowBytes) const override { return false; }
void buildProgramDesc(GrProgramDesc*,const GrPrimitiveProcessor&,
const GrPipeline&,
const GrBatchTracker&) const override {}
void discard(GrRenderTarget*) override {}
bool canCopySurface(const GrSurface* dst,
const GrSurface* src,
const SkIRect& srcRect,
const SkIPoint& dstPoint) override { return false; };
bool copySurface(GrSurface* dst,
GrSurface* src,
const SkIRect& srcRect,
const SkIPoint& dstPoint) override { return false; };
bool initCopySurfaceDstDesc(const GrSurface* src, GrSurfaceDesc* desc) override {
return false;
void xferBarrier(GrRenderTarget*, GrXferBarrierType) override {}
void onResetContext(uint32_t resetBits) override {}
GrTexture* onCreateTexture(const GrSurfaceDesc& desc, GrGpuResource::LifeCycle lifeCycle,
const void* srcData, size_t rowBytes) override {
return NULL;
GrTexture* onCreateCompressedTexture(const GrSurfaceDesc& desc, GrGpuResource::LifeCycle,
const void* srcData) override {
return NULL;
GrTexture* onWrapBackendTexture(const GrBackendTextureDesc&) override { return NULL; }
GrRenderTarget* onWrapBackendRenderTarget(const GrBackendRenderTargetDesc&) override {
return NULL;
GrVertexBuffer* onCreateVertexBuffer(size_t size, bool dynamic) override { return NULL; }
GrIndexBuffer* onCreateIndexBuffer(size_t size, bool dynamic) override { return NULL; }
void onClear(GrRenderTarget*, const SkIRect* rect, GrColor color,
bool canIgnoreRect) override {}
void onClearStencilClip(GrRenderTarget*, const SkIRect& rect, bool insideClip) override {}
void onDraw(const DrawArgs&, const GrNonInstancedVertices&) override {}
void onStencilPath(const GrPath* path, const StencilPathState& state) override {}
void onDrawPath(const DrawArgs&, const GrPath*, const GrStencilSettings&) override {}
void onDrawPaths(const DrawArgs&,
const GrPathRange*,
const void* indices,
const float transformValues[],
int count,
const GrStencilSettings&) override {}
bool onReadPixels(GrRenderTarget* target,
int left, int top, int width, int height,
void* buffer,
size_t rowBytes) override {
return false;
bool onWriteTexturePixels(GrTexture* texture,
int left, int top, int width, int height,
GrPixelConfig config, const void* buffer,
size_t rowBytes) override {
return false;
void onResolveRenderTarget(GrRenderTarget* target) override { return; }
bool createStencilAttachmentForRenderTarget(GrRenderTarget*, int width, int height) override {
return false;
bool attachStencilAttachmentToRenderTarget(GrStencilAttachment*, GrRenderTarget*) override {
return false;
void clearStencil(GrRenderTarget* target) override {}
void didAddGpuTraceMarker() override {}
void didRemoveGpuTraceMarker() override {}
typedef GrGpu INHERITED;
GrContext* GrContext::CreateMockContext() {
GrContext* context = SkNEW_ARGS(GrContext, (Options()));
return context;
void GrContext::initMockContext() {
fGpu = SkNEW_ARGS(MockGpu, (this));
// We delete these because we want to test the cache starting with zero resources. Also, none of
// these objects are required for any of tests that use this context. TODO: make stop allocating
// resources in the buffer pools.
fDrawBuffer = NULL;