Merge changes from topic "rust_caching" into main

* changes:
  aconfig: Cache flag values for rust codegen
  aconfig: Cache flag values for c/c++ codegen

tools/aconfig/src/codegen_cpp.rs

@@ -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();
+        parsed_flags_iter.map(|pf| create_class_element(package, pf, &mut readwrite_count)).collect();
-    let readwrite = class_elements.iter().any(|item| item.readwrite);
+    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,10 +343,13 @@ namespace com::android::aconfig::test {
             }
 
             virtual bool disabled_rw() override {
-                return server_configurable_flags::GetServerConfigurableFlag(
+                if (cache_[0] == -1) {
-                    "aconfig_flags.aconfig_test",
+                    cache_[0] = server_configurable_flags::GetServerConfigurableFlag(
-                    "com.android.aconfig.test.disabled_rw",
+                        "aconfig_flags.aconfig_test",
-                    "false") == "true";
+                        "com.android.aconfig.test.disabled_rw",
+                        "false") == "true";
+                }
+                return cache_[0];
             }
 
             virtual bool enabled_fixed_ro() override {
@@ -345,14 +361,19 @@ namespace com::android::aconfig::test {
             }
 
             virtual bool enabled_rw() override {
-                return server_configurable_flags::GetServerConfigurableFlag(
+                if (cache_[1] == -1) {
-                    "aconfig_flags.aconfig_test",
+                    cache_[1] = server_configurable_flags::GetServerConfigurableFlag(
-                    "com.android.aconfig.test.enabled_rw",
+                        "aconfig_flags.aconfig_test",
-                    "true") == "true";
+                        "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

@@ -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(
+        *CACHED_disabled_rw
-            "aconfig_flags.aconfig_test",
-            "com.android.aconfig.test.disabled_rw",
-            "false") == "true"
     }
 
     /// query flag enabled_fixed_ro
@@ -120,10 +134,7 @@ impl FlagProvider {
 
     /// query flag enabled_rw
     pub fn enabled_rw(&self) -> bool {
-        flags_rust::GetServerConfigurableFlag(
+        *CACHED_enabled_rw
-            "aconfig_flags.aconfig_test",
-            "com.android.aconfig.test.enabled_rw",
-            "true") == "true"
     }
 }
 

tools/aconfig/templates/cpp_exported_header.template

@@ -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

@@ -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) \{
-                "aconfig_flags.{item.device_config_namespace}",
+                cache_[{item.readwrite_idx}] = server_configurable_flags::GetServerConfigurableFlag(
-                "{item.device_config_flag}",
+                    "aconfig_flags.{item.device_config_namespace}",
-                "{item.default_value}") == "true";
+                    "{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

@@ -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(
+        *CACHED_{flag.name}
-          "aconfig_flags.{flag.device_config_namespace}",
-          "{flag.device_config_flag}",
-          "{flag.default_value}") == "true"
     {{ -else- }}
         {flag.default_value}
     {{ -endif }}