blob: c7cc3f0239ba96256eb82edaa87605ba959a795a [file] [log] [blame]
mtkleinf3723212014-06-25 14:08:00 -07001/*
2 * Copyright 2014 Google Inc.
3 *
4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
6 */
7
mtkleinbb6a0282014-07-01 08:43:42 -07008#include <ctype.h>
9
tomhudsond968a6f2015-03-26 11:28:06 -070010#include "nanobench.h"
11
msarett84451022016-02-11 06:45:51 -080012#include "AndroidCodecBench.h"
mtkleinf3723212014-06-25 14:08:00 -070013#include "Benchmark.h"
msarett7f691442015-09-22 11:56:16 -070014#include "BitmapRegionDecoderBench.h"
scroggo60869a42015-04-01 12:09:17 -070015#include "CodecBench.h"
msarett7f691442015-09-22 11:56:16 -070016#include "CodecBenchPriv.h"
mtkleinf3723212014-06-25 14:08:00 -070017#include "CrashHandler.h"
mtkleine714e752014-07-31 12:13:48 -070018#include "GMBench.h"
mtkleinafb43792014-08-19 15:55:55 -070019#include "ProcStats.h"
mtklein60317d0f2014-07-14 11:30:37 -070020#include "ResultsWriter.h"
mtkleinfd731ce2014-09-10 12:19:30 -070021#include "RecordingBench.h"
joshualitt261c3ad2015-04-27 09:16:57 -070022#include "SKPAnimationBench.h"
mtklein92007582014-08-01 07:46:52 -070023#include "SKPBench.h"
mtkleinf3723212014-06-25 14:08:00 -070024#include "Stats.h"
mtkleinf3723212014-06-25 14:08:00 -070025
msarett84451022016-02-11 06:45:51 -080026#include "SkAndroidCodec.h"
msarett5cb48852015-11-06 08:56:32 -080027#include "SkBitmapRegionDecoder.h"
mtklein6838d852014-10-29 14:15:10 -070028#include "SkBBoxHierarchy.h"
mtkleinf3723212014-06-25 14:08:00 -070029#include "SkCanvas.h"
scroggo60869a42015-04-01 12:09:17 -070030#include "SkCodec.h"
caryclark17f0b6d2014-07-22 10:15:34 -070031#include "SkCommonFlags.h"
kkinnunen3e980c32015-12-23 01:33:00 -080032#include "SkCommonFlagsConfig.h"
msarett95f192d2015-02-13 09:05:41 -080033#include "SkData.h"
mtkleinf3723212014-06-25 14:08:00 -070034#include "SkForceLinking.h"
35#include "SkGraphics.h"
mtklein20840502014-08-21 15:51:22 -070036#include "SkOSFile.h"
37#include "SkPictureRecorder.h"
mtklein051e56d2014-12-04 08:46:51 -080038#include "SkPictureUtils.h"
mtkleinf3723212014-06-25 14:08:00 -070039#include "SkString.h"
40#include "SkSurface.h"
robertphillips5b693772014-11-21 06:19:36 -080041#include "SkTaskGroup.h"
msarettc149f0e2016-01-04 11:35:43 -080042#include "SkThreadUtils.h"
joshualitt3ebd0502016-02-09 07:18:08 -080043#include "ThermalManager.h"
mtkleinf3723212014-06-25 14:08:00 -070044
bungeman60e0fee2015-08-26 05:15:46 -070045#include <stdlib.h>
46
scroggo38ce0a72016-01-07 07:28:47 -080047#ifndef SK_BUILD_FOR_WIN32
48 #include <unistd.h>
49#endif
50
tomhudsond968a6f2015-03-26 11:28:06 -070051#ifdef SK_BUILD_FOR_ANDROID_FRAMEWORK
52 #include "nanobenchAndroid.h"
53#endif
54
mtkleinbb6a0282014-07-01 08:43:42 -070055#if SK_SUPPORT_GPU
jcgregoriobf5e5232014-07-17 13:14:16 -070056 #include "gl/GrGLDefines.h"
bsalomon76228632015-05-29 08:02:10 -070057 #include "GrCaps.h"
mtkleinbb6a0282014-07-01 08:43:42 -070058 #include "GrContextFactory.h"
krajcevski69a55602014-08-13 10:46:31 -070059 SkAutoTDelete<GrContextFactory> gGrFactory;
mtkleinbb6a0282014-07-01 08:43:42 -070060#endif
61
bsalomon682c2692015-05-22 14:01:46 -070062 struct GrContextOptions;
63
mtkleinf3723212014-06-25 14:08:00 -070064__SK_FORCE_IMAGE_DECODER_LINKING;
65
reed53249782014-10-10 09:09:52 -070066static const int kAutoTuneLoops = 0;
bsalomon6eb03cc2014-08-07 14:28:50 -070067
mtkleinb5110422014-08-07 15:20:02 -070068static const int kDefaultLoops =
bsalomon6eb03cc2014-08-07 14:28:50 -070069#ifdef SK_DEBUG
70 1;
mtkleina189ccd2014-07-14 12:28:47 -070071#else
bsalomon6eb03cc2014-08-07 14:28:50 -070072 kAutoTuneLoops;
mtkleina189ccd2014-07-14 12:28:47 -070073#endif
74
bsalomon6eb03cc2014-08-07 14:28:50 -070075static SkString loops_help_txt() {
76 SkString help;
77 help.printf("Number of times to run each bench. Set this to %d to auto-"
78 "tune for each bench. Timings are only reported when auto-tuning.",
79 kAutoTuneLoops);
80 return help;
81}
82
cdaltone1b89582015-06-25 19:17:08 -070083static SkString to_string(int n) {
84 SkString str;
85 str.appendS32(n);
86 return str;
87}
88
bsalomon6eb03cc2014-08-07 14:28:50 -070089DEFINE_int32(loops, kDefaultLoops, loops_help_txt().c_str());
90
mtkleinf3723212014-06-25 14:08:00 -070091DEFINE_int32(samples, 10, "Number of samples to measure for each bench.");
mtkleinbbba1682015-10-28 11:36:30 -070092DEFINE_int32(ms, 0, "If >0, run each bench for this many ms instead of obeying --samples.");
mtkleinf3723212014-06-25 14:08:00 -070093DEFINE_int32(overheadLoops, 100000, "Loops to estimate timer overhead.");
94DEFINE_double(overheadGoal, 0.0001,
95 "Loop until timer overhead is at most this fraction of our measurments.");
mtkleinbb6a0282014-07-01 08:43:42 -070096DEFINE_double(gpuMs, 5, "Target bench time in millseconds for GPU.");
cdaltond416a5b2015-06-23 13:23:44 -070097DEFINE_int32(gpuFrameLag, 5, "If unknown, estimated maximum number of frames GPU allows to lag.");
krajcevski12b35442014-08-13 12:06:26 -070098DEFINE_bool(gpuCompressAlphaMasks, false, "Compress masks generated from falling back to "
99 "software path rendering.");
mtkleinf3723212014-06-25 14:08:00 -0700100
mtklein60317d0f2014-07-14 11:30:37 -0700101DEFINE_string(outResultsFile, "", "If given, write results here as JSON.");
mtklein55b0ffc2014-07-17 08:38:23 -0700102DEFINE_int32(maxCalibrationAttempts, 3,
103 "Try up to this many times to guess loops for a bench, or skip the bench.");
104DEFINE_int32(maxLoops, 1000000, "Never run a bench more times than this.");
mtklein92007582014-08-01 07:46:52 -0700105DEFINE_string(clip, "0,0,1000,1000", "Clip for SKPs.");
106DEFINE_string(scales, "1.0", "Space-separated scales for SKPs.");
cdalton63a82852015-06-29 14:06:10 -0700107DEFINE_string(zoom, "1.0,0", "Comma-separated zoomMax,zoomPeriodMs factors for a periodic SKP zoom "
108 "function that ping-pongs between 1.0 and zoomMax.");
mtklein20840502014-08-21 15:51:22 -0700109DEFINE_bool(bbh, true, "Build a BBH for SKPs?");
robertphillips5b693772014-11-21 06:19:36 -0800110DEFINE_bool(mpd, true, "Use MultiPictureDraw for the SKPs?");
cdaltonb4022962015-06-25 10:51:56 -0700111DEFINE_bool(loopSKP, true, "Loop SKPs like we do for micro benches?");
mtkleine070c2b2014-10-14 08:40:43 -0700112DEFINE_int32(flushEvery, 10, "Flush --outResultsFile every Nth run.");
mtklein55e88b22015-01-21 15:50:13 -0800113DEFINE_bool(resetGpuContext, true, "Reset the GrContext before running each test.");
bsalomonb12ea412015-02-02 21:19:50 -0800114DEFINE_bool(gpuStats, false, "Print GPU stats after each gpu benchmark?");
joshualitte45c81c2015-12-02 09:05:37 -0800115DEFINE_bool(gpuStatsDump, false, "Dump GPU states after each benchmark to json");
msarettc149f0e2016-01-04 11:35:43 -0800116DEFINE_bool(keepAlive, false, "Print a message every so often so that we don't time out");
joshualitt3ebd0502016-02-09 07:18:08 -0800117DEFINE_string(useThermalManager, "0,1,10,1000", "enabled,threshold,sleepTimeMs,TimeoutMs for "
118 "thermalManager\n");
mtklein92007582014-08-01 07:46:52 -0700119
mtklein65dfd2f2016-02-03 10:40:54 -0800120DEFINE_string(sourceType, "",
121 "Apply usual --match rules to source type: bench, gm, skp, image, etc.");
122DEFINE_string(benchType, "",
123 "Apply usual --match rules to bench type: micro, recording, playback, skcodec, etc.");
124
mtkleinbbba1682015-10-28 11:36:30 -0700125static double now_ms() { return SkTime::GetNSecs() * 1e-6; }
126
mtkleinf3723212014-06-25 14:08:00 -0700127static SkString humanize(double ms) {
mtkleindc5bbab2014-09-24 06:34:09 -0700128 if (FLAGS_verbose) return SkStringPrintf("%llu", (uint64_t)(ms*1e6));
mtklein748ca3b2015-01-15 10:56:12 -0800129 return HumanizeMs(ms);
mtkleinf3723212014-06-25 14:08:00 -0700130}
mtklein55b0ffc2014-07-17 08:38:23 -0700131#define HUMANIZE(ms) humanize(ms).c_str()
mtkleinf3723212014-06-25 14:08:00 -0700132
tomhudsond968a6f2015-03-26 11:28:06 -0700133bool Target::init(SkImageInfo info, Benchmark* bench) {
134 if (Benchmark::kRaster_Backend == config.backend) {
135 this->surface.reset(SkSurface::NewRaster(info));
136 if (!this->surface.get()) {
137 return false;
138 }
139 }
140 return true;
141}
142bool Target::capturePixels(SkBitmap* bmp) {
tomhudson75a0ebb2015-03-27 12:11:44 -0700143 SkCanvas* canvas = this->getCanvas();
tomhudsond968a6f2015-03-26 11:28:06 -0700144 if (!canvas) {
145 return false;
146 }
147 bmp->setInfo(canvas->imageInfo());
148 if (!canvas->readPixels(bmp, 0, 0)) {
149 SkDebugf("Can't read canvas pixels.\n");
150 return false;
151 }
152 return true;
153}
154
155#if SK_SUPPORT_GPU
156struct GPUTarget : public Target {
halcanary96fcdcc2015-08-27 07:41:13 -0700157 explicit GPUTarget(const Config& c) : Target(c), gl(nullptr) { }
tomhudsond968a6f2015-03-26 11:28:06 -0700158 SkGLContext* gl;
159
160 void setup() override {
161 this->gl->makeCurrent();
162 // Make sure we're done with whatever came before.
163 SK_GL(*this->gl, Finish());
164 }
165 void endTiming() override {
166 if (this->gl) {
167 SK_GL(*this->gl, Flush());
joshualitt01836ad2016-01-20 13:09:12 -0800168 this->gl->waitOnSyncOrSwap();
tomhudsond968a6f2015-03-26 11:28:06 -0700169 }
170 }
171 void fence() override {
172 SK_GL(*this->gl, Finish());
173 }
mtkleind75c4662015-04-30 07:11:22 -0700174
cdaltond416a5b2015-06-23 13:23:44 -0700175 bool needsFrameTiming(int* maxFrameLag) const override {
176 if (!this->gl->getMaxGpuFrameLag(maxFrameLag)) {
177 // Frame lag is unknown.
178 *maxFrameLag = FLAGS_gpuFrameLag;
179 }
180 return true;
181 }
tomhudsond968a6f2015-03-26 11:28:06 -0700182 bool init(SkImageInfo info, Benchmark* bench) override {
bsalomonafcd7cd2015-08-31 12:39:41 -0700183 uint32_t flags = this->config.useDFText ? SkSurfaceProps::kUseDeviceIndependentFonts_Flag :
184 0;
tomhudsond968a6f2015-03-26 11:28:06 -0700185 SkSurfaceProps props(flags, SkSurfaceProps::kLegacyFontHost_InitType);
kkinnunen5219fd92015-12-10 06:28:13 -0800186 this->surface.reset(SkSurface::NewRenderTarget(gGrFactory->get(this->config.ctxType,
kkinnunen5219fd92015-12-10 06:28:13 -0800187 this->config.ctxOptions),
tomhudsond968a6f2015-03-26 11:28:06 -0700188 SkSurface::kNo_Budgeted, info,
189 this->config.samples, &props));
kkinnunen3e980c32015-12-23 01:33:00 -0800190 this->gl = gGrFactory->getContextInfo(this->config.ctxType,
kkinnunen34058002016-01-06 23:49:30 -0800191 this->config.ctxOptions).fGLContext;
tomhudsond968a6f2015-03-26 11:28:06 -0700192 if (!this->surface.get()) {
193 return false;
194 }
cdaltond416a5b2015-06-23 13:23:44 -0700195 if (!this->gl->fenceSyncSupport()) {
196 SkDebugf("WARNING: GL context for config \"%s\" does not support fence sync. "
svaisanenc47635e2016-01-28 06:05:43 -0800197 "Timings might not be accurate.\n", this->config.name.c_str());
cdaltond416a5b2015-06-23 13:23:44 -0700198 }
tomhudsond968a6f2015-03-26 11:28:06 -0700199 return true;
200 }
201 void fillOptions(ResultsWriter* log) override {
202 const GrGLubyte* version;
203 SK_GL_RET(*this->gl, version, GetString(GR_GL_VERSION));
204 log->configOption("GL_VERSION", (const char*)(version));
205
206 SK_GL_RET(*this->gl, version, GetString(GR_GL_RENDERER));
207 log->configOption("GL_RENDERER", (const char*) version);
208
209 SK_GL_RET(*this->gl, version, GetString(GR_GL_VENDOR));
210 log->configOption("GL_VENDOR", (const char*) version);
211
212 SK_GL_RET(*this->gl, version, GetString(GR_GL_SHADING_LANGUAGE_VERSION));
213 log->configOption("GL_SHADING_LANGUAGE_VERSION", (const char*) version);
214 }
215};
mtkleind75c4662015-04-30 07:11:22 -0700216
tomhudsond968a6f2015-03-26 11:28:06 -0700217#endif
218
tomhudson75a0ebb2015-03-27 12:11:44 -0700219static double time(int loops, Benchmark* bench, Target* target) {
220 SkCanvas* canvas = target->getCanvas();
bsalomon6eb03cc2014-08-07 14:28:50 -0700221 if (canvas) {
222 canvas->clear(SK_ColorWHITE);
223 }
joshualitt8a6697a2015-09-30 12:11:07 -0700224 bench->preDraw(canvas);
mtkleinbbba1682015-10-28 11:36:30 -0700225 double start = now_ms();
tomhudson75a0ebb2015-03-27 12:11:44 -0700226 canvas = target->beginTiming(canvas);
227 bench->draw(loops, canvas);
mtkleinbb6a0282014-07-01 08:43:42 -0700228 if (canvas) {
229 canvas->flush();
230 }
tomhudson75a0ebb2015-03-27 12:11:44 -0700231 target->endTiming();
mtkleinbbba1682015-10-28 11:36:30 -0700232 double elapsed = now_ms() - start;
joshualitt8a6697a2015-09-30 12:11:07 -0700233 bench->postDraw(canvas);
mtkleinbbba1682015-10-28 11:36:30 -0700234 return elapsed;
mtkleinbb6a0282014-07-01 08:43:42 -0700235}
236
mtkleinf3723212014-06-25 14:08:00 -0700237static double estimate_timer_overhead() {
238 double overhead = 0;
mtkleinf3723212014-06-25 14:08:00 -0700239 for (int i = 0; i < FLAGS_overheadLoops; i++) {
mtkleinbbba1682015-10-28 11:36:30 -0700240 double start = now_ms();
241 overhead += now_ms() - start;
mtkleinf3723212014-06-25 14:08:00 -0700242 }
243 return overhead / FLAGS_overheadLoops;
244}
245
reed53249782014-10-10 09:09:52 -0700246static int detect_forever_loops(int loops) {
247 // look for a magic run-forever value
248 if (loops < 0) {
249 loops = SK_MaxS32;
250 }
251 return loops;
252}
253
mtklein55b0ffc2014-07-17 08:38:23 -0700254static int clamp_loops(int loops) {
255 if (loops < 1) {
mtklein527930f2014-11-06 08:04:34 -0800256 SkDebugf("ERROR: clamping loops from %d to 1. "
257 "There's probably something wrong with the bench.\n", loops);
mtklein55b0ffc2014-07-17 08:38:23 -0700258 return 1;
259 }
260 if (loops > FLAGS_maxLoops) {
261 SkDebugf("WARNING: clamping loops from %d to FLAGS_maxLoops, %d.\n", loops, FLAGS_maxLoops);
262 return FLAGS_maxLoops;
263 }
264 return loops;
265}
266
tomhudsond968a6f2015-03-26 11:28:06 -0700267static bool write_canvas_png(Target* target, const SkString& filename) {
268
bsalomon6eb03cc2014-08-07 14:28:50 -0700269 if (filename.isEmpty()) {
270 return false;
271 }
tomhudson75a0ebb2015-03-27 12:11:44 -0700272 if (target->getCanvas() &&
273 kUnknown_SkColorType == target->getCanvas()->imageInfo().colorType()) {
bsalomon6eb03cc2014-08-07 14:28:50 -0700274 return false;
275 }
tomhudsond968a6f2015-03-26 11:28:06 -0700276
bsalomon6eb03cc2014-08-07 14:28:50 -0700277 SkBitmap bmp;
tomhudsond968a6f2015-03-26 11:28:06 -0700278
279 if (!target->capturePixels(&bmp)) {
bsalomon6eb03cc2014-08-07 14:28:50 -0700280 return false;
281 }
tomhudsond968a6f2015-03-26 11:28:06 -0700282
bsalomon6eb03cc2014-08-07 14:28:50 -0700283 SkString dir = SkOSPath::Dirname(filename.c_str());
284 if (!sk_mkdir(dir.c_str())) {
285 SkDebugf("Can't make dir %s.\n", dir.c_str());
286 return false;
287 }
288 SkFILEWStream stream(filename.c_str());
289 if (!stream.isValid()) {
290 SkDebugf("Can't write %s.\n", filename.c_str());
291 return false;
292 }
293 if (!SkImageEncoder::EncodeStream(&stream, bmp, SkImageEncoder::kPNG_Type, 100)) {
294 SkDebugf("Can't encode a PNG.\n");
295 return false;
296 }
297 return true;
298}
299
300static int kFailedLoops = -2;
cdaltone1b89582015-06-25 19:17:08 -0700301static int setup_cpu_bench(const double overhead, Target* target, Benchmark* bench) {
mtkleinbb6a0282014-07-01 08:43:42 -0700302 // First figure out approximately how many loops of bench it takes to make overhead negligible.
mtklein2069e222014-08-04 13:57:39 -0700303 double bench_plus_overhead = 0.0;
mtklein55b0ffc2014-07-17 08:38:23 -0700304 int round = 0;
cdaltonb4022962015-06-25 10:51:56 -0700305 int loops = bench->calculateLoops(FLAGS_loops);
306 if (kAutoTuneLoops == loops) {
bsalomon6eb03cc2014-08-07 14:28:50 -0700307 while (bench_plus_overhead < overhead) {
308 if (round++ == FLAGS_maxCalibrationAttempts) {
309 SkDebugf("WARNING: Can't estimate loops for %s (%s vs. %s); skipping.\n",
mtklein96289052014-09-10 12:05:59 -0700310 bench->getUniqueName(), HUMANIZE(bench_plus_overhead), HUMANIZE(overhead));
bsalomon6eb03cc2014-08-07 14:28:50 -0700311 return kFailedLoops;
312 }
tomhudson75a0ebb2015-03-27 12:11:44 -0700313 bench_plus_overhead = time(1, bench, target);
mtklein55b0ffc2014-07-17 08:38:23 -0700314 }
mtklein2069e222014-08-04 13:57:39 -0700315 }
mtkleinf3723212014-06-25 14:08:00 -0700316
mtkleinbb6a0282014-07-01 08:43:42 -0700317 // Later we'll just start and stop the timer once but loop N times.
mtkleinf3723212014-06-25 14:08:00 -0700318 // We'll pick N to make timer overhead negligible:
319 //
mtkleinbb6a0282014-07-01 08:43:42 -0700320 // overhead
321 // ------------------------- < FLAGS_overheadGoal
322 // overhead + N * Bench Time
mtkleinf3723212014-06-25 14:08:00 -0700323 //
mtkleinbb6a0282014-07-01 08:43:42 -0700324 // where bench_plus_overhead ≈ overhead + Bench Time.
mtkleinf3723212014-06-25 14:08:00 -0700325 //
326 // Doing some math, we get:
327 //
mtkleinbb6a0282014-07-01 08:43:42 -0700328 // (overhead / FLAGS_overheadGoal) - overhead
329 // ------------------------------------------ < N
330 // bench_plus_overhead - overhead)
mtkleinf3723212014-06-25 14:08:00 -0700331 //
332 // Luckily, this also works well in practice. :)
bsalomon6eb03cc2014-08-07 14:28:50 -0700333 if (kAutoTuneLoops == loops) {
334 const double numer = overhead / FLAGS_overheadGoal - overhead;
335 const double denom = bench_plus_overhead - overhead;
336 loops = (int)ceil(numer / denom);
reed53249782014-10-10 09:09:52 -0700337 loops = clamp_loops(loops);
338 } else {
339 loops = detect_forever_loops(loops);
bsalomon6eb03cc2014-08-07 14:28:50 -0700340 }
mtkleinbb6a0282014-07-01 08:43:42 -0700341
mtkleinbb6a0282014-07-01 08:43:42 -0700342 return loops;
mtkleinf3723212014-06-25 14:08:00 -0700343}
344
cdaltone1b89582015-06-25 19:17:08 -0700345static int setup_gpu_bench(Target* target, Benchmark* bench, int maxGpuFrameLag) {
mtkleinbb6a0282014-07-01 08:43:42 -0700346 // First, figure out how many loops it'll take to get a frame up to FLAGS_gpuMs.
cdaltonb4022962015-06-25 10:51:56 -0700347 int loops = bench->calculateLoops(FLAGS_loops);
bsalomon6eb03cc2014-08-07 14:28:50 -0700348 if (kAutoTuneLoops == loops) {
349 loops = 1;
mtkleina189ccd2014-07-14 12:28:47 -0700350 double elapsed = 0;
351 do {
mtklein527930f2014-11-06 08:04:34 -0800352 if (1<<30 == loops) {
353 // We're about to wrap. Something's wrong with the bench.
354 loops = 0;
355 break;
356 }
mtkleina189ccd2014-07-14 12:28:47 -0700357 loops *= 2;
358 // If the GPU lets frames lag at all, we need to make sure we're timing
cdaltond416a5b2015-06-23 13:23:44 -0700359 // _this_ round, not still timing last round.
360 for (int i = 0; i < maxGpuFrameLag; i++) {
tomhudson75a0ebb2015-03-27 12:11:44 -0700361 elapsed = time(loops, bench, target);
mtkleina189ccd2014-07-14 12:28:47 -0700362 }
363 } while (elapsed < FLAGS_gpuMs);
mtkleinbb6a0282014-07-01 08:43:42 -0700364
mtkleina189ccd2014-07-14 12:28:47 -0700365 // We've overshot at least a little. Scale back linearly.
366 loops = (int)ceil(loops * FLAGS_gpuMs / elapsed);
reed53249782014-10-10 09:09:52 -0700367 loops = clamp_loops(loops);
mtkleinbb6a0282014-07-01 08:43:42 -0700368
tomhudsond968a6f2015-03-26 11:28:06 -0700369 // Make sure we're not still timing our calibration.
370 target->fence();
reed53249782014-10-10 09:09:52 -0700371 } else {
372 loops = detect_forever_loops(loops);
mtkleina189ccd2014-07-14 12:28:47 -0700373 }
mtkleinbb6a0282014-07-01 08:43:42 -0700374
375 // Pretty much the same deal as the calibration: do some warmup to make
376 // sure we're timing steady-state pipelined frames.
cdaltond416a5b2015-06-23 13:23:44 -0700377 for (int i = 0; i < maxGpuFrameLag - 1; i++) {
tomhudson75a0ebb2015-03-27 12:11:44 -0700378 time(loops, bench, target);
mtkleinf3723212014-06-25 14:08:00 -0700379 }
mtkleinbb6a0282014-07-01 08:43:42 -0700380
mtkleinbb6a0282014-07-01 08:43:42 -0700381 return loops;
382}
mtkleinbb6a0282014-07-01 08:43:42 -0700383
bsalomonc2553372014-07-22 13:09:05 -0700384#if SK_SUPPORT_GPU
385#define kBogusGLContextType GrContextFactory::kNative_GLContextType
kkinnunen5219fd92015-12-10 06:28:13 -0800386#define kBogusGLContextOptions GrContextFactory::kNone_GLContextOptions
bsalomonc2553372014-07-22 13:09:05 -0700387#else
388#define kBogusGLContextType 0
kkinnunen5219fd92015-12-10 06:28:13 -0800389#define kBogusGLContextOptions 0
mtkleine714e752014-07-31 12:13:48 -0700390#endif
bsalomonc2553372014-07-22 13:09:05 -0700391
svaisanenc47635e2016-01-28 06:05:43 -0800392static void create_config(const SkCommandLineConfig* config, SkTArray<Config>* configs) {
393
394#if SK_SUPPORT_GPU
395 if (const auto* gpuConfig = config->asConfigGpu()) {
396 if (!FLAGS_gpu)
397 return;
398
399 const auto ctxOptions = gpuConfig->getUseNVPR() ? GrContextFactory::kEnableNVPR_GLContextOptions
400 : GrContextFactory::kNone_GLContextOptions;
401 const auto ctxType = gpuConfig->getContextType();
402 const auto sampleCount = gpuConfig->getSamples();
403
404 if (const GrContext* ctx = gGrFactory->get(ctxType, ctxOptions)) {
405 const auto maxSampleCount = ctx->caps()->maxSampleCount();
406 if (sampleCount > ctx->caps()->maxSampleCount()) {
407 SkDebugf("Configuration sample count %d exceeds maximum %d.\n",
408 sampleCount, maxSampleCount);
409 return;
410 }
411 } else {
412 SkDebugf("No context was available matching config type and options.\n");
413 return;
414 }
415
416 Config target = {
417 config->getTag(),
418 Benchmark::kGPU_Backend,
419 kN32_SkColorType,
420 kPremul_SkAlphaType,
421 sampleCount,
422 ctxType,
423 ctxOptions,
424 false };
425
426 configs->push_back(target);
427 return;
428 }
429#endif
430
431 #define CPU_CONFIG(name, backend, color, alpha) \
432 if (config->getTag().equals(#name)) { \
433 Config config = { SkString(#name), Benchmark::backend, color, alpha, 0, \
434 kBogusGLContextType, kBogusGLContextOptions, \
435 false }; \
436 configs->push_back(config); \
437 return; \
mtkleinbb6a0282014-07-01 08:43:42 -0700438 }
mtkleine714e752014-07-31 12:13:48 -0700439
mtklein40b32be2014-07-09 08:46:49 -0700440 if (FLAGS_cpu) {
bsalomonc2553372014-07-22 13:09:05 -0700441 CPU_CONFIG(nonrendering, kNonRendering_Backend, kUnknown_SkColorType, kUnpremul_SkAlphaType)
442 CPU_CONFIG(8888, kRaster_Backend, kN32_SkColorType, kPremul_SkAlphaType)
443 CPU_CONFIG(565, kRaster_Backend, kRGB_565_SkColorType, kOpaque_SkAlphaType)
mtklein40b32be2014-07-09 08:46:49 -0700444 }
mtkleinbb6a0282014-07-01 08:43:42 -0700445
svaisanenc47635e2016-01-28 06:05:43 -0800446 #undef CPU_CONFIG
tomhudsond968a6f2015-03-26 11:28:06 -0700447
448#ifdef SK_BUILD_FOR_ANDROID_FRAMEWORK
djsollen817c72a2016-01-28 13:57:02 -0800449 if (config->getTag().equals("hwui")) {
450 Config config = { SkString("hwui"), Benchmark::kHWUI_Backend, kRGBA_8888_SkColorType,
kkinnunen5219fd92015-12-10 06:28:13 -0800451 kPremul_SkAlphaType, 0, kBogusGLContextType, kBogusGLContextOptions,
452 false };
svaisanenc47635e2016-01-28 06:05:43 -0800453 configs->push_back(config);
tomhudsond968a6f2015-03-26 11:28:06 -0700454 }
455#endif
mtkleinf3723212014-06-25 14:08:00 -0700456}
457
svaisanenc47635e2016-01-28 06:05:43 -0800458// Append all configs that are enabled and supported.
459void create_configs(SkTArray<Config>* configs) {
460 SkCommandLineConfigArray array;
461 ParseConfigs(FLAGS_config, &array);
462 for (int i = 0; i < array.count(); ++i) {
463 create_config(array[i], configs);
464 }
465}
466
halcanary96fcdcc2015-08-27 07:41:13 -0700467// If bench is enabled for config, returns a Target* for it, otherwise nullptr.
bsalomonc2553372014-07-22 13:09:05 -0700468static Target* is_enabled(Benchmark* bench, const Config& config) {
469 if (!bench->isSuitableFor(config.backend)) {
halcanary96fcdcc2015-08-27 07:41:13 -0700470 return nullptr;
bsalomonc2553372014-07-22 13:09:05 -0700471 }
472
reede5ea5002014-09-03 11:54:58 -0700473 SkImageInfo info = SkImageInfo::Make(bench->getSize().fX, bench->getSize().fY,
474 config.color, config.alpha);
bsalomonc2553372014-07-22 13:09:05 -0700475
halcanary96fcdcc2015-08-27 07:41:13 -0700476 Target* target = nullptr;
bsalomonc2553372014-07-22 13:09:05 -0700477
tomhudsond968a6f2015-03-26 11:28:06 -0700478 switch (config.backend) {
bsalomonc2553372014-07-22 13:09:05 -0700479#if SK_SUPPORT_GPU
tomhudsond968a6f2015-03-26 11:28:06 -0700480 case Benchmark::kGPU_Backend:
481 target = new GPUTarget(config);
482 break;
bsalomonc2553372014-07-22 13:09:05 -0700483#endif
tomhudsond968a6f2015-03-26 11:28:06 -0700484#ifdef SK_BUILD_FOR_ANDROID_FRAMEWORK
485 case Benchmark::kHWUI_Backend:
486 target = new HWUITarget(config, bench);
487 break;
488#endif
489 default:
490 target = new Target(config);
491 break;
492 }
bsalomonc2553372014-07-22 13:09:05 -0700493
tomhudsond968a6f2015-03-26 11:28:06 -0700494 if (!target->init(info, bench)) {
bsalomonc2553372014-07-22 13:09:05 -0700495 delete target;
halcanary96fcdcc2015-08-27 07:41:13 -0700496 return nullptr;
bsalomonc2553372014-07-22 13:09:05 -0700497 }
498 return target;
499}
500
msarett5cb48852015-11-06 08:56:32 -0800501static bool valid_brd_bench(SkData* encoded, SkBitmapRegionDecoder::Strategy strategy,
msarett7f691442015-09-22 11:56:16 -0700502 SkColorType colorType, uint32_t sampleSize, uint32_t minOutputSize, int* width,
503 int* height) {
msarett5cb48852015-11-06 08:56:32 -0800504 SkAutoTDelete<SkBitmapRegionDecoder> brd(
505 SkBitmapRegionDecoder::Create(encoded, strategy));
msarett7f691442015-09-22 11:56:16 -0700506 if (nullptr == brd.get()) {
507 // This is indicates that subset decoding is not supported for a particular image format.
508 return false;
509 }
510
msarett35e5d1b2015-10-27 12:50:25 -0700511 SkBitmap bitmap;
512 if (!brd->decodeRegion(&bitmap, nullptr, SkIRect::MakeXYWH(0, 0, brd->width(), brd->height()),
513 1, colorType, false)) {
514 return false;
515 }
msarett7f691442015-09-22 11:56:16 -0700516
517 if (sampleSize * minOutputSize > (uint32_t) brd->width() || sampleSize * minOutputSize >
518 (uint32_t) brd->height()) {
519 // This indicates that the image is not large enough to decode a
520 // minOutputSize x minOutputSize subset at the given sampleSize.
521 return false;
522 }
523
524 // Set the image width and height. The calling code will use this to choose subsets to decode.
525 *width = brd->width();
526 *height = brd->height();
527 return true;
528}
529
egdaniel3bf92062015-06-26 08:12:46 -0700530static void cleanup_run(Target* target) {
halcanary385fe4d2015-08-26 13:07:48 -0700531 delete target;
egdaniel3bf92062015-06-26 08:12:46 -0700532#if SK_SUPPORT_GPU
533 if (FLAGS_abandonGpuContext) {
534 gGrFactory->abandonContexts();
535 }
536 if (FLAGS_resetGpuContext || FLAGS_abandonGpuContext) {
537 gGrFactory->destroyContexts();
538 }
539#endif
540}
541
mtkleine714e752014-07-31 12:13:48 -0700542class BenchmarkStream {
543public:
mtklein92007582014-08-01 07:46:52 -0700544 BenchmarkStream() : fBenches(BenchRegistry::Head())
545 , fGMs(skiagm::GMRegistry::Head())
mtkleinfd731ce2014-09-10 12:19:30 -0700546 , fCurrentRecording(0)
mtklein92007582014-08-01 07:46:52 -0700547 , fCurrentScale(0)
robertphillips5b693772014-11-21 06:19:36 -0800548 , fCurrentSKP(0)
msarett95f192d2015-02-13 09:05:41 -0800549 , fCurrentUseMPD(0)
scroggo60869a42015-04-01 12:09:17 -0700550 , fCurrentCodec(0)
msarett84451022016-02-11 06:45:51 -0800551 , fCurrentAndroidCodec(0)
msarett7f691442015-09-22 11:56:16 -0700552 , fCurrentBRDImage(0)
msarett95f192d2015-02-13 09:05:41 -0800553 , fCurrentColorType(0)
msarettc7796b92016-01-07 14:20:20 -0800554 , fCurrentAlphaType(0)
msarettb23e6aa2015-06-09 13:56:10 -0700555 , fCurrentSubsetType(0)
msarett7f691442015-09-22 11:56:16 -0700556 , fCurrentBRDStrategy(0)
msarett84451022016-02-11 06:45:51 -0800557 , fCurrentSampleSize(0)
msarettb23e6aa2015-06-09 13:56:10 -0700558 , fCurrentAnimSKP(0) {
mtklein92007582014-08-01 07:46:52 -0700559 for (int i = 0; i < FLAGS_skps.count(); i++) {
560 if (SkStrEndsWith(FLAGS_skps[i], ".skp")) {
561 fSKPs.push_back() = FLAGS_skps[i];
562 } else {
563 SkOSFile::Iter it(FLAGS_skps[i], ".skp");
564 SkString path;
565 while (it.next(&path)) {
566 fSKPs.push_back() = SkOSPath::Join(FLAGS_skps[0], path.c_str());
567 }
568 }
569 }
mtkleine714e752014-07-31 12:13:48 -0700570
mtklein92007582014-08-01 07:46:52 -0700571 if (4 != sscanf(FLAGS_clip[0], "%d,%d,%d,%d",
572 &fClip.fLeft, &fClip.fTop, &fClip.fRight, &fClip.fBottom)) {
573 SkDebugf("Can't parse %s from --clip as an SkIRect.\n", FLAGS_clip[0]);
574 exit(1);
575 }
576
577 for (int i = 0; i < FLAGS_scales.count(); i++) {
578 if (1 != sscanf(FLAGS_scales[i], "%f", &fScales.push_back())) {
579 SkDebugf("Can't parse %s from --scales as an SkScalar.\n", FLAGS_scales[i]);
580 exit(1);
581 }
582 }
robertphillips5b693772014-11-21 06:19:36 -0800583
cdalton63a82852015-06-29 14:06:10 -0700584 if (2 != sscanf(FLAGS_zoom[0], "%f,%lf", &fZoomMax, &fZoomPeriodMs)) {
585 SkDebugf("Can't parse %s from --zoom as a zoomMax,zoomPeriodMs.\n", FLAGS_zoom[0]);
joshualitt261c3ad2015-04-27 09:16:57 -0700586 exit(1);
587 }
588
robertphillips5b693772014-11-21 06:19:36 -0800589 if (FLAGS_mpd) {
590 fUseMPDs.push_back() = true;
591 }
mtkleinc751ecb2015-06-15 08:56:38 -0700592 fUseMPDs.push_back() = false;
mtklein95553d92015-03-12 08:24:21 -0700593
msarett95f192d2015-02-13 09:05:41 -0800594 // Prepare the images for decoding
scroggo86737142016-02-03 12:19:11 -0800595 if (!CollectImages(&fImages)) {
596 exit(1);
msarett95f192d2015-02-13 09:05:41 -0800597 }
mtklein95553d92015-03-12 08:24:21 -0700598
msarett95f192d2015-02-13 09:05:41 -0800599 // Choose the candidate color types for image decoding
600 const SkColorType colorTypes[] =
msarettb23e6aa2015-06-09 13:56:10 -0700601 { kN32_SkColorType,
602 kRGB_565_SkColorType,
603 kAlpha_8_SkColorType,
604 kIndex_8_SkColorType,
605 kGray_8_SkColorType };
msarett74deb982015-10-20 16:45:56 -0700606 fColorTypes.reset(colorTypes, SK_ARRAY_COUNT(colorTypes));
mtklein92007582014-08-01 07:46:52 -0700607 }
608
mtkleinfd731ce2014-09-10 12:19:30 -0700609 static bool ReadPicture(const char* path, SkAutoTUnref<SkPicture>* pic) {
610 // Not strictly necessary, as it will be checked again later,
611 // but helps to avoid a lot of pointless work if we're going to skip it.
cdalton91e457d2016-02-17 11:10:16 -0800612 if (SkCommandLineFlags::ShouldSkip(FLAGS_match, SkOSPath::Basename(path).c_str())) {
mtkleinfd731ce2014-09-10 12:19:30 -0700613 return false;
614 }
615
scroggoa1193e42015-01-21 12:09:53 -0800616 SkAutoTDelete<SkStream> stream(SkStream::NewFromFile(path));
halcanary96fcdcc2015-08-27 07:41:13 -0700617 if (stream.get() == nullptr) {
mtkleinfd731ce2014-09-10 12:19:30 -0700618 SkDebugf("Could not read %s.\n", path);
619 return false;
620 }
621
mtklein57f27bd2015-02-09 11:58:41 -0800622 pic->reset(SkPicture::CreateFromStream(stream.get()));
halcanary96fcdcc2015-08-27 07:41:13 -0700623 if (pic->get() == nullptr) {
mtkleinfd731ce2014-09-10 12:19:30 -0700624 SkDebugf("Could not read %s as an SkPicture.\n", path);
625 return false;
626 }
627 return true;
628 }
629
mtklein92007582014-08-01 07:46:52 -0700630 Benchmark* next() {
mtklein65dfd2f2016-02-03 10:40:54 -0800631 SkAutoTDelete<Benchmark> bench;
632 do {
633 bench.reset(this->rawNext());
634 if (!bench) {
635 return nullptr;
636 }
637 } while(SkCommandLineFlags::ShouldSkip(FLAGS_sourceType, fSourceType) ||
638 SkCommandLineFlags::ShouldSkip(FLAGS_benchType, fBenchType));
639 return bench.detach();
640 }
641
642 Benchmark* rawNext() {
mtkleine714e752014-07-31 12:13:48 -0700643 if (fBenches) {
halcanary96fcdcc2015-08-27 07:41:13 -0700644 Benchmark* bench = fBenches->factory()(nullptr);
mtkleine714e752014-07-31 12:13:48 -0700645 fBenches = fBenches->next();
mtklein92007582014-08-01 07:46:52 -0700646 fSourceType = "bench";
mtkleinfd731ce2014-09-10 12:19:30 -0700647 fBenchType = "micro";
mtkleine714e752014-07-31 12:13:48 -0700648 return bench;
649 }
mtklein92007582014-08-01 07:46:52 -0700650
mtkleine714e752014-07-31 12:13:48 -0700651 while (fGMs) {
halcanary96fcdcc2015-08-27 07:41:13 -0700652 SkAutoTDelete<skiagm::GM> gm(fGMs->factory()(nullptr));
mtkleine714e752014-07-31 12:13:48 -0700653 fGMs = fGMs->next();
mtkleincf5d9c92015-01-23 10:31:45 -0800654 if (gm->runAsBench()) {
mtklein92007582014-08-01 07:46:52 -0700655 fSourceType = "gm";
mtkleinfd731ce2014-09-10 12:19:30 -0700656 fBenchType = "micro";
halcanary385fe4d2015-08-26 13:07:48 -0700657 return new GMBench(gm.detach());
mtkleine714e752014-07-31 12:13:48 -0700658 }
659 }
mtklein92007582014-08-01 07:46:52 -0700660
mtkleinfd731ce2014-09-10 12:19:30 -0700661 // First add all .skps as RecordingBenches.
662 while (fCurrentRecording < fSKPs.count()) {
663 const SkString& path = fSKPs[fCurrentRecording++];
664 SkAutoTUnref<SkPicture> pic;
665 if (!ReadPicture(path.c_str(), &pic)) {
666 continue;
667 }
668 SkString name = SkOSPath::Basename(path.c_str());
669 fSourceType = "skp";
670 fBenchType = "recording";
bsalomon0aa5cea2014-12-15 09:13:35 -0800671 fSKPBytes = static_cast<double>(SkPictureUtils::ApproximateBytesUsed(pic));
mtklein051e56d2014-12-04 08:46:51 -0800672 fSKPOps = pic->approximateOpCount();
halcanary385fe4d2015-08-26 13:07:48 -0700673 return new RecordingBench(name.c_str(), pic.get(), FLAGS_bbh);
mtkleinfd731ce2014-09-10 12:19:30 -0700674 }
675
676 // Then once each for each scale as SKPBenches (playback).
mtklein92007582014-08-01 07:46:52 -0700677 while (fCurrentScale < fScales.count()) {
678 while (fCurrentSKP < fSKPs.count()) {
robertphillips5b693772014-11-21 06:19:36 -0800679 const SkString& path = fSKPs[fCurrentSKP];
mtkleinfd731ce2014-09-10 12:19:30 -0700680 SkAutoTUnref<SkPicture> pic;
681 if (!ReadPicture(path.c_str(), &pic)) {
robertphillips5b693772014-11-21 06:19:36 -0800682 fCurrentSKP++;
mtklein92007582014-08-01 07:46:52 -0700683 continue;
684 }
robertphillips5b693772014-11-21 06:19:36 -0800685
686 while (fCurrentUseMPD < fUseMPDs.count()) {
687 if (FLAGS_bbh) {
688 // The SKP we read off disk doesn't have a BBH. Re-record so it grows one.
689 SkRTreeFactory factory;
690 SkPictureRecorder recorder;
691 static const int kFlags = SkPictureRecorder::kComputeSaveLayerInfo_RecordFlag;
692 pic->playback(recorder.beginRecording(pic->cullRect().width(),
693 pic->cullRect().height(),
mtklein748ca3b2015-01-15 10:56:12 -0800694 &factory,
robertphillipse451c4d2014-12-09 10:28:00 -0800695 fUseMPDs[fCurrentUseMPD] ? kFlags : 0));
robertphillips5b693772014-11-21 06:19:36 -0800696 pic.reset(recorder.endRecording());
697 }
698 SkString name = SkOSPath::Basename(path.c_str());
699 fSourceType = "skp";
700 fBenchType = "playback";
halcanary385fe4d2015-08-26 13:07:48 -0700701 return new SKPBench(name.c_str(), pic.get(), fClip, fScales[fCurrentScale],
702 fUseMPDs[fCurrentUseMPD++], FLAGS_loopSKP);
mtklein20840502014-08-21 15:51:22 -0700703 }
robertphillips5b693772014-11-21 06:19:36 -0800704 fCurrentUseMPD = 0;
705 fCurrentSKP++;
mtklein92007582014-08-01 07:46:52 -0700706 }
707 fCurrentSKP = 0;
708 fCurrentScale++;
709 }
710
joshualitt261c3ad2015-04-27 09:16:57 -0700711 // Now loop over each skp again if we have an animation
cdalton63a82852015-06-29 14:06:10 -0700712 if (fZoomMax != 1.0f && fZoomPeriodMs > 0) {
joshualitt261c3ad2015-04-27 09:16:57 -0700713 while (fCurrentAnimSKP < fSKPs.count()) {
714 const SkString& path = fSKPs[fCurrentAnimSKP];
715 SkAutoTUnref<SkPicture> pic;
716 if (!ReadPicture(path.c_str(), &pic)) {
717 fCurrentAnimSKP++;
718 continue;
719 }
720
721 fCurrentAnimSKP++;
722 SkString name = SkOSPath::Basename(path.c_str());
cdalton63a82852015-06-29 14:06:10 -0700723 SkAutoTUnref<SKPAnimationBench::Animation> animation(
724 SKPAnimationBench::CreateZoomAnimation(fZoomMax, fZoomPeriodMs));
halcanary385fe4d2015-08-26 13:07:48 -0700725 return new SKPAnimationBench(name.c_str(), pic.get(), fClip, animation,
726 FLAGS_loopSKP);
joshualitt261c3ad2015-04-27 09:16:57 -0700727 }
728 }
729
scroggo60869a42015-04-01 12:09:17 -0700730 for (; fCurrentCodec < fImages.count(); fCurrentCodec++) {
scroggo303fa352015-10-05 11:03:34 -0700731 fSourceType = "image";
732 fBenchType = "skcodec";
scroggo60869a42015-04-01 12:09:17 -0700733 const SkString& path = fImages[fCurrentCodec];
mtklein6f0ff912016-01-11 09:04:21 -0800734 if (SkCommandLineFlags::ShouldSkip(FLAGS_match, path.c_str())) {
735 continue;
736 }
scroggo60869a42015-04-01 12:09:17 -0700737 SkAutoTUnref<SkData> encoded(SkData::NewFromFileName(path.c_str()));
738 SkAutoTDelete<SkCodec> codec(SkCodec::NewFromData(encoded));
scroggo60869a42015-04-01 12:09:17 -0700739 if (!codec) {
740 // Nothing to time.
msarett9d9725c2015-04-24 11:41:55 -0700741 SkDebugf("Cannot find codec for %s\n", path.c_str());
scroggo60869a42015-04-01 12:09:17 -0700742 continue;
743 }
scroggo21027992015-04-02 13:22:38 -0700744
scroggo60869a42015-04-01 12:09:17 -0700745 while (fCurrentColorType < fColorTypes.count()) {
scroggo21027992015-04-02 13:22:38 -0700746 const SkColorType colorType = fColorTypes[fCurrentColorType];
scroggo21027992015-04-02 13:22:38 -0700747
msarettc7796b92016-01-07 14:20:20 -0800748 SkAlphaType alphaType = codec->getInfo().alphaType();
749 switch (alphaType) {
750 case kOpaque_SkAlphaType:
751 // We only need to test one alpha type (opaque).
752 fCurrentColorType++;
753 break;
754 case kUnpremul_SkAlphaType:
755 case kPremul_SkAlphaType:
756 if (0 == fCurrentAlphaType) {
757 // Test unpremul first.
758 alphaType = kUnpremul_SkAlphaType;
759 fCurrentAlphaType++;
760 } else {
761 // Test premul.
762 alphaType = kPremul_SkAlphaType;
763 fCurrentAlphaType = 0;
764 fCurrentColorType++;
765 }
766 break;
767 default:
768 SkASSERT(false);
769 fCurrentColorType++;
770 break;
scroggo21027992015-04-02 13:22:38 -0700771 }
772
msarettc7796b92016-01-07 14:20:20 -0800773 // Make sure we can decode to this color type and alpha type.
774 SkImageInfo info =
775 codec->getInfo().makeColorType(colorType).makeAlphaType(alphaType);
scroggo21027992015-04-02 13:22:38 -0700776 const size_t rowBytes = info.minRowBytes();
777 SkAutoMalloc storage(info.getSafeSize(rowBytes));
778
779 // Used if fCurrentColorType is kIndex_8_SkColorType
780 int colorCount = 256;
781 SkPMColor colors[256];
782
scroggoeb602a52015-07-09 08:16:03 -0700783 const SkCodec::Result result = codec->getPixels(
halcanary96fcdcc2015-08-27 07:41:13 -0700784 info, storage.get(), rowBytes, nullptr, colors,
scroggo21027992015-04-02 13:22:38 -0700785 &colorCount);
scroggo60869a42015-04-01 12:09:17 -0700786 switch (result) {
scroggoeb602a52015-07-09 08:16:03 -0700787 case SkCodec::kSuccess:
788 case SkCodec::kIncompleteInput:
scroggo60869a42015-04-01 12:09:17 -0700789 return new CodecBench(SkOSPath::Basename(path.c_str()),
msarettc7796b92016-01-07 14:20:20 -0800790 encoded, colorType, alphaType);
scroggoeb602a52015-07-09 08:16:03 -0700791 case SkCodec::kInvalidConversion:
scroggo60869a42015-04-01 12:09:17 -0700792 // This is okay. Not all conversions are valid.
793 break;
scroggo60869a42015-04-01 12:09:17 -0700794 default:
795 // This represents some sort of failure.
796 SkASSERT(false);
797 break;
798 }
799 }
800 fCurrentColorType = 0;
801 }
802
msarett84451022016-02-11 06:45:51 -0800803 // Run AndroidCodecBenches
804 const int sampleSizes[] = { 2, 4, 8 };
805 for (; fCurrentAndroidCodec < fImages.count(); fCurrentAndroidCodec++) {
806 fSourceType = "image";
807 fBenchType = "skandroidcodec";
808
809 const SkString& path = fImages[fCurrentAndroidCodec];
810 if (SkCommandLineFlags::ShouldSkip(FLAGS_match, path.c_str())) {
811 continue;
812 }
813 SkAutoTUnref<SkData> encoded(SkData::NewFromFileName(path.c_str()));
814 SkAutoTDelete<SkAndroidCodec> codec(SkAndroidCodec::NewFromData(encoded));
815 if (!codec) {
816 // Nothing to time.
817 SkDebugf("Cannot find codec for %s\n", path.c_str());
818 continue;
819 }
820
821 while (fCurrentSampleSize < (int) SK_ARRAY_COUNT(sampleSizes)) {
822 int sampleSize = sampleSizes[fCurrentSampleSize];
823 fCurrentSampleSize++;
824 if (10 * sampleSize > SkTMin(codec->getInfo().width(), codec->getInfo().height())) {
825 // Avoid benchmarking scaled decodes of already small images.
826 break;
827 }
828
829 return new AndroidCodecBench(SkOSPath::Basename(path.c_str()), encoded, sampleSize);
830 }
831 fCurrentSampleSize = 0;
832 }
833
msarett7f691442015-09-22 11:56:16 -0700834 // Run the BRDBenches
835 // We will benchmark multiple BRD strategies.
scroggo303fa352015-10-05 11:03:34 -0700836 static const struct {
msarett5cb48852015-11-06 08:56:32 -0800837 SkBitmapRegionDecoder::Strategy fStrategy;
msarett0459c942015-11-10 14:52:13 -0800838 const char* fName;
scroggo303fa352015-10-05 11:03:34 -0700839 } strategies[] = {
msarett0459c942015-11-10 14:52:13 -0800840 { SkBitmapRegionDecoder::kCanvas_Strategy, "BRD_canvas" },
msarett5cb48852015-11-06 08:56:32 -0800841 { SkBitmapRegionDecoder::kAndroidCodec_Strategy, "BRD_android_codec" },
msarett7f691442015-09-22 11:56:16 -0700842 };
843
844 // We intend to create benchmarks that model the use cases in
845 // android/libraries/social/tiledimage. In this library, an image is decoded in 512x512
846 // tiles. The image can be translated freely, so the location of a tile may be anywhere in
847 // the image. For that reason, we will benchmark decodes in five representative locations
848 // in the image. Additionally, this use case utilizes power of two scaling, so we will
849 // test on power of two sample sizes. The output tile is always 512x512, so, when a
850 // sampleSize is used, the size of the subset that is decoded is always
851 // (sampleSize*512)x(sampleSize*512).
852 // There are a few good reasons to only test on power of two sample sizes at this time:
msarett7f691442015-09-22 11:56:16 -0700853 // All use cases we are aware of only scale by powers of two.
854 // PNG decodes use the indicated sampling strategy regardless of the sample size, so
855 // these tests are sufficient to provide good coverage of our scaling options.
msarett84451022016-02-11 06:45:51 -0800856 const uint32_t brdSampleSizes[] = { 1, 2, 4, 8, 16 };
msarett7f691442015-09-22 11:56:16 -0700857 const uint32_t minOutputSize = 512;
mtklein6f0ff912016-01-11 09:04:21 -0800858 for (; fCurrentBRDImage < fImages.count(); fCurrentBRDImage++) {
859 const SkString& path = fImages[fCurrentBRDImage];
860 if (SkCommandLineFlags::ShouldSkip(FLAGS_match, path.c_str())) {
861 continue;
862 }
msarett7f691442015-09-22 11:56:16 -0700863 while (fCurrentBRDStrategy < (int) SK_ARRAY_COUNT(strategies)) {
scroggo303fa352015-10-05 11:03:34 -0700864 fSourceType = "image";
865 fBenchType = strategies[fCurrentBRDStrategy].fName;
scroggo860e8a62015-10-15 07:51:28 -0700866
msarett5cb48852015-11-06 08:56:32 -0800867 const SkBitmapRegionDecoder::Strategy strategy =
scroggo860e8a62015-10-15 07:51:28 -0700868 strategies[fCurrentBRDStrategy].fStrategy;
869
msarett7f691442015-09-22 11:56:16 -0700870 while (fCurrentColorType < fColorTypes.count()) {
msarett84451022016-02-11 06:45:51 -0800871 while (fCurrentSampleSize < (int) SK_ARRAY_COUNT(brdSampleSizes)) {
msarett7f691442015-09-22 11:56:16 -0700872 while (fCurrentSubsetType <= kLastSingle_SubsetType) {
scroggo860e8a62015-10-15 07:51:28 -0700873
msarett7f691442015-09-22 11:56:16 -0700874 SkAutoTUnref<SkData> encoded(SkData::NewFromFileName(path.c_str()));
875 const SkColorType colorType = fColorTypes[fCurrentColorType];
msarett84451022016-02-11 06:45:51 -0800876 uint32_t sampleSize = brdSampleSizes[fCurrentSampleSize];
msarett7f691442015-09-22 11:56:16 -0700877 int currentSubsetType = fCurrentSubsetType++;
878
879 int width = 0;
880 int height = 0;
881 if (!valid_brd_bench(encoded.get(), strategy, colorType, sampleSize,
882 minOutputSize, &width, &height)) {
883 break;
884 }
885
886 SkString basename = SkOSPath::Basename(path.c_str());
887 SkIRect subset;
888 const uint32_t subsetSize = sampleSize * minOutputSize;
889 switch (currentSubsetType) {
890 case kTopLeft_SubsetType:
891 basename.append("_TopLeft");
892 subset = SkIRect::MakeXYWH(0, 0, subsetSize, subsetSize);
893 break;
894 case kTopRight_SubsetType:
895 basename.append("_TopRight");
896 subset = SkIRect::MakeXYWH(width - subsetSize, 0, subsetSize,
897 subsetSize);
898 break;
899 case kMiddle_SubsetType:
900 basename.append("_Middle");
901 subset = SkIRect::MakeXYWH((width - subsetSize) / 2,
902 (height - subsetSize) / 2, subsetSize, subsetSize);
903 break;
904 case kBottomLeft_SubsetType:
905 basename.append("_BottomLeft");
906 subset = SkIRect::MakeXYWH(0, height - subsetSize, subsetSize,
907 subsetSize);
908 break;
909 case kBottomRight_SubsetType:
910 basename.append("_BottomRight");
911 subset = SkIRect::MakeXYWH(width - subsetSize,
912 height - subsetSize, subsetSize, subsetSize);
913 break;
914 default:
915 SkASSERT(false);
916 }
917
918 return new BitmapRegionDecoderBench(basename.c_str(), encoded.get(),
919 strategy, colorType, sampleSize, subset);
920 }
921 fCurrentSubsetType = 0;
msarett84451022016-02-11 06:45:51 -0800922 fCurrentSampleSize++;
msarett7f691442015-09-22 11:56:16 -0700923 }
msarett84451022016-02-11 06:45:51 -0800924 fCurrentSampleSize = 0;
msarett7f691442015-09-22 11:56:16 -0700925 fCurrentColorType++;
926 }
927 fCurrentColorType = 0;
928 fCurrentBRDStrategy++;
929 }
930 fCurrentBRDStrategy = 0;
msarett7f691442015-09-22 11:56:16 -0700931 }
932
halcanary96fcdcc2015-08-27 07:41:13 -0700933 return nullptr;
mtkleine714e752014-07-31 12:13:48 -0700934 }
mtklein92007582014-08-01 07:46:52 -0700935
936 void fillCurrentOptions(ResultsWriter* log) const {
937 log->configOption("source_type", fSourceType);
mtkleinfd731ce2014-09-10 12:19:30 -0700938 log->configOption("bench_type", fBenchType);
mtklein92007582014-08-01 07:46:52 -0700939 if (0 == strcmp(fSourceType, "skp")) {
940 log->configOption("clip",
941 SkStringPrintf("%d %d %d %d", fClip.fLeft, fClip.fTop,
942 fClip.fRight, fClip.fBottom).c_str());
djsollenf2b340f2016-01-29 08:51:04 -0800943 SkASSERT_RELEASE(fCurrentScale < fScales.count()); // debugging paranoia
mtklein92007582014-08-01 07:46:52 -0700944 log->configOption("scale", SkStringPrintf("%.2g", fScales[fCurrentScale]).c_str());
robertphillips5b693772014-11-21 06:19:36 -0800945 if (fCurrentUseMPD > 0) {
946 SkASSERT(1 == fCurrentUseMPD || 2 == fCurrentUseMPD);
947 log->configOption("multi_picture_draw", fUseMPDs[fCurrentUseMPD-1] ? "true" : "false");
948 }
mtklein92007582014-08-01 07:46:52 -0700949 }
mtklein051e56d2014-12-04 08:46:51 -0800950 if (0 == strcmp(fBenchType, "recording")) {
951 log->metric("bytes", fSKPBytes);
952 log->metric("ops", fSKPOps);
953 }
mtklein92007582014-08-01 07:46:52 -0700954 }
955
mtkleine714e752014-07-31 12:13:48 -0700956private:
msarettb23e6aa2015-06-09 13:56:10 -0700957 enum SubsetType {
958 kTopLeft_SubsetType = 0,
959 kTopRight_SubsetType = 1,
msarettab80e352015-06-17 10:28:22 -0700960 kMiddle_SubsetType = 2,
961 kBottomLeft_SubsetType = 3,
962 kBottomRight_SubsetType = 4,
963 kTranslate_SubsetType = 5,
964 kZoom_SubsetType = 6,
msarett7f691442015-09-22 11:56:16 -0700965 kLast_SubsetType = kZoom_SubsetType,
966 kLastSingle_SubsetType = kBottomRight_SubsetType,
msarettb23e6aa2015-06-09 13:56:10 -0700967 };
968
mtkleine714e752014-07-31 12:13:48 -0700969 const BenchRegistry* fBenches;
970 const skiagm::GMRegistry* fGMs;
mtklein92007582014-08-01 07:46:52 -0700971 SkIRect fClip;
972 SkTArray<SkScalar> fScales;
973 SkTArray<SkString> fSKPs;
robertphillips5b693772014-11-21 06:19:36 -0800974 SkTArray<bool> fUseMPDs;
msarett95f192d2015-02-13 09:05:41 -0800975 SkTArray<SkString> fImages;
msarett74deb982015-10-20 16:45:56 -0700976 SkTArray<SkColorType, true> fColorTypes;
cdalton63a82852015-06-29 14:06:10 -0700977 SkScalar fZoomMax;
978 double fZoomPeriodMs;
mtklein92007582014-08-01 07:46:52 -0700979
mtklein051e56d2014-12-04 08:46:51 -0800980 double fSKPBytes, fSKPOps;
981
mtkleinfd731ce2014-09-10 12:19:30 -0700982 const char* fSourceType; // What we're benching: bench, GM, SKP, ...
983 const char* fBenchType; // How we bench it: micro, recording, playback, ...
984 int fCurrentRecording;
mtklein92007582014-08-01 07:46:52 -0700985 int fCurrentScale;
986 int fCurrentSKP;
robertphillips5b693772014-11-21 06:19:36 -0800987 int fCurrentUseMPD;
scroggo60869a42015-04-01 12:09:17 -0700988 int fCurrentCodec;
msarett84451022016-02-11 06:45:51 -0800989 int fCurrentAndroidCodec;
msarett7f691442015-09-22 11:56:16 -0700990 int fCurrentBRDImage;
msarett95f192d2015-02-13 09:05:41 -0800991 int fCurrentColorType;
msarettc7796b92016-01-07 14:20:20 -0800992 int fCurrentAlphaType;
msarettb23e6aa2015-06-09 13:56:10 -0700993 int fCurrentSubsetType;
msarett7f691442015-09-22 11:56:16 -0700994 int fCurrentBRDStrategy;
msarett84451022016-02-11 06:45:51 -0800995 int fCurrentSampleSize;
joshualitt261c3ad2015-04-27 09:16:57 -0700996 int fCurrentAnimSKP;
mtkleine714e752014-07-31 12:13:48 -0700997};
998
msarettc149f0e2016-01-04 11:35:43 -0800999// Some runs (mostly, Valgrind) are so slow that the bot framework thinks we've hung.
1000// This prints something every once in a while so that it knows we're still working.
1001static void start_keepalive() {
1002 struct Loop {
1003 static void forever(void*) {
1004 for (;;) {
1005 static const int kSec = 1200;
1006 #if defined(SK_BUILD_FOR_WIN)
1007 Sleep(kSec * 1000);
1008 #else
1009 sleep(kSec);
1010 #endif
1011 SkDebugf("\nBenchmarks still running...\n");
1012 }
1013 }
1014 };
1015 static SkThread* intentionallyLeaked = new SkThread(Loop::forever);
1016 intentionallyLeaked->start();
1017}
1018
jcgregorio3b27ade2014-11-13 08:06:40 -08001019int nanobench_main();
caryclark17f0b6d2014-07-22 10:15:34 -07001020int nanobench_main() {
jcgregorio3b27ade2014-11-13 08:06:40 -08001021 SetupCrashHandler();
mtkleinf3723212014-06-25 14:08:00 -07001022 SkAutoGraphics ag;
mtkleincc29d262015-07-09 10:04:56 -07001023 SkTaskGroup::Enabler enabled(FLAGS_threads);
mtkleinf3723212014-06-25 14:08:00 -07001024
krajcevski69a55602014-08-13 10:46:31 -07001025#if SK_SUPPORT_GPU
bsalomon682c2692015-05-22 14:01:46 -07001026 GrContextOptions grContextOpts;
krajcevski12b35442014-08-13 12:06:26 -07001027 grContextOpts.fDrawPathToCompressedTexture = FLAGS_gpuCompressAlphaMasks;
halcanary385fe4d2015-08-26 13:07:48 -07001028 gGrFactory.reset(new GrContextFactory(grContextOpts));
krajcevski69a55602014-08-13 10:46:31 -07001029#endif
1030
bsalomon06cddec2014-10-24 10:40:50 -07001031 if (FLAGS_veryVerbose) {
1032 FLAGS_verbose = true;
1033 }
1034
bsalomon6eb03cc2014-08-07 14:28:50 -07001035 if (kAutoTuneLoops != FLAGS_loops) {
mtkleina189ccd2014-07-14 12:28:47 -07001036 FLAGS_samples = 1;
1037 FLAGS_gpuFrameLag = 0;
1038 }
1039
bsalomon6eb03cc2014-08-07 14:28:50 -07001040 if (!FLAGS_writePath.isEmpty()) {
1041 SkDebugf("Writing files to %s.\n", FLAGS_writePath[0]);
1042 if (!sk_mkdir(FLAGS_writePath[0])) {
1043 SkDebugf("Could not create %s. Files won't be written.\n", FLAGS_writePath[0]);
halcanary96fcdcc2015-08-27 07:41:13 -07001044 FLAGS_writePath.set(0, nullptr);
bsalomon6eb03cc2014-08-07 14:28:50 -07001045 }
1046 }
1047
halcanary385fe4d2015-08-26 13:07:48 -07001048 SkAutoTDelete<ResultsWriter> log(new ResultsWriter);
mtklein60317d0f2014-07-14 11:30:37 -07001049 if (!FLAGS_outResultsFile.isEmpty()) {
mtklein53520152016-01-20 09:53:59 -08001050#if defined(SK_RELEASE)
halcanary385fe4d2015-08-26 13:07:48 -07001051 log.reset(new NanoJSONResultsWriter(FLAGS_outResultsFile[0]));
mtklein53520152016-01-20 09:53:59 -08001052#else
1053 SkDebugf("I'm ignoring --outResultsFile because this is a Debug build.");
1054 return 1;
1055#endif
mtklein60317d0f2014-07-14 11:30:37 -07001056 }
mtklein1915b622014-08-20 11:45:00 -07001057
1058 if (1 == FLAGS_properties.count() % 2) {
1059 SkDebugf("ERROR: --properties must be passed with an even number of arguments.\n");
1060 return 1;
1061 }
1062 for (int i = 1; i < FLAGS_properties.count(); i += 2) {
1063 log->property(FLAGS_properties[i-1], FLAGS_properties[i]);
1064 }
jcgregoriobf5e5232014-07-17 13:14:16 -07001065
1066 if (1 == FLAGS_key.count() % 2) {
1067 SkDebugf("ERROR: --key must be passed with an even number of arguments.\n");
1068 return 1;
1069 }
1070 for (int i = 1; i < FLAGS_key.count(); i += 2) {
mtklein1915b622014-08-20 11:45:00 -07001071 log->key(FLAGS_key[i-1], FLAGS_key[i]);
mtklein94e51562014-08-19 12:41:53 -07001072 }
mtklein60317d0f2014-07-14 11:30:37 -07001073
mtkleinf3723212014-06-25 14:08:00 -07001074 const double overhead = estimate_timer_overhead();
mtklein55b0ffc2014-07-17 08:38:23 -07001075 SkDebugf("Timer overhead: %s\n", HUMANIZE(overhead));
Mike Klein91294772014-07-16 19:59:32 -04001076
cdaltone1b89582015-06-25 19:17:08 -07001077 SkTArray<double> samples;
mtkleinbb6a0282014-07-01 08:43:42 -07001078
bsalomon6eb03cc2014-08-07 14:28:50 -07001079 if (kAutoTuneLoops != FLAGS_loops) {
1080 SkDebugf("Fixed number of loops; times would only be misleading so we won't print them.\n");
mtkleinf3723212014-06-25 14:08:00 -07001081 } else if (FLAGS_quiet) {
mtklein66cfcff2015-12-04 06:35:30 -08001082 SkDebugf("! -> high variance, ? -> moderate variance\n");
1083 SkDebugf(" micros \tbench\n");
mtkleinbbba1682015-10-28 11:36:30 -07001084 } else if (FLAGS_ms) {
cdaltone1b89582015-06-25 19:17:08 -07001085 SkDebugf("curr/maxrss\tloops\tmin\tmedian\tmean\tmax\tstddev\tsamples\tconfig\tbench\n");
mtkleinf3723212014-06-25 14:08:00 -07001086 } else {
mtkleind75c4662015-04-30 07:11:22 -07001087 SkDebugf("curr/maxrss\tloops\tmin\tmedian\tmean\tmax\tstddev\t%-*s\tconfig\tbench\n",
qiankun.miao8247ec32014-09-09 19:24:36 -07001088 FLAGS_samples, "samples");
mtkleinf3723212014-06-25 14:08:00 -07001089 }
1090
svaisanenc47635e2016-01-28 06:05:43 -08001091 SkTArray<Config> configs;
bsalomonc2553372014-07-22 13:09:05 -07001092 create_configs(&configs);
1093
joshualitt3ebd0502016-02-09 07:18:08 -08001094#ifdef THERMAL_MANAGER_SUPPORTED
1095 int tmEnabled, tmThreshold, tmSleepTimeMs, tmTimeoutMs;
1096 if (4 != sscanf(FLAGS_useThermalManager[0], "%d,%d,%d,%d",
1097 &tmEnabled, &tmThreshold, &tmSleepTimeMs, &tmTimeoutMs)) {
1098 SkDebugf("Can't parse %s from --useThermalManager.\n", FLAGS_useThermalManager[0]);
1099 exit(1);
1100 }
1101 ThermalManager tm(tmThreshold, tmSleepTimeMs, tmTimeoutMs);
1102#endif
1103
msarettc149f0e2016-01-04 11:35:43 -08001104 if (FLAGS_keepAlive) {
1105 start_keepalive();
1106 }
1107
mtkleine070c2b2014-10-14 08:40:43 -07001108 int runs = 0;
mtklein92007582014-08-01 07:46:52 -07001109 BenchmarkStream benchStream;
1110 while (Benchmark* b = benchStream.next()) {
mtkleine714e752014-07-31 12:13:48 -07001111 SkAutoTDelete<Benchmark> bench(b);
mtklein96289052014-09-10 12:05:59 -07001112 if (SkCommandLineFlags::ShouldSkip(FLAGS_match, bench->getUniqueName())) {
mtkleinf3723212014-06-25 14:08:00 -07001113 continue;
1114 }
1115
svaisanenc47635e2016-01-28 06:05:43 -08001116 if (!configs.empty()) {
mtklein96289052014-09-10 12:05:59 -07001117 log->bench(bench->getUniqueName(), bench->getSize().fX, bench->getSize().fY);
joshualitt8a6697a2015-09-30 12:11:07 -07001118 bench->delayedSetup();
jcgregoriobf5e5232014-07-17 13:14:16 -07001119 }
egdaniel3bf92062015-06-26 08:12:46 -07001120 for (int i = 0; i < configs.count(); ++i) {
joshualitt3ebd0502016-02-09 07:18:08 -08001121#ifdef THERMAL_MANAGER_SUPPORTED
1122 if (tmEnabled && !tm.coolOffIfNecessary()) {
1123 SkDebugf("Could not cool off, timings will be throttled\n");
1124 }
1125#endif
egdaniel3bf92062015-06-26 08:12:46 -07001126 Target* target = is_enabled(b, configs[i]);
1127 if (!target) {
1128 continue;
1129 }
mtkleinf3723212014-06-25 14:08:00 -07001130
halcanary96fcdcc2015-08-27 07:41:13 -07001131 // During HWUI output this canvas may be nullptr.
egdaniel3bf92062015-06-26 08:12:46 -07001132 SkCanvas* canvas = target->getCanvas();
svaisanenc47635e2016-01-28 06:05:43 -08001133 const char* config = target->config.name.c_str();
egdaniel3bf92062015-06-26 08:12:46 -07001134
brianosman7a5ada82016-02-08 13:49:12 -08001135 if (FLAGS_pre_log || FLAGS_dryRun) {
benjaminwagner8d61f0d2016-01-25 13:02:40 -08001136 SkDebugf("Running %s\t%s\n"
1137 , bench->getUniqueName()
1138 , config);
brianosman7a5ada82016-02-08 13:49:12 -08001139 if (FLAGS_dryRun) {
1140 continue;
1141 }
benjaminwagner8d61f0d2016-01-25 13:02:40 -08001142 }
1143
egdaniel3bf92062015-06-26 08:12:46 -07001144 target->setup();
robertphillips5b693772014-11-21 06:19:36 -08001145 bench->perCanvasPreDraw(canvas);
1146
cdaltone1b89582015-06-25 19:17:08 -07001147 int maxFrameLag;
mtkleina1ebeb22015-10-01 09:43:39 -07001148 int loops = target->needsFrameTiming(&maxFrameLag)
egdaniel3bf92062015-06-26 08:12:46 -07001149 ? setup_gpu_bench(target, bench.get(), maxFrameLag)
1150 : setup_cpu_bench(overhead, target, bench.get());
cdaltone1b89582015-06-25 19:17:08 -07001151
mtkleinbbba1682015-10-28 11:36:30 -07001152 if (FLAGS_ms) {
1153 samples.reset();
1154 auto stop = now_ms() + FLAGS_ms;
1155 do {
1156 samples.push_back(time(loops, bench, target) / loops);
1157 } while (now_ms() < stop);
1158 } else {
cdaltone1b89582015-06-25 19:17:08 -07001159 samples.reset(FLAGS_samples);
1160 for (int s = 0; s < FLAGS_samples; s++) {
egdaniel3bf92062015-06-26 08:12:46 -07001161 samples[s] = time(loops, bench, target) / loops;
cdaltone1b89582015-06-25 19:17:08 -07001162 }
cdaltone1b89582015-06-25 19:17:08 -07001163 }
mtkleinf3723212014-06-25 14:08:00 -07001164
joshualitte45c81c2015-12-02 09:05:37 -08001165#if SK_SUPPORT_GPU
1166 SkTArray<SkString> keys;
1167 SkTArray<double> values;
1168 bool gpuStatsDump = FLAGS_gpuStatsDump && Benchmark::kGPU_Backend == configs[i].backend;
1169 if (gpuStatsDump) {
1170 // TODO cache stats
1171 bench->getGpuStats(canvas, &keys, &values);
1172 }
1173#endif
1174
robertphillips5b693772014-11-21 06:19:36 -08001175 bench->perCanvasPostDraw(canvas);
1176
egdaniel3bf92062015-06-26 08:12:46 -07001177 if (Benchmark::kNonRendering_Backend != target->config.backend &&
tomhudsond968a6f2015-03-26 11:28:06 -07001178 !FLAGS_writePath.isEmpty() && FLAGS_writePath[0]) {
bsalomon6eb03cc2014-08-07 14:28:50 -07001179 SkString pngFilename = SkOSPath::Join(FLAGS_writePath[0], config);
mtklein96289052014-09-10 12:05:59 -07001180 pngFilename = SkOSPath::Join(pngFilename.c_str(), bench->getUniqueName());
bsalomon6eb03cc2014-08-07 14:28:50 -07001181 pngFilename.append(".png");
egdaniel3bf92062015-06-26 08:12:46 -07001182 write_canvas_png(target, pngFilename);
bsalomon6eb03cc2014-08-07 14:28:50 -07001183 }
1184
1185 if (kFailedLoops == loops) {
mtklein2069e222014-08-04 13:57:39 -07001186 // Can't be timed. A warning note has already been printed.
egdaniel3bf92062015-06-26 08:12:46 -07001187 cleanup_run(target);
Mike Kleine3631362014-07-15 17:56:37 -04001188 continue;
1189 }
1190
cdaltone1b89582015-06-25 19:17:08 -07001191 Stats stats(samples);
mtklein1915b622014-08-20 11:45:00 -07001192 log->config(config);
mtklein96289052014-09-10 12:05:59 -07001193 log->configOption("name", bench->getName());
mtklein1915b622014-08-20 11:45:00 -07001194 benchStream.fillCurrentOptions(log.get());
egdaniel3bf92062015-06-26 08:12:46 -07001195 target->fillOptions(log.get());
mtklein051e56d2014-12-04 08:46:51 -08001196 log->metric("min_ms", stats.min);
mtkleine5cf2c62016-01-11 11:28:26 -08001197 log->metric("median_ms", stats.median);
joshualitte45c81c2015-12-02 09:05:37 -08001198#if SK_SUPPORT_GPU
1199 if (gpuStatsDump) {
1200 // dump to json, only SKPBench currently returns valid keys / values
1201 SkASSERT(keys.count() == values.count());
1202 for (int i = 0; i < keys.count(); i++) {
1203 log->metric(keys[i].c_str(), values[i]);
1204 }
1205 }
1206#endif
1207
mtkleine070c2b2014-10-14 08:40:43 -07001208 if (runs++ % FLAGS_flushEvery == 0) {
1209 log->flush();
1210 }
mtklein60317d0f2014-07-14 11:30:37 -07001211
bsalomon6eb03cc2014-08-07 14:28:50 -07001212 if (kAutoTuneLoops != FLAGS_loops) {
egdaniel3bf92062015-06-26 08:12:46 -07001213 if (configs.count() == 1) {
mtkleina189ccd2014-07-14 12:28:47 -07001214 config = ""; // Only print the config if we run the same bench on more than one.
1215 }
mtkleind75c4662015-04-30 07:11:22 -07001216 SkDebugf("%4d/%-4dMB\t%s\t%s\n"
1217 , sk_tools::getCurrResidentSetSizeMB()
1218 , sk_tools::getMaxResidentSetSizeMB()
mtklein53d25622014-09-18 07:39:42 -07001219 , bench->getUniqueName()
1220 , config);
mtkleinf3723212014-06-25 14:08:00 -07001221 } else if (FLAGS_quiet) {
mtklein66cfcff2015-12-04 06:35:30 -08001222 const char* mark = " ";
1223 const double stddev_percent = 100 * sqrt(stats.var) / stats.mean;
1224 if (stddev_percent > 5) mark = "?";
1225 if (stddev_percent > 10) mark = "!";
1226
1227 SkDebugf("%10.2f %s\t%s\t%s\n",
1228 stats.median*1e3, mark, bench->getUniqueName(), config);
mtkleinf3723212014-06-25 14:08:00 -07001229 } else {
1230 const double stddev_percent = 100 * sqrt(stats.var) / stats.mean;
mtkleind75c4662015-04-30 07:11:22 -07001231 SkDebugf("%4d/%-4dMB\t%d\t%s\t%s\t%s\t%s\t%.0f%%\t%s\t%s\t%s\n"
1232 , sk_tools::getCurrResidentSetSizeMB()
1233 , sk_tools::getMaxResidentSetSizeMB()
mtkleinf3723212014-06-25 14:08:00 -07001234 , loops
mtklein55b0ffc2014-07-17 08:38:23 -07001235 , HUMANIZE(stats.min)
1236 , HUMANIZE(stats.median)
1237 , HUMANIZE(stats.mean)
1238 , HUMANIZE(stats.max)
mtkleinf3723212014-06-25 14:08:00 -07001239 , stddev_percent
mtkleinbbba1682015-10-28 11:36:30 -07001240 , FLAGS_ms ? to_string(samples.count()).c_str() : stats.plot.c_str()
mtkleinf3723212014-06-25 14:08:00 -07001241 , config
mtklein96289052014-09-10 12:05:59 -07001242 , bench->getUniqueName()
mtkleinf3723212014-06-25 14:08:00 -07001243 );
1244 }
joshualitte45c81c2015-12-02 09:05:37 -08001245
bsalomonb12ea412015-02-02 21:19:50 -08001246#if SK_SUPPORT_GPU
joshualitte45c81c2015-12-02 09:05:37 -08001247 if (FLAGS_gpuStats && Benchmark::kGPU_Backend == configs[i].backend) {
kkinnunen5219fd92015-12-10 06:28:13 -08001248 GrContext* context = gGrFactory->get(configs[i].ctxType,
kkinnunen3e980c32015-12-23 01:33:00 -08001249 configs[i].ctxOptions);
kkinnunen5219fd92015-12-10 06:28:13 -08001250 context->printCacheStats();
1251 context->printGpuStats();
bsalomon06cddec2014-10-24 10:40:50 -07001252 }
1253#endif
joshualitte45c81c2015-12-02 09:05:37 -08001254
cdalton2c56ba52015-06-26 13:32:53 -07001255 if (FLAGS_verbose) {
1256 SkDebugf("Samples: ");
1257 for (int i = 0; i < samples.count(); i++) {
1258 SkDebugf("%s ", HUMANIZE(samples[i]));
1259 }
1260 SkDebugf("%s\n", bench->getUniqueName());
1261 }
egdaniel3bf92062015-06-26 08:12:46 -07001262 cleanup_run(target);
mtkleinf3723212014-06-25 14:08:00 -07001263 }
mtkleinf3723212014-06-25 14:08:00 -07001264 }
1265
mtkleine1091452014-12-04 10:47:02 -08001266 log->bench("memory_usage", 0,0);
1267 log->config("meta");
1268 log->metric("max_rss_mb", sk_tools::getMaxResidentSetSizeMB());
1269
joshualitte0b19d42015-03-26 10:41:02 -07001270#if SK_SUPPORT_GPU
1271 // Make sure we clean up the global GrContextFactory here, otherwise we might race with the
1272 // SkEventTracer destructor
halcanary96fcdcc2015-08-27 07:41:13 -07001273 gGrFactory.reset(nullptr);
joshualitte0b19d42015-03-26 10:41:02 -07001274#endif
1275
mtkleinf3723212014-06-25 14:08:00 -07001276 return 0;
1277}
1278
jcgregorio3b27ade2014-11-13 08:06:40 -08001279#if !defined SK_BUILD_FOR_IOS
1280int main(int argc, char** argv) {
1281 SkCommandLineFlags::Parse(argc, argv);
1282 return nanobench_main();
1283}
1284#endif