skia2/tools/VisualBench/VisualLightweightBenchModule.cpp
cdalton baf8fcbb1b Add offscreen mode to visualbench
Replaces "nvpr mode" with "offscreen mode" and a flag to enable/
disable nvpr. Assigns new config names to the various combinations of
flags and begins printing them with the bench results in order to match
nanobench.

BUG=skia:

Review URL: https://codereview.chromium.org/1473253002
2015-11-24 09:20:24 -08:00

157 lines
5.0 KiB
C++

/*
* Copyright 2015 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "VisualLightweightBenchModule.h"
#include "ProcStats.h"
#include "SkApplication.h"
#include "SkCanvas.h"
#include "SkCommandLineFlags.h"
#include "SkForceLinking.h"
#include "SkGraphics.h"
#include "SkGr.h"
#include "SkImageDecoder.h"
#include "SkOSFile.h"
#include "SkStream.h"
#include "Stats.h"
#include "gl/GrGLInterface.h"
__SK_FORCE_IMAGE_DECODER_LINKING;
// Between samples we reset context
// Between frames we swap buffers
DEFINE_bool2(verbose, v, false, "enable verbose output from the test driver.");
DEFINE_string(outResultsFile, "", "If given, write results here as JSON.");
DEFINE_string(key, "",
"Space-separated key/value pairs to add to JSON identifying this builder.");
DEFINE_string(properties, "",
"Space-separated key/value pairs to add to JSON identifying this run.");
DEFINE_int32(samples, 10, "Number of times to time each skp.");
static SkString humanize(double ms) {
if (FLAGS_verbose) {
return SkStringPrintf("%llu", (uint64_t)(ms*1e6));
}
return HumanizeMs(ms);
}
#define HUMANIZE(time) humanize(time).c_str()
VisualLightweightBenchModule::VisualLightweightBenchModule(VisualBench* owner)
: INHERITED(owner)
, fCurrentSample(0)
, fResults(new ResultsWriter) {
// Print header
SkDebugf("curr/maxrss\tloops\tmin\tmedian\tmean\tmax\tstddev\t%-*s\tconfig\tbench\n",
FLAGS_samples, "samples");
// setup json logging if required
if (!FLAGS_outResultsFile.isEmpty()) {
fResults.reset(new NanoJSONResultsWriter(FLAGS_outResultsFile[0]));
}
if (1 == FLAGS_key.count() % 2) {
SkDebugf("ERROR: --key must be passed with an even number of arguments.\n");
} else {
for (int i = 1; i < FLAGS_key.count(); i += 2) {
fResults->key(FLAGS_key[i - 1], FLAGS_key[i]);
}
}
if (1 == FLAGS_properties.count() % 2) {
SkDebugf("ERROR: --properties must be passed with an even number of arguments.\n");
} else {
for (int i = 1; i < FLAGS_properties.count(); i += 2) {
fResults->property(FLAGS_properties[i - 1], FLAGS_properties[i]);
}
}
// seed an initial record
fRecords.push_back();
}
void VisualLightweightBenchModule::renderFrame(SkCanvas* canvas, Benchmark* benchmark, int loops) {
benchmark->draw(loops, canvas);
canvas->flush();
}
void VisualLightweightBenchModule::printStats(Benchmark* benchmark, int loops) {
const SkTArray<double>& measurements = fRecords.back().fMeasurements;
const char* shortName = benchmark->getUniqueName();
// update log
// Note: We currently log only the minimum. It would be interesting to log more information
SkString configName;
if (FLAGS_cpu) {
configName.append("cpu");
} else if (FLAGS_nvpr) {
if (FLAGS_offscreen) {
configName.appendf("nvpr_%d", FLAGS_msaa);
} else {
configName.appendf("nvpr_msaa_%d", FLAGS_msaa);
}
} else if (FLAGS_msaa > 0) {
if (FLAGS_offscreen) {
configName.appendf("offscreen_msaa_%d", FLAGS_msaa);
} else {
configName.appendf("msaa_%d", FLAGS_msaa);
}
} else {
if (FLAGS_offscreen) {
configName.append("offscreen");
} else {
configName.append("gpu");
}
}
// Log bench name
fResults->bench(shortName, benchmark->getSize().fX, benchmark->getSize().fY);
fResults->config(configName.c_str());
fResults->configOption("name", shortName);
SkASSERT(measurements.count());
Stats stats(measurements);
fResults->metric("min_ms", stats.min);
// Print output
if (FLAGS_verbose) {
for (int i = 0; i < measurements.count(); i++) {
SkDebugf("%s ", HUMANIZE(measurements[i]));
}
SkDebugf("%s\n", shortName);
} else {
const double stdDevPercent = 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),
stdDevPercent,
stats.plot.c_str(),
configName.c_str(),
shortName);
}
}
bool VisualLightweightBenchModule::timingFinished(Benchmark* benchmark, int loops,
double measurement) {
fRecords.back().fMeasurements.push_back(measurement);
if (++fCurrentSample > FLAGS_samples) {
this->printStats(benchmark, loops);
fRecords.push_back();
fCurrentSample = 0;
return true;
}
return false;
}
bool VisualLightweightBenchModule::onHandleChar(SkUnichar c) {
return true;
}