Add --gpucache size to bench.

bench/benchmain.cpp

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "BenchTimer.h"
@@ skipping 263 matching lines @@
             return false;
         }
     }
     return true;
 }
 
 static void help() {
     SkDebugf("Usage: bench [-o outDir] [--repeat nr] [--logPerIter] "
                           "[--timers [wcgWC]*] [--rotate]\n"
              "    [--scale] [--clip] [--min] [--forceAA 1|0] [--forceFilter 1|0]\n"
-             "    [--forceDither 1|0] [--forceBlend 1|0] [--strokeWidth width]\n"
-             "    [--match name] [--mode normal|deferred|deferredSilent|record|picturerecord]\n"
+             "    [--forceDither 1|0] [--forceBlend 1|0]"
+#if SK_SUPPORT_GPU
+             " [--gpuCacheSize <bytes> <count>]"
+#endif
+             "\n"
+             "    [--strokeWidth width] [--match name]\n"
+             "    [--mode normal|deferred|deferredSilent|record|picturerecord]\n"
              "    [--config 8888|565|GPU|ANGLE|NULLGPU] [-Dfoo bar] [--logFile filename]\n"
              "    [-h|--help]");
     SkDebugf("\n\n");
     SkDebugf("    -o outDir : Image of each bench will be put in outDir.\n");
     SkDebugf("    --repeat nr : Each bench repeats for nr times.\n");
     SkDebugf("    --logPerIter : "
              "Log each repeat timer instead of mean, default is disabled.\n");
     SkDebugf("    --timers [wcgWC]* : "
              "Display wall, cpu, gpu, truncated wall or truncated cpu time for each bench.\n");
     SkDebugf("    --rotate : Rotate before each bench runs.\n");
     SkDebugf("    --scale : Scale before each bench runs.\n");
     SkDebugf("    --clip : Clip before each bench runs.\n");
     SkDebugf("    --min : Print the minimum times (instead of average).\n");
     SkDebugf("    --forceAA 1|0 : "
              "Enable/disable anti-aliased, default is enabled.\n");
     SkDebugf("    --forceFilter 1|0 : "
              "Enable/disable bitmap filtering, default is disabled.\n");
     SkDebugf("    --forceDither 1|0 : "
              "Enable/disable dithering, default is disabled.\n");
     SkDebugf("    --forceBlend 1|0 : "
              "Enable/disable dithering, default is disabled.\n");
+#if SK_SUPPORT_GPU
+    SkDebugf("    --gpuCacheSize <bytes> <count>: "
+             "limits gpu cache to  bytes size or object count.\n");
+    SkDebugf("      -1 for either value means use the default. 0 for either disables the cache.\n");
+#endif
     SkDebugf("    --strokeWidth width : The width for path stroke.\n");
     SkDebugf("    --match name : Only run bench whose name is matched.\n");
     SkDebugf("    --mode normal|deferred|deferredSilent|record|picturerecord :\n"
              "             Run in the corresponding mode\n"
              "                 normal, Use a normal canvas to draw to;\n"
              "                 deferred, Use a deferrred canvas when drawing;\n"
              "                 deferredSilent, deferred with silent playback;\n"
              "                 record, Benchmark the time to record to an SkPicture;\n"
              "                 picturerecord, Benchmark the time to do record from a \n"
              "                                SkPicture to a SkPicture.\n");
@@ skipping 26 matching lines @@
     bool timerWall = false;
     bool truncatedTimerWall = false;
     bool timerCpu = true;
     bool truncatedTimerCpu = false;
     bool timerGpu = true;
     bool doScale = false;
     bool doRotate = false;
     bool doClip = false;
     bool printMin = false;
     bool hasStrokeWidth = false;
+
+#if SK_SUPPORT_GPU
+    struct {
+        size_t  fBytes;
+        int     fCount;
+    } gpuCacheSize = { -1, -1 }; // -1s mean use the default
+#endif
+
     float strokeWidth;
     SkTDArray<const char*> fMatches;
     benchModes benchMode = kNormal_benchModes;
     SkString perIterTimeformat("%.2f");
     SkString normalTimeFormat("%6.2f");
 
     SkString outDir;
     SkBitmap::Config outConfig = SkBitmap::kNo_Config;
     const char* configName = "";
     Backend backend = kRaster_Backend;  // for warning
@@ skipping 77 matching lines @@
             }
             forceDither = tmp ? SkTriState::kTrue : SkTriState::kFalse;
         } else if (strcmp(*argv, "--forceBlend") == 0) {
             bool wantAlpha = false;
             if (!parse_bool_arg(++argv, stop, &wantAlpha)) {
                 logger.logError("missing arg for --forceBlend\n");
                 help();
                 return -1;
             }
             forceAlpha = wantAlpha ? 0x80 : 0xFF;
+#if SK_SUPPORT_GPU
+        } else if (strcmp(*argv, "--gpuCacheSize") == 0) {
+            if (stop - argv > 2) {
+                gpuCacheSize.fBytes = atoi(*++argv);
+                gpuCacheSize.fCount = atoi(*++argv);
+            } else {
+                SkDebugf("missing arg for --gpuCacheSize\n");
+                help();
+                return -1;
+            }
+#endif
         } else if (strcmp(*argv, "--mode") == 0) {
             argv++;
             if (argv < stop) {
                 if (strcmp(*argv, "normal") == 0) {
                     benchMode = kNormal_benchModes;
                 } else if (strcmp(*argv, "deferred") == 0) {
                     benchMode = kDeferred_benchModes;
                 } else if (strcmp(*argv, "deferredSilent") == 0) {
                     benchMode = kDeferredSilent_benchModes;
                 } else if (strcmp(*argv, "record") == 0) {
@@ skipping 154 matching lines @@
 #if defined(SK_DEBUG)
         str.append(" DEBUG");
 #endif
         str.append("\n");
         logger.logProgress(str);
     }
 
     SkTArray<BenchTimer*> timers(SK_ARRAY_COUNT(gConfigs));
     for (size_t i = 0; i < SK_ARRAY_COUNT(gConfigs); ++i) {
 #if SK_SUPPORT_GPU
-        SkGLContextHelper* ctx = NULL;
+        SkGLContextHelper* glCtx = NULL;
         if (kGPU_Backend == gConfigs[i].fBackend) {
-            ctx = gContextFactory.getGLContext(gConfigs[i].fContextType);
+            GrContext* context = gContextFactory.get(gConfigs[i].fContextType);
+            if (NULL != context) {
+                // Set the user specified cache limits if non-default.
+                size_t bytes;
+                int count;
+                context->getTextureCacheLimits(&count, &bytes);
+                if (-1 != gpuCacheSize.fBytes) {
+                    bytes = gpuCacheSize.fBytes;
+                }
+                if (-1 != gpuCacheSize.fCount) {
+                    count = gpuCacheSize.fCount;
+                }
+                context->setTextureCacheLimits(count, bytes);
+            }
+            glCtx = gContextFactory.getGLContext(gConfigs[i].fContextType);
         }
-        timers.push_back(SkNEW_ARGS(BenchTimer, (ctx)));
+        timers.push_back(SkNEW_ARGS(BenchTimer, (glCtx)));
 #else
         timers.push_back(SkNEW(BenchTimer));
 #endif
     }
 
     Iter iter(&defineDict);
     SkBenchmark* bench;
     while ((bench = iter.next()) != NULL) {
         SkAutoTUnref<SkBenchmark> benchUnref(bench);
 
@@ skipping 201 matching lines @@
     }
 
     return 0;
 }
 
 #if !defined(SK_BUILD_FOR_IOS) && !defined(SK_BUILD_FOR_NACL)
 int main(int argc, char * const argv[]) {
     return tool_main(argc, (char**) argv);
 }
 #endif