aidl: power-libperfmgr: Re-implement lineage perf hint

Signed-off-by: Michael Benedict <michaelbt@live.com>
Co-authored-by: Jesse Chan <jc@lineageos.org>
Co-authored-by: dianlujitao <dianlujitao@lineageos.org>
Co-authored-by: Tim Zimmermann <tim@linux4.de>
Change-Id: I14fde0fee5a0294a8f546746a3eb29b2974a8fe7
tirimbino
Michael Benedict 4 years ago
parent 3fe5163ee0
commit c50258fca0
No known key found for this signature in database
GPG Key ID: 38DFD0398CA46DD6
  1. 4
      aidl/power-libperfmgr/Android.bp
  2. 56
      aidl/power-libperfmgr/LineagePower.cpp
  3. 46
      aidl/power-libperfmgr/LineagePower.h
  4. 65
      aidl/power-libperfmgr/Power.cpp
  5. 11
      aidl/power-libperfmgr/Power.h
  6. 4
      aidl/power-libperfmgr/android.hardware.power-service.samsung.xml
  7. 14
      aidl/power-libperfmgr/service.cpp

@ -35,11 +35,13 @@ cc_binary {
"libbinder_ndk", "libbinder_ndk",
"libperfmgr", "libperfmgr",
"pixel-power-ext-ndk_platform", "pixel-power-ext-ndk_platform",
"vendor.lineage.power-ndk_platform",
], ],
srcs: [ srcs: [
"service.cpp", "service.cpp",
"Power.cpp", "Power.cpp",
"PowerExt.cpp", "PowerExt.cpp",
"InteractionHandler.cpp" "InteractionHandler.cpp",
"LineagePower.cpp"
], ],
} }

@ -0,0 +1,56 @@
/*
* Copyright (C) 2021 The LineageOS 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.
*/
#include "LineagePower.h"
namespace aidl {
namespace vendor {
namespace lineage {
namespace power {
namespace impl {
LineagePower::LineagePower(std::shared_ptr<Power> power, int32_t serviceNumPerfProfiles)
: mPower(power), mNumPerfProfiles(serviceNumPerfProfiles) {}
ndk::ScopedAStatus LineagePower::getFeature(Feature feature, int* _aidl_return) {
switch (feature) {
case Feature::SUPPORTED_PROFILES:
*_aidl_return = mNumPerfProfiles;
break;
default:
*_aidl_return = -1;
break;
}
return ndk::ScopedAStatus::ok();
}
ndk::ScopedAStatus LineagePower::setBoost(Boost type, int durationMs) {
switch (type) {
case Boost::SET_PROFILE:
mPower->setProfile(static_cast<PowerProfile>(durationMs));
break;
default:
break;
}
return ndk::ScopedAStatus::ok();
}
} // namespace impl
} // namespace power
} // namespace lineage
} // namespace vendor
} // namespace aidl

@ -0,0 +1,46 @@
/*
* Copyright (C) 2021 The LineageOS 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.
*/
#pragma once
#include <aidl/vendor/lineage/power/BnPower.h>
#include "Power.h"
namespace aidl {
namespace vendor {
namespace lineage {
namespace power {
namespace impl {
using aidl::google::hardware::power::impl::pixel::Power;
using aidl::google::hardware::power::impl::pixel::PowerProfile;
class LineagePower : public BnPower {
public:
LineagePower(std::shared_ptr<Power> power, int32_t serviceNumPerfProfiles);
ndk::ScopedAStatus getFeature(Feature feature, int* _aidl_return) override;
ndk::ScopedAStatus setBoost(Boost type, int durationMs) override;
private:
std::shared_ptr<Power> mPower;
int32_t mNumPerfProfiles;
};
} // namespace impl
} // namespace power
} // namespace lineage
} // namespace vendor
} // namespace aidl

