/*
* 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