Revert of skpbench: add option for gpu timing

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 "GpuTimer.h"
 #include "GrContextFactory.h"
 #include "SkCanvas.h"
 #include "SkOSFile.h"
 #include "SkPicture.h"
 #include "SkStream.h"
 #include "SkSurface.h"
 #include "SkSurfaceProps.h"
 #include "picture_utils.h"
 #include "flags/SkCommandLineFlags.h"
 #include "flags/SkCommonFlagsConfig.h"
 #include <stdlib.h>
 #include <algorithm>
 #include <array>
 #include <chrono>
 #include <cmath>
 #include <vector>
 
 /**
  * This is a minimalist program whose sole purpose is to open an skp file, benchmark it on a single
  * config, and exit. It is intended to be used through skpbench.py rather than invoked directly.
  * Limiting the entire process to a single config/skp pair helps to keep the results repeatable.
  *
  * No tiling, looping, or other fanciness is used; it just draws the skp whole into a size-matched
  * render target and syncs the GPU after each draw.
  *
  * Currently, only GPU configs are supported.
  */
 
+using sk_gpu_test::PlatformFence;
+using sk_gpu_test::kInvalidPlatformFence;
+using sk_gpu_test::FenceSync;
+
 DEFINE_int32(duration, 5000, "number of milliseconds to run the benchmark");
 DEFINE_int32(sampleMs, 50, "minimum duration of a sample");
-DEFINE_bool(gpuClock, false, "time on the gpu clock (gpu work only)");
 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 =
-"   accum    median       max       min   stddev  samples  sample_ms  clock  metric  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%%  %7li  %9i  %-5s  %-6s  %-9s %s";
+    "%8.4g  %8.4g  %8.4g  %8.4g  %6.3g%%  %7li  %9i  %-6s  %-9s %s";
 
 struct Sample {
-    using duration = std::chrono::nanoseconds;
+    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"; }
 
-    int        fFrames;
-    duration   fDuration;
+    int fFrames;
+    clock::duration fDuration;
 };
 
 class GpuSync {
 public:
-    GpuSync(const sk_gpu_test::FenceSync* fenceSync);
+    GpuSync(const FenceSync* fenceSync);
     ~GpuSync();
 
     void syncToPreviousFrame();
 
 private:
     void updateFence();
 
-    const sk_gpu_test::FenceSync* const   fFenceSync;
-    sk_gpu_test::PlatformFence            fFence;
+    const FenceSync* const   fFenceSync;
+    PlatformFence            fFence;
 };
 
 enum class ExitErr {
     kOk           = 0,
     kUsage        = 64,
     kData         = 65,
     kUnavailable  = 69,
     kIO           = 74,
     kSoftware     = 70
 };
 
 static void draw_skp_and_flush(SkCanvas*, const SkPicture*);
 static bool mkdir_p(const SkString& name);
 static SkString join(const SkCommandLineFlags::StringArray&);
 static void exitf(ExitErr, const char* format, ...);
 
