Split GrResource into GrCacheable/GrGpuObject

bench/GrResourceCacheBench.cpp

 
 /*
  * 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 "GrCacheable.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 {
+class StencilResource : public GrCacheable {
 public:
     SK_DECLARE_INST_COUNT(StencilResource);
-    StencilResource(GrGpu* gpu, int id)
-        : INHERITED(gpu, false),
-          fID(id) {
-    }
-    ~StencilResource() {
-        this->release();
+    StencilResource(int id)
+        : fID(id) {
     }
 
-    virtual size_t sizeInBytes() const SK_OVERRIDE {
+    virtual size_t gpuMemorySize() const SK_OVERRIDE {
         return 100 + ((fID % 1 == 0) ? -5 : 6);
     }
 
+    virtual bool isValidOnGpu() const SK_OVERRIDE {
+        return true;
+    }
+
     static GrResourceKey ComputeKey(int width, int height, int sampleCnt) {
         return GrStencilBuffer::ComputeKey(width, height, sampleCnt);
     }
 
     int fID;
 
 private:
-    typedef GrResource INHERITED;
+    typedef GrCacheable INHERITED;
 };
 
-class TextureResource : public GrResource {
+class TextureResource : public GrCacheable {
 public:
     SK_DECLARE_INST_COUNT(TextureResource);
-    TextureResource(GrGpu* gpu, int id)
-        : INHERITED(gpu, false),
-          fID(id) {
-    }
-    ~TextureResource() {
-        this->release();
+    TextureResource(int id)
+        : fID(id) {
     }
 
-    virtual size_t sizeInBytes() const SK_OVERRIDE {
+    virtual size_t gpuMemorySize() const SK_OVERRIDE {
         return 100 + ((fID % 1 == 0) ? -40 : 33);
     }
 
+    virtual bool isValidOnGpu() const SK_OVERRIDE {
+        return true;
+    }
+
     static GrResourceKey ComputeKey(const GrTextureDesc& desc) {
         return GrTexture::ComputeScratchKey(desc);
     }
 
     int fID;
 
 private:
-    typedef GrResource INHERITED;
+    typedef GrCacheable INHERITED;
 };
 
 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());
+        GrCacheable* resource = SkNEW_ARGS(StencilResource, (i));
+        cache->purgeAsNeeded(1, resource->gpuMemorySize());
         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());
+        GrCacheable* resource = SkNEW_ARGS(TextureResource, (i));
+        cache->purgeAsNeeded(1, resource->gpuMemorySize());
         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);
+        GrCacheable* item = cache->find(key);
         if (NULL == item) {
             SkFAIL("cache add does not work as expected");
             return;
         }
         if (static_cast<TextureResource*>(item)->fID != k) {
             SkFAIL("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);
+        GrCacheable* item = cache->find(key);
         if (NULL == item) {
             SkFAIL("cache add does not work as expected");
             return;
         }
         if (static_cast<TextureResource*>(item)->fID != k) {
             SkFAIL("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);
+        GrCacheable* item = cache->find(key);
         if (NULL != item) {
             SkFAIL("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);
+        GrCacheable* item = cache->find(key);
         if (NULL != item) {
             SkFAIL("cache add does not work as expected");
             return;
         }
     }
 }
 
 class GrResourceCacheBenchAdd : public SkBenchmark {
     enum {
         RESOURCE_COUNT = CACHE_SIZE_COUNT / 2,
@@ skipping 60 matching lines @@
     }
 
 private:
     typedef SkBenchmark INHERITED;
 };
 
 DEF_BENCH( return new GrResourceCacheBenchAdd(); )
 DEF_BENCH( return new GrResourceCacheBenchFind(); )
 
 #endif