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 "tests/common/TestContext.h"
20 #include "tests/common/TestScene.h"
21 #include "tests/common/scenes/TestSceneBase.h"
22 #include "renderthread/RenderProxy.h"
23 #include "renderthread/RenderTask.h"
24
25 #include <benchmark/benchmark.h>
26 #include <gui/Surface.h>
27 #include <log/log.h>
28 #include <ui/PixelFormat.h>
29
30 using namespace android;
31 using namespace android::uirenderer;
32 using namespace android::uirenderer::renderthread;
33 using namespace android::uirenderer::test;
34
35 class ContextFactory : public IContextFactory {
36 public:
createAnimationContext(renderthread::TimeLord & clock)37 virtual AnimationContext* createAnimationContext(renderthread::TimeLord& clock) override {
38 return new AnimationContext(clock);
39 }
40 };
41
42 template<class T>
43 class ModifiedMovingAverage {
44 public:
ModifiedMovingAverage(int weight)45 explicit ModifiedMovingAverage(int weight) : mWeight(weight) {}
46
add(T today)47 T add(T today) {
48 if (!mHasValue) {
49 mAverage = today;
50 } else {
51 mAverage = (((mWeight - 1) * mAverage) + today) / mWeight;
52 }
53 return mAverage;
54 }
55
average()56 T average() {
57 return mAverage;
58 }
59
60 private:
61 bool mHasValue = false;
62 int mWeight;
63 T mAverage;
64 };
65
outputBenchmarkReport(const TestScene::Info & info,const TestScene::Options & opts,benchmark::BenchmarkReporter * reporter,RenderProxy * proxy,double durationInS)66 void outputBenchmarkReport(const TestScene::Info& info, const TestScene::Options& opts,
67 benchmark::BenchmarkReporter* reporter, RenderProxy* proxy,
68 double durationInS) {
69 using namespace benchmark;
70
71 struct ReportInfo {
72 int percentile;
73 const char* suffix;
74 };
75
76 static std::array<ReportInfo, 4> REPORTS = {
77 ReportInfo { 50, "_50th" },
78 ReportInfo { 90, "_90th" },
79 ReportInfo { 95, "_95th" },
80 ReportInfo { 99, "_99th" },
81 };
82
83 // Although a vector is used, it must stay with only a single element
84 // otherwise the BenchmarkReporter will automatically compute
85 // mean and stddev which doesn't make sense for our usage
86 std::vector<BenchmarkReporter::Run> reports;
87 BenchmarkReporter::Run report;
88 report.benchmark_name = info.name;
89 report.iterations = static_cast<int64_t>(opts.count);
90 report.real_accumulated_time = durationInS;
91 report.cpu_accumulated_time = durationInS;
92 report.items_per_second = opts.count / durationInS;
93 reports.push_back(report);
94 reporter->ReportRuns(reports);
95
96 // Pretend the percentiles are single-iteration runs of the test
97 // If rendering offscreen skip this as it's fps that's more interesting
98 // in that test case than percentiles.
99 if (!opts.renderOffscreen) {
100 for (auto& ri : REPORTS) {
101 reports[0].benchmark_name = info.name;
102 reports[0].benchmark_name += ri.suffix;
103 durationInS = proxy->frameTimePercentile(ri.percentile) / 1000.0;
104 reports[0].real_accumulated_time = durationInS;
105 reports[0].cpu_accumulated_time = durationInS;
106 reports[0].iterations = 1;
107 reports[0].items_per_second = 0;
108 reporter->ReportRuns(reports);
109 }
110 }
111 }
112
run(const TestScene::Info & info,const TestScene::Options & opts,benchmark::BenchmarkReporter * reporter)113 void run(const TestScene::Info& info, const TestScene::Options& opts,
114 benchmark::BenchmarkReporter* reporter) {
115 // Switch to the real display
116 gDisplay = getBuiltInDisplay();
117
118 std::unique_ptr<TestScene> scene(info.createScene(opts));
119
120 Properties::forceDrawFrame = true;
121 TestContext testContext;
122 testContext.setRenderOffscreen(opts.renderOffscreen);
123
124 // create the native surface
125 const int width = gDisplay.w;
126 const int height = gDisplay.h;
127 sp<Surface> surface = testContext.surface();
128
129 sp<RenderNode> rootNode = TestUtils::createNode(0, 0, width, height,
130 [&scene, width, height](RenderProperties& props, Canvas& canvas) {
131 props.setClipToBounds(false);
132 scene->createContent(width, height, canvas);
133 });
134
135 ContextFactory factory;
136 std::unique_ptr<RenderProxy> proxy(new RenderProxy(false,
137 rootNode.get(), &factory));
138 proxy->loadSystemProperties();
139 proxy->initialize(surface);
140 float lightX = width / 2.0;
141 proxy->setup(dp(800.0f), 255 * 0.075, 255 * 0.15);
142 proxy->setLightCenter((Vector3){lightX, dp(-200.0f), dp(800.0f)});
143
144 // Do a few cold runs then reset the stats so that the caches are all hot
145 int warmupFrameCount = 5;
146 if (opts.renderOffscreen) {
147 // Do a few more warmups to try and boost the clocks up
148 warmupFrameCount = 10;
149 }
150 for (int i = 0; i < warmupFrameCount; i++) {
151 testContext.waitForVsync();
152 nsecs_t vsync = systemTime(CLOCK_MONOTONIC);
153 UiFrameInfoBuilder(proxy->frameInfo()).setVsync(vsync, vsync);
154 proxy->syncAndDrawFrame();
155 }
156
157 proxy->resetProfileInfo();
158 proxy->fence();
159
160 ModifiedMovingAverage<double> avgMs(opts.reportFrametimeWeight);
161
162 nsecs_t start = systemTime(CLOCK_MONOTONIC);
163 for (int i = 0; i < opts.count; i++) {
164 testContext.waitForVsync();
165 nsecs_t vsync = systemTime(CLOCK_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(CLOCK_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(CLOCK_MONOTONIC);
183
184 if (reporter) {
185 outputBenchmarkReport(info, opts, reporter, proxy.get(),
186 (end - start) / (double) s2ns(1));
187 } else {
188 proxy->dumpProfileInfo(STDOUT_FILENO, DumpFlags::JankStats);
189 }
190 }
191