| /* |
| * Copyright (C) 2018 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #define LOG_TAG "libpixelpowerstats" |
| |
| #include <memory> |
| #include <string> |
| #include <unordered_map> |
| #include <utility> |
| #include <vector> |
| |
| #include <pixelpowerstats/PowerStats.h> |
| |
| #include <android-base/file.h> |
| #include <android-base/logging.h> |
| #include <android-base/stringprintf.h> |
| |
| #include <inttypes.h> |
| #include <time.h> |
| |
| namespace android { |
| namespace hardware { |
| namespace power { |
| namespace stats { |
| namespace V1_0 { |
| namespace implementation { |
| |
| void PowerStats::setRailDataProvider(std::unique_ptr<IRailDataProvider> dataProvider) { |
| mRailDataProvider = std::move(dataProvider); |
| } |
| |
| Return<void> PowerStats::getRailInfo(getRailInfo_cb _hidl_cb) { |
| if (!mRailDataProvider) { |
| _hidl_cb({}, Status::NOT_SUPPORTED); |
| return Void(); |
| } |
| |
| return mRailDataProvider->getRailInfo(_hidl_cb); |
| } |
| |
| Return<void> PowerStats::getEnergyData(const hidl_vec<uint32_t> &railIndices, |
| getEnergyData_cb _hidl_cb) { |
| if (!mRailDataProvider) { |
| _hidl_cb({}, Status::NOT_SUPPORTED); |
| return Void(); |
| } |
| |
| return mRailDataProvider->getEnergyData(railIndices, _hidl_cb); |
| } |
| |
| Return<void> PowerStats::streamEnergyData(uint32_t timeMs, uint32_t samplingRate, |
| streamEnergyData_cb _hidl_cb) { |
| if (!mRailDataProvider) { |
| _hidl_cb({}, 0, 0, Status::NOT_SUPPORTED); |
| return Void(); |
| } |
| |
| return mRailDataProvider->streamEnergyData(timeMs, samplingRate, _hidl_cb); |
| } |
| |
| uint32_t PowerStats::addPowerEntity(const std::string &name, PowerEntityType type) { |
| uint32_t id = mPowerEntityInfos.size(); |
| mPowerEntityInfos.push_back({id, name, type}); |
| return id; |
| } |
| |
| void PowerStats::addStateResidencyDataProvider(sp<IStateResidencyDataProvider> p) { |
| std::vector<PowerEntityStateSpace> stateSpaces = p->getStateSpaces(); |
| for (auto stateSpace : stateSpaces) { |
| mPowerEntityStateSpaces.emplace(stateSpace.powerEntityId, stateSpace); |
| mStateResidencyDataProviders.emplace(stateSpace.powerEntityId, p); |
| } |
| } |
| |
| Return<void> PowerStats::getPowerEntityInfo(getPowerEntityInfo_cb _hidl_cb) { |
| // If not configured, return NOT_SUPPORTED |
| if (mPowerEntityInfos.empty()) { |
| _hidl_cb({}, Status::NOT_SUPPORTED); |
| return Void(); |
| } |
| |
| _hidl_cb(mPowerEntityInfos, Status::SUCCESS); |
| return Void(); |
| } |
| |
| Return<void> PowerStats::getPowerEntityStateInfo(const hidl_vec<uint32_t> &powerEntityIds, |
| getPowerEntityStateInfo_cb _hidl_cb) { |
| // If not configured, return NOT_SUPPORTED |
| if (mPowerEntityStateSpaces.empty()) { |
| _hidl_cb({}, Status::NOT_SUPPORTED); |
| return Void(); |
| } |
| |
| std::vector<PowerEntityStateSpace> stateSpaces; |
| |
| // If powerEntityIds is empty then return state space info for all entities |
| if (powerEntityIds.size() == 0) { |
| stateSpaces.reserve(mPowerEntityStateSpaces.size()); |
| for (auto i : mPowerEntityStateSpaces) { |
| stateSpaces.emplace_back(i.second); |
| } |
| _hidl_cb(stateSpaces, Status::SUCCESS); |
| return Void(); |
| } |
| |
| // Return state space information only for valid ids |
| auto ret = Status::SUCCESS; |
| stateSpaces.reserve(powerEntityIds.size()); |
| for (const uint32_t id : powerEntityIds) { |
| auto stateSpace = mPowerEntityStateSpaces.find(id); |
| if (stateSpace != mPowerEntityStateSpaces.end()) { |
| stateSpaces.emplace_back(stateSpace->second); |
| } else { |
| ret = Status::INVALID_INPUT; |
| } |
| } |
| |
| _hidl_cb(stateSpaces, ret); |
| return Void(); |
| } |
| |
| Return<void> PowerStats::getPowerEntityStateResidencyData( |
| const hidl_vec<uint32_t> &powerEntityIds, getPowerEntityStateResidencyData_cb _hidl_cb) { |
| // If not configured, return NOT_SUPPORTED |
| if (mStateResidencyDataProviders.empty() || mPowerEntityStateSpaces.empty()) { |
| _hidl_cb({}, Status::NOT_SUPPORTED); |
| return Void(); |
| } |
| |
| // If powerEntityIds is empty then return data for all supported entities |
| if (powerEntityIds.size() == 0) { |
| std::vector<uint32_t> ids; |
| for (auto stateSpace : mPowerEntityStateSpaces) { |
| ids.emplace_back(stateSpace.first); |
| } |
| return getPowerEntityStateResidencyData(ids, _hidl_cb); |
| } |
| |
| std::unordered_map<uint32_t, PowerEntityStateResidencyResult> stateResidencies; |
| std::vector<PowerEntityStateResidencyResult> results; |
| results.reserve(powerEntityIds.size()); |
| |
| // return results for only the given powerEntityIds |
| bool invalidInput = false; |
| bool filesystemError = false; |
| for (auto id : powerEntityIds) { |
| auto dataProvider = mStateResidencyDataProviders.find(id); |
| // skip if the given powerEntityId does not have an associated StateResidencyDataProvider |
| if (dataProvider == mStateResidencyDataProviders.end()) { |
| invalidInput = true; |
| continue; |
| } |
| |
| // get the results if we have not already done so. |
| if (stateResidencies.find(id) == stateResidencies.end()) { |
| if (!dataProvider->second->getResults(stateResidencies)) { |
| filesystemError = true; |
| } |
| } |
| |
| // append results |
| auto stateResidency = stateResidencies.find(id); |
| if (stateResidency != stateResidencies.end()) { |
| results.emplace_back(stateResidency->second); |
| } |
| } |
| |
| auto ret = Status::SUCCESS; |
| if (filesystemError) { |
| ret = Status::FILESYSTEM_ERROR; |
| } else if (invalidInput) { |
| ret = Status::INVALID_INPUT; |
| } |
| |
| _hidl_cb(results, ret); |
| return Void(); |
| } |
| |
| // |
| // Debugging utilities to support printing data via debug() |
| // |
| |
| static uint64_t getTimeElapsedMs(const struct timespec &now, const struct timespec &then) { |
| uint64_t thenMs = then.tv_sec * 1000 + (then.tv_nsec / 1000000); |
| uint64_t nowMs = now.tv_sec * 1000 + (now.tv_nsec / 1000000); |
| return (nowMs - thenMs); |
| } |
| |
| static const char RESIDENCY_HEADER[] = |
| "\n============= PowerStats HAL 1.0 state residencies ==============\n"; |
| static const char RESIDENCY_FOOTER[] = |
| "========== End of PowerStats HAL 1.0 state residencies ==========\n"; |
| |
| static bool DumpResidencyDataToFd( |
| const std::unordered_map<uint32_t, std::string> &entityNames, |
| const std::unordered_map<uint32_t, std::unordered_map<uint32_t, std::string>> stateNames, |
| const hidl_vec<PowerEntityStateResidencyResult> &results, int fd) { |
| std::ostringstream dumpStats; |
| const char *headerFormat = " %14s %14s %16s %15s %17s\n"; |
| const char *dataFormat = |
| " %14s %14s %13" PRIu64 " ms %15" PRIu64 " %14" PRIu64 " ms\n"; |
| |
| dumpStats << RESIDENCY_HEADER; |
| dumpStats << android::base::StringPrintf(headerFormat, "Entity", "State", "Total time", |
| "Total entries", "Last entry tstamp"); |
| |
| for (auto result : results) { |
| for (auto stateResidency : result.stateResidencyData) { |
| dumpStats << android::base::StringPrintf( |
| dataFormat, entityNames.at(result.powerEntityId).c_str(), |
| stateNames.at(result.powerEntityId) |
| .at(stateResidency.powerEntityStateId).c_str(), |
| stateResidency.totalTimeInStateMs, stateResidency.totalStateEntryCount, |
| stateResidency.lastEntryTimestampMs); |
| } |
| } |
| |
| dumpStats << RESIDENCY_FOOTER; |
| |
| return android::base::WriteStringToFd(dumpStats.str(), fd); |
| } |
| |
| static bool DumpResidencyDataDiffToFd( |
| const std::unordered_map<uint32_t, std::string> &entityNames, |
| const std::unordered_map<uint32_t, std::unordered_map<uint32_t, std::string>> stateNames, |
| uint64_t elapsedTimeMs, const hidl_vec<PowerEntityStateResidencyResult> &prevResults, |
| const hidl_vec<PowerEntityStateResidencyResult> &results, int fd) { |
| std::ostringstream dumpStats; |
| const char *headerFormat = " %14s %14s %16s (%14s) %15s (%16s) %17s (%14s)\n"; |
| const char *dataFormatWithDelta = |
| " %14s %14s %13" PRIu64 " ms (%14" PRId64 ") %15" PRIu64 " (%16" PRId64 ")" |
| " %14" PRIu64 " ms (%14" PRId64 ")\n"; |
| const char *dataFormatWithoutDelta = |
| " %14s %14s %13" PRIu64 " ms ( none) %15" PRIu64 " ( none)" |
| " %14" PRIu64 " ms ( none)\n"; |
| |
| dumpStats << RESIDENCY_HEADER; |
| dumpStats << "Elapsed time: " |
| << (elapsedTimeMs == 0 ? "unknown" : std::to_string(elapsedTimeMs)) << " ms\n"; |
| |
| dumpStats << android::base::StringPrintf(headerFormat, "Entity", "State", "Total time", |
| "Delta ", "Total entries", "Delta ", |
| "Last entry tstamp", "Delta "); |
| |
| // Process prevResults into a 2-tier lookup table for easy reference |
| std::unordered_map<uint32_t, std::unordered_map<uint32_t, PowerEntityStateResidencyData>> |
| prevResultsMap; |
| for (auto prevResult : prevResults) { |
| prevResultsMap.emplace(prevResult.powerEntityId, |
| std::unordered_map<uint32_t, PowerEntityStateResidencyData>()); |
| for (auto stateResidency : prevResult.stateResidencyData) { |
| prevResultsMap.at(prevResult.powerEntityId) |
| .emplace(stateResidency.powerEntityStateId, stateResidency); |
| } |
| } |
| |
| // Iterate over the new result data (one "result" per entity) |
| for (auto result : results) { |
| uint32_t entityId = result.powerEntityId; |
| const char *entityName = entityNames.at(entityId).c_str(); |
| |
| // Look up previous result data for the same entity |
| auto prevEntityResultIt = prevResultsMap.find(entityId); |
| |
| // Iterate over individual states within the current entity's new result |
| for (auto stateResidency : result.stateResidencyData) { |
| uint32_t stateId = stateResidency.powerEntityStateId; |
| const char *stateName = stateNames.at(entityId).at(stateId).c_str(); |
| |
| // If a previous result was found for the same entity, see if that |
| // result also contains data for the current state |
| bool prevValueFound = false; |
| if (prevEntityResultIt != prevResultsMap.end()) { |
| auto prevStateResidencyIt = prevEntityResultIt->second.find(stateId); |
| // If a previous result was found for the current entity and state, calculate the |
| // deltas and display them along with new result |
| if (prevStateResidencyIt != prevEntityResultIt->second.end()) { |
| int64_t deltaTotalTime = stateResidency.totalTimeInStateMs - |
| prevStateResidencyIt->second.totalTimeInStateMs; |
| int64_t deltaTotalCount = stateResidency.totalStateEntryCount - |
| prevStateResidencyIt->second.totalStateEntryCount; |
| int64_t deltaTimestamp = stateResidency.lastEntryTimestampMs - |
| prevStateResidencyIt->second.lastEntryTimestampMs; |
| |
| dumpStats << android::base::StringPrintf( |
| dataFormatWithDelta, entityName, stateName, |
| stateResidency.totalTimeInStateMs, deltaTotalTime, |
| stateResidency.totalStateEntryCount, deltaTotalCount, |
| stateResidency.lastEntryTimestampMs, deltaTimestamp); |
| prevValueFound = true; |
| } |
| } |
| |
| // If no previous result was found for the current entity and state, display the new |
| // result without deltas |
| if (!prevValueFound) { |
| dumpStats << android::base::StringPrintf( |
| dataFormatWithoutDelta, entityName, stateName, |
| stateResidency.totalTimeInStateMs, stateResidency.totalStateEntryCount, |
| stateResidency.lastEntryTimestampMs); |
| } |
| } |
| } |
| |
| dumpStats << RESIDENCY_FOOTER; |
| |
| return android::base::WriteStringToFd(dumpStats.str(), fd); |
| } |
| |
| void PowerStats::debugStateResidency(const std::unordered_map<uint32_t, std::string> &entityNames, |
| int fd, bool delta) { |
| static struct timespec prevDataTime; |
| static bool prevDataTimeValid = false; |
| struct timespec dataTime; |
| bool dataTimeValid; |
| |
| // Get power entity state space information |
| Status status; |
| hidl_vec<PowerEntityStateSpace> stateSpaces; |
| getPowerEntityStateInfo({}, [&status, &stateSpaces](auto rStateSpaces, auto rStatus) { |
| status = rStatus; |
| stateSpaces = rStateSpaces; |
| }); |
| if (status != Status::SUCCESS) { |
| LOG(ERROR) << "Error getting state info"; |
| return; |
| } |
| |
| // Construct lookup table of powerEntityId, powerEntityStateId to state name |
| std::unordered_map<uint32_t, std::unordered_map<uint32_t, std::string>> stateNames; |
| for (auto stateSpace : stateSpaces) { |
| stateNames.emplace(stateSpace.powerEntityId, std::unordered_map<uint32_t, std::string>()); |
| auto &entityStateNames = stateNames.at(stateSpace.powerEntityId); |
| for (auto state : stateSpace.states) { |
| entityStateNames.emplace(state.powerEntityStateId, state.powerEntityStateName); |
| } |
| } |
| |
| // Get power entity state residency data |
| hidl_vec<PowerEntityStateResidencyResult> results; |
| getPowerEntityStateResidencyData( |
| {}, [&status, &results, &dataTime, &dataTimeValid](auto rResults, auto rStatus) { |
| status = rStatus; |
| results = rResults; |
| dataTimeValid = (clock_gettime(CLOCK_BOOTTIME, &dataTime) == 0); |
| }); |
| |
| // This implementation of getPowerEntityStateResidencyData supports the |
| // return of partial results if status == FILESYSTEM_ERROR. |
| if (status != Status::SUCCESS) { |
| LOG(ERROR) << "Error getting residency data -- Some results missing"; |
| } |
| |
| if (!delta) { |
| // If no delta argument was supplied, just dump the latest data |
| if (!DumpResidencyDataToFd(entityNames, stateNames, results, fd)) { |
| PLOG(ERROR) << "Failed to dump residency data to fd"; |
| } |
| } else { |
| // If the delta argument was supplied, calculate the elapsed time since the previous |
| // result and then dump the latest data along with elapsed time and deltas |
| static hidl_vec<PowerEntityStateResidencyResult> prevResults; |
| uint64_t elapsedTimeMs = 0; |
| if (dataTimeValid && prevDataTimeValid) { |
| elapsedTimeMs = getTimeElapsedMs(dataTime, prevDataTime); |
| } |
| |
| if (!DumpResidencyDataDiffToFd(entityNames, stateNames, elapsedTimeMs, prevResults, |
| results, fd)) { |
| PLOG(ERROR) << "Failed to dump residency data delta to fd"; |
| } |
| |
| prevResults = results; |
| prevDataTime = dataTime; |
| prevDataTimeValid = dataTimeValid; |
| } |
| } |
| |
| static const char ENERGYDATA_HEADER[] = |
| "\n============= PowerStats HAL 1.0 rail energy data ==============\n"; |
| static const char ENERGYDATA_FOOTER[] = |
| "========== End of PowerStats HAL 1.0 rail energy data ==========\n"; |
| |
| static bool DumpEnergyDataToFd( |
| const std::unordered_map<uint32_t, std::pair<std::string, std::string>> &railNames, |
| const hidl_vec<EnergyData> &energyData, int fd) { |
| std::ostringstream dumpStats; |
| const char *headerFormat = " %14s %18s %18s\n"; |
| const char *dataFormat = " %14s %18s %14.2f mWs\n"; |
| |
| dumpStats << ENERGYDATA_HEADER; |
| dumpStats << android::base::StringPrintf(headerFormat, "Subsys", "Rail", "Cumulative Energy"); |
| |
| for (auto data : energyData) { |
| dumpStats << android::base::StringPrintf(dataFormat, railNames.at(data.index).first.c_str(), |
| railNames.at(data.index).second.c_str(), |
| static_cast<float>(data.energy) / 1000.0); |
| } |
| |
| dumpStats << ENERGYDATA_FOOTER; |
| |
| return android::base::WriteStringToFd(dumpStats.str(), fd); |
| } |
| |
| static bool DumpEnergyDataDiffToFd( |
| const std::unordered_map<uint32_t, std::pair<std::string, std::string>> &railNames, |
| uint64_t elapsedTimeMs, const hidl_vec<EnergyData> &prevEnergyData, |
| const hidl_vec<EnergyData> &energyData, int fd) { |
| std::ostringstream dumpStats; |
| const char *headerFormat = " %14s %18s %18s (%14s)\n"; |
| const char *dataFormatWithDelta = " %14s %18s %14.2f mWs (%14.2f)\n"; |
| const char *dataFormatWithoutDelta = " %14s %18s %14.2f mWs ( none)\n"; |
| |
| dumpStats << ENERGYDATA_HEADER; |
| dumpStats << "Elapsed time: " |
| << (elapsedTimeMs == 0 ? "unknown" : std::to_string(elapsedTimeMs)) << " ms\n"; |
| |
| dumpStats << android::base::StringPrintf(headerFormat, "Subsys", "Rail", "Cumulative Energy", |
| "Delta "); |
| |
| std::unordered_map<uint32_t, uint64_t> prevEnergyDataMap; |
| for (auto data : prevEnergyData) { |
| prevEnergyDataMap.emplace(data.index, data.energy); |
| } |
| |
| for (auto data : energyData) { |
| const char *subsysName = railNames.at(data.index).first.c_str(); |
| const char *railName = railNames.at(data.index).second.c_str(); |
| |
| auto prevEnergyDataIt = prevEnergyDataMap.find(data.index); |
| |
| if (prevEnergyDataIt != prevEnergyDataMap.end()) { |
| int64_t deltaEnergy = data.energy - prevEnergyDataIt->second; |
| |
| dumpStats << android::base::StringPrintf(dataFormatWithDelta, subsysName, railName, |
| static_cast<float>(data.energy) / 1000.0, |
| static_cast<float>(deltaEnergy) / 1000.0); |
| } else { |
| dumpStats << android::base::StringPrintf(dataFormatWithoutDelta, subsysName, railName, |
| static_cast<float>(data.energy) / 1000.0); |
| } |
| } |
| |
| dumpStats << ENERGYDATA_FOOTER; |
| |
| return android::base::WriteStringToFd(dumpStats.str(), fd); |
| } |
| |
| void PowerStats::debugEnergyData(int fd, bool delta) { |
| static struct timespec prevDataTime; |
| static bool prevDataTimeValid = false; |
| struct timespec dataTime; |
| bool dataTimeValid = false; |
| |
| std::unordered_map<uint32_t, std::pair<std::string, std::string>> railNames; |
| getRailInfo([&railNames](auto infos, auto /* status */) { |
| // Don't care about the status. infos will be nonempty if rail energy is supported. |
| for (auto info : infos) { |
| railNames.emplace(info.index, std::make_pair(info.subsysName, info.railName)); |
| } |
| }); |
| if (railNames.empty()) { |
| return; |
| } |
| |
| Status status; |
| hidl_vec<EnergyData> energyData; |
| getEnergyData( |
| {}, [&status, &energyData, &dataTime, &dataTimeValid](auto rEnergyData, auto rStatus) { |
| status = rStatus; |
| energyData = rEnergyData; |
| dataTimeValid = (clock_gettime(CLOCK_BOOTTIME, &dataTime) == 0); |
| }); |
| |
| // getEnergyData returns no results if status != SUCCESS. |
| if (status != Status::SUCCESS) { |
| LOG(ERROR) << "Error getting rail data"; |
| return; |
| } |
| |
| if (!delta) { |
| if (!DumpEnergyDataToFd(railNames, energyData, fd)) { |
| PLOG(ERROR) << "Failed to dump energy data to fd"; |
| } |
| } else { |
| // If the delta argument was supplied, calculate the elapsed time since the previous |
| // result and then dump the latest data along with elapsed time and deltas |
| static hidl_vec<EnergyData> prevEnergyData; |
| uint64_t elapsedTimeMs = 0; |
| if (dataTimeValid && prevDataTimeValid) { |
| elapsedTimeMs = getTimeElapsedMs(dataTime, prevDataTime); |
| } |
| |
| if (!DumpEnergyDataDiffToFd(railNames, elapsedTimeMs, prevEnergyData, energyData, fd)) { |
| PLOG(ERROR) << "Failed to dump energy data delta to fd"; |
| } |
| |
| prevEnergyData = energyData; |
| prevDataTime = dataTime; |
| prevDataTimeValid = dataTimeValid; |
| } |
| } |
| |
| Return<void> PowerStats::debug(const hidl_handle &handle, const hidl_vec<hidl_string> &args) { |
| if (handle == nullptr || handle->numFds < 1) { |
| return Void(); |
| } |
| |
| int fd = handle->data[0]; |
| bool delta = (args.size() == 1) && (args[0] == "delta"); |
| |
| // Get power entity information, which is common across all supported data categories |
| Status status; |
| hidl_vec<PowerEntityInfo> stateInfos; |
| getPowerEntityInfo([&status, &stateInfos](auto rInfos, auto rStatus) { |
| status = rStatus; |
| stateInfos = rInfos; |
| }); |
| if (status != Status::SUCCESS) { |
| LOG(ERROR) << "Error getting power entity info"; |
| return Void(); |
| } |
| |
| // Construct lookup table of powerEntityId to name |
| std::unordered_map<uint32_t, std::string> entityNames; |
| for (auto info : stateInfos) { |
| entityNames.emplace(info.powerEntityId, info.powerEntityName); |
| } |
| |
| // Generate debug output for supported data categories |
| debugStateResidency(entityNames, fd, delta); |
| |
| // Generate debug output for energy data |
| debugEnergyData(fd, delta); |
| |
| fsync(fd); |
| return Void(); |
| } |
| |
| } // namespace implementation |
| } // namespace V1_0 |
| } // namespace stats |
| } // namespace power |
| } // namespace hardware |
| } // namespace android |
