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

Commit e7b4a10a authored by Rob Carr's avatar Rob Carr Committed by Automerger Merge Worker
Browse files

Merge "Composition strategy prediction: Make broader predictions." into tm-dev am: d0f7b15b 

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



Change-Id: Iaf8fc8832e40547e287a317d9ffb6000c170a734
Signed-off-by: default avatarAutomerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
parents 7b382d31 d0f7b15b

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

+3 −0
Original line number Diff line number Diff line
@@ -164,6 +164,9 @@ struct OutputCompositionState { 


    bool treat170mAsSrgb = false;



    uint64_t lastOutputLayerHash = 0;

    uint64_t outputLayerHash = 0;



    // Debugging

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

};

services/surfaceflinger/CompositionEngine/src/Output.cpp

+22 −6
Original line number Diff line number Diff line
@@ -763,6 +763,7 @@ void Output::writeCompositionState(const compositionengine::CompositionRefreshAr 
    bool includeGeometry = refreshArgs.updatingGeometryThisFrame;

    uint32_t z = 0;

    bool overrideZ = false;

    uint64_t outputLayerHash = 0;

    for (auto* layer : getOutputLayersOrderedByZ()) {

        if (layer == peekThroughLayer) {

            // No longer needed, although it should not show up again, so
@@ -789,6 +790,10 @@ void Output::writeCompositionState(const compositionengine::CompositionRefreshAr 
                    constexpr bool isPeekingThrough = true;

                    peekThroughLayer->writeStateToHWC(includeGeometry, false, z++, overrideZ,

                                                      isPeekingThrough);

                    outputLayerHash ^= android::hashCombine(

                            reinterpret_cast<uint64_t>(&peekThroughLayer->getLayerFE()),

                            z, includeGeometry, overrideZ, isPeekingThrough,

                            peekThroughLayer->requiresClientComposition());

                }



                previousOverride = overrideInfo.buffer->getBuffer();
@@ -797,8 +802,15 @@ void Output::writeCompositionState(const compositionengine::CompositionRefreshAr 


        constexpr bool isPeekingThrough = false;

        layer->writeStateToHWC(includeGeometry, skipLayer, z++, overrideZ, isPeekingThrough);

        if (!skipLayer) {

            outputLayerHash ^= android::hashCombine(

                    reinterpret_cast<uint64_t>(&layer->getLayerFE()),

                    z, includeGeometry, overrideZ, isPeekingThrough,

                    layer->requiresClientComposition());

        }

    }

    editState().outputLayerHash = outputLayerHash;

}



compositionengine::OutputLayer* Output::findLayerRequestingBackgroundComposition() const {

    compositionengine::OutputLayer* layerRequestingBgComposition = nullptr;
@@ -1493,6 +1505,10 @@ void Output::setTreat170mAsSrgb(bool enable) { 
}



bool Output::canPredictCompositionStrategy(const CompositionRefreshArgs& refreshArgs) {

    uint64_t lastOutputLayerHash = getState().lastOutputLayerHash;

    uint64_t outputLayerHash = getState().outputLayerHash;

    editState().lastOutputLayerHash = outputLayerHash;



    if (!getState().isEnabled || !mHwComposerAsyncWorker) {

        ALOGV("canPredictCompositionStrategy disabled");

        return false;
@@ -1513,6 +1529,11 @@ bool Output::canPredictCompositionStrategy(const CompositionRefreshArgs& refresh 
        return false;

    }



    if (lastOutputLayerHash != outputLayerHash) {

        ALOGV("canPredictCompositionStrategy output layers changed");

        return false;

    }



    // If no layer uses clientComposition, then don't predict composition strategy

    // because we have less work to do in parallel.

    if (!anyLayersRequireClientComposition()) {
@@ -1520,14 +1541,9 @@ bool Output::canPredictCompositionStrategy(const CompositionRefreshArgs& refresh 
        return false;

    }



    if (!refreshArgs.updatingOutputGeometryThisFrame) {

    return true;

}



    ALOGV("canPredictCompositionStrategy updatingOutputGeometryThisFrame");

    return false;

}



bool Output::anyLayersRequireClientComposition() const {

    const auto layers = getOutputLayersOrderedByZ();

    return std::any_of(layers.begin(), layers.end(),

services/surfaceflinger/CompositionEngine/tests/OutputTest.cpp

+45 −0
Original line number Diff line number Diff line
@@ -850,14 +850,20 @@ TEST_F(OutputUpdateAndWriteCompositionStateTest, updatesLayerContentForAllLayers 
    EXPECT_CALL(*layer1.outputLayer,

                writeStateToHWC(/*includeGeometry*/ false, /*skipLayer*/ false, z++,

                                /*zIsOverridden*/ false, /*isPeekingThrough*/ false));

    EXPECT_CALL(*layer1.outputLayer, requiresClientComposition())

            .WillRepeatedly(Return(false));

    EXPECT_CALL(*layer2.outputLayer, updateCompositionState(false, false, ui::Transform::ROT_180));

    EXPECT_CALL(*layer2.outputLayer,

                writeStateToHWC(/*includeGeometry*/ false, /*skipLayer*/ false, z++,

                                /*zIsOverridden*/ false, /*isPeekingThrough*/ false));

    EXPECT_CALL(*layer2.outputLayer, requiresClientComposition())

            .WillRepeatedly(Return(false));

    EXPECT_CALL(*layer3.outputLayer, updateCompositionState(false, false, ui::Transform::ROT_180));

    EXPECT_CALL(*layer3.outputLayer,

                writeStateToHWC(/*includeGeometry*/ false, /*skipLayer*/ false, z++,

                                /*zIsOverridden*/ false, /*isPeekingThrough*/ false));

    EXPECT_CALL(*layer3.outputLayer, requiresClientComposition())

            .WillRepeatedly(Return(false));



    injectOutputLayer(layer1);

    injectOutputLayer(layer2);
@@ -884,14 +890,20 @@ TEST_F(OutputUpdateAndWriteCompositionStateTest, updatesLayerGeometryAndContentF 
    EXPECT_CALL(*layer1.outputLayer,

                writeStateToHWC(/*includeGeometry*/ true, /*skipLayer*/ false, z++,

                                /*zIsOverridden*/ false, /*isPeekingThrough*/ false));

    EXPECT_CALL(*layer1.outputLayer, requiresClientComposition())

            .WillRepeatedly(Return(false));

    EXPECT_CALL(*layer2.outputLayer, updateCompositionState(true, false, ui::Transform::ROT_0));

    EXPECT_CALL(*layer2.outputLayer,

                writeStateToHWC(/*includeGeometry*/ true, /*skipLayer*/ false, z++,

                                /*zIsOverridden*/ false, /*isPeekingThrough*/ false));

    EXPECT_CALL(*layer2.outputLayer, requiresClientComposition())

            .WillRepeatedly(Return(false));

    EXPECT_CALL(*layer3.outputLayer, updateCompositionState(true, false, ui::Transform::ROT_0));

    EXPECT_CALL(*layer3.outputLayer,

                writeStateToHWC(/*includeGeometry*/ true, /*skipLayer*/ false, z++,

                                /*zIsOverridden*/ false, /*isPeekingThrough*/ false));

    EXPECT_CALL(*layer3.outputLayer, requiresClientComposition())

            .WillRepeatedly(Return(false));



    injectOutputLayer(layer1);

    injectOutputLayer(layer2);
@@ -917,14 +929,20 @@ TEST_F(OutputUpdateAndWriteCompositionStateTest, forcesClientCompositionForAllLa 
    EXPECT_CALL(*layer1.outputLayer,

                writeStateToHWC(/*includeGeometry*/ false, /*skipLayer*/ false, z++,

                                /*zIsOverridden*/ false, /*isPeekingThrough*/ false));

    EXPECT_CALL(*layer1.outputLayer, requiresClientComposition())

            .WillRepeatedly(Return(false));

    EXPECT_CALL(*layer2.outputLayer, updateCompositionState(false, true, ui::Transform::ROT_0));

    EXPECT_CALL(*layer2.outputLayer,

                writeStateToHWC(/*includeGeometry*/ false, /*skipLayer*/ false, z++,

                                /*zIsOverridden*/ false, /*isPeekingThrough*/ false));

    EXPECT_CALL(*layer2.outputLayer, requiresClientComposition())

            .WillRepeatedly(Return(false));

    EXPECT_CALL(*layer3.outputLayer, updateCompositionState(false, true, ui::Transform::ROT_0));

    EXPECT_CALL(*layer3.outputLayer,

                writeStateToHWC(/*includeGeometry*/ false, /*skipLayer*/ false, z++,

                                /*zIsOverridden*/ false, /*isPeekingThrough*/ false));

    EXPECT_CALL(*layer3.outputLayer, requiresClientComposition())

            .WillRepeatedly(Return(false));



    injectOutputLayer(layer1);

    injectOutputLayer(layer2);
@@ -950,6 +968,8 @@ TEST_F(OutputUpdateAndWriteCompositionStateTest, peekThroughLayerChangesOrder) { 
    InSequence seq;

    EXPECT_CALL(*layer0.outputLayer, updateCompositionState(true, false, ui::Transform::ROT_0));

    EXPECT_CALL(*layer1.outputLayer, updateCompositionState(true, false, ui::Transform::ROT_0));

        EXPECT_CALL(*layer1.outputLayer, requiresClientComposition())

                .WillRepeatedly(Return(false));

    EXPECT_CALL(*layer2.outputLayer, updateCompositionState(true, false, ui::Transform::ROT_0));

    EXPECT_CALL(*layer3.outputLayer, updateCompositionState(true, false, ui::Transform::ROT_0));
@@ -957,6 +977,9 @@ TEST_F(OutputUpdateAndWriteCompositionStateTest, peekThroughLayerChangesOrder) { 
    EXPECT_CALL(*layer0.outputLayer,

                writeStateToHWC(/*includeGeometry*/ true, /*skipLayer*/ false, z++,

                                /*zIsOverridden*/ false, /*isPeekingThrough*/ false));

    EXPECT_CALL(*layer0.outputLayer, requiresClientComposition())

            .WillRepeatedly(Return(false));





    // After calling planComposition (which clears overrideInfo), this test sets

    // layer3 to be the peekThroughLayer for layer1 and layer2. As a result, it
@@ -966,12 +989,18 @@ TEST_F(OutputUpdateAndWriteCompositionStateTest, peekThroughLayerChangesOrder) { 
                writeStateToHWC(/*includeGeometry*/ true, /*skipLayer*/ false, z++,

                                /*zIsOverridden*/ true, /*isPeekingThrough*/

                                true));

    EXPECT_CALL(*layer3.outputLayer, requiresClientComposition())

            .WillRepeatedly(Return(false));

    EXPECT_CALL(*layer1.outputLayer,

                writeStateToHWC(/*includeGeometry*/ true, /*skipLayer*/ false, z++,

                                /*zIsOverridden*/ true, /*isPeekingThrough*/ false));

    EXPECT_CALL(*layer1.outputLayer, requiresClientComposition())

            .WillRepeatedly(Return(false));

    EXPECT_CALL(*layer2.outputLayer,

                writeStateToHWC(/*includeGeometry*/ true, /*skipLayer*/ true, z++,

                                /*zIsOverridden*/ true, /*isPeekingThrough*/ false));

    EXPECT_CALL(*layer2.outputLayer, requiresClientComposition())

            .WillRepeatedly(Return(false));



    injectOutputLayer(layer0);

    injectOutputLayer(layer1);
@@ -4798,10 +4827,14 @@ TEST_F(OutputUpdateAndWriteCompositionStateTest, noBackgroundBlurWhenOpaque) { 
    EXPECT_CALL(*layer1.outputLayer,

                writeStateToHWC(/*includeGeometry*/ false, /*skipLayer*/ false, z++,

                                /*zIsOverridden*/ false, /*isPeekingThrough*/ false));

    EXPECT_CALL(*layer1.outputLayer, requiresClientComposition())

            .WillRepeatedly(Return(false));

    EXPECT_CALL(*layer2.outputLayer, updateCompositionState(false, false, ui::Transform::ROT_0));

    EXPECT_CALL(*layer2.outputLayer,

                writeStateToHWC(/*includeGeometry*/ false, /*skipLayer*/ false, z++,

                                /*zIsOverridden*/ false, /*isPeekingThrough*/ false));

    EXPECT_CALL(*layer2.outputLayer, requiresClientComposition())

            .WillRepeatedly(Return(false));



    layer2.layerFEState.backgroundBlurRadius = 10;

    layer2.layerFEState.isOpaque = true;
@@ -4830,14 +4863,20 @@ TEST_F(OutputUpdateAndWriteCompositionStateTest, handlesBackgroundBlurRequests) 
    EXPECT_CALL(*layer1.outputLayer,

                writeStateToHWC(/*includeGeometry*/ false, /*skipLayer*/ false, z++,

                                /*zIsOverridden*/ false, /*isPeekingThrough*/ false));

    EXPECT_CALL(*layer1.outputLayer, requiresClientComposition())

            .WillRepeatedly(Return(false));

    EXPECT_CALL(*layer2.outputLayer, updateCompositionState(false, true, ui::Transform::ROT_0));

    EXPECT_CALL(*layer2.outputLayer,

                writeStateToHWC(/*includeGeometry*/ false, /*skipLayer*/ false, z++,

                                /*zIsOverridden*/ false, /*isPeekingThrough*/ false));

    EXPECT_CALL(*layer2.outputLayer, requiresClientComposition())

            .WillRepeatedly(Return(false));

    EXPECT_CALL(*layer3.outputLayer, updateCompositionState(false, false, ui::Transform::ROT_0));

    EXPECT_CALL(*layer3.outputLayer,

                writeStateToHWC(/*includeGeometry*/ false, /*skipLayer*/ false, z++,

                                /*zIsOverridden*/ false, /*isPeekingThrough*/ false));

    EXPECT_CALL(*layer3.outputLayer, requiresClientComposition())

            .WillRepeatedly(Return(false));



    layer2.layerFEState.backgroundBlurRadius = 10;

    layer2.layerFEState.isOpaque = false;
@@ -4867,14 +4906,20 @@ TEST_F(OutputUpdateAndWriteCompositionStateTest, handlesBlurRegionRequests) { 
    EXPECT_CALL(*layer1.outputLayer,

                writeStateToHWC(/*includeGeometry*/ false, /*skipLayer*/ false, z++,

                                /*zIsOverridden*/ false, /*isPeekingThrough*/ false));

    EXPECT_CALL(*layer1.outputLayer, requiresClientComposition())

            .WillRepeatedly(Return(false));

    EXPECT_CALL(*layer2.outputLayer, updateCompositionState(false, true, ui::Transform::ROT_0));

    EXPECT_CALL(*layer2.outputLayer,

                writeStateToHWC(/*includeGeometry*/ false, /*skipLayer*/ false, z++,

                                /*zIsOverridden*/ false, /*isPeekingThrough*/ false));

    EXPECT_CALL(*layer2.outputLayer, requiresClientComposition())

            .WillRepeatedly(Return(false));

    EXPECT_CALL(*layer3.outputLayer, updateCompositionState(false, false, ui::Transform::ROT_0));

    EXPECT_CALL(*layer3.outputLayer,

                writeStateToHWC(/*includeGeometry*/ false, /*skipLayer*/ false, z++,

                                /*zIsOverridden*/ false, /*isPeekingThrough*/ false));

    EXPECT_CALL(*layer3.outputLayer, requiresClientComposition())

            .WillRepeatedly(Return(false));



    BlurRegion region;

    layer2.layerFEState.blurRegions.push_back(region);