Home | History | Annotate | Download | only in hwui 
      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
     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
     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 
     76 uint32_t ProfileData::frameTimeForSlowFrameCountIndex(uint32_t index) {
     77     return (index * kSlowFrameBucketIntervalMs) + kSlowFrameBucketStartMs;
     78 }
     79 
     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 
    103 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 
    122 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 
    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 
    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 
    161 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 */