skpbench: use accumulative result as the default

tools/skpbench/skpbench.cpp

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrContextFactory.h"
 #include "SkCanvas.h"
 #include "SkOSFile.h"
@@ skipping 24 matching lines @@
 
 DEFINE_int32(duration, 5000, "number of milliseconds to run the benchmark");
 DEFINE_int32(sampleMs, 50, "minimum duration of a sample");
 DEFINE_bool(fps, false, "use fps instead of ms");
 DEFINE_string(skp, "", "path to a single .skp file to benchmark");
 DEFINE_string(png, "", "if set, save a .png proof to disk at this file location");
 DEFINE_int32(verbosity, 4, "level of verbosity (0=none to 5=debug)");
 DEFINE_bool(suppressHeader, false, "don't print a header row before the results");
 
 static const char* header =
-    "  median     accum       max       min   stddev  metric  samples  sample_ms  config    bench";
+    "   accum    median       max       min   stddev  samples  sample_ms  metric  config    bench";
 
 static const char* resultFormat =
-    "%8.4g  %8.4g  %8.4g  %8.4g  %6.3g%%  %-6s  %7li  %9i  %-9s %s";
+    "%8.4g  %8.4g  %8.4g  %8.4g  %6.3g%%  %7li  %9i  %-6s  %-9s %s";
 
 struct Sample {
     using clock = std::chrono::high_resolution_clock;
 
     Sample() : fFrames(0), fDuration(0) {}
     double seconds() const { return std::chrono::duration<double>(fDuration).count(); }
     double ms() const { return std::chrono::duration<double, std::milli>(fDuration).count(); }
     double value() const { return FLAGS_fps ? fFrames / this->seconds() : this->ms() / fFrames; }
     static const char* metric() { return FLAGS_fps ? "fps" : "ms"; }
 
@@ skipping 67 matching lines @@
 
     Sample accum = Sample();
     std::vector<double> values;
     values.reserve(samples.size());
     for (const Sample& sample : samples) {
         accum.fFrames += sample.fFrames;
         accum.fDuration += sample.fDuration;
         values.push_back(sample.value());
     }
     std::sort(values.begin(), values.end());
-    const double medianValue = values[values.size() / 2];
+
     const double accumValue = accum.value();
-
     double variance = 0;
     for (double value : values) {
         const double delta = value - accumValue;
         variance += delta * delta;
     }
     variance /= values.size();
     // Technically, this is the relative standard deviation.
     const double stddev = 100/*%*/ * sqrt(variance) / accumValue;
 
-    printf(resultFormat, medianValue, accumValue, values.back(), values.front(), stddev,
-           Sample::metric(), values.size(), FLAGS_sampleMs, config, bench);
+    printf(resultFormat, accumValue, values[values.size() / 2], values.back(), values.front(),
+           stddev, values.size(), FLAGS_sampleMs, Sample::metric(), config, bench);
     printf("\n");
     fflush(stdout);
 }
 
 int main(int argc, char** argv) {
     SkCommandLineFlags::SetUsage("Use skpbench.py instead. "
                                  "You usually don't want to use this program directly.");
     SkCommandLineFlags::Parse(argc, argv);
 
     if (!FLAGS_suppressHeader) {
@@ skipping 156 matching lines @@
     fFenceSync->deleteFence(fFence);
     this->updateFence();
 }
 
 void GpuSync::updateFence() {
     fFence = fFenceSync->insertFence();
     if (kInvalidPlatformGpuFence == fFence) {
         exitf(ExitErr::kUnavailable, "failed to insert fence");
     }
 }