1 /*
2 * Copyright 2012 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 "SkBenchLogger.h"
9 #include "BenchTimer.h"
10 #include "PictureBenchmark.h"
11 #include "SkCanvas.h"
12 #include "SkPicture.h"
13 #include "SkString.h"
14 #include "picture_utils.h"
15
16 namespace sk_tools {
17
PictureBenchmark()18 PictureBenchmark::PictureBenchmark()
19 : fRepeats(1)
20 , fLogger(NULL)
21 , fRenderer(NULL)
22 , fTimerResult(TimerData::kAvg_Result)
23 , fTimerTypes(0)
24 , fTimeIndividualTiles(false)
25 {}
26
~PictureBenchmark()27 PictureBenchmark::~PictureBenchmark() {
28 SkSafeUnref(fRenderer);
29 }
30
setTimersToShow(bool wall,bool truncatedWall,bool cpu,bool truncatedCpu,bool gpu)31 void PictureBenchmark::setTimersToShow(bool wall,
32 bool truncatedWall,
33 bool cpu,
34 bool truncatedCpu,
35 bool gpu) {
36 fTimerTypes = 0;
37 fTimerTypes |= wall ? TimerData::kWall_Flag : 0;
38 fTimerTypes |= truncatedWall ? TimerData::kTruncatedWall_Flag : 0;
39 fTimerTypes |= cpu ? TimerData::kCpu_Flag : 0;
40 fTimerTypes |= truncatedCpu ? TimerData::kTruncatedCpu_Flag : 0;
41 fTimerTypes |= gpu ? TimerData::kGpu_Flag : 0;
42 }
43
setupTimer(bool useGLTimer)44 BenchTimer* PictureBenchmark::setupTimer(bool useGLTimer) {
45 #if SK_SUPPORT_GPU
46 if (useGLTimer && fRenderer != NULL && fRenderer->isUsingGpuDevice()) {
47 return SkNEW_ARGS(BenchTimer, (fRenderer->getGLContext()));
48 }
49 #endif
50 return SkNEW_ARGS(BenchTimer, (NULL));
51 }
52
logProgress(const char msg[])53 void PictureBenchmark::logProgress(const char msg[]) {
54 if (fLogger != NULL) {
55 fLogger->logProgress(msg);
56 }
57 }
58
setRenderer(sk_tools::PictureRenderer * renderer)59 PictureRenderer* PictureBenchmark::setRenderer(sk_tools::PictureRenderer* renderer) {
60 SkRefCnt_SafeAssign(fRenderer, renderer);
61 return renderer;
62 }
63
run(SkPicture * pict)64 void PictureBenchmark::run(SkPicture* pict) {
65 SkASSERT(pict);
66 if (NULL == pict) {
67 return;
68 }
69
70 SkASSERT(fRenderer != NULL);
71 if (NULL == fRenderer) {
72 return;
73 }
74
75 fRenderer->init(pict);
76
77 // We throw this away to remove first time effects (such as paging in this program)
78 fRenderer->setup();
79 fRenderer->render(NULL);
80 fRenderer->resetState(true);
81
82 bool usingGpu = false;
83 #if SK_SUPPORT_GPU
84 usingGpu = fRenderer->isUsingGpuDevice();
85 #endif
86
87 uint32_t timerTypes = fTimerTypes;
88 if (!usingGpu) {
89 timerTypes &= ~TimerData::kGpu_Flag;
90 }
91
92 SkString timeFormat;
93 if (TimerData::kPerIter_Result == fTimerResult) {
94 timeFormat = fRenderer->getPerIterTimeFormat();
95 } else {
96 timeFormat = fRenderer->getNormalTimeFormat();
97 }
98
99 if (fTimeIndividualTiles) {
100 TiledPictureRenderer* tiledRenderer = fRenderer->getTiledRenderer();
101 SkASSERT(tiledRenderer && tiledRenderer->supportsTimingIndividualTiles());
102 if (NULL == tiledRenderer || !tiledRenderer->supportsTimingIndividualTiles()) {
103 return;
104 }
105 int xTiles, yTiles;
106 if (!tiledRenderer->tileDimensions(xTiles, yTiles)) {
107 return;
108 }
109
110 // Insert a newline so that each tile is reported on its own line (separate from the line
111 // that describes the skp being run).
112 this->logProgress("\n");
113
114 int x, y;
115 while (tiledRenderer->nextTile(x, y)) {
116 // There are two timers, which will behave slightly differently:
117 // 1) longRunningTimer, along with perTileTimerData, will time how long it takes to draw
118 // one tile fRepeats times, and take the average. As such, it will not respect thea
119 // logPerIter or printMin options, since it does not know the time per iteration. It
120 // will also be unable to call flush() for each tile.
121 // The goal of this timer is to make up for a system timer that is not precise enough to
122 // measure the small amount of time it takes to draw one tile once.
123 //
124 // 2) perTileTimer, along with perTileTimerData, will record each run separately, and
125 // then take the average. As such, it supports logPerIter and printMin options.
126 //
127 // Although "legal", having two gpu timers running at the same time
128 // seems to cause problems (i.e., INVALID_OPERATIONs) on several
129 // platforms. To work around this, we disable the gpu timer on the
130 // long running timer.
131 SkAutoTDelete<BenchTimer> longRunningTimer(this->setupTimer());
132 TimerData longRunningTimerData(1);
133 SkAutoTDelete<BenchTimer> perTileTimer(this->setupTimer(false));
134 TimerData perTileTimerData(fRepeats);
135 longRunningTimer->start();
136 for (int i = 0; i < fRepeats; ++i) {
137 perTileTimer->start();
138 tiledRenderer->drawCurrentTile();
139 perTileTimer->truncatedEnd();
140 tiledRenderer->resetState(false);
141 perTileTimer->end();
142 SkAssertResult(perTileTimerData.appendTimes(perTileTimer.get()));
143 }
144 longRunningTimer->truncatedEnd();
145 tiledRenderer->resetState(true);
146 longRunningTimer->end();
147 SkAssertResult(longRunningTimerData.appendTimes(longRunningTimer.get()));
148
149 SkString configName = tiledRenderer->getConfigName();
150 configName.appendf(": tile [%i,%i] out of [%i,%i]", x, y, xTiles, yTiles);
151
152 SkString result = perTileTimerData.getResult(timeFormat.c_str(), fTimerResult,
153 configName.c_str(), timerTypes);
154 result.append("\n");
155
156 // TODO(borenet): Turn off per-iteration tile time reporting for now. Avoiding logging the time
157 // for every iteration for each tile cuts down on data file size by a significant amount. Re-enable
158 // this once we're loading the bench data directly into a data store and are no longer generating
159 // SVG graphs.
160 #if 0
161 this->logProgress(result.c_str());
162 #endif
163
164 configName.append(" <averaged>");
165 SkString longRunningResult = longRunningTimerData.getResult(
166 tiledRenderer->getNormalTimeFormat().c_str(),
167 TimerData::kAvg_Result,
168 configName.c_str(), timerTypes, fRepeats);
169 longRunningResult.append("\n");
170 this->logProgress(longRunningResult.c_str());
171 }
172 } else {
173 SkAutoTDelete<BenchTimer> timer(this->setupTimer());
174 TimerData timerData(fRepeats);
175 for (int i = 0; i < fRepeats; ++i) {
176 fRenderer->setup();
177
178 timer->start();
179 fRenderer->render(NULL);
180 timer->truncatedEnd();
181
182 // Finishes gl context
183 fRenderer->resetState(true);
184 timer->end();
185
186 SkAssertResult(timerData.appendTimes(timer.get()));
187 }
188
189 SkString configName = fRenderer->getConfigName();
190
191 SkString result = timerData.getResult(timeFormat.c_str(),
192 fTimerResult,
193 configName.c_str(),
194 timerTypes);
195 result.append("\n");
196 this->logProgress(result.c_str());
197 }
198
199 fRenderer->end();
200 }
201
202 }
203