Modify kilobench to run each sample in its own process

tools/kilobench/kilobench.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 "GrCaps.h"
 #include "GrContextFactory.h"
 #include "Benchmark.h"
+#include "ResultsWriter.h"
 #include "SkCommandLineFlags.h"
 #include "SkOSFile.h"
 #include "SkStream.h"
 #include "SkSurface.h"
 #include "SkTime.h"
 #include "Stats.h"
 #include "Timer.h"
 #include "VisualSKPBench.h"
 #include "gl/GrGLDefines.h"
 
+// posix only for now
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+
 /*
  * This is an experimental GPU only benchmarking program.  The initial implementation will only
  * support SKPs.
  */
 
 // To get image decoders linked in we have to do the below magic
 #include "SkForceLinking.h"
 #include "SkImageDecoder.h"
 __SK_FORCE_IMAGE_DECODER_LINKING;
 
@@ skipping 25 matching lines @@
                "^ and $ requires an exact match\n"
                "If a bench does not match any list entry,\n"
                "it is skipped unless some list entry starts with ~");
 DEFINE_int32(gpuFrameLag, 5, "If unknown, estimated maximum number of frames GPU allows to lag.");
 DEFINE_int32(samples, 10, "Number of samples to measure for each bench.");
 DEFINE_int32(maxLoops, 1000000, "Never run a bench more times than this.");
 DEFINE_int32(loops, kDefaultLoops, loops_help_txt().c_str());
 DEFINE_double(gpuMs, 5, "Target bench time in millseconds for GPU.");
 DEFINE_string2(writePath, w, "", "If set, write bitmaps here as .pngs.");
 
