Minor tweak to visual bench timing

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"
 
@@ skipping 12 matching lines @@
 
 __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.");
 DEFINE_string(key, "", "");  // dummy to enable gm tests that have platform-specific names
 DEFINE_string(outResultsFile, "", "If given, write results here as JSON.");
 DEFINE_string(properties, "",
               "Space-separated key/value pairs to add to JSON identifying this run.");
 
 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)
     , fCurrentSample(0)
     , fCurrentFrame(0)
-    , fFlushes(1)
     , fLoops(1)
     , fState(kPreWarmLoops_State)
     , fBenchmark(nullptr)
     , fResults(new ResultsWriter) {
     SkCommandLineFlags::Parse(argc, argv);
 
     this->setTitle();
     this->setupBackend();
 
     fBenchmarkStream.reset(new VisualBenchmarkStream);
@@ skipping 69 matching lines @@
     this->setupRenderTarget();
 }
 
 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++) {
-        fBenchmark->draw(fLoops, canvas);
-        canvas->flush();
-    }
+    fBenchmark->draw(fLoops, canvas);
+    canvas->flush();
     INHERITED::present();
 }
 
 void VisualBench::printStats() {
     const SkTArray<double>& measurements = fRecords.back().fMeasurements;
     const char* shortName = fBenchmark->getUniqueName();
 
     // update log
     // Note: We currently log only the minimum.  It would be interesting to log more information
     SkString configName;
     if (FLAGS_msaa > 0) {
         configName.appendf("msaa_%d", FLAGS_msaa);
     } else {
         configName.appendf("gpu");
     }
     fResults->config(configName.c_str());
     fResults->configOption("name", fBenchmark->getUniqueName());
     SkASSERT(measurements.count());
     Stats stats(measurements);
     fResults->metric("min_ms",    stats.min);
 
     // Print output
     if (FLAGS_verbose) {
         for (int i = 0; i < measurements.count(); i++) {
             SkDebugf("%s  ", HUMANIZE(measurements[i]));
         }
         SkDebugf("%s\n", shortName);
     } else {
         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",
+        SkDebugf("%4d/%-4dMB\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);
     }
 }
 
 bool VisualBench::advanceRecordIfNecessary(SkCanvas* canvas) {
@@ skipping 82 matching lines @@
 
 void VisualBench::resetTimingState() {
     fCurrentFrame = 0;
     fTimer = WallTimer();
     this->resetContext();
 }
 
 void VisualBench::scaleLoops(double elapsedMs) {
     // Scale back the number of loops
     fLoops = (int)ceil(fLoops * FLAGS_loopMs / elapsedMs);
-    fFlushes = (int)ceil(FLAGS_flushMs / elapsedMs);
 }
 
 inline void VisualBench::tuneLoops() {
     if (1 << 30 == fLoops) {
         // We're about to wrap.  Something's wrong with the bench.
         SkDebugf("InnerLoops wrapped\n");
         fLoops = 0;
     } else {
         double elapsedMs = this->elapsed();
         if (elapsedMs > FLAGS_loopMs) {
             this->scaleLoops(elapsedMs);
             this->nextState(kPreWarmTimingPerCanvasPreDraw_State);
         } else {
             fLoops *= 2;
             this->nextState(kPreWarmLoops_State);
         }
         this->resetTimingState();
     }
 }
 
 void VisualBench::recordMeasurement() {
-    double measurement = this->elapsed() / (FLAGS_frames * fLoops * fFlushes);
+    double measurement = this->elapsed() / (FLAGS_frames * fLoops);
     fRecords.back().fMeasurements.push_back(measurement);
 }
 
 void VisualBench::postDraw(SkCanvas* canvas) {
     fBenchmark->perCanvasPostDraw(canvas);
     fBenchmark.reset(nullptr);
     fCurrentSample = 0;
-    fFlushes = 1;
     fLoops = 1;
 }
 
 inline void VisualBench::timing(SkCanvas* canvas) {
     if (fCurrentFrame >= FLAGS_frames) {
         this->recordMeasurement();
         if (fCurrentSample++ >= FLAGS_samples) {
             this->printStats();
             this->postDraw(canvas);
             this->nextState(kPreWarmLoopsPerCanvasPreDraw_State);
@@ skipping 22 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);
 }