Merge "Remove individual Power HAL benchmarks" into main (7663abc5) · Commits · e / os / android_frameworks_native

services/powermanager/benchmarks/Android.bp

+0 −2

Original line number	Diff line number	Diff line
		@@ -26,9 +26,7 @@ cc_benchmark {
		defaults: ["android.hardware.power-ndk_shared"],
		srcs: [
		"main.cpp",
		"PowerHalAidlBenchmarks.cpp",
		"PowerHalControllerBenchmarks.cpp",
		"PowerHalHidlBenchmarks.cpp",
		],
		shared_libs: [
		"libbase",

services/powermanager/benchmarks/PowerHalAidlBenchmarks.cpp

deleted100644 → 0

+0 −255

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2020 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 "PowerHalAidlBenchmarks"

		#include <aidl/android/hardware/power/Boost.h>
		#include <aidl/android/hardware/power/IPower.h>
		#include <aidl/android/hardware/power/IPowerHintSession.h>
		#include <aidl/android/hardware/power/Mode.h>
		#include <aidl/android/hardware/power/WorkDuration.h>
		#include <benchmark/benchmark.h>
		#include <binder/IServiceManager.h>
		#include <binder/Status.h>
		#include <powermanager/PowerHalLoader.h>
		#include <testUtil.h>
		#include <chrono>

		using aidl::android::hardware::power::Boost;
		using aidl::android::hardware::power::IPower;
		using aidl::android::hardware::power::IPowerHintSession;
		using aidl::android::hardware::power::Mode;
		using aidl::android::hardware::power::WorkDuration;
		using android::power::PowerHalLoader;
		using std::chrono::microseconds;

		using namespace android;
		using namespace std::chrono_literals;

		// Values from Boost.aidl and Mode.aidl.
		static constexpr int64_t FIRST_BOOST = static_cast<int64_t>(*ndk::enum_range<Boost>().begin());
		static constexpr int64_t LAST_BOOST = static_cast<int64_t>(*(ndk::enum_range<Boost>().end()-1));
		static constexpr int64_t FIRST_MODE = static_cast<int64_t>(*ndk::enum_range<Mode>().begin());
		static constexpr int64_t LAST_MODE = static_cast<int64_t>(*(ndk::enum_range<Mode>().end()-1));

		class DurationWrapper : public WorkDuration {
		public:
		DurationWrapper(int64_t dur, int64_t time) {
		durationNanos = dur;
		timeStampNanos = time;
		}
		};

		static const std::vector<WorkDuration> DURATIONS = {
		DurationWrapper(1L, 1L),
		DurationWrapper(1000L, 2L),
		DurationWrapper(1000000L, 3L),
		DurationWrapper(1000000000L, 4L),
		};

		// Delay between oneway method calls to avoid overflowing the binder buffers.
		static constexpr microseconds ONEWAY_API_DELAY = 100us;

		template <class R, class... Args0, class... Args1>
		static void runBenchmark(benchmark::State& state, microseconds delay, R (IPower::*fn)(Args0...),
		Args1&&... args1) {
		std::shared_ptr<IPower> hal = PowerHalLoader::loadAidl();

		if (hal == nullptr) {
		ALOGV("Power HAL not available, skipping test...");
		state.SkipWithMessage("Power HAL unavailable");
		return;
		}

		ndk::ScopedAStatus ret = (hal.fn)(std::forward<Args1>(args1)...);
		if (ret.getExceptionCode() == binder::Status::EX_UNSUPPORTED_OPERATION) {
		ALOGV("Power HAL does not support this operation, skipping test...");
		state.SkipWithMessage("operation unsupported");
		return;
		}

		for (auto _ : state) {
		ret = (hal.fn)(std::forward<Args1>(args1)...);
		if (!ret.isOk()) {
		state.SkipWithError(ret.getDescription().c_str());
		break;
		}
		if (delay > 0us) {
		state.PauseTiming();
		testDelaySpin(std::chrono::duration_cast<std::chrono::duration<float>>(delay).count());
		state.ResumeTiming();
		}
		}
		}

		template <class R, class... Args0, class... Args1>
		static void runSessionBenchmark(benchmark::State& state, R (IPowerHintSession::*fn)(Args0...),
		Args1&&... args1) {
		std::shared_ptr<IPower> hal = PowerHalLoader::loadAidl();

		if (hal == nullptr) {
		ALOGV("Power HAL not available, skipping test...");
		state.SkipWithMessage("Power HAL unavailable");
		return;
		}

		// do not use tid from the benchmark process, use 1 for init
		std::vector<int32_t> threadIds{1};
		int64_t durationNanos = 16666666L;
		std::shared_ptr<IPowerHintSession> session;

		auto status = hal->createHintSession(1, 0, threadIds, durationNanos, &session);

		if (session == nullptr) {
		ALOGV("Power HAL doesn't support session, skipping test...");
		state.SkipWithMessage("operation unsupported");
		return;
		}

		ndk::ScopedAStatus ret = (session.fn)(std::forward<Args1>(args1)...);
		if (ret.getExceptionCode() == binder::Status::EX_UNSUPPORTED_OPERATION) {
		ALOGV("Power HAL does not support this operation, skipping test...");
		state.SkipWithMessage("operation unsupported");
		return;
		}

		for (auto _ : state) {
		ret = (session.fn)(std::forward<Args1>(args1)...);
		if (!ret.isOk()) {
		state.SkipWithError(ret.getDescription().c_str());
		break;
		}
		state.PauseTiming();
		testDelaySpin(std::chrono::duration_cast<std::chrono::duration<float>>(ONEWAY_API_DELAY)
		.count());
		state.ResumeTiming();
		}
		session->close();
		}

		static void BM_PowerHalAidlBenchmarks_isBoostSupported(benchmark::State& state) {
		bool isSupported;
		Boost boost = static_cast<Boost>(state.range(0));
		runBenchmark(state, 0us, &IPower::isBoostSupported, boost, &isSupported);
		}

		static void BM_PowerHalAidlBenchmarks_isModeSupported(benchmark::State& state) {
		bool isSupported;
		Mode mode = static_cast<Mode>(state.range(0));
		runBenchmark(state, 0us, &IPower::isModeSupported, mode, &isSupported);
		}

		static void BM_PowerHalAidlBenchmarks_setBoost(benchmark::State& state) {
		Boost boost = static_cast<Boost>(state.range(0));
		bool isSupported;
		std::shared_ptr<IPower> hal = PowerHalLoader::loadAidl();

		if (hal == nullptr) {
		ALOGV("Power HAL not available, skipping test...");
		state.SkipWithMessage("Power HAL unavailable");
		return;
		}

		ndk::ScopedAStatus ret = hal->isBoostSupported(boost, &isSupported);
		if (!ret.isOk() \|\| !isSupported) {
		state.SkipWithMessage("operation unsupported");
		return;
		}

		runBenchmark(state, ONEWAY_API_DELAY, &IPower::setBoost, boost, 1);
		}

		static void BM_PowerHalAidlBenchmarks_setMode(benchmark::State& state) {
		Mode mode = static_cast<Mode>(state.range(0));
		bool isSupported;
		std::shared_ptr<IPower> hal = PowerHalLoader::loadAidl();

		if (hal == nullptr) {
		ALOGV("Power HAL not available, skipping test...");
		state.SkipWithMessage("Power HAL unavailable");
		return;
		}

		ndk::ScopedAStatus ret = hal->isModeSupported(mode, &isSupported);
		if (!ret.isOk() \|\| !isSupported) {
		state.SkipWithMessage("operation unsupported");
		return;
		}

		runBenchmark(state, ONEWAY_API_DELAY, &IPower::setMode, mode, false);
		}

		static void BM_PowerHalAidlBenchmarks_createHintSession(benchmark::State& state) {
		std::vector<int32_t> threadIds{static_cast<int32_t>(state.range(0))};
		int64_t durationNanos = 16666666L;
		int32_t tgid = 999;
		int32_t uid = 1001;
		std::shared_ptr<IPowerHintSession> appSession;
		std::shared_ptr<IPower> hal = PowerHalLoader::loadAidl();

		if (hal == nullptr) {
		ALOGV("Power HAL not available, skipping test...");
		state.SkipWithMessage("Power HAL unavailable");
		return;
		}

		ndk::ScopedAStatus ret =
		hal->createHintSession(tgid, uid, threadIds, durationNanos, &appSession);
		if (ret.getExceptionCode() == binder::Status::EX_UNSUPPORTED_OPERATION) {
		ALOGV("Power HAL does not support this operation, skipping test...");
		state.SkipWithMessage("operation unsupported");
		return;
		} else if (!ret.isOk()) {
		state.SkipWithError(ret.getDescription().c_str());
		return;
		} else {
		appSession->close();
		}

		for (auto _ : state) {
		ret = hal->createHintSession(tgid, uid, threadIds, durationNanos, &appSession);
		if (!ret.isOk()) {
		state.SkipWithError(ret.getDescription().c_str());
		break;
		}
		state.PauseTiming();
		appSession->close();
		state.ResumeTiming();
		}
		}

		static void BM_PowerHalAidlBenchmarks_getHintSessionPreferredRate(benchmark::State& state) {
		int64_t rate;
		runBenchmark(state, 0us, &IPower::getHintSessionPreferredRate, &rate);
		}

		static void BM_PowerHalAidlBenchmarks_updateTargetWorkDuration(benchmark::State& state) {
		int64_t duration = 1000;
		runSessionBenchmark(state, &IPowerHintSession::updateTargetWorkDuration, duration);
		}

		static void BM_PowerHalAidlBenchmarks_reportActualWorkDuration(benchmark::State& state) {
		runSessionBenchmark(state, &IPowerHintSession::reportActualWorkDuration, DURATIONS);
		}

		BENCHMARK(BM_PowerHalAidlBenchmarks_isBoostSupported)->DenseRange(FIRST_BOOST, LAST_BOOST, 1);
		BENCHMARK(BM_PowerHalAidlBenchmarks_isModeSupported)->DenseRange(FIRST_MODE, LAST_MODE, 1);
		BENCHMARK(BM_PowerHalAidlBenchmarks_setBoost)->DenseRange(FIRST_BOOST, LAST_BOOST, 1);
		BENCHMARK(BM_PowerHalAidlBenchmarks_setMode)->DenseRange(FIRST_MODE, LAST_MODE, 1);
		BENCHMARK(BM_PowerHalAidlBenchmarks_createHintSession)->Arg(1);
		BENCHMARK(BM_PowerHalAidlBenchmarks_getHintSessionPreferredRate);
		BENCHMARK(BM_PowerHalAidlBenchmarks_updateTargetWorkDuration);
		BENCHMARK(BM_PowerHalAidlBenchmarks_reportActualWorkDuration);

services/powermanager/benchmarks/PowerHalControllerBenchmarks.cpp

+106 −0

Original line number	Diff line number	Diff line
		@@ -21,12 +21,15 @@
		#include <benchmark/benchmark.h>
		#include <chrono>
		#include <powermanager/PowerHalController.h>
		#include <powermanager/PowerHintSessionWrapper.h>
		#include <testUtil.h>

		using aidl::android::hardware::power::Boost;
		using aidl::android::hardware::power::Mode;
		using aidl::android::hardware::power::WorkDuration;
		using android::power::HalResult;
		using android::power::PowerHalController;
		using android::power::PowerHintSessionWrapper;

		using namespace android;
		using namespace std::chrono_literals;
		@@ -37,6 +40,21 @@ static constexpr int64_t LAST_BOOST = static_cast<int64_t>(*(ndk::enum_range<Boo
		static constexpr int64_t FIRST_MODE = static_cast<int64_t>(*ndk::enum_range<Mode>().begin());
		static constexpr int64_t LAST_MODE = static_cast<int64_t>(*(ndk::enum_range<Mode>().end()-1));

		class DurationWrapper : public WorkDuration {
		public:
		DurationWrapper(int64_t dur, int64_t time) {
		durationNanos = dur;
		timeStampNanos = time;
		}
		};

		static const std::vector<WorkDuration> DURATIONS = {
		DurationWrapper(1L, 1L),
		DurationWrapper(1000L, 2L),
		DurationWrapper(1000000L, 3L),
		DurationWrapper(1000000000L, 4L),
		};

		// Delay between oneway method calls to avoid overflowing the binder buffers.
		static constexpr std::chrono::microseconds ONEWAY_API_DELAY = 100us;

		@@ -92,6 +110,50 @@ static void runCachedBenchmark(benchmark::State& state,
		}
		}

		template <class T, class... Args0, class... Args1>
		static void runSessionBenchmark(benchmark::State& state,
		HalResult<T> (PowerHintSessionWrapper::*fn)(Args0...),
		Args1&&... args1) {
		PowerHalController controller;

		// do not use tid from the benchmark process, use 1 for init
		std::vector<int32_t> threadIds{1};
		int64_t durationNanos = 16666666L;

		HalResult<std::shared_ptr<PowerHintSessionWrapper>> result =
		controller.createHintSession(1, 0, threadIds, durationNanos);

		if (result.isFailed()) {
		state.SkipWithError(result.errorMessage());
		return;
		} else if (result.isUnsupported()) {
		ALOGV("Power HAL doesn't support session, skipping test...");
		state.SkipWithMessage("operation unsupported");
		return;
		}

		std::shared_ptr<PowerHintSessionWrapper> session = result.value();
		HalResult<T> ret = (session.fn)(std::forward<Args1>(args1)...);
		if (ret.isUnsupported()) {
		ALOGV("Power HAL session does not support this operation, skipping test...");
		state.SkipWithMessage("operation unsupported");
		return;
		}

		for (auto _ : state) {
		ret = (session.fn)(std::forward<Args1>(args1)...);
		if (!ret.isOk()) {
		state.SkipWithError(ret.errorMessage());
		break;
		}
		state.PauseTiming();
		testDelaySpin(
		std::chrono::duration_cast<std::chrono::duration<float>>(ONEWAY_API_DELAY).count());
		state.ResumeTiming();
		}
		session->close();
		}

		static void BM_PowerHalControllerBenchmarks_init(benchmark::State& state) {
		for (auto _ : state) {
		PowerHalController controller;
		@@ -129,9 +191,53 @@ static void BM_PowerHalControllerBenchmarks_setModeCached(benchmark::State& stat
		runCachedBenchmark(state, &PowerHalController::setMode, mode, false);
		}

		static void BM_PowerHalControllerBenchmarks_createHintSession(benchmark::State& state) {
		std::vector<int32_t> threadIds{static_cast<int32_t>(state.range(0))};
		int64_t durationNanos = 16666666L;
		int32_t tgid = 999;
		int32_t uid = 1001;
		PowerHalController controller;

		HalResult<std::shared_ptr<PowerHintSessionWrapper>> result =
		controller.createHintSession(tgid, uid, threadIds, durationNanos);
		if (result.isFailed()) {
		state.SkipWithError(result.errorMessage());
		return;
		} else if (result.isUnsupported()) {
		ALOGV("Power HAL doesn't support session, skipping test...");
		state.SkipWithMessage("operation unsupported");
		return;
		} else {
		result.value()->close();
		}

		for (auto _ : state) {
		result = controller.createHintSession(tgid, uid, threadIds, durationNanos);
		if (!result.isOk()) {
		state.SkipWithError(result.errorMessage());
		break;
		}
		state.PauseTiming();
		result.value()->close();
		state.ResumeTiming();
		}
		}

		static void BM_PowerHalControllerBenchmarks_updateTargetWorkDuration(benchmark::State& state) {
		int64_t duration = 1000;
		runSessionBenchmark(state, &PowerHintSessionWrapper::updateTargetWorkDuration, duration);
		}

		static void BM_PowerHalControllerBenchmarks_reportActualWorkDuration(benchmark::State& state) {
		runSessionBenchmark(state, &PowerHintSessionWrapper::reportActualWorkDuration, DURATIONS);
		}

		BENCHMARK(BM_PowerHalControllerBenchmarks_init);
		BENCHMARK(BM_PowerHalControllerBenchmarks_initCached);
		BENCHMARK(BM_PowerHalControllerBenchmarks_setBoost)->DenseRange(FIRST_BOOST, LAST_BOOST, 1);
		BENCHMARK(BM_PowerHalControllerBenchmarks_setBoostCached)->DenseRange(FIRST_BOOST, LAST_BOOST, 1);
		BENCHMARK(BM_PowerHalControllerBenchmarks_setMode)->DenseRange(FIRST_MODE, LAST_MODE, 1);
		BENCHMARK(BM_PowerHalControllerBenchmarks_setModeCached)->DenseRange(FIRST_MODE, LAST_MODE, 1);
		BENCHMARK(BM_PowerHalControllerBenchmarks_createHintSession)->Arg(1);
		BENCHMARK(BM_PowerHalControllerBenchmarks_updateTargetWorkDuration);
		BENCHMARK(BM_PowerHalControllerBenchmarks_reportActualWorkDuration);

services/powermanager/benchmarks/PowerHalHidlBenchmarks.cpp

deleted100644 → 0

+0 −94

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2020 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 "PowerHalHidlBenchmarks"

		#include <aidl/android/hardware/power/Boost.h>
		#include <aidl/android/hardware/power/IPower.h>
		#include <aidl/android/hardware/power/Mode.h>
		#include <android/hardware/power/1.1/IPower.h>
		#include <benchmark/benchmark.h>
		#include <hardware/power.h>
		#include <hardware_legacy/power.h>
		#include <testUtil.h>
		#include <chrono>

		using android::hardware::Return;
		using android::hardware::power::V1_0::Feature;
		using android::hardware::power::V1_0::PowerHint;
		using std::chrono::microseconds;
		using IPower1_0 = android::hardware::power::V1_0::IPower;
		using IPower1_1 = android::hardware::power::V1_1::IPower;

		using namespace android;
		using namespace std::chrono_literals;

		// Values from types.hal from versions 1.0 to 1.3.
		static constexpr int64_t FIRST_POWER_HINT = static_cast<int64_t>(PowerHint::VSYNC);
		static constexpr int64_t LAST_POWER_HINT = static_cast<int64_t>(PowerHint::LAUNCH);

		// Delay between oneway method calls to avoid overflowing the binder buffers.
		static constexpr microseconds ONEWAY_API_DELAY = 100us;

		template <class R, class I, class... Args0, class... Args1>
		static void runBenchmark(benchmark::State& state, microseconds delay, Return<R> (I::*fn)(Args0...),
		Args1&&... args1) {
		sp<I> hal = I::getService();

		if (hal == nullptr) {
		ALOGV("Power HAL HIDL not available, skipping test...");
		state.SkipWithMessage("Power HAL unavailable");
		return;
		}

		for (auto _ : state) {
		Return<R> ret = (hal.fn)(std::forward<Args1>(args1)...);
		if (!ret.isOk()) {
		state.SkipWithError(ret.description().c_str());
		break;
		}
		if (delay > 0us) {
		state.PauseTiming();
		testDelaySpin(std::chrono::duration_cast<std::chrono::duration<float>>(delay).count());
		state.ResumeTiming();
		}
		}
		}

		static void BM_PowerHalHidlBenchmarks_setFeature(benchmark::State& state) {
		runBenchmark(state, 0us, &IPower1_0::setFeature, Feature::POWER_FEATURE_DOUBLE_TAP_TO_WAKE,
		false);
		}

		static void BM_PowerHalHidlBenchmarks_setInteractive(benchmark::State& state) {
		runBenchmark(state, 0us, &IPower1_0::setInteractive, false);
		}

		static void BM_PowerHalHidlBenchmarks_powerHint(benchmark::State& state) {
		PowerHint powerHint = static_cast<PowerHint>(state.range(0));
		runBenchmark(state, 0us, &IPower1_0::powerHint, powerHint, 0);
		}

		static void BM_PowerHalHidlBenchmarks_powerHintAsync(benchmark::State& state) {
		PowerHint powerHint = static_cast<PowerHint>(state.range(0));
		runBenchmark(state, ONEWAY_API_DELAY, &IPower1_1::powerHintAsync, powerHint, 0);
		}

		BENCHMARK(BM_PowerHalHidlBenchmarks_setFeature);
		BENCHMARK(BM_PowerHalHidlBenchmarks_setInteractive);
		BENCHMARK(BM_PowerHalHidlBenchmarks_powerHint)->DenseRange(FIRST_POWER_HINT, LAST_POWER_HINT, 1);
		BENCHMARK(BM_PowerHalHidlBenchmarks_powerHintAsync)
		->DenseRange(FIRST_POWER_HINT, LAST_POWER_HINT, 1);