powerstats/AidlStateResidencyDataProvider.cpp - platform/hardware/google/pixel - Git at Google

 /*
  * Copyright (C) 2019 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 <android-base/logging.h>
 #include <android-base/stringprintf.h>
 #include <binder/IPCThreadState.h>
 #include <binder/IServiceManager.h>
 #include <binder/ProcessState.h>
 #include <pixelpowerstats/AidlStateResidencyDataProvider.h>
 #include <time.h>
 using android::base::StringPrintf;

 static const uint64_t MAX_LATENCY_US = 2000;

 namespace android {
 namespace hardware {
 namespace google {
 namespace pixel {
 namespace powerstats {

 void AidlStateResidencyDataProvider::addEntity(uint32_t id, std::string entityName,
                                                std::vector<std::string> stateNames) {
     std::lock_guard<std::mutex> lock(mLock);
     // Create a new entry in the map of power entities
     mEntityInfos.emplace(entityName, StateSpace{.powerEntityId = id, .stateInfos = {}});

     // Create an entry for each state and assign an Id.
     uint32_t stateId = 0;
     auto &stateInfos = mEntityInfos.at(entityName).stateInfos;
     for (auto stateName : stateNames) {
         stateInfos.emplace(stateName, stateId++);
     }
 }

 binderStatus AidlStateResidencyDataProvider::unregisterCallbackInternal(
         const sp<IBinder> &callback) {
     if (callback == nullptr) {
         // Callback pointer is null. Return an error.
         return binderStatus::fromExceptionCode(binderStatus::EX_NULL_POINTER, "callback is null");
     }

     bool removed = false;
     std::lock_guard<std::mutex> lock(mLock);

     // Iterate over collection of callbacks and remove the one that matches
     for (auto it = mCallbacks.begin(); it != mCallbacks.end();) {
         if (asBinder(it->second) == callback) {
             LOG(INFO) << "Unregistering callback for " << it->first;
             it = mCallbacks.erase(it);
             removed = true;
         } else {
             it++;
         }
     }
     (void)callback->unlinkToDeath(this);  // ignore errors
     return removed ? binderStatus::ok()
                    : binderStatus::fromExceptionCode(binderStatus::EX_ILLEGAL_ARGUMENT,
                             "callback not found");
 }

 void AidlStateResidencyDataProvider::binderDied(const wp<IBinder> &who) {
     binderStatus status = unregisterCallbackInternal(who.promote());
     if (!status.isOk()) {
         LOG(ERROR) << __func__ << "failed to unregister callback " << status.toString8();
     }
 }

 binderStatus AidlStateResidencyDataProvider::unregisterCallback(
         const sp<IPixelPowerStatsCallback> &callback) {
     return unregisterCallbackInternal(asBinder(callback));
 }

 binderStatus AidlStateResidencyDataProvider::registerCallback(
         const std::string &entityName, const sp<IPixelPowerStatsCallback> &callback) {
     LOG(INFO) << "Registering callback for " << entityName;
     if (callback == nullptr) {
         // Callback pointer is null. Return an error.
         LOG(ERROR) << __func__ << ": "
                    << "Invalid callback. Callback is null";
         return binderStatus::fromExceptionCode(
                 binderStatus::EX_NULL_POINTER, "Invalid callback. Callback is null");
     }

     std::lock_guard<std::mutex> lock(mLock);
     if (mEntityInfos.find(entityName) == mEntityInfos.end()) {
         // Could not find the entity associated with this callback. Return an error.
         LOG(ERROR) << __func__ << ": "
                    << "Invalid entity";
         return binderStatus::fromExceptionCode(binderStatus::EX_ILLEGAL_ARGUMENT, "Invalid entity");
     }

     mCallbacks.emplace(entityName, callback);

     // death recipient
     auto linkRet = asBinder(callback)->linkToDeath(this, 0u /* cookie */);
     if (linkRet != android::OK) {
         LOG(WARNING) << __func__ << "Cannot link to death: " << linkRet;
         // ignore the error
     }

     return binderStatus::ok();
 }

 static binderStatus getStatsTimed(
         const std::pair<std::string, sp<IPixelPowerStatsCallback>> &cb,
         std::vector<android::vendor::powerstats::StateResidencyData> &stats) {
     struct timespec then;
     struct timespec now;

     clock_gettime(CLOCK_BOOTTIME, &then);
     binderStatus status = cb.second->getStats(&stats);
     clock_gettime(CLOCK_BOOTTIME, &now);

     uint64_t time_elapsed_us =
             ((now.tv_sec - then.tv_sec) * 1000000) + ((now.tv_nsec - then.tv_nsec) / 1000);
     if (time_elapsed_us > MAX_LATENCY_US) {
         LOG(WARNING) << "getStats for " << cb.first << " exceeded time allowed: " << time_elapsed_us
                      << "us";
     }
     return status;
 }

 bool AidlStateResidencyDataProvider::buildResult(
         std::string entityName,
         const std::vector<android::vendor::powerstats::StateResidencyData> &stats,
         PowerEntityStateResidencyResult &result) {
     auto infosEntry = mEntityInfos.find(entityName);
     if (infosEntry == mEntityInfos.end()) {
         LOG(ERROR) << __func__ << " failed: " << entityName << " is not registered.";
         return false;
     }
     auto stateSpace = infosEntry->second;
     result.powerEntityId = stateSpace.powerEntityId;
     size_t numStates = stateSpace.stateInfos.size();
     result.stateResidencyData.resize(numStates);
     size_t numStatesFound = 0;
     for (auto stat = stats.begin(); (numStatesFound < numStates) && (stat != stats.end()); stat++) {
         auto stateInfosEntry = stateSpace.stateInfos.find(stat->state);

         if (stateInfosEntry != stateSpace.stateInfos.end()) {
             PowerEntityStateResidencyData &data = result.stateResidencyData[numStatesFound++];
             data.powerEntityStateId = stateInfosEntry->second;
             data.totalTimeInStateMs = static_cast<uint64_t>(stat->totalTimeInStateMs);
             data.totalStateEntryCount = static_cast<uint64_t>(stat->totalStateEntryCount);
             data.lastEntryTimestampMs = static_cast<uint64_t>(stat->lastEntryTimestampMs);
         } else {
             LOG(WARNING) << "getStats for " << entityName << " returned data for unknown state "
                          << stat->state;
         }
     }

     return (numStatesFound == numStates);
 }

 bool AidlStateResidencyDataProvider::getResults(
         std::unordered_map<uint32_t, PowerEntityStateResidencyResult> &results) {
     std::lock_guard<std::mutex> lock(mLock);
     // TODO (b/126260512): return cached results if time elapsed isn't large
     size_t numResultsFound = 0;
     size_t numResults = mEntityInfos.size();
     for (auto cb : mCallbacks) {
         std::vector<android::vendor::powerstats::StateResidencyData> stats;

         // Get stats for the current callback
         binderStatus status = getStatsTimed(cb, stats);
         if (!status.isOk()) {
             LOG(ERROR) << "getStats for " << cb.first << " failed: " << status.toString8();
         }

         PowerEntityStateResidencyResult result;
         if (buildResult(cb.first, stats, result)) {
             results.emplace(result.powerEntityId, result);
             numResultsFound++;
         } else {
             LOG(ERROR) << "State residency data missing for " << cb.first;
         }
     }
     bool ret = (numResultsFound == numResults);

     // TODO (b/126260512): Cache results of the call, the return value, and the timestamp.
     return ret;
 }

 std::vector<PowerEntityStateSpace> AidlStateResidencyDataProvider::getStateSpaces() {
     std::lock_guard<std::mutex> lock(mLock);
     std::vector<PowerEntityStateSpace> stateSpaces;
     stateSpaces.reserve(mEntityInfos.size());

     // Return state space information for every entity for which this is configured to provide data
     for (auto info : mEntityInfos) {
         PowerEntityStateSpace statespace = {
                 .powerEntityId = info.second.powerEntityId, .states = {}};
         statespace.states.resize(info.second.stateInfos.size());
         size_t i = 0;
         for (auto state : info.second.stateInfos) {
             statespace.states[i++] = {
                     .powerEntityStateId = state.second, .powerEntityStateName = state.first};
         }
         stateSpaces.emplace_back(statespace);
     }
     return stateSpaces;
 }

 }  // namespace powerstats
 }  // namespace pixel
 }  // namespace google
 }  // namespace hardware
 }  // namespace android
	/*
	* Copyright (C) 2019 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 <android-base/logging.h>
	#include <android-base/stringprintf.h>
	#include <binder/IPCThreadState.h>
	#include <binder/IServiceManager.h>
	#include <binder/ProcessState.h>
	#include <pixelpowerstats/AidlStateResidencyDataProvider.h>
	#include <time.h>
	using android::base::StringPrintf;

	static const uint64_t MAX_LATENCY_US = 2000;

	namespace android {
	namespace hardware {
	namespace google {
	namespace pixel {
	namespace powerstats {

	void AidlStateResidencyDataProvider::addEntity(uint32_t id, std::string entityName,
	std::vector<std::string> stateNames) {
	std::lock_guard<std::mutex> lock(mLock);
	// Create a new entry in the map of power entities
	mEntityInfos.emplace(entityName, StateSpace{.powerEntityId = id, .stateInfos = {}});

	// Create an entry for each state and assign an Id.
	uint32_t stateId = 0;
	auto &stateInfos = mEntityInfos.at(entityName).stateInfos;
	for (auto stateName : stateNames) {
	stateInfos.emplace(stateName, stateId++);
	}
	}

	binderStatus AidlStateResidencyDataProvider::unregisterCallbackInternal(
	const sp<IBinder> &callback) {
	if (callback == nullptr) {
	// Callback pointer is null. Return an error.
	return binderStatus::fromExceptionCode(binderStatus::EX_NULL_POINTER, "callback is null");
	}

	bool removed = false;
	std::lock_guard<std::mutex> lock(mLock);

	// Iterate over collection of callbacks and remove the one that matches
	for (auto it = mCallbacks.begin(); it != mCallbacks.end();) {
	if (asBinder(it->second) == callback) {
	LOG(INFO) << "Unregistering callback for " << it->first;
	it = mCallbacks.erase(it);
	removed = true;
	} else {
	it++;
	}
	}
	(void)callback->unlinkToDeath(this); // ignore errors
	return removed ? binderStatus::ok()
	: binderStatus::fromExceptionCode(binderStatus::EX_ILLEGAL_ARGUMENT,
	"callback not found");
	}

	void AidlStateResidencyDataProvider::binderDied(const wp<IBinder> &who) {
	binderStatus status = unregisterCallbackInternal(who.promote());
	if (!status.isOk()) {
	LOG(ERROR) << __func__ << "failed to unregister callback " << status.toString8();
	}
	}

	binderStatus AidlStateResidencyDataProvider::unregisterCallback(
	const sp<IPixelPowerStatsCallback> &callback) {
	return unregisterCallbackInternal(asBinder(callback));
	}

	binderStatus AidlStateResidencyDataProvider::registerCallback(
	const std::string &entityName, const sp<IPixelPowerStatsCallback> &callback) {
	LOG(INFO) << "Registering callback for " << entityName;
	if (callback == nullptr) {
	// Callback pointer is null. Return an error.
	LOG(ERROR) << __func__ << ": "
	<< "Invalid callback. Callback is null";
	return binderStatus::fromExceptionCode(
	binderStatus::EX_NULL_POINTER, "Invalid callback. Callback is null");
	}

	std::lock_guard<std::mutex> lock(mLock);
	if (mEntityInfos.find(entityName) == mEntityInfos.end()) {
	// Could not find the entity associated with this callback. Return an error.
	LOG(ERROR) << __func__ << ": "
	<< "Invalid entity";
	return binderStatus::fromExceptionCode(binderStatus::EX_ILLEGAL_ARGUMENT, "Invalid entity");
	}

	mCallbacks.emplace(entityName, callback);

	// death recipient
	auto linkRet = asBinder(callback)->linkToDeath(this, 0u /* cookie */);
	if (linkRet != android::OK) {
	LOG(WARNING) << __func__ << "Cannot link to death: " << linkRet;
	// ignore the error
	}

	return binderStatus::ok();
	}

	static binderStatus getStatsTimed(
	const std::pair<std::string, sp<IPixelPowerStatsCallback>> &cb,
	std::vector<android::vendor::powerstats::StateResidencyData> &stats) {
	struct timespec then;
	struct timespec now;

	clock_gettime(CLOCK_BOOTTIME, &then);
	binderStatus status = cb.second->getStats(&stats);
	clock_gettime(CLOCK_BOOTTIME, &now);

	uint64_t time_elapsed_us =
	((now.tv_sec - then.tv_sec) * 1000000) + ((now.tv_nsec - then.tv_nsec) / 1000);
	if (time_elapsed_us > MAX_LATENCY_US) {
	LOG(WARNING) << "getStats for " << cb.first << " exceeded time allowed: " << time_elapsed_us
	<< "us";
	}
	return status;
	}

	bool AidlStateResidencyDataProvider::buildResult(
	std::string entityName,
	const std::vector<android::vendor::powerstats::StateResidencyData> &stats,
	PowerEntityStateResidencyResult &result) {
	auto infosEntry = mEntityInfos.find(entityName);
	if (infosEntry == mEntityInfos.end()) {
	LOG(ERROR) << __func__ << " failed: " << entityName << " is not registered.";
	return false;
	}
	auto stateSpace = infosEntry->second;
	result.powerEntityId = stateSpace.powerEntityId;
	size_t numStates = stateSpace.stateInfos.size();
	result.stateResidencyData.resize(numStates);
	size_t numStatesFound = 0;
	for (auto stat = stats.begin(); (numStatesFound < numStates) && (stat != stats.end()); stat++) {
	auto stateInfosEntry = stateSpace.stateInfos.find(stat->state);

	if (stateInfosEntry != stateSpace.stateInfos.end()) {
	PowerEntityStateResidencyData &data = result.stateResidencyData[numStatesFound++];
	data.powerEntityStateId = stateInfosEntry->second;
	data.totalTimeInStateMs = static_cast<uint64_t>(stat->totalTimeInStateMs);
	data.totalStateEntryCount = static_cast<uint64_t>(stat->totalStateEntryCount);
	data.lastEntryTimestampMs = static_cast<uint64_t>(stat->lastEntryTimestampMs);
	} else {
	LOG(WARNING) << "getStats for " << entityName << " returned data for unknown state "
	<< stat->state;
	}
	}

	return (numStatesFound == numStates);
	}

	bool AidlStateResidencyDataProvider::getResults(
	std::unordered_map<uint32_t, PowerEntityStateResidencyResult> &results) {
	std::lock_guard<std::mutex> lock(mLock);
	// TODO (b/126260512): return cached results if time elapsed isn't large
	size_t numResultsFound = 0;
	size_t numResults = mEntityInfos.size();
	for (auto cb : mCallbacks) {
	std::vector<android::vendor::powerstats::StateResidencyData> stats;

	// Get stats for the current callback
	binderStatus status = getStatsTimed(cb, stats);
	if (!status.isOk()) {
	LOG(ERROR) << "getStats for " << cb.first << " failed: " << status.toString8();
	}

	PowerEntityStateResidencyResult result;
	if (buildResult(cb.first, stats, result)) {
	results.emplace(result.powerEntityId, result);
	numResultsFound++;
	} else {
	LOG(ERROR) << "State residency data missing for " << cb.first;
	}
	}
	bool ret = (numResultsFound == numResults);

	// TODO (b/126260512): Cache results of the call, the return value, and the timestamp.
	return ret;
	}

	std::vector<PowerEntityStateSpace> AidlStateResidencyDataProvider::getStateSpaces() {
	std::lock_guard<std::mutex> lock(mLock);
	std::vector<PowerEntityStateSpace> stateSpaces;
	stateSpaces.reserve(mEntityInfos.size());

	// Return state space information for every entity for which this is configured to provide data
	for (auto info : mEntityInfos) {
	PowerEntityStateSpace statespace = {
	.powerEntityId = info.second.powerEntityId, .states = {}};
	statespace.states.resize(info.second.stateInfos.size());
	size_t i = 0;
	for (auto state : info.second.stateInfos) {
	statespace.states[i++] = {
	.powerEntityStateId = state.second, .powerEntityStateName = state.first};
	}
	stateSpaces.emplace_back(statespace);
	}
	return stateSpaces;
	}

	} // namespace powerstats
	} // namespace pixel
	} // namespace google
	} // namespace hardware
	} // namespace android