blob: e61567ecae782274068606be94e53d0353fc3955 [file] [log] [blame]
Adithya Srinivasanf279e042020-08-17 14:56:27 -07001/*
2 * Copyright 2020 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#pragma once
18
Alec Mouri9a29e672020-09-14 12:39:14 -070019#include <../TimeStats/TimeStats.h>
Ady Abraham22c7b5c2020-09-22 19:33:40 -070020#include <gui/ISurfaceComposer.h>
Adithya Srinivasanf279e042020-08-17 14:56:27 -070021#include <ui/FenceTime.h>
22#include <utils/RefBase.h>
Adithya Srinivasan8fc601d2020-09-25 13:51:09 -070023#include <utils/String16.h>
Adithya Srinivasanf279e042020-08-17 14:56:27 -070024#include <utils/Timers.h>
Adithya Srinivasan8fc601d2020-09-25 13:51:09 -070025#include <utils/Vector.h>
Adithya Srinivasanf279e042020-08-17 14:56:27 -070026
Alec Mouri9a29e672020-09-14 12:39:14 -070027#include <deque>
28#include <mutex>
Adithya Srinivasanf279e042020-08-17 14:56:27 -070029
Alec Mouri9a29e672020-09-14 12:39:14 -070030namespace android::frametimeline {
Adithya Srinivasan8fc601d2020-09-25 13:51:09 -070031
32enum JankMetadata {
33 // Frame was presented earlier than expected
34 EarlyPresent = 0x1,
35 // Frame was presented later than expected
36 LatePresent = 0x2,
37 // App/SF started earlier than expected
38 EarlyStart = 0x4,
39 // App/SF started later than expected
40 LateStart = 0x8,
41 // App/SF finished work earlier than the deadline
42 EarlyFinish = 0x10,
43 // App/SF finished work later than the deadline
44 LateFinish = 0x20,
45 // SF was in GPU composition
46 GpuComposition = 0x40,
47};
48
Adithya Srinivasanf279e042020-08-17 14:56:27 -070049class FrameTimelineTest;
50
51/*
52 * Collection of timestamps that can be used for both predictions and actual times.
53 */
54struct TimelineItem {
55 TimelineItem(const nsecs_t startTime = 0, const nsecs_t endTime = 0,
56 const nsecs_t presentTime = 0)
57 : startTime(startTime), endTime(endTime), presentTime(presentTime) {}
58
59 nsecs_t startTime;
60 nsecs_t endTime;
61 nsecs_t presentTime;
Ady Abraham55fa7272020-09-30 19:19:27 -070062
63 bool operator==(const TimelineItem& other) const {
64 return startTime == other.startTime && endTime == other.endTime &&
65 presentTime == other.presentTime;
66 }
67
68 bool operator!=(const TimelineItem& other) const { return !(*this == other); }
Adithya Srinivasanf279e042020-08-17 14:56:27 -070069};
70
71/*
72 * TokenManager generates a running number token for a set of predictions made by VsyncPredictor. It
73 * saves these predictions for a short period of time and returns the predictions for a given token,
74 * if it hasn't expired.
75 */
76class TokenManager {
77public:
78 virtual ~TokenManager() = default;
79
80 // Generates a token for the given set of predictions. Stores the predictions for 120ms and
81 // destroys it later.
Adithya Srinivasan5f683cf2020-09-15 14:21:04 -070082 virtual int64_t generateTokenForPredictions(TimelineItem&& prediction) = 0;
Adithya Srinivasanf279e042020-08-17 14:56:27 -070083};
84
85enum class PredictionState {
86 Valid, // Predictions obtained successfully from the TokenManager
87 Expired, // TokenManager no longer has the predictions
88 None, // Predictions are either not present or didn't come from TokenManager
89};
90
91/*
92 * Stores a set of predictions and the corresponding actual timestamps pertaining to a single frame
93 * from the app
94 */
95class SurfaceFrame {
96public:
97 enum class PresentState {
98 Presented, // Buffer was latched and presented by SurfaceFlinger
99 Dropped, // Buffer was dropped by SurfaceFlinger
100 Unknown, // Initial state, SurfaceFlinger hasn't seen this buffer yet
101 };
102
103 virtual ~SurfaceFrame() = default;
104
Adithya Srinivasan8fc601d2020-09-25 13:51:09 -0700105 virtual TimelineItem getPredictions() const = 0;
106 virtual TimelineItem getActuals() const = 0;
107 virtual nsecs_t getActualQueueTime() const = 0;
108 virtual PresentState getPresentState() const = 0;
109 virtual PredictionState getPredictionState() const = 0;
Adithya Srinivasan9febda82020-10-19 10:49:41 -0700110 virtual pid_t getOwnerPid() const = 0;
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700111
112 virtual void setPresentState(PresentState state) = 0;
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700113
Adithya Srinivasan5f683cf2020-09-15 14:21:04 -0700114 // Actual timestamps of the app are set individually at different functions.
115 // Start time (if the app provides) and Queue time are accessible after queueing the frame,
Ady Abraham7f8a1e62020-09-28 16:09:35 -0700116 // whereas Acquire Fence time is available only during latch.
Adithya Srinivasan5f683cf2020-09-15 14:21:04 -0700117 virtual void setActualStartTime(nsecs_t actualStartTime) = 0;
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700118 virtual void setActualQueueTime(nsecs_t actualQueueTime) = 0;
Ady Abraham7f8a1e62020-09-28 16:09:35 -0700119 virtual void setAcquireFenceTime(nsecs_t acquireFenceTime) = 0;
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700120};
121
122/*
123 * Maintains a history of SurfaceFrames grouped together by the vsync time in which they were
124 * presented
125 */
126class FrameTimeline {
127public:
128 virtual ~FrameTimeline() = default;
Adithya Srinivasan5f683cf2020-09-15 14:21:04 -0700129 virtual TokenManager* getTokenManager() = 0;
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700130
131 // Create a new surface frame, set the predictions based on a token and return it to the caller.
132 // Sets the PredictionState of SurfaceFrame.
Alec Mouri9a29e672020-09-14 12:39:14 -0700133 // Debug name is the human-readable debugging string for dumpsys.
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700134 virtual std::unique_ptr<SurfaceFrame> createSurfaceFrameForToken(
Adithya Srinivasan9febda82020-10-19 10:49:41 -0700135 pid_t ownerPid, uid_t ownerUid, std::string layerName, std::string debugName,
Alec Mouri9a29e672020-09-14 12:39:14 -0700136 std::optional<int64_t> token) = 0;
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700137
138 // Adds a new SurfaceFrame to the current DisplayFrame. Frames from multiple layers can be
139 // composited into one display frame.
140 virtual void addSurfaceFrame(std::unique_ptr<SurfaceFrame> surfaceFrame,
141 SurfaceFrame::PresentState state) = 0;
142
143 // The first function called by SF for the current DisplayFrame. Fetches SF predictions based on
144 // the token and sets the actualSfWakeTime for the current DisplayFrame.
145 virtual void setSfWakeUp(int64_t token, nsecs_t wakeupTime) = 0;
146
147 // Sets the sfPresentTime and finalizes the current DisplayFrame. Tracks the given present fence
148 // until it's signaled, and updates the present timestamps of all presented SurfaceFrames in
149 // that vsync.
150 virtual void setSfPresent(nsecs_t sfPresentTime,
151 const std::shared_ptr<FenceTime>& presentFence) = 0;
Adithya Srinivasan5f683cf2020-09-15 14:21:04 -0700152
Adithya Srinivasan8fc601d2020-09-25 13:51:09 -0700153 // Args:
154 // -jank : Dumps only the Display Frames that are either janky themselves
155 // or contain janky Surface Frames.
156 // -all : Dumps the entire list of DisplayFrames and the SurfaceFrames contained within
157 virtual void parseArgs(const Vector<String16>& args, std::string& result) = 0;
Adithya Srinivasan2d736322020-10-01 16:53:48 -0700158
159 // Sets the max number of display frames that can be stored. Called by SF backdoor.
160 virtual void setMaxDisplayFrames(uint32_t size);
161
162 // Restores the max number of display frames to default. Called by SF backdoor.
163 virtual void reset() = 0;
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700164};
165
166namespace impl {
167
168using namespace std::chrono_literals;
169
170class TokenManager : public android::frametimeline::TokenManager {
171public:
Ady Abraham22c7b5c2020-09-22 19:33:40 -0700172 TokenManager() : mCurrentToken(ISurfaceComposer::INVALID_VSYNC_ID + 1) {}
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700173 ~TokenManager() = default;
174
175 int64_t generateTokenForPredictions(TimelineItem&& predictions) override;
176 std::optional<TimelineItem> getPredictionsForToken(int64_t token);
177
178private:
179 // Friend class for testing
180 friend class android::frametimeline::FrameTimelineTest;
181
182 void flushTokens(nsecs_t flushTime) REQUIRES(mMutex);
183
184 std::unordered_map<int64_t, TimelineItem> mPredictions GUARDED_BY(mMutex);
185 std::vector<std::pair<int64_t, nsecs_t>> mTokens GUARDED_BY(mMutex);
186 int64_t mCurrentToken GUARDED_BY(mMutex);
187 std::mutex mMutex;
188 static constexpr nsecs_t kMaxRetentionTime =
189 std::chrono::duration_cast<std::chrono::nanoseconds>(120ms).count();
190};
191
192class SurfaceFrame : public android::frametimeline::SurfaceFrame {
193public:
Adithya Srinivasan9febda82020-10-19 10:49:41 -0700194 SurfaceFrame(pid_t ownerPid, uid_t ownerUid, std::string layerName, std::string debugName,
Alec Mouri9a29e672020-09-14 12:39:14 -0700195 PredictionState predictionState, TimelineItem&& predictions);
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700196 ~SurfaceFrame() = default;
197
Adithya Srinivasan8fc601d2020-09-25 13:51:09 -0700198 TimelineItem getPredictions() const override { return mPredictions; };
199 TimelineItem getActuals() const override;
200 nsecs_t getActualQueueTime() const override;
201 PresentState getPresentState() const override;
202 PredictionState getPredictionState() const override { return mPredictionState; };
Adithya Srinivasan9febda82020-10-19 10:49:41 -0700203 pid_t getOwnerPid() const override { return mOwnerPid; };
204 TimeStats::JankType getJankType() const;
205 nsecs_t getBaseTime() const;
206 uid_t getOwnerUid() const { return mOwnerUid; };
207 const std::string& getName() const { return mLayerName; };
Adithya Srinivasan5f683cf2020-09-15 14:21:04 -0700208
209 void setActualStartTime(nsecs_t actualStartTime) override;
210 void setActualQueueTime(nsecs_t actualQueueTime) override;
Ady Abraham7f8a1e62020-09-28 16:09:35 -0700211 void setAcquireFenceTime(nsecs_t acquireFenceTime) override;
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700212 void setPresentState(PresentState state) override;
Adithya Srinivasan5f683cf2020-09-15 14:21:04 -0700213 void setActualPresentTime(nsecs_t presentTime);
Alec Mouri9a29e672020-09-14 12:39:14 -0700214 void setJankInfo(TimeStats::JankType jankType, int32_t jankMetadata);
Adithya Srinivasan9febda82020-10-19 10:49:41 -0700215
Adithya Srinivasan8fc601d2020-09-25 13:51:09 -0700216 // All the timestamps are dumped relative to the baseTime
217 void dump(std::string& result, const std::string& indent, nsecs_t baseTime);
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700218
219private:
Adithya Srinivasan9febda82020-10-19 10:49:41 -0700220 const pid_t mOwnerPid;
Alec Mouri9a29e672020-09-14 12:39:14 -0700221 const uid_t mOwnerUid;
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700222 const std::string mLayerName;
Alec Mouri9a29e672020-09-14 12:39:14 -0700223 const std::string mDebugName;
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700224 PresentState mPresentState GUARDED_BY(mMutex);
Adithya Srinivasan8fc601d2020-09-25 13:51:09 -0700225 const PredictionState mPredictionState;
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700226 const TimelineItem mPredictions;
227 TimelineItem mActuals GUARDED_BY(mMutex);
Adithya Srinivasan8fc601d2020-09-25 13:51:09 -0700228 nsecs_t mActualQueueTime GUARDED_BY(mMutex);
229 mutable std::mutex mMutex;
Alec Mouri9a29e672020-09-14 12:39:14 -0700230 TimeStats::JankType mJankType GUARDED_BY(mMutex); // Enum for the type of jank
Adithya Srinivasan8fc601d2020-09-25 13:51:09 -0700231 int32_t mJankMetadata GUARDED_BY(mMutex); // Additional details about the jank
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700232};
233
234class FrameTimeline : public android::frametimeline::FrameTimeline {
235public:
Alec Mouri9a29e672020-09-14 12:39:14 -0700236 FrameTimeline(std::shared_ptr<TimeStats> timeStats);
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700237 ~FrameTimeline() = default;
238
Adithya Srinivasan5f683cf2020-09-15 14:21:04 -0700239 frametimeline::TokenManager* getTokenManager() override { return &mTokenManager; }
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700240 std::unique_ptr<frametimeline::SurfaceFrame> createSurfaceFrameForToken(
Adithya Srinivasan9febda82020-10-19 10:49:41 -0700241 pid_t ownerPid, uid_t ownerUid, std::string layerName, std::string debugName,
Alec Mouri9a29e672020-09-14 12:39:14 -0700242 std::optional<int64_t> token) override;
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700243 void addSurfaceFrame(std::unique_ptr<frametimeline::SurfaceFrame> surfaceFrame,
244 SurfaceFrame::PresentState state) override;
245 void setSfWakeUp(int64_t token, nsecs_t wakeupTime) override;
246 void setSfPresent(nsecs_t sfPresentTime,
247 const std::shared_ptr<FenceTime>& presentFence) override;
Adithya Srinivasan8fc601d2020-09-25 13:51:09 -0700248 void parseArgs(const Vector<String16>& args, std::string& result) override;
Adithya Srinivasan2d736322020-10-01 16:53:48 -0700249 void setMaxDisplayFrames(uint32_t size) override;
250 void reset() override;
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700251
252private:
253 // Friend class for testing
254 friend class android::frametimeline::FrameTimelineTest;
255
256 /*
257 * DisplayFrame should be used only internally within FrameTimeline.
258 */
259 struct DisplayFrame {
260 DisplayFrame();
261
262 /* Usage of TimelineItem w.r.t SurfaceFlinger
263 * startTime Time when SurfaceFlinger wakes up to handle transactions and buffer updates
264 * endTime Time when SurfaceFlinger sends a composited frame to Display
265 * presentTime Time when the composited frame was presented on screen
266 */
267 TimelineItem surfaceFlingerPredictions;
268 TimelineItem surfaceFlingerActuals;
269
270 // Collection of predictions and actual values sent over by Layers
271 std::vector<std::unique_ptr<SurfaceFrame>> surfaceFrames;
272
273 PredictionState predictionState;
Alec Mouri9a29e672020-09-14 12:39:14 -0700274 TimeStats::JankType jankType = TimeStats::JankType::None; // Enum for the type of jank
Adithya Srinivasan8fc601d2020-09-25 13:51:09 -0700275 int32_t jankMetadata = 0x0; // Additional details about the jank
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700276 };
277
278 void flushPendingPresentFences() REQUIRES(mMutex);
279 void finalizeCurrentDisplayFrame() REQUIRES(mMutex);
Adithya Srinivasan8fc601d2020-09-25 13:51:09 -0700280 // BaseTime is the smallest timestamp in a DisplayFrame.
281 // Used for dumping all timestamps relative to the oldest, making it easy to read.
282 nsecs_t findBaseTime(const std::shared_ptr<DisplayFrame>&) REQUIRES(mMutex);
283 void dumpDisplayFrame(std::string& result, const std::shared_ptr<DisplayFrame>&,
284 nsecs_t baseTime) REQUIRES(mMutex);
285 void dumpAll(std::string& result);
286 void dumpJank(std::string& result);
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700287
288 // Sliding window of display frames. TODO(b/168072834): compare perf with fixed size array
289 std::deque<std::shared_ptr<DisplayFrame>> mDisplayFrames GUARDED_BY(mMutex);
290 std::vector<std::pair<std::shared_ptr<FenceTime>, std::shared_ptr<DisplayFrame>>>
291 mPendingPresentFences GUARDED_BY(mMutex);
292 std::shared_ptr<DisplayFrame> mCurrentDisplayFrame GUARDED_BY(mMutex);
293 TokenManager mTokenManager;
294 std::mutex mMutex;
Adithya Srinivasan2d736322020-10-01 16:53:48 -0700295 uint32_t mMaxDisplayFrames;
Alec Mouri9a29e672020-09-14 12:39:14 -0700296 std::shared_ptr<TimeStats> mTimeStats;
Adithya Srinivasan2d736322020-10-01 16:53:48 -0700297 static constexpr uint32_t kDefaultMaxDisplayFrames = 64;
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700298 // The initial container size for the vector<SurfaceFrames> inside display frame. Although this
299 // number doesn't represent any bounds on the number of surface frames that can go in a display
300 // frame, this is a good starting size for the vector so that we can avoid the internal vector
301 // resizing that happens with push_back.
302 static constexpr uint32_t kNumSurfaceFramesInitial = 10;
Adithya Srinivasan8fc601d2020-09-25 13:51:09 -0700303 // The various thresholds for App and SF. If the actual timestamp falls within the threshold
304 // compared to prediction, we don't treat it as a jank.
305 static constexpr nsecs_t kPresentThreshold =
306 std::chrono::duration_cast<std::chrono::nanoseconds>(2ms).count();
307 static constexpr nsecs_t kDeadlineThreshold =
308 std::chrono::duration_cast<std::chrono::nanoseconds>(2ms).count();
309 static constexpr nsecs_t kSFStartThreshold =
310 std::chrono::duration_cast<std::chrono::nanoseconds>(1ms).count();
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700311};
312
313} // namespace impl
314} // namespace android::frametimeline