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

Commit e7bdb06b authored by Ady Abraham's avatar Ady Abraham Committed by Android (Google) Code Review
Browse files

Merge changes from topic "sf_flagmanager" into main 

* changes:
  SF: move trunk stable flags to FlagManager
  SF: cleanup FlagManager
  SF: make FlagManager singleton
parents 7002ccad d6d8016d

services/surfaceflinger/DisplayHardware/DisplayMode.h

+2 −3
Original line number Diff line number Diff line
@@ -30,8 +30,8 @@ 
#include <scheduler/Fps.h>



#include "DisplayHardware/Hal.h"

#include "FlagManager.h"

#include "Scheduler/StrongTyping.h"

#include "Utils/FlagUtils.h"



namespace android {
@@ -50,7 +50,6 @@ using DisplayModeId = StrongTyping<ui::DisplayModeId, struct DisplayModeIdTag, C 


using DisplayModes = ftl::SmallMap<DisplayModeId, DisplayModePtr, 3>;

using DisplayModeIterator = DisplayModes::const_iterator;

using namespace com::android::graphics::surfaceflinger;



class DisplayMode {

public:
@@ -140,7 +139,7 @@ public: 
    // Peak refresh rate represents the highest refresh rate that can be used

    // for the presentation.

    Fps getPeakFps() const {

        return flagutils::vrrConfigEnabled() && mVrrConfig

        return FlagManager::getInstance().vrr_config() && mVrrConfig

                ? Fps::fromPeriodNsecs(mVrrConfig->minFrameIntervalNs)

                : mVsyncRate;

    }

services/surfaceflinger/FlagManager.cpp

+122 −53
Original line number Diff line number Diff line
@@ -26,37 +26,21 @@ 
#include <server_configurable_flags/get_flags.h>

#include <cinttypes>



#include <com_android_graphics_surfaceflinger_flags.h>



namespace android {

using namespace com::android::graphics::surfaceflinger;



static constexpr const char* kExperimentNamespace = "surface_flinger_native_boot";

static constexpr const int64_t kDemoFlag = -1;



FlagManager::~FlagManager() = default;

std::unique_ptr<FlagManager> FlagManager::mInstance;

std::once_flag FlagManager::mOnce;



void FlagManager::dump(std::string& result) const {

    base::StringAppendF(&result, "FlagManager values: \n");

    base::StringAppendF(&result, "demo_flag: %" PRId64 "\n", demo_flag());

    base::StringAppendF(&result, "use_adpf_cpu_hint: %s\n", use_adpf_cpu_hint() ? "true" : "false");

    base::StringAppendF(&result, "use_skia_tracing: %s\n", use_skia_tracing() ? "true" : "false");

}

FlagManager::FlagManager(ConstructorTag) {}

FlagManager::~FlagManager() = default;



namespace {

template <typename T>

std::optional<T> doParse(const char* str);



template <>

[[maybe_unused]] std::optional<int32_t> doParse(const char* str) {

    int32_t ret;

    return base::ParseInt(str, &ret) ? std::make_optional(ret) : std::nullopt;

}



template <>

[[maybe_unused]] std::optional<int64_t> doParse(const char* str) {

    int64_t ret;

    return base::ParseInt(str, &ret) ? std::make_optional(ret) : std::nullopt;

}



template <>

[[maybe_unused]] std::optional<bool> doParse(const char* str) {

std::optional<bool> parseBool(const char* str) {

    base::ParseBoolResult parseResult = base::ParseBool(str);

    switch (parseResult) {

        case base::ParseBoolResult::kTrue:
@@ -67,44 +51,129 @@ template <> 
            return std::nullopt;

    }

}



bool getFlagValue(std::function<bool()> getter, std::optional<bool> overrideValue) {

    if (overrideValue.has_value()) {

        return *overrideValue;

    }



    return getter();

}



void dumpFlag(std::string& result, const char* name, std::function<bool()> getter) {

    base::StringAppendF(&result, "%s: %s\n", name, getter() ? "true" : "false");

}



} // namespace



std::string FlagManager::getServerConfigurableFlag(const std::string& experimentFlagName) const {

    return server_configurable_flags::GetServerConfigurableFlag(kExperimentNamespace,

                                                                experimentFlagName, "");

const FlagManager& FlagManager::getInstance() {

    return getMutableInstance();

}



template int32_t FlagManager::getValue<int32_t>(const std::string&, std::optional<int32_t>,

                                                int32_t) const;

template int64_t FlagManager::getValue<int64_t>(const std::string&, std::optional<int64_t>,

                                                int64_t) const;

template bool FlagManager::getValue<bool>(const std::string&, std::optional<bool>, bool) const;

template <typename T>

T FlagManager::getValue(const std::string& experimentFlagName, std::optional<T> systemPropertyOpt,

                        T defaultValue) const {

    // System property takes precedence over the experiment config server value.

    if (systemPropertyOpt.has_value()) {

        return *systemPropertyOpt;

FlagManager& FlagManager::getMutableInstance() {

    std::call_once(mOnce, [&] {

        LOG_ALWAYS_FATAL_IF(mInstance, "Instance already created");

        mInstance = std::make_unique<FlagManager>(ConstructorTag{});

    });



    return *mInstance;

}

    std::string str = getServerConfigurableFlag(experimentFlagName);

    return str.empty() ? defaultValue : doParse<T>(str.c_str()).value_or(defaultValue);



void FlagManager::markBootCompleted() {

    mBootCompleted = true;

}



void FlagManager::setUnitTestMode() {

    mUnitTestMode = true;



    // Also set boot completed as we don't really care about it in unit testing

    mBootCompleted = true;

}



void FlagManager::dump(std::string& result) const {

#define DUMP_FLAG(name) dumpFlag(result, #name, std::bind(&FlagManager::name, this))



    base::StringAppendF(&result, "FlagManager values: \n");

    DUMP_FLAG(use_adpf_cpu_hint);

    DUMP_FLAG(use_skia_tracing);

    DUMP_FLAG(connected_display);

    DUMP_FLAG(dont_skip_on_early);

    DUMP_FLAG(enable_small_area_detection);

    DUMP_FLAG(misc1);

    DUMP_FLAG(late_boot_misc2);

    DUMP_FLAG(vrr_config);



#undef DUMP_FLAG

}



int64_t FlagManager::demo_flag() const {

    std::optional<int64_t> sysPropVal = std::nullopt;

    return getValue("DemoFeature__demo_flag", sysPropVal, kDemoFlag);

std::optional<bool> FlagManager::getBoolProperty(const char* property) const {

    return parseBool(base::GetProperty(property, "").c_str());

}



bool FlagManager::use_adpf_cpu_hint() const {

    std::optional<bool> sysPropVal =

            doParse<bool>(base::GetProperty("debug.sf.enable_adpf_cpu_hint", "").c_str());

    return getValue("AdpfFeature__adpf_cpu_hint", sysPropVal, false);

bool FlagManager::getServerConfigurableFlag(const char* experimentFlagName) const {

    const auto value = server_configurable_flags::GetServerConfigurableFlag(kExperimentNamespace,

                                                                            experimentFlagName, "");

    const auto res = parseBool(value.c_str());

    return res.has_value() && res.value();

}



#define FLAG_MANAGER_LEGACY_SERVER_FLAG(name, syspropOverride, serverFlagName)              \

    bool FlagManager::name() const {                                                        \

        LOG_ALWAYS_FATAL_IF(!mBootCompleted,                                                \

                            "Can't read %s before boot completed as it is server writable", \

                            __func__);                                                      \

        const auto debugOverride = getBoolProperty(syspropOverride);                        \

        if (debugOverride.has_value()) return debugOverride.value();                        \

        return getServerConfigurableFlag(serverFlagName);                                   \

    }



#define FLAG_MANAGER_FLAG_INTERNAL(name, syspropOverride, checkForBootCompleted)                \

    bool FlagManager::name() const {                                                            \

        if (checkForBootCompleted) {                                                            \

            LOG_ALWAYS_FATAL_IF(!mBootCompleted,                                                \

                                "Can't read %s before boot completed as it is server writable", \

                                __func__);                                                      \

        }                                                                                       \

        static std::optional<bool> debugOverride = getBoolProperty(syspropOverride);            \

        static bool value = getFlagValue([] { return flags::name(); }, debugOverride);          \

        if (mUnitTestMode) {                                                                    \

            /*                                                                                  \

             * When testing, we don't want to rely on the cached values stored in the static    \

             * variables.                                                                       \

             */                                                                                 \

            debugOverride = getBoolProperty(syspropOverride);                                   \

            value = getFlagValue([] { return flags::name(); }, debugOverride);                  \

        }                                                                                       \

        return value;                                                                           \

    }



bool FlagManager::use_skia_tracing() const {

    std::optional<bool> sysPropVal =

            doParse<bool>(base::GetProperty(PROPERTY_SKIA_ATRACE_ENABLED, "").c_str());

    return getValue("SkiaTracingFeature__use_skia_tracing", sysPropVal, false);

#define FLAG_MANAGER_SERVER_FLAG(name, syspropOverride) \

    FLAG_MANAGER_FLAG_INTERNAL(name, syspropOverride, true)



#define FLAG_MANAGER_READ_ONLY_FLAG(name, syspropOverride) \

    FLAG_MANAGER_FLAG_INTERNAL(name, syspropOverride, false)



/// Legacy server flags ///

FLAG_MANAGER_LEGACY_SERVER_FLAG(test_flag, "", "")

FLAG_MANAGER_LEGACY_SERVER_FLAG(use_adpf_cpu_hint, "debug.sf.enable_adpf_cpu_hint",

                                "AdpfFeature__adpf_cpu_hint")

FLAG_MANAGER_LEGACY_SERVER_FLAG(use_skia_tracing, PROPERTY_SKIA_ATRACE_ENABLED,

                                "SkiaTracingFeature__use_skia_tracing")



/// Trunk stable readonly flags ///

FLAG_MANAGER_READ_ONLY_FLAG(connected_display, "")

FLAG_MANAGER_READ_ONLY_FLAG(enable_small_area_detection, "")

FLAG_MANAGER_READ_ONLY_FLAG(misc1, "")

FLAG_MANAGER_READ_ONLY_FLAG(vrr_config, "debug.sf.enable_vrr_config")



/// Trunk stable server flags ///

FLAG_MANAGER_SERVER_FLAG(late_boot_misc2, "")



/// Exceptions ///

bool FlagManager::dont_skip_on_early() const {

    // Even though this is a server writable flag, we do call it before boot completed, but that's

    // fine since the decision is done per frame. We can't do caching though.

    return flags::dont_skip_on_early();

}



} // namespace android

services/surfaceflinger/FlagManager.h

+37 −10
Original line number Diff line number Diff line
@@ -17,32 +17,59 @@ 
#pragma once



#include <cstdint>

#include <mutex>

#include <optional>

#include <string>



namespace android {

// Manages flags for SurfaceFlinger, including default values, system properties, and Mendel

// experiment configuration values.

// experiment configuration values. Can be called from any thread.

class FlagManager {

private:

    // Effectively making the constructor private, while allowing std::make_unique to work

    struct ConstructorTag {};



public:

    FlagManager() = default;

    static const FlagManager& getInstance();

    static FlagManager& getMutableInstance();



    FlagManager(ConstructorTag);

    virtual ~FlagManager();



    void markBootCompleted();

    void dump(std::string& result) const;



    int64_t demo_flag() const;

    void setUnitTestMode();



    /// Legacy server flags ///

    bool test_flag() const;

    bool use_adpf_cpu_hint() const;



    bool use_skia_tracing() const;



    /// Trunk stable readonly flags ///

    bool connected_display() const;

    bool enable_small_area_detection() const;

    bool misc1() const;

    bool vrr_config() const;



    /// Trunk stable server flags ///

    bool late_boot_misc2() const;

    bool dont_skip_on_early() const;



protected:

    // overridden for unit tests

    virtual std::optional<bool> getBoolProperty(const char*) const;

    virtual bool getServerConfigurableFlag(const char*) const;



private:

    friend class FlagManagerTest;

    friend class TestableFlagManager;



    FlagManager(const FlagManager&) = delete;



    // Wrapper for mocking in test.

    virtual std::string getServerConfigurableFlag(const std::string& experimentFlagName) const;

    std::atomic_bool mBootCompleted = false;

    std::atomic_bool mUnitTestMode = false;



    template <typename T>

    T getValue(const std::string& experimentFlagName, std::optional<T> systemPropertyOpt,

               T defaultValue) const;

    static std::unique_ptr<FlagManager> mInstance;

    static std::once_flag mOnce;

};

} // namespace android

services/surfaceflinger/RefreshRateOverlay.cpp

+3 −2
Original line number Diff line number Diff line
@@ -17,9 +17,9 @@ 
#include <algorithm>



#include "Client.h"

#include "FlagManager.h"

#include "Layer.h"

#include "RefreshRateOverlay.h"

#include "Utils/FlagUtils.h"



#include <SkSurface.h>
@@ -268,7 +268,8 @@ void RefreshRateOverlay::changeRefreshRate(Fps vsyncRate, Fps renderFps) { 
}



void RefreshRateOverlay::changeRenderRate(Fps renderFps) {

    if (mFeatures.test(Features::RenderRate) && mVsyncRate && flagutils::vrrConfigEnabled()) {

    if (mFeatures.test(Features::RenderRate) && mVsyncRate &&

        FlagManager::getInstance().vrr_config()) {

        mRenderFps = renderFps;

        const auto buffer = getOrCreateBuffers(*mVsyncRate, renderFps)[mFrame];

        createTransaction().setBuffer(mSurfaceControl->get(), buffer).apply();

services/surfaceflinger/Scheduler/EventThread.cpp

+2 −1
Original line number Diff line number Diff line
@@ -45,6 +45,7 @@ 


#include <scheduler/VsyncConfig.h>

#include "DisplayHardware/DisplayMode.h"

#include "FlagManager.h"

#include "FrameTimeline.h"

#include "VSyncDispatch.h"

#include "VSyncTracker.h"
@@ -308,7 +309,7 @@ sp<EventThreadConnection> EventThread::createEventConnection( 
    auto connection = sp<EventThreadConnection>::make(const_cast<EventThread*>(this),

                                                      IPCThreadState::self()->getCallingUid(),

                                                      eventRegistration);

    if (flags::misc1()) {

    if (FlagManager::getInstance().misc1()) {

        const int policy = SCHED_FIFO;

        connection->setMinSchedulerPolicy(policy, sched_get_priority_min(policy));

    }