OLD | NEW |
1 /* | 1 /* |
2 * Copyright 2013 Google Inc. | 2 * Copyright 2013 Google Inc. |
3 * | 3 * |
4 * Use of this source code is governed by a BSD-style license that can be | 4 * Use of this source code is governed by a BSD-style license that can be |
5 * found in the LICENSE file. | 5 * found in the LICENSE file. |
6 */ | 6 */ |
7 | 7 |
8 #include "BenchTimer.h" | 8 #include "BenchTimer.h" |
9 #include "LazyDecodeBitmap.h" | 9 #include "LazyDecodeBitmap.h" |
10 #include "PictureBenchmark.h" | 10 #include "PictureBenchmark.h" |
11 #include "PictureRenderer.h" | 11 #include "PictureRenderer.h" |
12 #include "SkBenchmark.h" | 12 #include "SkBenchmark.h" |
13 #include "SkForceLinking.h" | 13 #include "SkForceLinking.h" |
14 #include "SkGraphics.h" | 14 #include "SkGraphics.h" |
15 #include "SkStream.h" | 15 #include "SkStream.h" |
16 #include "SkString.h" | 16 #include "SkString.h" |
17 #include "SkTArray.h" | 17 #include "SkTArray.h" |
18 #include "SkCommandLineFlags.h" | 18 #include "TimerData.h" |
19 | 19 |
20 typedef sk_tools::PictureRenderer::BBoxHierarchyType BBoxType; | 20 static const int kNumNormalRecordings = 10; |
21 static const int kBBoxTypeCount = sk_tools::PictureRenderer::kLast_BBoxHierarchy
Type + 1; | 21 static const int kNumRTreeRecordings = 10; |
| 22 static const int kNumPlaybacks = 1; |
| 23 static const size_t kNumBaseBenchmarks = 3; |
| 24 static const size_t kNumTileSizes = 3; |
| 25 static const size_t kNumBbhPlaybackBenchmarks = 3; |
| 26 static const size_t kNumBenchmarks = kNumBaseBenchmarks + kNumBbhPlaybackBenchma
rks; |
| 27 |
| 28 enum BenchmarkType { |
| 29 kNormal_BenchmarkType = 0, |
| 30 kRTree_BenchmarkType, |
| 31 }; |
| 32 |
| 33 struct Histogram { |
| 34 Histogram() { |
| 35 // Make fCpuTime negative so that we don't mess with stats: |
| 36 fCpuTime = SkIntToScalar(-1); |
| 37 } |
| 38 SkScalar fCpuTime; |
| 39 SkString fPath; |
| 40 }; |
22 | 41 |
23 | 42 |
24 DEFINE_string2(skps, r, "", "The list of SKPs to benchmark."); | 43 //////////////////////////////////////////////////////////////////////////////// |
25 DEFINE_string(bbh, "", "The set of bbox types to test. If empty, all are tested.
" | 44 // Defined below. |
26 "Should be one or more of none, quadtree, rtree, tilegrid
."); | 45 struct BenchmarkControl; |
27 DEFINE_int32(record, 100, "Number of times to record each SKP."); | |
28 DEFINE_int32(playback, 1, "Number of times to playback each SKP."); | |
29 DEFINE_int32(tilesize, 256, "The size of a tile."); | |
30 | 46 |
31 struct Measurement { | 47 typedef void (*BenchmarkFunction) |
| 48 (const BenchmarkControl&, const SkString&, SkPicture*, BenchTimer*); |
| 49 |
| 50 static void benchmark_playback( |
| 51 const BenchmarkControl&, const SkString&, SkPicture*, BenchTimer*); |
| 52 static void benchmark_recording( |
| 53 const BenchmarkControl&, const SkString&, SkPicture*, BenchTimer*); |
| 54 //////////////////////////////////////////////////////////////////////////////// |
| 55 |
| 56 /** |
| 57 * Acts as a POD containing information needed to run a benchmark. |
| 58 * Provides static methods to poll benchmark info from an index. |
| 59 */ |
| 60 struct BenchmarkControl { |
| 61 SkISize fTileSize; |
| 62 BenchmarkType fType; |
| 63 BenchmarkFunction fFunction; |
32 SkString fName; | 64 SkString fName; |
33 SkScalar fRecordAverage[kBBoxTypeCount]; | 65 |
34 SkScalar fPlaybackAverage[kBBoxTypeCount]; | 66 /** |
| 67 * Will construct a BenchmarkControl instance from an index between 0 an kNu
mBenchmarks. |
| 68 */ |
| 69 static BenchmarkControl Make(size_t i) { |
| 70 SkASSERT(kNumBenchmarks > i); |
| 71 BenchmarkControl benchControl; |
| 72 benchControl.fTileSize = GetTileSize(i); |
| 73 benchControl.fType = GetBenchmarkType(i); |
| 74 benchControl.fFunction = GetBenchmarkFunc(i); |
| 75 benchControl.fName = GetBenchmarkName(i); |
| 76 return benchControl; |
| 77 } |
| 78 |
| 79 enum BaseBenchmarks { |
| 80 kNormalRecord = 0, |
| 81 kRTreeRecord, |
| 82 kNormalPlayback, |
| 83 }; |
| 84 |
| 85 static SkISize fTileSizes[kNumTileSizes]; |
| 86 |
| 87 static SkISize GetTileSize(size_t i) { |
| 88 // Two of the base benchmarks don't need a tile size. But to maintain si
mplicity |
| 89 // down the pipeline we have to let a couple of values unused. |
| 90 if (i < kNumBaseBenchmarks) { |
| 91 return SkISize::Make(256, 256); |
| 92 } |
| 93 if (i >= kNumBaseBenchmarks && i < kNumBenchmarks) { |
| 94 return fTileSizes[i - kNumBaseBenchmarks]; |
| 95 } |
| 96 SkASSERT(0); |
| 97 return SkISize::Make(0, 0); |
| 98 } |
| 99 |
| 100 static BenchmarkType GetBenchmarkType(size_t i) { |
| 101 if (i < kNumBaseBenchmarks) { |
| 102 switch (i) { |
| 103 case kNormalRecord: |
| 104 return kNormal_BenchmarkType; |
| 105 case kNormalPlayback: |
| 106 return kNormal_BenchmarkType; |
| 107 case kRTreeRecord: |
| 108 return kRTree_BenchmarkType; |
| 109 } |
| 110 } |
| 111 if (i < kNumBenchmarks) { |
| 112 return kRTree_BenchmarkType; |
| 113 } |
| 114 SkASSERT(0); |
| 115 return kRTree_BenchmarkType; |
| 116 } |
| 117 |
| 118 static BenchmarkFunction GetBenchmarkFunc(size_t i) { |
| 119 // Base functions. |
| 120 switch (i) { |
| 121 case kNormalRecord: |
| 122 return benchmark_recording; |
| 123 case kNormalPlayback: |
| 124 return benchmark_playback; |
| 125 case kRTreeRecord: |
| 126 return benchmark_recording; |
| 127 } |
| 128 // RTree playbacks |
| 129 if (i < kNumBenchmarks) { |
| 130 return benchmark_playback; |
| 131 } |
| 132 SkASSERT(0); |
| 133 return NULL; |
| 134 } |
| 135 |
| 136 static SkString GetBenchmarkName(size_t i) { |
| 137 // Base benchmark names |
| 138 switch (i) { |
| 139 case kNormalRecord: |
| 140 return SkString("normal_recording"); |
| 141 case kNormalPlayback: |
| 142 return SkString("normal_playback"); |
| 143 case kRTreeRecord: |
| 144 return SkString("rtree_recording"); |
| 145 } |
| 146 // RTree benchmark names. |
| 147 if (i < kNumBenchmarks) { |
| 148 SkASSERT(i >= kNumBaseBenchmarks); |
| 149 SkString name; |
| 150 name.printf("rtree_playback_%dx%d", |
| 151 fTileSizes[i - kNumBaseBenchmarks].fWidth, |
| 152 fTileSizes[i - kNumBaseBenchmarks].fHeight); |
| 153 return name; |
| 154 |
| 155 } else { |
| 156 SkASSERT(0); |
| 157 } |
| 158 return SkString(""); |
| 159 } |
| 160 |
35 }; | 161 }; |
36 | 162 |
37 const char* kBBoxHierarchyTypeNames[kBBoxTypeCount] = { | 163 SkISize BenchmarkControl::fTileSizes[kNumTileSizes] = { |
38 "none", // kNone_BBoxHierarchyType | 164 SkISize::Make(256, 256), |
39 "quadtree", // kQuadTree_BBoxHierarchyType | 165 SkISize::Make(512, 512), |
40 "rtree", // kRTree_BBoxHierarchyType | 166 SkISize::Make(1024, 1024), |
41 "tilegrid", // kTileGrid_BBoxHierarchyType | |
42 }; | 167 }; |
43 | 168 |
44 static SkPicture* pic_from_path(const char path[]) { | 169 static SkPicture* pic_from_path(const char path[]) { |
45 SkFILEStream stream(path); | 170 SkFILEStream stream(path); |
46 if (!stream.isValid()) { | 171 if (!stream.isValid()) { |
47 SkDebugf("-- Can't open '%s'\n", path); | 172 SkDebugf("-- Can't open '%s'\n", path); |
48 return NULL; | 173 return NULL; |
49 } | 174 } |
50 return SkPicture::CreateFromStream(&stream, &sk_tools::LazyDecodeBitmap); | 175 return SkPicture::CreateFromStream(&stream, &sk_tools::LazyDecodeBitmap); |
51 } | 176 } |
52 | 177 |
53 /** | 178 /** |
| 179 * Returns true when a tiled renderer with no bounding box hierarchy produces th
e given bitmap. |
| 180 */ |
| 181 static bool compare_picture(const SkString& path, const SkBitmap& inBitmap, SkPi
cture* pic) { |
| 182 SkBitmap* bitmap; |
| 183 sk_tools::TiledPictureRenderer renderer; |
| 184 renderer.setBBoxHierarchyType(sk_tools::PictureRenderer::kNone_BBoxHierarchy
Type); |
| 185 renderer.init(pic); |
| 186 renderer.setup(); |
| 187 renderer.render(&path, &bitmap); |
| 188 SkAutoTDelete<SkBitmap> bmDeleter(bitmap); |
| 189 renderer.end(); |
| 190 |
| 191 if (bitmap->getSize() != inBitmap.getSize()) { |
| 192 return false; |
| 193 } |
| 194 return !memcmp(bitmap->getPixels(), inBitmap.getPixels(), bitmap->getSize())
; |
| 195 } |
| 196 |
| 197 /** |
54 * This function is the sink to which all work ends up going. | 198 * This function is the sink to which all work ends up going. |
55 * @param renderer The renderer to use to perform the work. | 199 * Renders the picture into the renderer. It may or may not use an RTree. |
56 * To measure rendering, use a TiledPictureRenderer. | 200 * The renderer is chosen upstream. If we want to measure recording, we will |
57 * To measure recording, use a RecordPictureRenderer. | 201 * use a RecordPictureRenderer. If we want to measure rendering, we will use a |
58 * @param bBoxType The bounding box hierarchy type to use. | 202 * TiledPictureRenderer. |
59 * @param pic The picture to draw to the renderer. | |
60 * @param numRepeats The number of times to repeat the draw. | |
61 * @param timer The timer used to benchmark the work. | |
62 */ | 203 */ |
63 static void do_benchmark_work(sk_tools::PictureRenderer* renderer, | 204 static void do_benchmark_work(sk_tools::PictureRenderer* renderer, |
64 BBoxType bBoxType, | 205 int benchmarkType, const SkString& path, SkPicture* pic, |
65 SkPicture* pic, | 206 const int numRepeats, const char *msg, BenchTimer* timer) { |
66 const int numRepeats, | 207 SkString msgPrefix; |
67 BenchTimer* timer) { | 208 |
68 renderer->setBBoxHierarchyType(bBoxType); | 209 switch (benchmarkType){ |
69 renderer->setGridSize(FLAGS_tilesize, FLAGS_tilesize); | 210 case kNormal_BenchmarkType: |
| 211 msgPrefix.set("Normal"); |
| 212 renderer->setBBoxHierarchyType(sk_tools::PictureRenderer::kNone_BBox
HierarchyType); |
| 213 break; |
| 214 case kRTree_BenchmarkType: |
| 215 msgPrefix.set("RTree"); |
| 216 renderer->setBBoxHierarchyType(sk_tools::PictureRenderer::kRTree_BBo
xHierarchyType); |
| 217 break; |
| 218 default: |
| 219 SkASSERT(0); |
| 220 break; |
| 221 } |
| 222 |
70 renderer->init(pic); | 223 renderer->init(pic); |
71 | 224 |
72 SkDebugf("%s %d times...\n", renderer->getConfigName().c_str(), numRepeats); | 225 /** |
| 226 * If the renderer is not tiled, assume we are measuring recording. |
| 227 */ |
| 228 bool isPlayback = (NULL != renderer->getTiledRenderer()); |
| 229 // Will be non-null during RTree picture playback. For correctness test. |
| 230 SkBitmap* bitmap = NULL; |
| 231 |
| 232 SkDebugf("%s %s %s %d times...\n", msgPrefix.c_str(), msg, path.c_str(), num
Repeats); |
73 for (int i = 0; i < numRepeats; ++i) { | 233 for (int i = 0; i < numRepeats; ++i) { |
| 234 // Set up the bitmap. |
| 235 SkBitmap** out = NULL; |
| 236 if (i == 0 && kRTree_BenchmarkType == benchmarkType && isPlayback) { |
| 237 out = &bitmap; |
| 238 } |
| 239 |
74 renderer->setup(); | 240 renderer->setup(); |
75 // Render once to fill caches | 241 // Render once to fill caches. Fill bitmap during the first iteration. |
76 renderer->render(NULL, NULL); | 242 renderer->render(NULL, out); |
77 // Render again to measure | 243 // Render again to measure |
78 timer->start(); | 244 timer->start(); |
79 renderer->render(NULL); | 245 bool result = renderer->render(NULL); |
80 timer->end(); | 246 timer->end(); |
| 247 |
| 248 // We only care about a false result on playback. RecordPictureRenderer:
:render will always |
| 249 // return false because we are passing a NULL file name on purpose; whic
h is fine. |
| 250 if (isPlayback && !result) { |
| 251 SkDebugf("Error rendering during playback.\n"); |
| 252 } |
| 253 } |
| 254 if (bitmap) { |
| 255 SkAutoTDelete<SkBitmap> bmDeleter(bitmap); |
| 256 if (!compare_picture(path, *bitmap, pic)) { |
| 257 SkDebugf("Error: RTree produced different bitmap\n"); |
| 258 } |
| 259 } |
| 260 } |
| 261 |
| 262 /** |
| 263 * Call do_benchmark_work with a tiled renderer using the default tile dimension
s. |
| 264 */ |
| 265 static void benchmark_playback( |
| 266 const BenchmarkControl& benchControl, |
| 267 const SkString& path, SkPicture* pic, BenchTimer* timer) { |
| 268 sk_tools::TiledPictureRenderer renderer; |
| 269 |
| 270 SkString message("tiled_playback"); |
| 271 message.appendf("_%dx%d", benchControl.fTileSize.fWidth, benchControl.fTileS
ize.fHeight); |
| 272 do_benchmark_work(&renderer, benchControl.fType, |
| 273 path, pic, kNumPlaybacks, message.c_str(), timer); |
| 274 } |
| 275 |
| 276 /** |
| 277 * Call do_benchmark_work with a RecordPictureRenderer. |
| 278 */ |
| 279 static void benchmark_recording( |
| 280 const BenchmarkControl& benchControl, |
| 281 const SkString& path, SkPicture* pic, BenchTimer* timer) { |
| 282 sk_tools::RecordPictureRenderer renderer; |
| 283 int numRecordings = 0; |
| 284 switch(benchControl.fType) { |
| 285 case kRTree_BenchmarkType: |
| 286 numRecordings = kNumRTreeRecordings; |
| 287 break; |
| 288 case kNormal_BenchmarkType: |
| 289 numRecordings = kNumNormalRecordings; |
| 290 break; |
| 291 } |
| 292 do_benchmark_work(&renderer, benchControl.fType, |
| 293 path, pic, numRecordings, "recording", timer); |
| 294 } |
| 295 |
| 296 /** |
| 297 * Takes argc,argv along with one of the benchmark functions defined above. |
| 298 * Will loop along all skp files and perform measurments. |
| 299 */ |
| 300 static void benchmark_loop( |
| 301 int argc, |
| 302 char **argv, |
| 303 const BenchmarkControl& benchControl, |
| 304 SkTArray<Histogram>& histogram) { |
| 305 for (int index = 1; index < argc; ++index) { |
| 306 BenchTimer timer; |
| 307 SkString path(argv[index]); |
| 308 SkAutoTUnref<SkPicture> pic(pic_from_path(path.c_str())); |
| 309 if (NULL == pic) { |
| 310 SkDebugf("Couldn't create picture. Ignoring path: %s\n", path.c_str(
)); |
| 311 continue; |
| 312 } |
| 313 benchControl.fFunction(benchControl, path, pic, &timer); |
| 314 histogram[index - 1].fPath = path; |
| 315 histogram[index - 1].fCpuTime = SkDoubleToScalar(timer.fCpu); |
81 } | 316 } |
82 } | 317 } |
83 | 318 |
84 int tool_main(int argc, char** argv); | 319 int tool_main(int argc, char** argv); |
85 int tool_main(int argc, char** argv) { | 320 int tool_main(int argc, char** argv) { |
86 SkCommandLineFlags::Parse(argc, argv); | |
87 SkAutoGraphics ag; | 321 SkAutoGraphics ag; |
88 bool includeBBoxType[kBBoxTypeCount]; | 322 SkString usage; |
89 for (int bBoxType = 0; bBoxType < kBBoxTypeCount; ++bBoxType) { | 323 usage.printf("Usage: filename [filename]*\n"); |
90 includeBBoxType[bBoxType] = (FLAGS_bbh.count() == 0) || | 324 |
91 FLAGS_bbh.contains(kBBoxHierarchyTypeNames[bBoxType]); | 325 if (argc < 2) { |
92 } | 326 SkDebugf("%s\n", usage.c_str()); |
93 // go through all the pictures | 327 return -1; |
94 SkTArray<Measurement> measurements; | |
95 for (int index = 0; index < FLAGS_skps.count(); ++index) { | |
96 const char* path = FLAGS_skps[index]; | |
97 SkPicture* picture = pic_from_path(path); | |
98 if (NULL == picture) { | |
99 SkDebugf("Couldn't create picture. Ignoring path: %s\n", path); | |
100 continue; | |
101 } | |
102 SkDebugf("Benchmarking path: %s\n", path); | |
103 Measurement& measurement = measurements.push_back(); | |
104 measurement.fName = path; | |
105 for (int bBoxType = 0; bBoxType < kBBoxTypeCount; ++bBoxType) { | |
106 if (!includeBBoxType[bBoxType]) { continue; } | |
107 if (FLAGS_playback > 0) { | |
108 sk_tools::TiledPictureRenderer playbackRenderer; | |
109 BenchTimer playbackTimer; | |
110 do_benchmark_work(&playbackRenderer, (BBoxType)bBoxType, | |
111 picture, FLAGS_playback, &playbackTimer); | |
112 measurement.fPlaybackAverage[bBoxType] = playbackTimer.fCpu; | |
113 } | |
114 if (FLAGS_record > 0) { | |
115 sk_tools::RecordPictureRenderer recordRenderer; | |
116 BenchTimer recordTimer; | |
117 do_benchmark_work(&recordRenderer, (BBoxType)bBoxType, | |
118 picture, FLAGS_record, &recordTimer); | |
119 measurement.fRecordAverage[bBoxType] = recordTimer.fCpu; | |
120 } | |
121 } | |
122 } | 328 } |
123 | 329 |
124 Measurement globalMeasurement; | 330 SkTArray<Histogram> histograms[kNumBenchmarks]; |
125 for (int bBoxType = 0; bBoxType < kBBoxTypeCount; ++bBoxType) { | 331 |
126 if (!includeBBoxType[bBoxType]) { continue; } | 332 for (size_t i = 0; i < kNumBenchmarks; ++i) { |
127 globalMeasurement.fPlaybackAverage[bBoxType] = 0; | 333 histograms[i].reset(argc - 1); |
128 globalMeasurement.fRecordAverage[bBoxType] = 0; | 334 benchmark_loop(argc, argv, BenchmarkControl::Make(i), histograms[i]); |
129 for (int index = 0; index < measurements.count(); ++index) { | |
130 const Measurement& measurement = measurements[index]; | |
131 globalMeasurement.fPlaybackAverage[bBoxType] += | |
132 measurement.fPlaybackAverage[bBoxType]; | |
133 globalMeasurement.fRecordAverage[bBoxType] += | |
134 measurement.fRecordAverage[bBoxType]; | |
135 } | |
136 globalMeasurement.fPlaybackAverage[bBoxType] /= measurements.count(); | |
137 globalMeasurement.fRecordAverage[bBoxType] /= measurements.count(); | |
138 } | 335 } |
139 | 336 |
140 // Output gnuplot readable histogram data.. | 337 // Output gnuplot readable histogram data.. |
141 const char* pbTitle = "bbh_shootout_playback.dat"; | 338 const char* pbTitle = "bbh_shootout_playback.dat"; |
142 const char* recTitle = "bbh_shootout_record.dat"; | 339 const char* recTitle = "bbh_shootout_record.dat"; |
143 SkFILEWStream playbackOut(pbTitle); | 340 SkFILEWStream playbackOut(pbTitle); |
144 SkFILEWStream recordOut(recTitle); | 341 SkFILEWStream recordOut(recTitle); |
145 recordOut.writeText("# "); | 342 recordOut.writeText("# "); |
146 playbackOut.writeText("# "); | 343 playbackOut.writeText("# "); |
147 SkDebugf("---\n"); | 344 for (size_t i = 0; i < kNumBenchmarks; ++i) { |
148 for (int bBoxType = 0; bBoxType < kBBoxTypeCount; ++bBoxType) { | |
149 if (!includeBBoxType[bBoxType]) { continue; } | |
150 SkString out; | 345 SkString out; |
151 out.printf("%s ", kBBoxHierarchyTypeNames[bBoxType]); | 346 out.printf("%s ", BenchmarkControl::GetBenchmarkName(i).c_str()); |
152 recordOut.writeText(out.c_str()); | 347 if (BenchmarkControl::GetBenchmarkFunc(i) == &benchmark_recording) { |
153 playbackOut.writeText(out.c_str()); | 348 recordOut.writeText(out.c_str()); |
154 | |
155 if (FLAGS_record > 0) { | |
156 SkDebugf("Average %s recording time: %.3fms\n", | |
157 kBBoxHierarchyTypeNames[bBoxType], | |
158 globalMeasurement.fRecordAverage[bBoxType]); | |
159 } | 349 } |
160 if (FLAGS_playback > 0) { | 350 if (BenchmarkControl::GetBenchmarkFunc(i) == &benchmark_playback) { |
161 SkDebugf("Average %s playback time: %.3fms\n", | 351 playbackOut.writeText(out.c_str()); |
162 kBBoxHierarchyTypeNames[bBoxType], | |
163 globalMeasurement.fPlaybackAverage[bBoxType]); | |
164 } | 352 } |
165 } | 353 } |
166 recordOut.writeText("\n"); | 354 recordOut.writeText("\n"); |
167 playbackOut.writeText("\n"); | 355 playbackOut.writeText("\n"); |
168 // Write to file, and save recording averages. | 356 // Write to file, and save recording averages. |
169 for (int index = 0; index < measurements.count(); ++index) { | 357 SkScalar avgRecord = SkIntToScalar(0); |
170 const Measurement& measurement = measurements[index]; | 358 SkScalar avgPlayback = SkIntToScalar(0); |
| 359 SkScalar avgRecordRTree = SkIntToScalar(0); |
| 360 SkScalar avgPlaybackRTree = SkIntToScalar(0); |
| 361 for (int i = 0; i < argc - 1; ++i) { |
171 SkString pbLine; | 362 SkString pbLine; |
172 SkString recLine; | 363 SkString recLine; |
| 364 // ==== Write record info |
| 365 recLine.printf("%d ", i); |
| 366 SkScalar cpuTime = histograms[BenchmarkControl::kNormalRecord][i].fCpuTi
me; |
| 367 recLine.appendf("%f ", cpuTime); |
| 368 avgRecord += cpuTime; |
| 369 cpuTime = histograms[BenchmarkControl::kRTreeRecord][i].fCpuTime; |
| 370 recLine.appendf("%f", cpuTime); |
| 371 avgRecordRTree += cpuTime; |
| 372 avgPlaybackRTree += cpuTime; |
173 | 373 |
174 pbLine.printf("%d", index); | 374 // ==== Write playback info |
175 recLine.printf("%d", index); | 375 pbLine.printf("%d ", i); |
176 for (int bBoxType = 0; bBoxType < kBBoxTypeCount; ++bBoxType) { | 376 pbLine.appendf("%f ", histograms[2][i].fCpuTime); // Start with normal
playback time. |
177 if (!includeBBoxType[bBoxType]) { continue; } | 377 avgPlayback += histograms[kNumBbhPlaybackBenchmarks - 1][i].fCpuTime; |
178 pbLine.appendf(" %f", measurement.fPlaybackAverage[bBoxType]); | 378 avgPlaybackRTree += histograms[kNumBbhPlaybackBenchmarks][i].fCpuTime; |
179 recLine.appendf(" %f", measurement.fRecordAverage[bBoxType]); | 379 // Append all playback benchmark times. |
| 380 for (size_t j = kNumBbhPlaybackBenchmarks; j < kNumBenchmarks; ++j) { |
| 381 pbLine.appendf("%f ", histograms[j][i].fCpuTime); |
180 } | 382 } |
| 383 pbLine.remove(pbLine.size() - 1, 1); // Remove trailing space from line
. |
181 pbLine.appendf("\n"); | 384 pbLine.appendf("\n"); |
182 recLine.appendf("\n"); | 385 recLine.appendf("\n"); |
183 playbackOut.writeText(pbLine.c_str()); | 386 playbackOut.writeText(pbLine.c_str()); |
184 recordOut.writeText(recLine.c_str()); | 387 recordOut.writeText(recLine.c_str()); |
185 } | 388 } |
| 389 avgRecord /= argc - 1; |
| 390 avgRecordRTree /= argc - 1; |
| 391 avgPlayback /= argc - 1; |
| 392 avgPlaybackRTree /= argc - 1; |
| 393 SkDebugf("Average base recording time: %.3fms\n", avgRecord); |
| 394 SkDebugf("Average recording time with rtree: %.3fms\n", avgRecordRTree); |
| 395 SkDebugf("Average base playback time: %.3fms\n", avgPlayback); |
| 396 SkDebugf("Average playback time with rtree: %.3fms\n", avgPlaybackRTree); |
| 397 |
186 SkDebugf("\nWrote data to gnuplot-readable files: %s %s\n", pbTitle, recTitl
e); | 398 SkDebugf("\nWrote data to gnuplot-readable files: %s %s\n", pbTitle, recTitl
e); |
| 399 |
187 return 0; | 400 return 0; |
188 } | 401 } |
189 | 402 |
190 #if !defined(SK_BUILD_FOR_IOS) && !defined(SK_BUILD_FOR_NACL) | 403 #if !defined(SK_BUILD_FOR_IOS) && !defined(SK_BUILD_FOR_NACL) |
191 int main(int argc, char** argv) { | 404 int main(int argc, char** argv) { |
192 return tool_main(argc, argv); | 405 return tool_main(argc, argv); |
193 } | 406 } |
194 #endif | 407 #endif |
OLD | NEW |