@ -40,12 +40,14 @@ namespace pixel {
constexpr char kPowerHalStateProp[] = "vendor.powerhal.state"; constexpr char kPowerHalStateProp[] = "vendor.powerhal.state";
constexpr char kPowerHalAudioProp[] = "vendor.powerhal.audio"; constexpr char kPowerHalAudioProp[] = "vendor.powerhal.audio";
constexpr char kPowerHalRenderingProp[] = "vendor.powerhal.rendering"; constexpr char kPowerHalRenderingProp[] = "vendor.powerhal.rendering";
constexpr char kPowerHalProfileProp[] = "vendor.powerhal.perf_profile";
Power::Power(std::shared_ptr<HintManager> hm) Power::Power(std::shared_ptr<HintManager> hm)
: mHintManager(hm), : mHintManager(hm),
mInteractionHandler(nullptr), mInteractionHandler(nullptr),
mVRModeOn(false), mVRModeOn(false),
mSustainedPerfModeOn(false) { mSustainedPerfModeOn(false),
mCurrentPerfProfile(PowerProfile::BALANCED) {
mInteractionHandler = std::make_unique<InteractionHandler>(mHintManager); mInteractionHandler = std::make_unique<InteractionHandler>(mHintManager);
mInteractionHandler->Init(); mInteractionHandler->Init();
@ -79,6 +81,21 @@ Power::Power(std::shared_ptr<HintManager> hm)
mHintManager->DoHint("EXPENSIVE_RENDERING"); mHintManager->DoHint("EXPENSIVE_RENDERING");
} }
state = ::android::base::GetProperty(kPowerHalProfileProp, "");
if (state == "POWER_SAVE") {
ALOGI("Initialize with POWER_SAVE profile");
setProfile(PowerProfile::POWER_SAVE);
} else if (state == "BIAS_POWER_SAVE") {
ALOGI("Initialize with BIAS_POWER_SAVE profile");
setProfile(PowerProfile::BIAS_POWER_SAVE);
} else if (state == "BIAS_PERFORMANCE") {
ALOGI("Initialize with BIAS_PERFORMANCE profile");
setProfile(PowerProfile::BIAS_PERFORMANCE);
} else if (state == "HIGH_PERFORMANCE") {
ALOGI("Initialize with HIGH_PERFORMANCE profile");
setProfile(PowerProfile::HIGH_PERFORMANCE);
}
// Now start to take powerhint // Now start to take powerhint
ALOGI("PowerHAL ready to process hints"); ALOGI("PowerHAL ready to process hints");
} }
@ -190,6 +207,52 @@ ndk::ScopedAStatus Power::isModeSupported(Mode type, bool *_aidl_return) {
return ndk::ScopedAStatus::ok(); return ndk::ScopedAStatus::ok();
} }
ndk::ScopedAStatus Power::setProfile(PowerProfile profile) {
if (mCurrentPerfProfile == profile) {
return ndk::ScopedAStatus::ok();
}
// End previous perf profile hints
switch (mCurrentPerfProfile) {
case PowerProfile::POWER_SAVE:
mHintManager->EndHint("PROFILE_POWER_SAVE");
break;
case PowerProfile::BIAS_POWER_SAVE:
mHintManager->EndHint("PROFILE_BIAS_POWER_SAVE");
break;
case PowerProfile::BIAS_PERFORMANCE:
mHintManager->EndHint("PROFILE_BIAS_PERFORMANCE");
break;
case PowerProfile::HIGH_PERFORMANCE:
mHintManager->EndHint("PROFILE_HIGH_PERFORMANCE");
break;
default:
break;
}
// Apply perf profile hints
switch (profile) {
case PowerProfile::POWER_SAVE:
mHintManager->DoHint("PROFILE_POWER_SAVE");
break;
case PowerProfile::BIAS_POWER_SAVE:
mHintManager->DoHint("PROFILE_BIAS_POWER_SAVE");
break;
case PowerProfile::BIAS_PERFORMANCE:
mHintManager->DoHint("PROFILE_BIAS_PERFORMANCE");
break;
case PowerProfile::HIGH_PERFORMANCE:
mHintManager->DoHint("PROFILE_HIGH_PERFORMANCE");
break;
default:
break;
}
mCurrentPerfProfile = profile;
return ndk::ScopedAStatus::ok();
}
ndk::ScopedAStatus Power::setBoost(Boost type, int32_t durationMs) { ndk::ScopedAStatus Power::setBoost(Boost type, int32_t durationMs) {
LOG(DEBUG) << "Power setBoost: " << toString(type) << " duration: " << durationMs; LOG(DEBUG) << "Power setBoost: " << toString(type) << " duration: " << durationMs;
ATRACE_INT(toString(type).c_str(), durationMs); ATRACE_INT(toString(type).c_str(), durationMs);

@ -37,11 +37,21 @@ using ::aidl::android::hardware::power::Boost;
using ::aidl::android::hardware::power::Mode; using ::aidl::android::hardware::power::Mode;
using ::android::perfmgr::HintManager; using ::android::perfmgr::HintManager;
enum PowerProfile {
POWER_SAVE = 0,
BALANCED,
HIGH_PERFORMANCE,
BIAS_POWER_SAVE,
BIAS_PERFORMANCE,
MAX
};
class Power : public ::aidl::android::hardware::power::BnPower { class Power : public ::aidl::android::hardware::power::BnPower {
public: public:
Power(std::shared_ptr<HintManager> hm); Power(std::shared_ptr<HintManager> hm);
ndk::ScopedAStatus setMode(Mode type, bool enabled) override; ndk::ScopedAStatus setMode(Mode type, bool enabled) override;
ndk::ScopedAStatus isModeSupported(Mode type, bool *_aidl_return) override; ndk::ScopedAStatus isModeSupported(Mode type, bool *_aidl_return) override;
ndk::ScopedAStatus setProfile(PowerProfile profile);
ndk::ScopedAStatus setBoost(Boost type, int32_t durationMs) override; ndk::ScopedAStatus setBoost(Boost type, int32_t durationMs) override;
ndk::ScopedAStatus isBoostSupported(Boost type, bool *_aidl_return) override; ndk::ScopedAStatus isBoostSupported(Boost type, bool *_aidl_return) override;
binder_status_t dump(int fd, const char **args, uint32_t numArgs) override; binder_status_t dump(int fd, const char **args, uint32_t numArgs) override;
@ -51,6 +61,7 @@ class Power : public ::aidl::android::hardware::power::BnPower {
std::unique_ptr<InteractionHandler> mInteractionHandler; std::unique_ptr<InteractionHandler> mInteractionHandler;
std::atomic<bool> mVRModeOn; std::atomic<bool> mVRModeOn;
std::atomic<bool> mSustainedPerfModeOn; std::atomic<bool> mSustainedPerfModeOn;
std::atomic<PowerProfile> mCurrentPerfProfile;
}; };
} // namespace pixel } // namespace pixel

@ -3,4 +3,8 @@
<name>android.hardware.power</name> <name>android.hardware.power</name>
<fqname>IPower/default</fqname> <fqname>IPower/default</fqname>
</hal> </hal>
<hal format="aidl" override="true">
<name>vendor.lineage.power</name>
<fqname>IPower/default</fqname>
</hal>
</manifest> </manifest>

@ -23,13 +23,16 @@
#include <android/binder_manager.h> #include <android/binder_manager.h>
#include <android/binder_process.h> #include <android/binder_process.h>
#include "LineagePower.h"
#include "Power.h" #include "Power.h"
#include "PowerExt.h" #include "PowerExt.h"
using aidl::google::hardware::power::impl::pixel::Power; using aidl::google::hardware::power::impl::pixel::Power;
using aidl::google::hardware::power::impl::pixel::PowerExt; using aidl::google::hardware::power::impl::pixel::PowerExt;
using ::android::perfmgr::HintManager; using ::android::perfmgr::HintManager;
using aidl::vendor::lineage::power::impl::LineagePower;
constexpr char kPowerHalProfileNumProp[] = "vendor.powerhal.perf_profiles";
constexpr char kPowerHalConfigPath[] = "/vendor/etc/powerhint.json"; constexpr char kPowerHalConfigPath[] = "/vendor/etc/powerhint.json";
constexpr char kPowerHalInitProp[] = "vendor.powerhal.init"; constexpr char kPowerHalInitProp[] = "vendor.powerhal.init";
@ -42,6 +45,9 @@ int main() {
LOG(FATAL) << "Invalid config: " << kPowerHalConfigPath; LOG(FATAL) << "Invalid config: " << kPowerHalConfigPath;
} }
// parse number of profiles
int32_t serviceNumPerfProfiles = android::base::GetIntProperty(kPowerHalProfileNumProp, 0);
// single thread // single thread
ABinderProcess_setThreadPoolMaxThreadCount(0); ABinderProcess_setThreadPoolMaxThreadCount(0);
@ -58,7 +64,13 @@ int main() {
const std::string instance = std::string() + Power::descriptor + "/default"; const std::string instance = std::string() + Power::descriptor + "/default";
binder_status_t status = AServiceManager_addService(pw->asBinder().get(), instance.c_str()); binder_status_t status = AServiceManager_addService(pw->asBinder().get(), instance.c_str());
CHECK(status == STATUS_OK); CHECK(status == STATUS_OK);
LOG(INFO) << "Pixel Power HAL AIDL Service with Extension is started.";
// lineage service
std::shared_ptr<LineagePower> lineagePw = ndk::SharedRefBase::make<LineagePower>(pw, serviceNumPerfProfiles);
const std::string lineageInstance = std::string() + LineagePower::descriptor + "/default";
binder_status_t lineageStatus = AServiceManager_addService(lineagePw->asBinder().get(), lineageInstance.c_str());
CHECK(lineageStatus == STATUS_OK);
LOG(INFO) << "Pixel Power HAL AIDL Service with Extension & Lineage Perf Profile is started.";
std::thread initThread([&]() { std::thread initThread([&]() {
::android::base::WaitForProperty(kPowerHalInitProp, "1"); ::android::base::WaitForProperty(kPowerHalInitProp, "1");

Loading…
Cancel
Save