Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 7053d901 authored by Ady Abraham's avatar Ady Abraham Committed by Automerger Merge Worker
Browse files

Merge "SurfaceFlinger: more aggressive infrequent layer detection" into rvc-dev am: 51a1625a 

Change-Id: Ib129989cc509ff51f4f747d9fc8b9f3adb64f58c
parents b4229e90 51a1625a

services/surfaceflinger/Scheduler/LayerHistoryV2.cpp

+1 −1
Original line number Diff line number Diff line
@@ -90,7 +90,7 @@ LayerHistoryV2::~LayerHistoryV2() = default; 
void LayerHistoryV2::registerLayer(Layer* layer, float /*lowRefreshRate*/, float highRefreshRate,

                                   LayerVoteType type) {

    const nsecs_t highRefreshRatePeriod = static_cast<nsecs_t>(1e9f / highRefreshRate);

    auto info = std::make_unique<LayerInfoV2>(highRefreshRatePeriod, type);

    auto info = std::make_unique<LayerInfoV2>(layer->getName(), highRefreshRatePeriod, type);

    std::lock_guard lock(mLock);

    mLayerInfos.emplace_back(layer, std::move(info));

}

services/surfaceflinger/Scheduler/LayerInfoV2.cpp

+19 −36
Original line number Diff line number Diff line
@@ -27,8 +27,10 @@ 


namespace android::scheduler {



LayerInfoV2::LayerInfoV2(nsecs_t highRefreshRatePeriod, LayerHistory::LayerVoteType defaultVote)

      : mHighRefreshRatePeriod(highRefreshRatePeriod),

LayerInfoV2::LayerInfoV2(const std::string& name, nsecs_t highRefreshRatePeriod,

                         LayerHistory::LayerVoteType defaultVote)

      : mName(name),

        mHighRefreshRatePeriod(highRefreshRatePeriod),

        mDefaultVote(defaultVote),

        mLayerVote({defaultVote, 0.0f}) {}
@@ -45,54 +47,31 @@ void LayerInfoV2::setLastPresentTime(nsecs_t lastPresentTime, nsecs_t now) { 
    }

}



bool LayerInfoV2::isFrameTimeValid(const FrameTimeData& frameTime) const {

    return frameTime.queueTime >= std::chrono::duration_cast<std::chrono::nanoseconds>(

                                          mFrameTimeValidSince.time_since_epoch())

                                          .count();

}



