1 /*
2 * Copyright (C) 2015 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include "AnimationContext.h"
18 #include "RenderNode.h"
19 #include "renderthread/RenderProxy.h"
20 #include "renderthread/RenderTask.h"
21 #include "tests/common/TestContext.h"
22 #include "tests/common/TestScene.h"
23 #include "tests/common/scenes/TestSceneBase.h"
24 #include "utils/TraceUtils.h"
25
26 #include <benchmark/benchmark.h>
27 #include <gui/Surface.h>
28 #include <log/log.h>
29 #include <ui/PixelFormat.h>
30
31 using namespace android;
32 using namespace android::uirenderer;
33 using namespace android::uirenderer::renderthread;
34 using namespace android::uirenderer::test;
35
36 class ContextFactory : public IContextFactory {
37 public:
createAnimationContext(renderthread::TimeLord & clock)38 virtual AnimationContext* createAnimationContext(renderthread::TimeLord& clock) override {
39 return new AnimationContext(clock);
40 }
41 };
42
43 template <class T>
44 class ModifiedMovingAverage {
45 public:
ModifiedMovingAverage(int weight)46 explicit ModifiedMovingAverage(int weight) : mWeight(weight) {}
47
add(T today)48 T add(T today) {
49 if (!mHasValue) {
50 mAverage = today;
51 } else {
52 mAverage = (((mWeight - 1) * mAverage) + today) / mWeight;
53 }
54 return mAverage;
55 }
56
average()57 T average() { return mAverage; }
58
59 private:
60 bool mHasValue = false;
61 int mWeight;
62 T mAverage;
63 };
64
outputBenchmarkReport(const TestScene::Info & info,const TestScene::Options & opts,benchmark::BenchmarkReporter * reporter,RenderProxy * proxy,double durationInS)65 void outputBenchmarkReport(const TestScene::Info& info, const TestScene::Options& opts,
66 benchmark::BenchmarkReporter* reporter, RenderProxy* proxy,
67 double durationInS) {
68 using namespace benchmark;
69
70 struct ReportInfo {
71 int percentile;
72 const char* suffix;
73 };
74
75 static std::array<ReportInfo, 4> REPORTS = {
76 ReportInfo{50, "_50th"}, ReportInfo{90, "_90th"}, ReportInfo{95, "_95th"},
77 ReportInfo{99, "_99th"},
78 };
79
80 // Although a vector is used, it must stay with only a single element
81 // otherwise the BenchmarkReporter will automatically compute
82 // mean and stddev which doesn't make sense for our usage
83 std::vector<BenchmarkReporter::Run> reports;
84 BenchmarkReporter::Run report;
85 report.run_name.function_name = info.name;
86 report.iterations = static_cast<int64_t>(opts.count);
87 report.real_accumulated_time = durationInS;
88 report.cpu_accumulated_time = durationInS;
89 report.counters["items_per_second"] = opts.count / durationInS;
90 reports.push_back(report);
91 reporter->ReportRuns(reports);
92
93 // Pretend the percentiles are single-iteration runs of the test
94 // If rendering offscreen skip this as it's fps that's more interesting
95 // in that test case than percentiles.
96 if (!opts.renderOffscreen) {
97 for (auto& ri : REPORTS) {
98 reports[0].run_name.function_name = info.name;
99 reports[0].run_name.function_name += ri.suffix;
100 durationInS = proxy->frameTimePercentile(ri.percentile) / 1000.0;
101 reports[0].real_accumulated_time = durationInS;
102 reports[0].cpu_accumulated_time = durationInS;
103 reports[0].iterations = 1;
104 reports[0].counters["items_per_second"] = 0;
105 reporter->ReportRuns(reports);
106 }
107 }
108 }
109
run(const TestScene::Info & info,const TestScene::Options & opts,benchmark::BenchmarkReporter * reporter)110 void run(const TestScene::Info& info, const TestScene::Options& opts,
111 benchmark::BenchmarkReporter* reporter) {
112 Properties::forceDrawFrame = true;
113 TestContext testContext;
114 testContext.setRenderOffscreen(opts.renderOffscreen);
115
116 // create the native surface
117 const ui::Size& resolution = getActiveDisplayResolution();
118 const int width = resolution.getWidth();
119 const int height = resolution.getHeight();
120 sp<Surface> surface = testContext.surface();
121
122 std::unique_ptr<TestScene> scene(info.createScene(opts));
123 scene->renderTarget = surface;
124
125 sp<RenderNode> rootNode = TestUtils::createNode(
126 0, 0, width, height, [&scene, width, height](RenderProperties& props, Canvas& canvas) {
127 props.setClipToBounds(false);
128 scene->createContent(width, height, canvas);
129 });
130
131 ContextFactory factory;
132 std::unique_ptr<RenderProxy> proxy(new RenderProxy(false, rootNode.get(), &factory));
133 proxy->loadSystemProperties();
134 proxy->setSurface(surface.get());
135 float lightX = width / 2.0;
136 proxy->setLightAlpha(255 * 0.075, 255 * 0.15);
137 proxy->setLightGeometry((Vector3){lightX, dp(-200.0f), dp(800.0f)}, dp(800.0f));
138
139 // Do a few cold runs then reset the stats so that the caches are all hot
140 int warmupFrameCount = 5;
141 if (opts.renderOffscreen) {
142 // Do a few more warmups to try and boost the clocks up
143 warmupFrameCount = 10;
144 }
145 for (int i = 0; i < warmupFrameCount; i++) {
146 testContext.waitForVsync();
147 nsecs_t vsync = systemTime(SYSTEM_TIME_MONOTONIC);
148 UiFrameInfoBuilder(proxy->frameInfo()).setVsync(vsync, vsync);
149 proxy->syncAndDrawFrame();
150 }
151
152 proxy->resetProfileInfo();
153 proxy->fence();
154
155 if (opts.renderAhead) {
156 usleep(33000);
157 }
158 proxy->setRenderAheadDepth(opts.renderAhead);
159
160 ModifiedMovingAverage<double> avgMs(opts.reportFrametimeWeight);
161
162 nsecs_t start = systemTime(SYSTEM_TIME_MONOTONIC);
163 for (int i = 0; i < opts.count; i++) {
164 testContext.waitForVsync();
165 nsecs_t vsync = systemTime(SYSTEM_TIME_MONOTONIC);
166 {
167 ATRACE_NAME("UI-Draw Frame");
168 UiFrameInfoBuilder(proxy->frameInfo()).setVsync(vsync, vsync);
169 scene->doFrame(i);
170 proxy->syncAndDrawFrame();
171 }
172 if (opts.reportFrametimeWeight) {
173 proxy->fence();
174 nsecs_t done = systemTime(SYSTEM_TIME_MONOTONIC);
175 avgMs.add((done - vsync) / 1000000.0);
176 if (i % 10 == 9) {
177 printf("Average frametime %.3fms\n", avgMs.average());
178 }
179 }
180 }
181 proxy->fence();
182 nsecs_t end = systemTime(SYSTEM_TIME_MONOTONIC);
183
184 if (reporter) {
185 outputBenchmarkReport(info, opts, reporter, proxy.get(), (end - start) / (double)s2ns(1));
186 } else {
187 proxy->dumpProfileInfo(STDOUT_FILENO, DumpFlags::JankStats);
188 }
189 }
190