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

Commit 05585a9f authored by Dennis Shen's avatar Dennis Shen Committed by Gerrit Code Review
Browse files

Merge changes from topic "rust_caching" into main 

* changes:
  aconfig: Cache flag values for rust codegen
  aconfig: Cache flag values for c/c++ codegen
parents 092c6b68 737b8e30

tools/aconfig/src/codegen_cpp.rs

+32 −11
Original line number Diff line number Diff line
@@ -31,9 +31,10 @@ pub fn generate_cpp_code<'a, I>( 
where

    I: Iterator<Item = &'a ProtoParsedFlag>,

{

    let mut readwrite_count = 0;

    let class_elements: Vec<ClassElement> =

        parsed_flags_iter.map(|pf| create_class_element(package, pf)).collect();

    let readwrite = class_elements.iter().any(|item| item.readwrite);

        parsed_flags_iter.map(|pf| create_class_element(package, pf, &mut readwrite_count)).collect();

    let readwrite = readwrite_count > 0;

    let has_fixed_read_only = class_elements.iter().any(|item| item.is_fixed_read_only);

    let header = package.replace('.', "_");

    let package_macro = header.to_uppercase();
@@ -46,6 +47,7 @@ where 
        package,

        has_fixed_read_only,

        readwrite,

        readwrite_count,

        for_test: codegen_mode == CodegenMode::Test,

        class_elements,

    };
@@ -88,12 +90,14 @@ pub struct Context<'a> { 
    pub package: &'a str,

    pub has_fixed_read_only: bool,

    pub readwrite: bool,

    pub readwrite_count: i32,

    pub for_test: bool,

    pub class_elements: Vec<ClassElement>,

}



#[derive(Serialize)]

pub struct ClassElement {

    pub readwrite_idx: i32,

    pub readwrite: bool,

    pub is_fixed_read_only: bool,