+static SkString humanize(double ms) {
+    return HumanizeMs(ms);
+}
+#define HUMANIZE(ms) humanize(ms).c_str()
+
 namespace kilobench {
 class BenchmarkStream {
 public:
     BenchmarkStream() : fCurrentSKP(0) {
         for (int i = 0; i < FLAGS_skps.count(); i++) {
             if (SkStrEndsWith(FLAGS_skps[i], ".skp")) {
                 fSKPs.push_back() = FLAGS_skps[i];
             } else {
                 SkOSFile::Iter it(FLAGS_skps[i], ".skp");
                 SkString path;
@@ skipping 239 matching lines @@
 
     // Pretty much the same deal as the calibration: do some warmup to make
     // sure we're timing steady-state pipelined frames.
     for (int i = 0; i < maxGpuFrameLag - 1; i++) {
         time(loops, bench, target);
     }
 
     return loops;
 }
 
-static SkString humanize(double ms) {
-    return HumanizeMs(ms);
-}
-#define HUMANIZE(ms) humanize(ms).c_str()
+struct AutoSetupContextBenchAndTarget {
+    AutoSetupContextBenchAndTarget(Benchmark* bench) : fBenchmark(bench) {
+        GrContextOptions grContextOpts;
+        fCtxFactory.reset(new GrContextFactory(grContextOpts));
 
-void benchmark_inner_loop(Benchmark* bench, GrContextFactory* ctxFactory) {
-    SkTArray<double> samples;
-    GPUTarget target;
-    SkAssertResult(target.init(bench, ctxFactory, false,
-                               GrContextFactory::kNative_GLContextType,
-                               GrContextFactory::kNone_GLContextOptions, 0));
+        SkAssertResult(fTarget.init(bench, fCtxFactory, false,
+                                    GrContextFactory::kNative_GLContextType,
+                                    GrContextFactory::kNone_GLContextOptions, 0));
 
-    SkCanvas* canvas = target.getCanvas();
-    target.setup();
+        fCanvas = fTarget.getCanvas();
+        fTarget.setup();
 
-    bench->perCanvasPreDraw(canvas);
-    int maxFrameLag;
-    target.needsFrameTiming(&maxFrameLag);
-    int loops = setup_gpu_bench(&target, bench, maxFrameLag);
-
-    samples.reset(FLAGS_samples);
-    for (int s = 0; s < FLAGS_samples; s++) {
-        samples[s] = time(loops, bench, &target) / loops;
+        bench->perCanvasPreDraw(fCanvas);
+        fTarget.needsFrameTiming(&fMaxFrameLag);
     }
 
-    bench->perCanvasPostDraw(canvas);
+    int getLoops() { return setup_gpu_bench(&fTarget, fBenchmark, fMaxFrameLag); }
 
-    Stats stats(samples);
-    const double stddev_percent = 100 * sqrt(stats.var) / stats.mean;
-    SkDebugf("%d\t%s\t%s\t%s\t%s\t%.0f%%\t%s\t%s\t%s\n"
-            , loops
-            , HUMANIZE(stats.min)
-            , HUMANIZE(stats.median)
-            , HUMANIZE(stats.mean)
-            , HUMANIZE(stats.max)
-            , stddev_percent
-            , stats.plot.c_str()
-            , "gpu"
-            , bench->getUniqueName()
-            );
+    double timeSample(int loops) {
+        for (int i = 0; i < fMaxFrameLag; i++) {
+            time(loops, fBenchmark, &fTarget);
+        }
+
+        return time(loops, fBenchmark, &fTarget) / loops;
+    }
+    void teardownBench() { fBenchmark->perCanvasPostDraw(fCanvas); }
+
+    SkAutoTDelete<GrContextFactory> fCtxFactory;
+    GPUTarget fTarget;
+    SkCanvas* fCanvas;
+    Benchmark* fBenchmark;
+    int fMaxFrameLag;
+};
+
+int setup_loops(Benchmark* bench) {
+    AutoSetupContextBenchAndTarget ascbt(bench);
+    int loops = ascbt.getLoops();
+    ascbt.teardownBench();
 
     if (!FLAGS_writePath.isEmpty() && FLAGS_writePath[0]) {
         SkString pngFilename = SkOSPath::Join(FLAGS_writePath[0], "gpu");
         pngFilename = SkOSPath::Join(pngFilename.c_str(), bench->getUniqueName());
         pngFilename.append(".png");
-        write_canvas_png(&target, pngFilename);
+        write_canvas_png(&ascbt.fTarget, pngFilename);
     }
+    return loops;
+}
+
+double time_sample(Benchmark* bench, int loops) {
+    AutoSetupContextBenchAndTarget ascbt(bench);
+    double sample = ascbt.timeSample(loops);
+    ascbt.teardownBench();
+
+    return sample;
 }
 
 } // namespace kilobench
 
+static const int kOutResultSize = 1024;
+
 int kilobench_main() {
-    SkAutoTDelete<GrContextFactory> ctxFactory;
-
-    GrContextOptions grContextOpts;
-    ctxFactory.reset(new GrContextFactory(grContextOpts));
-
     kilobench::BenchmarkStream benchStream;
 
     SkDebugf("loops\tmin\tmedian\tmean\tmax\tstddev\t%-*s\tconfig\tbench\n",
              FLAGS_samples, "samples");
 
+    int descriptors[2];
+    if (pipe(descriptors) != 0) {
+        SkFAIL("Failed to open a pipe\n");
+    }
+
     while (Benchmark* b = benchStream.next()) {
         SkAutoTDelete<Benchmark> bench(b);
-        kilobench::benchmark_inner_loop(bench.get(), ctxFactory.get());
+
+        int loops;
+        SkTArray<double> samples;
+        for (int i = 0; i < FLAGS_samples + 1; i++) {
+            // We fork off a new process to setup the grcontext and run the test while we wait
+            int childPid = fork();
+            if (childPid > 0) {
+                char result[kOutResultSize];
+                if (read(descriptors[0], result, kOutResultSize) < 0) {
+                     SkFAIL("Failed to read from pipe\n");
+                }
+
+                // if samples == 0 then parse # of loops
+                // else parse float
+                if (i == 0) {
+                    sscanf(result, "%d", &loops);
+                } else {
+                    sscanf(result, "%lf", &samples.push_back());
+                }
+
+                // wait until exit
+                int status;
+                waitpid(childPid, &status, 0);
+            } else if (0 == childPid) {
+                char result[kOutResultSize];
+                if (i == 0) {
+                    sprintf(result, "%d", kilobench::setup_loops(bench));
+                } else {
+                    sprintf(result, "%lf", kilobench::time_sample(bench, loops));
+                }
+
+                // Make sure to write the null terminator
+                if (write(descriptors[1], result, strlen(result) + 1) < 0) {
+                    SkFAIL("Failed to write to pipe\n");
+                }
+                return 0;
+            } else {
+                SkFAIL("Fork failed\n");
+            }
+        }
+
+        Stats stats(samples);
+        const double stddev_percent = 100 * sqrt(stats.var) / stats.mean;
+        SkDebugf("%d\t%s\t%s\t%s\t%s\t%.0f%%\t%s\t%s\t%s\n"
+                , loops
+                , HUMANIZE(stats.min)
+                , HUMANIZE(stats.median)
+                , HUMANIZE(stats.mean)
+                , HUMANIZE(stats.max)
+                , stddev_percent
+                , stats.plot.c_str()
+                , "gpu"
+                , bench->getUniqueName()
+                );
+
     }
-
-    // Make sure we clean up the global GrContextFactory here, otherwise we might race with the
-    // SkEventTracer destructor
-    ctxFactory.reset(nullptr);
     return 0;
 }
 
 #if !defined SK_BUILD_FOR_IOS
 int main(int argc, char** argv) {
     SkCommandLineFlags::Parse(argc, argv);
     return kilobench_main();
 }
 #endif