You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1123 lines
44 KiB
1123 lines
44 KiB
/*
|
|
* Copyright 2018 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#include <unordered_map>
|
|
#undef LOG_TAG
|
|
#define LOG_TAG "TimeStats"
|
|
#define ATRACE_TAG ATRACE_TAG_GRAPHICS
|
|
|
|
#include <android-base/stringprintf.h>
|
|
#include <log/log.h>
|
|
#include <timestatsatomsproto/TimeStatsAtomsProtoHeader.h>
|
|
#include <utils/String8.h>
|
|
#include <utils/Timers.h>
|
|
#include <utils/Trace.h>
|
|
|
|
#include <algorithm>
|
|
#include <chrono>
|
|
|
|
#include "TimeStats.h"
|
|
#include "timestatsproto/TimeStatsHelper.h"
|
|
|
|
namespace android {
|
|
|
|
namespace impl {
|
|
|
|
namespace {
|
|
|
|
FrameTimingHistogram histogramToProto(const std::unordered_map<int32_t, int32_t>& histogram,
|
|
size_t maxPulledHistogramBuckets) {
|
|
auto buckets = std::vector<std::pair<int32_t, int32_t>>(histogram.begin(), histogram.end());
|
|
std::sort(buckets.begin(), buckets.end(),
|
|
[](std::pair<int32_t, int32_t>& left, std::pair<int32_t, int32_t>& right) {
|
|
return left.second > right.second;
|
|
});
|
|
|
|
FrameTimingHistogram histogramProto;
|
|
int histogramSize = 0;
|
|
for (const auto& bucket : buckets) {
|
|
if (++histogramSize > maxPulledHistogramBuckets) {
|
|
break;
|
|
}
|
|
histogramProto.add_time_millis_buckets((int32_t)bucket.first);
|
|
histogramProto.add_frame_counts((int64_t)bucket.second);
|
|
}
|
|
return histogramProto;
|
|
}
|
|
|
|
SurfaceflingerStatsLayerInfo_GameMode gameModeToProto(int32_t gameMode) {
|
|
switch (gameMode) {
|
|
case TimeStatsHelper::GameModeUnsupported:
|
|
return SurfaceflingerStatsLayerInfo::GAME_MODE_UNSUPPORTED;
|
|
case TimeStatsHelper::GameModeStandard:
|
|
return SurfaceflingerStatsLayerInfo::GAME_MODE_STANDARD;
|
|
case TimeStatsHelper::GameModePerformance:
|
|
return SurfaceflingerStatsLayerInfo::GAME_MODE_PERFORMANCE;
|
|
case TimeStatsHelper::GameModeBattery:
|
|
return SurfaceflingerStatsLayerInfo::GAME_MODE_BATTERY;
|
|
default:
|
|
return SurfaceflingerStatsLayerInfo::GAME_MODE_UNSPECIFIED;
|
|
}
|
|
}
|
|
|
|
SurfaceflingerStatsLayerInfo_SetFrameRateVote frameRateVoteToProto(
|
|
const TimeStats::SetFrameRateVote& setFrameRateVote) {
|
|
using FrameRateCompatibilityEnum =
|
|
SurfaceflingerStatsLayerInfo::SetFrameRateVote::FrameRateCompatibility;
|
|
using SeamlessnessEnum = SurfaceflingerStatsLayerInfo::SetFrameRateVote::Seamlessness;
|
|
|
|
SurfaceflingerStatsLayerInfo_SetFrameRateVote proto;
|
|
proto.set_frame_rate(setFrameRateVote.frameRate);
|
|
proto.set_frame_rate_compatibility(
|
|
static_cast<FrameRateCompatibilityEnum>(setFrameRateVote.frameRateCompatibility));
|
|
proto.set_seamlessness(static_cast<SeamlessnessEnum>(setFrameRateVote.seamlessness));
|
|
return proto;
|
|
}
|
|
} // namespace
|
|
|
|
bool TimeStats::populateGlobalAtom(std::string* pulledData) {
|
|
std::lock_guard<std::mutex> lock(mMutex);
|
|
|
|
if (mTimeStats.statsStartLegacy == 0) {
|
|
return false;
|
|
}
|
|
flushPowerTimeLocked();
|
|
SurfaceflingerStatsGlobalInfoWrapper atomList;
|
|
for (const auto& globalSlice : mTimeStats.stats) {
|
|
SurfaceflingerStatsGlobalInfo* atom = atomList.add_atom();
|
|
atom->set_total_frames(mTimeStats.totalFramesLegacy);
|
|
atom->set_missed_frames(mTimeStats.missedFramesLegacy);
|
|
atom->set_client_composition_frames(mTimeStats.clientCompositionFramesLegacy);
|
|
atom->set_display_on_millis(mTimeStats.displayOnTimeLegacy);
|
|
atom->set_animation_millis(mTimeStats.presentToPresentLegacy.totalTime());
|
|
atom->set_event_connection_count(mTimeStats.displayEventConnectionsCountLegacy);
|
|
*atom->mutable_frame_duration() =
|
|
histogramToProto(mTimeStats.frameDurationLegacy.hist, mMaxPulledHistogramBuckets);
|
|
*atom->mutable_render_engine_timing() =
|
|
histogramToProto(mTimeStats.renderEngineTimingLegacy.hist,
|
|
mMaxPulledHistogramBuckets);
|
|
atom->set_total_timeline_frames(globalSlice.second.jankPayload.totalFrames);
|
|
atom->set_total_janky_frames(globalSlice.second.jankPayload.totalJankyFrames);
|
|
atom->set_total_janky_frames_with_long_cpu(globalSlice.second.jankPayload.totalSFLongCpu);
|
|
atom->set_total_janky_frames_with_long_gpu(globalSlice.second.jankPayload.totalSFLongGpu);
|
|
atom->set_total_janky_frames_sf_unattributed(
|
|
globalSlice.second.jankPayload.totalSFUnattributed);
|
|
atom->set_total_janky_frames_app_unattributed(
|
|
globalSlice.second.jankPayload.totalAppUnattributed);
|
|
atom->set_total_janky_frames_sf_scheduling(
|
|
globalSlice.second.jankPayload.totalSFScheduling);
|
|
atom->set_total_jank_frames_sf_prediction_error(
|
|
globalSlice.second.jankPayload.totalSFPredictionError);
|
|
atom->set_total_jank_frames_app_buffer_stuffing(
|
|
globalSlice.second.jankPayload.totalAppBufferStuffing);
|
|
atom->set_display_refresh_rate_bucket(globalSlice.first.displayRefreshRateBucket);
|
|
*atom->mutable_sf_deadline_misses() =
|
|
histogramToProto(globalSlice.second.displayDeadlineDeltas.hist,
|
|
mMaxPulledHistogramBuckets);
|
|
*atom->mutable_sf_prediction_errors() =
|
|
histogramToProto(globalSlice.second.displayPresentDeltas.hist,
|
|
mMaxPulledHistogramBuckets);
|
|
atom->set_render_rate_bucket(globalSlice.first.renderRateBucket);
|
|
}
|
|
|
|
// Always clear data.
|
|
clearGlobalLocked();
|
|
|
|
return atomList.SerializeToString(pulledData);
|
|
}
|
|
|
|
bool TimeStats::populateLayerAtom(std::string* pulledData) {
|
|
std::lock_guard<std::mutex> lock(mMutex);
|
|
|
|
std::vector<TimeStatsHelper::TimeStatsLayer*> dumpStats;
|
|
uint32_t numLayers = 0;
|
|
for (const auto& globalSlice : mTimeStats.stats) {
|
|
numLayers += globalSlice.second.stats.size();
|
|
}
|
|
|
|
dumpStats.reserve(numLayers);
|
|
|
|
for (auto& globalSlice : mTimeStats.stats) {
|
|
for (auto& layerSlice : globalSlice.second.stats) {
|
|
dumpStats.push_back(&layerSlice.second);
|
|
}
|
|
}
|
|
|
|
std::sort(dumpStats.begin(), dumpStats.end(),
|
|
[](TimeStatsHelper::TimeStatsLayer const* l,
|
|
TimeStatsHelper::TimeStatsLayer const* r) {
|
|
return l->totalFrames > r->totalFrames;
|
|
});
|
|
|
|
if (mMaxPulledLayers < dumpStats.size()) {
|
|
dumpStats.resize(mMaxPulledLayers);
|
|
}
|
|
|
|
SurfaceflingerStatsLayerInfoWrapper atomList;
|
|
for (auto& layer : dumpStats) {
|
|
SurfaceflingerStatsLayerInfo* atom = atomList.add_atom();
|
|
atom->set_layer_name(layer->layerName);
|
|
atom->set_total_frames(layer->totalFrames);
|
|
atom->set_dropped_frames(layer->droppedFrames);
|
|
const auto& present2PresentHist = layer->deltas.find("present2present");
|
|
if (present2PresentHist != layer->deltas.cend()) {
|
|
*atom->mutable_present_to_present() =
|
|
histogramToProto(present2PresentHist->second.hist, mMaxPulledHistogramBuckets);
|
|
}
|
|
const auto& post2presentHist = layer->deltas.find("post2present");
|
|
if (post2presentHist != layer->deltas.cend()) {
|
|
*atom->mutable_post_to_present() =
|
|
histogramToProto(post2presentHist->second.hist, mMaxPulledHistogramBuckets);
|
|
}
|
|
const auto& acquire2presentHist = layer->deltas.find("acquire2present");
|
|
if (acquire2presentHist != layer->deltas.cend()) {
|
|
*atom->mutable_acquire_to_present() =
|
|
histogramToProto(acquire2presentHist->second.hist, mMaxPulledHistogramBuckets);
|
|
}
|
|
const auto& latch2presentHist = layer->deltas.find("latch2present");
|
|
if (latch2presentHist != layer->deltas.cend()) {
|
|
*atom->mutable_latch_to_present() =
|
|
histogramToProto(latch2presentHist->second.hist, mMaxPulledHistogramBuckets);
|
|
}
|
|
const auto& desired2presentHist = layer->deltas.find("desired2present");
|
|
if (desired2presentHist != layer->deltas.cend()) {
|
|
*atom->mutable_desired_to_present() =
|
|
histogramToProto(desired2presentHist->second.hist, mMaxPulledHistogramBuckets);
|
|
}
|
|
const auto& post2acquireHist = layer->deltas.find("post2acquire");
|
|
if (post2acquireHist != layer->deltas.cend()) {
|
|
*atom->mutable_post_to_acquire() =
|
|
histogramToProto(post2acquireHist->second.hist, mMaxPulledHistogramBuckets);
|
|
}
|
|
|
|
atom->set_late_acquire_frames(layer->lateAcquireFrames);
|
|
atom->set_bad_desired_present_frames(layer->badDesiredPresentFrames);
|
|
atom->set_uid(layer->uid);
|
|
atom->set_total_timeline_frames(layer->jankPayload.totalFrames);
|
|
atom->set_total_janky_frames(layer->jankPayload.totalJankyFrames);
|
|
atom->set_total_janky_frames_with_long_cpu(layer->jankPayload.totalSFLongCpu);
|
|
atom->set_total_janky_frames_with_long_gpu(layer->jankPayload.totalSFLongGpu);
|
|
atom->set_total_janky_frames_sf_unattributed(layer->jankPayload.totalSFUnattributed);
|
|
atom->set_total_janky_frames_app_unattributed(layer->jankPayload.totalAppUnattributed);
|
|
atom->set_total_janky_frames_sf_scheduling(layer->jankPayload.totalSFScheduling);
|
|
atom->set_total_jank_frames_sf_prediction_error(layer->jankPayload.totalSFPredictionError);
|
|
atom->set_total_jank_frames_app_buffer_stuffing(layer->jankPayload.totalAppBufferStuffing);
|
|
atom->set_display_refresh_rate_bucket(layer->displayRefreshRateBucket);
|
|
atom->set_render_rate_bucket(layer->renderRateBucket);
|
|
*atom->mutable_set_frame_rate_vote() = frameRateVoteToProto(layer->setFrameRateVote);
|
|
*atom->mutable_app_deadline_misses() =
|
|
histogramToProto(layer->deltas["appDeadlineDeltas"].hist,
|
|
mMaxPulledHistogramBuckets);
|
|
atom->set_game_mode(gameModeToProto(layer->gameMode));
|
|
}
|
|
|
|
// Always clear data.
|
|
clearLayersLocked();
|
|
|
|
return atomList.SerializeToString(pulledData);
|
|
}
|
|
|
|
TimeStats::TimeStats() : TimeStats(std::nullopt, std::nullopt) {}
|
|
|
|
TimeStats::TimeStats(std::optional<size_t> maxPulledLayers,
|
|
std::optional<size_t> maxPulledHistogramBuckets) {
|
|
if (maxPulledLayers) {
|
|
mMaxPulledLayers = *maxPulledLayers;
|
|
}
|
|
|
|
if (maxPulledHistogramBuckets) {
|
|
mMaxPulledHistogramBuckets = *maxPulledHistogramBuckets;
|
|
}
|
|
}
|
|
|
|
bool TimeStats::onPullAtom(const int atomId, std::string* pulledData) {
|
|
bool success = false;
|
|
if (atomId == 10062) { // SURFACEFLINGER_STATS_GLOBAL_INFO
|
|
success = populateGlobalAtom(pulledData);
|
|
} else if (atomId == 10063) { // SURFACEFLINGER_STATS_LAYER_INFO
|
|
success = populateLayerAtom(pulledData);
|
|
}
|
|
|
|
// Enable timestats now. The first full pull for a given build is expected to
|
|
// have empty or very little stats, as stats are first enabled after the
|
|
// first pull is completed for either the global or layer stats.
|
|
enable();
|
|
return success;
|
|
}
|
|
|
|
void TimeStats::parseArgs(bool asProto, const Vector<String16>& args, std::string& result) {
|
|
ATRACE_CALL();
|
|
|
|
std::unordered_map<std::string, int32_t> argsMap;
|
|
for (size_t index = 0; index < args.size(); ++index) {
|
|
argsMap[std::string(String8(args[index]).c_str())] = index;
|
|
}
|
|
|
|
if (argsMap.count("-disable")) {
|
|
disable();
|
|
}
|
|
|
|
if (argsMap.count("-dump")) {
|
|
std::optional<uint32_t> maxLayers = std::nullopt;
|
|
auto iter = argsMap.find("-maxlayers");
|
|
if (iter != argsMap.end() && iter->second + 1 < static_cast<int32_t>(args.size())) {
|
|
int64_t value = strtol(String8(args[iter->second + 1]).c_str(), nullptr, 10);
|
|
value = std::clamp(value, int64_t(0), int64_t(UINT32_MAX));
|
|
maxLayers = static_cast<uint32_t>(value);
|
|
}
|
|
|
|
dump(asProto, maxLayers, result);
|
|
}
|
|
|
|
if (argsMap.count("-clear")) {
|
|
clearAll();
|
|
}
|
|
|
|
if (argsMap.count("-enable")) {
|
|
enable();
|
|
}
|
|
}
|
|
|
|
std::string TimeStats::miniDump() {
|
|
ATRACE_CALL();
|
|
|
|
std::string result = "TimeStats miniDump:\n";
|
|
std::lock_guard<std::mutex> lock(mMutex);
|
|
android::base::StringAppendF(&result, "Number of layers currently being tracked is %zu\n",
|
|
mTimeStatsTracker.size());
|
|
android::base::StringAppendF(&result, "Number of layers in the stats pool is %zu\n",
|
|
mTimeStats.stats.size());
|
|
return result;
|
|
}
|
|
|
|
void TimeStats::incrementTotalFrames() {
|
|
if (!mEnabled.load()) return;
|
|
|
|
ATRACE_CALL();
|
|
|
|
std::lock_guard<std::mutex> lock(mMutex);
|
|
mTimeStats.totalFramesLegacy++;
|
|
}
|
|
|
|
void TimeStats::incrementMissedFrames() {
|
|
if (!mEnabled.load()) return;
|
|
|
|
ATRACE_CALL();
|
|
|
|
std::lock_guard<std::mutex> lock(mMutex);
|
|
mTimeStats.missedFramesLegacy++;
|
|
}
|
|
|
|
void TimeStats::incrementClientCompositionFrames() {
|
|
if (!mEnabled.load()) return;
|
|
|
|
ATRACE_CALL();
|
|
|
|
std::lock_guard<std::mutex> lock(mMutex);
|
|
mTimeStats.clientCompositionFramesLegacy++;
|
|
}
|
|
|
|
void TimeStats::incrementClientCompositionReusedFrames() {
|
|
if (!mEnabled.load()) return;
|
|
|
|
ATRACE_CALL();
|
|
|
|
std::lock_guard<std::mutex> lock(mMutex);
|
|
mTimeStats.clientCompositionReusedFramesLegacy++;
|
|
}
|
|
|
|
void TimeStats::incrementRefreshRateSwitches() {
|
|
if (!mEnabled.load()) return;
|
|
|
|
ATRACE_CALL();
|
|
|
|
std::lock_guard<std::mutex> lock(mMutex);
|
|
mTimeStats.refreshRateSwitchesLegacy++;
|
|
}
|
|
|
|
void TimeStats::incrementCompositionStrategyChanges() {
|
|
if (!mEnabled.load()) return;
|
|
|
|
ATRACE_CALL();
|
|
|
|
std::lock_guard<std::mutex> lock(mMutex);
|
|
mTimeStats.compositionStrategyChangesLegacy++;
|
|
}
|
|
|
|
void TimeStats::recordDisplayEventConnectionCount(int32_t count) {
|
|
if (!mEnabled.load()) return;
|
|
|
|
ATRACE_CALL();
|
|
|
|
std::lock_guard<std::mutex> lock(mMutex);
|
|
mTimeStats.displayEventConnectionsCountLegacy =
|
|
std::max(mTimeStats.displayEventConnectionsCountLegacy, count);
|
|
}
|
|
|
|
static int32_t toMs(nsecs_t nanos) {
|
|
int64_t millis =
|
|
std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::nanoseconds(nanos))
|
|
.count();
|
|
millis = std::clamp(millis, int64_t(INT32_MIN), int64_t(INT32_MAX));
|
|
return static_cast<int32_t>(millis);
|
|
}
|
|
|
|
static int32_t msBetween(nsecs_t start, nsecs_t end) {
|
|
return toMs(end - start);
|
|
}
|
|
|
|
void TimeStats::recordFrameDuration(nsecs_t startTime, nsecs_t endTime) {
|
|
if (!mEnabled.load()) return;
|
|
|
|
std::lock_guard<std::mutex> lock(mMutex);
|
|
if (mPowerTime.powerMode == PowerMode::ON) {
|
|
mTimeStats.frameDurationLegacy.insert(msBetween(startTime, endTime));
|
|
}
|
|
}
|
|
|
|
void TimeStats::recordRenderEngineDuration(nsecs_t startTime, nsecs_t endTime) {
|
|
if (!mEnabled.load()) return;
|
|
|
|
std::lock_guard<std::mutex> lock(mMutex);
|
|
if (mGlobalRecord.renderEngineDurations.size() == MAX_NUM_TIME_RECORDS) {
|
|
ALOGE("RenderEngineTimes are already at its maximum size[%zu]", MAX_NUM_TIME_RECORDS);
|
|
mGlobalRecord.renderEngineDurations.pop_front();
|
|
}
|
|
mGlobalRecord.renderEngineDurations.push_back({startTime, endTime});
|
|
}
|
|
|
|
void TimeStats::recordRenderEngineDuration(nsecs_t startTime,
|
|
const std::shared_ptr<FenceTime>& endTime) {
|
|
if (!mEnabled.load()) return;
|
|
|
|
std::lock_guard<std::mutex> lock(mMutex);
|
|
if (mGlobalRecord.renderEngineDurations.size() == MAX_NUM_TIME_RECORDS) {
|
|
ALOGE("RenderEngineTimes are already at its maximum size[%zu]", MAX_NUM_TIME_RECORDS);
|
|
mGlobalRecord.renderEngineDurations.pop_front();
|
|
}
|
|
mGlobalRecord.renderEngineDurations.push_back({startTime, endTime});
|
|
}
|
|
|
|
bool TimeStats::recordReadyLocked(int32_t layerId, TimeRecord* timeRecord) {
|
|
if (!timeRecord->ready) {
|
|
ALOGV("[%d]-[%" PRIu64 "]-presentFence is still not received", layerId,
|
|
timeRecord->frameTime.frameNumber);
|
|
return false;
|
|
}
|
|
|
|
if (timeRecord->acquireFence != nullptr) {
|
|
if (timeRecord->acquireFence->getSignalTime() == Fence::SIGNAL_TIME_PENDING) {
|
|
return false;
|
|
}
|
|
if (timeRecord->acquireFence->getSignalTime() != Fence::SIGNAL_TIME_INVALID) {
|
|
timeRecord->frameTime.acquireTime = timeRecord->acquireFence->getSignalTime();
|
|
timeRecord->acquireFence = nullptr;
|
|
} else {
|
|
ALOGV("[%d]-[%" PRIu64 "]-acquireFence signal time is invalid", layerId,
|
|
timeRecord->frameTime.frameNumber);
|
|
}
|
|
}
|
|
|
|
if (timeRecord->presentFence != nullptr) {
|
|
if (timeRecord->presentFence->getSignalTime() == Fence::SIGNAL_TIME_PENDING) {
|
|
return false;
|
|
}
|
|
if (timeRecord->presentFence->getSignalTime() != Fence::SIGNAL_TIME_INVALID) {
|
|
timeRecord->frameTime.presentTime = timeRecord->presentFence->getSignalTime();
|
|
timeRecord->presentFence = nullptr;
|
|
} else {
|
|
ALOGV("[%d]-[%" PRIu64 "]-presentFence signal time invalid", layerId,
|
|
timeRecord->frameTime.frameNumber);
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
static int32_t clampToNearestBucket(Fps fps, size_t bucketWidth) {
|
|
return std::round(fps.getValue() / bucketWidth) * bucketWidth;
|
|
}
|
|
|
|
void TimeStats::flushAvailableRecordsToStatsLocked(int32_t layerId, Fps displayRefreshRate,
|
|
std::optional<Fps> renderRate,
|
|
SetFrameRateVote frameRateVote,
|
|
int32_t gameMode) {
|
|
ATRACE_CALL();
|
|
ALOGV("[%d]-flushAvailableRecordsToStatsLocked", layerId);
|
|
|
|
LayerRecord& layerRecord = mTimeStatsTracker[layerId];
|
|
TimeRecord& prevTimeRecord = layerRecord.prevTimeRecord;
|
|
std::deque<TimeRecord>& timeRecords = layerRecord.timeRecords;
|
|
const int32_t refreshRateBucket =
|
|
clampToNearestBucket(displayRefreshRate, REFRESH_RATE_BUCKET_WIDTH);
|
|
const int32_t renderRateBucket =
|
|
clampToNearestBucket(renderRate ? *renderRate : displayRefreshRate,
|
|
RENDER_RATE_BUCKET_WIDTH);
|
|
while (!timeRecords.empty()) {
|
|
if (!recordReadyLocked(layerId, &timeRecords[0])) break;
|
|
ALOGV("[%d]-[%" PRIu64 "]-presentFenceTime[%" PRId64 "]", layerId,
|
|
timeRecords[0].frameTime.frameNumber, timeRecords[0].frameTime.presentTime);
|
|
|
|
if (prevTimeRecord.ready) {
|
|
uid_t uid = layerRecord.uid;
|
|
const std::string& layerName = layerRecord.layerName;
|
|
TimeStatsHelper::TimelineStatsKey timelineKey = {refreshRateBucket, renderRateBucket};
|
|
if (!mTimeStats.stats.count(timelineKey)) {
|
|
mTimeStats.stats[timelineKey].key = timelineKey;
|
|
}
|
|
|
|
TimeStatsHelper::TimelineStats& displayStats = mTimeStats.stats[timelineKey];
|
|
|
|
TimeStatsHelper::LayerStatsKey layerKey = {uid, layerName, gameMode};
|
|
if (!displayStats.stats.count(layerKey)) {
|
|
displayStats.stats[layerKey].displayRefreshRateBucket = refreshRateBucket;
|
|
displayStats.stats[layerKey].renderRateBucket = renderRateBucket;
|
|
displayStats.stats[layerKey].uid = uid;
|
|
displayStats.stats[layerKey].layerName = layerName;
|
|
displayStats.stats[layerKey].gameMode = gameMode;
|
|
}
|
|
if (frameRateVote.frameRate > 0.0f) {
|
|
displayStats.stats[layerKey].setFrameRateVote = frameRateVote;
|
|
}
|
|
TimeStatsHelper::TimeStatsLayer& timeStatsLayer = displayStats.stats[layerKey];
|
|
timeStatsLayer.totalFrames++;
|
|
timeStatsLayer.droppedFrames += layerRecord.droppedFrames;
|
|
timeStatsLayer.lateAcquireFrames += layerRecord.lateAcquireFrames;
|
|
timeStatsLayer.badDesiredPresentFrames += layerRecord.badDesiredPresentFrames;
|
|
|
|
layerRecord.droppedFrames = 0;
|
|
layerRecord.lateAcquireFrames = 0;
|
|
layerRecord.badDesiredPresentFrames = 0;
|
|
|
|
const int32_t postToAcquireMs = msBetween(timeRecords[0].frameTime.postTime,
|
|
timeRecords[0].frameTime.acquireTime);
|
|
ALOGV("[%d]-[%" PRIu64 "]-post2acquire[%d]", layerId,
|
|
timeRecords[0].frameTime.frameNumber, postToAcquireMs);
|
|
timeStatsLayer.deltas["post2acquire"].insert(postToAcquireMs);
|
|
|
|
const int32_t postToPresentMs = msBetween(timeRecords[0].frameTime.postTime,
|
|
timeRecords[0].frameTime.presentTime);
|
|
ALOGV("[%d]-[%" PRIu64 "]-post2present[%d]", layerId,
|
|
timeRecords[0].frameTime.frameNumber, postToPresentMs);
|
|
timeStatsLayer.deltas["post2present"].insert(postToPresentMs);
|
|
|
|
const int32_t acquireToPresentMs = msBetween(timeRecords[0].frameTime.acquireTime,
|
|
timeRecords[0].frameTime.presentTime);
|
|
ALOGV("[%d]-[%" PRIu64 "]-acquire2present[%d]", layerId,
|
|
timeRecords[0].frameTime.frameNumber, acquireToPresentMs);
|
|
timeStatsLayer.deltas["acquire2present"].insert(acquireToPresentMs);
|
|
|
|
const int32_t latchToPresentMs = msBetween(timeRecords[0].frameTime.latchTime,
|
|
timeRecords[0].frameTime.presentTime);
|
|
ALOGV("[%d]-[%" PRIu64 "]-latch2present[%d]", layerId,
|
|
timeRecords[0].frameTime.frameNumber, latchToPresentMs);
|
|
timeStatsLayer.deltas["latch2present"].insert(latchToPresentMs);
|
|
|
|
const int32_t desiredToPresentMs = msBetween(timeRecords[0].frameTime.desiredTime,
|
|
timeRecords[0].frameTime.presentTime);
|
|
ALOGV("[%d]-[%" PRIu64 "]-desired2present[%d]", layerId,
|
|
timeRecords[0].frameTime.frameNumber, desiredToPresentMs);
|
|
timeStatsLayer.deltas["desired2present"].insert(desiredToPresentMs);
|
|
|
|
const int32_t presentToPresentMs = msBetween(prevTimeRecord.frameTime.presentTime,
|
|
timeRecords[0].frameTime.presentTime);
|
|
ALOGV("[%d]-[%" PRIu64 "]-present2present[%d]", layerId,
|
|
timeRecords[0].frameTime.frameNumber, presentToPresentMs);
|
|
timeStatsLayer.deltas["present2present"].insert(presentToPresentMs);
|
|
}
|
|
prevTimeRecord = timeRecords[0];
|
|
timeRecords.pop_front();
|
|
layerRecord.waitData--;
|
|
}
|
|
}
|
|
|
|
static constexpr const char* kPopupWindowPrefix = "PopupWindow";
|
|
static const size_t kMinLenLayerName = std::strlen(kPopupWindowPrefix);
|
|
|
|
// Avoid tracking the "PopupWindow:<random hash>#<number>" layers
|
|
static bool layerNameIsValid(const std::string& layerName) {
|
|
return layerName.length() >= kMinLenLayerName &&
|
|
layerName.compare(0, kMinLenLayerName, kPopupWindowPrefix) != 0;
|
|
}
|
|
|
|
bool TimeStats::canAddNewAggregatedStats(uid_t uid, const std::string& layerName,
|
|
int32_t gameMode) {
|
|
uint32_t layerRecords = 0;
|
|
for (const auto& record : mTimeStats.stats) {
|
|
if (record.second.stats.count({uid, layerName, gameMode}) > 0) {
|
|
return true;
|
|
}
|
|
|
|
layerRecords += record.second.stats.size();
|
|
}
|
|
|
|
return mTimeStats.stats.size() < MAX_NUM_LAYER_STATS;
|
|
}
|
|
|
|
void TimeStats::setPostTime(int32_t layerId, uint64_t frameNumber, const std::string& layerName,
|
|
uid_t uid, nsecs_t postTime, int32_t gameMode) {
|
|
if (!mEnabled.load()) return;
|
|
|
|
ATRACE_CALL();
|
|
ALOGV("[%d]-[%" PRIu64 "]-[%s]-PostTime[%" PRId64 "]", layerId, frameNumber, layerName.c_str(),
|
|
postTime);
|
|
|
|
std::lock_guard<std::mutex> lock(mMutex);
|
|
if (!canAddNewAggregatedStats(uid, layerName, gameMode)) {
|
|
return;
|
|
}
|
|
if (!mTimeStatsTracker.count(layerId) && mTimeStatsTracker.size() < MAX_NUM_LAYER_RECORDS &&
|
|
layerNameIsValid(layerName)) {
|
|
mTimeStatsTracker[layerId].uid = uid;
|
|
mTimeStatsTracker[layerId].layerName = layerName;
|
|
mTimeStatsTracker[layerId].gameMode = gameMode;
|
|
}
|
|
if (!mTimeStatsTracker.count(layerId)) return;
|
|
LayerRecord& layerRecord = mTimeStatsTracker[layerId];
|
|
if (layerRecord.timeRecords.size() == MAX_NUM_TIME_RECORDS) {
|
|
ALOGE("[%d]-[%s]-timeRecords is at its maximum size[%zu]. Ignore this when unittesting.",
|
|
layerId, layerRecord.layerName.c_str(), MAX_NUM_TIME_RECORDS);
|
|
mTimeStatsTracker.erase(layerId);
|
|
return;
|
|
}
|
|
// For most media content, the acquireFence is invalid because the buffer is
|
|
// ready at the queueBuffer stage. In this case, acquireTime should be given
|
|
// a default value as postTime.
|
|
TimeRecord timeRecord = {
|
|
.frameTime =
|
|
{
|
|
.frameNumber = frameNumber,
|
|
.postTime = postTime,
|
|
.latchTime = postTime,
|
|
.acquireTime = postTime,
|
|
.desiredTime = postTime,
|
|
},
|
|
};
|
|
layerRecord.timeRecords.push_back(timeRecord);
|
|
if (layerRecord.waitData < 0 ||
|
|
layerRecord.waitData >= static_cast<int32_t>(layerRecord.timeRecords.size()))
|
|
layerRecord.waitData = layerRecord.timeRecords.size() - 1;
|
|
}
|
|
|
|
void TimeStats::setLatchTime(int32_t layerId, uint64_t frameNumber, nsecs_t latchTime) {
|
|
if (!mEnabled.load()) return;
|
|
|
|
ATRACE_CALL();
|
|
ALOGV("[%d]-[%" PRIu64 "]-LatchTime[%" PRId64 "]", layerId, frameNumber, latchTime);
|
|
|
|
std::lock_guard<std::mutex> lock(mMutex);
|
|
if (!mTimeStatsTracker.count(layerId)) return;
|
|
LayerRecord& layerRecord = mTimeStatsTracker[layerId];
|
|
if (layerRecord.waitData < 0 ||
|
|
layerRecord.waitData >= static_cast<int32_t>(layerRecord.timeRecords.size()))
|
|
return;
|
|
TimeRecord& timeRecord = layerRecord.timeRecords[layerRecord.waitData];
|
|
if (timeRecord.frameTime.frameNumber == frameNumber) {
|
|
timeRecord.frameTime.latchTime = latchTime;
|
|
}
|
|
}
|
|
|
|
void TimeStats::incrementLatchSkipped(int32_t layerId, LatchSkipReason reason) {
|
|
if (!mEnabled.load()) return;
|
|
|
|
ATRACE_CALL();
|
|
ALOGV("[%d]-LatchSkipped-Reason[%d]", layerId,
|
|
static_cast<std::underlying_type<LatchSkipReason>::type>(reason));
|
|
|
|
std::lock_guard<std::mutex> lock(mMutex);
|
|
if (!mTimeStatsTracker.count(layerId)) return;
|
|
LayerRecord& layerRecord = mTimeStatsTracker[layerId];
|
|
|
|
switch (reason) {
|
|
case LatchSkipReason::LateAcquire:
|
|
layerRecord.lateAcquireFrames++;
|
|
break;
|
|
}
|
|
}
|
|
|
|
void TimeStats::incrementBadDesiredPresent(int32_t layerId) {
|
|
if (!mEnabled.load()) return;
|
|
|
|
ATRACE_CALL();
|
|
ALOGV("[%d]-BadDesiredPresent", layerId);
|
|
|
|
std::lock_guard<std::mutex> lock(mMutex);
|
|
if (!mTimeStatsTracker.count(layerId)) return;
|
|
LayerRecord& layerRecord = mTimeStatsTracker[layerId];
|
|
layerRecord.badDesiredPresentFrames++;
|
|
}
|
|
|
|
void TimeStats::setDesiredTime(int32_t layerId, uint64_t frameNumber, nsecs_t desiredTime) {
|
|
if (!mEnabled.load()) return;
|
|
|
|
ATRACE_CALL();
|
|
ALOGV("[%d]-[%" PRIu64 "]-DesiredTime[%" PRId64 "]", layerId, frameNumber, desiredTime);
|
|
|
|
std::lock_guard<std::mutex> lock(mMutex);
|
|
if (!mTimeStatsTracker.count(layerId)) return;
|
|
LayerRecord& layerRecord = mTimeStatsTracker[layerId];
|
|
if (layerRecord.waitData < 0 ||
|
|
layerRecord.waitData >= static_cast<int32_t>(layerRecord.timeRecords.size()))
|
|
return;
|
|
TimeRecord& timeRecord = layerRecord.timeRecords[layerRecord.waitData];
|
|
if (timeRecord.frameTime.frameNumber == frameNumber) {
|
|
timeRecord.frameTime.desiredTime = desiredTime;
|
|
}
|
|
}
|
|
|
|
void TimeStats::setAcquireTime(int32_t layerId, uint64_t frameNumber, nsecs_t acquireTime) {
|
|
if (!mEnabled.load()) return;
|
|
|
|
ATRACE_CALL();
|
|
ALOGV("[%d]-[%" PRIu64 "]-AcquireTime[%" PRId64 "]", layerId, frameNumber, acquireTime);
|
|
|
|
std::lock_guard<std::mutex> lock(mMutex);
|
|
if (!mTimeStatsTracker.count(layerId)) return;
|
|
LayerRecord& layerRecord = mTimeStatsTracker[layerId];
|
|
if (layerRecord.waitData < 0 ||
|
|
layerRecord.waitData >= static_cast<int32_t>(layerRecord.timeRecords.size()))
|
|
return;
|
|
TimeRecord& timeRecord = layerRecord.timeRecords[layerRecord.waitData];
|
|
if (timeRecord.frameTime.frameNumber == frameNumber) {
|
|
timeRecord.frameTime.acquireTime = acquireTime;
|
|
}
|
|
}
|
|
|
|
void TimeStats::setAcquireFence(int32_t layerId, uint64_t frameNumber,
|
|
const std::shared_ptr<FenceTime>& acquireFence) {
|
|
if (!mEnabled.load()) return;
|
|
|
|
ATRACE_CALL();
|
|
ALOGV("[%d]-[%" PRIu64 "]-AcquireFenceTime[%" PRId64 "]", layerId, frameNumber,
|
|
acquireFence->getSignalTime());
|
|
|
|
std::lock_guard<std::mutex> lock(mMutex);
|
|
if (!mTimeStatsTracker.count(layerId)) return;
|
|
LayerRecord& layerRecord = mTimeStatsTracker[layerId];
|
|
if (layerRecord.waitData < 0 ||
|
|
layerRecord.waitData >= static_cast<int32_t>(layerRecord.timeRecords.size()))
|
|
return;
|
|
TimeRecord& timeRecord = layerRecord.timeRecords[layerRecord.waitData];
|
|
if (timeRecord.frameTime.frameNumber == frameNumber) {
|
|
timeRecord.acquireFence = acquireFence;
|
|
}
|
|
}
|
|
|
|
void TimeStats::setPresentTime(int32_t layerId, uint64_t frameNumber, nsecs_t presentTime,
|
|
Fps displayRefreshRate, std::optional<Fps> renderRate,
|
|
SetFrameRateVote frameRateVote, int32_t gameMode) {
|
|
if (!mEnabled.load()) return;
|
|
|
|
ATRACE_CALL();
|
|
ALOGV("[%d]-[%" PRIu64 "]-PresentTime[%" PRId64 "]", layerId, frameNumber, presentTime);
|
|
|
|
std::lock_guard<std::mutex> lock(mMutex);
|
|
if (!mTimeStatsTracker.count(layerId)) return;
|
|
LayerRecord& layerRecord = mTimeStatsTracker[layerId];
|
|
if (layerRecord.waitData < 0 ||
|
|
layerRecord.waitData >= static_cast<int32_t>(layerRecord.timeRecords.size()))
|
|
return;
|
|
TimeRecord& timeRecord = layerRecord.timeRecords[layerRecord.waitData];
|
|
if (timeRecord.frameTime.frameNumber == frameNumber) {
|
|
timeRecord.frameTime.presentTime = presentTime;
|
|
timeRecord.ready = true;
|
|
layerRecord.waitData++;
|
|
}
|
|
|
|
flushAvailableRecordsToStatsLocked(layerId, displayRefreshRate, renderRate, frameRateVote,
|
|
gameMode);
|
|
}
|
|
|
|
void TimeStats::setPresentFence(int32_t layerId, uint64_t frameNumber,
|
|
const std::shared_ptr<FenceTime>& presentFence,
|
|
Fps displayRefreshRate, std::optional<Fps> renderRate,
|
|
SetFrameRateVote frameRateVote, int32_t gameMode) {
|
|
if (!mEnabled.load()) return;
|
|
|
|
ATRACE_CALL();
|
|
ALOGV("[%d]-[%" PRIu64 "]-PresentFenceTime[%" PRId64 "]", layerId, frameNumber,
|
|
presentFence->getSignalTime());
|
|
|
|
std::lock_guard<std::mutex> lock(mMutex);
|
|
if (!mTimeStatsTracker.count(layerId)) return;
|
|
LayerRecord& layerRecord = mTimeStatsTracker[layerId];
|
|
if (layerRecord.waitData < 0 ||
|
|
layerRecord.waitData >= static_cast<int32_t>(layerRecord.timeRecords.size()))
|
|
return;
|
|
TimeRecord& timeRecord = layerRecord.timeRecords[layerRecord.waitData];
|
|
if (timeRecord.frameTime.frameNumber == frameNumber) {
|
|
timeRecord.presentFence = presentFence;
|
|
timeRecord.ready = true;
|
|
layerRecord.waitData++;
|
|
}
|
|
|
|
flushAvailableRecordsToStatsLocked(layerId, displayRefreshRate, renderRate, frameRateVote,
|
|
gameMode);
|
|
}
|
|
|
|
static const constexpr int32_t kValidJankyReason = JankType::DisplayHAL |
|
|
JankType::SurfaceFlingerCpuDeadlineMissed | JankType::SurfaceFlingerGpuDeadlineMissed |
|
|
JankType::AppDeadlineMissed | JankType::PredictionError |
|
|
JankType::SurfaceFlingerScheduling;
|
|
|
|
template <class T>
|
|
static void updateJankPayload(T& t, int32_t reasons) {
|
|
t.jankPayload.totalFrames++;
|
|
|
|
if (reasons & kValidJankyReason) {
|
|
t.jankPayload.totalJankyFrames++;
|
|
if ((reasons & JankType::SurfaceFlingerCpuDeadlineMissed) != 0) {
|
|
t.jankPayload.totalSFLongCpu++;
|
|
}
|
|
if ((reasons & JankType::SurfaceFlingerGpuDeadlineMissed) != 0) {
|
|
t.jankPayload.totalSFLongGpu++;
|
|
}
|
|
if ((reasons & JankType::DisplayHAL) != 0) {
|
|
t.jankPayload.totalSFUnattributed++;
|
|
}
|
|
if ((reasons & JankType::AppDeadlineMissed) != 0) {
|
|
t.jankPayload.totalAppUnattributed++;
|
|
}
|
|
if ((reasons & JankType::PredictionError) != 0) {
|
|
t.jankPayload.totalSFPredictionError++;
|
|
}
|
|
if ((reasons & JankType::SurfaceFlingerScheduling) != 0) {
|
|
t.jankPayload.totalSFScheduling++;
|
|
}
|
|
}
|
|
|
|
// We want to track BufferStuffing separately as it can provide info on latency issues
|
|
if (reasons & JankType::BufferStuffing) {
|
|
t.jankPayload.totalAppBufferStuffing++;
|
|
}
|
|
}
|
|
|
|
void TimeStats::incrementJankyFrames(const JankyFramesInfo& info) {
|
|
if (!mEnabled.load()) return;
|
|
|
|
ATRACE_CALL();
|
|
std::lock_guard<std::mutex> lock(mMutex);
|
|
|
|
// Only update layer stats if we're already tracking the layer in TimeStats.
|
|
// Otherwise, continue tracking the statistic but use a default layer name instead.
|
|
// As an implementation detail, we do this because this method is expected to be
|
|
// called from FrameTimeline, whose jank classification includes transaction jank
|
|
// that occurs without a buffer. But, in general those layer names are not suitable as
|
|
// aggregation keys: e.g., it's normal and expected for Window Manager to include the hash code
|
|
// for an animation leash. So while we can show that jank in dumpsys, aggregating based on the
|
|
// layer blows up the stats size, so as a workaround drop those stats. This assumes that
|
|
// TimeStats will flush the first present fence for a layer *before* FrameTimeline does so that
|
|
// the first jank record is not dropped.
|
|
|
|
static const std::string kDefaultLayerName = "none";
|
|
static constexpr int32_t kDefaultGameMode = TimeStatsHelper::GameModeUnsupported;
|
|
|
|
const int32_t refreshRateBucket =
|
|
clampToNearestBucket(info.refreshRate, REFRESH_RATE_BUCKET_WIDTH);
|
|
const int32_t renderRateBucket =
|
|
clampToNearestBucket(info.renderRate ? *info.renderRate : info.refreshRate,
|
|
RENDER_RATE_BUCKET_WIDTH);
|
|
const TimeStatsHelper::TimelineStatsKey timelineKey = {refreshRateBucket, renderRateBucket};
|
|
|
|
if (!mTimeStats.stats.count(timelineKey)) {
|
|
mTimeStats.stats[timelineKey].key = timelineKey;
|
|
}
|
|
|
|
TimeStatsHelper::TimelineStats& timelineStats = mTimeStats.stats[timelineKey];
|
|
|
|
updateJankPayload<TimeStatsHelper::TimelineStats>(timelineStats, info.reasons);
|
|
|
|
TimeStatsHelper::LayerStatsKey layerKey = {info.uid, info.layerName, info.gameMode};
|
|
if (!timelineStats.stats.count(layerKey)) {
|
|
layerKey = {info.uid, kDefaultLayerName, kDefaultGameMode};
|
|
timelineStats.stats[layerKey].displayRefreshRateBucket = refreshRateBucket;
|
|
timelineStats.stats[layerKey].renderRateBucket = renderRateBucket;
|
|
timelineStats.stats[layerKey].uid = info.uid;
|
|
timelineStats.stats[layerKey].layerName = kDefaultLayerName;
|
|
timelineStats.stats[layerKey].gameMode = kDefaultGameMode;
|
|
}
|
|
|
|
TimeStatsHelper::TimeStatsLayer& timeStatsLayer = timelineStats.stats[layerKey];
|
|
updateJankPayload<TimeStatsHelper::TimeStatsLayer>(timeStatsLayer, info.reasons);
|
|
|
|
if (info.reasons & kValidJankyReason) {
|
|
// TimeStats Histograms only retain positive values, so we don't need to check if these
|
|
// deadlines were really missed if we know that the frame had jank, since deadlines
|
|
// that were met will be dropped.
|
|
timelineStats.displayDeadlineDeltas.insert(toMs(info.displayDeadlineDelta));
|
|
timelineStats.displayPresentDeltas.insert(toMs(info.displayPresentJitter));
|
|
timeStatsLayer.deltas["appDeadlineDeltas"].insert(toMs(info.appDeadlineDelta));
|
|
}
|
|
}
|
|
|
|
void TimeStats::onDestroy(int32_t layerId) {
|
|
ATRACE_CALL();
|
|
ALOGV("[%d]-onDestroy", layerId);
|
|
std::lock_guard<std::mutex> lock(mMutex);
|
|
mTimeStatsTracker.erase(layerId);
|
|
}
|
|
|
|
void TimeStats::removeTimeRecord(int32_t layerId, uint64_t frameNumber) {
|
|
if (!mEnabled.load()) return;
|
|
|
|
ATRACE_CALL();
|
|
ALOGV("[%d]-[%" PRIu64 "]-removeTimeRecord", layerId, frameNumber);
|
|
|
|
std::lock_guard<std::mutex> lock(mMutex);
|
|
if (!mTimeStatsTracker.count(layerId)) return;
|
|
LayerRecord& layerRecord = mTimeStatsTracker[layerId];
|
|
size_t removeAt = 0;
|
|
for (const TimeRecord& record : layerRecord.timeRecords) {
|
|
if (record.frameTime.frameNumber == frameNumber) break;
|
|
removeAt++;
|
|
}
|
|
if (removeAt == layerRecord.timeRecords.size()) return;
|
|
layerRecord.timeRecords.erase(layerRecord.timeRecords.begin() + removeAt);
|
|
if (layerRecord.waitData > static_cast<int32_t>(removeAt)) {
|
|
layerRecord.waitData--;
|
|
}
|
|
layerRecord.droppedFrames++;
|
|
}
|
|
|
|
void TimeStats::flushPowerTimeLocked() {
|
|
if (!mEnabled.load()) return;
|
|
|
|
nsecs_t curTime = systemTime();
|
|
// elapsedTime is in milliseconds.
|
|
int64_t elapsedTime = (curTime - mPowerTime.prevTime) / 1000000;
|
|
|
|
switch (mPowerTime.powerMode) {
|
|
case PowerMode::ON:
|
|
mTimeStats.displayOnTimeLegacy += elapsedTime;
|
|
break;
|
|
case PowerMode::OFF:
|
|
case PowerMode::DOZE:
|
|
case PowerMode::DOZE_SUSPEND:
|
|
case PowerMode::ON_SUSPEND:
|
|
default:
|
|
break;
|
|
}
|
|
|
|
mPowerTime.prevTime = curTime;
|
|
}
|
|
|
|
void TimeStats::setPowerMode(PowerMode powerMode) {
|
|
if (!mEnabled.load()) {
|
|
std::lock_guard<std::mutex> lock(mMutex);
|
|
mPowerTime.powerMode = powerMode;
|
|
return;
|
|
}
|
|
|
|
std::lock_guard<std::mutex> lock(mMutex);
|
|
if (powerMode == mPowerTime.powerMode) return;
|
|
|
|
flushPowerTimeLocked();
|
|
mPowerTime.powerMode = powerMode;
|
|
}
|
|
|
|
void TimeStats::recordRefreshRate(uint32_t fps, nsecs_t duration) {
|
|
std::lock_guard<std::mutex> lock(mMutex);
|
|
if (mTimeStats.refreshRateStatsLegacy.count(fps)) {
|
|
mTimeStats.refreshRateStatsLegacy[fps] += duration;
|
|
} else {
|
|
mTimeStats.refreshRateStatsLegacy.insert({fps, duration});
|
|
}
|
|
}
|
|
|
|
void TimeStats::flushAvailableGlobalRecordsToStatsLocked() {
|
|
ATRACE_CALL();
|
|
|
|
while (!mGlobalRecord.presentFences.empty()) {
|
|
const nsecs_t curPresentTime = mGlobalRecord.presentFences.front()->getSignalTime();
|
|
if (curPresentTime == Fence::SIGNAL_TIME_PENDING) break;
|
|
|
|
if (curPresentTime == Fence::SIGNAL_TIME_INVALID) {
|
|
ALOGE("GlobalPresentFence is invalid!");
|
|
mGlobalRecord.prevPresentTime = 0;
|
|
mGlobalRecord.presentFences.pop_front();
|
|
continue;
|
|
}
|
|
|
|
ALOGV("GlobalPresentFenceTime[%" PRId64 "]",
|
|
mGlobalRecord.presentFences.front()->getSignalTime());
|
|
|
|
if (mGlobalRecord.prevPresentTime != 0) {
|
|
const int32_t presentToPresentMs =
|
|
msBetween(mGlobalRecord.prevPresentTime, curPresentTime);
|
|
ALOGV("Global present2present[%d] prev[%" PRId64 "] curr[%" PRId64 "]",
|
|
presentToPresentMs, mGlobalRecord.prevPresentTime, curPresentTime);
|
|
mTimeStats.presentToPresentLegacy.insert(presentToPresentMs);
|
|
}
|
|
|
|
mGlobalRecord.prevPresentTime = curPresentTime;
|
|
mGlobalRecord.presentFences.pop_front();
|
|
}
|
|
while (!mGlobalRecord.renderEngineDurations.empty()) {
|
|
const auto duration = mGlobalRecord.renderEngineDurations.front();
|
|
const auto& endTime = duration.endTime;
|
|
|
|
nsecs_t endNs = -1;
|
|
|
|
if (auto val = std::get_if<nsecs_t>(&endTime)) {
|
|
endNs = *val;
|
|
} else {
|
|
endNs = std::get<std::shared_ptr<FenceTime>>(endTime)->getSignalTime();
|
|
}
|
|
|
|
if (endNs == Fence::SIGNAL_TIME_PENDING) break;
|
|
|
|
if (endNs < 0) {
|
|
ALOGE("RenderEngineTiming is invalid!");
|
|
mGlobalRecord.renderEngineDurations.pop_front();
|
|
continue;
|
|
}
|
|
|
|
const int32_t renderEngineMs = msBetween(duration.startTime, endNs);
|
|
mTimeStats.renderEngineTimingLegacy.insert(renderEngineMs);
|
|
|
|
mGlobalRecord.renderEngineDurations.pop_front();
|
|
}
|
|
}
|
|
|
|
void TimeStats::setPresentFenceGlobal(const std::shared_ptr<FenceTime>& presentFence) {
|
|
if (!mEnabled.load()) return;
|
|
|
|
ATRACE_CALL();
|
|
std::lock_guard<std::mutex> lock(mMutex);
|
|
if (presentFence == nullptr || !presentFence->isValid()) {
|
|
mGlobalRecord.prevPresentTime = 0;
|
|
return;
|
|
}
|
|
|
|
if (mPowerTime.powerMode != PowerMode::ON) {
|
|
// Try flushing the last present fence on PowerMode::ON.
|
|
flushAvailableGlobalRecordsToStatsLocked();
|
|
mGlobalRecord.presentFences.clear();
|
|
mGlobalRecord.prevPresentTime = 0;
|
|
return;
|
|
}
|
|
|
|
if (mGlobalRecord.presentFences.size() == MAX_NUM_TIME_RECORDS) {
|
|
// The front presentFence must be trapped in pending status in this
|
|
// case. Try dequeuing the front one to recover.
|
|
ALOGE("GlobalPresentFences is already at its maximum size[%zu]", MAX_NUM_TIME_RECORDS);
|
|
mGlobalRecord.prevPresentTime = 0;
|
|
mGlobalRecord.presentFences.pop_front();
|
|
}
|
|
|
|
mGlobalRecord.presentFences.emplace_back(presentFence);
|
|
flushAvailableGlobalRecordsToStatsLocked();
|
|
}
|
|
|
|
void TimeStats::enable() {
|
|
if (mEnabled.load()) return;
|
|
|
|
ATRACE_CALL();
|
|
|
|
std::lock_guard<std::mutex> lock(mMutex);
|
|
mEnabled.store(true);
|
|
mTimeStats.statsStartLegacy = static_cast<int64_t>(std::time(0));
|
|
mPowerTime.prevTime = systemTime();
|
|
ALOGD("Enabled");
|
|
}
|
|
|
|
void TimeStats::disable() {
|
|
if (!mEnabled.load()) return;
|
|
|
|
ATRACE_CALL();
|
|
|
|
std::lock_guard<std::mutex> lock(mMutex);
|
|
flushPowerTimeLocked();
|
|
mEnabled.store(false);
|
|
mTimeStats.statsEndLegacy = static_cast<int64_t>(std::time(0));
|
|
ALOGD("Disabled");
|
|
}
|
|
|
|
void TimeStats::clearAll() {
|
|
std::lock_guard<std::mutex> lock(mMutex);
|
|
mTimeStats.stats.clear();
|
|
clearGlobalLocked();
|
|
clearLayersLocked();
|
|
}
|
|
|
|
void TimeStats::clearGlobalLocked() {
|
|
ATRACE_CALL();
|
|
|
|
mTimeStats.statsStartLegacy = (mEnabled.load() ? static_cast<int64_t>(std::time(0)) : 0);
|
|
mTimeStats.statsEndLegacy = 0;
|
|
mTimeStats.totalFramesLegacy = 0;
|
|
mTimeStats.missedFramesLegacy = 0;
|
|
mTimeStats.clientCompositionFramesLegacy = 0;
|
|
mTimeStats.clientCompositionReusedFramesLegacy = 0;
|
|
mTimeStats.refreshRateSwitchesLegacy = 0;
|
|
mTimeStats.compositionStrategyChangesLegacy = 0;
|
|
mTimeStats.displayEventConnectionsCountLegacy = 0;
|
|
mTimeStats.displayOnTimeLegacy = 0;
|
|
mTimeStats.presentToPresentLegacy.hist.clear();
|
|
mTimeStats.frameDurationLegacy.hist.clear();
|
|
mTimeStats.renderEngineTimingLegacy.hist.clear();
|
|
mTimeStats.refreshRateStatsLegacy.clear();
|
|
mPowerTime.prevTime = systemTime();
|
|
for (auto& globalRecord : mTimeStats.stats) {
|
|
globalRecord.second.clearGlobals();
|
|
}
|
|
mGlobalRecord.prevPresentTime = 0;
|
|
mGlobalRecord.presentFences.clear();
|
|
ALOGD("Cleared global stats");
|
|
}
|
|
|
|
void TimeStats::clearLayersLocked() {
|
|
ATRACE_CALL();
|
|
|
|
mTimeStatsTracker.clear();
|
|
|
|
for (auto& globalRecord : mTimeStats.stats) {
|
|
globalRecord.second.stats.clear();
|
|
}
|
|
ALOGD("Cleared layer stats");
|
|
}
|
|
|
|
bool TimeStats::isEnabled() {
|
|
return mEnabled.load();
|
|
}
|
|
|
|
void TimeStats::dump(bool asProto, std::optional<uint32_t> maxLayers, std::string& result) {
|
|
ATRACE_CALL();
|
|
|
|
std::lock_guard<std::mutex> lock(mMutex);
|
|
if (mTimeStats.statsStartLegacy == 0) {
|
|
return;
|
|
}
|
|
|
|
mTimeStats.statsEndLegacy = static_cast<int64_t>(std::time(0));
|
|
|
|
flushPowerTimeLocked();
|
|
|
|
if (asProto) {
|
|
ALOGD("Dumping TimeStats as proto");
|
|
SFTimeStatsGlobalProto timeStatsProto = mTimeStats.toProto(maxLayers);
|
|
result.append(timeStatsProto.SerializeAsString());
|
|
} else {
|
|
ALOGD("Dumping TimeStats as text");
|
|
result.append(mTimeStats.toString(maxLayers));
|
|
result.append("\n");
|
|
}
|
|
}
|
|
|
|
} // namespace impl
|
|
|
|
} // namespace android
|