Add -logPerIter, -timers, and -min to bench_pictures.

Additional changes:

Add instance count to bench_pictures.

Remove various PictureBenchmark subclasses which did not do
anything besides have a different PictureRenderer.

BUG=https://code.google.com/p/skia/issues/detail?id=856

Review URL: https://codereview.appspot.com/6496109

git-svn-id: http://skia.googlecode.com/svn/trunk@5496 2bbb7eff-a529-9590-31e7-b0007b416f81

3 files changed, 164 insertions, 189 deletions

diff --git a/tools/PictureBenchmark.cpp b/tools/PictureBenchmark.cpp
index f63d087ccc..7879414de5 100644
--- a/tools/PictureBenchmark.cpp
+++ b/tools/PictureBenchmark.cpp
@@ -5,7 +5,6 @@
  * found in the LICENSE file.
  */
 
-#include "SkTypes.h"
 #include "SkBenchLogger.h"
 #include "BenchTimer.h"
 #include "PictureBenchmark.h"
@@ -17,12 +16,27 @@
 
 namespace sk_tools {
 
+PictureBenchmark::PictureBenchmark()
+: fRepeats(1)
+, fLogger(NULL)
+, fRenderer(NULL)
+, fLogPerIter(false)
+, fPrintMin(false)
+, fShowWallTime(false)
+, fShowTruncatedWallTime(false)
+, fShowCpuTime(true)
+, fShowTruncatedCpuTime(false)
+, fShowGpuTime(false)
+{}
+
+PictureBenchmark::~PictureBenchmark() {
+    SkSafeUnref(fRenderer);
+}
+
 BenchTimer* PictureBenchmark::setupTimer() {
 #if SK_SUPPORT_GPU
-    PictureRenderer* renderer = getRenderer();
-
-    if (renderer != NULL && renderer->isUsingGpuDevice()) {
-        return SkNEW_ARGS(BenchTimer, (renderer->getGLContext()));
+    if (fRenderer != NULL && fRenderer->isUsingGpuDevice()) {
+        return SkNEW_ARGS(BenchTimer, (fRenderer->getGLContext()));
     } else {
         return SkNEW_ARGS(BenchTimer, (NULL));
     }
@@ -37,61 +51,59 @@ void PictureBenchmark::logProgress(const char msg[]) {
     }
 }
 
+PictureRenderer* PictureBenchmark::setRenderer(sk_tools::PictureRenderer* renderer) {
+    SkRefCnt_SafeAssign(fRenderer, renderer);
+    return renderer;
+}
+
 void PictureBenchmark::run(SkPicture* pict) {
     SkASSERT(pict);
     if (NULL == pict) {
         return;
     }
 
-    PictureRenderer* renderer = this->getRenderer();
-    SkASSERT(renderer != NULL);
-    if (NULL == renderer) {
+    SkASSERT(fRenderer != NULL);
+    if (NULL == fRenderer) {
         return;
     }
-    renderer->init(pict);
 
-    // We throw this away to remove first time effects (such as paging in this
-    // program)
-    renderer->setup();
-    renderer->render(false);
-    renderer->resetState();
+    fRenderer->init(pict);
+
+    // We throw this away to remove first time effects (such as paging in this program)
+    fRenderer->setup();
+    fRenderer->render(false);
+    fRenderer->resetState();
 
     BenchTimer* timer = this->setupTimer();
     bool usingGpu = false;
 #if SK_SUPPORT_GPU
-    usingGpu = renderer->isUsingGpuDevice();
+    usingGpu = fRenderer->isUsingGpuDevice();
 #endif
 
-    TimerData timerData(renderer->getPerIterTimeFormat(), renderer->getNormalTimeFormat());
+    TimerData timerData(fRenderer->getPerIterTimeFormat(), fRenderer->getNormalTimeFormat());
     for (int i = 0; i < fRepeats; ++i) {
-        renderer->setup();
+        fRenderer->setup();
 
         timer->start();
-        renderer->render(false);
+        fRenderer->render(false);
         timer->truncatedEnd();
 
         // Finishes gl context
-        renderer->resetState();
+        fRenderer->resetState();
         timer->end();
 
         timerData.appendTimes(timer, fRepeats - 1 == i);
     }
 
-    // FIXME: Pass these options on the command line.
-    bool logPerIter = false;
-    bool printMin = false;
     const char* configName = usingGpu ? "gpu" : "raster";
-    bool showWallTime = true;
-    bool showTruncatedWallTime = false;
-    bool showCpuTime = false;
-    bool showTruncatedCpuTime = false;
-    SkString result = timerData.getResult(logPerIter, printMin, fRepeats,
-                                          configName, showWallTime, showTruncatedWallTime,
-                                          showCpuTime, showTruncatedCpuTime, usingGpu);
+    SkString result = timerData.getResult(fLogPerIter, fPrintMin, fRepeats,
+                                          configName, fShowWallTime, fShowTruncatedWallTime,
+                                          fShowCpuTime, fShowTruncatedCpuTime,
+                                          usingGpu && fShowGpuTime);
     result.append("\n");
     this->logProgress(result.c_str());
 
-    renderer->end();
+    fRenderer->end();
     SkDELETE(timer);
 }
 
diff --git a/tools/PictureBenchmark.h b/tools/PictureBenchmark.h
index c3767e1cb3..0ab5ff9bf1 100644
--- a/tools/PictureBenchmark.h
+++ b/tools/PictureBenchmark.h
@@ -7,8 +7,8 @@
 
 #ifndef PictureBenchmark_DEFINED
 #define PictureBenchmark_DEFINED
+
 #include "SkTypes.h"
-#include "SkRefCnt.h"
 #include "PictureRenderer.h"
 
 class BenchTimer;
@@ -18,11 +18,11 @@ class SkString;
 
 namespace sk_tools {
 
-class PictureBenchmark : public SkRefCnt {
+class PictureBenchmark {
 public:
-    PictureBenchmark()
-    : fRepeats(1)
-    , fLogger(NULL) {}
+    PictureBenchmark();
+
+    ~PictureBenchmark();
 
     void run(SkPicture* pict);
 
@@ -30,133 +30,43 @@ public:
         fRepeats = repeats;
     }
 
-    void setDeviceType(PictureRenderer::SkDeviceTypes deviceType) {
-        sk_tools::PictureRenderer* renderer = getRenderer();
+    PictureRenderer* setRenderer(PictureRenderer*);
 
-        if (renderer != NULL) {
-            renderer->setDeviceType(deviceType);
+    void setDeviceType(PictureRenderer::SkDeviceTypes deviceType) {
+        if (fRenderer != NULL) {
+            fRenderer->setDeviceType(deviceType);
         }
     }
 
-    void setLogger(SkBenchLogger* logger) { fLogger = logger; }
-
-private:
-    int            fRepeats;
-    SkBenchLogger* fLogger;
-
-    void logProgress(const char msg[]);
-
-    virtual sk_tools::PictureRenderer* getRenderer() = 0;
-
-    BenchTimer* setupTimer();
-
-    typedef SkRefCnt INHERITED;
-};
-
-// TODO: Use just one PictureBenchmark with different renderers.
-
-class PipePictureBenchmark : public PictureBenchmark {
-private:
-    PipePictureRenderer fRenderer;
-
-    virtual sk_tools::PictureRenderer* getRenderer() SK_OVERRIDE {
-        return &fRenderer;
-    }
-
-    typedef PictureBenchmark INHERITED;
-};
-
-class RecordPictureBenchmark : public PictureBenchmark {
-private:
-    RecordPictureRenderer fRenderer;
-
-    virtual sk_tools::PictureRenderer* getRenderer() SK_OVERRIDE {
-        return &fRenderer;
-    }
-
-    typedef PictureBenchmark INHERITED;
-};
-
-class SimplePictureBenchmark : public PictureBenchmark {
-private:
-    SimplePictureRenderer fRenderer;
-
-    virtual sk_tools::PictureRenderer* getRenderer() SK_OVERRIDE {
-        return &fRenderer;
-    }
-
-    typedef PictureBenchmark INHERITED;
-};
-
-class TiledPictureBenchmark : public PictureBenchmark {
-public:
-    void setTileWidth(int width) {
-        fRenderer.setTileWidth(width);
-    }
-
-    int getTileWidth() const {
-        return fRenderer.getTileWidth();
-    }
-
-    void setTileHeight(int height) {
-        fRenderer.setTileHeight(height);
-    }
-
-    int getTileHeight() const {
-        return fRenderer.getTileHeight();
-    }
-
-    void setTileWidthPercentage(double percentage) {
-        fRenderer.setTileWidthPercentage(percentage);
-    }
-
-    double getTileWidthPercentage() const {
-        return fRenderer.getTileWidthPercentage();
-    }
-
-    void setTileHeightPercentage(double percentage) {
-        fRenderer.setTileHeightPercentage(percentage);
-    }
+    void setLogPerIter(bool log) { fLogPerIter = log; }
 
-    double getTileHeightPercentage() const {
-        return fRenderer.getTileHeightPercentage();
-    }
-
-    void setTileMinPowerOf2Width(int width) {
-        fRenderer.setTileMinPowerOf2Width(width);
-    }
-
-    int getTileMinPowerOf2Width() {
-        return fRenderer.getTileMinPowerOf2Width();
-    }
-
-    void setThreading(bool multi) {
-        fRenderer.setMultiThreaded(multi);
-    }
-
-    void setUsePipe(bool usePipe) {
-        fRenderer.setUsePipe(usePipe);
-    }
-
-private:
-    TiledPictureRenderer fRenderer;
+    void setPrintMin(bool min) { fPrintMin = min; }
 
-    virtual sk_tools::PictureRenderer* getRenderer() SK_OVERRIDE{
-        return &fRenderer;
+    void setTimersToShow(bool wall, bool truncatedWall, bool cpu, bool truncatedCpu, bool gpu) {
+        fShowWallTime = wall;
+        fShowTruncatedWallTime = truncatedWall;
+        fShowCpuTime = cpu;
+        fShowTruncatedCpuTime = truncatedCpu;
+        fShowGpuTime = gpu;
     }
 
-    typedef PictureBenchmark INHERITED;
-};
+    void setLogger(SkBenchLogger* logger) { fLogger = logger; }
 
-class PlaybackCreationBenchmark : public PictureBenchmark {
 private:
-    PlaybackCreationRenderer fRenderer;
+    int              fRepeats;
+    SkBenchLogger*   fLogger;
+    PictureRenderer* fRenderer;
+    bool             fLogPerIter;
+    bool             fPrintMin;
+    bool             fShowWallTime;
+    bool             fShowTruncatedWallTime;
+    bool             fShowCpuTime;
+    bool             fShowTruncatedCpuTime;
+    bool             fShowGpuTime;
 
-    virtual sk_tools::PictureRenderer* getRenderer() SK_OVERRIDE{
-        return &fRenderer;
-    }
+    void logProgress(const char msg[]);
 
-    typedef PictureBenchmark INHERITED;
+    BenchTimer* setupTimer();
 };
 
 }
diff --git a/tools/bench_pictures_main.cpp b/tools/bench_pictures_main.cpp
index d1117164e9..2f5fb0e6c6 100644
--- a/tools/bench_pictures_main.cpp
+++ b/tools/bench_pictures_main.cpp
@@ -24,7 +24,7 @@ static void usage(const char* argv0) {
     SkDebugf("\n"
 "Usage: \n"
 "     %s <inputDir>...\n"
-"     [--logFile filename]\n"
+"     [--logFile filename][--timers [wcgWC]*][--logPerIter 1|0][--min]\n"
 "     [--repeat] \n"
 "     [--mode pow2tile minWidth height[] (multi) | record | simple\n"
 "             | tile width[] height[] (multi) | playbackCreation]\n"
@@ -40,6 +40,11 @@ static void usage(const char* argv0) {
 "     inputDir:  A list of directories and files to use as input. Files are\n"
 "                expected to have the .skp extension.\n\n"
 "     --logFile filename : destination for writing log output, in addition to stdout.\n");
+    SkDebugf("     --logPerIter 1|0 : "
+             "Log each repeat timer instead of mean, default is disabled.\n");
+    SkDebugf("     --min : Print the minimum times (instead of average).\n");
+    SkDebugf("     --timers [wcgWC]* : "
+             "Display wall, cpu, gpu, truncated wall or truncated cpu time for each picture.\n");
     SkDebugf(
 "     --mode pow2tile minWidht height[] (multi) | record | simple\n"
 "            | tile width[] height[] (multi) | playbackCreation:\n"
@@ -118,7 +123,7 @@ static void run_single_benchmark(const SkString& inputPath,
 }
 
 static void parse_commandline(int argc, char* const argv[], SkTArray<SkString>* inputs,
-                              sk_tools::PictureBenchmark*& benchmark) {
+                              sk_tools::PictureBenchmark* benchmark) {
     const char* argv0 = argv[0];
     char* const* stop = argv + argc;
 
@@ -126,6 +131,8 @@ static void parse_commandline(int argc, char* const argv[], SkTArray<SkString>*
     sk_tools::PictureRenderer::SkDeviceTypes deviceType =
         sk_tools::PictureRenderer::kBitmap_DeviceType;
 
+    sk_tools::PictureRenderer* renderer = NULL;
+
     // Create a string to show our current settings.
     // TODO: Make it prettier. Currently it just repeats the command line.
     SkString commandLine("bench_pictures:");
@@ -147,12 +154,10 @@ static void parse_commandline(int argc, char* const argv[], SkTArray<SkString>*
             if (argv < stop) {
                 repeats = atoi(*argv);
                 if (repeats < 1) {
-                    SkDELETE(benchmark);
                     gLogger.logError("--repeat must be given a value > 0\n");
                     exit(-1);
                 }
             } else {
-                SkDELETE(benchmark);
                 gLogger.logError("Missing arg for --repeat\n");
                 usage(argv0);
                 exit(-1);
@@ -175,7 +180,6 @@ static void parse_commandline(int argc, char* const argv[], SkTArray<SkString>*
                 exit(-1);
             }
         } else if (0 == strcmp(*argv, "--mode")) {
-            SkDELETE(benchmark);
 
             ++argv;
             if (argv >= stop) {
@@ -185,9 +189,9 @@ static void parse_commandline(int argc, char* const argv[], SkTArray<SkString>*
             }
 
             if (0 == strcmp(*argv, "record")) {
-                benchmark = SkNEW(sk_tools::RecordPictureBenchmark);
+                renderer = SkNEW(sk_tools::RecordPictureRenderer);
             } else if (0 == strcmp(*argv, "simple")) {
-                benchmark = SkNEW(sk_tools::SimplePictureBenchmark);
+                renderer = SkNEW(sk_tools::SimplePictureRenderer);
             } else if ((0 == strcmp(*argv, "tile")) || (0 == strcmp(*argv, "pow2tile"))) {
                 useTiles = true;
                 mode = *argv;
@@ -221,7 +225,7 @@ static void parse_commandline(int argc, char* const argv[], SkTArray<SkString>*
                     --argv;
                 }
             } else if (0 == strcmp(*argv, "playbackCreation")) {
-                benchmark = SkNEW(sk_tools::PlaybackCreationBenchmark);
+                renderer = SkNEW(sk_tools::PlaybackCreationRenderer);
             } else {
                 SkString err;
                 err.printf("%s is not a valid mode for --mode\n", *argv);
@@ -252,9 +256,56 @@ static void parse_commandline(int argc, char* const argv[], SkTArray<SkString>*
                 usage(argv0);
                 exit(-1);
             }
-
+        } else if (0 == strcmp(*argv, "--timers")) {
+            ++argv;
+            if (argv < stop) {
+                bool timerWall = false;
+                bool truncatedTimerWall = false;
+                bool timerCpu = false;
+                bool truncatedTimerCpu = false;
+                bool timerGpu = false;
+                for (char* t = *argv; *t; ++t) {
+                    switch (*t) {
+                        case 'w':
+                            timerWall = true;
+                            break;
+                        case 'c':
+                            timerCpu = true;
+                            break;
+                        case 'W':
+                            truncatedTimerWall = true;
+                            break;
+                        case 'C':
+                            truncatedTimerCpu = true;
+                            break;
+                        case 'g':
+                            timerGpu = true;
+                            break;
+                        default: {
+                            break;
+                        }
+                    }
+                }
+                benchmark->setTimersToShow(timerWall, truncatedTimerWall, timerCpu,
+                                           truncatedTimerCpu, timerGpu);
+            } else {
+                gLogger.logError("Missing arg for --timers\n");
+                usage(argv0);
+                exit(-1);
+            }
+        } else if (0 == strcmp(*argv, "--min")) {
+            benchmark->setPrintMin(true);
+        } else if (0 == strcmp(*argv, "--logPerIter")) {
+            ++argv;
+            if (argv < stop) {
+                bool log = atoi(*argv) != 0;
+                benchmark->setLogPerIter(log);
+            } else {
+                gLogger.logError("Missing arg for --logPerIter\n");
+                usage(argv0);
+                exit(-1);
+            }
         } else if (0 == strcmp(*argv, "--help") || 0 == strcmp(*argv, "-h")) {
-            SkDELETE(benchmark);
             usage(argv0);
             exit(0);
         } else {
@@ -263,55 +314,55 @@ static void parse_commandline(int argc, char* const argv[], SkTArray<SkString>*
     }
 
     if (useTiles) {
-        sk_tools::TiledPictureBenchmark* tileBenchmark = SkNEW(sk_tools::TiledPictureBenchmark);
+        SkASSERT(NULL == renderer);
+        sk_tools::TiledPictureRenderer* tiledRenderer = SkNEW(sk_tools::TiledPictureRenderer);
         if (isPowerOf2Mode) {
             int minWidth = atoi(widthString);
             if (!SkIsPow2(minWidth) || minWidth < 0) {
-                SkDELETE(tileBenchmark);
+                tiledRenderer->unref();
                 SkString err;
-                err.printf("--mode %s must be given a width"
+                err.printf("-mode %s must be given a width"
                          " value that is a power of two\n", mode);
                 gLogger.logError(err);
                 exit(-1);
             }
-            tileBenchmark->setTileMinPowerOf2Width(minWidth);
+            tiledRenderer->setTileMinPowerOf2Width(minWidth);
         } else if (sk_tools::is_percentage(widthString)) {
-            tileBenchmark->setTileWidthPercentage(atof(widthString));
-            if (!(tileBenchmark->getTileWidthPercentage() > 0)) {
-                SkDELETE(tileBenchmark);
+            tiledRenderer->setTileWidthPercentage(atof(widthString));
+            if (!(tiledRenderer->getTileWidthPercentage() > 0)) {
+                tiledRenderer->unref();
                 gLogger.logError("--mode tile must be given a width percentage > 0\n");
                 exit(-1);
             }
         } else {
-            tileBenchmark->setTileWidth(atoi(widthString));
-            if (!(tileBenchmark->getTileWidth() > 0)) {
-                SkDELETE(tileBenchmark);
+            tiledRenderer->setTileWidth(atoi(widthString));
+            if (!(tiledRenderer->getTileWidth() > 0)) {
+                tiledRenderer->unref();
                 gLogger.logError("--mode tile must be given a width > 0\n");
                 exit(-1);
             }
         }
 
         if (sk_tools::is_percentage(heightString)) {
-            tileBenchmark->setTileHeightPercentage(atof(heightString));
-            if (!(tileBenchmark->getTileHeightPercentage() > 0)) {
-                SkDELETE(tileBenchmark);
+            tiledRenderer->setTileHeightPercentage(atof(heightString));
+            if (!(tiledRenderer->getTileHeightPercentage() > 0)) {
+                tiledRenderer->unref();
                 gLogger.logError("--mode tile must be given a height percentage > 0\n");
                 exit(-1);
             }
         } else {
-            tileBenchmark->setTileHeight(atoi(heightString));
-            if (!(tileBenchmark->getTileHeight() > 0)) {
-                SkDELETE(tileBenchmark);
+            tiledRenderer->setTileHeight(atoi(heightString));
+            if (!(tiledRenderer->getTileHeight() > 0)) {
+                tiledRenderer->unref();
                 gLogger.logError("--mode tile must be given a height > 0\n");
                 exit(-1);
             }
         }
-        tileBenchmark->setThreading(multiThreaded);
-        tileBenchmark->setUsePipe(usePipe);
-        benchmark = tileBenchmark;
+        tiledRenderer->setMultiThreaded(multiThreaded);
+        tiledRenderer->setUsePipe(usePipe);
+        renderer = tiledRenderer;
     } else if (usePipe) {
-        SkDELETE(benchmark);
-        benchmark = SkNEW(sk_tools::PipePictureBenchmark);
+        renderer = SkNEW(sk_tools::PipePictureRenderer);
     }
     if (inputs->count() < 1) {
         SkDELETE(benchmark);
@@ -319,10 +370,10 @@ static void parse_commandline(int argc, char* const argv[], SkTArray<SkString>*
         exit(-1);
     }
 
-    if (NULL == benchmark) {
-        benchmark = SkNEW(sk_tools::SimplePictureBenchmark);
+    if (NULL == renderer) {
+        renderer = SkNEW(sk_tools::SimplePictureRenderer);
     }
-
+    benchmark->setRenderer(renderer)->unref();
     benchmark->setRepeats(repeats);
     benchmark->setDeviceType(deviceType);
     benchmark->setLogger(&gLogger);
@@ -346,15 +397,17 @@ static void process_input(const SkString& input, sk_tools::PictureBenchmark& ben
 }
 
 int main(int argc, char* const argv[]) {
+#ifdef SK_ENABLE_INST_COUNT
+    gPrintInstCount = true;
+#endif
     SkAutoGraphics ag;
+
     SkTArray<SkString> inputs;
-    sk_tools::PictureBenchmark* benchmark = NULL;
+    sk_tools::PictureBenchmark benchmark;
 
-    parse_commandline(argc, argv, &inputs, benchmark);
+    parse_commandline(argc, argv, &inputs, &benchmark);
 
     for (int i = 0; i < inputs.count(); ++i) {
-        process_input(inputs[i], *benchmark);
+        process_input(inputs[i], benchmark);
     }
-
-    SkDELETE(benchmark);
 }