Fix nanobench to reset gl/gr context after every config run.

bench/nanobench.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include <ctype.h>
 
 #include "nanobench.h"
@@ skipping 470 matching lines @@
         break;
     }
 
     if (!target->init(info, bench)) {
         delete target;
         return NULL;
     }
     return target;
 }
 
-// Creates targets for a benchmark and a set of configs.
-static void create_targets(SkTDArray<Target*>* targets, Benchmark* b,
-                           const SkTDArray<Config>& configs) {
-    for (int i = 0; i < configs.count(); ++i) {
-        if (Target* t = is_enabled(b, configs[i])) {
-            targets->push(t);
-        }
-
-    }
-}
-
 /*
  * Returns true if set up for a subset decode succeeds, false otherwise
  * If the set-up succeeds, the width and height parameters will be set
  */
 static bool valid_subset_bench(const SkString& path, SkColorType colorType, bool useCodec,
         int* width, int* height) {
     SkAutoTUnref<SkData> encoded(SkData::NewFromFileName(path.c_str()));
     SkAutoTDelete<SkMemoryStream> stream(new SkMemoryStream(encoded));
 
     // Check that we can create a codec or image decoder.
@@ skipping 39 matching lines @@
 
     // Check if the image is large enough for a meaningful subset benchmark.
     if (*width <= 512 && *height <= 512) {
         // This should not print a message since it is not an error.
         return false;
     }
 
     return true;
 }
 
