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 #ifndef FRAMEINFO_H_
17 #define FRAMEINFO_H_
18 
19 #include "utils/Macros.h"
20 
21 #include <cutils/compiler.h>
22 #include <utils/Timers.h>
23 
24 #include <memory.h>
25 #include <string>
26 
27 namespace android {
28 namespace uirenderer {
29 
30 #define UI_THREAD_FRAME_INFO_SIZE 9
31 
32 enum class FrameInfoIndex {
33     Flags = 0,
34     IntendedVsync,
35     Vsync,
36     OldestInputEvent,
37     NewestInputEvent,
38     HandleInputStart,
39     AnimationStart,
40     PerformTraversalsStart,
41     DrawStart,
42     // End of UI frame info
43 
44     SyncQueued,
45 
46     SyncStart,
47     IssueDrawCommandsStart,
48     SwapBuffers,
49     FrameCompleted,
50 
51     // Must be the last value!
52     NumIndexes
53 };
54 
55 extern const std::string FrameInfoNames[];
56 
57 namespace FrameInfoFlags {
58     enum {
59         WindowLayoutChanged = 1 << 0,
60         RTAnimation = 1 << 1,
61         SurfaceCanvas = 1 << 2,
62         SkippedFrame = 1 << 3,
63     };
64 };
65 
66 class ANDROID_API UiFrameInfoBuilder {
67 public:
UiFrameInfoBuilder(int64_t * buffer)68     UiFrameInfoBuilder(int64_t* buffer) : mBuffer(buffer) {
69         memset(mBuffer, 0, UI_THREAD_FRAME_INFO_SIZE * sizeof(int64_t));
70     }
71 
setVsync(nsecs_t vsyncTime,nsecs_t intendedVsync)72     UiFrameInfoBuilder& setVsync(nsecs_t vsyncTime, nsecs_t intendedVsync) {
73         set(FrameInfoIndex::Vsync) = vsyncTime;
74         set(FrameInfoIndex::IntendedVsync) = intendedVsync;
75         // Pretend the other fields are all at vsync, too, so that naive
76         // duration calculations end up being 0 instead of very large
77         set(FrameInfoIndex::HandleInputStart) = vsyncTime;
78         set(FrameInfoIndex::AnimationStart) = vsyncTime;
79         set(FrameInfoIndex::PerformTraversalsStart) = vsyncTime;
80         set(FrameInfoIndex::DrawStart) = vsyncTime;
81         return *this;
82     }
83 
addFlag(int frameInfoFlag)84     UiFrameInfoBuilder& addFlag(int frameInfoFlag) {
85         set(FrameInfoIndex::Flags) |= static_cast<uint64_t>(frameInfoFlag);
86         return *this;
87     }
88 
89 private:
set(FrameInfoIndex index)90     inline int64_t& set(FrameInfoIndex index) {
91         return mBuffer[static_cast<int>(index)];
92     }
93 
94     int64_t* mBuffer;
95 };
96 
97 class FrameInfo {
98 public:
99     void importUiThreadInfo(int64_t* info);
100 
markSyncStart()101     void markSyncStart() {
102         set(FrameInfoIndex::SyncStart) = systemTime(CLOCK_MONOTONIC);
103     }
104 
markIssueDrawCommandsStart()105     void markIssueDrawCommandsStart() {
106         set(FrameInfoIndex::IssueDrawCommandsStart) = systemTime(CLOCK_MONOTONIC);
107     }
108 
markSwapBuffers()109     void markSwapBuffers() {
110         set(FrameInfoIndex::SwapBuffers) = systemTime(CLOCK_MONOTONIC);
111     }
112 
markFrameCompleted()113     void markFrameCompleted() {
114         set(FrameInfoIndex::FrameCompleted) = systemTime(CLOCK_MONOTONIC);
115     }
116 
addFlag(int frameInfoFlag)117     void addFlag(int frameInfoFlag) {
118         set(FrameInfoIndex::Flags) |= static_cast<uint64_t>(frameInfoFlag);
119     }
120 
data()121     const int64_t* data() const {
122         return mFrameInfo;
123     }
124 
125     inline int64_t operator[](FrameInfoIndex index) const {
126         return get(index);
127     }
128 
129     inline int64_t operator[](int index) const {
130         if (index < 0 || index >= static_cast<int>(FrameInfoIndex::NumIndexes)) return 0;
131         return mFrameInfo[index];
132     }
133 
duration(FrameInfoIndex start,FrameInfoIndex end)134     inline int64_t duration(FrameInfoIndex start, FrameInfoIndex end) const {
135         int64_t endtime = get(end);
136         int64_t starttime = get(start);
137         int64_t gap = endtime - starttime;
138         gap = starttime > 0 ? gap : 0;
139         if (end > FrameInfoIndex::SyncQueued &&
140                 start < FrameInfoIndex::SyncQueued) {
141             // Need to subtract out the time spent in a stalled state
142             // as this will be captured by the previous frame's info
143             int64_t offset = get(FrameInfoIndex::SyncStart)
144                     - get(FrameInfoIndex::SyncQueued);
145             if (offset > 0) {
146                 gap -= offset;
147             }
148         }
149         return gap > 0 ? gap : 0;
150     }
151 
totalDuration()152     inline int64_t totalDuration() const {
153         return duration(FrameInfoIndex::IntendedVsync, FrameInfoIndex::FrameCompleted);
154     }
155 
set(FrameInfoIndex index)156     inline int64_t& set(FrameInfoIndex index) {
157         return mFrameInfo[static_cast<int>(index)];
158     }
159 
get(FrameInfoIndex index)160     inline int64_t get(FrameInfoIndex index) const {
161         if (index == FrameInfoIndex::NumIndexes) return 0;
162         return mFrameInfo[static_cast<int>(index)];
163     }
164 
165 private:
166     int64_t mFrameInfo[static_cast<int>(FrameInfoIndex::NumIndexes)];
167 };
168 
169 } /* namespace uirenderer */
170 } /* namespace android */
171 
172 #endif /* FRAMEINFO_H_ */
173