in bench/nanobench.cpp [1355:1701]
int main(int argc, char** argv) {
CommandLineFlags::Parse(argc, argv);
initializeEventTracingForTools();
#if defined(SK_BUILD_FOR_IOS)
cd_Documents();
#endif
SetupCrashHandler();
if (FLAGS_runtimeCPUDetection) {
SkGraphics::Init();
}
// Our benchmarks only currently decode .png or .jpg files
SkCodecs::Register(SkPngDecoder::Decoder());
SkCodecs::Register(SkJpegDecoder::Decoder());
SkTaskGroup::Enabler enabled(FLAGS_threads);
CommonFlags::SetCtxOptions(&grContextOpts);
#if defined(SK_GRAPHITE)
CommonFlags::SetTestOptions(&gTestOptions);
#endif
NanobenchShaderErrorHandler errorHandler;
grContextOpts.fShaderErrorHandler = &errorHandler;
if (kAutoTuneLoops != FLAGS_loops) {
FLAGS_samples = 1;
FLAGS_gpuFrameLag = 0;
}
if (!FLAGS_writePath.isEmpty()) {
SkDebugf("Writing files to %s.\n", FLAGS_writePath[0]);
if (!sk_mkdir(FLAGS_writePath[0])) {
SkDebugf("Could not create %s. Files won't be written.\n", FLAGS_writePath[0]);
FLAGS_writePath.set(0, nullptr);
}
}
std::unique_ptr<SkWStream> logStream(new SkNullWStream);
if (!FLAGS_outResultsFile.isEmpty()) {
#if defined(SK_RELEASE)
logStream.reset(new SkFILEWStream(FLAGS_outResultsFile[0]));
#else
SkDebugf("I'm ignoring --outResultsFile because this is a Debug build.");
return 1;
#endif
}
NanoJSONResultsWriter log(logStream.get(), SkJSONWriter::Mode::kPretty);
log.beginObject(); // root
if (1 == FLAGS_properties.size() % 2) {
SkDebugf("ERROR: --properties must be passed with an even number of arguments.\n");
return 1;
}
for (int i = 1; i < FLAGS_properties.size(); i += 2) {
log.appendCString(FLAGS_properties[i-1], FLAGS_properties[i]);
}
if (1 == FLAGS_key.size() % 2) {
SkDebugf("ERROR: --key must be passed with an even number of arguments.\n");
return 1;
}
if (FLAGS_key.size()) {
log.beginObject("key");
for (int i = 1; i < FLAGS_key.size(); i += 2) {
log.appendCString(FLAGS_key[i - 1], FLAGS_key[i]);
}
log.endObject(); // key
}
const double overhead = estimate_timer_overhead();
if (!FLAGS_quiet && !FLAGS_csv) {
SkDebugf("Timer overhead: %s\n", HUMANIZE(overhead));
}
TArray<double> 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_quiet) {
SkDebugf("! -> high variance, ? -> moderate variance\n");
SkDebugf(" micros \tbench\n");
} else if (FLAGS_csv) {
SkDebugf("min,median,mean,max,stddev,config,bench\n");
} else if (FLAGS_ms) {
SkDebugf("curr/maxrss\tloops\tmin\tmedian\tmean\tmax\tstddev\tsamples\tconfig\tbench\n");
} else {
SkDebugf("curr/maxrss\tloops\tmin\tmedian\tmean\tmax\tstddev\t%-*s\tconfig\tbench\n",
FLAGS_samples, "samples");
}
GrRecordingContextPriv::DMSAAStats combinedDMSAAStats;
TArray<Config> configs;
create_configs(&configs);
if (FLAGS_keepAlive) {
start_keepalive();
}
gSkForceRasterPipelineBlitter = FLAGS_forceRasterPipelineHP || FLAGS_forceRasterPipeline;
gForceHighPrecisionRasterPipeline = FLAGS_forceRasterPipelineHP;
// The SkSL memory benchmark must run before any GPU painting occurs. SkSL allocates memory for
// its modules the first time they are accessed, and this test is trying to measure the size of
// those allocations. If a paint has already occurred, some modules will have already been
// loaded, so we won't be able to capture a delta for them.
log.beginObject("results");
RunSkSLModuleBenchmarks(&log);
int runs = 0;
BenchmarkStream benchStream;
AutoreleasePool pool;
while (Benchmark* b = benchStream.next()) {
std::unique_ptr<Benchmark> bench(b);
if (CommandLineFlags::ShouldSkip(FLAGS_match, bench->getUniqueName())) {
continue;
}
if (!configs.empty()) {
log.beginBench(
bench->getUniqueName(), bench->getSize().width(), bench->getSize().height());
bench->delayedSetup();
}
for (int i = 0; i < configs.size(); ++i) {
Target* target = is_enabled(b, configs[i]);
if (!target) {
continue;
}
// During HWUI output this canvas may be nullptr.
SkCanvas* canvas = target->getCanvas();
const char* config = target->config.name.c_str();
if (FLAGS_pre_log || FLAGS_dryRun) {
SkDebugf("Running %s\t%s\n"
, bench->getUniqueName()
, config);
if (FLAGS_dryRun) {
continue;
}
}
if (FLAGS_purgeBetweenBenches) {
SkGraphics::PurgeAllCaches();
}
if (FLAGS_splitPerfettoTracesByBenchmark) {
TRACE_EVENT_API_NEW_TRACE_SECTION(TRACE_STR_COPY(bench->getUniqueName()));
}
TRACE_EVENT2("skia", "Benchmark", "name", TRACE_STR_COPY(bench->getUniqueName()),
"config", TRACE_STR_COPY(config));
target->setup();
bench->perCanvasPreDraw(canvas);
int maxFrameLag;
int loops = target->needsFrameTiming(&maxFrameLag)
? setup_gpu_bench(target, bench.get(), maxFrameLag)
: setup_cpu_bench(overhead, target, bench.get());
if (kFailedLoops == loops) {
// Can't be timed. A warning note has already been printed.
cleanup_run(target);
continue;
}
if (runs == 0 && FLAGS_ms < 1000) {
// Run the first bench for 1000ms to warm up the nanobench if FLAGS_ms < 1000.
// Otherwise, the first few benches' measurements will be inaccurate.
auto stop = now_ms() + 1000;
do {
time(loops, bench.get(), target);
pool.drain();
} while (now_ms() < stop);
}
if (FLAGS_ms) {
samples.clear();
auto stop = now_ms() + FLAGS_ms;
do {
samples.push_back(time(loops, bench.get(), target) / loops);
pool.drain();
} while (now_ms() < stop);
} else {
samples.reset(FLAGS_samples);
for (int s = 0; s < FLAGS_samples; s++) {
samples[s] = time(loops, bench.get(), target) / loops;
pool.drain();
}
}
// Scale each result to the benchmark's own units, time/unit.
for (double& sample : samples) {
sample *= (1.0 / bench->getUnits());
}
TArray<SkString> keys;
TArray<double> values;
if (configs[i].backend == Benchmark::Backend::kGanesh) {
if (FLAGS_gpuStatsDump) {
// TODO cache stats
bench->getGpuStats(canvas, &keys, &values);
}
if (FLAGS_dmsaaStatsDump && bench->getDMSAAStats(canvas->recordingContext())) {
const auto& dmsaaStats = canvas->recordingContext()->priv().dmsaaStats();
dmsaaStats.dumpKeyValuePairs(&keys, &values);
dmsaaStats.dump();
combinedDMSAAStats.merge(dmsaaStats);
}
}
bench->perCanvasPostDraw(canvas);
if (Benchmark::Backend::kNonRendering != 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(target, pngFilename);
}
// Building stats.plot often shows up in profiles,
// so skip building it when we're not going to print it anyway.
const bool want_plot = !FLAGS_quiet && !FLAGS_ms;
Stats stats(samples, want_plot);
log.beginObject(config);
log.beginObject("options");
log.appendCString("name", bench->getName());
benchStream.fillCurrentOptions(log);
log.endObject(); // options
// Metrics
log.appendMetric("min_ms", stats.min);
log.appendMetric("min_ratio", sk_ieee_double_divide(stats.median, stats.min));
log.beginArray("samples");
for (double sample : samples) {
log.appendDoubleDigits(sample, 16);
}
log.endArray(); // samples
benchStream.fillCurrentMetrics(log);
if (!keys.empty()) {
// dump to json, only SKPBench currently returns valid keys / values
SkASSERT(keys.size() == values.size());
for (int j = 0; j < keys.size(); j++) {
log.appendMetric(keys[j].c_str(), values[j]);
}
}
log.endObject(); // config
if (runs++ % FLAGS_flushEvery == 0) {
log.flush();
}
if (kAutoTuneLoops != FLAGS_loops) {
if (configs.size() == 1) {
config = ""; // Only print the config if we run the same bench on more than one.
}
SkDebugf("%4d/%-4dMB\t%s\t%s "
, sk_tools::getCurrResidentSetSizeMB()
, sk_tools::getMaxResidentSetSizeMB()
, bench->getUniqueName()
, config);
SkDebugf("\n");
} else if (FLAGS_quiet) {
const char* mark = " ";
const double stddev_percent =
sk_ieee_double_divide(100 * sqrt(stats.var), stats.mean);
if (stddev_percent > 5) mark = "?";
if (stddev_percent > 10) mark = "!";
SkDebugf("%10.2f %s\t%s\t%s\n",
stats.median*1e3, mark, bench->getUniqueName(), config);
} else if (FLAGS_csv) {
const double stddev_percent =
sk_ieee_double_divide(100 * sqrt(stats.var), stats.mean);
SkDebugf("%g,%g,%g,%g,%g,%s,%s\n"
, stats.min
, stats.median
, stats.mean
, stats.max
, stddev_percent
, config
, bench->getUniqueName()
);
} else {
const double stddev_percent =
sk_ieee_double_divide(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
, FLAGS_ms ? to_string(samples.size()).c_str() : stats.plot.c_str()
, config
, bench->getUniqueName()
);
}
if (FLAGS_gpuStats && Benchmark::Backend::kGanesh == configs[i].backend) {
target->dumpStats();
}
if (FLAGS_verbose) {
SkDebugf("Samples: ");
for (int j = 0; j < samples.size(); j++) {
SkDebugf("%s ", HUMANIZE(samples[j]));
}
SkDebugf("%s\n", bench->getUniqueName());
}
cleanup_run(target);
pool.drain();
}
if (!configs.empty()) {
log.endBench();
}
}
if (FLAGS_dmsaaStatsDump) {
SkDebugf("<<Total Combined DMSAA Stats>>\n");
combinedDMSAAStats.dump();
}
SkGraphics::PurgeAllCaches();
log.beginBench("memory_usage", 0, 0);
log.beginObject("meta"); // config
log.appendS32("max_rss_mb", sk_tools::getMaxResidentSetSizeMB());
log.endObject(); // config
log.endBench();
log.endObject(); // results
log.endObject(); // root
log.flush();
return 0;
}