skpbench: add warmup run

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 "SkPerlinNoiseShader.h"
 #include "SkPicture.h"
+#include "SkPictureRecorder.h"
 #include "SkStream.h"
 #include "SkSurface.h"
 #include "SkSurfaceProps.h"
 #include "picture_utils.h"
+#include "sk_tool_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.
  */
 
 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(skp, "", "path to a single .skp file, or 'warmup' for a builtin warmup run");
 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";
 
 static const char* resultFormat =
 "%8.4g  %8.4g  %8.4g  %8.4g  %6.3g%%  %7li  %9i  %-5s  %-6s  %-9s %s";
 
@@ skipping 27 matching lines @@
 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 sk_sp<SkPicture> create_warmup_skp();
 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);
     const clock::duration benchDuration = std::chrono::milliseconds(FLAGS_duration);
 
@@ skipping 124 matching lines @@
     }
     if (FLAGS_duration <= 0) {
         exit(0); // This can be used to print the header and quit.
     }
 
     // Parse the config.
     const SkCommandLineConfigGpu* config = nullptr; // Initialize for spurious warning.
     SkCommandLineConfigArray configs;
     ParseConfigs(FLAGS_config, &configs);
     if (configs.count() != 1 || !(config = configs[0]->asConfigGpu())) {
-        exitf(ExitErr::kUsage, "invalid config %s, must specify one (and only one) GPU config",
+        exitf(ExitErr::kUsage, "invalid config '%s': must specify one (and only one) GPU config",
                                join(FLAGS_config).c_str());
     }
 
     // Parse the skp.
     if (FLAGS_skp.count() != 1) {
-        exitf(ExitErr::kUsage, "invalid skp %s, must specify (and only one) skp path name.",
+        exitf(ExitErr::kUsage, "invalid skp '%s': must specify a single skp file, or 'warmup'",
                                join(FLAGS_skp).c_str());
     }
-    const char* skpfile = FLAGS_skp[0];
-    std::unique_ptr<SkStream> skpstream(SkStream::MakeFromFile(skpfile));
-    if (!skpstream) {
-        exitf(ExitErr::kIO, "failed to open skp file %s", skpfile);
-    }
-    sk_sp<SkPicture> skp = SkPicture::MakeFromStream(skpstream.get());
-    if (!skp) {
-        exitf(ExitErr::kData, "failed to parse skp file %s", skpfile);
+    sk_sp<SkPicture> skp;
+    SkString skpname;
+    if (0 == strcmp(FLAGS_skp[0], "warmup")) {
+        skp = create_warmup_skp();
+        skpname = "warmup";
+    } else {
+        const char* skpfile = FLAGS_skp[0];
+        std::unique_ptr<SkStream> skpstream(SkStream::MakeFromFile(skpfile));
+        if (!skpstream) {
+            exitf(ExitErr::kIO, "failed to open skp file %s", skpfile);
+        }
+        skp = SkPicture::MakeFromStream(skpstream.get());
+        if (!skp) {
+            exitf(ExitErr::kData, "failed to parse skp file %s", skpfile);
+        }
+        skpname = SkOSPath::Basename(skpfile);
     }
     int width = SkTMin(SkScalarCeilToInt(skp->cullRect().width()), 2048),
         height = SkTMin(SkScalarCeilToInt(skp->cullRect().height()), 2048);
     if (FLAGS_verbosity >= 3 &&
         (width != skp->cullRect().width() || height != skp->cullRect().height())) {
         fprintf(stderr, "%s is too large (%ix%i), cropping to %ix%i.\n",
-                        SkOSPath::Basename(skpfile).c_str(),
-                        SkScalarCeilToInt(skp->cullRect().width()),
+                        skpname.c_str(), SkScalarCeilToInt(skp->cullRect().width()),
                         SkScalarCeilToInt(skp->cullRect().height()), width, height);
     }
 
     // Create a context.
     sk_gpu_test::GrContextFactory factory;
     sk_gpu_test::ContextInfo ctxInfo =
         factory.getContextInfo(config->getContextType(), config->getContextOptions());
     GrContext* ctx = ctxInfo.grContext();
     if (!ctx) {
         exitf(ExitErr::kUnavailable, "failed to create context for config %s",
@@ skipping 20 matching lines @@
                                          kPremul_SkAlphaType, sk_ref_sp(config->getColorSpace()));
     uint32_t flags = config->getUseDIText() ? SkSurfaceProps::kUseDeviceIndependentFonts_Flag : 0;
     SkSurfaceProps props(flags, SkSurfaceProps::kLegacyFontHost_InitType);
     sk_sp<SkSurface> surface =
         SkSurface::MakeRenderTarget(ctx, SkBudgeted::kNo, info, config->getSamples(), &props);
     if (!surface) {
         exitf(ExitErr::kUnavailable, "failed to create %ix%i render target for config %s",
                                      width, height, config->getTag().c_str());
     }
 
+    // Run the benchmark.
     std::vector<Sample> samples;
     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);
     }
-    print_result(samples, config->getTag().c_str(), SkOSPath::Basename(skpfile).c_str());
+    print_result(samples, config->getTag().c_str(), skpname.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]),
                        &basename = SkOSPath::Basename(FLAGS_png[0]);
         if (!mkdir_p(dirname)) {
             exitf(ExitErr::kIO, "failed to create directory \"%s\" for png", dirname.c_str());
         }
         if (!sk_tools::write_bitmap_to_disk(bmp, dirname, nullptr, basename)) {
             exitf(ExitErr::kIO, "failed to save png to \"%s\"", FLAGS_png[0]);
         }
     }
 
     exit(0);
 }
 
 static void draw_skp_and_flush(SkCanvas* canvas, const SkPicture* skp) {
     canvas->drawPicture(skp);
     canvas->flush();
 }
 
+static sk_sp<SkPicture> create_warmup_skp() {
+    static constexpr SkRect bounds{0, 0, 500, 500};
+    SkPictureRecorder recorder;
+    SkCanvas* recording = recorder.beginRecording(bounds);
+
+    recording->clear(SK_ColorWHITE);
+
+    SkPaint stroke;
+    stroke.setStyle(SkPaint::kStroke_Style);
+    stroke.setStrokeWidth(2);
+
+    // Use a big path to (theoretically) warmup the CPU.
+    SkPath bigPath;
+    sk_tool_utils::make_big_path(bigPath);
+    recording->drawPath(bigPath, stroke);
+
+    // Use a perlin shader to warmup the GPU.
+    SkPaint perlin;
+    perlin.setShader(SkPerlinNoiseShader::MakeTurbulence(0.1f, 0.1f, 1, 0, nullptr));
+    recording->drawRect(bounds, perlin);
+
+    return recorder.finishRecordingAsPicture();
+}
+
 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]);
+    for (int i = 0; i < stringArray.count(); ++i) {
+        joined.appendf(i ? " %s" : "%s", stringArray[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);
@@ skipping 20 matching lines @@
     fFenceSync->deleteFence(fFence);
     this->updateFence();
 }
 
 void GpuSync::updateFence() {
     fFence = fFenceSync->insertFence();
     if (sk_gpu_test::kInvalidFence == fFence) {
         exitf(ExitErr::kUnavailable, "failed to insert fence");
     }
 }