-static void run_benchmark(const sk_gpu_test::FenceSync* fenceSync, SkCanvas* canvas,
-                          const SkPicture* skp, std::vector<Sample>* samples) {
-    using clock = std::chrono::high_resolution_clock;
-    const Sample::duration sampleDuration = std::chrono::milliseconds(FLAGS_sampleMs);
+static void run_benchmark(const FenceSync* fenceSync, SkCanvas* canvas, const SkPicture* skp,
+                          std::vector<Sample>* samples) {
+    using clock = Sample::clock;
+    const clock::duration sampleDuration = std::chrono::milliseconds(FLAGS_sampleMs);
     const clock::duration benchDuration = std::chrono::milliseconds(FLAGS_duration);
 
     draw_skp_and_flush(canvas, skp);
     GpuSync gpuSync(fenceSync);
 
     draw_skp_and_flush(canvas, skp);
     gpuSync.syncToPreviousFrame();
 
     clock::time_point now = clock::now();
     const clock::time_point endTime = now + benchDuration;
 
     do {
         clock::time_point sampleStart = now;
         samples->emplace_back();
         Sample& sample = samples->back();
 
         do {
             draw_skp_and_flush(canvas, skp);
             gpuSync.syncToPreviousFrame();
 
             now = clock::now();
             sample.fDuration = now - sampleStart;
             ++sample.fFrames;
         } while (sample.fDuration < sampleDuration);
     } while (now < endTime || 0 == samples->size() % 2);
 }
 
-static void run_gpu_time_benchmark(sk_gpu_test::GpuTimer* gpuTimer,
-                                   const sk_gpu_test::FenceSync* fenceSync, SkCanvas* canvas,
-                                   const SkPicture* skp, std::vector<Sample>* samples) {
-    using sk_gpu_test::PlatformTimerQuery;
-    using clock = std::chrono::steady_clock;
-    const clock::duration sampleDuration = std::chrono::milliseconds(FLAGS_sampleMs);
-    const clock::duration benchDuration = std::chrono::milliseconds(FLAGS_duration);
-
-    if (!gpuTimer->disjointSupport()) {
-        fprintf(stderr, "WARNING: GPU timer cannot detect disjoint operations; "
-                        "results may be unreliable\n");
-    }
-
-    draw_skp_and_flush(canvas, skp);
-    GpuSync gpuSync(fenceSync);
-
-    gpuTimer->queueStart();
-    draw_skp_and_flush(canvas, skp);
-    PlatformTimerQuery previousTime = gpuTimer->queueStop();
-    gpuSync.syncToPreviousFrame();
-
-    clock::time_point now = clock::now();
-    const clock::time_point endTime = now + benchDuration;
-
-    do {
-        const clock::time_point sampleEndTime = now + sampleDuration;
-        samples->emplace_back();
-        Sample& sample = samples->back();
-
-        do {
-            gpuTimer->queueStart();
-            draw_skp_and_flush(canvas, skp);
-            PlatformTimerQuery time = gpuTimer->queueStop();
-            gpuSync.syncToPreviousFrame();
-
-            switch (gpuTimer->checkQueryStatus(previousTime)) {
-                using QueryStatus = sk_gpu_test::GpuTimer::QueryStatus;
-                case QueryStatus::kInvalid:
-                    exitf(ExitErr::kUnavailable, "GPU timer failed");
-                case QueryStatus::kPending:
-                    exitf(ExitErr::kUnavailable, "timer query still not ready after fence sync");
-                case QueryStatus::kDisjoint:
-                    if (FLAGS_verbosity >= 4) {
-                        fprintf(stderr, "discarding timer query due to disjoint operations.\n");
-                    }
-                    break;
-                case QueryStatus::kAccurate:
-                    sample.fDuration += gpuTimer->getTimeElapsed(previousTime);
-                    ++sample.fFrames;
-                    break;
-            }
-            gpuTimer->deleteQuery(previousTime);
-            previousTime = time;
-            now = clock::now();
-        } while (now < sampleEndTime || 0 == sample.fFrames);
-    } while (now < endTime || 0 == samples->size() % 2);
-
-    gpuTimer->deleteQuery(previousTime);
-}
-
 void print_result(const std::vector<Sample>& samples, const char* config, const char* bench)  {
     if (0 == (samples.size() % 2)) {
         exitf(ExitErr::kSoftware, "attempted to gather stats on even number of samples");
     }
 
     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 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, accumValue, values[values.size() / 2], values.back(), values.front(),
-           stddev, values.size(), FLAGS_sampleMs, FLAGS_gpuClock ? "gpu" : "cpu", Sample::metric(),
-           config, bench);
+           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 77 matching lines @@
     if (FLAGS_sampleMs > 0) {
         // +1 because we might take one more sample in order to have an odd number.
         samples.reserve(1 + (FLAGS_duration + FLAGS_sampleMs - 1) / FLAGS_sampleMs);
     } else {
         samples.reserve(2 * FLAGS_duration);
     }
 
     // Run the benchmark.
     SkCanvas* canvas = surface->getCanvas();
     canvas->translate(-skp->cullRect().x(), -skp->cullRect().y());
-    if (!FLAGS_gpuClock) {
-        run_benchmark(testCtx->fenceSync(), canvas, skp.get(), &samples);
-    } else {
-        if (!testCtx->gpuTimingSupport()) {
-            exitf(ExitErr::kUnavailable, "GPU does not support timing");
-        }
-        run_gpu_time_benchmark(testCtx->gpuTimer(), testCtx->fenceSync(), canvas, skp.get(),
-                               &samples);
-    }
+    run_benchmark(testCtx->fenceSync(), canvas, skp.get(), &samples);
     print_result(samples, config->getTag().c_str(), SkOSPath::Basename(skpfile).c_str());
 
     // Save a proof (if one was requested).
     if (!FLAGS_png.isEmpty()) {
         SkBitmap bmp;
         bmp.setInfo(info);
         if (!surface->getCanvas()->readPixels(&bmp, 0, 0)) {
             exitf(ExitErr::kUnavailable, "failed to read canvas pixels for png");
         }
         const SkString &dirname = SkOSPath::Dirname(FLAGS_png[0]),
@@ skipping 32 matching lines @@
 static void exitf(ExitErr err, const char* format, ...) {
     fprintf(stderr, ExitErr::kSoftware == err ? "INTERNAL ERROR: " : "ERROR: ");
     va_list args;
     va_start(args, format);
     vfprintf(stderr, format, args);
     va_end(args);
     fprintf(stderr, ExitErr::kSoftware == err ? "; this should never happen.\n": ".\n");
     exit((int)err);
 }
 
-GpuSync::GpuSync(const sk_gpu_test::FenceSync* fenceSync)
+GpuSync::GpuSync(const FenceSync* fenceSync)
     : fFenceSync(fenceSync) {
     this->updateFence();
 }
 
 GpuSync::~GpuSync() {
     fFenceSync->deleteFence(fFence);
 }
 
 void GpuSync::syncToPreviousFrame() {
-    if (sk_gpu_test::kInvalidFence == fFence) {
+    if (kInvalidPlatformFence == fFence) {
         exitf(ExitErr::kSoftware, "attempted to sync with invalid fence");
     }
     if (!fFenceSync->waitFence(fFence)) {
         exitf(ExitErr::kUnavailable, "failed to wait for fence");
     }
     fFenceSync->deleteFence(fFence);
     this->updateFence();
 }
 
 void GpuSync::updateFence() {
     fFence = fFenceSync->insertFence();
-    if (sk_gpu_test::kInvalidFence == fFence) {
+    if (kInvalidPlatformFence == fFence) {
         exitf(ExitErr::kUnavailable, "failed to insert fence");
     }
 }