path: root/services/surfaceflinger/TimeStats/timestatsproto/TimeStatsHelper.cpp

/*
 * Copyright (C) 2017 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 "timestatsproto/TimeStatsHelper.h"

#include <android-base/stringprintf.h>
#include <inttypes.h>

#include <array>

#define HISTOGRAM_SIZE 85

using android::base::StringAppendF;
using android::base::StringPrintf;

namespace android {
namespace surfaceflinger {

// Time buckets for histogram, the calculated time deltas will be lower bounded
// to the buckets in this array.
static const std::array<int32_t, HISTOGRAM_SIZE> histogramConfig =
        {0,   1,   2,   3,   4,   5,   6,   7,   8,   9,   10,  11,  12,  13,  14,  15,  16,
         17,  18,  19,  20,  21,  22,  23,  24,  25,  26,  27,  28,  29,  30,  31,  32,  33,
         34,  36,  38,  40,  42,  44,  46,  48,  50,  54,  58,  62,  66,  70,  74,  78,  82,
         86,  90,  94,  98,  102, 106, 110, 114, 118, 122, 126, 130, 134, 138, 142, 146, 150,
         200, 250, 300, 350, 400, 450, 500, 550, 600, 650, 700, 750, 800, 850, 900, 950, 1000};

void TimeStatsHelper::Histogram::insert(int32_t delta) {
    if (delta < 0) return;
    // std::lower_bound won't work on out of range values
    if (delta > histogramConfig[HISTOGRAM_SIZE - 1]) {
        hist[histogramConfig[HISTOGRAM_SIZE - 1]]++;
        return;
    }
    auto iter = std::lower_bound(histogramConfig.begin(), histogramConfig.end(), delta);
    hist[*iter]++;
}

int64_t TimeStatsHelper::Histogram::totalTime() const {
    int64_t ret = 0;
    for (const auto& ele : hist) {
        ret += ele.first * ele.second;
    }
    return ret;
}

float TimeStatsHelper::Histogram::averageTime() const {
    int64_t ret = 0;
    int64_t count = 0;
    for (const auto& ele : hist) {
        count += ele.second;
        ret += ele.first * ele.second;
    }
    return static_cast<float>(ret) / count;
}

std::string TimeStatsHelper::Histogram::toString() const {
    std::string result;
    for (int32_t i = 0; i < HISTOGRAM_SIZE; ++i) {
        int32_t bucket = histogramConfig[i];
        int32_t count = (hist.count(bucket) == 0) ? 0 : hist.at(bucket);
        StringAppendF(&result, "%dms=%d ", bucket, count);
    }
    result.back() = '\n';
    return result;
}

std::string TimeStatsHelper::JankPayload::toString() const {
    std::string result;
    StringAppendF(&result, "totalTimelineFrames = %d\n", totalFrames);
    StringAppendF(&result, "jankyFrames = %d\n", totalJankyFrames);
    StringAppendF(&result, "sfLongCpuJankyFrames = %d\n", totalSFLongCpu);
    StringAppendF(&result, "sfLongGpuJankyFrames = %d\n", totalSFLongGpu);
    StringAppendF(&result, "sfUnattributedJankyFrames = %d\n", totalSFUnattributed);
    StringAppendF(&result, "appUnattributedJankyFrames = %d\n", totalAppUnattributed);
    StringAppendF(&result, "sfSchedulingJankyFrames = %d\n", totalSFScheduling);
    StringAppendF(&result, "sfPredictionErrorJankyFrames = %d\n", totalSFPredictionError);
    StringAppendF(&result, "appBufferStuffingJankyFrames = %d\n", totalAppBufferStuffing);
    return result;
}

std::string TimeStatsHelper::SetFrameRateVote::toString(FrameRateCompatibility compatibility) {
    switch (compatibility) {
        case FrameRateCompatibility::Undefined:
            return "Undefined";
        case FrameRateCompatibility::Default:
            return "Default";
        case FrameRateCompatibility::ExactOrMultiple:
            return "ExactOrMultiple";
    }
}

std::string TimeStatsHelper::SetFrameRateVote::toString(Seamlessness seamlessness) {
    switch (seamlessness) {
        case Seamlessness::Undefined:
            return "Undefined";
        case Seamlessness::ShouldBeSeamless:
            return "ShouldBeSeamless";
        case Seamlessness::NotRequired:
            return "NotRequired";
    }
}

std::string TimeStatsHelper::SetFrameRateVote::toString() const {
    std::string result;
    StringAppendF(&result, "frameRate = %.2f\n", frameRate);
    StringAppendF(&result, "frameRateCompatibility = %s\n",
                  toString(frameRateCompatibility).c_str());
    StringAppendF(&result, "seamlessness = %s\n", toString(seamlessness).c_str());
    return result;
}

std::string TimeStatsHelper::TimeStatsLayer::toString(int32_t gameMode) const {
    switch (gameMode) {
        case TimeStatsHelper::GameModeUnsupported:
            return "GameModeUnsupported";
        case TimeStatsHelper::GameModeStandard:
            return "GameModeStandard";
        case TimeStatsHelper::GameModePerformance:
            return "GameModePerformance";
        case TimeStatsHelper::GameModeBattery:
            return "GameModeBattery";
        default:
            return "GameModeUnspecified";
    }
}
std::string TimeStatsHelper::TimeStatsLayer::toString() const {
    std::string result = "\n";
    StringAppendF(&result, "displayRefreshRate = %d fps\n", displayRefreshRateBucket);
    StringAppendF(&result, "renderRate = %d fps\n", renderRateBucket);
    StringAppendF(&result, "uid = %d\n", uid);
    StringAppendF(&result, "layerName = %s\n", layerName.c_str());
    StringAppendF(&result, "packageName = %s\n", packageName.c_str());
    StringAppendF(&result, "gameMode = %s\n", toString(gameMode).c_str());
    StringAppendF(&result, "totalFrames = %d\n", totalFrames);
    StringAppendF(&result, "droppedFrames = %d\n", droppedFrames);
    StringAppendF(&result, "lateAcquireFrames = %d\n", lateAcquireFrames);
    StringAppendF(&result, "badDesiredPresentFrames = %d\n", badDesiredPresentFrames);
    result.append("Jank payload for this layer:\n");
    result.append(jankPayload.toString());
    result.append("SetFrateRate vote for this layer:\n");
    result.append(setFrameRateVote.toString());
    const auto iter = deltas.find("present2present");
    if (iter != deltas.end()) {
        const float averageTime = iter->second.averageTime();
        const float averageFPS = averageTime < 1.0f ? 0.0f : 1000.0f / averageTime;
        StringAppendF(&result, "averageFPS = %.3f\n", averageFPS);
    }
    for (const auto& ele : deltas) {
        StringAppendF(&result, "%s histogram is as below:\n", ele.first.c_str());
        result.append(ele.second.toString());
    }

    return result;
}

std::string TimeStatsHelper::TimeStatsGlobal::toString(std::optional<uint32_t> maxLayers) const {
    std::string result = "SurfaceFlinger TimeStats:\n";
    result.append("Legacy stats are as follows:\n");
    StringAppendF(&result, "statsStart = %" PRId64 "\n", statsStartLegacy);
    StringAppendF(&result, "statsEnd = %" PRId64 "\n", statsEndLegacy);
    StringAppendF(&result, "totalFrames = %d\n", totalFramesLegacy);
    StringAppendF(&result, "missedFrames = %d\n", missedFramesLegacy);
    StringAppendF(&result, "clientCompositionFrames = %d\n", clientCompositionFramesLegacy);
    StringAppendF(&result, "clientCompositionReusedFrames = %d\n",
                  clientCompositionReusedFramesLegacy);
    StringAppendF(&result, "refreshRateSwitches = %d\n", refreshRateSwitchesLegacy);
    StringAppendF(&result, "compositionStrategyChanges = %d\n", compositionStrategyChangesLegacy);
    StringAppendF(&result, "displayOnTime = %" PRId64 " ms\n", displayOnTimeLegacy);
    StringAppendF(&result, "displayConfigStats is as below:\n");
    for (const auto& [fps, duration] : refreshRateStatsLegacy) {
        StringAppendF(&result, "%dfps = %ldms\n", fps, ns2ms(duration));
    }
    result.back() = '\n';
    StringAppendF(&result, "totalP2PTime = %" PRId64 " ms\n", presentToPresentLegacy.totalTime());
    StringAppendF(&result, "presentToPresent histogram is as below:\n");
    result.append(presentToPresentLegacy.toString());
    const float averageFrameDuration = frameDurationLegacy.averageTime();
    StringAppendF(&result, "averageFrameDuration = %.3f ms\n",
                  std::isnan(averageFrameDuration) ? 0.0f : averageFrameDuration);
    StringAppendF(&result, "frameDuration histogram is as below:\n");
    result.append(frameDurationLegacy.toString());
    const float averageRenderEngineTiming = renderEngineTimingLegacy.averageTime();
    StringAppendF(&result, "averageRenderEngineTiming = %.3f ms\n",
                  std::isnan(averageRenderEngineTiming) ? 0.0f : averageRenderEngineTiming);
    StringAppendF(&result, "renderEngineTiming histogram is as below:\n");
    result.append(renderEngineTimingLegacy.toString());

    result.append("\nGlobal aggregated jank payload (Timeline stats):");
    for (const auto& ele : stats) {
        result.append("\n");
        StringAppendF(&result, "displayRefreshRate = %d fps\n",
                      ele.second.key.displayRefreshRateBucket);
        StringAppendF(&result, "renderRate = %d fps\n", ele.second.key.renderRateBucket);
        result.append(ele.second.jankPayload.toString());
        StringAppendF(&result, "sfDeadlineMisses histogram is as below:\n");
        result.append(ele.second.displayDeadlineDeltas.toString());
        StringAppendF(&result, "sfPredictionErrors histogram is as below:\n");
        result.append(ele.second.displayPresentDeltas.toString());
    }

    const auto dumpStats = generateDumpStats(maxLayers);
    for (const auto& ele : dumpStats) {
        result.append(ele->toString());
    }

    return result;
}

SFTimeStatsLayerProto TimeStatsHelper::TimeStatsLayer::toProto() const {
    SFTimeStatsLayerProto layerProto;
    layerProto.set_layer_name(layerName);
    layerProto.set_package_name(packageName);
    layerProto.set_total_frames(totalFrames);
    layerProto.set_dropped_frames(droppedFrames);
    for (const auto& ele : deltas) {
        SFTimeStatsDeltaProto* deltaProto = layerProto.add_deltas();
        deltaProto->set_delta_name(ele.first);
        for (const auto& histEle : ele.second.hist) {
            SFTimeStatsHistogramBucketProto* histProto = deltaProto->add_histograms();
            histProto->set_time_millis(histEle.first);
            histProto->set_frame_count(histEle.second);
        }
    }
    return layerProto;
}

SFTimeStatsGlobalProto TimeStatsHelper::TimeStatsGlobal::toProto(
        std::optional<uint32_t> maxLayers) const {
    SFTimeStatsGlobalProto globalProto;
    globalProto.set_stats_start(statsStartLegacy);
    globalProto.set_stats_end(statsEndLegacy);
    globalProto.set_total_frames(totalFramesLegacy);
    globalProto.set_missed_frames(missedFramesLegacy);
    globalProto.set_client_composition_frames(clientCompositionFramesLegacy);
    globalProto.set_display_on_time(displayOnTimeLegacy);
    for (const auto& ele : refreshRateStatsLegacy) {
        SFTimeStatsDisplayConfigBucketProto* configBucketProto =
                globalProto.add_display_config_stats();
        SFTimeStatsDisplayConfigProto* configProto = configBucketProto->mutable_config();
        configProto->set_fps(ele.first);
        configBucketProto->set_duration_millis(ns2ms(ele.second));
    }
    for (const auto& histEle : presentToPresentLegacy.hist) {
        SFTimeStatsHistogramBucketProto* histProto = globalProto.add_present_to_present();
        histProto->set_time_millis(histEle.first);
        histProto->set_frame_count(histEle.second);
    }
    for (const auto& histEle : frameDurationLegacy.hist) {
        SFTimeStatsHistogramBucketProto* histProto = globalProto.add_frame_duration();
        histProto->set_time_millis(histEle.first);
        histProto->set_frame_count(histEle.second);
    }
    for (const auto& histEle : renderEngineTimingLegacy.hist) {
        SFTimeStatsHistogramBucketProto* histProto = globalProto.add_render_engine_timing();
        histProto->set_time_millis(histEle.first);
        histProto->set_frame_count(histEle.second);
    }
    const auto dumpStats = generateDumpStats(maxLayers);
    for (const auto& ele : dumpStats) {
        SFTimeStatsLayerProto* layerProto = globalProto.add_stats();
        layerProto->CopyFrom(ele->toProto());
    }
    return globalProto;
}

std::vector<TimeStatsHelper::TimeStatsLayer const*>
TimeStatsHelper::TimeStatsGlobal::generateDumpStats(std::optional<uint32_t> maxLayers) const {
    std::vector<TimeStatsLayer const*> dumpStats;

    int numLayers = 0;
    for (const auto& ele : stats) {
        numLayers += ele.second.stats.size();
    }

    dumpStats.reserve(numLayers);

    for (const auto& ele : stats) {
        for (const auto& layerEle : ele.second.stats) {
            dumpStats.push_back(&layerEle.second);
        }
    }

    std::sort(dumpStats.begin(), dumpStats.end(),
              [](TimeStatsHelper::TimeStatsLayer const* l,
                 TimeStatsHelper::TimeStatsLayer const* r) {
                  return l->totalFrames > r->totalFrames;
              });

    if (maxLayers && (*maxLayers < dumpStats.size())) {
        dumpStats.resize(*maxLayers);
    }
    return dumpStats;
}

} // namespace surfaceflinger
} // namespace android