skpbench: use double buffering instead of triple

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 42 matching lines @@
     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;
     clock::duration fDuration;
 };
 
+class GpuSync {
+public:
+    GpuSync(const SkGpuFenceSync* fenceSync);
+    ~GpuSync();
+
+    void syncToPreviousFrame();
+
+private:
+    void updateFence();
+
+    const SkGpuFenceSync* const   fFenceSync;
+    SkPlatformGpuFence            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 SkPlatformGpuFence insert_verified_fence(const SkGpuFenceSync*);
-static void wait_fence_and_delete(const SkGpuFenceSync*, SkPlatformGpuFence);
 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 SkGpuFenceSync* sync, SkCanvas* canvas, const SkPicture* skp,
+static void run_benchmark(const SkGpuFenceSync* 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);
 
-    // Prime the graphics pipe.
-    SkPlatformGpuFence frameN_minus_2, frameN_minus_1;
-    {
-        draw_skp_and_flush(canvas, skp);
-        SkPlatformGpuFence frame0 = insert_verified_fence(sync);
+    draw_skp_and_flush(canvas, skp);
+    GpuSync gpuSync(fenceSync);
 
-        draw_skp_and_flush(canvas, skp);
-        frameN_minus_2 = insert_verified_fence(sync);
-
-        draw_skp_and_flush(canvas, skp);
-        frameN_minus_1 = insert_verified_fence(sync);
-
-        wait_fence_and_delete(sync, frame0);
-    }
+    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);
-
-            // Sync the GPU.
-            wait_fence_and_delete(sync, frameN_minus_2);
-            frameN_minus_2 = frameN_minus_1;
-            frameN_minus_1 = insert_verified_fence(sync);
+            gpuSync.syncToPreviousFrame();
 
             now = clock::now();
             sample.fDuration = now - sampleStart;
             ++sample.fFrames;
         } while (sample.fDuration < sampleDuration);
     } while (now < endTime || 0 == samples->size() % 2);
-
-    sync->deleteFence(frameN_minus_2);
-    sync->deleteFence(frameN_minus_1);
 }
 
 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());
@@ skipping 135 matching lines @@
     }
 
     exit(0);
 }
 
 static void draw_skp_and_flush(SkCanvas* canvas, const SkPicture* skp) {
     canvas->drawPicture(skp);
     canvas->flush();
 }
 
-static SkPlatformGpuFence insert_verified_fence(const SkGpuFenceSync* sync) {
-    SkPlatformGpuFence fence = sync->insertFence();
-    if (kInvalidPlatformGpuFence == fence) {
-        exitf(ExitErr::kUnavailable, "failed to insert fence");
-    }
-    return fence;
-}
-
-static void wait_fence_and_delete(const SkGpuFenceSync* sync, SkPlatformGpuFence fence) {
-    if (kInvalidPlatformGpuFence == fence) {
-        exitf(ExitErr::kSoftware, "attempted to wait on invalid fence");
-    }
-    if (!sync->waitFence(fence)) {
-        exitf(ExitErr::kUnavailable, "failed to wait for fence");
-    }
-    sync->deleteFence(fence);
-}
-
 bool mkdir_p(const SkString& dirname) {
     if (dirname.isEmpty()) {
         return true;
     }
     return mkdir_p(SkOSPath::Dirname(dirname.c_str())) && sk_mkdir(dirname.c_str());
 }
 
 static SkString join(const SkCommandLineFlags::StringArray& stringArray) {
     SkString joined;
     for (int i = 0; i < FLAGS_config.count(); ++i) {
         joined.appendf(i ? " %s" : "%s", FLAGS_config[i]);
     }
     return joined;
 }
 
 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 SkGpuFenceSync* fenceSync)
+    : fFenceSync(fenceSync) {
+    this->updateFence();
+}
+
+GpuSync::~GpuSync() {
+    fFenceSync->deleteFence(fFence);
+}
+
+void GpuSync::syncToPreviousFrame() {
+    if (kInvalidPlatformGpuFence == 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 (kInvalidPlatformGpuFence == fFence) {
+        exitf(ExitErr::kUnavailable, "failed to insert fence");
+    }
+}