bench/GrResourceCacheBench.cpp

   1
   2 /*
   3  * Copyright 2013 Google Inc.
   4  *
   5  * Use of this source code is governed by a BSD-style license that can be
   6  * found in the LICENSE file.
   7  */
   8
   9 #include "Benchmark.h"
  10
  11 #if SK_SUPPORT_GPU
  12
  13 #include "GrGpuResource.h"
  14 #include "GrGpuResourcePriv.h"
  15 #include "GrContext.h"
  16 #include "GrGpu.h"
  17 #include "GrResourceCache.h"
  18 #include "SkCanvas.h"
  19
  20 enum {
  21     CACHE_SIZE_COUNT = 4096,
  22 };
  23
  24 class BenchResource : public GrGpuResource {
  25 public:
  26     SK_DECLARE_INST_COUNT(BenchResource);
  27     BenchResource (GrGpu* gpu)
  28         : INHERITED(gpu, kCached_LifeCycle) {
  29         this->registerWithCache();
  30     }
  31
  32     static void ComputeKey(int i, GrUniqueKey* key) {
  33         static GrUniqueKey::Domain kDomain = GrUniqueKey::GenerateDomain();
  34         GrUniqueKey::Builder builder(key, kDomain, 1);
  35         builder[0] = i;
  36     }
  37
  38 private:
  39     size_t onGpuMemorySize() const SK_OVERRIDE { return 100; }
  40
  41     typedef GrGpuResource INHERITED;
  42 };
  43
  44 static void populate_cache(GrGpu* gpu, int resourceCount) {
  45     for (int i = 0; i < resourceCount; ++i) {
  46         GrUniqueKey key;
  47         BenchResource::ComputeKey(i, &key);
  48         GrGpuResource* resource = SkNEW_ARGS(BenchResource, (gpu));
  49         resource->resourcePriv().setUniqueKey(key);
  50         resource->unref();
  51     }
  52 }
  53
  54 class GrResourceCacheBenchAdd : public Benchmark {
  55 public:
  56     bool isSuitableFor(Backend backend) SK_OVERRIDE {
  57         return backend == kNonRendering_Backend;
  58     }
  59
  60 protected:
  61     const char* onGetName() SK_OVERRIDE {
  62         return "grresourcecache_add";
  63     }
  64
  65     void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
  66         SkAutoTUnref<GrContext> context(GrContext::CreateMockContext());
  67         if (NULL == context) {
  68             return;
  69         }
  70         // Set the cache budget to be very large so no purging occurs.
  71         context->setResourceCacheLimits(CACHE_SIZE_COUNT, 1 << 30);
  72
  73         GrResourceCache* cache = context->getResourceCache();
  74
  75         // Make sure the cache is empty.
  76         cache->purgeAllUnlocked();
  77         SkASSERT(0 == cache->getResourceCount() && 0 == cache->getResourceBytes());
  78
  79         GrGpu* gpu = context->getGpu();
  80
  81         for (int i = 0; i < loops; ++i) {
  82             populate_cache(gpu, CACHE_SIZE_COUNT);
  83             SkASSERT(CACHE_SIZE_COUNT == cache->getResourceCount());
  84         }
  85     }
  86
  87 private:
  88     typedef Benchmark INHERITED;
  89 };
  90
  91 class GrResourceCacheBenchFind : public Benchmark {
  92 public:
  93     bool isSuitableFor(Backend backend) SK_OVERRIDE {
  94         return backend == kNonRendering_Backend;
  95     }
  96
  97 protected:
  98     const char* onGetName() SK_OVERRIDE {
  99         return "grresourcecache_find";
 100     }
 101
 102     void onPreDraw() SK_OVERRIDE {
 103         fContext.reset(GrContext::CreateMockContext());
 104         if (!fContext) {
 105             return;
 106         }
 107         // Set the cache budget to be very large so no purging occurs.
 108         fContext->setResourceCacheLimits(CACHE_SIZE_COUNT, 1 << 30);
 109
 110         GrResourceCache* cache = fContext->getResourceCache();
 111
 112         // Make sure the cache is empty.
 113         cache->purgeAllUnlocked();
 114         SkASSERT(0 == cache->getResourceCount() && 0 == cache->getResourceBytes());
 115
 116         GrGpu* gpu = fContext->getGpu();
 117
 118         populate_cache(gpu, CACHE_SIZE_COUNT);
 119     }
 120
 121     void onDraw(const int loops, SkCanvas* canvas) SK_OVERRIDE {
 122         if (!fContext) {
 123             return;
 124         }
 125         GrResourceCache* cache = fContext->getResourceCache();
 126         SkASSERT(CACHE_SIZE_COUNT == cache->getResourceCount());
 127         for (int i = 0; i < loops; ++i) {
 128             for (int k = 0; k < CACHE_SIZE_COUNT; ++k) {
 129                 GrUniqueKey key;
 130                 BenchResource::ComputeKey(k, &key);
 131                 SkAutoTUnref<GrGpuResource> resource(cache->findAndRefUniqueResource(key));
 132                 SkASSERT(resource);
 133             }
 134         }
 135     }
 136
 137 private:
 138     SkAutoTUnref<GrContext> fContext;
 139     typedef Benchmark INHERITED;
 140 };
 141
 142 DEF_BENCH( return new GrResourceCacheBenchAdd(); )
 143 DEF_BENCH( return new GrResourceCacheBenchFind(); )
 144
 145 #endif