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

Commit cc71acd1 authored by Rob Carr's avatar Rob Carr Committed by Android (Google) Code Review
Browse files

Merge changes from topics "presubmit-am-5af13e92c3164470b7a9cd1bad20005d",... 

Merge changes from topics "presubmit-am-5af13e92c3164470b7a9cd1bad20005d", "presubmit-am-f9d8a5a0c94c4482ac55b4cb0f789cb0" into tm-dev

* changes:
  Revert "SF: Add composition strategy prediction stats"
  Revert "SF: Enable HWC composition strategy prediction"
parents 0fbb50ca a00eb14c

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

+3 −0
Original line number Original line Diff line number Diff line
@@ -22,6 +22,9 @@ 
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

+0 −12
Original line number Original line 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.

    // 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

+5 −8
Original line number Original line Diff line number Diff line
@@ -58,8 +58,7 @@ 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>
@@ -967,7 +966,6 @@ void Output::prepareFrame() { 
    }

    }





    auto changes = chooseCompositionStrategy();

    auto changes = chooseCompositionStrategy();

    outputState.strategyPrediction = CompositionStrategyPredictionState::DISABLED;

    outputState.previousDeviceRequestedChanges = changes;

    outputState.previousDeviceRequestedChanges = changes;

    if (changes) {

    if (changes) {

        applyCompositionStrategy(changes);

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




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

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

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

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

    state.strategyPrediction = predictionSucceeded ? CompositionStrategyPredictionState::SUCCESS

    compositionResult.succeeded = predictionSucceeded;

                                                   : CompositionStrategyPredictionState::FAIL;

    if (!predictionSucceeded) {

    if (!predictionSucceeded) {

        ATRACE_NAME("CompositionStrategyPredictionMiss");

        ATRACE_NAME("CompositionStrategyPredictionMiss");

        if (changes) {

        if (changes) {
@@ -1047,15 +1044,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 (!outputState.isEnabled) {

    if (!getState().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 (outputState.strategyPrediction == CompositionStrategyPredictionState::SUCCESS) {

    if (result.succeeded) {

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

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

    } else {

    } else {

        if (result.bufferAvailable()) {

        if (result.bufferAvailable()) {

services/surfaceflinger/CompositionEngine/src/OutputCompositionState.cpp

+0 −14
Original line number Original line Diff line number Diff line
@@ -18,19 +18,6 @@ 
#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("   ");
@@ -69,7 +56,6 @@ 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

+7 −11
Original line number Original line Diff line number Diff line
@@ -74,9 +74,6 @@ 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,7 +1021,6 @@ 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
@@ -1040,7 +1036,6 @@ 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 {
@@ -1089,7 +1084,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_EQ(mOutput.getState().strategyPrediction, CompositionStrategyPredictionState::SUCCESS);

    EXPECT_TRUE(result.succeeded);

    EXPECT_FALSE(result.bufferAvailable());

    EXPECT_FALSE(result.bufferAvailable());

}

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

    EXPECT_CALL(mOutput, chooseCompositionStrategyAsync()).WillOnce([&] { return p.get_future(); });





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

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

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

    EXPECT_FALSE(result.succeeded);

    EXPECT_FALSE(result.bufferAvailable());

    EXPECT_FALSE(result.bufferAvailable());

}

}
@@ -1137,7 +1132,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_EQ(mOutput.getState().strategyPrediction, CompositionStrategyPredictionState::FAIL);

    EXPECT_FALSE(result.succeeded);

    EXPECT_TRUE(result.bufferAvailable());

    EXPECT_TRUE(result.bufferAvailable());

}

}
@@ -1166,7 +1161,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_EQ(mOutput.getState().strategyPrediction, CompositionStrategyPredictionState::FAIL);

    EXPECT_FALSE(result.succeeded);

    EXPECT_TRUE(result.bufferAvailable());

    EXPECT_TRUE(result.bufferAvailable());

}

}
@@ -3010,21 +3005,22 @@ 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,