1 /*
2 * Copyright (C) 2017 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 "ProfileData.h"
18
19 #include <cinttypes>
20
21 namespace android {
22 namespace uirenderer {
23
24 static const char* JANK_TYPE_NAMES[] = {
25 "Missed Vsync", "High input latency", "Slow UI thread",
26 "Slow bitmap uploads", "Slow issue draw commands", "Frame deadline missed"};
27
28 // The bucketing algorithm controls so to speak
29 // If a frame is <= to this it goes in bucket 0
30 static const uint32_t kBucketMinThreshold = 5;
31 // If a frame is > this, start counting in increments of 2ms
32 static const uint32_t kBucket2msIntervals = 32;
33 // If a frame is > this, start counting in increments of 4ms
34 static const uint32_t kBucket4msIntervals = 48;
35
36 // The interval of the slow frame histogram
37 static const uint32_t kSlowFrameBucketIntervalMs = 50;
38 // The start point of the slow frame bucket in ms
39 static const uint32_t kSlowFrameBucketStartMs = 150;
40
41 // This will be called every frame, performance sensitive
42 // Uses bit twiddling to avoid branching while achieving the packing desired
frameCountIndexForFrameTime(nsecs_t frameTime)43 static uint32_t frameCountIndexForFrameTime(nsecs_t frameTime) {
44 uint32_t index = static_cast<uint32_t>(ns2ms(frameTime));
45 // If index > kBucketMinThreshold mask will be 0xFFFFFFFF as a result
46 // of negating 1 (twos compliment, yaay) else mask will be 0
47 uint32_t mask = -(index > kBucketMinThreshold);
48 // If index > threshold, this will essentially perform:
49 // amountAboveThreshold = index - threshold;
50 // index = threshold + (amountAboveThreshold / 2)
51 // However if index is <= this will do nothing. It will underflow, do
52 // a right shift by 0 (no-op), then overflow back to the original value
53 index = ((index - kBucket4msIntervals) >> (index > kBucket4msIntervals)) + kBucket4msIntervals;
54 index = ((index - kBucket2msIntervals) >> (index > kBucket2msIntervals)) + kBucket2msIntervals;
55 // If index was < minThreshold at the start of all this it's going to
56 // be a pretty garbage value right now. However, mask is 0 so we'll end
57 // up with the desired result of 0.
58 index = (index - kBucketMinThreshold) & mask;
59 return index;
60 }
61
62 // Only called when dumping stats, less performance sensitive
frameTimeForFrameCountIndex(uint32_t index)63 uint32_t ProfileData::frameTimeForFrameCountIndex(uint32_t index) {
64 index = index + kBucketMinThreshold;
65 if (index > kBucket2msIntervals) {
66 index += (index - kBucket2msIntervals);
67 }
68 if (index > kBucket4msIntervals) {
69 // This works because it was already doubled by the above if
70 // 1 is added to shift slightly more towards the middle of the bucket
71 index += (index - kBucket4msIntervals) + 1;
72 }
73 return index;
74 }
75
frameTimeForSlowFrameCountIndex(uint32_t index)76 uint32_t ProfileData::frameTimeForSlowFrameCountIndex(uint32_t index) {
77 return (index * kSlowFrameBucketIntervalMs) + kSlowFrameBucketStartMs;
78 }
79
mergeWith(const ProfileData & other)80 void ProfileData::mergeWith(const ProfileData& other) {
81 // Make sure we don't overflow Just In Case
82 uint32_t divider = 0;
83 if (mTotalFrameCount > (1 << 24)) {
84 divider = 4;
85 }
86 for (size_t i = 0; i < other.mJankTypeCounts.size(); i++) {
87 mJankTypeCounts[i] >>= divider;
88 mJankTypeCounts[i] += other.mJankTypeCounts[i];
89 }
90 for (size_t i = 0; i < other.mFrameCounts.size(); i++) {
91 mFrameCounts[i] >>= divider;
92 mFrameCounts[i] += other.mFrameCounts[i];
93 }
94 mJankFrameCount >>= divider;
95 mJankFrameCount += other.mJankFrameCount;
96 mTotalFrameCount >>= divider;
97 mTotalFrameCount += other.mTotalFrameCount;
98 if (mStatStartTime > other.mStatStartTime || mStatStartTime == 0) {
99 mStatStartTime = other.mStatStartTime;
100 }
101 }
102
dump(int fd) const103 void ProfileData::dump(int fd) const {
104 dprintf(fd, "\nStats since: %" PRIu64 "ns", mStatStartTime);
105 dprintf(fd, "\nTotal frames rendered: %u", mTotalFrameCount);
106 dprintf(fd, "\nJanky frames: %u (%.2f%%)", mJankFrameCount,
107 mTotalFrameCount == 0 ? 0.0f
108 : (float)mJankFrameCount / (float)mTotalFrameCount * 100.0f);
109 dprintf(fd, "\n50th percentile: %ums", findPercentile(50));
110 dprintf(fd, "\n90th percentile: %ums", findPercentile(90));
111 dprintf(fd, "\n95th percentile: %ums", findPercentile(95));
112 dprintf(fd, "\n99th percentile: %ums", findPercentile(99));
113 for (int i = 0; i < NUM_BUCKETS; i++) {
114 dprintf(fd, "\nNumber %s: %u", JANK_TYPE_NAMES[i], mJankTypeCounts[i]);
115 }
116 dprintf(fd, "\nHISTOGRAM:");
117 histogramForEach([fd](HistogramEntry entry) {
118 dprintf(fd, " %ums=%u", entry.renderTimeMs, entry.frameCount);
119 });
120 }
121
findPercentile(int percentile) const122 uint32_t ProfileData::findPercentile(int percentile) const {
123 int pos = percentile * mTotalFrameCount / 100;
124 int remaining = mTotalFrameCount - pos;
125 for (int i = mSlowFrameCounts.size() - 1; i >= 0; i--) {
126 remaining -= mSlowFrameCounts[i];
127 if (remaining <= 0) {
128 return (i * kSlowFrameBucketIntervalMs) + kSlowFrameBucketStartMs;
129 }
130 }
131 for (int i = mFrameCounts.size() - 1; i >= 0; i--) {
132 remaining -= mFrameCounts[i];
133 if (remaining <= 0) {
134 return frameTimeForFrameCountIndex(i);
135 }
136 }
137 return 0;
138 }
139
reset()140 void ProfileData::reset() {
141 mJankTypeCounts.fill(0);
142 mFrameCounts.fill(0);
143 mSlowFrameCounts.fill(0);
144 mTotalFrameCount = 0;
145 mJankFrameCount = 0;
146 mStatStartTime = systemTime(CLOCK_MONOTONIC);
147 }
148
reportFrame(int64_t duration)149 void ProfileData::reportFrame(int64_t duration) {
150 mTotalFrameCount++;
151 uint32_t framebucket = frameCountIndexForFrameTime(duration);
152 if (framebucket <= mFrameCounts.size()) {
153 mFrameCounts[framebucket]++;
154 } else {
155 framebucket = (ns2ms(duration) - kSlowFrameBucketStartMs) / kSlowFrameBucketIntervalMs;
156 framebucket = std::min(framebucket, static_cast<uint32_t>(mSlowFrameCounts.size() - 1));
157 mSlowFrameCounts[framebucket]++;
158 }
159 }
160
histogramForEach(const std::function<void (HistogramEntry)> & callback) const161 void ProfileData::histogramForEach(const std::function<void(HistogramEntry)>& callback) const {
162 for (size_t i = 0; i < mFrameCounts.size(); i++) {
163 callback(HistogramEntry{frameTimeForFrameCountIndex(i), mFrameCounts[i]});
164 }
165 for (size_t i = 0; i < mSlowFrameCounts.size(); i++) {
166 callback(HistogramEntry{frameTimeForSlowFrameCountIndex(i), mSlowFrameCounts[i]});
167 }
168 }
169
170 } /* namespace uirenderer */
171 } /* namespace android */