Add benchmarkstream to visualbench

tools/VisualBench/VisualBench.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  *
  */
 
 #include "VisualBench.h"
 
 #include "ProcStats.h"
 #include "SkApplication.h"
 #include "SkCanvas.h"
 #include "SkCommandLineFlags.h"
-#include "SkCommonFlags.h"
 #include "SkForceLinking.h"
 #include "SkGraphics.h"
 #include "SkGr.h"
 #include "SkImageDecoder.h"
 #include "SkOSFile.h"
 #include "SkStream.h"
 #include "Stats.h"
 #include "gl/GrGLInterface.h"
 
 __SK_FORCE_IMAGE_DECODER_LINKING;
 
 // Between samples we reset context
 // Between frames we swap buffers
 // Between flushes we call flush on GrContext
 
 DEFINE_int32(gpuFrameLag, 5, "Overestimate of maximum number of frames GPU allows to lag.");
 DEFINE_int32(samples, 10, "Number of times to time each skp.");
 DEFINE_int32(frames, 5, "Number of frames of each skp to render per sample.");
 DEFINE_double(flushMs, 20, "Target flush time in millseconds.");
 DEFINE_double(loopMs, 5, "Target loop time in millseconds.");
 DEFINE_int32(msaa, 0, "Number of msaa samples.");
 DEFINE_bool2(fullscreen, f, true, "Run fullscreen.");
+DEFINE_bool2(verbose, v, false, "enable verbose output from the test driver.");
 
 static SkString humanize(double ms) {
     if (FLAGS_verbose) {
         return SkStringPrintf("%llu", (uint64_t)(ms*1e6));
     }
     return HumanizeMs(ms);
 }
 
 #define HUMANIZE(time) humanize(time).c_str()
 
 VisualBench::VisualBench(void* hwnd, int argc, char** argv)
     : INHERITED(hwnd)
-    , fCurrentPictureIdx(-1)
     , fCurrentSample(0)
     , fCurrentFrame(0)
     , fFlushes(1)
     , fLoops(1)
-    , fState(kPreWarmLoops_State) {
+    , fState(kPreWarmLoops_State)
+    , fBenchmark(NULL) {
     SkCommandLineFlags::Parse(argc, argv);
 
-    // read all the skp file names.
-    for (int i = 0; i < FLAGS_skps.count(); i++) {
-        if (SkStrEndsWith(FLAGS_skps[i], ".skp")) {
-            fRecords.push_back().fFilename = FLAGS_skps[i];
-        } else {
-            SkOSFile::Iter it(FLAGS_skps[i], ".skp");
-            SkString path;
-            while (it.next(&path)) {
-                fRecords.push_back().fFilename = SkOSPath::Join(FLAGS_skps[i], path.c_str());;
-            }
-        }
-    }
-
-    if (fRecords.empty()) {
-        SkDebugf("no valid skps found\n");
-    }
-
     this->setTitle();
     this->setupBackend();
 
+    fBenchmarkStream.reset(SkNEW(VisualBenchmarkStream));
+
     // Print header
     SkDebugf("curr/maxrss\tloops\tflushes\tmin\tmedian\tmean\tmax\tstddev\tbench\n");
 }
 
 VisualBench::~VisualBench() {
     INHERITED::detach();
 }
 
 void VisualBench::setTitle() {
     SkString title("VisualBench");
@@ skipping 39 matching lines @@
 }
 
 void VisualBench::setupRenderTarget() {
     if (fContext) {
         fRenderTarget.reset(this->renderTarget(fAttachmentInfo, fInterface, fContext));
     }
 }
 
 inline void VisualBench::renderFrame(SkCanvas* canvas) {
     for (int flush = 0; flush < fFlushes; flush++) {
-        for (int loop = 0; loop < fLoops; loop++) {
-            canvas->drawPicture(fPicture);
-        }
+        fBenchmark->draw(fLoops, canvas);
         canvas->flush();
     }
     INHERITED::present();
 }
 
 void VisualBench::printStats() {
-    const SkTArray<double>& measurements = fRecords[fCurrentPictureIdx].fMeasurements;
-    SkString shortName = SkOSPath::Basename(fRecords[fCurrentPictureIdx].fFilename.c_str());
+    const SkTArray<double>& measurements = fRecords.back().fMeasurements;
+    const char* shortName = fBenchmark->getUniqueName();
     if (FLAGS_verbose) {
         for (int i = 0; i < measurements.count(); i++) {
             SkDebugf("%s  ", HUMANIZE(measurements[i]));
         }
-        SkDebugf("%s\n", shortName.c_str());
+        SkDebugf("%s\n", shortName);
     } else {
         SkASSERT(measurements.count());
         Stats stats(measurements);
         const double stdDevPercent = 100 * sqrt(stats.var) / stats.mean;
         SkDebugf("%4d/%-4dMB\t%d\t%d\t%s\t%s\t%s\t%s\t%.0f%%\t%s\n",
                  sk_tools::getCurrResidentSetSizeMB(),
                  sk_tools::getMaxResidentSetSizeMB(),
                  fLoops,
                  fFlushes,
                  HUMANIZE(stats.min),
                  HUMANIZE(stats.median),
                  HUMANIZE(stats.mean),
                  HUMANIZE(stats.max),
                  stdDevPercent,
-                 shortName.c_str());
+                 shortName);
     }
 }
 
