blob: 51a0c99af66efad3262942c246ca3b3e433ecb1f [file] [log] [blame]
/*
* Copyright (C) 2021 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 "perf_hint"
#include <utility>
#include <vector>
#include <android/os/IHintManager.h>
#include <android/os/IHintSession.h>
#include <binder/Binder.h>
#include <binder/IBinder.h>
#include <binder/IServiceManager.h>
#include <performance_hint_private.h>
#include <utils/SystemClock.h>
using namespace android;
using namespace android::os;
struct APerformanceHintSession;
struct APerformanceHintManager {
public:
static APerformanceHintManager* getInstance();
APerformanceHintManager(sp<IHintManager> service, int64_t preferredRateNanos);
APerformanceHintManager() = delete;
~APerformanceHintManager() = default;
APerformanceHintSession* createSession(const int32_t* threadIds, size_t size,
int64_t initialTargetWorkDurationNanos);
int64_t getPreferredRateNanos() const;
private:
static APerformanceHintManager* create(sp<IHintManager> iHintManager);
sp<IHintManager> mHintManager;
const int64_t mPreferredRateNanos;
};
struct APerformanceHintSession {
public:
APerformanceHintSession(sp<IHintSession> session, int64_t preferredRateNanos,
int64_t targetDurationNanos);
APerformanceHintSession() = delete;
~APerformanceHintSession();
int updateTargetWorkDuration(int64_t targetDurationNanos);
int reportActualWorkDuration(int64_t actualDurationNanos);
private:
friend struct APerformanceHintManager;
sp<IHintSession> mHintSession;
// HAL preferred update rate
const int64_t mPreferredRateNanos;
// Target duration for choosing update rate
int64_t mTargetDurationNanos;
// Last update timestamp
int64_t mLastUpdateTimestamp;
// Cached samples
std::vector<int64_t> mActualDurationsNanos;
std::vector<int64_t> mTimestampsNanos;
};
static IHintManager* gIHintManagerForTesting = nullptr;
static APerformanceHintManager* gHintManagerForTesting = nullptr;
// ===================================== APerformanceHintManager implementation
APerformanceHintManager::APerformanceHintManager(sp<IHintManager> manager,
int64_t preferredRateNanos)
: mHintManager(std::move(manager)), mPreferredRateNanos(preferredRateNanos) {}
APerformanceHintManager* APerformanceHintManager::getInstance() {
if (gHintManagerForTesting) return gHintManagerForTesting;
if (gIHintManagerForTesting) {
APerformanceHintManager* manager = create(gIHintManagerForTesting);
gIHintManagerForTesting = nullptr;
return manager;
}
static APerformanceHintManager* instance = create(nullptr);
return instance;
}
APerformanceHintManager* APerformanceHintManager::create(sp<IHintManager> manager) {
if (!manager) {
manager = interface_cast<IHintManager>(
defaultServiceManager()->checkService(String16("performance_hint")));
}
if (manager == nullptr) {
ALOGE("%s: PerformanceHint service is not ready ", __FUNCTION__);
return nullptr;
}
int64_t preferredRateNanos = -1L;
binder::Status ret = manager->getHintSessionPreferredRate(&preferredRateNanos);
if (!ret.isOk()) {
ALOGE("%s: PerformanceHint cannot get preferred rate. %s", __FUNCTION__,
ret.exceptionMessage().c_str());
return nullptr;
}
if (preferredRateNanos <= 0) {
preferredRateNanos = -1L;
}
return new APerformanceHintManager(std::move(manager), preferredRateNanos);
}
APerformanceHintSession* APerformanceHintManager::createSession(
const int32_t* threadIds, size_t size, int64_t initialTargetWorkDurationNanos) {
sp<IBinder> token = sp<BBinder>::make();
std::vector<int32_t> tids(threadIds, threadIds + size);
sp<IHintSession> session;
binder::Status ret =
mHintManager->createHintSession(token, tids, initialTargetWorkDurationNanos, &session);
if (!ret.isOk() || !session) {
return nullptr;
}
return new APerformanceHintSession(std::move(session), mPreferredRateNanos,
initialTargetWorkDurationNanos);
}
int64_t APerformanceHintManager::getPreferredRateNanos() const {
return mPreferredRateNanos;
}
// ===================================== APerformanceHintSession implementation
APerformanceHintSession::APerformanceHintSession(sp<IHintSession> session,
int64_t preferredRateNanos,
int64_t targetDurationNanos)
: mHintSession(std::move(session)),
mPreferredRateNanos(preferredRateNanos),
mTargetDurationNanos(targetDurationNanos),
mLastUpdateTimestamp(elapsedRealtimeNano()) {}
APerformanceHintSession::~APerformanceHintSession() {
binder::Status ret = mHintSession->close();
if (!ret.isOk()) {
ALOGE("%s: HintSession close failed: %s", __FUNCTION__, ret.exceptionMessage().c_str());
}
}
int APerformanceHintSession::updateTargetWorkDuration(int64_t targetDurationNanos) {
if (targetDurationNanos <= 0) {
ALOGE("%s: targetDurationNanos must be positive", __FUNCTION__);
return EINVAL;
}
binder::Status ret = mHintSession->updateTargetWorkDuration(targetDurationNanos);
if (!ret.isOk()) {
ALOGE("%s: HintSessionn updateTargetWorkDuration failed: %s", __FUNCTION__,
ret.exceptionMessage().c_str());
return EPIPE;
}
mTargetDurationNanos = targetDurationNanos;
/**
* Most of the workload is target_duration dependent, so now clear the cached samples
* as they are most likely obsolete.
*/
mActualDurationsNanos.clear();
mTimestampsNanos.clear();
mLastUpdateTimestamp = elapsedRealtimeNano();
return 0;
}
int APerformanceHintSession::reportActualWorkDuration(int64_t actualDurationNanos) {
if (actualDurationNanos <= 0) {
ALOGE("%s: actualDurationNanos must be positive", __FUNCTION__);
return EINVAL;
}
int64_t now = elapsedRealtimeNano();
mActualDurationsNanos.push_back(actualDurationNanos);
mTimestampsNanos.push_back(now);
/**
* Use current sample to determine the rate limit. We can pick a shorter rate limit
* if any sample underperformed, however, it could be the lower level system is slow
* to react. So here we explicitly choose the rate limit with the latest sample.
*/
int64_t rateLimit = actualDurationNanos > mTargetDurationNanos ? mPreferredRateNanos
: 10 * mPreferredRateNanos;
if (now - mLastUpdateTimestamp <= rateLimit) return 0;
binder::Status ret =
mHintSession->reportActualWorkDuration(mActualDurationsNanos, mTimestampsNanos);
mActualDurationsNanos.clear();
mTimestampsNanos.clear();
if (!ret.isOk()) {
ALOGE("%s: HintSession reportActualWorkDuration failed: %s", __FUNCTION__,
ret.exceptionMessage().c_str());
return EPIPE;
}
mLastUpdateTimestamp = now;
return 0;
}
// ===================================== C API
APerformanceHintManager* APerformanceHint_getManager() {
return APerformanceHintManager::getInstance();
}
APerformanceHintSession* APerformanceHint_createSession(APerformanceHintManager* manager,
const int32_t* threadIds, size_t size,
int64_t initialTargetWorkDurationNanos) {
return manager->createSession(threadIds, size, initialTargetWorkDurationNanos);
}
int64_t APerformanceHint_getPreferredUpdateRateNanos(APerformanceHintManager* manager) {
return manager->getPreferredRateNanos();
}
int APerformanceHint_updateTargetWorkDuration(APerformanceHintSession* session,
int64_t targetDurationNanos) {
return session->updateTargetWorkDuration(targetDurationNanos);
}
int APerformanceHint_reportActualWorkDuration(APerformanceHintSession* session,
int64_t actualDurationNanos) {
return session->reportActualWorkDuration(actualDurationNanos);
}
void APerformanceHint_closeSession(APerformanceHintSession* session) {
delete session;
}
void APerformanceHint_setIHintManagerForTesting(void* iManager) {
delete gHintManagerForTesting;
gHintManagerForTesting = nullptr;
gIHintManagerForTesting = static_cast<IHintManager*>(iManager);
}