1 /*
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
8 #include <ctype.h>
9
10 #include "nanobench.h"
11
12 #include "Benchmark.h"
13 #include "CodecBench.h"
14 #include "CrashHandler.h"
15 #include "DecodingBench.h"
16 #include "DecodingSubsetBench.h"
17 #include "GMBench.h"
18 #include "ProcStats.h"
19 #include "ResultsWriter.h"
20 #include "RecordingBench.h"
21 #include "SKPAnimationBench.h"
22 #include "SKPBench.h"
23 #include "Stats.h"
24 #include "Timer.h"
25
26 #include "SkBBoxHierarchy.h"
27 #include "SkCanvas.h"
28 #include "SkCodec.h"
29 #include "SkCommonFlags.h"
30 #include "SkData.h"
31 #include "SkForceLinking.h"
32 #include "SkGraphics.h"
33 #include "SkOSFile.h"
34 #include "SkPictureRecorder.h"
35 #include "SkPictureUtils.h"
36 #include "SkString.h"
37 #include "SkSurface.h"
38 #include "SkTaskGroup.h"
39
40 #ifdef SK_BUILD_FOR_ANDROID_FRAMEWORK
41 #include "nanobenchAndroid.h"
42 #endif
43
44 #if SK_SUPPORT_GPU
45 #include "gl/GrGLDefines.h"
46 #include "GrContextFactory.h"
47 SkAutoTDelete<GrContextFactory> gGrFactory;
48 #endif
49
50 __SK_FORCE_IMAGE_DECODER_LINKING;
51
52 static const int kAutoTuneLoops = 0;
53
54 static const int kDefaultLoops =
55 #ifdef SK_DEBUG
56 1;
57 #else
58 kAutoTuneLoops;
59 #endif
60
loops_help_txt()61 static SkString loops_help_txt() {
62 SkString help;
63 help.printf("Number of times to run each bench. Set this to %d to auto-"
64 "tune for each bench. Timings are only reported when auto-tuning.",
65 kAutoTuneLoops);
66 return help;
67 }
68
69 DEFINE_int32(loops, kDefaultLoops, loops_help_txt().c_str());
70
71 DEFINE_int32(samples, 10, "Number of samples to measure for each bench.");
72 DEFINE_int32(overheadLoops, 100000, "Loops to estimate timer overhead.");
73 DEFINE_double(overheadGoal, 0.0001,
74 "Loop until timer overhead is at most this fraction of our measurments.");
75 DEFINE_double(gpuMs, 5, "Target bench time in millseconds for GPU.");
76 DEFINE_int32(gpuFrameLag, 5, "Overestimate of maximum number of frames GPU allows to lag.");
77 DEFINE_bool(gpuCompressAlphaMasks, false, "Compress masks generated from falling back to "
78 "software path rendering.");
79
80 DEFINE_string(outResultsFile, "", "If given, write results here as JSON.");
81 DEFINE_int32(maxCalibrationAttempts, 3,
82 "Try up to this many times to guess loops for a bench, or skip the bench.");
83 DEFINE_int32(maxLoops, 1000000, "Never run a bench more times than this.");
84 DEFINE_string(clip, "0,0,1000,1000", "Clip for SKPs.");
85 DEFINE_string(scales, "1.0", "Space-separated scales for SKPs.");
86 DEFINE_string(zoom, "1.0,1", "Comma-separated scale,step zoom factors for SKPs.");
87 DEFINE_bool(bbh, true, "Build a BBH for SKPs?");
88 DEFINE_bool(mpd, true, "Use MultiPictureDraw for the SKPs?");
89 DEFINE_int32(flushEvery, 10, "Flush --outResultsFile every Nth run.");
90 DEFINE_bool(resetGpuContext, true, "Reset the GrContext before running each test.");
91 DEFINE_bool(gpuStats, false, "Print GPU stats after each gpu benchmark?");
92
humanize(double ms)93 static SkString humanize(double ms) {
94 if (FLAGS_verbose) return SkStringPrintf("%llu", (uint64_t)(ms*1e6));
95 return HumanizeMs(ms);
96 }
97 #define HUMANIZE(ms) humanize(ms).c_str()
98
init(SkImageInfo info,Benchmark * bench)99 bool Target::init(SkImageInfo info, Benchmark* bench) {
100 if (Benchmark::kRaster_Backend == config.backend) {
101 this->surface.reset(SkSurface::NewRaster(info));
102 if (!this->surface.get()) {
103 return false;
104 }
105 }
106 return true;
107 }
capturePixels(SkBitmap * bmp)108 bool Target::capturePixels(SkBitmap* bmp) {
109 SkCanvas* canvas = this->getCanvas();
110 if (!canvas) {
111 return false;
112 }
113 bmp->setInfo(canvas->imageInfo());
114 if (!canvas->readPixels(bmp, 0, 0)) {
115 SkDebugf("Can't read canvas pixels.\n");
116 return false;
117 }
118 return true;
119 }
120
121 #if SK_SUPPORT_GPU
122 struct GPUTarget : public Target {
GPUTargetGPUTarget123 explicit GPUTarget(const Config& c) : Target(c), gl(NULL) { }
124 SkGLContext* gl;
125
setupGPUTarget126 void setup() override {
127 this->gl->makeCurrent();
128 // Make sure we're done with whatever came before.
129 SK_GL(*this->gl, Finish());
130 }
endTimingGPUTarget131 void endTiming() override {
132 if (this->gl) {
133 SK_GL(*this->gl, Flush());
134 this->gl->swapBuffers();
135 }
136 }
fenceGPUTarget137 void fence() override {
138 SK_GL(*this->gl, Finish());
139 }
140
needsFrameTimingGPUTarget141 bool needsFrameTiming() const override { return true; }
initGPUTarget142 bool init(SkImageInfo info, Benchmark* bench) override {
143 uint32_t flags = this->config.useDFText ? SkSurfaceProps::kUseDistanceFieldFonts_Flag : 0;
144 SkSurfaceProps props(flags, SkSurfaceProps::kLegacyFontHost_InitType);
145 this->surface.reset(SkSurface::NewRenderTarget(gGrFactory->get(this->config.ctxType),
146 SkSurface::kNo_Budgeted, info,
147 this->config.samples, &props));
148 this->gl = gGrFactory->getGLContext(this->config.ctxType);
149 if (!this->surface.get()) {
150 return false;
151 }
152 return true;
153 }
fillOptionsGPUTarget154 void fillOptions(ResultsWriter* log) override {
155 const GrGLubyte* version;
156 SK_GL_RET(*this->gl, version, GetString(GR_GL_VERSION));
157 log->configOption("GL_VERSION", (const char*)(version));
158
159 SK_GL_RET(*this->gl, version, GetString(GR_GL_RENDERER));
160 log->configOption("GL_RENDERER", (const char*) version);
161
162 SK_GL_RET(*this->gl, version, GetString(GR_GL_VENDOR));
163 log->configOption("GL_VENDOR", (const char*) version);
164
165 SK_GL_RET(*this->gl, version, GetString(GR_GL_SHADING_LANGUAGE_VERSION));
166 log->configOption("GL_SHADING_LANGUAGE_VERSION", (const char*) version);
167 }
168 };
169
170 #endif
171
time(int loops,Benchmark * bench,Target * target)172 static double time(int loops, Benchmark* bench, Target* target) {
173 SkCanvas* canvas = target->getCanvas();
174 if (canvas) {
175 canvas->clear(SK_ColorWHITE);
176 }
177 WallTimer timer;
178 timer.start();
179 canvas = target->beginTiming(canvas);
180 bench->draw(loops, canvas);
181 if (canvas) {
182 canvas->flush();
183 }
184 target->endTiming();
185 timer.end();
186 return timer.fWall;
187 }
188
estimate_timer_overhead()189 static double estimate_timer_overhead() {
190 double overhead = 0;
191 for (int i = 0; i < FLAGS_overheadLoops; i++) {
192 WallTimer timer;
193 timer.start();
194 timer.end();
195 overhead += timer.fWall;
196 }
197 return overhead / FLAGS_overheadLoops;
198 }
199
detect_forever_loops(int loops)200 static int detect_forever_loops(int loops) {
201 // look for a magic run-forever value
202 if (loops < 0) {
203 loops = SK_MaxS32;
204 }
205 return loops;
206 }
207
clamp_loops(int loops)208 static int clamp_loops(int loops) {
209 if (loops < 1) {
210 SkDebugf("ERROR: clamping loops from %d to 1. "
211 "There's probably something wrong with the bench.\n", loops);
212 return 1;
213 }
214 if (loops > FLAGS_maxLoops) {
215 SkDebugf("WARNING: clamping loops from %d to FLAGS_maxLoops, %d.\n", loops, FLAGS_maxLoops);
216 return FLAGS_maxLoops;
217 }
218 return loops;
219 }
220
write_canvas_png(Target * target,const SkString & filename)221 static bool write_canvas_png(Target* target, const SkString& filename) {
222
223 if (filename.isEmpty()) {
224 return false;
225 }
226 if (target->getCanvas() &&
227 kUnknown_SkColorType == target->getCanvas()->imageInfo().colorType()) {
228 return false;
229 }
230
231 SkBitmap bmp;
232
233 if (!target->capturePixels(&bmp)) {
234 return false;
235 }
236
237 SkString dir = SkOSPath::Dirname(filename.c_str());
238 if (!sk_mkdir(dir.c_str())) {
239 SkDebugf("Can't make dir %s.\n", dir.c_str());
240 return false;
241 }
242 SkFILEWStream stream(filename.c_str());
243 if (!stream.isValid()) {
244 SkDebugf("Can't write %s.\n", filename.c_str());
245 return false;
246 }
247 if (!SkImageEncoder::EncodeStream(&stream, bmp, SkImageEncoder::kPNG_Type, 100)) {
248 SkDebugf("Can't encode a PNG.\n");
249 return false;
250 }
251 return true;
252 }
253
254 static int kFailedLoops = -2;
cpu_bench(const double overhead,Target * target,Benchmark * bench,double * samples)255 static int cpu_bench(const double overhead, Target* target, Benchmark* bench, double* samples) {
256 // First figure out approximately how many loops of bench it takes to make overhead negligible.
257 double bench_plus_overhead = 0.0;
258 int round = 0;
259 if (kAutoTuneLoops == FLAGS_loops) {
260 while (bench_plus_overhead < overhead) {
261 if (round++ == FLAGS_maxCalibrationAttempts) {
262 SkDebugf("WARNING: Can't estimate loops for %s (%s vs. %s); skipping.\n",
263 bench->getUniqueName(), HUMANIZE(bench_plus_overhead), HUMANIZE(overhead));
264 return kFailedLoops;
265 }
266 bench_plus_overhead = time(1, bench, target);
267 }
268 }
269
270 // Later we'll just start and stop the timer once but loop N times.
271 // We'll pick N to make timer overhead negligible:
272 //
273 // overhead
274 // ------------------------- < FLAGS_overheadGoal
275 // overhead + N * Bench Time
276 //
277 // where bench_plus_overhead ≈ overhead + Bench Time.
278 //
279 // Doing some math, we get:
280 //
281 // (overhead / FLAGS_overheadGoal) - overhead
282 // ------------------------------------------ < N
283 // bench_plus_overhead - overhead)
284 //
285 // Luckily, this also works well in practice. :)
286 int loops = FLAGS_loops;
287 if (kAutoTuneLoops == loops) {
288 const double numer = overhead / FLAGS_overheadGoal - overhead;
289 const double denom = bench_plus_overhead - overhead;
290 loops = (int)ceil(numer / denom);
291 loops = clamp_loops(loops);
292 } else {
293 loops = detect_forever_loops(loops);
294 }
295
296 for (int i = 0; i < FLAGS_samples; i++) {
297 samples[i] = time(loops, bench, target) / loops;
298 }
299 return loops;
300 }
301
gpu_bench(Target * target,Benchmark * bench,double * samples)302 static int gpu_bench(Target* target,
303 Benchmark* bench,
304 double* samples) {
305 // First, figure out how many loops it'll take to get a frame up to FLAGS_gpuMs.
306 int loops = FLAGS_loops;
307 if (kAutoTuneLoops == loops) {
308 loops = 1;
309 double elapsed = 0;
310 do {
311 if (1<<30 == loops) {
312 // We're about to wrap. Something's wrong with the bench.
313 loops = 0;
314 break;
315 }
316 loops *= 2;
317 // If the GPU lets frames lag at all, we need to make sure we're timing
318 // _this_ round, not still timing last round. We force this by looping
319 // more times than any reasonable GPU will allow frames to lag.
320 for (int i = 0; i < FLAGS_gpuFrameLag; i++) {
321 elapsed = time(loops, bench, target);
322 }
323 } while (elapsed < FLAGS_gpuMs);
324
325 // We've overshot at least a little. Scale back linearly.
326 loops = (int)ceil(loops * FLAGS_gpuMs / elapsed);
327 loops = clamp_loops(loops);
328
329 // Make sure we're not still timing our calibration.
330 target->fence();
331 } else {
332 loops = detect_forever_loops(loops);
333 }
334
335 // Pretty much the same deal as the calibration: do some warmup to make
336 // sure we're timing steady-state pipelined frames.
337 for (int i = 0; i < FLAGS_gpuFrameLag; i++) {
338 time(loops, bench, target);
339 }
340
341 // Now, actually do the timing!
342 for (int i = 0; i < FLAGS_samples; i++) {
343 samples[i] = time(loops, bench, target) / loops;
344 }
345
346 return loops;
347 }
348
to_lower(const char * str)349 static SkString to_lower(const char* str) {
350 SkString lower(str);
351 for (size_t i = 0; i < lower.size(); i++) {
352 lower[i] = tolower(lower[i]);
353 }
354 return lower;
355 }
356
is_cpu_config_allowed(const char * name)357 static bool is_cpu_config_allowed(const char* name) {
358 for (int i = 0; i < FLAGS_config.count(); i++) {
359 if (to_lower(FLAGS_config[i]).equals(name)) {
360 return true;
361 }
362 }
363 return false;
364 }
365
366 #if SK_SUPPORT_GPU
is_gpu_config_allowed(const char * name,GrContextFactory::GLContextType ctxType,int sampleCnt)367 static bool is_gpu_config_allowed(const char* name, GrContextFactory::GLContextType ctxType,
368 int sampleCnt) {
369 if (!is_cpu_config_allowed(name)) {
370 return false;
371 }
372 if (const GrContext* ctx = gGrFactory->get(ctxType)) {
373 return sampleCnt <= ctx->getMaxSampleCount();
374 }
375 return false;
376 }
377 #endif
378
379 #if SK_SUPPORT_GPU
380 #define kBogusGLContextType GrContextFactory::kNative_GLContextType
381 #else
382 #define kBogusGLContextType 0
383 #endif
384
385 // Append all configs that are enabled and supported.
create_configs(SkTDArray<Config> * configs)386 static void create_configs(SkTDArray<Config>* configs) {
387 #define CPU_CONFIG(name, backend, color, alpha) \
388 if (is_cpu_config_allowed(#name)) { \
389 Config config = { #name, Benchmark::backend, color, alpha, 0, \
390 kBogusGLContextType, false }; \
391 configs->push(config); \
392 }
393
394 if (FLAGS_cpu) {
395 CPU_CONFIG(nonrendering, kNonRendering_Backend, kUnknown_SkColorType, kUnpremul_SkAlphaType)
396 CPU_CONFIG(8888, kRaster_Backend, kN32_SkColorType, kPremul_SkAlphaType)
397 CPU_CONFIG(565, kRaster_Backend, kRGB_565_SkColorType, kOpaque_SkAlphaType)
398 }
399
400 #if SK_SUPPORT_GPU
401 #define GPU_CONFIG(name, ctxType, samples, useDFText) \
402 if (is_gpu_config_allowed(#name, GrContextFactory::ctxType, samples)) { \
403 Config config = { \
404 #name, \
405 Benchmark::kGPU_Backend, \
406 kN32_SkColorType, \
407 kPremul_SkAlphaType, \
408 samples, \
409 GrContextFactory::ctxType, \
410 useDFText }; \
411 configs->push(config); \
412 }
413
414 if (FLAGS_gpu) {
415 GPU_CONFIG(gpu, kNative_GLContextType, 0, false)
416 GPU_CONFIG(msaa4, kNative_GLContextType, 4, false)
417 GPU_CONFIG(msaa16, kNative_GLContextType, 16, false)
418 GPU_CONFIG(nvprmsaa4, kNVPR_GLContextType, 4, false)
419 GPU_CONFIG(nvprmsaa16, kNVPR_GLContextType, 16, false)
420 GPU_CONFIG(gpudft, kNative_GLContextType, 0, true)
421 GPU_CONFIG(debug, kDebug_GLContextType, 0, false)
422 GPU_CONFIG(nullgpu, kNull_GLContextType, 0, false)
423 #ifdef SK_ANGLE
424 GPU_CONFIG(angle, kANGLE_GLContextType, 0, false)
425 #endif
426 }
427 #endif
428
429 #ifdef SK_BUILD_FOR_ANDROID_FRAMEWORK
430 if (is_cpu_config_allowed("hwui")) {
431 Config config = { "hwui", Benchmark::kHWUI_Backend, kRGBA_8888_SkColorType,
432 kPremul_SkAlphaType, 0, kBogusGLContextType, false };
433 configs->push(config);
434 }
435 #endif
436 }
437
438 // If bench is enabled for config, returns a Target* for it, otherwise NULL.
is_enabled(Benchmark * bench,const Config & config)439 static Target* is_enabled(Benchmark* bench, const Config& config) {
440 if (!bench->isSuitableFor(config.backend)) {
441 return NULL;
442 }
443
444 SkImageInfo info = SkImageInfo::Make(bench->getSize().fX, bench->getSize().fY,
445 config.color, config.alpha);
446
447 Target* target = NULL;
448
449 switch (config.backend) {
450 #if SK_SUPPORT_GPU
451 case Benchmark::kGPU_Backend:
452 target = new GPUTarget(config);
453 break;
454 #endif
455 #ifdef SK_BUILD_FOR_ANDROID_FRAMEWORK
456 case Benchmark::kHWUI_Backend:
457 target = new HWUITarget(config, bench);
458 break;
459 #endif
460 default:
461 target = new Target(config);
462 break;
463 }
464
465 if (!target->init(info, bench)) {
466 delete target;
467 return NULL;
468 }
469 return target;
470 }
471
472 // Creates targets for a benchmark and a set of configs.
create_targets(SkTDArray<Target * > * targets,Benchmark * b,const SkTDArray<Config> & configs)473 static void create_targets(SkTDArray<Target*>* targets, Benchmark* b,
474 const SkTDArray<Config>& configs) {
475 for (int i = 0; i < configs.count(); ++i) {
476 if (Target* t = is_enabled(b, configs[i])) {
477 targets->push(t);
478 }
479
480 }
481 }
482
483
484 class BenchmarkStream {
485 public:
BenchmarkStream()486 BenchmarkStream() : fBenches(BenchRegistry::Head())
487 , fGMs(skiagm::GMRegistry::Head())
488 , fCurrentRecording(0)
489 , fCurrentScale(0)
490 , fCurrentSKP(0)
491 , fCurrentUseMPD(0)
492 , fCurrentCodec(0)
493 , fCurrentImage(0)
494 , fCurrentSubsetImage(0)
495 , fCurrentColorType(0)
496 , fCurrentAnimSKP(0)
497 , fDivisor(2) {
498 for (int i = 0; i < FLAGS_skps.count(); i++) {
499 if (SkStrEndsWith(FLAGS_skps[i], ".skp")) {
500 fSKPs.push_back() = FLAGS_skps[i];
501 } else {
502 SkOSFile::Iter it(FLAGS_skps[i], ".skp");
503 SkString path;
504 while (it.next(&path)) {
505 fSKPs.push_back() = SkOSPath::Join(FLAGS_skps[0], path.c_str());
506 }
507 }
508 }
509
510 if (4 != sscanf(FLAGS_clip[0], "%d,%d,%d,%d",
511 &fClip.fLeft, &fClip.fTop, &fClip.fRight, &fClip.fBottom)) {
512 SkDebugf("Can't parse %s from --clip as an SkIRect.\n", FLAGS_clip[0]);
513 exit(1);
514 }
515
516 for (int i = 0; i < FLAGS_scales.count(); i++) {
517 if (1 != sscanf(FLAGS_scales[i], "%f", &fScales.push_back())) {
518 SkDebugf("Can't parse %s from --scales as an SkScalar.\n", FLAGS_scales[i]);
519 exit(1);
520 }
521 }
522
523 if (2 != sscanf(FLAGS_zoom[0], "%f,%d", &fZoomScale, &fZoomSteps)) {
524 SkDebugf("Can't parse %s from --zoom as a scale,step.\n", FLAGS_zoom[0]);
525 exit(1);
526 }
527
528 fUseMPDs.push_back() = false;
529 if (FLAGS_mpd) {
530 fUseMPDs.push_back() = true;
531 }
532
533 // Prepare the images for decoding
534 for (int i = 0; i < FLAGS_images.count(); i++) {
535 const char* flag = FLAGS_images[i];
536 if (sk_isdir(flag)) {
537 // If the value passed in is a directory, add all the images
538 SkOSFile::Iter it(flag);
539 SkString file;
540 while (it.next(&file)) {
541 fImages.push_back() = SkOSPath::Join(flag, file.c_str());
542 }
543 } else if (sk_exists(flag)) {
544 // Also add the value if it is a single image
545 fImages.push_back() = flag;
546 }
547 }
548
549 // Choose the candidate color types for image decoding
550 const SkColorType colorTypes[] =
551 { kN32_SkColorType, kRGB_565_SkColorType, kAlpha_8_SkColorType, kIndex_8_SkColorType };
552 fColorTypes.push_back_n(SK_ARRAY_COUNT(colorTypes), colorTypes);
553 }
554
ReadPicture(const char * path,SkAutoTUnref<SkPicture> * pic)555 static bool ReadPicture(const char* path, SkAutoTUnref<SkPicture>* pic) {
556 // Not strictly necessary, as it will be checked again later,
557 // but helps to avoid a lot of pointless work if we're going to skip it.
558 if (SkCommandLineFlags::ShouldSkip(FLAGS_match, path)) {
559 return false;
560 }
561
562 SkAutoTDelete<SkStream> stream(SkStream::NewFromFile(path));
563 if (stream.get() == NULL) {
564 SkDebugf("Could not read %s.\n", path);
565 return false;
566 }
567
568 pic->reset(SkPicture::CreateFromStream(stream.get()));
569 if (pic->get() == NULL) {
570 SkDebugf("Could not read %s as an SkPicture.\n", path);
571 return false;
572 }
573 return true;
574 }
575
next()576 Benchmark* next() {
577 if (fBenches) {
578 Benchmark* bench = fBenches->factory()(NULL);
579 fBenches = fBenches->next();
580 fSourceType = "bench";
581 fBenchType = "micro";
582 return bench;
583 }
584
585 while (fGMs) {
586 SkAutoTDelete<skiagm::GM> gm(fGMs->factory()(NULL));
587 fGMs = fGMs->next();
588 if (gm->runAsBench()) {
589 fSourceType = "gm";
590 fBenchType = "micro";
591 return SkNEW_ARGS(GMBench, (gm.detach()));
592 }
593 }
594
595 // First add all .skps as RecordingBenches.
596 while (fCurrentRecording < fSKPs.count()) {
597 const SkString& path = fSKPs[fCurrentRecording++];
598 SkAutoTUnref<SkPicture> pic;
599 if (!ReadPicture(path.c_str(), &pic)) {
600 continue;
601 }
602 SkString name = SkOSPath::Basename(path.c_str());
603 fSourceType = "skp";
604 fBenchType = "recording";
605 fSKPBytes = static_cast<double>(SkPictureUtils::ApproximateBytesUsed(pic));
606 fSKPOps = pic->approximateOpCount();
607 return SkNEW_ARGS(RecordingBench, (name.c_str(), pic.get(), FLAGS_bbh));
608 }
609
610 // Then once each for each scale as SKPBenches (playback).
611 while (fCurrentScale < fScales.count()) {
612 while (fCurrentSKP < fSKPs.count()) {
613 const SkString& path = fSKPs[fCurrentSKP];
614 SkAutoTUnref<SkPicture> pic;
615 if (!ReadPicture(path.c_str(), &pic)) {
616 fCurrentSKP++;
617 continue;
618 }
619
620 while (fCurrentUseMPD < fUseMPDs.count()) {
621 if (FLAGS_bbh) {
622 // The SKP we read off disk doesn't have a BBH. Re-record so it grows one.
623 SkRTreeFactory factory;
624 SkPictureRecorder recorder;
625 static const int kFlags = SkPictureRecorder::kComputeSaveLayerInfo_RecordFlag;
626 pic->playback(recorder.beginRecording(pic->cullRect().width(),
627 pic->cullRect().height(),
628 &factory,
629 fUseMPDs[fCurrentUseMPD] ? kFlags : 0));
630 pic.reset(recorder.endRecording());
631 }
632 SkString name = SkOSPath::Basename(path.c_str());
633 fSourceType = "skp";
634 fBenchType = "playback";
635 return SkNEW_ARGS(SKPBench,
636 (name.c_str(), pic.get(), fClip,
637 fScales[fCurrentScale], fUseMPDs[fCurrentUseMPD++]));
638
639 }
640 fCurrentUseMPD = 0;
641 fCurrentSKP++;
642 }
643 fCurrentSKP = 0;
644 fCurrentScale++;
645 }
646
647 // Now loop over each skp again if we have an animation
648 if (fZoomScale != 1.0f && fZoomSteps != 1) {
649 while (fCurrentAnimSKP < fSKPs.count()) {
650 const SkString& path = fSKPs[fCurrentAnimSKP];
651 SkAutoTUnref<SkPicture> pic;
652 if (!ReadPicture(path.c_str(), &pic)) {
653 fCurrentAnimSKP++;
654 continue;
655 }
656
657 fCurrentAnimSKP++;
658 SkString name = SkOSPath::Basename(path.c_str());
659 SkMatrix anim = SkMatrix::I();
660 anim.setScale(fZoomScale, fZoomScale);
661 return SkNEW_ARGS(SKPAnimationBench, (name.c_str(), pic.get(), fClip, anim,
662 fZoomSteps));
663 }
664 }
665
666
667 for (; fCurrentCodec < fImages.count(); fCurrentCodec++) {
668 const SkString& path = fImages[fCurrentCodec];
669 SkAutoTUnref<SkData> encoded(SkData::NewFromFileName(path.c_str()));
670 SkAutoTDelete<SkCodec> codec(SkCodec::NewFromData(encoded));
671 if (!codec) {
672 // Nothing to time.
673 SkDebugf("Cannot find codec for %s\n", path.c_str());
674 continue;
675 }
676
677 while (fCurrentColorType < fColorTypes.count()) {
678 const SkColorType colorType = fColorTypes[fCurrentColorType];
679 fCurrentColorType++;
680
681 // Make sure we can decode to this color type.
682 SkImageInfo info = codec->getInfo().makeColorType(colorType);
683 SkAlphaType alphaType;
684 if (!SkColorTypeValidateAlphaType(colorType, info.alphaType(),
685 &alphaType)) {
686 continue;
687 }
688 if (alphaType != info.alphaType()) {
689 info = info.makeAlphaType(alphaType);
690 }
691
692 const size_t rowBytes = info.minRowBytes();
693 SkAutoMalloc storage(info.getSafeSize(rowBytes));
694
695 // Used if fCurrentColorType is kIndex_8_SkColorType
696 int colorCount = 256;
697 SkPMColor colors[256];
698
699 const SkImageGenerator::Result result = codec->getPixels(
700 info, storage.get(), rowBytes, NULL, colors,
701 &colorCount);
702 switch (result) {
703 case SkImageGenerator::kSuccess:
704 case SkImageGenerator::kIncompleteInput:
705 return new CodecBench(SkOSPath::Basename(path.c_str()),
706 encoded, colorType);
707 case SkImageGenerator::kInvalidConversion:
708 // This is okay. Not all conversions are valid.
709 break;
710 default:
711 // This represents some sort of failure.
712 SkASSERT(false);
713 break;
714 }
715 }
716 fCurrentColorType = 0;
717 }
718
719 // Run the DecodingBenches
720 while (fCurrentImage < fImages.count()) {
721 while (fCurrentColorType < fColorTypes.count()) {
722 const SkString& path = fImages[fCurrentImage];
723 SkColorType colorType = fColorTypes[fCurrentColorType];
724 fCurrentColorType++;
725 // Check if the image decodes to the right color type
726 // before creating the benchmark
727 SkBitmap bitmap;
728 if (SkImageDecoder::DecodeFile(path.c_str(), &bitmap,
729 colorType, SkImageDecoder::kDecodePixels_Mode)
730 && bitmap.colorType() == colorType) {
731 return new DecodingBench(path, colorType);
732 }
733 }
734 fCurrentColorType = 0;
735 fCurrentImage++;
736 }
737
738 // Run the DecodingSubsetBenches
739 while (fCurrentSubsetImage < fImages.count()) {
740 while (fCurrentColorType < fColorTypes.count()) {
741 const SkString& path = fImages[fCurrentSubsetImage];
742 SkColorType colorType = fColorTypes[fCurrentColorType];
743 fCurrentColorType++;
744 // Check if the image decodes before creating the benchmark
745 SkAutoTUnref<SkData> encoded(
746 SkData::NewFromFileName(path.c_str()));
747 SkAutoTDelete<SkMemoryStream> stream(
748 new SkMemoryStream(encoded));
749 SkAutoTDelete<SkImageDecoder>
750 decoder(SkImageDecoder::Factory(stream.get()));
751 if (!decoder) {
752 SkDebugf("Cannot find decoder for %s\n", path.c_str());
753 } else {
754 stream->rewind();
755 int w, h;
756 bool success;
757 if (!decoder->buildTileIndex(stream.detach(), &w, &h)
758 || w*h == 1) {
759 // This is not an error, but in this case we still
760 // do not want to run the benchmark.
761 success = false;
762 } else if (fDivisor > w || fDivisor > h) {
763 SkDebugf("Divisor %d is too big for %s %dx%d\n",
764 fDivisor, path.c_str(), w, h);
765 success = false;
766 } else {
767 const int sW = w / fDivisor;
768 const int sH = h / fDivisor;
769 SkBitmap bitmap;
770 success = true;
771 for (int y = 0; y < h; y += sH) {
772 for (int x = 0; x < w; x += sW) {
773 SkIRect rect = SkIRect::MakeXYWH(x, y, sW, sH);
774 success &= decoder->decodeSubset(&bitmap, rect,
775 colorType);
776 }
777 }
778 }
779 // Create the benchmark if successful
780 if (success) {
781 return new DecodingSubsetBench(path, colorType,
782 fDivisor);
783 }
784 }
785 }
786 fCurrentColorType = 0;
787 fCurrentSubsetImage++;
788 }
789
790 return NULL;
791 }
792
fillCurrentOptions(ResultsWriter * log) const793 void fillCurrentOptions(ResultsWriter* log) const {
794 log->configOption("source_type", fSourceType);
795 log->configOption("bench_type", fBenchType);
796 if (0 == strcmp(fSourceType, "skp")) {
797 log->configOption("clip",
798 SkStringPrintf("%d %d %d %d", fClip.fLeft, fClip.fTop,
799 fClip.fRight, fClip.fBottom).c_str());
800 log->configOption("scale", SkStringPrintf("%.2g", fScales[fCurrentScale]).c_str());
801 if (fCurrentUseMPD > 0) {
802 SkASSERT(1 == fCurrentUseMPD || 2 == fCurrentUseMPD);
803 log->configOption("multi_picture_draw", fUseMPDs[fCurrentUseMPD-1] ? "true" : "false");
804 }
805 }
806 if (0 == strcmp(fBenchType, "recording")) {
807 log->metric("bytes", fSKPBytes);
808 log->metric("ops", fSKPOps);
809 }
810 }
811
812 private:
813 const BenchRegistry* fBenches;
814 const skiagm::GMRegistry* fGMs;
815 SkIRect fClip;
816 SkTArray<SkScalar> fScales;
817 SkTArray<SkString> fSKPs;
818 SkTArray<bool> fUseMPDs;
819 SkTArray<SkString> fImages;
820 SkTArray<SkColorType> fColorTypes;
821 SkScalar fZoomScale;
822 int fZoomSteps;
823
824 double fSKPBytes, fSKPOps;
825
826 const char* fSourceType; // What we're benching: bench, GM, SKP, ...
827 const char* fBenchType; // How we bench it: micro, recording, playback, ...
828 int fCurrentRecording;
829 int fCurrentScale;
830 int fCurrentSKP;
831 int fCurrentUseMPD;
832 int fCurrentCodec;
833 int fCurrentImage;
834 int fCurrentSubsetImage;
835 int fCurrentColorType;
836 int fCurrentAnimSKP;
837 const int fDivisor;
838 };
839
840 int nanobench_main();
nanobench_main()841 int nanobench_main() {
842 SetupCrashHandler();
843 SkAutoGraphics ag;
844 SkTaskGroup::Enabler enabled;
845
846 #if SK_SUPPORT_GPU
847 GrContext::Options grContextOpts;
848 grContextOpts.fDrawPathToCompressedTexture = FLAGS_gpuCompressAlphaMasks;
849 gGrFactory.reset(SkNEW_ARGS(GrContextFactory, (grContextOpts)));
850 #endif
851
852 if (FLAGS_veryVerbose) {
853 FLAGS_verbose = true;
854 }
855
856 if (kAutoTuneLoops != FLAGS_loops) {
857 FLAGS_samples = 1;
858 FLAGS_gpuFrameLag = 0;
859 }
860
861 if (!FLAGS_writePath.isEmpty()) {
862 SkDebugf("Writing files to %s.\n", FLAGS_writePath[0]);
863 if (!sk_mkdir(FLAGS_writePath[0])) {
864 SkDebugf("Could not create %s. Files won't be written.\n", FLAGS_writePath[0]);
865 FLAGS_writePath.set(0, NULL);
866 }
867 }
868
869 SkAutoTDelete<ResultsWriter> log(SkNEW(ResultsWriter));
870 if (!FLAGS_outResultsFile.isEmpty()) {
871 log.reset(SkNEW(NanoJSONResultsWriter(FLAGS_outResultsFile[0])));
872 }
873
874 if (1 == FLAGS_properties.count() % 2) {
875 SkDebugf("ERROR: --properties must be passed with an even number of arguments.\n");
876 return 1;
877 }
878 for (int i = 1; i < FLAGS_properties.count(); i += 2) {
879 log->property(FLAGS_properties[i-1], FLAGS_properties[i]);
880 }
881
882 if (1 == FLAGS_key.count() % 2) {
883 SkDebugf("ERROR: --key must be passed with an even number of arguments.\n");
884 return 1;
885 }
886 for (int i = 1; i < FLAGS_key.count(); i += 2) {
887 log->key(FLAGS_key[i-1], FLAGS_key[i]);
888 }
889
890 const double overhead = estimate_timer_overhead();
891 SkDebugf("Timer overhead: %s\n", HUMANIZE(overhead));
892
893 SkAutoTMalloc<double> samples(FLAGS_samples);
894
895 if (kAutoTuneLoops != FLAGS_loops) {
896 SkDebugf("Fixed number of loops; times would only be misleading so we won't print them.\n");
897 } else if (FLAGS_verbose) {
898 // No header.
899 } else if (FLAGS_quiet) {
900 SkDebugf("median\tbench\tconfig\n");
901 } else {
902 SkDebugf("curr/maxrss\tloops\tmin\tmedian\tmean\tmax\tstddev\t%-*s\tconfig\tbench\n",
903 FLAGS_samples, "samples");
904 }
905
906 SkTDArray<Config> configs;
907 create_configs(&configs);
908
909 int runs = 0;
910 BenchmarkStream benchStream;
911 while (Benchmark* b = benchStream.next()) {
912 SkAutoTDelete<Benchmark> bench(b);
913 if (SkCommandLineFlags::ShouldSkip(FLAGS_match, bench->getUniqueName())) {
914 continue;
915 }
916
917 SkTDArray<Target*> targets;
918 create_targets(&targets, bench.get(), configs);
919
920 if (!targets.isEmpty()) {
921 log->bench(bench->getUniqueName(), bench->getSize().fX, bench->getSize().fY);
922 bench->preDraw();
923 }
924 for (int j = 0; j < targets.count(); j++) {
925 // During HWUI output this canvas may be NULL.
926 SkCanvas* canvas = targets[j]->getCanvas();
927 const char* config = targets[j]->config.name;
928
929 targets[j]->setup();
930 bench->perCanvasPreDraw(canvas);
931
932 const int loops =
933 targets[j]->needsFrameTiming()
934 ? gpu_bench(targets[j], bench.get(), samples.get())
935 : cpu_bench(overhead, targets[j], bench.get(), samples.get());
936
937 bench->perCanvasPostDraw(canvas);
938
939 if (Benchmark::kNonRendering_Backend != targets[j]->config.backend &&
940 !FLAGS_writePath.isEmpty() && FLAGS_writePath[0]) {
941 SkString pngFilename = SkOSPath::Join(FLAGS_writePath[0], config);
942 pngFilename = SkOSPath::Join(pngFilename.c_str(), bench->getUniqueName());
943 pngFilename.append(".png");
944 write_canvas_png(targets[j], pngFilename);
945 }
946
947 if (kFailedLoops == loops) {
948 // Can't be timed. A warning note has already been printed.
949 continue;
950 }
951
952 Stats stats(samples.get(), FLAGS_samples);
953 log->config(config);
954 log->configOption("name", bench->getName());
955 benchStream.fillCurrentOptions(log.get());
956 targets[j]->fillOptions(log.get());
957 log->metric("min_ms", stats.min);
958 if (runs++ % FLAGS_flushEvery == 0) {
959 log->flush();
960 }
961
962 if (kAutoTuneLoops != FLAGS_loops) {
963 if (targets.count() == 1) {
964 config = ""; // Only print the config if we run the same bench on more than one.
965 }
966 SkDebugf("%4d/%-4dMB\t%s\t%s\n"
967 , sk_tools::getCurrResidentSetSizeMB()
968 , sk_tools::getMaxResidentSetSizeMB()
969 , bench->getUniqueName()
970 , config);
971 } else if (FLAGS_verbose) {
972 for (int i = 0; i < FLAGS_samples; i++) {
973 SkDebugf("%s ", HUMANIZE(samples[i]));
974 }
975 SkDebugf("%s\n", bench->getUniqueName());
976 } else if (FLAGS_quiet) {
977 if (targets.count() == 1) {
978 config = ""; // Only print the config if we run the same bench on more than one.
979 }
980 SkDebugf("%s\t%s\t%s\n", HUMANIZE(stats.median), bench->getUniqueName(), config);
981 } else {
982 const double stddev_percent = 100 * sqrt(stats.var) / stats.mean;
983 SkDebugf("%4d/%-4dMB\t%d\t%s\t%s\t%s\t%s\t%.0f%%\t%s\t%s\t%s\n"
984 , sk_tools::getCurrResidentSetSizeMB()
985 , sk_tools::getMaxResidentSetSizeMB()
986 , loops
987 , HUMANIZE(stats.min)
988 , HUMANIZE(stats.median)
989 , HUMANIZE(stats.mean)
990 , HUMANIZE(stats.max)
991 , stddev_percent
992 , stats.plot.c_str()
993 , config
994 , bench->getUniqueName()
995 );
996 }
997 #if SK_SUPPORT_GPU
998 if (FLAGS_gpuStats &&
999 Benchmark::kGPU_Backend == targets[j]->config.backend) {
1000 gGrFactory->get(targets[j]->config.ctxType)->printCacheStats();
1001 gGrFactory->get(targets[j]->config.ctxType)->printGpuStats();
1002 }
1003 #endif
1004 }
1005 targets.deleteAll();
1006
1007 #if SK_SUPPORT_GPU
1008 if (FLAGS_abandonGpuContext) {
1009 gGrFactory->abandonContexts();
1010 }
1011 if (FLAGS_resetGpuContext || FLAGS_abandonGpuContext) {
1012 gGrFactory->destroyContexts();
1013 }
1014 #endif
1015 }
1016
1017 log->bench("memory_usage", 0,0);
1018 log->config("meta");
1019 log->metric("max_rss_mb", sk_tools::getMaxResidentSetSizeMB());
1020
1021 #if SK_SUPPORT_GPU
1022 // Make sure we clean up the global GrContextFactory here, otherwise we might race with the
1023 // SkEventTracer destructor
1024 gGrFactory.reset(NULL);
1025 #endif
1026
1027 return 0;
1028 }
1029
1030 #if !defined SK_BUILD_FOR_IOS
main(int argc,char ** argv)1031 int main(int argc, char** argv) {
1032 SkCommandLineFlags::Parse(argc, argv);
1033 return nanobench_main();
1034 }
1035 #endif
1036