bool LayerInfoV2::isFrequent(nsecs_t now) const {

    // Find the first valid frame time

    auto it = mFrameTimes.begin();

    for (; it != mFrameTimes.end(); ++it) {

        if (isFrameTimeValid(*it)) {

            break;

        }

    for (auto it = mFrameTimes.crbegin(); it != mFrameTimes.crend(); ++it) {

        if (now - it->queueTime >= MAX_FREQUENT_LAYER_PERIOD_NS.count()) {

            ALOGV("%s infrequent (last frame is %.2fms ago", mName.c_str(),

                  (now - mFrameTimes.back().queueTime) / 1e6f);

            return false;

        }



    // If we know nothing about this layer we consider it as frequent as it might be the start

    // of an animation.

    if (std::distance(it, mFrameTimes.end()) < FREQUENT_LAYER_WINDOW_SIZE) {

        const auto numFrames = std::distance(mFrameTimes.crbegin(), it + 1);

        if (numFrames >= FREQUENT_LAYER_WINDOW_SIZE) {

            ALOGV("%s frequent (burst of %zu frames", mName.c_str(), numFrames);

            return true;

        }



    // Find the first active frame

    for (; it != mFrameTimes.end(); ++it) {

        if (it->queueTime >= getActiveLayerThreshold(now)) {

            break;

        }

    }



    const auto numFrames = std::distance(it, mFrameTimes.end());

    if (numFrames < FREQUENT_LAYER_WINDOW_SIZE) {

    ALOGV("%s infrequent (not enough frames %zu)", mName.c_str(), mFrameTimes.size());

    return false;

}



    // Layer is considered frequent if the average frame rate is higher than the threshold

    const auto totalTime = mFrameTimes.back().queueTime - it->queueTime;

    return (1e9f * (numFrames - 1)) / totalTime >= MIN_FPS_FOR_FREQUENT_LAYER;

}



bool LayerInfoV2::hasEnoughDataForHeuristic() const {

    // The layer had to publish at least HISTORY_SIZE or HISTORY_TIME of updates

    if (mFrameTimes.size() < 2) {

        return false;

    }



    if (!isFrameTimeValid(mFrameTimes.front())) {

        return false;

    }



    if (mFrameTimes.size() < HISTORY_SIZE &&

        mFrameTimes.back().queueTime - mFrameTimes.front().queueTime < HISTORY_TIME.count()) {

        return false;
@@ -167,18 +146,22 @@ std::optional<float> LayerInfoV2::calculateRefreshRateIfPossible() { 


std::pair<LayerHistory::LayerVoteType, float> LayerInfoV2::getRefreshRate(nsecs_t now) {

    if (mLayerVote.type != LayerHistory::LayerVoteType::Heuristic) {

        ALOGV("%s voted %d ", mName.c_str(), static_cast<int>(mLayerVote.type));

        return {mLayerVote.type, mLayerVote.fps};

    }



    if (!isFrequent(now)) {

        ALOGV("%s is infrequent", mName.c_str());

        return {LayerHistory::LayerVoteType::Min, 0};

    }



    auto refreshRate = calculateRefreshRateIfPossible();

    if (refreshRate.has_value()) {

        ALOGV("%s calculated refresh rate: %.2f", mName.c_str(), refreshRate.value());

        return {LayerHistory::LayerVoteType::Heuristic, refreshRate.value()};

    }



    ALOGV("%s Max (can't resolve refresh rate", mName.c_str());

    return {LayerHistory::LayerVoteType::Max, 0};

}

services/surfaceflinger/Scheduler/LayerInfoV2.h

+5 −9
Original line number Diff line number Diff line
@@ -54,7 +54,8 @@ class LayerInfoV2 { 
    friend class LayerHistoryTestV2;



public:

    LayerInfoV2(nsecs_t highRefreshRatePeriod, LayerHistory::LayerVoteType defaultVote);

    LayerInfoV2(const std::string& name, nsecs_t highRefreshRatePeriod,

                LayerHistory::LayerVoteType defaultVote);



    LayerInfoV2(const LayerInfo&) = delete;

    LayerInfoV2& operator=(const LayerInfoV2&) = delete;
@@ -83,11 +84,7 @@ public: 
    nsecs_t getLastUpdatedTime() const { return mLastUpdatedTime; }



    void clearHistory() {

        // Mark mFrameTimeValidSince to now to ignore all previous frame times.

        // We are not deleting the old frame to keep track of whether we should treat the first

        // buffer as Max as we don't know anything about this layer or Min as this layer is

        // posting infrequent updates.

        mFrameTimeValidSince = std::chrono::steady_clock::now();

        mFrameTimes.clear();

        mLastReportedRefreshRate = 0.0f;

    }
@@ -101,7 +98,8 @@ private: 
    bool isFrequent(nsecs_t now) const;

    bool hasEnoughDataForHeuristic() const;

    std::optional<float> calculateRefreshRateIfPossible();

    bool isFrameTimeValid(const FrameTimeData&) const;



    const std::string mName;



    // Used for sanitizing the heuristic data

    const nsecs_t mHighRefreshRatePeriod;
@@ -118,8 +116,6 @@ private: 
    } mLayerVote;



    std::deque<FrameTimeData> mFrameTimes;

    std::chrono::time_point<std::chrono::steady_clock> mFrameTimeValidSince =

            std::chrono::steady_clock::now();

    static constexpr size_t HISTORY_SIZE = 90;

    static constexpr std::chrono::nanoseconds HISTORY_TIME = 1s;

};

services/surfaceflinger/Scheduler/RefreshRateConfigs.cpp

+11 −6
Original line number Diff line number Diff line
@@ -103,7 +103,7 @@ const RefreshRate& RefreshRateConfigs::getBestRefreshRate( 
    ATRACE_CALL();

    ALOGV("getRefreshRateForContent %zu layers", layers.size());



    *touchConsidered = false;

    if (touchConsidered) *touchConsidered = false;

    std::lock_guard lock(mLock);



    int noVoteLayers = 0;
@@ -131,7 +131,8 @@ const RefreshRate& RefreshRateConfigs::getBestRefreshRate( 
    // Consider the touch event if there are no Explicit* layers. Otherwise wait until after we've

    // selected a refresh rate to see if we should apply touch boost.

    if (touchActive && explicitDefaultVoteLayers == 0 && explicitExactOrMultipleVoteLayers == 0) {

        *touchConsidered = true;

        ALOGV("TouchBoost - choose %s", getMaxRefreshRateByPolicyLocked().getName().c_str());

        if (touchConsidered) *touchConsidered = true;

        return getMaxRefreshRateByPolicyLocked();

    }
@@ -145,6 +146,7 @@ const RefreshRate& RefreshRateConfigs::getBestRefreshRate( 


    // Only if all layers want Min we should return Min

    if (noVoteLayers + minVoteLayers == layers.size()) {

        ALOGV("all layers Min - choose %s", getMinRefreshRateByPolicyLocked().getName().c_str());

        return getMinRefreshRateByPolicyLocked();

    }
@@ -243,9 +245,11 @@ const RefreshRate& RefreshRateConfigs::getBestRefreshRate( 


                    return 1.0f / iter;

                }();

                ALOGV("%s (ExplicitExactOrMultiple, weight %.2f) %.2fHz gives %s score of %.2f",

                      layer.name.c_str(), weight, 1e9f / layerPeriod, scores[i].first->name.c_str(),

                      layerScore);

                ALOGV("%s (%s, weight %.2f) %.2fHz gives %s score of %.2f", layer.name.c_str(),

                      layer.vote == LayerVoteType::ExplicitExactOrMultiple

                              ? "ExplicitExactOrMultiple"

                              : "Heuristic",

                      weight, 1e9f / layerPeriod, scores[i].first->name.c_str(), layerScore);

                scores[i].second += weight * layerScore;

                continue;

            }
@@ -266,7 +270,8 @@ const RefreshRate& RefreshRateConfigs::getBestRefreshRate( 
    const RefreshRate& touchRefreshRate = getMaxRefreshRateByPolicyLocked();

    if (touchActive && explicitDefaultVoteLayers == 0 &&

        bestRefreshRate->fps < touchRefreshRate.fps) {

        *touchConsidered = true;

        if (touchConsidered) *touchConsidered = true;

        ALOGV("TouchBoost - choose %s", touchRefreshRate.getName().c_str());

        return touchRefreshRate;

    }

services/surfaceflinger/Scheduler/Scheduler.cpp

+14 −18
Original line number Diff line number Diff line
@@ -526,7 +526,9 @@ void Scheduler::idleTimerCallback(TimerState state) { 


void Scheduler::touchTimerCallback(TimerState state) {

    const TouchState touch = state == TimerState::Reset ? TouchState::Active : TouchState::Inactive;

    handleTimerStateChanged(&mFeatures.touch, touch, true /* eventOnContentDetection */);

    if (handleTimerStateChanged(&mFeatures.touch, touch, true /* eventOnContentDetection */)) {

        mLayerHistory->clear();

    }

    ATRACE_INT("TouchState", static_cast<int>(touch));

}
@@ -549,18 +551,19 @@ void Scheduler::dump(std::string& result) const { 
}



template <class T>

void Scheduler::handleTimerStateChanged(T* currentState, T newState, bool eventOnContentDetection) {

bool Scheduler::handleTimerStateChanged(T* currentState, T newState, bool eventOnContentDetection) {

    ConfigEvent event = ConfigEvent::None;

    HwcConfigIndexType newConfigId;

    bool touchConsidered = false;

    {

        std::lock_guard<std::mutex> lock(mFeatureStateLock);

        if (*currentState == newState) {

            return;

            return touchConsidered;

        }

        *currentState = newState;

        newConfigId = calculateRefreshRateConfigIndexType();

        newConfigId = calculateRefreshRateConfigIndexType(&touchConsidered);

        if (mFeatures.configId == newConfigId) {

            return;

            return touchConsidered;

        }

        mFeatures.configId = newConfigId;

        if (eventOnContentDetection && !mFeatures.contentRequirements.empty()) {
@@ -569,10 +572,12 @@ void Scheduler::handleTimerStateChanged(T* currentState, T newState, bool eventO 
    }

    const RefreshRate& newRefreshRate = mRefreshRateConfigs.getRefreshRateFromConfigId(newConfigId);

    mSchedulerCallback.changeRefreshRate(newRefreshRate, event);

    return touchConsidered;

}



HwcConfigIndexType Scheduler::calculateRefreshRateConfigIndexType() {

HwcConfigIndexType Scheduler::calculateRefreshRateConfigIndexType(bool* touchConsidered) {

    ATRACE_CALL();

    if (touchConsidered) *touchConsidered = false;



    // If Display Power is not in normal operation we want to be in performance mode. When coming

    // back to normal mode, a grace period is given with DisplayPowerTimer.
@@ -607,18 +612,9 @@ HwcConfigIndexType Scheduler::calculateRefreshRateConfigIndexType() { 
                .getConfigId();

    }



    bool touchConsidered;

    const auto& ret = mRefreshRateConfigs

                              .getBestRefreshRate(mFeatures.contentRequirements, touchActive, idle,

                                                  &touchConsidered)

    return mRefreshRateConfigs

            .getBestRefreshRate(mFeatures.contentRequirements, touchActive, idle, touchConsidered)

            .getConfigId();

    if (touchConsidered) {

        // Clear layer history if refresh rate was selected based on touch to allow

        // the hueristic to pick up with the new rate.

        mLayerHistory->clear();

    }



    return ret;

}



std::optional<HwcConfigIndexType> Scheduler::getPreferredConfigId() {