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 "SkCommandLineFlags.h"
9#include "SkForceLinking.h"
10#include "SkGraphics.h"
11#include "SkOSFile.h"
12#include "SkPicture.h"
13#include "SkPictureRecorder.h"
14#include "SkStream.h"
15#include "SkString.h"
16
17#include "LazyDecodeBitmap.h"
18#include "Stats.h"
19#include "Timer.h"
20
21__SK_FORCE_IMAGE_DECODER_LINKING;
22
23DEFINE_string2(skps, r, "skps", "Directory containing SKPs to read and re-record.");
24DEFINE_int32(samples, 10, "Number of times to re-record each SKP.");
25DEFINE_int32(tileGridSize, 512, "Set the tile grid size. Has no effect if bbh is not set to tilegrid.");
26DEFINE_string(bbh, "", "Turn on the bbh and select the type, one of rtree, tilegrid, quadtree");
27DEFINE_bool(skr, false, "Record SKR instead of SKP.");
28DEFINE_string(match, "", "The usual filters on file names of SKPs to bench.");
29DEFINE_string(timescale, "us", "Print times in ms, us, or ns");
30DEFINE_double(overheadGoal, 0.0001,
31              "Try to make timer overhead at most this fraction of our sample measurements.");
32DEFINE_int32(verbose, 0, "0: print min sample; "
33                         "1: print min, mean, max and noise indication "
34                         "2: print all samples");
35
36static double timescale() {
37    if (FLAGS_timescale.contains("us")) return 1000;
38    if (FLAGS_timescale.contains("ns")) return 1000000;
39    return 1;
40}
41
42static SkBBHFactory* parse_FLAGS_bbh() {
43    if (FLAGS_bbh.isEmpty()) {
44        return NULL;
45    }
46
47    if (FLAGS_bbh.contains("rtree")) {
48        return SkNEW(SkRTreeFactory);
49    }
50    if (FLAGS_bbh.contains("tilegrid")) {
51        SkTileGridFactory::TileGridInfo info;
52        info.fTileInterval.set(FLAGS_tileGridSize, FLAGS_tileGridSize);
53        info.fMargin.setEmpty();
54        info.fOffset.setZero();
55        return SkNEW_ARGS(SkTileGridFactory, (info));
56    }
57    if (FLAGS_bbh.contains("quadtree")) {
58        return SkNEW(SkQuadTreeFactory);
59    }
60    SkDebugf("Invalid bbh type %s, must be one of rtree, tilegrid, quadtree.\n", FLAGS_bbh[0]);
61    return NULL;
62}
63
64static void rerecord(const SkPicture& src, SkBBHFactory* bbhFactory) {
65    SkPictureRecorder recorder;
66    if (FLAGS_skr) {
67        src.draw(recorder.EXPERIMENTAL_beginRecording(src.width(), src.height(), bbhFactory));
68    } else {
69        src.draw(recorder.beginRecording(src.width(), src.height(), bbhFactory));
70    }
71    SkAutoTUnref<SkPicture> pic(recorder.endRecording());
72}
73
74static void bench_record(const SkPicture& src,
75                         const double timerOverhead,
76                         const char* name,
77                         SkBBHFactory* bbhFactory) {
78    // Rerecord once to warm up any caches.  Otherwise the first sample can be very noisy.
79    rerecord(src, bbhFactory);
80
81    // Rerecord once to see how many times we should loop to make timer overhead insignificant.
82    WallTimer timer;
83    const double scale = timescale();
84    do {
85        timer.start();
86        rerecord(src, bbhFactory);
87        timer.end();
88    } while (timer.fWall * scale < timerOverhead);  // Loop just in case something bizarre happens.
89
90    // We want (timer overhead / measurement) to be less than FLAGS_overheadGoal.
91    // So in each sample, we'll loop enough times to have made that true for our first measurement.
92    const int loops = (int)ceil(timerOverhead / timer.fWall / FLAGS_overheadGoal);
93
94    SkAutoTMalloc<double> samples(FLAGS_samples);
95    for (int i = 0; i < FLAGS_samples; i++) {
96        timer.start();
97        for (int j = 0; j < loops; j++) {
98            rerecord(src, bbhFactory);
99        }
100        timer.end();
101        samples[i] = timer.fWall * scale / loops;
102    }
103
104    Stats stats(samples.get(), FLAGS_samples);
105    if (FLAGS_verbose == 0) {
106        printf("%g\t%s\n", stats.min, name);
107    } else if (FLAGS_verbose == 1) {
108        // Get a rough idea of how noisy the measurements were.
109        const double noisePercent = 100 * sqrt(stats.var) / stats.mean;
110        printf("%g\t%g\t%g\t±%.0f%%\t%s\n", stats.min, stats.mean, stats.max, noisePercent, name);
111    } else if (FLAGS_verbose == 2) {
112        printf("%s", name);
113        for (int i = 0; i < FLAGS_samples; i++) {
114            printf("\t%g", samples[i]);
115        }
116        printf("\n");
117    }
118}
119
120int tool_main(int argc, char** argv);
121int tool_main(int argc, char** argv) {
122    SkCommandLineFlags::Parse(argc, argv);
123    SkAutoGraphics autoGraphics;
124
125    if (FLAGS_bbh.count() > 1) {
126        SkDebugf("Multiple bbh arguments supplied.\n");
127        return 1;
128    }
129
130    SkAutoTDelete<SkBBHFactory> bbhFactory(parse_FLAGS_bbh());
131
132    // Each run will use this timer overhead estimate to guess how many times it should run.
133    static const int kOverheadLoops = 10000000;
134    WallTimer timer;
135    double overheadEstimate = 0.0;
136    const double scale = timescale();
137    for (int i = 0; i < kOverheadLoops; i++) {
138        timer.start();
139        timer.end();
140        overheadEstimate += timer.fWall * scale;
141    }
142    overheadEstimate /= kOverheadLoops;
143
144    SkOSFile::Iter it(FLAGS_skps[0], ".skp");
145    SkString filename;
146    bool failed = false;
147    while (it.next(&filename)) {
148        if (SkCommandLineFlags::ShouldSkip(FLAGS_match, filename.c_str())) {
149            continue;
150        }
151
152        const SkString path = SkOSPath::SkPathJoin(FLAGS_skps[0], filename.c_str());
153
154        SkAutoTUnref<SkStream> stream(SkStream::NewFromFile(path.c_str()));
155        if (!stream) {
156            SkDebugf("Could not read %s.\n", path.c_str());
157            failed = true;
158            continue;
159        }
160        SkAutoTUnref<SkPicture> src(
161            SkPicture::CreateFromStream(stream, sk_tools::LazyDecodeBitmap));
162        if (!src) {
163            SkDebugf("Could not read %s as an SkPicture.\n", path.c_str());
164            failed = true;
165            continue;
166        }
167        bench_record(*src, overheadEstimate, filename.c_str(), bbhFactory.get());
168    }
169    return failed ? 1 : 0;
170}
171
172#if !defined SK_BUILD_FOR_IOS
173int main(int argc, char * const argv[]) {
174    return tool_main(argc, (char**) argv);
175}
176#endif
177