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

Commit f808b17f authored by Chavi Weingarten's avatar Chavi Weingarten Committed by Automerger Merge Worker
Browse files

Merge "SF: Add composition strategy prediction stats" into tm-dev am: 5a896f35 

Original change: https://googleplex-android-review.googlesource.com/c/platform/frameworks/native/+/17570689



Change-Id: I5307369e55367a0f6fd3edf83b7650e84aec7bd3
Signed-off-by: default avatarAutomerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
parents ec8af0ef 5a896f35

services/surfaceflinger/CompositionEngine/include/compositionengine/impl/GpuCompositionResult.h

+0 −3
Original line number Original line Diff line number Diff line
@@ -22,9 +22,6 @@ 
namespace android::compositionengine::impl {

namespace android::compositionengine::impl {





struct GpuCompositionResult {

struct GpuCompositionResult {

    // True if composition strategy was predicted successfully.

    bool succeeded = false;



    // Composition ready fence.

    // Composition ready fence.

    base::unique_fd fence{};

    base::unique_fd fence{};

services/surfaceflinger/CompositionEngine/include/compositionengine/impl/OutputCompositionState.h

+12 −0
Original line number Original line Diff line number Diff line
@@ -148,6 +148,18 @@ struct OutputCompositionState { 
    // This is slightly distinct from nits, in that nits cannot be passed to hw composer.

    // This is slightly distinct from nits, in that nits cannot be passed to hw composer.

    std::optional<float> displayBrightness = std::nullopt;

    std::optional<float> displayBrightness = std::nullopt;





    enum class CompositionStrategyPredictionState : uint32_t {

        // Composition strategy prediction did not run for this frame.

        DISABLED = 0,

        // Composition strategy predicted successfully for this frame.

        SUCCESS = 1,

        // Composition strategy prediction failed for this frame.

        FAIL = 2,

    };



    CompositionStrategyPredictionState strategyPrediction =

            CompositionStrategyPredictionState::DISABLED;



    // Debugging

    // Debugging

    void dump(std::string& result) const;

    void dump(std::string& result) const;

};

};

services/surfaceflinger/CompositionEngine/src/Output.cpp

+8 −5
Original line number Original line Diff line number Diff line
@@ -58,7 +58,8 @@ namespace android::compositionengine { 
Output::~Output() = default;

Output::~Output() = default;





namespace impl {

namespace impl {



using CompositionStrategyPredictionState =

        OutputCompositionState::CompositionStrategyPredictionState;

namespace {

namespace {





template <typename T>

template <typename T>
@@ -970,6 +971,7 @@ void Output::prepareFrame() { 
    std::optional<android::HWComposer::DeviceRequestedChanges> changes;

    std::optional<android::HWComposer::DeviceRequestedChanges> changes;

    bool success = chooseCompositionStrategy(&changes);

    bool success = chooseCompositionStrategy(&changes);

    resetCompositionStrategy();

    resetCompositionStrategy();

    outputState.strategyPrediction = CompositionStrategyPredictionState::DISABLED;

    outputState.previousDeviceRequestedChanges = changes;

    outputState.previousDeviceRequestedChanges = changes;

    outputState.previousDeviceRequestedSuccess = success;

    outputState.previousDeviceRequestedSuccess = success;

    if (success) {

    if (success) {
@@ -1012,7 +1014,8 @@ GpuCompositionResult Output::prepareFrameAsync(const CompositionRefreshArgs& ref 




    auto chooseCompositionSuccess = hwcResult.get();

    auto chooseCompositionSuccess = hwcResult.get();

    const bool predictionSucceeded = dequeueSucceeded && changes == previousChanges;

    const bool predictionSucceeded = dequeueSucceeded && changes == previousChanges;

    compositionResult.succeeded = predictionSucceeded;

    state.strategyPrediction = predictionSucceeded ? CompositionStrategyPredictionState::SUCCESS

                                                   : CompositionStrategyPredictionState::FAIL;

    if (!predictionSucceeded) {

    if (!predictionSucceeded) {

        ATRACE_NAME("CompositionStrategyPredictionMiss");

        ATRACE_NAME("CompositionStrategyPredictionMiss");

        resetCompositionStrategy();

        resetCompositionStrategy();
@@ -1056,15 +1059,15 @@ void Output::devOptRepaintFlash(const compositionengine::CompositionRefreshArgs& 
void Output::finishFrame(const CompositionRefreshArgs& refreshArgs, GpuCompositionResult&& result) {

void Output::finishFrame(const CompositionRefreshArgs& refreshArgs, GpuCompositionResult&& result) {

    ATRACE_CALL();

    ATRACE_CALL();

    ALOGV(__FUNCTION__);

    ALOGV(__FUNCTION__);



    const auto& outputState = getState();

    if (!getState().isEnabled) {

    if (!outputState.isEnabled) {

        return;

        return;

    }

    }





    std::optional<base::unique_fd> optReadyFence;

    std::optional<base::unique_fd> optReadyFence;

    std::shared_ptr<renderengine::ExternalTexture> buffer;

    std::shared_ptr<renderengine::ExternalTexture> buffer;

    base::unique_fd bufferFence;

    base::unique_fd bufferFence;

    if (result.succeeded) {

    if (outputState.strategyPrediction == CompositionStrategyPredictionState::SUCCESS) {

        optReadyFence = std::move(result.fence);

        optReadyFence = std::move(result.fence);

    } else {

    } else {

        if (result.bufferAvailable()) {

        if (result.bufferAvailable()) {

services/surfaceflinger/CompositionEngine/src/OutputCompositionState.cpp

+14 −0
Original line number Original line Diff line number Diff line
@@ -18,6 +18,19 @@ 
#include <compositionengine/impl/OutputCompositionState.h>

#include <compositionengine/impl/OutputCompositionState.h>





namespace android::compositionengine::impl {

namespace android::compositionengine::impl {

using CompositionStrategyPredictionState =

        OutputCompositionState::CompositionStrategyPredictionState;



std::string toString(CompositionStrategyPredictionState state) {

    switch (state) {

        case CompositionStrategyPredictionState::DISABLED:

            return "Disabled";

        case CompositionStrategyPredictionState::SUCCESS:

            return "Success";

        case CompositionStrategyPredictionState::FAIL:

            return "Fail";

    }

}





void OutputCompositionState::dump(std::string& out) const {

void OutputCompositionState::dump(std::string& out) const {

    out.append("   ");

    out.append("   ");
@@ -56,6 +69,7 @@ void OutputCompositionState::dump(std::string& out) const { 
    dumpVal(out, "sdrWhitePointNits", sdrWhitePointNits);

    dumpVal(out, "sdrWhitePointNits", sdrWhitePointNits);

    dumpVal(out, "clientTargetBrightness", clientTargetBrightness);

    dumpVal(out, "clientTargetBrightness", clientTargetBrightness);

    dumpVal(out, "displayBrightness", displayBrightness);

    dumpVal(out, "displayBrightness", displayBrightness);

    dumpVal(out, "compositionStrategyPredictionState", toString(strategyPrediction));





    out.append("\n");

    out.append("\n");

}

}

services/surfaceflinger/CompositionEngine/tests/OutputTest.cpp

+11 −7
Original line number Original line Diff line number Diff line
@@ -74,6 +74,9 @@ const mat4 kNonIdentityQuarter = mat4() * 0.25f; 
constexpr OutputColorSetting kVendorSpecifiedOutputColorSetting =

constexpr OutputColorSetting kVendorSpecifiedOutputColorSetting =

        static_cast<OutputColorSetting>(0x100);

        static_cast<OutputColorSetting>(0x100);





using CompositionStrategyPredictionState = android::compositionengine::impl::

        OutputCompositionState::CompositionStrategyPredictionState;



struct OutputPartialMockBase : public impl::Output {

struct OutputPartialMockBase : public impl::Output {

    // compositionengine::Output overrides

    // compositionengine::Output overrides

    const OutputCompositionState& getState() const override { return mState; }

    const OutputCompositionState& getState() const override { return mState; }
@@ -1024,6 +1027,7 @@ TEST_F(OutputPrepareFrameTest, delegatesToChooseCompositionStrategyAndRenderSurf 
    EXPECT_CALL(*mRenderSurface, prepareFrame(false, true));

    EXPECT_CALL(*mRenderSurface, prepareFrame(false, true));





    mOutput.prepareFrame();

    mOutput.prepareFrame();

    EXPECT_EQ(mOutput.getState().strategyPrediction, CompositionStrategyPredictionState::DISABLED);

}

}





// Note: Use OutputTest and not OutputPrepareFrameTest, so the real

// Note: Use OutputTest and not OutputPrepareFrameTest, so the real
@@ -1039,6 +1043,7 @@ TEST_F(OutputTest, prepareFrameSetsClientCompositionOnlyByDefault) { 




    EXPECT_TRUE(mOutput->getState().usesClientComposition);

    EXPECT_TRUE(mOutput->getState().usesClientComposition);

    EXPECT_FALSE(mOutput->getState().usesDeviceComposition);

    EXPECT_FALSE(mOutput->getState().usesDeviceComposition);

    EXPECT_EQ(mOutput->getState().strategyPrediction, CompositionStrategyPredictionState::DISABLED);

}

}





struct OutputPrepareFrameAsyncTest : public testing::Test {

struct OutputPrepareFrameAsyncTest : public testing::Test {
@@ -1093,7 +1098,7 @@ TEST_F(OutputPrepareFrameAsyncTest, delegatesToChooseCompositionStrategyAndRende 
    EXPECT_CALL(mOutput, composeSurfaces(_, Ref(mRefreshArgs), _, _));

    EXPECT_CALL(mOutput, composeSurfaces(_, Ref(mRefreshArgs), _, _));





    impl::GpuCompositionResult result = mOutput.prepareFrameAsync(mRefreshArgs);

    impl::GpuCompositionResult result = mOutput.prepareFrameAsync(mRefreshArgs);

    EXPECT_TRUE(result.succeeded);

    EXPECT_EQ(mOutput.getState().strategyPrediction, CompositionStrategyPredictionState::SUCCESS);

    EXPECT_FALSE(result.bufferAvailable());

    EXPECT_FALSE(result.bufferAvailable());

}

}
@@ -1116,7 +1121,7 @@ TEST_F(OutputPrepareFrameAsyncTest, skipCompositionOnDequeueFailure) { 
                            Return(ByMove(p.get_future()))));

                            Return(ByMove(p.get_future()))));





    impl::GpuCompositionResult result = mOutput.prepareFrameAsync(mRefreshArgs);

    impl::GpuCompositionResult result = mOutput.prepareFrameAsync(mRefreshArgs);

    EXPECT_FALSE(result.succeeded);

    EXPECT_EQ(mOutput.getState().strategyPrediction, CompositionStrategyPredictionState::FAIL);

    EXPECT_FALSE(result.bufferAvailable());

    EXPECT_FALSE(result.bufferAvailable());

}

}
@@ -1146,7 +1151,7 @@ TEST_F(OutputPrepareFrameAsyncTest, chooseCompositionStrategyFailureCallsPrepare 
    EXPECT_CALL(mOutput, composeSurfaces(_, Ref(mRefreshArgs), _, _));

    EXPECT_CALL(mOutput, composeSurfaces(_, Ref(mRefreshArgs), _, _));





    impl::GpuCompositionResult result = mOutput.prepareFrameAsync(mRefreshArgs);

    impl::GpuCompositionResult result = mOutput.prepareFrameAsync(mRefreshArgs);

    EXPECT_FALSE(result.succeeded);

    EXPECT_EQ(mOutput.getState().strategyPrediction, CompositionStrategyPredictionState::FAIL);

    EXPECT_TRUE(result.bufferAvailable());

    EXPECT_TRUE(result.bufferAvailable());

}

}
@@ -1178,7 +1183,7 @@ TEST_F(OutputPrepareFrameAsyncTest, predictionMiss) { 
    EXPECT_CALL(mOutput, composeSurfaces(_, Ref(mRefreshArgs), _, _));

    EXPECT_CALL(mOutput, composeSurfaces(_, Ref(mRefreshArgs), _, _));





    impl::GpuCompositionResult result = mOutput.prepareFrameAsync(mRefreshArgs);

    impl::GpuCompositionResult result = mOutput.prepareFrameAsync(mRefreshArgs);

    EXPECT_FALSE(result.succeeded);

    EXPECT_EQ(mOutput.getState().strategyPrediction, CompositionStrategyPredictionState::FAIL);

    EXPECT_TRUE(result.bufferAvailable());

    EXPECT_TRUE(result.bufferAvailable());

}

}
@@ -3047,22 +3052,21 @@ TEST_F(OutputFinishFrameTest, queuesBufferIfComposeSurfacesReturnsAFence) { 




TEST_F(OutputFinishFrameTest, predictionSucceeded) {

TEST_F(OutputFinishFrameTest, predictionSucceeded) {

    mOutput.mState.isEnabled = true;

    mOutput.mState.isEnabled = true;



    mOutput.mState.strategyPrediction = CompositionStrategyPredictionState::SUCCESS;

    InSequence seq;

    InSequence seq;

    EXPECT_CALL(*mRenderSurface, queueBuffer(_));

    EXPECT_CALL(*mRenderSurface, queueBuffer(_));





    impl::GpuCompositionResult result;

    impl::GpuCompositionResult result;

    result.succeeded = true;

    mOutput.finishFrame(mRefreshArgs, std::move(result));

    mOutput.finishFrame(mRefreshArgs, std::move(result));

}

}





TEST_F(OutputFinishFrameTest, predictionFailedAndBufferIsReused) {

TEST_F(OutputFinishFrameTest, predictionFailedAndBufferIsReused) {

    mOutput.mState.isEnabled = true;

    mOutput.mState.isEnabled = true;

    mOutput.mState.strategyPrediction = CompositionStrategyPredictionState::FAIL;





    InSequence seq;

    InSequence seq;





    impl::GpuCompositionResult result;

    impl::GpuCompositionResult result;

    result.succeeded = false;

    result.buffer =

    result.buffer =

            std::make_shared<renderengine::mock::FakeExternalTexture>(1, 1,

            std::make_shared<renderengine::mock::FakeExternalTexture>(1, 1,

                                                                      HAL_PIXEL_FORMAT_RGBA_8888, 1,

                                                                      HAL_PIXEL_FORMAT_RGBA_8888, 1,