+static void cleanup_run(Target* target) {
+    SkDELETE(target);
+#if SK_SUPPORT_GPU
+    if (FLAGS_abandonGpuContext) {
+        gGrFactory->abandonContexts();
+    }
+    if (FLAGS_resetGpuContext || FLAGS_abandonGpuContext) {
+        gGrFactory->destroyContexts();
+    }
+#endif
+}
+
 class BenchmarkStream {
 public:
     BenchmarkStream() : fBenches(BenchRegistry::Head())
                       , fGMs(skiagm::GMRegistry::Head())
                       , fCurrentRecording(0)
                       , fCurrentScale(0)
                       , fCurrentSKP(0)
                       , fCurrentUseMPD(0)
                       , fCurrentCodec(0)
                       , fCurrentImage(0)
@@ skipping 448 matching lines @@
     create_configs(&configs);
 
     int runs = 0;
     BenchmarkStream benchStream;
     while (Benchmark* b = benchStream.next()) {
         SkAutoTDelete<Benchmark> bench(b);
         if (SkCommandLineFlags::ShouldSkip(FLAGS_match, bench->getUniqueName())) {
             continue;
         }
 
-        SkTDArray<Target*> targets;
-        create_targets(&targets, bench.get(), configs);
-
-        if (!targets.isEmpty()) {
+        if (!configs.isEmpty()) {
             log->bench(bench->getUniqueName(), bench->getSize().fX, bench->getSize().fY);
             bench->preDraw();
         }
-        for (int j = 0; j < targets.count(); j++) {
+        for (int i = 0; i < configs.count(); ++i) {
+            Target* target = is_enabled(b, configs[i]);
+            if (!target) {
+                continue;
+            }
+
             // During HWUI output this canvas may be NULL.
-            SkCanvas* canvas = targets[j]->getCanvas();
-            const char* config = targets[j]->config.name;
+            SkCanvas* canvas = target->getCanvas();
+            const char* config = target->config.name;
 
-            targets[j]->setup();
+            target->setup();
             bench->perCanvasPreDraw(canvas);
 
             int maxFrameLag;
-            const int loops = targets[j]->needsFrameTiming(&maxFrameLag)
-                ? setup_gpu_bench(targets[j], bench.get(), maxFrameLag)
-                : setup_cpu_bench(overhead, targets[j], bench.get());
+            const int loops = target->needsFrameTiming(&maxFrameLag)
+                ? setup_gpu_bench(target, bench.get(), maxFrameLag)
+                : setup_cpu_bench(overhead, target, bench.get());
 
             if (kTimedSampling != FLAGS_samples) {
                 samples.reset(FLAGS_samples);
                 for (int s = 0; s < FLAGS_samples; s++) {
-                    samples[s] = time(loops, bench, targets[j]) / loops;
+                    samples[s] = time(loops, bench, target) / loops;
                 }
             } else if (samplingTimeMs) {
                 samples.reset();
                 if (FLAGS_verbose) {
                     SkDebugf("Begin sampling %s for %ims\n",
                              bench->getUniqueName(), static_cast<int>(samplingTimeMs));
                 }
                 WallTimer timer;
                 timer.start();
                 do {
-                    samples.push_back(time(loops, bench, targets[j]) / loops);
+                    samples.push_back(time(loops, bench, target) / loops);
                     timer.end();
                 } while (timer.fWall < samplingTimeMs);
             }
 
             bench->perCanvasPostDraw(canvas);
 
-            if (Benchmark::kNonRendering_Backend != targets[j]->config.backend &&
+            if (Benchmark::kNonRendering_Backend != target->config.backend &&
                 !FLAGS_writePath.isEmpty() && FLAGS_writePath[0]) {
                 SkString pngFilename = SkOSPath::Join(FLAGS_writePath[0], config);
                 pngFilename = SkOSPath::Join(pngFilename.c_str(), bench->getUniqueName());
                 pngFilename.append(".png");
-                write_canvas_png(targets[j], pngFilename);
+                write_canvas_png(target, pngFilename);
             }
 
             if (kFailedLoops == loops) {
                 // Can't be timed.  A warning note has already been printed.
+                cleanup_run(target);
                 continue;
             }
 
             Stats stats(samples);
             log->config(config);
             log->configOption("name", bench->getName());
             benchStream.fillCurrentOptions(log.get());
-            targets[j]->fillOptions(log.get());
+            target->fillOptions(log.get());
             log->metric("min_ms",    stats.min);
             if (runs++ % FLAGS_flushEvery == 0) {
                 log->flush();
             }
 
             if (kAutoTuneLoops != FLAGS_loops) {
-                if (targets.count() == 1) {
+                if (configs.count() == 1) {
                     config = ""; // Only print the config if we run the same bench on more than one.
                 }
                 SkDebugf("%4d/%-4dMB\t%s\t%s\n"
                          , sk_tools::getCurrResidentSetSizeMB()
                          , sk_tools::getMaxResidentSetSizeMB()
                          , bench->getUniqueName()
                          , config);
             } else if (FLAGS_verbose) {
                 for (int i = 0; i < samples.count(); i++) {
                     SkDebugf("%s  ", HUMANIZE(samples[i]));
                 }
                 SkDebugf("%s\n", bench->getUniqueName());
             } else if (FLAGS_quiet) {
-                if (targets.count() == 1) {
+                if (configs.count() == 1) {
                     config = ""; // Only print the config if we run the same bench on more than one.
                 }
                 SkDebugf("%s\t%s\t%s\n", HUMANIZE(stats.median), bench->getUniqueName(), config);
             } else {
                 const double stddev_percent = 100 * sqrt(stats.var) / stats.mean;
                 SkDebugf("%4d/%-4dMB\t%d\t%s\t%s\t%s\t%s\t%.0f%%\t%s\t%s\t%s\n"
                         , sk_tools::getCurrResidentSetSizeMB()
                         , sk_tools::getMaxResidentSetSizeMB()
                         , loops
                         , HUMANIZE(stats.min)
                         , HUMANIZE(stats.median)
                         , HUMANIZE(stats.mean)
                         , HUMANIZE(stats.max)
                         , stddev_percent
                         , kTimedSampling != FLAGS_samples ? stats.plot.c_str()
                                                           : to_string(samples.count()).c_str()
                         , config
                         , bench->getUniqueName()
                         );
             }
 #if SK_SUPPORT_GPU
             if (FLAGS_gpuStats &&
-                Benchmark::kGPU_Backend == targets[j]->config.backend) {
-                gGrFactory->get(targets[j]->config.ctxType)->printCacheStats();
-                gGrFactory->get(targets[j]->config.ctxType)->printGpuStats();
+                Benchmark::kGPU_Backend == configs[i].backend) {
+                gGrFactory->get(configs[i].ctxType)->printCacheStats();
+                gGrFactory->get(configs[i].ctxType)->printGpuStats();
             }
 #endif
+            cleanup_run(target);
         }
-        targets.deleteAll();
-
-#if SK_SUPPORT_GPU
-        if (FLAGS_abandonGpuContext) {
-            gGrFactory->abandonContexts();
-        }
-        if (FLAGS_resetGpuContext || FLAGS_abandonGpuContext) {
-            gGrFactory->destroyContexts();
-        }
-#endif
     }
 
     log->bench("memory_usage", 0,0);
     log->config("meta");
     log->metric("max_rss_mb", sk_tools::getMaxResidentSetSizeMB());
 
 #if SK_SUPPORT_GPU
     // Make sure we clean up the global GrContextFactory here, otherwise we might race with the
     // SkEventTracer destructor
     gGrFactory.reset(NULL);
 #endif
 
     return 0;
 }
 
 #if !defined SK_BUILD_FOR_IOS
 int main(int argc, char** argv) {
     SkCommandLineFlags::Parse(argc, argv);
     return nanobench_main();
 }
 #endif