-bool VisualBench::advanceRecordIfNecessary() {
-    if (fPicture) {
+bool VisualBench::advanceRecordIfNecessary(SkCanvas* canvas) {
+    if (fBenchmark) {
         return true;
     }
-    ++fCurrentPictureIdx;
-    while (true) {
-        if (fCurrentPictureIdx >= fRecords.count()) {
-            return false;
-        }
-        if (this->loadPicture()) {
-            return true;
-        }
-        fRecords.removeShuffle(fCurrentPictureIdx);
+
+    while ((fBenchmark = fBenchmarkStream->next()) &&
+           (SkCommandLineFlags::ShouldSkip(FLAGS_match, fBenchmark->getUniqueName()) ||
+            !fBenchmark->isSuitableFor(Benchmark::kGPU_Backend))) {}
+
+    if (!fBenchmark) {
+        return false;
     }
-}
 
-bool VisualBench::loadPicture() {
-    const char* fileName = fRecords[fCurrentPictureIdx].fFilename.c_str();
-    SkFILEStream stream(fileName);
-    if (stream.isValid()) {
-        fPicture.reset(SkPicture::CreateFromStream(&stream));
-        if (SkToBool(fPicture)) {
-            return true;
-        }
-    }
-    SkDebugf("couldn't load picture at \"%s\"\n", fileName);
-    return false;
+    canvas->clear(0xffffffff);
+    fBenchmark->preDraw();
+    fBenchmark->perCanvasPreDraw(canvas);
+    fRecords.push_back();
+    return true;
 }
 
 void VisualBench::preWarm(State nextState) {
     if (fCurrentFrame >= FLAGS_gpuFrameLag) {
         // we currently time across all frames to make sure we capture all GPU work
         fState = nextState;
         fCurrentFrame = 0;
         fTimer.start();
     } else {
         fCurrentFrame++;
     }
 }
 
 void VisualBench::draw(SkCanvas* canvas) {
-    if (!this->advanceRecordIfNecessary()) {
+    if (!this->advanceRecordIfNecessary(canvas)) {
         this->closeWindow();
         return;
     }
     this->renderFrame(canvas);
     switch (fState) {
         case kPreWarmLoops_State: {
             this->preWarm(kTuneLoops_State);
             break;
         }
         case kTuneLoops_State: {
@@ skipping 21 matching lines @@
             }
             break;
         }
         case kPreWarmTiming_State: {
             this->preWarm(kTiming_State);
             break;
         }
         case kTiming_State: {
             if (fCurrentFrame >= FLAGS_frames) {
                 fTimer.end();
-                fRecords[fCurrentPictureIdx].fMeasurements.push_back(
+                fRecords.back().fMeasurements.push_back(
                         fTimer.fWall / (FLAGS_frames * fLoops * fFlushes));
                 if (fCurrentSample++ >= FLAGS_samples) {
                     fState = kPreWarmLoops_State;
                     this->printStats();
-                    fPicture.reset(NULL);
+                    fBenchmark->perCanvasPostDraw(canvas);
+                    fBenchmark = NULL;
                     fCurrentSample = 0;
                     fFlushes = 1;
                     fLoops = 1;
                 } else {
                     fState = kPreWarmTiming_State;
                 }
                 fTimer = WallTimer();
                 this->resetContext();
                 fCurrentFrame = 0;
             } else {
@@ skipping 23 matching lines @@
 
 void application_term() {
     SkEvent::Term();
     SkGraphics::Term();
 }
 
 SkOSWindow* create_sk_window(void* hwnd, int argc, char** argv) {
     return new VisualBench(hwnd, argc, argv);
 }