403 lines
16 KiB
C++
403 lines
16 KiB
C++
/*
|
|
* Copyright (C) 2020 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.
|
|
*/
|
|
|
|
#include "include/PowerStatsAidl.h"
|
|
#include <aidl/android/hardware/power/stats/BnPowerStats.h>
|
|
|
|
#include <android-base/chrono_utils.h>
|
|
#include <android-base/file.h>
|
|
#include <android-base/logging.h>
|
|
#include <android-base/stringprintf.h>
|
|
#include <android-base/strings.h>
|
|
|
|
#include <inttypes.h>
|
|
#include <chrono>
|
|
#include <numeric>
|
|
#include <string>
|
|
|
|
namespace aidl {
|
|
namespace android {
|
|
namespace hardware {
|
|
namespace power {
|
|
namespace stats {
|
|
|
|
void PowerStats::addStateResidencyDataProvider(std::unique_ptr<IStateResidencyDataProvider> p) {
|
|
if (!p) {
|
|
return;
|
|
}
|
|
|
|
int32_t id = mPowerEntityInfos.size();
|
|
auto info = p->getInfo();
|
|
|
|
size_t index = mStateResidencyDataProviders.size();
|
|
mStateResidencyDataProviders.emplace_back(std::move(p));
|
|
|
|
for (const auto &[entityName, states] : info) {
|
|
PowerEntity i = {
|
|
.id = id++,
|
|
.name = entityName,
|
|
.states = states,
|
|
};
|
|
mPowerEntityInfos.emplace_back(i);
|
|
mStateResidencyDataProviderIndex.emplace_back(index);
|
|
}
|
|
}
|
|
|
|
ndk::ScopedAStatus PowerStats::getPowerEntityInfo(std::vector<PowerEntity> *_aidl_return) {
|
|
*_aidl_return = mPowerEntityInfos;
|
|
return ndk::ScopedAStatus::ok();
|
|
}
|
|
|
|
ndk::ScopedAStatus PowerStats::getStateResidency(const std::vector<int32_t> &in_powerEntityIds,
|
|
std::vector<StateResidencyResult> *_aidl_return) {
|
|
if (mPowerEntityInfos.empty()) {
|
|
return ndk::ScopedAStatus::ok();
|
|
}
|
|
|
|
// If in_powerEntityIds is empty then return data for all supported entities
|
|
if (in_powerEntityIds.empty()) {
|
|
std::vector<int32_t> v(mPowerEntityInfos.size());
|
|
std::iota(std::begin(v), std::end(v), 0);
|
|
return getStateResidency(v, _aidl_return);
|
|
}
|
|
|
|
std::unordered_map<std::string, std::vector<StateResidency>> stateResidencies;
|
|
|
|
for (const int32_t id : in_powerEntityIds) {
|
|
// check for invalid ids
|
|
if (id < 0 || id >= mPowerEntityInfos.size()) {
|
|
return ndk::ScopedAStatus(AStatus_fromExceptionCode(EX_ILLEGAL_ARGUMENT));
|
|
}
|
|
|
|
// Check to see if we already have data for the given id
|
|
std::string powerEntityName = mPowerEntityInfos[id].name;
|
|
if (stateResidencies.find(powerEntityName) == stateResidencies.end()) {
|
|
mStateResidencyDataProviders.at(mStateResidencyDataProviderIndex.at(id))
|
|
->getStateResidencies(&stateResidencies);
|
|
}
|
|
|
|
// Append results if we have them
|
|
auto stateResidency = stateResidencies.find(powerEntityName);
|
|
if (stateResidency != stateResidencies.end()) {
|
|
StateResidencyResult res = {
|
|
.id = id,
|
|
.stateResidencyData = stateResidency->second,
|
|
};
|
|
_aidl_return->emplace_back(res);
|
|
} else {
|
|
// Failed to get results for the given id.
|
|
LOG(ERROR) << "Failed to get results for " << powerEntityName;
|
|
}
|
|
}
|
|
|
|
return ndk::ScopedAStatus::ok();
|
|
}
|
|
|
|
void PowerStats::addEnergyConsumer(std::unique_ptr<IEnergyConsumer> p) {
|
|
if (!p) {
|
|
return;
|
|
}
|
|
|
|
std::pair<EnergyConsumerType, std::string> info = p->getInfo();
|
|
|
|
int32_t count = count_if(mEnergyConsumerInfos.begin(), mEnergyConsumerInfos.end(),
|
|
[&info](const EnergyConsumer &c) { return info.first == c.type; });
|
|
int32_t id = mEnergyConsumers.size();
|
|
mEnergyConsumerInfos.emplace_back(
|
|
EnergyConsumer{.id = id, .ordinal = count, .type = info.first, .name = info.second});
|
|
mEnergyConsumers.emplace_back(std::move(p));
|
|
}
|
|
|
|
ndk::ScopedAStatus PowerStats::getEnergyConsumerInfo(std::vector<EnergyConsumer> *_aidl_return) {
|
|
*_aidl_return = mEnergyConsumerInfos;
|
|
return ndk::ScopedAStatus::ok();
|
|
}
|
|
|
|
ndk::ScopedAStatus PowerStats::getEnergyConsumed(const std::vector<int32_t> &in_energyConsumerIds,
|
|
std::vector<EnergyConsumerResult> *_aidl_return) {
|
|
if (mEnergyConsumers.empty()) {
|
|
return ndk::ScopedAStatus::ok();
|
|
}
|
|
|
|
// If in_powerEntityIds is empty then return data for all supported energy consumers
|
|
if (in_energyConsumerIds.empty()) {
|
|
std::vector<int32_t> v(mEnergyConsumerInfos.size());
|
|
std::iota(std::begin(v), std::end(v), 0);
|
|
return getEnergyConsumed(v, _aidl_return);
|
|
}
|
|
|
|
for (const auto id : in_energyConsumerIds) {
|
|
// check for invalid ids
|
|
if (id < 0 || id >= mEnergyConsumers.size()) {
|
|
return ndk::ScopedAStatus(AStatus_fromExceptionCode(EX_ILLEGAL_ARGUMENT));
|
|
}
|
|
|
|
auto resopt = mEnergyConsumers[id]->getEnergyConsumed();
|
|
if (resopt) {
|
|
EnergyConsumerResult res = resopt.value();
|
|
res.id = id;
|
|
_aidl_return->emplace_back(res);
|
|
} else {
|
|
// Failed to get results for the given id.
|
|
LOG(ERROR) << "Failed to get results for " << mEnergyConsumerInfos[id].name;
|
|
}
|
|
}
|
|
|
|
return ndk::ScopedAStatus::ok();
|
|
}
|
|
|
|
void PowerStats::setEnergyMeterDataProvider(std::unique_ptr<IEnergyMeterDataProvider> p) {
|
|
mEnergyMeterDataProvider = std::move(p);
|
|
}
|
|
|
|
ndk::ScopedAStatus PowerStats::getEnergyMeterInfo(std::vector<Channel> *_aidl_return) {
|
|
if (!mEnergyMeterDataProvider) {
|
|
return ndk::ScopedAStatus::ok();
|
|
}
|
|
return mEnergyMeterDataProvider->getEnergyMeterInfo(_aidl_return);
|
|
}
|
|
|
|
ndk::ScopedAStatus PowerStats::readEnergyMeter(const std::vector<int32_t> &in_channelIds,
|
|
std::vector<EnergyMeasurement> *_aidl_return) {
|
|
if (!mEnergyMeterDataProvider) {
|
|
return ndk::ScopedAStatus::ok();
|
|
}
|
|
return mEnergyMeterDataProvider->readEnergyMeter(in_channelIds, _aidl_return);
|
|
}
|
|
|
|
void PowerStats::getEntityStateNames(
|
|
std::unordered_map<int32_t, std::string> *entityNames,
|
|
std::unordered_map<int32_t, std::unordered_map<int32_t, std::string>> *stateNames) {
|
|
std::vector<PowerEntity> infos;
|
|
getPowerEntityInfo(&infos);
|
|
|
|
for (const auto &info : infos) {
|
|
entityNames->emplace(info.id, info.name);
|
|
stateNames->emplace(info.id, std::unordered_map<int32_t, std::string>());
|
|
auto &entityStateNames = stateNames->at(info.id);
|
|
for (const auto &state : info.states) {
|
|
entityStateNames.emplace(state.id, state.name);
|
|
}
|
|
}
|
|
}
|
|
|
|
void PowerStats::getChannelNames(std::unordered_map<int32_t, std::string> *channelNames) {
|
|
std::vector<Channel> infos;
|
|
getEnergyMeterInfo(&infos);
|
|
|
|
for (const auto &info : infos) {
|
|
channelNames->emplace(info.id, "[" + info.name + "]:" + info.subsystem);
|
|
}
|
|
}
|
|
|
|
void PowerStats::dumpEnergyMeter(std::ostringstream &oss, bool delta) {
|
|
const char *headerFormat = " %32s %18s\n";
|
|
const char *dataFormat = " %32s %14.2f mWs\n";
|
|
const char *headerFormatDelta = " %32s %18s (%14s)\n";
|
|
const char *dataFormatDelta = " %32s %14.2f mWs (%14.2f)\n";
|
|
|
|
std::unordered_map<int32_t, std::string> channelNames;
|
|
getChannelNames(&channelNames);
|
|
|
|
oss << "\n============= PowerStats HAL 2.0 energy meter ==============\n";
|
|
|
|
std::vector<EnergyMeasurement> energyData;
|
|
readEnergyMeter({}, &energyData);
|
|
|
|
if (delta) {
|
|
static std::vector<EnergyMeasurement> prevEnergyData;
|
|
::android::base::boot_clock::time_point curTime = ::android::base::boot_clock::now();
|
|
static ::android::base::boot_clock::time_point prevTime = curTime;
|
|
|
|
oss << "Elapsed time: "
|
|
<< std::chrono::duration_cast<std::chrono::milliseconds>(curTime - prevTime).count()
|
|
<< " ms\n";
|
|
|
|
oss << ::android::base::StringPrintf(headerFormatDelta, "Channel", "Cumulative Energy",
|
|
"Delta ");
|
|
|
|
std::unordered_map<int32_t, int64_t> prevEnergyDataMap;
|
|
for (const auto &data : prevEnergyData) {
|
|
prevEnergyDataMap.emplace(data.id, data.energyUWs);
|
|
}
|
|
|
|
for (const auto &data : energyData) {
|
|
auto prevEnergyDataIt = prevEnergyDataMap.find(data.id);
|
|
int64_t deltaEnergy = 0;
|
|
if (prevEnergyDataIt != prevEnergyDataMap.end()) {
|
|
deltaEnergy = data.energyUWs - prevEnergyDataIt->second;
|
|
}
|
|
|
|
oss << ::android::base::StringPrintf(dataFormatDelta, channelNames.at(data.id).c_str(),
|
|
static_cast<float>(data.energyUWs) / 1000.0,
|
|
static_cast<float>(deltaEnergy) / 1000.0);
|
|
}
|
|
|
|
prevEnergyData = energyData;
|
|
prevTime = curTime;
|
|
} else {
|
|
oss << ::android::base::StringPrintf(headerFormat, "Channel", "Cumulative Energy");
|
|
|
|
for (const auto &data : energyData) {
|
|
oss << ::android::base::StringPrintf(dataFormat, channelNames.at(data.id).c_str(),
|
|
static_cast<float>(data.energyUWs) / 1000.0);
|
|
}
|
|
}
|
|
|
|
oss << "========== End of PowerStats HAL 2.0 energy meter ==========\n";
|
|
}
|
|
|
|
void PowerStats::dumpStateResidency(std::ostringstream &oss, bool delta) {
|
|
const char *headerFormat = " %16s %18s %16s %15s %17s\n";
|
|
const char *dataFormat =
|
|
" %16s %18s %13" PRIu64 " ms %15" PRIu64 " %14" PRIu64 " ms\n";
|
|
const char *headerFormatDelta = " %16s %18s %16s (%14s) %15s (%16s) %17s (%14s)\n";
|
|
const char *dataFormatDelta = " %16s %18s %13" PRIu64 " ms (%14" PRId64 ") %15" PRIu64
|
|
" (%16" PRId64 ") %14" PRIu64 " ms (%14" PRId64 ")\n";
|
|
|
|
// Construct maps to entity and state names
|
|
std::unordered_map<int32_t, std::string> entityNames;
|
|
std::unordered_map<int32_t, std::unordered_map<int32_t, std::string>> stateNames;
|
|
getEntityStateNames(&entityNames, &stateNames);
|
|
|
|
oss << "\n============= PowerStats HAL 2.0 state residencies ==============\n";
|
|
|
|
std::vector<StateResidencyResult> results;
|
|
getStateResidency({}, &results);
|
|
|
|
if (delta) {
|
|
static std::vector<StateResidencyResult> prevResults;
|
|
::android::base::boot_clock::time_point curTime = ::android::base::boot_clock::now();
|
|
static ::android::base::boot_clock::time_point prevTime = curTime;
|
|
|
|
oss << "Elapsed time: "
|
|
<< std::chrono::duration_cast<std::chrono::milliseconds>(curTime - prevTime).count()
|
|
<< " ms\n";
|
|
|
|
oss << ::android::base::StringPrintf(headerFormatDelta, "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<int32_t, std::unordered_map<int32_t, StateResidency>> prevResultsMap;
|
|
for (const auto &prevResult : prevResults) {
|
|
prevResultsMap.emplace(prevResult.id, std::unordered_map<int32_t, StateResidency>());
|
|
for (auto stateResidency : prevResult.stateResidencyData) {
|
|
prevResultsMap.at(prevResult.id).emplace(stateResidency.id, stateResidency);
|
|
}
|
|
}
|
|
|
|
// Iterate over the new result data (one "result" per entity)
|
|
for (const auto &result : results) {
|
|
const char *entityName = entityNames.at(result.id).c_str();
|
|
|
|
// Look up previous result data for the same entity
|
|
auto prevEntityResultIt = prevResultsMap.find(result.id);
|
|
|
|
// Iterate over individual states within the current entity's new result
|
|
for (const auto &stateResidency : result.stateResidencyData) {
|
|
const char *stateName = stateNames.at(result.id).at(stateResidency.id).c_str();
|
|
|
|
// If a previous result was found for the same entity, see if that
|
|
// result also contains data for the current state
|
|
int64_t deltaTotalTime = 0;
|
|
int64_t deltaTotalCount = 0;
|
|
int64_t deltaTimestamp = 0;
|
|
if (prevEntityResultIt != prevResultsMap.end()) {
|
|
auto prevStateResidencyIt = prevEntityResultIt->second.find(stateResidency.id);
|
|
// 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()) {
|
|
deltaTotalTime = stateResidency.totalTimeInStateMs -
|
|
prevStateResidencyIt->second.totalTimeInStateMs;
|
|
deltaTotalCount = stateResidency.totalStateEntryCount -
|
|
prevStateResidencyIt->second.totalStateEntryCount;
|
|
deltaTimestamp = stateResidency.lastEntryTimestampMs -
|
|
prevStateResidencyIt->second.lastEntryTimestampMs;
|
|
}
|
|
}
|
|
|
|
oss << ::android::base::StringPrintf(
|
|
dataFormatDelta, entityName, stateName, stateResidency.totalTimeInStateMs,
|
|
deltaTotalTime, stateResidency.totalStateEntryCount, deltaTotalCount,
|
|
stateResidency.lastEntryTimestampMs, deltaTimestamp);
|
|
}
|
|
}
|
|
|
|
prevResults = results;
|
|
prevTime = curTime;
|
|
} else {
|
|
oss << ::android::base::StringPrintf(headerFormat, "Entity", "State", "Total time",
|
|
"Total entries", "Last entry tstamp");
|
|
for (const auto &result : results) {
|
|
for (const auto &stateResidency : result.stateResidencyData) {
|
|
oss << ::android::base::StringPrintf(
|
|
dataFormat, entityNames.at(result.id).c_str(),
|
|
stateNames.at(result.id).at(stateResidency.id).c_str(),
|
|
stateResidency.totalTimeInStateMs, stateResidency.totalStateEntryCount,
|
|
stateResidency.lastEntryTimestampMs);
|
|
}
|
|
}
|
|
}
|
|
|
|
oss << "========== End of PowerStats HAL 2.0 state residencies ==========\n";
|
|
}
|
|
|
|
void PowerStats::dumpEnergyConsumer(std::ostringstream &oss, bool delta) {
|
|
(void)delta;
|
|
|
|
std::vector<EnergyConsumerResult> results;
|
|
getEnergyConsumed({}, &results);
|
|
|
|
oss << "\n============= PowerStats HAL 2.0 energy consumers ==============\n";
|
|
|
|
for (const auto &result : results) {
|
|
oss << ::android::base::StringPrintf("%-12s : %14.2f mWs\n",
|
|
mEnergyConsumers[result.id]->getConsumerName().c_str(),
|
|
static_cast<float>(result.energyUWs) / 1000.0);
|
|
for (auto &attr : result.attribution) {
|
|
oss << ::android::base::StringPrintf(" %10d - %14.2f mWs\n", attr.uid,
|
|
static_cast<float>(attr.energyUWs) / 1000.0);
|
|
}
|
|
}
|
|
|
|
oss << "========== End of PowerStats HAL 2.0 energy consumers ==========\n";
|
|
}
|
|
|
|
binder_status_t PowerStats::dump(int fd, const char **args, uint32_t numArgs) {
|
|
std::ostringstream oss;
|
|
bool delta = (numArgs == 1) && (std::string(args[0]) == "delta");
|
|
|
|
// Generate debug output for state residency
|
|
dumpStateResidency(oss, delta);
|
|
|
|
// Generate debug output for energy consumer
|
|
dumpEnergyConsumer(oss, delta);
|
|
|
|
// Generate debug output energy meter
|
|
dumpEnergyMeter(oss, delta);
|
|
|
|
::android::base::WriteStringToFd(oss.str(), fd);
|
|
fsync(fd);
|
|
return STATUS_OK;
|
|
}
|
|
|
|
} // namespace stats
|
|
} // namespace power
|
|
} // namespace hardware
|
|
} // namespace android
|
|
} // namespace aidl
|