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

Commit cf6eb037 authored by Robert Carr's avatar Robert Carr Committed by Android Build Coastguard Worker
Browse files

Revert "SF: Add composition strategy prediction stats" 

This reverts commit 47183ae0.

Change-Id: I92f9f0e7fdd56a8749207a88887e1f23e25ee924
Bug: 223543469
(cherry picked from commit 779ca498203d3c7e6f9555952b4a1ba8c0363010)
Merged-In: I92f9f0e7fdd56a8749207a88887e1f23e25ee924
parent aab9f95b

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

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



struct GpuCompositionResult {

    // True if composition strategy was predicted successfully.

    bool succeeded = false;



    // Composition ready fence.

    base::unique_fd fence{};

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

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

    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

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

};

services/surfaceflinger/CompositionEngine/src/Output.cpp

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



namespace impl {

using CompositionStrategyPredictionState =

        OutputCompositionState::CompositionStrategyPredictionState;



namespace {



template <typename T>
@@ -967,7 +966,6 @@ void Output::prepareFrame() { 
    }



    auto changes = chooseCompositionStrategy();

    outputState.strategyPrediction = CompositionStrategyPredictionState::DISABLED;

    outputState.previousDeviceRequestedChanges = changes;

    if (changes) {

        applyCompositionStrategy(changes);
@@ -1004,8 +1002,7 @@ GpuCompositionResult Output::prepareFrameAsync(const CompositionRefreshArgs& ref 


    auto changes = hwcResult.valid() ? hwcResult.get() : std::nullopt;

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

    state.strategyPrediction = predictionSucceeded ? CompositionStrategyPredictionState::SUCCESS

                                                   : CompositionStrategyPredictionState::FAIL;

    compositionResult.succeeded = predictionSucceeded;

    if (!predictionSucceeded) {

        ATRACE_NAME("CompositionStrategyPredictionMiss");

        if (changes) {
@@ -1047,15 +1044,15 @@ void Output::devOptRepaintFlash(const compositionengine::CompositionRefreshArgs& 
void Output::finishFrame(const CompositionRefreshArgs& refreshArgs, GpuCompositionResult&& result) {

    ATRACE_CALL();

    ALOGV(__FUNCTION__);

    const auto& outputState = getState();

    if (!outputState.isEnabled) {



    if (!getState().isEnabled) {

        return;

    }



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

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

    base::unique_fd bufferFence;

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

    if (result.succeeded) {

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

    } else {

        if (result.bufferAvailable()) {

services/surfaceflinger/CompositionEngine/src/OutputCompositionState.cpp

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



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 {

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

    dumpVal(out, "clientTargetBrightness", clientTargetBrightness);

    dumpVal(out, "displayBrightness", displayBrightness);

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



    out.append("\n");

}

services/surfaceflinger/CompositionEngine/tests/OutputTest.cpp

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

        static_cast<OutputColorSetting>(0x100);



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

        OutputCompositionState::CompositionStrategyPredictionState;



struct OutputPartialMockBase : public impl::Output {

    // compositionengine::Output overrides

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



    mOutput.prepareFrame();

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

}



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


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

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

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

}



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



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

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

    EXPECT_TRUE(result.succeeded);

    EXPECT_FALSE(result.bufferAvailable());

}
@@ -1109,7 +1104,7 @@ TEST_F(OutputPrepareFrameAsyncTest, skipCompositionOnDequeueFailure) { 
    EXPECT_CALL(mOutput, chooseCompositionStrategyAsync()).WillOnce([&] { return p.get_future(); });



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

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

    EXPECT_FALSE(result.succeeded);

    EXPECT_FALSE(result.bufferAvailable());

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



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

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

    EXPECT_FALSE(result.succeeded);

    EXPECT_TRUE(result.bufferAvailable());

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



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

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

    EXPECT_FALSE(result.succeeded);

    EXPECT_TRUE(result.bufferAvailable());

}
@@ -3010,21 +3005,22 @@ TEST_F(OutputFinishFrameTest, queuesBufferIfComposeSurfacesReturnsAFence) { 


TEST_F(OutputFinishFrameTest, predictionSucceeded) {

    mOutput.mState.isEnabled = true;

    mOutput.mState.strategyPrediction = CompositionStrategyPredictionState::SUCCESS;



    InSequence seq;

    EXPECT_CALL(*mRenderSurface, queueBuffer(_));



    impl::GpuCompositionResult result;

    result.succeeded = true;

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

}



TEST_F(OutputFinishFrameTest, predictionFailedAndBufferIsReused) {

    mOutput.mState.isEnabled = true;

    mOutput.mState.strategyPrediction = CompositionStrategyPredictionState::FAIL;



    InSequence seq;



    impl::GpuCompositionResult result;

    result.succeeded = false;

    result.buffer =

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

                                                                      HAL_PIXEL_FORMAT_RGBA_8888, 1,