    pub default_value: String,
@@ -103,8 +107,13 @@ pub struct ClassElement { 
    pub device_config_flag: String,

}



fn create_class_element(package: &str, pf: &ProtoParsedFlag) -> ClassElement {

fn create_class_element(package: &str, pf: &ProtoParsedFlag, rw_count: &mut i32) -> ClassElement {

    ClassElement {

        readwrite_idx: if pf.permission() == ProtoFlagPermission::READ_WRITE {

            let index = *rw_count; *rw_count += 1; index

        } else {

            -1

        },

        readwrite: pf.permission() == ProtoFlagPermission::READ_WRITE,

        is_fixed_read_only: pf.is_fixed_read_only(),

        default_value: if pf.state() == ProtoFlagState::ENABLED {
@@ -139,8 +148,12 @@ mod tests { 
#ifdef __cplusplus



#include <memory>

#include <vector>



namespace com::android::aconfig::test {



extern std::vector<int8_t> cache_;



class flag_provider_interface {

public:

    virtual ~flag_provider_interface() = default;
@@ -330,11 +343,14 @@ namespace com::android::aconfig::test { 
            }



            virtual bool disabled_rw() override {

                return server_configurable_flags::GetServerConfigurableFlag(

                if (cache_[0] == -1) {

                    cache_[0] = server_configurable_flags::GetServerConfigurableFlag(

                        "aconfig_flags.aconfig_test",

                        "com.android.aconfig.test.disabled_rw",

                        "false") == "true";

                }

                return cache_[0];

            }



            virtual bool enabled_fixed_ro() override {

                return COM_ANDROID_ACONFIG_TEST_ENABLED_FIXED_RO;
@@ -345,14 +361,19 @@ namespace com::android::aconfig::test { 
            }



            virtual bool enabled_rw() override {

                return server_configurable_flags::GetServerConfigurableFlag(

                if (cache_[1] == -1) {

                    cache_[1] = server_configurable_flags::GetServerConfigurableFlag(

                        "aconfig_flags.aconfig_test",

                        "com.android.aconfig.test.enabled_rw",

                        "true") == "true";

                }

                return cache_[1];

            }



    };



    std::vector<int8_t> cache_ = std::vector<int8_t>(2, -1);



    std::unique_ptr<flag_provider_interface> provider_ =

        std::make_unique<flag_provider>();

}

tools/aconfig/src/codegen_rust.rs

+19 −8
Original line number Diff line number Diff line
@@ -32,10 +32,12 @@ where 
{

    let template_flags: Vec<TemplateParsedFlag> =

        parsed_flags_iter.map(|pf| TemplateParsedFlag::new(package, pf)).collect();

    let has_readwrite = template_flags.iter().any(|item| item.readwrite);

    let context = TemplateContext {

        package: package.to_string(),

        template_flags,

        modules: package.split('.').map(|s| s.to_string()).collect::<Vec<_>>(),

        has_readwrite,

    };

    let mut template = TinyTemplate::new();

    template.add_template(
@@ -55,6 +57,7 @@ struct TemplateContext { 
    pub package: String,

    pub template_flags: Vec<TemplateParsedFlag>,

    pub modules: Vec<String>,

    pub has_readwrite: bool,

}



#[derive(Serialize)]
@@ -94,6 +97,20 @@ mod tests { 
/// flag provider

pub struct FlagProvider;



lazy_static::lazy_static! {

    /// flag value cache for disabled_rw

    static ref CACHED_disabled_rw: bool = flags_rust::GetServerConfigurableFlag(

        "aconfig_flags.aconfig_test",

        "com.android.aconfig.test.disabled_rw",

        "false") == "true";



    /// flag value cache for enabled_rw

    static ref CACHED_enabled_rw: bool = flags_rust::GetServerConfigurableFlag(

        "aconfig_flags.aconfig_test",

        "com.android.aconfig.test.enabled_rw",

        "true") == "true";

}



impl FlagProvider {

    /// query flag disabled_ro

    pub fn disabled_ro(&self) -> bool {
@@ -102,10 +119,7 @@ impl FlagProvider { 


    /// query flag disabled_rw

    pub fn disabled_rw(&self) -> bool {

        flags_rust::GetServerConfigurableFlag(

            "aconfig_flags.aconfig_test",

            "com.android.aconfig.test.disabled_rw",

            "false") == "true"

        *CACHED_disabled_rw

    }



    /// query flag enabled_fixed_ro
@@ -120,10 +134,7 @@ impl FlagProvider { 


    /// query flag enabled_rw

    pub fn enabled_rw(&self) -> bool {

        flags_rust::GetServerConfigurableFlag(

            "aconfig_flags.aconfig_test",

            "com.android.aconfig.test.enabled_rw",

            "true") == "true"

        *CACHED_enabled_rw

    }

}

tools/aconfig/templates/cpp_exported_header.template

+7 −1
Original line number Diff line number Diff line
@@ -18,10 +18,16 @@ 
#ifdef __cplusplus



#include <memory>



{{ if not for_test- }}

#include <vector>

{{ -endif }}



namespace {cpp_namespace} \{



{{ if not for_test- }}

extern std::vector<int8_t> cache_;

{{ -endif }}



class flag_provider_interface \{

public:

    virtual ~flag_provider_interface() = default;

tools/aconfig/templates/cpp_source_file.template

+9 −5
Original line number Diff line number Diff line
@@ -53,10 +53,13 @@ namespace {cpp_namespace} \{ 
        {{ for item in class_elements}}

        virtual bool {item.flag_name}() override \{

            {{ if item.readwrite- }}

            return server_configurable_flags::GetServerConfigurableFlag(

            if (cache_[{item.readwrite_idx}] == -1) \{

                cache_[{item.readwrite_idx}] = server_configurable_flags::GetServerConfigurableFlag(

                    "aconfig_flags.{item.device_config_namespace}",

                    "{item.device_config_flag}",

                    "{item.default_value}") == "true";

            }

            return cache_[{item.readwrite_idx}];

            {{ -else- }}

            {{ if item.is_fixed_read_only }}

            return {package_macro}_{item.flag_macro};
@@ -68,13 +71,14 @@ namespace {cpp_namespace} \{ 
        {{ endfor }}

    };



    std::vector<int8_t> cache_ = std::vector<int8_t>({readwrite_count}, -1);



{{ -endif }}





std::unique_ptr<flag_provider_interface> provider_ =

    std::make_unique<flag_provider>();





}

tools/aconfig/templates/rust_prod.template

+15 −4
Original line number Diff line number Diff line
@@ -3,16 +3,27 @@ 
/// flag provider

pub struct FlagProvider;



{{ if has_readwrite - }}

lazy_static::lazy_static! \{

    {{ for flag in template_flags }}

    {{ if flag.readwrite -}}

    /// flag value cache for {flag.name}

    static ref CACHED_{flag.name}: bool = flags_rust::GetServerConfigurableFlag(

        "aconfig_flags.{flag.device_config_namespace}",

        "{flag.device_config_flag}",

        "{flag.default_value}") == "true";

    {{ -endif }}

    {{ endfor }}

}

{{ -endif }}



impl FlagProvider \{



    {{ for flag in template_flags }}

    /// query flag {flag.name}

    pub fn {flag.name}(&self) -> bool \{

    {{ if flag.readwrite -}}

        flags_rust::GetServerConfigurableFlag(

          "aconfig_flags.{flag.device_config_namespace}",

          "{flag.device_config_flag}",

          "{flag.default_value}") == "true"

        *CACHED_{flag.name}

    {{ -else- }}

        {flag.default_value}

    {{ -endif }}