Merge changes from topic "power.stats HAL" (9d21a5b1) · Commits · e / os / android_hardware_interfaces

power/stats/1.0/IPowerStats.hal

+14 −16

Original line number	Diff line number	Diff line
		@@ -105,9 +105,9 @@ interface IPowerStats {
		* consumption.
		*
		* @return powerEntityInfos List of information on each PowerEntity
		* @return status SUCCESS on success or NOT_SUPPORTED if
		* feature is not enabled or FILESYSTEM_ERROR on filesystem nodes
		* access error.
		* @return status SUCCESS on success, NOT_SUPPORTED if feature is not
		* enabled, FILESYSTEM_ERROR if there was an error accessing the
		* filesystem.
		*/
		getPowerEntityInfo()
		generates(vec<PowerEntityInfo> powerEntityInfos, Status status);
		@@ -123,12 +123,11 @@ interface IPowerStats {
		* information for all PowerEntity(s) pass an empty vector.
		*
		* @return powerEntityStateSpaces PowerEntity state space information for
		* each specified PowerEntity.
		* @return status SUCCESS if powerEntityStateInfos contains state space
		* information for at least one PowerEntity, NOT_SUPPORTED if feature
		* is not enabled, INVALID_INPUT if no requested PowerEntity(s)
		* provide state space information, FILESYSTEM_ERROR if no state space
		* information is returned due to filesystem errors.
		* each specified PowerEntity that provides state space information.
		* @return status SUCCESS on success, NOT_SUPPORTED if feature is not
		* enabled, FILESYSTEM_ERROR if there was an error accessing the
		* filesystem, INVALID_INPUT if any requested PowerEntity(s) do not
		* provide state space information and there was not a filesystem error.
		*/
		getPowerEntityStateInfo(vec<uint32_t> powerEntityIds)
		generates(vec<PowerEntityStateSpace> powerEntityStateSpaces,
		@@ -148,13 +147,12 @@ interface IPowerStats {
		* residency data is requested. PowerEntity name to ID mapping may
		* be queried from getPowerEntityInfo(). To get state residency
		* data for all PowerEntity(s) pass an empty vector.
		* @return stateResidencyResults state residency data for the
		* specified powerEntity(s)
		* @return status SUCCESS if stateResidencyResults contains residency
		* data for at least one PowerEntity, NOT_SUPPORTED if
		* feature is not enabled, INVALID_INPUT if no requested
		* PowerEntity(s) provide state residency data, FILESYSTEM_ERROR
		* if no data is returned due to filesystem errors.
		* @return stateResidencyResults state residency data for each specified
		* PowerEntity that provides state residency data.
		* @return status SUCCESS on success, NOT_SUPPORTED if feature is not
		* enabled, FILESYSTEM_ERROR if there was an error accessing the
		* filesystem, INVALID_INPUT if any requested PowerEntity(s) do not
		* provide state residency data and there was not a filesystem error.
		*/
		getPowerEntityStateResidencyData(vec<uint32_t> powerEntityIds)
		generates(vec<PowerEntityStateResidencyResult> stateResidencyResults,

power/stats/1.0/types.hal

+8 −9

Original line number	Diff line number	Diff line
		@@ -69,19 +69,18 @@ enum PowerEntityType : uint32_t {
		* given PowerEntity.
		*/
		struct PowerEntityInfo {
		/** ID corresponding to the PowerEntity */
		/** Unique ID corresponding to the PowerEntity */
		uint32_t powerEntityId;
		/**
		* Name of the PowerEntity. This is unique and opaque to the
		* Android framework
		*/
		/** Name of the PowerEntity */
		string powerEntityName;
		/** Type of the PowerEntity */
		PowerEntityType type;
		};

		struct PowerEntityStateInfo {
		/** ID corresponding to the state */
		/**
		* ID corresponding to the state. Unique for a given PowerEntityStateSpace
		*/
		uint32_t powerEntityStateId;
		/** Name of the state */
		string powerEntityStateName;
		@@ -93,7 +92,7 @@ struct PowerEntityStateInfo {
		* PowerEntity provides residency data for.
		*/
		struct PowerEntityStateSpace {
		/** ID of the corresponding PowerEntity */
		/** Unique ID of the corresponding PowerEntity */
		uint32_t powerEntityId;

		/** List of states that the PowerEntity may reside in */
		@@ -102,7 +101,7 @@ struct PowerEntityStateSpace {

		/** Contains residency data for a single state */
		struct PowerEntityStateResidencyData {
		/** ID of the corresponding PowerEntityStateInfo */
		/** Unique ID of the corresponding PowerEntityStateInfo */
		uint32_t powerEntityStateId;
		/**
		* Total time in milliseconds that the corresponding PowerEntity resided
		@@ -122,7 +121,7 @@ struct PowerEntityStateResidencyData {
		};

		struct PowerEntityStateResidencyResult {
		/** ID of the corresponding PowerEntity */
		/** Unique ID of the corresponding PowerEntity */
		uint32_t powerEntityId;
		/** Residency data for each state the PowerEntity's state space */
		vec<PowerEntityStateResidencyData> stateResidencyData;

power/stats/1.0/vts/functional/VtsHalPowerStatsV1_0TargetTest.cpp

+275 −1

Original line number	Diff line number	Diff line
		@@ -40,6 +40,9 @@ 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;

		@@ -68,9 +71,281 @@ class PowerStatsHidlTest : public ::testing::VtsHalHidlTargetTestBase {

		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_F(PowerStatsHidlTest, ValidatePowerEntityNames) {
		hidl_vec<PowerEntityInfo> infos;
		getInfos(infos);
		for (auto info : infos) {
		ASSERT_NE(info.powerEntityName, "");
		}
		}

		// Each PowerEntity must have a unique ID
		TEST_F(PowerStatsHidlTest, ValidatePowerEntityIds) {
		hidl_vec<PowerEntityInfo> infos;
		getInfos(infos);

		set<uint32_t> ids;
		for (auto info : infos) {
		ASSERT_TRUE(ids.insert(info.powerEntityId).second);
		}
		}

		// Each PowerEntityStateSpace must have an associated PowerEntityInfo
		TEST_F(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_F(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_F(PowerStatsHidlTest, ValidateStateUniqueIds) {
		hidl_vec<PowerEntityStateSpace> stateSpaces;
		getStateSpaces(stateSpaces);

		for (auto stateSpace : stateSpaces) {
		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_F(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_F(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_F(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_F(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_F(PowerStatsHidlTest, ValidateRailInfo) {
		hidl_vec<RailInfo> rails[2];
		Status s;
		@@ -299,7 +574,6 @@ int main(int argc, char** argv) {
		LOG(INFO) << "Test result = " << status;
		return status;
		}

		} // namespace vts
		} // namespace stats
		} // namespace power