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

Commit 68636061 authored by Ady Abraham's avatar Ady Abraham
Browse files

SF: add render frame rate dimension to RefreshRateSelector 

RefreshRateSelector will now select the render frame rate in addition
to the display refresh rate. This will allow SF (in follow up CL)
to schedule frames based on the render frame rate instead of being
tied to the display refresh rate. The render frame rate is a divisor of
the display refresh rate.

Bug: 257071863
Test: atest libsurfaceflinger_unittest
Change-Id: Id6aaa389b431514fc06190d88d16eb9fcf0ba348
parent d1c4b8ab

services/surfaceflinger/Layer.cpp

+1 −1
Original line number Diff line number Diff line
@@ -1123,7 +1123,7 @@ bool Layer::propagateFrameRateForLayerTree(FrameRate parentFrameRate, bool* tran 


    // We return whether this layer ot its children has a vote. We ignore ExactOrMultiple votes for

    // the same reason we are allowing touch boost for those layers. See

    // RefreshRateSelector::rankRefreshRates for details.

    // RefreshRateSelector::rankFrameRates for details.

    const auto layerVotedWithDefaultCompatibility =

            frameRate.rate.isValid() && frameRate.type == FrameRateCompatibility::Default;

    const auto layerVotedWithNoVote = frameRate.type == FrameRateCompatibility::NoVote;

services/surfaceflinger/Scheduler/RefreshRateSelector.cpp

+268 −148

File changed.

Preview size limit exceeded, changes collapsed.

services/surfaceflinger/Scheduler/RefreshRateSelector.h

+64 −27
Original line number Diff line number Diff line
@@ -24,9 +24,11 @@ 


#include <ftl/concat.h>

#include <ftl/optional.h>

#include <ftl/unit.h>

#include <gui/DisplayEventReceiver.h>



#include <scheduler/Fps.h>

#include <scheduler/FrameRateMode.h>

#include <scheduler/Seamlessness.h>



#include "DisplayHardware/DisplayMode.h"
@@ -58,6 +60,9 @@ public: 
    static constexpr nsecs_t MARGIN_FOR_PERIOD_CALCULATION =

            std::chrono::nanoseconds(800us).count();



    // The lowest Render Frame Rate that will ever be selected

    static constexpr Fps kMinSupportedFrameRate = 20_Hz;



    class Policy {

        static constexpr int kAllowGroupSwitchingDefault = false;
@@ -196,12 +201,12 @@ public: 
        }

    };



    struct ScoredRefreshRate {

        DisplayModePtr modePtr;

    struct ScoredFrameRate {

        FrameRateMode frameRateMode;

        float score = 0.0f;



        bool operator==(const ScoredRefreshRate& other) const {

            return modePtr == other.modePtr && score == other.score;

        bool operator==(const ScoredFrameRate& other) const {

            return frameRateMode == other.frameRateMode && score == other.score;

        }



        static bool scoresEqual(float lhs, float rhs) {
@@ -210,25 +215,25 @@ public: 
        }



        struct DescendingScore {

            bool operator()(const ScoredRefreshRate& lhs, const ScoredRefreshRate& rhs) const {

            bool operator()(const ScoredFrameRate& lhs, const ScoredFrameRate& rhs) const {

                return lhs.score > rhs.score && !scoresEqual(lhs.score, rhs.score);

            }

        };

    };



    using RefreshRateRanking = std::vector<ScoredRefreshRate>;

    using FrameRateRanking = std::vector<ScoredFrameRate>;



    struct RankedRefreshRates {

        RefreshRateRanking ranking; // Ordered by descending score.

    struct RankedFrameRates {

        FrameRateRanking ranking; // Ordered by descending score.

        GlobalSignals consideredSignals;



        bool operator==(const RankedRefreshRates& other) const {

        bool operator==(const RankedFrameRates& other) const {

            return ranking == other.ranking && consideredSignals == other.consideredSignals;

        }

    };



    RankedRefreshRates getRankedRefreshRates(const std::vector<LayerRequirement>&,

                                             GlobalSignals) const EXCLUDES(mLock);

    RankedFrameRates getRankedFrameRates(const std::vector<LayerRequirement>&, GlobalSignals) const

            EXCLUDES(mLock);



    FpsRange getSupportedRefreshRateRange() const EXCLUDES(mLock) {

        std::lock_guard lock(mLock);
@@ -257,9 +262,12 @@ public: 


            // Override the frame rate for an app to a value which is also

            // a display refresh rate

            EnabledForNativeRefreshRates,

            AppOverrideNativeRefreshRates,



            // Override the frame rate for an app to any value

            AppOverride,



            // Override the frame rate for all apps and all values.

            Enabled,



            ftl_last = Enabled
@@ -291,10 +299,13 @@ public: 


    // Returns whether switching modes (refresh rate or resolution) is possible.

    // TODO(b/158780872): Consider HAL support, and skip frame rate detection if the modes only

    // differ in resolution.

    //  differ in resolution. Once Config::FrameRateOverride::Enabled becomes the default,

    //  we can probably remove canSwitch altogether since all devices will be able

    //  to switch to a frame rate divisor.

    bool canSwitch() const EXCLUDES(mLock) {

        std::lock_guard lock(mLock);

        return mDisplayModes.size() > 1;

        return mDisplayModes.size() > 1 ||

                mFrameRateOverrideConfig == Config::FrameRateOverride::Enabled;

    }



    // Class to enumerate options around toggling the kernel timer on and off.
@@ -307,10 +318,14 @@ public: 
    // refresh rates.

    KernelIdleTimerAction getIdleTimerAction() const;



    bool supportsFrameRateOverrideByContent() const {

    bool supportsAppFrameRateOverrideByContent() const {

        return mFrameRateOverrideConfig != Config::FrameRateOverride::Disabled;

    }



    bool supportsFrameRateOverride() const {

        return mFrameRateOverrideConfig == Config::FrameRateOverride::Enabled;

    }



    // Return the display refresh rate divisor to match the layer

    // frame rate, or 0 if the display refresh rate is not a multiple of the

    // layer refresh rate.
@@ -387,8 +402,8 @@ private: 
    // See mActiveModeIt for thread safety.

    DisplayModeIterator getActiveModeItLocked() const REQUIRES(mLock);



    RankedRefreshRates getRankedRefreshRatesLocked(const std::vector<LayerRequirement>&,

                                                   GlobalSignals) const REQUIRES(mLock);

    RankedFrameRates getRankedFrameRatesLocked(const std::vector<LayerRequirement>& layers,

                                               GlobalSignals signals) const REQUIRES(mLock);



    // Returns number of display frames and remainder when dividing the layer refresh period by

    // display refresh period.
@@ -404,18 +419,24 @@ private: 


    struct RefreshRateScoreComparator;



    enum class RefreshRateOrder { Ascending, Descending };

    enum class RefreshRateOrder {

        Ascending,

        Descending,



        ftl_last = Descending

    };



    // Only uses the primary range, not the app request range.

    RefreshRateRanking rankRefreshRates(std::optional<int> anchorGroupOpt, RefreshRateOrder,

                                        std::optional<DisplayModeId> preferredDisplayModeOpt =

                                                std::nullopt) const REQUIRES(mLock);

    FrameRateRanking rankFrameRates(

            std::optional<int> anchorGroupOpt, RefreshRateOrder refreshRateOrder,

            std::optional<DisplayModeId> preferredDisplayModeOpt = std::nullopt) const

            REQUIRES(mLock);



    const Policy* getCurrentPolicyLocked() const REQUIRES(mLock);

    bool isPolicyValidLocked(const Policy& policy) const REQUIRES(mLock);



    // Returns the refresh rate score as a ratio to max refresh rate, which has a score of 1.

    float calculateRefreshRateScoreForFps(Fps refreshRate) const REQUIRES(mLock);

    float calculateDistanceScoreFromMax(Fps refreshRate) const REQUIRES(mLock);

    // calculates a score for a layer. Used to determine the display refresh rate

    // and the frame rate override for certains applications.

    float calculateLayerScoreLocked(const LayerRequirement&, Fps refreshRate,
@@ -436,11 +457,27 @@ private: 
                                                             : mIdleTimerCallbacks->platform;

    }



    bool isNativeRefreshRate(Fps fps) const REQUIRES(mLock) {

        LOG_ALWAYS_FATAL_IF(mConfig.enableFrameRateOverride !=

                                    Config::FrameRateOverride::AppOverrideNativeRefreshRates,

                            "should only be called when "

                            "Config::FrameRateOverride::AppOverrideNativeRefreshRates is used");

        return mAppOverrideNativeRefreshRates.contains(fps);

    }



    std::vector<FrameRateMode> createFrameRateModes(

            std::function<bool(const DisplayMode&)>&& filterModes, const FpsRange&) const

            REQUIRES(mLock);



    // The display modes of the active display. The DisplayModeIterators below are pointers into

    // this container, so must be invalidated whenever the DisplayModes change. The Policy below

    // is also dependent, so must be reset as well.

    DisplayModes mDisplayModes GUARDED_BY(mLock);



    // Set of supported display refresh rates for easy lookup

    // when FrameRateOverride::AppOverrideNativeRefreshRates is in use.

    ftl::SmallMap<Fps, ftl::Unit, 8, FpsApproxEqual> mAppOverrideNativeRefreshRates;



    // Written under mLock exclusively from kMainThreadContext, so reads from kMainThreadContext

    // need not be under mLock.

    DisplayModeIterator mActiveModeIt GUARDED_BY(mLock) GUARDED_BY(kMainThreadContext);
@@ -449,8 +486,8 @@ private: 
    DisplayModeIterator mMaxRefreshRateModeIt GUARDED_BY(mLock);



    // Display modes that satisfy the Policy's ranges, filtered and sorted by refresh rate.

    std::vector<DisplayModeIterator> mPrimaryRefreshRates GUARDED_BY(mLock);

    std::vector<DisplayModeIterator> mAppRequestRefreshRates GUARDED_BY(mLock);

    std::vector<FrameRateMode> mPrimaryFrameRates GUARDED_BY(mLock);

    std::vector<FrameRateMode> mAppRequestFrameRates GUARDED_BY(mLock);



    Policy mDisplayManagerPolicy GUARDED_BY(mLock);

    std::optional<Policy> mOverridePolicy GUARDED_BY(mLock);
@@ -466,11 +503,11 @@ private: 
    const Config mConfig;

    Config::FrameRateOverride mFrameRateOverrideConfig;



    struct GetRankedRefreshRatesCache {

    struct GetRankedFrameRatesCache {

        std::pair<std::vector<LayerRequirement>, GlobalSignals> arguments;

        RankedRefreshRates result;

        RankedFrameRates result;

    };

    mutable std::optional<GetRankedRefreshRatesCache> mGetRankedRefreshRatesCache GUARDED_BY(mLock);

    mutable std::optional<GetRankedFrameRatesCache> mGetRankedFrameRatesCache GUARDED_BY(mLock);



    // Declare mIdleTimer last to ensure its thread joins before the mutex/callbacks are destroyed.

    std::mutex mIdleTimerCallbacksMutex;

services/surfaceflinger/Scheduler/Scheduler.cpp

+14 −11
Original line number Diff line number Diff line
@@ -152,7 +152,7 @@ std::unique_ptr<VSyncSource> Scheduler::makePrimaryDispSyncSource( 


std::optional<Fps> Scheduler::getFrameRateOverride(uid_t uid) const {

    const bool supportsFrameRateOverrideByContent =

            leaderSelectorPtr()->supportsFrameRateOverrideByContent();

            leaderSelectorPtr()->supportsAppFrameRateOverrideByContent();

    return mFrameRateOverrideMappings

            .getFrameRateOverrideForUid(uid, supportsFrameRateOverrideByContent);

}
@@ -268,7 +268,7 @@ void Scheduler::onScreenReleased(ConnectionHandle handle) { 


void Scheduler::onFrameRateOverridesChanged(ConnectionHandle handle, PhysicalDisplayId displayId) {

    const bool supportsFrameRateOverrideByContent =

            leaderSelectorPtr()->supportsFrameRateOverrideByContent();

            leaderSelectorPtr()->supportsAppFrameRateOverrideByContent();



    std::vector<FrameRateOverride> overrides =

            mFrameRateOverrideMappings.getAllFrameRateOverrides(supportsFrameRateOverrideByContent);
@@ -707,7 +707,7 @@ auto Scheduler::applyPolicy(S Policy::*statePtr, T&& newState) -> GlobalSignals 
auto Scheduler::chooseDisplayModes() const -> DisplayModeChoiceMap {

    ATRACE_CALL();



    using RankedRefreshRates = RefreshRateSelector::RankedRefreshRates;

    using RankedRefreshRates = RefreshRateSelector::RankedFrameRates;

    display::PhysicalDisplayVector<RankedRefreshRates> perDisplayRanking;



    // Tallies the score of a refresh rate across `displayCount` displays.
@@ -726,9 +726,10 @@ auto Scheduler::chooseDisplayModes() const -> DisplayModeChoiceMap { 


    for (const auto& [id, selectorPtr] : mRefreshRateSelectors) {

        auto rankedRefreshRates =

                selectorPtr->getRankedRefreshRates(mPolicy.contentRequirements, globalSignals);

                selectorPtr->getRankedFrameRates(mPolicy.contentRequirements, globalSignals);



        for (const auto& [modePtr, score] : rankedRefreshRates.ranking) {

        for (const auto& [frameRateMode, score] : rankedRefreshRates.ranking) {

            const auto& modePtr = frameRateMode.modePtr;

            const auto [it, inserted] = refreshRateTallies.try_emplace(modePtr->getFps(), score);



            if (!inserted) {
@@ -771,16 +772,18 @@ auto Scheduler::chooseDisplayModes() const -> DisplayModeChoiceMap { 


    for (auto& [ranking, signals] : perDisplayRanking) {

        if (!chosenFps) {

            auto& [modePtr, _] = ranking.front();

            const auto& [frameRateMode, _] = ranking.front();

            const auto& modePtr = frameRateMode.modePtr;

            modeChoices.try_emplace(modePtr->getPhysicalDisplayId(),

                                    DisplayModeChoice{std::move(modePtr), signals});

                                    DisplayModeChoice{modePtr, signals});

            continue;

        }



        for (auto& [modePtr, _] : ranking) {

        for (auto& [frameRateMode, _] : ranking) {

            const auto& modePtr = frameRateMode.modePtr;

            if (modePtr->getFps() == *chosenFps) {

                modeChoices.try_emplace(modePtr->getPhysicalDisplayId(),

                                        DisplayModeChoice{std::move(modePtr), signals});

                                        DisplayModeChoice{modePtr, signals});

                break;

            }

        }
@@ -804,10 +807,10 @@ DisplayModePtr Scheduler::getPreferredDisplayMode() { 
    if (mPolicy.mode) {

        const auto ranking =

                leaderSelectorPtr()

                        ->getRankedRefreshRates(mPolicy.contentRequirements, makeGlobalSignals())

                        ->getRankedFrameRates(mPolicy.contentRequirements, makeGlobalSignals())

                        .ranking;



        mPolicy.mode = ranking.front().modePtr;

        mPolicy.mode = ranking.front().frameRateMode.modePtr;

    }

    return mPolicy.mode;

}

services/surfaceflinger/Scheduler/include/scheduler/Fps.h

+13 −0
Original line number Diff line number Diff line
@@ -66,6 +66,7 @@ struct FpsRange { 
    Fps max = Fps::fromValue(std::numeric_limits<float>::max());



    bool includes(Fps) const;

    bool includes(FpsRange) const;

};



struct FpsRanges {
@@ -75,6 +76,8 @@ struct FpsRanges { 
    // the range of frame rates that refers to the render rate, which is

    // the rate that frames are swapped.

    FpsRange render;



    bool valid() const;

};



static_assert(std::is_trivially_copyable_v<Fps>);
@@ -159,6 +162,16 @@ inline bool FpsRange::includes(Fps fps) const { 
    return min <= fps && fps <= max;

}



inline bool FpsRange::includes(FpsRange range) const {

    using namespace fps_approx_ops;

    return min <= range.min && max >= range.max;

}



inline bool FpsRanges::valid() const {

    using fps_approx_ops::operator>=;

    return physical.max >= render.max;

}



struct FpsApproxEqual {

    bool operator()(Fps lhs, Fps rhs) const { return isApproxEqual(lhs, rhs); }

};