Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 6278ece8 authored by TreeHugger Robot's avatar TreeHugger Robot Committed by Android (Google) Code Review
Browse files

Merge "Fail Power HAL benchmarks on failed result"

parents 5050b4da 14e97b77

services/powermanager/PowerHalWrapper.cpp

+14 −6
Original line number Diff line number Diff line
@@ -29,12 +29,20 @@ namespace power { 
// -------------------------------------------------------------------------------------------------



inline HalResult toHalResult(const binder::Status& result) {

    return result.isOk() ? HalResult::SUCCESSFUL : HalResult::FAILED;

    if (result.isOk()) {

        return HalResult::SUCCESSFUL;

    }

    ALOGE("Power HAL request failed: %s", result.toString8().c_str());

    return HalResult::FAILED;

}



template <typename T>

inline HalResult toHalResult(const hardware::Return<T>& result) {

    return result.isOk() ? HalResult::SUCCESSFUL : HalResult::FAILED;

    if (result.isOk()) {

        return HalResult::SUCCESSFUL;

    }

    ALOGE("Power HAL request failed: %s", result.description().c_str());

    return HalResult::FAILED;

}



// -------------------------------------------------------------------------------------------------
@@ -117,8 +125,8 @@ HalResult AidlHalWrapper::setBoost(Boost boost, int32_t durationMs) { 
        bool isSupported = false;

        auto isSupportedRet = mHandle->isBoostSupported(boost, &isSupported);

        if (!isSupportedRet.isOk()) {

            ALOGV("Skipped setBoost %s because Power HAL is not available to check support",

                  toString(boost).c_str());

            ALOGE("Skipped setBoost %s because check support failed with: %s",

                  toString(boost).c_str(), isSupportedRet.toString8().c_str());

            return HalResult::FAILED;

        }
@@ -148,8 +156,8 @@ HalResult AidlHalWrapper::setMode(Mode mode, bool enabled) { 
        bool isSupported = false;

        auto isSupportedRet = mHandle->isModeSupported(mode, &isSupported);

        if (!isSupportedRet.isOk()) {

            ALOGV("Skipped setMode %s because Power HAL is not available to check support",

                  toString(mode).c_str());

            ALOGE("Skipped setMode %s because check support failed with: %s",

                  toString(mode).c_str(), isSupportedRet.toString8().c_str());

            return HalResult::FAILED;

        }

services/powermanager/benchmarks/Android.bp

+3 −0
Original line number Diff line number Diff line
@@ -31,6 +31,9 @@ cc_benchmark { 
        "android.hardware.power@1.1",

        "android.hardware.power-cpp",

    ],

    static_libs: [

        "libtestUtil",

    ],

    cflags: [

        "-Wall",

        "-Werror",

services/powermanager/benchmarks/PowerHalAidlBenchmarks.cpp

+41 −13
Original line number Diff line number Diff line
@@ -19,50 +19,78 @@ 
#include <android/hardware/power/Boost.h>

#include <android/hardware/power/IPower.h>

#include <android/hardware/power/Mode.h>



#include <benchmark/benchmark.h>



#include <binder/IServiceManager.h>

#include <testUtil.h>

#include <chrono>



using android::hardware::power::Boost;

using android::hardware::power::IPower;

using android::hardware::power::Mode;

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>(Boost::INTERACTION);

static constexpr int64_t LAST_BOOST = static_cast<int64_t>(Boost::CAMERA_SHOT);

static constexpr int64_t FIRST_MODE = static_cast<int64_t>(Mode::DOUBLE_TAP_TO_WAKE);

static constexpr int64_t LAST_MODE = static_cast<int64_t>(Mode::CAMERA_STREAMING_HIGH);



// 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, R (IPower::*fn)(Args0...), Args1&&... args1) {

static void runBenchmark(benchmark::State& state, microseconds delay, R (IPower::*fn)(Args0...),

                         Args1&&... args1) {

    sp<IPower> hal = waitForVintfService<IPower>();



    if (hal == nullptr) {

        ALOGI("Power HAL AIDL not available, skipping test...");

        ALOGI("Power HAL not available, skipping test...");

        return;

    }



    binder::Status ret = (*hal.*fn)(std::forward<Args1>(args1)...);

    if (ret.exceptionCode() == binder::Status::Exception::EX_UNSUPPORTED_OPERATION) {

        ALOGI("Power HAL does not support this operation, skipping test...");

        return;

    }



    while (state.KeepRunning()) {

        (*hal.*fn)(std::forward<Args1>(args1)...);

        ret = (*hal.*fn)(std::forward<Args1>(args1)...);

        state.PauseTiming();

        if (!ret.isOk()) state.SkipWithError(ret.toString8().c_str());

        if (delay > 0us) {

            testDelaySpin(std::chrono::duration_cast<std::chrono::duration<float>>(delay).count());

        }

        state.ResumeTiming();

    }

}



static void BM_PowerHalAidlBenchmarks_isBoostSupported(benchmark::State& state) {

    bool isSupported;

    runBenchmark(state, &IPower::isBoostSupported, Boost::INTERACTION, &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;

    runBenchmark(state, &IPower::isModeSupported, Mode::INTERACTIVE, &isSupported);

    Mode mode = static_cast<Mode>(state.range(0));

    runBenchmark(state, 0us, &IPower::isModeSupported, mode, &isSupported);

}



static void BM_PowerHalAidlBenchmarks_setBoost(benchmark::State& state) {

    runBenchmark(state, &IPower::setBoost, Boost::INTERACTION, 0);

    Boost boost = static_cast<Boost>(state.range(0));

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

}



static void BM_PowerHalAidlBenchmarks_setMode(benchmark::State& state) {

    runBenchmark(state, &IPower::setMode, Mode::INTERACTIVE, false);

    Mode mode = static_cast<Mode>(state.range(0));

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

}



BENCHMARK(BM_PowerHalAidlBenchmarks_isBoostSupported);

BENCHMARK(BM_PowerHalAidlBenchmarks_isModeSupported);

BENCHMARK(BM_PowerHalAidlBenchmarks_setBoost);

BENCHMARK(BM_PowerHalAidlBenchmarks_setMode);
 
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);

services/powermanager/benchmarks/PowerHalControllerBenchmarks.cpp

+56 −28
Original line number Diff line number Diff line
@@ -18,16 +18,58 @@ 


#include <android/hardware/power/Boost.h>

#include <android/hardware/power/Mode.h>



#include <benchmark/benchmark.h>



#include <powermanager/PowerHalController.h>

#include <testUtil.h>

#include <chrono>



using android::hardware::power::Boost;

using android::hardware::power::Mode;

using android::power::HalResult;

using android::power::PowerHalController;



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>(Boost::INTERACTION);

static constexpr int64_t LAST_BOOST = static_cast<int64_t>(Boost::CAMERA_SHOT);

static constexpr int64_t FIRST_MODE = static_cast<int64_t>(Mode::DOUBLE_TAP_TO_WAKE);

static constexpr int64_t LAST_MODE = static_cast<int64_t>(Mode::CAMERA_STREAMING_HIGH);



// Delay between oneway method calls to avoid overflowing the binder buffers.

static constexpr std::chrono::microseconds ONEWAY_API_DELAY = 100us;



template <class... Args0, class... Args1>

static void runBenchmark(benchmark::State& state, HalResult (PowerHalController::*fn)(Args0...),

                         Args1&&... args1) {

    while (state.KeepRunning()) {

        PowerHalController controller;

        HalResult ret = (controller.*fn)(std::forward<Args1>(args1)...);

        state.PauseTiming();

        if (ret == HalResult::FAILED) state.SkipWithError("Power HAL request failed");

        state.ResumeTiming();

    }

}



template <class... Args0, class... Args1>

static void runCachedBenchmark(benchmark::State& state,

                               HalResult (PowerHalController::*fn)(Args0...), Args1&&... args1) {

    PowerHalController controller;

    // First call out of test, to cache HAL service and isSupported result.

    (controller.*fn)(std::forward<Args1>(args1)...);



    while (state.KeepRunning()) {

        HalResult ret = (controller.*fn)(std::forward<Args1>(args1)...);

        state.PauseTiming();

        if (ret == HalResult::FAILED) {

            state.SkipWithError("Power HAL request failed");

        }

        testDelaySpin(

                std::chrono::duration_cast<std::chrono::duration<float>>(ONEWAY_API_DELAY).count());

        state.ResumeTiming();

    }

}



static void BM_PowerHalControllerBenchmarks_init(benchmark::State& state) {

    while (state.KeepRunning()) {
@@ -47,42 +89,28 @@ static void BM_PowerHalControllerBenchmarks_initCached(benchmark::State& state) 
}



static void BM_PowerHalControllerBenchmarks_setBoost(benchmark::State& state) {

    while (state.KeepRunning()) {

        PowerHalController controller;

        controller.setBoost(Boost::INTERACTION, 0);

    }

    Boost boost = static_cast<Boost>(state.range(0));

    runBenchmark(state, &PowerHalController::setBoost, boost, 0);

}



static void BM_PowerHalControllerBenchmarks_setBoostCached(benchmark::State& state) {

    PowerHalController controller;

    // First call out of test, to cache supported boost.

    controller.setBoost(Boost::INTERACTION, 0);



    while (state.KeepRunning()) {

        controller.setBoost(Boost::INTERACTION, 0);

    }

    Boost boost = static_cast<Boost>(state.range(0));

    runCachedBenchmark(state, &PowerHalController::setBoost, boost, 0);

}



static void BM_PowerHalControllerBenchmarks_setMode(benchmark::State& state) {

    while (state.KeepRunning()) {

        PowerHalController controller;

        controller.setMode(Mode::INTERACTIVE, false);

    }

    Mode mode = static_cast<Mode>(state.range(0));

    runBenchmark(state, &PowerHalController::setMode, mode, false);

}



static void BM_PowerHalControllerBenchmarks_setModeCached(benchmark::State& state) {

    PowerHalController controller;

    // First call out of test, to cache supported mode.

    controller.setMode(Mode::INTERACTIVE, false);



    while (state.KeepRunning()) {

        controller.setMode(Mode::INTERACTIVE, false);

    }

    Mode mode = static_cast<Mode>(state.range(0));

    runCachedBenchmark(state, &PowerHalController::setMode, mode, false);

}



BENCHMARK(BM_PowerHalControllerBenchmarks_init);

BENCHMARK(BM_PowerHalControllerBenchmarks_initCached);

BENCHMARK(BM_PowerHalControllerBenchmarks_setBoost);

BENCHMARK(BM_PowerHalControllerBenchmarks_setBoostCached);

BENCHMARK(BM_PowerHalControllerBenchmarks_setMode);

BENCHMARK(BM_PowerHalControllerBenchmarks_setModeCached);
 
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);

services/powermanager/benchmarks/PowerHalHidlBenchmarks.cpp

+31 −10
Original line number Diff line number Diff line
@@ -20,23 +20,34 @@ 
#include <android/hardware/power/Boost.h>

#include <android/hardware/power/IPower.h>

#include <android/hardware/power/Mode.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::Boost;

using android::hardware::power::Mode;

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, R (I::*fn)(Args0...), Args1&&... args1) {

static void runBenchmark(benchmark::State& state, microseconds delay, Return<R> (I::*fn)(Args0...),

                         Args1&&... args1) {

    sp<I> hal = I::getService();



    if (hal == nullptr) {
@@ -45,27 +56,37 @@ static void runBenchmark(benchmark::State& state, R (I::*fn)(Args0...), Args1&&. 
    }



    while (state.KeepRunning()) {

        (*hal.*fn)(std::forward<Args1>(args1)...);

        Return<R> ret = (*hal.*fn)(std::forward<Args1>(args1)...);

        state.PauseTiming();

        if (!ret.isOk()) state.SkipWithError(ret.description().c_str());

        if (delay > 0us) {

            testDelaySpin(std::chrono::duration_cast<std::chrono::duration<float>>(delay).count());

        }

        state.ResumeTiming();

    }

}



static void BM_PowerHalHidlBenchmarks_setFeature(benchmark::State& state) {

    runBenchmark(state, &IPower1_0::setFeature, Feature::POWER_FEATURE_DOUBLE_TAP_TO_WAKE, false);

    runBenchmark(state, 0us, &IPower1_0::setFeature, Feature::POWER_FEATURE_DOUBLE_TAP_TO_WAKE,

                 false);

}



static void BM_PowerHalHidlBenchmarks_setInteractive(benchmark::State& state) {

    runBenchmark(state, &IPower1_0::setInteractive, false);

    runBenchmark(state, 0us, &IPower1_0::setInteractive, false);

}



static void BM_PowerHalHidlBenchmarks_powerHint(benchmark::State& state) {

    runBenchmark(state, &IPower1_0::powerHint, PowerHint::INTERACTION, 0);

    PowerHint powerHint = static_cast<PowerHint>(state.range(0));

    runBenchmark(state, 0us, &IPower1_0::powerHint, powerHint, 0);

}



static void BM_PowerHalHidlBenchmarks_powerHintAsync(benchmark::State& state) {

    runBenchmark(state, &IPower1_1::powerHintAsync, PowerHint::INTERACTION, 0);

    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);

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

BENCHMARK(BM_PowerHalHidlBenchmarks_powerHintAsync)

        ->DenseRange(FIRST_POWER_HINT, LAST_POWER_HINT, 1);