blob: b66e02afe134a094eea07780464b4112486d8a63 [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 Mouri7d436ec2021-01-27 20:40:50 -080019#include <../Fps.h>
Alec Mouri9a29e672020-09-14 12:39:14 -070020#include <../TimeStats/TimeStats.h>
Ady Abraham22c7b5c2020-09-22 19:33:40 -070021#include <gui/ISurfaceComposer.h>
Jorim Jaggi5814ab82020-12-03 20:45:58 +010022#include <gui/JankInfo.h>
Adithya Srinivasan01189672020-10-20 14:23:05 -070023#include <perfetto/trace/android/frame_timeline_event.pbzero.h>
24#include <perfetto/tracing.h>
Adithya Srinivasanf279e042020-08-17 14:56:27 -070025#include <ui/FenceTime.h>
26#include <utils/RefBase.h>
Adithya Srinivasan8fc601d2020-09-25 13:51:09 -070027#include <utils/String16.h>
Adithya Srinivasanf279e042020-08-17 14:56:27 -070028#include <utils/Timers.h>
Adithya Srinivasan8fc601d2020-09-25 13:51:09 -070029#include <utils/Vector.h>
Adithya Srinivasanf279e042020-08-17 14:56:27 -070030
Alec Mouri9a29e672020-09-14 12:39:14 -070031#include <deque>
32#include <mutex>
Adithya Srinivasanf279e042020-08-17 14:56:27 -070033
Alec Mouri9a29e672020-09-14 12:39:14 -070034namespace android::frametimeline {
Adithya Srinivasan8fc601d2020-09-25 13:51:09 -070035
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -080036class FrameTimelineTest;
37
38using namespace std::chrono_literals;
39
40// Metadata indicating how the frame was presented w.r.t expected present time.
41enum class FramePresentMetadata : int8_t {
42 // Frame was presented on time
43 OnTimePresent,
44 // Frame was presented late
45 LatePresent,
46 // Frame was presented early
47 EarlyPresent,
48 // Unknown/initial state
49 UnknownPresent,
Adithya Srinivasan8fc601d2020-09-25 13:51:09 -070050};
51
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -080052// Metadata comparing the frame's actual finish time to the expected deadline.
53enum class FrameReadyMetadata : int8_t {
54 // App/SF finished on time. Early finish is treated as on time since the goal of any component
55 // is to finish before the deadline.
56 OnTimeFinish,
57 // App/SF finished work later than expected
58 LateFinish,
59 // Unknown/initial state
60 UnknownFinish,
61};
62
63// Metadata comparing the frame's actual start time to the expected start time.
64enum class FrameStartMetadata : int8_t {
65 // App/SF started on time
66 OnTimeStart,
67 // App/SF started later than expected
68 LateStart,
69 // App/SF started earlier than expected
70 EarlyStart,
71 // Unknown/initial state
72 UnknownStart,
73};
Adithya Srinivasanf279e042020-08-17 14:56:27 -070074
75/*
76 * Collection of timestamps that can be used for both predictions and actual times.
77 */
78struct TimelineItem {
79 TimelineItem(const nsecs_t startTime = 0, const nsecs_t endTime = 0,
80 const nsecs_t presentTime = 0)
81 : startTime(startTime), endTime(endTime), presentTime(presentTime) {}
82
83 nsecs_t startTime;
84 nsecs_t endTime;
85 nsecs_t presentTime;
Ady Abraham55fa7272020-09-30 19:19:27 -070086
87 bool operator==(const TimelineItem& other) const {
88 return startTime == other.startTime && endTime == other.endTime &&
89 presentTime == other.presentTime;
90 }
91
92 bool operator!=(const TimelineItem& other) const { return !(*this == other); }
Adithya Srinivasanf279e042020-08-17 14:56:27 -070093};
94
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -080095struct TokenManagerPrediction {
96 nsecs_t timestamp = 0;
97 TimelineItem predictions;
98};
99
100struct JankClassificationThresholds {
101 // The various thresholds for App and SF. If the actual timestamp falls within the threshold
102 // compared to prediction, we treat it as on time.
103 nsecs_t presentThreshold = std::chrono::duration_cast<std::chrono::nanoseconds>(2ms).count();
104 nsecs_t deadlineThreshold = std::chrono::duration_cast<std::chrono::nanoseconds>(2ms).count();
105 nsecs_t startThreshold = std::chrono::duration_cast<std::chrono::nanoseconds>(2ms).count();
106};
107
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700108/*
109 * TokenManager generates a running number token for a set of predictions made by VsyncPredictor. It
110 * saves these predictions for a short period of time and returns the predictions for a given token,
111 * if it hasn't expired.
112 */
113class TokenManager {
114public:
115 virtual ~TokenManager() = default;
116
117 // Generates a token for the given set of predictions. Stores the predictions for 120ms and
118 // destroys it later.
Adithya Srinivasan5f683cf2020-09-15 14:21:04 -0700119 virtual int64_t generateTokenForPredictions(TimelineItem&& prediction) = 0;
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -0800120
121 // Returns the stored predictions for a given token, if the predictions haven't expired.
122 virtual std::optional<TimelineItem> getPredictionsForToken(int64_t token) const = 0;
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700123};
124
125enum class PredictionState {
126 Valid, // Predictions obtained successfully from the TokenManager
127 Expired, // TokenManager no longer has the predictions
128 None, // Predictions are either not present or didn't come from TokenManager
129};
130
Adithya Srinivasan05bd2d12021-01-11 18:49:58 +0000131/*
132 * Trace cookie is used to send start and end timestamps of <Surface/Display>Frames separately
133 * without needing to resend all the other information. We send all info to perfetto, along with a
134 * new cookie, in the start of a frame. For the corresponding end, we just send the same cookie.
135 * This helps in reducing the amount of data emitted by the producer.
136 */
137class TraceCookieCounter {
138public:
139 int64_t getCookieForTracing();
140
141private:
142 // Friend class for testing
143 friend class android::frametimeline::FrameTimelineTest;
144
145 std::atomic<int64_t> mTraceCookie = 0;
146};
147
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700148class SurfaceFrame {
149public:
150 enum class PresentState {
151 Presented, // Buffer was latched and presented by SurfaceFlinger
152 Dropped, // Buffer was dropped by SurfaceFlinger
153 Unknown, // Initial state, SurfaceFlinger hasn't seen this buffer yet
154 };
155
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -0800156 // Only FrameTimeline can construct a SurfaceFrame as it provides Predictions(through
157 // TokenManager), Thresholds and TimeStats pointer.
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -1000158 SurfaceFrame(const FrameTimelineInfo& frameTimelineInfo, pid_t ownerPid, uid_t ownerUid,
Alec Mouriadebf5c2021-01-05 12:57:36 -0800159 int32_t layerId, std::string layerName, std::string debugName,
160 PredictionState predictionState, TimelineItem&& predictions,
161 std::shared_ptr<TimeStats> timeStats, JankClassificationThresholds thresholds,
162 TraceCookieCounter* traceCookieCounter);
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -0800163 ~SurfaceFrame() = default;
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700164
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -0800165 // Returns std::nullopt if the frame hasn't been classified yet.
166 // Used by both SF and FrameTimeline.
167 std::optional<int32_t> getJankType() const;
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700168
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -0800169 // Functions called by SF
170 int64_t getToken() const { return mToken; };
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -1000171 int32_t getInputEventId() const { return mInputEventId; };
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -0800172 TimelineItem getPredictions() const { return mPredictions; };
Adithya Srinivasan5f683cf2020-09-15 14:21:04 -0700173 // Actual timestamps of the app are set individually at different functions.
174 // Start time (if the app provides) and Queue time are accessible after queueing the frame,
Adithya Srinivasan061c14c2021-02-11 01:19:47 +0000175 // whereas Acquire Fence time is available only during latch. Drop time is available at the time
176 // the buffer was dropped.
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -0800177 void setActualStartTime(nsecs_t actualStartTime);
178 void setActualQueueTime(nsecs_t actualQueueTime);
179 void setAcquireFenceTime(nsecs_t acquireFenceTime);
Adithya Srinivasan061c14c2021-02-11 01:19:47 +0000180 void setDropTime(nsecs_t dropTime);
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -0800181 void setPresentState(PresentState presentState, nsecs_t lastLatchTime = 0);
Alec Mouri7d436ec2021-01-27 20:40:50 -0800182 void setRenderRate(Fps renderRate);
Jorim Jaggi9c03b502020-11-24 23:51:31 +0100183
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -0800184 // Functions called by FrameTimeline
185 // BaseTime is the smallest timestamp in this SurfaceFrame.
186 // Used for dumping all timestamps relative to the oldest, making it easy to read.
187 nsecs_t getBaseTime() const;
188 // Sets the actual present time, appropriate metadata and classifies the jank.
Alec Mouri363faf02021-01-29 16:34:55 -0800189 // displayRefreshRate, displayDeadlineDelta, and displayPresentDelta are propagated from the
190 // display frame.
191 void onPresent(nsecs_t presentTime, int32_t displayFrameJankType, Fps refreshRate,
192 nsecs_t displayDeadlineDelta, nsecs_t displayPresentDelta);
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -0800193 // All the timestamps are dumped relative to the baseTime
194 void dump(std::string& result, const std::string& indent, nsecs_t baseTime) const;
195 // Emits a packet for perfetto tracing. The function body will be executed only if tracing is
196 // enabled. The displayFrameToken is needed to link the SurfaceFrame to the corresponding
197 // DisplayFrame at the trace processor side.
Adithya Srinivasan061c14c2021-02-11 01:19:47 +0000198 void trace(int64_t displayFrameToken) const;
Jorim Jaggi9c03b502020-11-24 23:51:31 +0100199
Adithya Srinivasan061c14c2021-02-11 01:19:47 +0000200 // Getter functions used only by FrameTimelineTests and SurfaceFrame internally
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -0800201 TimelineItem getActuals() const;
202 pid_t getOwnerPid() const { return mOwnerPid; };
Alec Mouriadebf5c2021-01-05 12:57:36 -0800203 int32_t getLayerId() const { return mLayerId; };
Adithya Srinivasan061c14c2021-02-11 01:19:47 +0000204 PredictionState getPredictionState() const;
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -0800205 PresentState getPresentState() const;
206 FrameReadyMetadata getFrameReadyMetadata() const;
207 FramePresentMetadata getFramePresentMetadata() const;
Adithya Srinivasan061c14c2021-02-11 01:19:47 +0000208 nsecs_t getDropTime() const;
209
210 // For prediction expired frames, this delta is subtracted from the actual end time to get a
211 // start time decent enough to see in traces.
212 // TODO(b/172587309): Remove this when we have actual start times.
213 static constexpr nsecs_t kPredictionExpiredStartTimeDelta =
214 std::chrono::duration_cast<std::chrono::nanoseconds>(2ms).count();
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -0800215
216private:
Adithya Srinivasan061c14c2021-02-11 01:19:47 +0000217 void tracePredictions(int64_t displayFrameToken) const;
218 void traceActuals(int64_t displayFrameToken) const;
Adithya Srinivasan7c4ac7a2021-03-08 23:48:03 +0000219 void classifyJankLocked(int32_t displayFrameJankType, const Fps& refreshRate,
220 nsecs_t& deadlineDelta) REQUIRES(mMutex);
Adithya Srinivasan061c14c2021-02-11 01:19:47 +0000221
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -0800222 const int64_t mToken;
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -1000223 const int32_t mInputEventId;
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -0800224 const pid_t mOwnerPid;
225 const uid_t mOwnerUid;
226 const std::string mLayerName;
227 const std::string mDebugName;
Alec Mouriadebf5c2021-01-05 12:57:36 -0800228 const int32_t mLayerId;
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -0800229 PresentState mPresentState GUARDED_BY(mMutex);
230 const PredictionState mPredictionState;
231 const TimelineItem mPredictions;
232 TimelineItem mActuals GUARDED_BY(mMutex);
233 std::shared_ptr<TimeStats> mTimeStats;
234 const JankClassificationThresholds mJankClassificationThresholds;
235 nsecs_t mActualQueueTime GUARDED_BY(mMutex) = 0;
Adithya Srinivasan061c14c2021-02-11 01:19:47 +0000236 nsecs_t mDropTime GUARDED_BY(mMutex) = 0;
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -0800237 mutable std::mutex mMutex;
238 // Bitmask for the type of jank
239 int32_t mJankType GUARDED_BY(mMutex) = JankType::None;
240 // Indicates if this frame was composited by the GPU or not
241 bool mGpuComposition GUARDED_BY(mMutex) = false;
Alec Mouri7d436ec2021-01-27 20:40:50 -0800242 // Rendering rate for this frame.
243 std::optional<Fps> mRenderRate GUARDED_BY(mMutex);
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -0800244 // Enum for the type of present
245 FramePresentMetadata mFramePresentMetadata GUARDED_BY(mMutex) =
246 FramePresentMetadata::UnknownPresent;
247 // Enum for the type of finish
248 FrameReadyMetadata mFrameReadyMetadata GUARDED_BY(mMutex) = FrameReadyMetadata::UnknownFinish;
249 // Time when the previous buffer from the same layer was latched by SF. This is used in checking
250 // for BufferStuffing where the current buffer is expected to be ready but the previous buffer
251 // was latched instead.
252 nsecs_t mLastLatchTime GUARDED_BY(mMutex) = 0;
Adithya Srinivasan05bd2d12021-01-11 18:49:58 +0000253 // TraceCookieCounter is used to obtain the cookie for sendig trace packets to perfetto. Using a
254 // reference here because the counter is owned by FrameTimeline, which outlives SurfaceFrame.
255 TraceCookieCounter& mTraceCookieCounter;
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700256};
257
258/*
259 * Maintains a history of SurfaceFrames grouped together by the vsync time in which they were
260 * presented
261 */
262class FrameTimeline {
263public:
264 virtual ~FrameTimeline() = default;
Adithya Srinivasan5f683cf2020-09-15 14:21:04 -0700265 virtual TokenManager* getTokenManager() = 0;
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700266
Adithya Srinivasan01189672020-10-20 14:23:05 -0700267 // Initializes the Perfetto DataSource that emits DisplayFrame and SurfaceFrame events. Test
268 // classes can avoid double registration by mocking this function.
269 virtual void onBootFinished() = 0;
270
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700271 // Create a new surface frame, set the predictions based on a token and return it to the caller.
Alec Mouri9a29e672020-09-14 12:39:14 -0700272 // Debug name is the human-readable debugging string for dumpsys.
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -1000273 virtual std::shared_ptr<SurfaceFrame> createSurfaceFrameForToken(
274 const FrameTimelineInfo& frameTimelineInfo, pid_t ownerPid, uid_t ownerUid,
Alec Mouriadebf5c2021-01-05 12:57:36 -0800275 int32_t layerId, std::string layerName, std::string debugName) = 0;
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700276
277 // Adds a new SurfaceFrame to the current DisplayFrame. Frames from multiple layers can be
278 // composited into one display frame.
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -0800279 virtual void addSurfaceFrame(std::shared_ptr<SurfaceFrame> surfaceFrame) = 0;
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700280
281 // The first function called by SF for the current DisplayFrame. Fetches SF predictions based on
282 // the token and sets the actualSfWakeTime for the current DisplayFrame.
Alec Mouri7d436ec2021-01-27 20:40:50 -0800283 virtual void setSfWakeUp(int64_t token, nsecs_t wakeupTime, Fps refreshRate) = 0;
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700284
285 // Sets the sfPresentTime and finalizes the current DisplayFrame. Tracks the given present fence
286 // until it's signaled, and updates the present timestamps of all presented SurfaceFrames in
287 // that vsync.
288 virtual void setSfPresent(nsecs_t sfPresentTime,
289 const std::shared_ptr<FenceTime>& presentFence) = 0;
Adithya Srinivasan5f683cf2020-09-15 14:21:04 -0700290
Adithya Srinivasan8fc601d2020-09-25 13:51:09 -0700291 // Args:
292 // -jank : Dumps only the Display Frames that are either janky themselves
293 // or contain janky Surface Frames.
294 // -all : Dumps the entire list of DisplayFrames and the SurfaceFrames contained within
295 virtual void parseArgs(const Vector<String16>& args, std::string& result) = 0;
Adithya Srinivasan2d736322020-10-01 16:53:48 -0700296
297 // Sets the max number of display frames that can be stored. Called by SF backdoor.
298 virtual void setMaxDisplayFrames(uint32_t size);
299
Alec Mouriadebf5c2021-01-05 12:57:36 -0800300 // Computes the historical fps for the provided set of layer IDs
301 // The fps is compted from the linear timeline of present timestamps for DisplayFrames
302 // containing at least one layer ID.
303 virtual float computeFps(const std::unordered_set<int32_t>& layerIds);
304
Adithya Srinivasan2d736322020-10-01 16:53:48 -0700305 // Restores the max number of display frames to default. Called by SF backdoor.
306 virtual void reset() = 0;
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700307};
308
309namespace impl {
310
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700311class TokenManager : public android::frametimeline::TokenManager {
312public:
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -1000313 TokenManager() : mCurrentToken(FrameTimelineInfo::INVALID_VSYNC_ID + 1) {}
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700314 ~TokenManager() = default;
315
316 int64_t generateTokenForPredictions(TimelineItem&& predictions) override;
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -0800317 std::optional<TimelineItem> getPredictionsForToken(int64_t token) const override;
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700318
319private:
320 // Friend class for testing
321 friend class android::frametimeline::FrameTimelineTest;
322
323 void flushTokens(nsecs_t flushTime) REQUIRES(mMutex);
324
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -0800325 std::map<int64_t, TokenManagerPrediction> mPredictions GUARDED_BY(mMutex);
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700326 int64_t mCurrentToken GUARDED_BY(mMutex);
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -0800327 mutable std::mutex mMutex;
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700328 static constexpr nsecs_t kMaxRetentionTime =
329 std::chrono::duration_cast<std::chrono::nanoseconds>(120ms).count();
330};
331
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700332class FrameTimeline : public android::frametimeline::FrameTimeline {
333public:
Adithya Srinivasan01189672020-10-20 14:23:05 -0700334 class FrameTimelineDataSource : public perfetto::DataSource<FrameTimelineDataSource> {
335 void OnSetup(const SetupArgs&) override{};
336 void OnStart(const StartArgs&) override{};
337 void OnStop(const StopArgs&) override{};
338 };
339
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -0800340 /*
341 * DisplayFrame should be used only internally within FrameTimeline. All members and methods are
342 * guarded by FrameTimeline's mMutex.
343 */
344 class DisplayFrame {
345 public:
Adithya Srinivasan05bd2d12021-01-11 18:49:58 +0000346 DisplayFrame(std::shared_ptr<TimeStats> timeStats, JankClassificationThresholds thresholds,
Adithya Srinivasan939cd4d2021-02-23 06:18:13 +0000347 nsecs_t hwcDuration, TraceCookieCounter* traceCookieCounter);
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -0800348 virtual ~DisplayFrame() = default;
349 // Dumpsys interface - dumps only if the DisplayFrame itself is janky or is at least one
350 // SurfaceFrame is janky.
351 void dumpJank(std::string& result, nsecs_t baseTime, int displayFrameCount) const;
352 // Dumpsys interface - dumps all data irrespective of jank
353 void dumpAll(std::string& result, nsecs_t baseTime) const;
354 // Emits a packet for perfetto tracing. The function body will be executed only if tracing
355 // is enabled.
356 void trace(pid_t surfaceFlingerPid) const;
357 // Sets the token, vsyncPeriod, predictions and SF start time.
Alec Mouri7d436ec2021-01-27 20:40:50 -0800358 void onSfWakeUp(int64_t token, Fps refreshRate, std::optional<TimelineItem> predictions,
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -0800359 nsecs_t wakeUpTime);
Adithya Srinivasan115ac692021-03-06 01:21:30 +0000360 // Sets the appropriate metadata and classifies the jank.
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -0800361 void onPresent(nsecs_t signalTime);
362 // Adds the provided SurfaceFrame to the current display frame.
363 void addSurfaceFrame(std::shared_ptr<SurfaceFrame> surfaceFrame);
364
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -0800365 void setPredictions(PredictionState predictionState, TimelineItem predictions);
366 void setActualStartTime(nsecs_t actualStartTime);
367 void setActualEndTime(nsecs_t actualEndTime);
368
369 // BaseTime is the smallest timestamp in a DisplayFrame.
370 // Used for dumping all timestamps relative to the oldest, making it easy to read.
371 nsecs_t getBaseTime() const;
372
373 // Functions to be used only in testing.
374 TimelineItem getActuals() const { return mSurfaceFlingerActuals; };
375 TimelineItem getPredictions() const { return mSurfaceFlingerPredictions; };
Adithya Srinivasan939cd4d2021-02-23 06:18:13 +0000376 FrameStartMetadata getFrameStartMetadata() const { return mFrameStartMetadata; };
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -0800377 FramePresentMetadata getFramePresentMetadata() const { return mFramePresentMetadata; };
378 FrameReadyMetadata getFrameReadyMetadata() const { return mFrameReadyMetadata; };
379 int32_t getJankType() const { return mJankType; }
380 const std::vector<std::shared_ptr<SurfaceFrame>>& getSurfaceFrames() const {
381 return mSurfaceFrames;
382 }
383
384 private:
385 void dump(std::string& result, nsecs_t baseTime) const;
Adithya Srinivasan061c14c2021-02-11 01:19:47 +0000386 void tracePredictions(pid_t surfaceFlingerPid) const;
387 void traceActuals(pid_t surfaceFlingerPid) const;
Adithya Srinivasan115ac692021-03-06 01:21:30 +0000388 void classifyJank(nsecs_t& deadlineDelta, nsecs_t& deltaToVsync);
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -0800389
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -1000390 int64_t mToken = FrameTimelineInfo::INVALID_VSYNC_ID;
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -0800391
392 /* Usage of TimelineItem w.r.t SurfaceFlinger
393 * startTime Time when SurfaceFlinger wakes up to handle transactions and buffer updates
394 * endTime Time when SurfaceFlinger sends a composited frame to Display
395 * presentTime Time when the composited frame was presented on screen
396 */
397 TimelineItem mSurfaceFlingerPredictions;
398 TimelineItem mSurfaceFlingerActuals;
399 std::shared_ptr<TimeStats> mTimeStats;
400 const JankClassificationThresholds mJankClassificationThresholds;
Adithya Srinivasan939cd4d2021-02-23 06:18:13 +0000401 const nsecs_t mHwcDuration;
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -0800402
403 // Collection of predictions and actual values sent over by Layers
404 std::vector<std::shared_ptr<SurfaceFrame>> mSurfaceFrames;
405
406 PredictionState mPredictionState = PredictionState::None;
407 // Bitmask for the type of jank
408 int32_t mJankType = JankType::None;
409 // Indicates if this frame was composited by the GPU or not
410 bool mGpuComposition = false;
411 // Enum for the type of present
412 FramePresentMetadata mFramePresentMetadata = FramePresentMetadata::UnknownPresent;
413 // Enum for the type of finish
414 FrameReadyMetadata mFrameReadyMetadata = FrameReadyMetadata::UnknownFinish;
415 // Enum for the type of start
416 FrameStartMetadata mFrameStartMetadata = FrameStartMetadata::UnknownStart;
417 // The refresh rate (vsync period) in nanoseconds as seen by SF during this DisplayFrame's
418 // timeline
Alec Mouri7d436ec2021-01-27 20:40:50 -0800419 Fps mRefreshRate;
Adithya Srinivasan05bd2d12021-01-11 18:49:58 +0000420 // TraceCookieCounter is used to obtain the cookie for sendig trace packets to perfetto.
421 // Using a reference here because the counter is owned by FrameTimeline, which outlives
422 // DisplayFrame.
423 TraceCookieCounter& mTraceCookieCounter;
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -0800424 };
425
426 FrameTimeline(std::shared_ptr<TimeStats> timeStats, pid_t surfaceFlingerPid,
Adithya Srinivasan939cd4d2021-02-23 06:18:13 +0000427 JankClassificationThresholds thresholds = {},
428 nsecs_t hwcDuration = kDefaultHwcDuration);
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700429 ~FrameTimeline() = default;
430
Adithya Srinivasan5f683cf2020-09-15 14:21:04 -0700431 frametimeline::TokenManager* getTokenManager() override { return &mTokenManager; }
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -1000432 std::shared_ptr<SurfaceFrame> createSurfaceFrameForToken(
433 const FrameTimelineInfo& frameTimelineInfo, pid_t ownerPid, uid_t ownerUid,
Alec Mouriadebf5c2021-01-05 12:57:36 -0800434 int32_t layerId, std::string layerName, std::string debugName) override;
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -0800435 void addSurfaceFrame(std::shared_ptr<frametimeline::SurfaceFrame> surfaceFrame) override;
Alec Mouri7d436ec2021-01-27 20:40:50 -0800436 void setSfWakeUp(int64_t token, nsecs_t wakeupTime, Fps refreshRate) override;
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700437 void setSfPresent(nsecs_t sfPresentTime,
438 const std::shared_ptr<FenceTime>& presentFence) override;
Adithya Srinivasan8fc601d2020-09-25 13:51:09 -0700439 void parseArgs(const Vector<String16>& args, std::string& result) override;
Adithya Srinivasan2d736322020-10-01 16:53:48 -0700440 void setMaxDisplayFrames(uint32_t size) override;
Alec Mouriadebf5c2021-01-05 12:57:36 -0800441 float computeFps(const std::unordered_set<int32_t>& layerIds) override;
Adithya Srinivasan2d736322020-10-01 16:53:48 -0700442 void reset() override;
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700443
Adithya Srinivasan01189672020-10-20 14:23:05 -0700444 // Sets up the perfetto tracing backend and data source.
445 void onBootFinished() override;
446 // Registers the data source with the perfetto backend. Called as part of onBootFinished()
447 // and should not be called manually outside of tests.
448 void registerDataSource();
449
450 static constexpr char kFrameTimelineDataSource[] = "android.surfaceflinger.frametimeline";
451
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700452private:
453 // Friend class for testing
454 friend class android::frametimeline::FrameTimelineTest;
455
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700456 void flushPendingPresentFences() REQUIRES(mMutex);
457 void finalizeCurrentDisplayFrame() REQUIRES(mMutex);
Adithya Srinivasan8fc601d2020-09-25 13:51:09 -0700458 void dumpAll(std::string& result);
459 void dumpJank(std::string& result);
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700460
461 // Sliding window of display frames. TODO(b/168072834): compare perf with fixed size array
462 std::deque<std::shared_ptr<DisplayFrame>> mDisplayFrames GUARDED_BY(mMutex);
463 std::vector<std::pair<std::shared_ptr<FenceTime>, std::shared_ptr<DisplayFrame>>>
464 mPendingPresentFences GUARDED_BY(mMutex);
465 std::shared_ptr<DisplayFrame> mCurrentDisplayFrame GUARDED_BY(mMutex);
466 TokenManager mTokenManager;
Adithya Srinivasan05bd2d12021-01-11 18:49:58 +0000467 TraceCookieCounter mTraceCookieCounter;
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -0800468 mutable std::mutex mMutex;
Adithya Srinivasan2d736322020-10-01 16:53:48 -0700469 uint32_t mMaxDisplayFrames;
Alec Mouri9a29e672020-09-14 12:39:14 -0700470 std::shared_ptr<TimeStats> mTimeStats;
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -0800471 const pid_t mSurfaceFlingerPid;
472 const JankClassificationThresholds mJankClassificationThresholds;
Adithya Srinivasan939cd4d2021-02-23 06:18:13 +0000473 // In SF Predictions, both end & present are the same. The predictions consider the time used by
474 // composer as well, but we have no way to estimate how much time the composer needs. We are
475 // assuming an arbitrary time for the composer work.
476 const nsecs_t mHwcDuration;
477 static constexpr nsecs_t kDefaultHwcDuration = std::chrono::nanoseconds(3ms).count();
Adithya Srinivasan2d736322020-10-01 16:53:48 -0700478 static constexpr uint32_t kDefaultMaxDisplayFrames = 64;
Adithya Srinivasan01189672020-10-20 14:23:05 -0700479 // The initial container size for the vector<SurfaceFrames> inside display frame. Although
480 // this number doesn't represent any bounds on the number of surface frames that can go in a
481 // display frame, this is a good starting size for the vector so that we can avoid the
482 // internal vector resizing that happens with push_back.
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700483 static constexpr uint32_t kNumSurfaceFramesInitial = 10;
Adithya Srinivasanf279e042020-08-17 14:56:27 -0700484};
485
486} // namespace impl
487} // namespace android::frametimeline