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
30using namespace android;
31using namespace android::uirenderer;
32using namespace android::uirenderer::renderthread;
33using namespace android::uirenderer::test;
34
35class ContextFactory : public IContextFactory {
36public:
37    virtual AnimationContext* createAnimationContext(renderthread::TimeLord& clock) override {
38        return new AnimationContext(clock);
39    }
40};
41
42template<class T>
43class ModifiedMovingAverage {
44public:
45    explicit ModifiedMovingAverage(int weight) : mWeight(weight) {}
46
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
56    T average() {
57        return mAverage;
58    }
59
60private:
61    bool mHasValue = false;
62    int mWeight;
63    T mAverage;
64};
65
66void 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
113void 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