Run non-rendering benches in their own config.

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 168 matching lines @@
 
 static bool parse_bool_arg(char * const* argv, char* const* stop, bool* var) {
     if (argv < stop) {
         *var = atoi(*argv) != 0;
         return true;
     }
     return false;
 }
 
 enum Backend {
+    kNonRendering_Backend,
     kRaster_Backend,
     kGPU_Backend,
     kPDF_Backend,
 };
 
 static SkDevice* make_device(SkBitmap::Config config, const SkIPoint& size,
                              Backend backend, GrContext* context) {
     SkDevice* device = NULL;
     SkBitmap bitmap;
     bitmap.setConfig(config, size.fX, size.fY);
@@ skipping 34 matching lines @@
 typedef int GLContextType;
 static const GLContextType kDontCareGLCtxType = 0;
 #endif
 
 static const struct {
     SkBitmap::Config    fConfig;
     const char*         fName;
     Backend             fBackend;
     GLContextType       fContextType;
 } gConfigs[] = {
-    { SkBitmap::kARGB_8888_Config,  "8888",     kRaster_Backend, kDontCareGLCtxType },
-    { SkBitmap::kRGB_565_Config,    "565",      kRaster_Backend, kDontCareGLCtxType },
+    { SkBitmap::kNo_Config,         "NONRENDERING",    kNonRendering_Backend, kDontCareGLCtxType },
+    { SkBitmap::kARGB_8888_Config,  "8888",            kRaster_Backend, kDontCareGLCtxType },
+    { SkBitmap::kRGB_565_Config,    "565",             kRaster_Backend, kDontCareGLCtxType },
 #if SK_SUPPORT_GPU
-    { SkBitmap::kARGB_8888_Config,  "GPU",      kGPU_Backend, GrContextFactory::kNative_GLContextType },
+    { SkBitmap::kARGB_8888_Config,  "GPU",             kGPU_Backend, GrContextFactory::kNative_GLContextType },
 #if SK_ANGLE
-    { SkBitmap::kARGB_8888_Config,  "ANGLE",    kGPU_Backend, GrContextFactory::kANGLE_GLContextType },
+    { SkBitmap::kARGB_8888_Config,  "ANGLE",           kGPU_Backend, GrContextFactory::kANGLE_GLContextType },
 #endif // SK_ANGLE
 #ifdef SK_DEBUG
-    { SkBitmap::kARGB_8888_Config,  "Debug",    kGPU_Backend, GrContextFactory::kDebug_GLContextType },
+    { SkBitmap::kARGB_8888_Config,  "Debug",           kGPU_Backend, GrContextFactory::kDebug_GLContextType },
 #endif // SK_DEBUG
-    { SkBitmap::kARGB_8888_Config,  "NULLGPU",  kGPU_Backend, GrContextFactory::kNull_GLContextType },
+    { SkBitmap::kARGB_8888_Config,  "NULLGPU",         kGPU_Backend, GrContextFactory::kNull_GLContextType },
 #endif // SK_SUPPORT_GPU
 };
 
 static int findConfig(const char config[]) {
     for (size_t i = 0; i < SK_ARRAY_COUNT(gConfigs); i++) {
         if (!strcmp(config, gConfigs[i].fName)) {
             return i;
         }
     }
     return -1;
@@ skipping 54 matching lines @@
     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");
     SkDebugf("    --logFile filename : destination for writing log output, in addition to stdout.\n");
-#if SK_SUPPORT_GPU
-    SkDebugf("    --config 8888|565|GPU|ANGLE|NULLGPU : "
-             "Run bench in corresponding config mode.\n");
-#else
-    SkDebugf("    --config 8888|565: "
-             "Run bench in corresponding config mode.\n");
-#endif
+    SkDebugf("    --config ");
+    static const int kConfigCount = SK_ARRAY_COUNT(gConfigs);

[robertphillips, 2013/03/14 21:13:51]

size_t -> int? or kConfigCount -> size_t?

[bsalomon, 2013/03/15 15:44:10]

Done. (kConfigCount -> size_t).

+    for (size_t i = 0; i < kConfigCount; ++i) {
+        SkDebugf("%s%s", gConfigs[i].fName, ((i == kConfigCount - 1) ? "" : "|"));
+    }
+    SkDebugf(" :  Run bench in corresponding config mode.\n");
     SkDebugf("    -Dfoo bar : Add extra definition to bench.\n");
     SkDebugf("    -h|--help : Show this help message.\n");
 }
 
 int tool_main(int argc, char** argv);
 int tool_main(int argc, char** argv) {
 #if SK_ENABLE_INST_COUNT
     gPrintInstCount = true;
 #endif
     SkAutoGraphics ag;
@@ skipping 240 matching lines @@
     if ((benchMode == kRecord_benchModes || benchMode == kPictureRecord_benchModes)) {
         perIterTimeformat.set("%.4f");
         normalTimeFormat.set("%6.4f");
     }
     if (!userConfig) {
         // if no config is specified by user, we add them all.
         for (unsigned int i = 0; i < SK_ARRAY_COUNT(gConfigs); ++i) {
             *configs.append() = i;
         }
     }
+    if (kNormal_benchModes != benchMode) {
+        // Non-rendering configs only run in normal mode
+        for (int i = 0; i < configs.count(); ++i) {
+            int configIdx = configs[i];
+            if (kNonRendering_Backend == gConfigs[configIdx].fBackend) {
+                configs.remove(i, 1);
+                --i;
+            }
+        }
+    }
 
     // report our current settings
     {
         SkString str;
         const char* deferredMode = benchMode == kDeferred_benchModes ? "yes" :
             (benchMode == kDeferredSilent_benchModes ? "silent" : "no");
         str.printf("skia bench: alpha=0x%02X antialias=%d filter=%d "
                    "deferred=%s logperiter=%d",
                    forceAlpha, forceAA, forceFilter, deferredMode,
                    logPerIter);
@@ skipping 85 matching lines @@
         bench->setDither(forceDither);
         if (hasStrokeWidth) {
             bench->setStrokeWidth(strokeWidth);
         }
 
         // only run benchmarks if their name contains matchStr
         if (skip_name(fMatches, bench->getName())) {
             continue;
         }
 
-        {
-            SkString str;
-            str.printf("running bench [%d %d] %28s", dim.fX, dim.fY,
-                       bench->getName());
-            logger.logProgress(str);
-        }
+        bool loggedBenchStart = false;
 
         AutoPrePostDraw appd(bench);
 
-        bool runOnce = false;
         for (int x = 0; x < configs.count(); ++x) {
-            if (!bench->isRendering() && runOnce) {
-                continue;
+            int configIndex = configs[x];
+
+            if (kNonRendering_Backend == gConfigs[configIndex].fBackend) {
+                if (bench->isRendering()) {
+                    continue;
+                }
+            } else {
+                if (!bench->isRendering()) {
+                    continue;
+                }
             }
-            runOnce = true;
-
-            int configIndex = configs[x];
 
             outConfig = gConfigs[configIndex].fConfig;
             configName = gConfigs[configIndex].fName;
             backend = gConfigs[configIndex].fBackend;
             GrContext* context = NULL;
             BenchTimer* timer = timers[configIndex];
 
 #if SK_SUPPORT_GPU
             SkGLContextHelper* glContext = NULL;
             if (kGPU_Backend == backend) {
                 context = gContextFactory.get(gConfigs[configIndex].fContextType);
                 if (NULL == context) {
                     continue;
                 }
                 glContext = gContextFactory.getGLContext(gConfigs[configIndex].fContextType);
             }
 #endif
-            SkDevice* device = make_device(outConfig, dim, backend, context);
+            SkDevice* device = NULL;
             SkCanvas* canvas = NULL;
             SkPicture pictureRecordFrom;
             SkPicture pictureRecordTo;
-            switch(benchMode) {
-                case kDeferredSilent_benchModes:
-                case kDeferred_benchModes:
-                    canvas = new SkDeferredCanvas(device);
-                    break;
-                case kRecord_benchModes:
-                    canvas = pictureRecordTo.beginRecording(dim.fX, dim.fY,
-                        SkPicture::kUsePathBoundsForClip_RecordingFlag);
-                    canvas->ref();
-                    break;
-                case kPictureRecord_benchModes: {
-                    // This sets up picture-to-picture recording.
-                    // The C++ drawing calls for the benchmark are recorded into
-                    // pictureRecordFrom. As the benchmark, we will time how
-                    // long it takes to playback pictureRecordFrom into
-                    // pictureRecordTo.
-                    SkCanvas* tempCanvas = pictureRecordFrom.beginRecording(dim.fX, dim.fY,
-                        SkPicture::kUsePathBoundsForClip_RecordingFlag);
-                    bench->draw(tempCanvas);
-                    pictureRecordFrom.endRecording();
-                    canvas = pictureRecordTo.beginRecording(dim.fX, dim.fY,
-                        SkPicture::kUsePathBoundsForClip_RecordingFlag);
-                    canvas->ref();
-                    break;
+
+            if (kNonRendering_Backend != backend) {
+                device = make_device(outConfig, dim, backend, context);
+
+                switch(benchMode) {
+                    case kDeferredSilent_benchModes:
+                    case kDeferred_benchModes:
+                        canvas = new SkDeferredCanvas(device);
+                        break;
+                    case kRecord_benchModes:
+                        canvas = pictureRecordTo.beginRecording(dim.fX, dim.fY,
+                            SkPicture::kUsePathBoundsForClip_RecordingFlag);
+                        canvas->ref();
+                        break;
+                    case kPictureRecord_benchModes: {
+                        // This sets up picture-to-picture recording.
+                        // The C++ drawing calls for the benchmark are recorded into
+                        // pictureRecordFrom. As the benchmark, we will time how
+                        // long it takes to playback pictureRecordFrom into
+                        // pictureRecordTo.
+                        SkCanvas* tempCanvas = pictureRecordFrom.beginRecording(dim.fX, dim.fY,
+                            SkPicture::kUsePathBoundsForClip_RecordingFlag);
+                        bench->draw(tempCanvas);
+                        pictureRecordFrom.endRecording();
+                        canvas = pictureRecordTo.beginRecording(dim.fX, dim.fY,
+                            SkPicture::kUsePathBoundsForClip_RecordingFlag);
+                        canvas->ref();
+                        break;
+                    }
+                    case kNormal_benchModes:
+                        canvas = new SkCanvas(device);
+                        break;
+                    default:
+                        SkASSERT(0);
                 }
-                case kNormal_benchModes:
-                    canvas = new SkCanvas(device);
-                    break;
-                default:
-                    SkASSERT(0);
+                device->unref();
             }
-            device->unref();
             SkAutoUnref canvasUnref(canvas);
 
-            if (doClip) {
-                performClip(canvas, dim.fX, dim.fY);
+            if (NULL != canvas) {
+                if (doClip) {
+                    performClip(canvas, dim.fX, dim.fY);
+                }
+                if (doScale) {
+                    performScale(canvas, dim.fX, dim.fY);
+                }
+                if (doRotate) {
+                    performRotate(canvas, dim.fX, dim.fY);
+                }
             }
-            if (doScale) {
-                performScale(canvas, dim.fX, dim.fY);
-            }
-            if (doRotate) {
-                performRotate(canvas, dim.fX, dim.fY);
+
+            if (!loggedBenchStart) {
+                loggedBenchStart = true;
+                SkString str;
+                str.printf("running bench [%d %d] %28s", dim.fX, dim.fY, bench->getName());
+                logger.logProgress(str);
             }
 
             // warm up caches if needed
-            if (repeatDraw > 1) {
+            if (repeatDraw > 1 && NULL != canvas) {
 #if SK_SUPPORT_GPU
                 // purge the GPU resources to reduce variance
                 if (NULL != context) {
                     context->freeGpuResources();
                 }
 #endif
                 SkAutoCanvasRestore acr(canvas, true);
                 if (benchMode == kPictureRecord_benchModes) {
                     pictureRecordFrom.draw(canvas);
                 } else {
                     bench->draw(canvas);
                 }
 
                 if (kDeferredSilent_benchModes == benchMode) {
                     static_cast<SkDeferredCanvas*>(canvas)->silentFlush();
                 } else {
                     canvas->flush();
                 }
 #if SK_SUPPORT_GPU
                 if (NULL != context) {
                     context->flush();
                     SK_GL(*glContext, Finish());
                 }
 #endif
             }
 
             // record timer values for each repeat, and their sum
             TimerData timerData(perIterTimeformat, normalTimeFormat);
             for (int i = 0; i < repeatDraw; i++) {
-                if ((benchMode == kRecord_benchModes
-                     || benchMode == kPictureRecord_benchModes)) {
+                if ((benchMode == kRecord_benchModes || benchMode == kPictureRecord_benchModes)) {
                     // This will clear the recorded commands so that they do not
                     // accumulate.
                     canvas = pictureRecordTo.beginRecording(dim.fX, dim.fY,
                         SkPicture::kUsePathBoundsForClip_RecordingFlag);
                 }
 
                 timer->start();
-                SkAutoCanvasRestore acr(canvas, true);
+                if (NULL != canvas) {
+                    canvas->save();
+                }
                 if (benchMode == kPictureRecord_benchModes) {
                     pictureRecordFrom.draw(canvas);
                 } else {
                     bench->draw(canvas);
                 }
 
                 if (kDeferredSilent_benchModes == benchMode) {
                     static_cast<SkDeferredCanvas*>(canvas)->silentFlush();
-                } else {
+                } else if (NULL != canvas) {
                     canvas->flush();
                 }
 
+                if (NULL != canvas) {
+                    canvas->restore();
+                }
+
                 // stop the truncated timer after the last canvas call but
                 // don't wait for all the GL calls to complete
                 timer->truncatedEnd();
 #if SK_SUPPORT_GPU
                 if (NULL != glContext) {
                     context->flush();
                     SK_GL(*glContext, Finish());
                 }
 #endif
                 // stop the inclusive and gpu timers once all the GL calls
                 // have completed
                 timer->end();
 
                 timerData.appendTimes(timer, repeatDraw - 1 == i);
 
             }
             if (repeatDraw > 1) {
                 SkString result = timerData.getResult(logPerIter, printMin, repeatDraw, configName,
                                                       timerWall, truncatedTimerWall, timerCpu,
                                                       truncatedTimerCpu,
                                                       timerGpu && NULL != context);
                 logger.logProgress(result);
             }
-            if (outDir.size() > 0) {
+            if (outDir.size() > 0 && kNonRendering_Backend != backend) {
                 saveFile(bench->getName(), configName, outDir.c_str(),
                          device->accessBitmap(false));
                 canvas->clear(SK_ColorWHITE);
             }
         }
-        logger.logProgress(SkString("\n"));
+        if (loggedBenchStart) {
+            logger.logProgress(SkString("\n"));
+        }
     }
 #if SK_SUPPORT_GPU
 #if GR_CACHE_STATS
     for (int i = 0; i <= GrContextFactory::kLastGLContextType; ++i) {
         GrContextFactory::GLContextType ctxType = (GrContextFactory::GLContextType)i;
         GrContext* context = gContextFactory.get(ctxType);
         if (NULL != context) {
             SkDebugf("Cache Stats for %s context:\n", GrContextFactory::GLContextTypeName(ctxType));
             context->printCacheStats();
             SkDebugf("\n");
         }
     }
 #endif
     // Destroy the GrContext before the inst tracking printing at main() exit occurs.
     gContextFactory.destroyContexts();
 #endif
     for (size_t i = 0; i < SK_ARRAY_COUNT(gConfigs); ++i) {
         SkDELETE(timers[i]);
     }
 
     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