rk3588-game
/
android13
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
android13/hardware/interfaces/power/stats/1.0/vts/functional/VtsHalPowerStatsV1_0TargetT...

569 lines
20 KiB
C++
Raw Blame History

/*
* 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 "android.power.stats.vts"
#include <android-base/logging.h>
#include <android/hardware/power/stats/1.0/IPowerStats.h>
#include <fmq/MessageQueue.h>
#include <gtest/gtest.h>
#include <hidl/GtestPrinter.h>
#include <hidl/MQDescriptor.h>
#include <hidl/ServiceManagement.h>
#include <inttypes.h>
#include <algorithm>
#include <random>
#include <thread>
namespace android {
namespace power {
namespace stats {
namespace vts {
namespace {
using android::sp;
using android::hardware::hidl_vec;
using android::hardware::kSynchronizedReadWrite;
using android::hardware::Return;
using android::hardware::Void;
using android::hardware::power::stats::V1_0::EnergyData;
using android::hardware::power::stats::V1_0::IPowerStats;
using android::hardware::power::stats::V1_0::PowerEntityInfo;
using android::hardware::power::stats::V1_0::PowerEntityStateResidencyResult;
using android::hardware::power::stats::V1_0::PowerEntityStateSpace;
using android::hardware::power::stats::V1_0::RailInfo;
using android::hardware::power::stats::V1_0::Status;
} // namespace
typedef hardware::MessageQueue<EnergyData, kSynchronizedReadWrite> MessageQueueSync;
class PowerStatsHidlTest : public ::testing::TestWithParam<std::string> {
public:
virtual void SetUp() override {
service_ = IPowerStats::getService(GetParam());
ASSERT_NE(service_, nullptr);
}
virtual void TearDown() override {}
void getInfos(hidl_vec<PowerEntityInfo>& infos);
void getStateSpaces(hidl_vec<PowerEntityStateSpace>& stateSpaces,
const std::vector<uint32_t>& ids);
void getResidencyResults(hidl_vec<PowerEntityStateResidencyResult>& results,
const std::vector<uint32_t>& ids);
void getRandomIds(std::vector<uint32_t>& ids);
sp<IPowerStats> service_;
};
void PowerStatsHidlTest::getInfos(hidl_vec<PowerEntityInfo>& infos) {
Status status;
Return<void> ret = service_->getPowerEntityInfo([&status, &infos](auto rInfos, auto rStatus) {
status = rStatus;
infos = rInfos;
});
ASSERT_TRUE(ret.isOk());
if (status == Status::SUCCESS) {
ASSERT_NE(infos.size(), 0) << "powerEntityInfos must have entries if supported";
} else {
ASSERT_EQ(status, Status::NOT_SUPPORTED);
ASSERT_EQ(infos.size(), 0);
LOG(INFO) << "getPowerEntityInfo not supported";
}
}
void PowerStatsHidlTest::getStateSpaces(hidl_vec<PowerEntityStateSpace>& stateSpaces,
const std::vector<uint32_t>& ids = {}) {
Status status;
Return<void> ret = service_->getPowerEntityStateInfo(
ids, [&status, &stateSpaces](auto rStateSpaces, auto rStatus) {
status = rStatus;
stateSpaces = rStateSpaces;
});
ASSERT_TRUE(ret.isOk());
if (status == Status::SUCCESS) {
ASSERT_NE(stateSpaces.size(), 0) << "powerEntityStateSpaces must have entries if supported";
} else {
ASSERT_EQ(status, Status::NOT_SUPPORTED);
ASSERT_EQ(stateSpaces.size(), 0);
LOG(INFO) << "getPowerEntityStateInfo not supported";
}
}
void PowerStatsHidlTest::getResidencyResults(hidl_vec<PowerEntityStateResidencyResult>& results,
const std::vector<uint32_t>& ids = {}) {
Status status;
Return<void> ret = service_->getPowerEntityStateResidencyData(
ids, [&status, &results](auto rResults, auto rStatus) {
status = rStatus;
results = rResults;
});
ASSERT_TRUE(ret.isOk());
if (status == Status::SUCCESS) {
ASSERT_NE(results.size(), 0);
} else {
ASSERT_EQ(status, Status::NOT_SUPPORTED);
ASSERT_EQ(results.size(), 0);
LOG(INFO) << "getPowerEntityStateResidencyData not supported";
}
}
void PowerStatsHidlTest::getRandomIds(std::vector<uint32_t>& ids) {
hidl_vec<PowerEntityStateSpace> stateSpaces;
getStateSpaces(stateSpaces);
if (stateSpaces.size() == 0) {
return;
}
for (auto stateSpace : stateSpaces) {
ids.push_back(stateSpace.powerEntityId);
}
unsigned seed = std::chrono::system_clock::now().time_since_epoch().count();
auto gen = std::default_random_engine(seed);
std::uniform_int_distribution<uint32_t> dist(1, stateSpaces.size());
std::shuffle(ids.begin(), ids.end(), gen);
ids.resize(dist(gen));
}
// Each PowerEntity must have a valid name
TEST_P(PowerStatsHidlTest, ValidatePowerEntityNames) {
hidl_vec<PowerEntityInfo> infos;
getInfos(infos);
for (auto info : infos) {
ASSERT_NE(info.powerEntityName, "");
}
}
// Each PowerEntity must have a unique ID
TEST_P(PowerStatsHidlTest, ValidatePowerEntityIds) {
hidl_vec<PowerEntityInfo> infos;
getInfos(infos);
std::set<uint32_t> ids;
for (auto info : infos) {
ASSERT_TRUE(ids.insert(info.powerEntityId).second);
}
}
// Each PowerEntityStateSpace must have an associated PowerEntityInfo
TEST_P(PowerStatsHidlTest, ValidateStateInfoAssociation) {
hidl_vec<PowerEntityInfo> infos;
getInfos(infos);
hidl_vec<PowerEntityStateSpace> stateSpaces;
getStateSpaces(stateSpaces);
std::set<uint32_t> ids;
for (auto info : infos) {
ids.insert(info.powerEntityId);
}
for (auto stateSpace : stateSpaces) {
ASSERT_NE(ids.count(stateSpace.powerEntityId), 0);
}
}
// Each state must have a valid name
TEST_P(PowerStatsHidlTest, ValidateStateNames) {
hidl_vec<PowerEntityStateSpace> stateSpaces;
getStateSpaces(stateSpaces);
for (auto stateSpace : stateSpaces) {
for (auto state : stateSpace.states) {
ASSERT_NE(state.powerEntityStateName, "");
}
}
}
// Each state must have an ID that is unique to the PowerEntityStateSpace
TEST_P(PowerStatsHidlTest, ValidateStateUniqueIds) {
hidl_vec<PowerEntityStateSpace> stateSpaces;
getStateSpaces(stateSpaces);
for (auto stateSpace : stateSpaces) {
std::set<uint32_t> stateIds;
for (auto state : stateSpace.states) {
ASSERT_TRUE(stateIds.insert(state.powerEntityStateId).second);
}
}
}
// getPowerEntityStateInfo must support passing in requested IDs
// Results must contain state space information for all requested IDs
TEST_P(PowerStatsHidlTest, ValidateStateInfoAssociationSelect) {
std::vector<uint32_t> randomIds;
getRandomIds(randomIds);
if (randomIds.empty()) {
return;
}
hidl_vec<PowerEntityStateSpace> stateSpaces;
getStateSpaces(stateSpaces, randomIds);
ASSERT_EQ(stateSpaces.size(), randomIds.size());
std::set<uint32_t> ids;
for (auto id : randomIds) {
ids.insert(id);
}
for (auto stateSpace : stateSpaces) {
ASSERT_NE(ids.count(stateSpace.powerEntityId), 0);
}
}
// Requested state space info must match initially obtained stateinfos
TEST_P(PowerStatsHidlTest, ValidateStateInfoSelect) {
hidl_vec<PowerEntityStateSpace> stateSpaces;
getStateSpaces(stateSpaces);
if (stateSpaces.size() == 0) {
return;
}
std::vector<uint32_t> randomIds;
getRandomIds(randomIds);
ASSERT_FALSE(randomIds.empty());
hidl_vec<PowerEntityStateSpace> selectedStateSpaces;
getStateSpaces(selectedStateSpaces, randomIds);
std::map<uint32_t, PowerEntityStateSpace> stateSpaceMap;
for (auto stateSpace : stateSpaces) {
stateSpaceMap[stateSpace.powerEntityId] = stateSpace;
}
for (auto stateSpace : selectedStateSpaces) {
auto it = stateSpaceMap.find(stateSpace.powerEntityId);
ASSERT_NE(it, stateSpaceMap.end());
ASSERT_EQ(stateSpace.states.size(), it->second.states.size());
for (auto i = 0; i < stateSpace.states.size(); i++) {
ASSERT_EQ(stateSpace.states[i].powerEntityStateId,
it->second.states[i].powerEntityStateId);
ASSERT_EQ(stateSpace.states[i].powerEntityStateName,
it->second.states[i].powerEntityStateName);
}
}
}
// stateResidencyResults must contain results for every PowerEntityStateSpace
// returned by getPowerEntityStateInfo
TEST_P(PowerStatsHidlTest, ValidateResidencyResultsAssociation) {
hidl_vec<PowerEntityStateSpace> stateSpaces;
getStateSpaces(stateSpaces);
hidl_vec<PowerEntityStateResidencyResult> results;
getResidencyResults(results);
std::map<uint32_t, PowerEntityStateResidencyResult> resultsMap;
for (auto result : results) {
resultsMap[result.powerEntityId] = result;
}
for (auto stateSpace : stateSpaces) {
auto it = resultsMap.find(stateSpace.powerEntityId);
ASSERT_NE(it, resultsMap.end());
ASSERT_EQ(stateSpace.states.size(), it->second.stateResidencyData.size());
std::set<uint32_t> stateIds;
for (auto residency : it->second.stateResidencyData) {
stateIds.insert(residency.powerEntityStateId);
}
for (auto state : stateSpace.states) {
ASSERT_NE(stateIds.count(state.powerEntityStateId), 0);
}
}
}
// getPowerEntityStateResidencyData must support passing in requested IDs
// stateResidencyResults must contain results for each PowerEntityStateSpace
// returned by getPowerEntityStateInfo
TEST_P(PowerStatsHidlTest, ValidateResidencyResultsAssociationSelect) {
std::vector<uint32_t> randomIds;
getRandomIds(randomIds);
if (randomIds.empty()) {
return;
}
hidl_vec<PowerEntityStateSpace> stateSpaces;
getStateSpaces(stateSpaces, randomIds);
hidl_vec<PowerEntityStateResidencyResult> results;
getResidencyResults(results, randomIds);
std::map<uint32_t, PowerEntityStateResidencyResult> resultsMap;
for (auto result : results) {
resultsMap[result.powerEntityId] = result;
}
for (auto stateSpace : stateSpaces) {
auto it = resultsMap.find(stateSpace.powerEntityId);
ASSERT_NE(it, resultsMap.end());
ASSERT_EQ(stateSpace.states.size(), it->second.stateResidencyData.size());
std::set<uint32_t> stateIds;
for (auto residency : it->second.stateResidencyData) {
stateIds.insert(residency.powerEntityStateId);
}
for (auto state : stateSpace.states) {
ASSERT_NE(stateIds.count(state.powerEntityStateId), 0);
}
}
}
TEST_P(PowerStatsHidlTest, ValidateRailInfo) {
hidl_vec<RailInfo> rails[2];
Status s;
auto cb = [&rails, &s](hidl_vec<RailInfo> rail_subsys, Status status) {
rails[0] = rail_subsys;
s = status;
};
Return<void> ret = service_->getRailInfo(cb);
EXPECT_TRUE(ret.isOk());
if (s == Status::SUCCESS) {
/* Rails size should be non-zero on SUCCESS*/
ASSERT_NE(rails[0].size(), 0);
/* check if indices returned are unique*/
std::set<uint32_t> ids;
for (auto rail : rails[0]) {
ASSERT_TRUE(ids.insert(rail.index).second);
}
auto cb = [&rails, &s](hidl_vec<RailInfo> rail_subsys, Status status) {
rails[1] = rail_subsys;
s = status;
};
Return<void> ret = service_->getRailInfo(cb);
EXPECT_TRUE(ret.isOk());
ASSERT_EQ(s, Status::SUCCESS);
ASSERT_EQ(rails[0].size(), rails[1].size());
/* check if data returned by two calls to getRailInfo is same*/
for (int i = 0; i < rails[0].size(); i++) {
ASSERT_NE(rails[0][i].railName, "");
ASSERT_NE(rails[0][i].subsysName, "");
int j = 0;
bool match = false;
for (j = 0; j < rails[1].size(); j++) {
if (rails[0][i].index == rails[1][j].index) {
ASSERT_EQ(rails[0][i].railName, rails[1][i].railName);
ASSERT_EQ(rails[0][i].subsysName, rails[1][i].subsysName);
match = true;
break;
}
}
ASSERT_TRUE(match);
}
} else if (s == Status::FILESYSTEM_ERROR) {
ALOGI("ValidateRailInfo returned FILESYSTEM_ERROR");
ASSERT_EQ(rails[0].size(), 0);
} else if (s == Status::NOT_SUPPORTED) {
ALOGI("ValidateRailInfo returned NOT_SUPPORTED");
ASSERT_EQ(rails[0].size(), 0);
} else if (s == Status::INVALID_INPUT) {
ALOGI("ValidateRailInfo returned INVALID_INPUT");
ASSERT_EQ(rails[0].size(), 0);
} else if (s == Status::INSUFFICIENT_RESOURCES) {
ALOGI("ValidateRailInfo returned INSUFFICIENT_RESOURCES");
ASSERT_EQ(rails[0].size(), 0);
}
}
TEST_P(PowerStatsHidlTest, ValidateAllPowerData) {
hidl_vec<EnergyData> measurements[2];
Status s;
auto cb = [&measurements, &s](hidl_vec<EnergyData> measure, Status status) {
measurements[0] = measure;
s = status;
};
Return<void> ret = service_->getEnergyData(hidl_vec<uint32_t>(), cb);
EXPECT_TRUE(ret.isOk());
if (s == Status::SUCCESS) {
/*measurements size should be non-zero on SUCCESS*/
ASSERT_NE(measurements[0].size(), 0);
auto cb = [&measurements, &s](hidl_vec<EnergyData> measure, Status status) {
measurements[1] = measure;
s = status;
};
Return<void> ret = service_->getEnergyData(hidl_vec<uint32_t>(), cb);
EXPECT_TRUE(ret.isOk());
ASSERT_EQ(s, Status::SUCCESS);
/*Both calls should returns same amount of data*/
ASSERT_EQ(measurements[0].size(), measurements[1].size());
/*Check is energy and timestamp are monotonically increasing*/
for (int i = 0; i < measurements[0].size(); i++) {
int j;
for (j = 0; j < measurements[1].size(); j++) {
if (measurements[0][i].index == measurements[1][j].index) {
EXPECT_GE(measurements[1][j].timestamp, measurements[0][i].timestamp);
EXPECT_GE(measurements[1][j].energy, measurements[0][i].energy);
break;
}
}
/*Check is indices for two call match*/
ASSERT_NE(j, measurements[1].size());
}
} else if (s == Status::FILESYSTEM_ERROR) {
ALOGI("ValidateAllPowerData returned FILESYSTEM_ERROR");
ASSERT_EQ(measurements[0].size(), 0);
} else if (s == Status::NOT_SUPPORTED) {
ALOGI("ValidateAllPowerData returned NOT_SUPPORTED");
ASSERT_EQ(measurements[0].size(), 0);
} else if (s == Status::INVALID_INPUT) {
ALOGI("ValidateAllPowerData returned INVALID_INPUT");
ASSERT_EQ(measurements[0].size(), 0);
} else if (s == Status::INSUFFICIENT_RESOURCES) {
ALOGI("ValidateAllPowerData returned INSUFFICIENT_RESOURCES");
ASSERT_EQ(measurements[0].size(), 0);
}
}
TEST_P(PowerStatsHidlTest, ValidateFilteredPowerData) {
hidl_vec<RailInfo> rails;
hidl_vec<EnergyData> measurements;
hidl_vec<uint32_t> indices;
std::string debugString;
Status s;
auto cb = [&rails, &s](hidl_vec<RailInfo> rail_subsys, Status status) {
rails = rail_subsys;
s = status;
};
Return<void> ret = service_->getRailInfo(cb);
EXPECT_TRUE(ret.isOk());
std::time_t seed = std::time(nullptr);
std::srand(seed);
if (s == Status::SUCCESS) {
size_t sz = std::max(1, (int)(std::rand() % rails.size()));
indices.resize(sz);
for (int i = 0; i < sz; i++) {
int j = std::rand() % rails.size();
indices[i] = rails[j].index;
debugString += std::to_string(indices[i]) + ", ";
}
debugString += "\n";
ALOGI("ValidateFilteredPowerData for indices: %s", debugString.c_str());
auto cb = [&measurements, &s](hidl_vec<EnergyData> measure, Status status) {
measurements = measure;
s = status;
};
Return<void> ret = service_->getEnergyData(indices, cb);
EXPECT_TRUE(ret.isOk());
if (s == Status::SUCCESS) {
/* Make sure that all the measurements are returned */
ASSERT_EQ(sz, measurements.size());
for (int i = 0; i < measurements.size(); i++) {
int j;
bool match = false;
/* Check that the measurement belongs to the requested index */
for (j = 0; j < indices.size(); j++) {
if (indices[j] == measurements[i].index) {
match = true;
break;
}
}
ASSERT_TRUE(match);
}
}
} else {
/* size should be zero is stats is NOT SUCCESS */
ASSERT_EQ(rails.size(), 0);
}
}
void readEnergy(sp<IPowerStats> service_, uint32_t timeMs) {
std::unique_ptr<MessageQueueSync> mQueue;
Status s;
uint32_t railsInSample;
uint32_t totalSamples;
auto cb = [&s, &mQueue, &totalSamples, &railsInSample](
const hardware::MQDescriptorSync<EnergyData>& in, uint32_t numSamples,
uint32_t railsPerSample, Status status) {
mQueue.reset(new (std::nothrow) MessageQueueSync(in));
s = status;
totalSamples = numSamples;
railsInSample = railsPerSample;
};
service_->streamEnergyData(timeMs, 10, cb);
if (s == Status::SUCCESS) {
ASSERT_NE(nullptr, mQueue);
ASSERT_TRUE(mQueue->isValid());
bool rc;
int sampleCount = 0;
uint32_t totalQuants = railsInSample * totalSamples;
uint64_t timeout_ns = 10000000000;
if (totalSamples > 0) {
uint32_t batch = std::max(1, (int)((std::rand() % totalSamples) * railsInSample));
ALOGI("Read energy, timsMs: %u, batch: %u", timeMs, batch);
std::vector<EnergyData> data(batch);
while (sampleCount < totalQuants) {
rc = mQueue->readBlocking(&data[0], batch, timeout_ns);
if (rc == false) {
break;
}
sampleCount = sampleCount + batch;
if (batch > totalQuants - sampleCount) {
batch = 1;
}
}
ASSERT_EQ(totalQuants, sampleCount);
}
} else if (s == Status::FILESYSTEM_ERROR) {
ASSERT_FALSE(mQueue->isValid());
ASSERT_EQ(totalSamples, 0);
ASSERT_EQ(railsInSample, 0);
} else if (s == Status::NOT_SUPPORTED) {
ASSERT_FALSE(mQueue->isValid());
ASSERT_EQ(totalSamples, 0);
ASSERT_EQ(railsInSample, 0);
} else if (s == Status::INVALID_INPUT) {
ASSERT_FALSE(mQueue->isValid());
ASSERT_EQ(totalSamples, 0);
ASSERT_EQ(railsInSample, 0);
} else if (s == Status::INSUFFICIENT_RESOURCES) {
ASSERT_FALSE(mQueue->isValid());
ASSERT_EQ(totalSamples, 0);
ASSERT_EQ(railsInSample, 0);
}
}
TEST_P(PowerStatsHidlTest, StreamEnergyData) {
std::time_t seed = std::time(nullptr);
std::srand(seed);
std::thread thread1 = std::thread(readEnergy, service_, std::rand() % 5000);
thread1.join();
}
GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(PowerStatsHidlTest);
INSTANTIATE_TEST_SUITE_P(
PerInstance, PowerStatsHidlTest,
testing::ValuesIn(android::hardware::getAllHalInstanceNames(IPowerStats::descriptor)),
android::hardware::PrintInstanceNameToString);
} // namespace vts
} // namespace stats
} // namespace power
} // namespace android
Reference in New Issue View Git Blame Copy Permalink