powerstats: timeout mechanism for AoC data provider

Bug: 219630658
Test: dumpsys android.hardware.power.stats.IPowerStats/default
Change-Id: Ib70000580f9515b3cb73968dd190f99ae8af178f
Signed-off-by: Darren Hsu <darrenhsu@google.com>

2 files changed, 93 insertions, 9 deletions

diff --git a/powerstats/AocStateResidencyDataProvider.cpp b/powerstats/AocStateResidencyDataProvider.cpp
index c64496d..b8d40ea 100644
--- a/powerstats/AocStateResidencyDataProvider.cpp
+++ b/powerstats/AocStateResidencyDataProvider.cpp
@@ -17,6 +17,8 @@
 #include "AocStateResidencyDataProvider.h"
 
 #include <android-base/logging.h>
+#include <chrono>
+#include <pthread.h>
 
 namespace aidl {
 namespace android {
@@ -24,12 +26,22 @@ namespace hardware {
 namespace power {
 namespace stats {
 
+struct async_data_t {
+    pthread_cond_t *cond;
+    pthread_mutex_t *lock;
+    std::unordered_map<std::string, std::vector<StateResidency>> *residencies;
+    std::unordered_map<std::string,
+        std::vector<std::unique_ptr<GenericStateResidencyDataProvider>>> *providers;
+};
+
 AocStateResidencyDataProvider::AocStateResidencyDataProvider(std::vector<std::pair<std::string,
-        std::string>> ids, std::vector<std::pair<std::string, std::string>> states) {
+        std::string>> ids, std::vector<std::pair<std::string, std::string>> states,
+        const uint64_t timeoutMillis) {
     // AoC stats are reported in ticks of 244.140625ns. The transform
     // function converts ticks to milliseconds.
     // 1000000 / 244.140625 = 4096.
     static const uint64_t AOC_CLK = 4096;
+    static const uint64_t TIMEOUT_MILLIS = 120;
     std::function<uint64_t(uint64_t)> aocTickToMs = [](uint64_t a) { return a / AOC_CLK; };
     GenericStateResidencyDataProvider::StateResidencyConfig config = {
             .entryCountSupported = true,
@@ -54,13 +66,16 @@ AocStateResidencyDataProvider::AocStateResidencyDataProvider(std::vector<std::pa
             mProviders[id.first].push_back(std::move(sdp));
         }
     }
+    mStateCount = states.size();
+    mTimeoutMillis = timeoutMillis == 0 ? TIMEOUT_MILLIS : timeoutMillis;
 }
 
-bool AocStateResidencyDataProvider::getStateResidencies(
-        std::unordered_map<std::string, std::vector<StateResidency>> *residencies) {
+void *getStateResidenciesAsync(void *arg) {
+    struct async_data_t *async = (struct async_data_t*)arg;
+    const auto *originalContainer = async->residencies;
+
     // States from the same power entity are merged.
-    bool ret = true;
-    for (const auto &providerList : mProviders) {
+    for (const auto &providerList : *async->providers) {
         int32_t stateId = 0;
         std::string curEntity = providerList.first;
         std::vector<StateResidency> stateResidencies;
@@ -68,7 +83,7 @@ bool AocStateResidencyDataProvider::getStateResidencies(
         // Iterate over each provider in the providerList, appending each of the states
         for (const auto &provider : providerList.second) {
             std::unordered_map<std::string, std::vector<StateResidency>> residency;
-            ret &= provider->getStateResidencies(&residency);
+            provider->getStateResidencies(&residency);
 
             // Each provider should only return data for curEntity but checking anyway
             if (residency.find(curEntity) != residency.end()) {
@@ -84,8 +99,74 @@ bool AocStateResidencyDataProvider::getStateResidencies(
             }
         }
 
-        residencies->emplace(curEntity, stateResidencies);
+        if (async->residencies != originalContainer) {
+            /*
+             * When provider->gretStateResidencies() exceeds timeout expiration, the main thread
+             * stops waiting and continue, then the original residency pointer is erased in the
+             * main thread when AocStateResidencyDataProvider::getStateResidencies() ends, and new
+             * container will be created in the async thread later. In this situation, we ignore
+             * delayed residency data and end the async thread.
+             */
+            return 0;
+        }
+
+        async->residencies->emplace(curEntity, stateResidencies);
+    }
+
+    pthread_mutex_lock(async->lock);
+    pthread_cond_signal(async->cond);
+    pthread_mutex_unlock(async->lock);
+
+    return 0;
+}
+
+bool AocStateResidencyDataProvider::getStateResidencies(
+        std::unordered_map<std::string, std::vector<StateResidency>> *residencies) {
+    bool ret = true;
+    int condResult = 0;
+    pthread_t tid;
+    pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
+    pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
+    std::unordered_map<std::string, std::vector<StateResidency>> stateResidencies;
+    struct timespec start, timeout;
+    struct async_data_t async = {
+        .cond = &cond,
+        .lock = &lock,
+        .residencies = &stateResidencies,
+        .providers = &mProviders
+    };
+
+    pthread_create(&tid, NULL, &getStateResidenciesAsync, (void*)&async);
+
+    clock_gettime(CLOCK_REALTIME, &start);
+
+    uint64_t expirationMillis = mTimeoutMillis * mStateCount;
+    timeout.tv_sec = start.tv_sec + expirationMillis / 1000;
+    uint64_t nsec = start.tv_nsec + (expirationMillis % 1000) * 1000000;
+    if (nsec < 1000000000) {
+        timeout.tv_nsec = nsec;
+    } else {
+        timeout.tv_sec += 1;
+        timeout.tv_nsec = nsec - 1000000000;
     }
+
+    pthread_mutex_lock(&lock);
+    condResult = pthread_cond_timedwait(&cond, &lock, &timeout);
+    pthread_mutex_unlock(&lock);
+
+    if (condResult != 0) {
+        if (condResult == ETIMEDOUT) {
+            LOG(WARNING) << __func__ << " latency for AoC timeout: " << expirationMillis << " ms";
+        } else {
+            LOG(ERROR) << "Failed to wait for the condition variable: " << condResult;
+        }
+        ret = false;
+    } else {
+        for (const auto &residency : stateResidencies) {
+            residencies->emplace(residency.first, residency.second);
+        }
+    }
+
     return ret;
 }
 
diff --git a/powerstats/include/AocStateResidencyDataProvider.h b/powerstats/include/AocStateResidencyDataProvider.h
index 5008912..150f335 100644
--- a/powerstats/include/AocStateResidencyDataProvider.h
+++ b/powerstats/include/AocStateResidencyDataProvider.h
@@ -27,7 +27,8 @@ namespace stats {
 class AocStateResidencyDataProvider : public PowerStats::IStateResidencyDataProvider {
   public:
     AocStateResidencyDataProvider(std::vector<std::pair<std::string, std::string>> ids,
-                                  std::vector<std::pair<std::string, std::string>> states);
+                                  std::vector<std::pair<std::string, std::string>> states,
+                                  const uint64_t timeoutMillis);
     ~AocStateResidencyDataProvider() = default;
     bool getStateResidencies(
         std::unordered_map<std::string, std::vector<StateResidency>> *residencies) override;
@@ -36,10 +37,12 @@ class AocStateResidencyDataProvider : public PowerStats::IStateResidencyDataProv
   private:
     std::unordered_map<std::string /* entity name */,
         std::vector<std::unique_ptr<GenericStateResidencyDataProvider>> /* providers */> mProviders;
+    int32_t mStateCount;
+    uint64_t mTimeoutMillis;
 };
 
 }  // namespace stats
 }  // namespace power
 }  // namespace hardware
 }  // namespace android
-}  // namespace aidl
\ No newline at end of file
+}  // namespace aidl