diff options
author | commit-bot@chromium.org <commit-bot@chromium.org@2bbb7eff-a529-9590-31e7-b0007b416f81> | 2013-11-21 06:21:58 +0000 |
---|---|---|
committer | commit-bot@chromium.org <commit-bot@chromium.org@2bbb7eff-a529-9590-31e7-b0007b416f81> | 2013-11-21 06:21:58 +0000 |
commit | 644629c1c7913a43ced172b98d56e0f471bc348b (patch) | |
tree | 944e9533b0ed138a623b2adf8c8dedd3fedafca2 /bench/GrResourceCacheBench.cpp | |
parent | bf6426120a8a9a034f37d37feaf942b1386b7a84 (diff) |
Implement a benchmark for GrResourceCache
Adds "grresourcecache_add" and "grresourcecache_find" bench tests to test
GrResourceCache::add and GrResourceCache::find. The tests work only
with GPU backends, since GrResourceCache needs an GrGpu.
Modifies bench tests to override SkBenchmark::isSuitableFor(Backend)
function that specifies what kind of backend the test is inteded
for. This replaces the previous "fIsRendering" flag that would
indicate test that did no rendering.
Adds SkCanvas::getGrContext() call to get the GrContext that the
canvas ends up drawing to. The member function solves a common
use-case that is also used in the benchmark added here.
R=mtklein@google.com, bsalomon@google.com
Author: kkinnunen@nvidia.com
Review URL: https://codereview.chromium.org/73643005
git-svn-id: http://skia.googlecode.com/svn/trunk@12334 2bbb7eff-a529-9590-31e7-b0007b416f81
Diffstat (limited to 'bench/GrResourceCacheBench.cpp')
-rw-r--r-- | bench/GrResourceCacheBench.cpp | 242 |
1 files changed, 242 insertions, 0 deletions
diff --git a/bench/GrResourceCacheBench.cpp b/bench/GrResourceCacheBench.cpp new file mode 100644 index 0000000000..ea8297dec5 --- /dev/null +++ b/bench/GrResourceCacheBench.cpp @@ -0,0 +1,242 @@ + +/* + * Copyright 2013 Google Inc. + * + * Use of this source code is governed by a BSD-style license that can be + * found in the LICENSE file. + */ + +#if SK_SUPPORT_GPU + +#include "GrContext.h" +#include "GrResource.h" +#include "GrResourceCache.h" +#include "GrStencilBuffer.h" +#include "GrTexture.h" +#include "SkBenchmark.h" +#include "SkCanvas.h" + +enum { + CACHE_SIZE_COUNT = 2048, + CACHE_SIZE_BYTES = 2 * 1024 * 1024, +}; + +class StencilResource : public GrResource { +public: + SK_DECLARE_INST_COUNT(StencilResource); + StencilResource(GrGpu* gpu, int id) + : INHERITED(gpu, false), + fID(id) { + } + ~StencilResource() { + this->release(); + } + + virtual size_t sizeInBytes() const SK_OVERRIDE { + return 100 + ((fID % 1 == 0) ? -5 : 6); + } + + static GrResourceKey ComputeKey(int width, int height, int sampleCnt) { + return GrStencilBuffer::ComputeKey(width, height, sampleCnt); + } + + int fID; + +private: + typedef GrResource INHERITED; +}; + +class TextureResource : public GrResource { +public: + SK_DECLARE_INST_COUNT(TextureResource); + TextureResource(GrGpu* gpu, int id) + : INHERITED(gpu, false), + fID(id) { + } + ~TextureResource() { + this->release(); + } + + virtual size_t sizeInBytes() const SK_OVERRIDE { + return 100 + ((fID % 1 == 0) ? -40 : 33); + } + + static GrResourceKey ComputeKey(const GrTextureDesc& desc) { + return GrTexture::ComputeScratchKey(desc); + } + + int fID; + +private: + typedef GrResource INHERITED; +}; + +SK_DEFINE_INST_COUNT(StencilResource) +SK_DEFINE_INST_COUNT(TextureResource) + +static void get_stencil(int i, int* w, int* h, int* s) { + *w = i % 1024; + *h = i * 2 % 1024; + *s = i % 1 == 0 ? 0 : 4; +} + +static void get_texture_desc(int i, GrTextureDesc* desc) { + desc->fFlags = kRenderTarget_GrTextureFlagBit | + kNoStencil_GrTextureFlagBit; + desc->fWidth = i % 1024; + desc->fHeight = i * 2 % 1024; + desc->fConfig = static_cast<GrPixelConfig>(i % (kLast_GrPixelConfig + 1)); + desc->fSampleCnt = i % 1 == 0 ? 0 : 4; +} + +static void populate_cache(GrResourceCache* cache, GrGpu* gpu, int resourceCount) { + for (int i = 0; i < resourceCount; ++i) { + int w, h, s; + get_stencil(i, &w, &h, &s); + GrResourceKey key = GrStencilBuffer::ComputeKey(w, h, s); + GrResource* resource = SkNEW_ARGS(StencilResource, (gpu, i)); + cache->purgeAsNeeded(1, resource->sizeInBytes()); + cache->addResource(key, resource); + resource->unref(); + } + + for (int i = 0; i < resourceCount; ++i) { + GrTextureDesc desc; + get_texture_desc(i, &desc); + GrResourceKey key = TextureResource::ComputeKey(desc); + GrResource* resource = SkNEW_ARGS(TextureResource, (gpu, i)); + cache->purgeAsNeeded(1, resource->sizeInBytes()); + cache->addResource(key, resource); + resource->unref(); + } +} + +static void check_cache_contents_or_die(GrResourceCache* cache, int k) { + // Benchmark find calls that succeed. + { + GrTextureDesc desc; + get_texture_desc(k, &desc); + GrResourceKey key = TextureResource::ComputeKey(desc); + GrResource* item = cache->find(key); + if (NULL == item) { + GrCrash("cache add does not work as expected"); + return; + } + if (static_cast<TextureResource*>(item)->fID != k) { + GrCrash("cache add does not work as expected"); + return; + } + } + { + int w, h, s; + get_stencil(k, &w, &h, &s); + GrResourceKey key = StencilResource::ComputeKey(w, h, s); + GrResource* item = cache->find(key); + if (NULL == item) { + GrCrash("cache add does not work as expected"); + return; + } + if (static_cast<TextureResource*>(item)->fID != k) { + GrCrash("cache add does not work as expected"); + return; + } + } + + // Benchmark also find calls that always fail. + { + GrTextureDesc desc; + get_texture_desc(k, &desc); + desc.fHeight |= 1; + GrResourceKey key = TextureResource::ComputeKey(desc); + GrResource* item = cache->find(key); + if (NULL != item) { + GrCrash("cache add does not work as expected"); + return; + } + } + { + int w, h, s; + get_stencil(k, &w, &h, &s); + h |= 1; + GrResourceKey key = StencilResource::ComputeKey(w, h, s); + GrResource* item = cache->find(key); + if (NULL != item) { + GrCrash("cache add does not work as expected"); + return; + } + } +} + +class GrResourceCacheBenchAdd : public SkBenchmark { + enum { + RESOURCE_COUNT = CACHE_SIZE_COUNT / 2, + DUPLICATE_COUNT = CACHE_SIZE_COUNT / 4, + }; + +public: + virtual bool isSuitableFor(Backend backend) SK_OVERRIDE { + return backend == kGPU_Backend; + } + +protected: + virtual const char* onGetName() SK_OVERRIDE { + return "grresourcecache_add"; + } + + virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE { + GrGpu* gpu = canvas->getGrContext()->getGpu(); + + for (int i = 0; i < this->getLoops(); ++i) { + GrResourceCache cache(CACHE_SIZE_COUNT, CACHE_SIZE_BYTES); + populate_cache(&cache, gpu, DUPLICATE_COUNT); + populate_cache(&cache, gpu, RESOURCE_COUNT); + + // Check that cache works. + for (int k = 0; k < RESOURCE_COUNT; k += 33) { + check_cache_contents_or_die(&cache, k); + } + cache.purgeAllUnlocked(); + } + } + +private: + typedef SkBenchmark INHERITED; +}; + +class GrResourceCacheBenchFind : public SkBenchmark { + enum { + RESOURCE_COUNT = (CACHE_SIZE_COUNT / 2) - 100, + DUPLICATE_COUNT = 100 + }; + +public: + virtual bool isSuitableFor(Backend backend) SK_OVERRIDE { + return backend == kGPU_Backend; + } + +protected: + virtual const char* onGetName() SK_OVERRIDE { + return "grresourcecache_find"; + } + + virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE { + GrGpu* gpu = canvas->getGrContext()->getGpu(); + GrResourceCache cache(CACHE_SIZE_COUNT, CACHE_SIZE_BYTES); + populate_cache(&cache, gpu, DUPLICATE_COUNT); + populate_cache(&cache, gpu, RESOURCE_COUNT); + + for (int i = 0; i < this->getLoops(); ++i) { + for (int k = 0; k < RESOURCE_COUNT; ++k) { + check_cache_contents_or_die(&cache, k); + } + } + } + +private: + typedef SkBenchmark INHERITED; +}; + +DEF_BENCH( return new GrResourceCacheBenchAdd(); ) +DEF_BENCH( return new GrResourceCacheBenchFind(); ) + +#endif |