DM+nanobench: print both current and max RSS.

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 119 matching lines @@
     }
     void endTiming() override {
         if (this->gl) {
             SK_GL(*this->gl, Flush());
             this->gl->swapBuffers();
         }
     }
     void fence() override {
         SK_GL(*this->gl, Finish());
     }
- 
+
     bool needsFrameTiming() const override { return true; }
     bool init(SkImageInfo info, Benchmark* bench) override {
         uint32_t flags = this->config.useDFText ? SkSurfaceProps::kUseDistanceFieldFonts_Flag : 0;
         SkSurfaceProps props(flags, SkSurfaceProps::kLegacyFontHost_InitType);
         this->surface.reset(SkSurface::NewRenderTarget(gGrFactory->get(this->config.ctxType),
                                                          SkSurface::kNo_Budgeted, info,
                                                          this->config.samples, &props));
         this->gl = gGrFactory->getGLContext(this->config.ctxType);
         if (!this->surface.get()) {
             return false;
         }
         return true;
     }
     void fillOptions(ResultsWriter* log) override {
         const GrGLubyte* version;
         SK_GL_RET(*this->gl, version, GetString(GR_GL_VERSION));
         log->configOption("GL_VERSION", (const char*)(version));
 
         SK_GL_RET(*this->gl, version, GetString(GR_GL_RENDERER));
         log->configOption("GL_RENDERER", (const char*) version);
 
         SK_GL_RET(*this->gl, version, GetString(GR_GL_VENDOR));
         log->configOption("GL_VENDOR", (const char*) version);
 
         SK_GL_RET(*this->gl, version, GetString(GR_GL_SHADING_LANGUAGE_VERSION));
         log->configOption("GL_SHADING_LANGUAGE_VERSION", (const char*) version);
     }
 };
-        
+
 #endif
 
 static double time(int loops, Benchmark* bench, Target* target) {
     SkCanvas* canvas = target->getCanvas();
     if (canvas) {
         canvas->clear(SK_ColorWHITE);
     }
     WallTimer timer;
     timer.start();
     canvas = target->beginTiming(canvas);
@@ skipping 712 matching lines @@
 
     SkAutoTMalloc<double> samples(FLAGS_samples);
 
     if (kAutoTuneLoops != FLAGS_loops) {
         SkDebugf("Fixed number of loops; times would only be misleading so we won't print them.\n");
     } else if (FLAGS_verbose) {
         // No header.
     } else if (FLAGS_quiet) {
         SkDebugf("median\tbench\tconfig\n");
     } else {
-        SkDebugf("maxrss\tloops\tmin\tmedian\tmean\tmax\tstddev\t%-*s\tconfig\tbench\n",
+        SkDebugf("curr/maxrss\tloops\tmin\tmedian\tmean\tmax\tstddev\t%-*s\tconfig\tbench\n",
                  FLAGS_samples, "samples");
     }
 
     SkTDArray<Config> configs;
     create_configs(&configs);
 
     int runs = 0;
     BenchmarkStream benchStream;
     while (Benchmark* b = benchStream.next()) {
         SkAutoTDelete<Benchmark> bench(b);
@@ skipping 43 matching lines @@
             targets[j]->fillOptions(log.get());
             log->metric("min_ms",    stats.min);
             if (runs++ % FLAGS_flushEvery == 0) {
                 log->flush();
             }
 
             if (kAutoTuneLoops != FLAGS_loops) {
                 if (targets.count() == 1) {
                     config = ""; // Only print the config if we run the same bench on more than one.
                 }
-                SkDebugf("%4dM\t%s\t%s\n"
-                         , sk_tools::getBestResidentSetSizeMB()
+                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 < FLAGS_samples; i++) {
                     SkDebugf("%s  ", HUMANIZE(samples[i]));
                 }
                 SkDebugf("%s\n", bench->getUniqueName());
             } else if (FLAGS_quiet) {
                 if (targets.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("%4dM\t%d\t%s\t%s\t%s\t%s\t%.0f%%\t%s\t%s\t%s\n"
-                        , sk_tools::getBestResidentSetSizeMB()
+                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
                         , stats.plot.c_str()
                         , config
                         , bench->getUniqueName()
                         );
@@ skipping 30 matching lines @@
 
     return 0;
 }
 
 #if !defined SK_BUILD_FOR_IOS
 int main(int argc, char** argv) {
     SkCommandLineFlags::Parse(argc, argv);
     return nanobench_main();
 }
 #endif