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

Commit 005398be authored by Ady Abraham's avatar Ady Abraham
Browse files

SF: add traces for latch unsignled 

Add more debug information to traces to determine SF would
not try to latch an unsignaled buffer.

Test: manual
Bug: 285901173
Change-Id: I60a19fe889ce7c052ea4f3fc8f10771494d330aa
parent 5b54e980

services/surfaceflinger/Layer.cpp

+28 −37
Original line number Diff line number Diff line
@@ -3599,7 +3599,7 @@ std::pair<FloatRect, bool> Layer::getInputBounds(bool fillParentBounds) const { 
    return {inputBounds, inputBoundsValid};

}



bool Layer::simpleBufferUpdate(const layer_state_t& s) const {

bool Layer::isSimpleBufferUpdate(const layer_state_t& s) const {

    const uint64_t requiredFlags = layer_state_t::eBufferChanged;



    const uint64_t deniedFlags = layer_state_t::eProducerDisconnect | layer_state_t::eLayerChanged |
@@ -3608,51 +3608,42 @@ bool Layer::simpleBufferUpdate(const layer_state_t& s) const { 
            layer_state_t::eLayerStackChanged | layer_state_t::eAutoRefreshChanged |

            layer_state_t::eReparent;



    const uint64_t allowedFlags = layer_state_t::eHasListenerCallbacksChanged |

            layer_state_t::eFrameRateSelectionPriority | layer_state_t::eFrameRateChanged |

            layer_state_t::eSurfaceDamageRegionChanged | layer_state_t::eApiChanged |

            layer_state_t::eMetadataChanged | layer_state_t::eDropInputModeChanged |

            layer_state_t::eInputInfoChanged;



    if ((s.what & requiredFlags) != requiredFlags) {

        ALOGV("%s: false [missing required flags 0x%" PRIx64 "]", __func__,

        ATRACE_FORMAT_INSTANT("%s: false [missing required flags 0x%" PRIx64 "]", __func__,

                              (s.what | requiredFlags) & ~s.what);

        return false;

    }



    if (s.what & deniedFlags) {

        ALOGV("%s: false [has denied flags 0x%" PRIx64 "]", __func__, s.what & deniedFlags);

        ATRACE_FORMAT_INSTANT("%s: false [has denied flags 0x%" PRIx64 "]", __func__,

                              s.what & deniedFlags);

        return false;

    }



    if (s.what & allowedFlags) {

        ALOGV("%s: [has allowed flags 0x%" PRIx64 "]", __func__, s.what & allowedFlags);

    }



    if (s.what & layer_state_t::ePositionChanged) {

        if (mRequestedTransform.tx() != s.x || mRequestedTransform.ty() != s.y) {

            ALOGV("%s: false [ePositionChanged changed]", __func__);

            ATRACE_FORMAT_INSTANT("%s: false [ePositionChanged changed]", __func__);

            return false;

        }

    }



    if (s.what & layer_state_t::eAlphaChanged) {

        if (mDrawingState.color.a != s.color.a) {

            ALOGV("%s: false [eAlphaChanged changed]", __func__);

            ATRACE_FORMAT_INSTANT("%s: false [eAlphaChanged changed]", __func__);

            return false;

        }

    }



    if (s.what & layer_state_t::eColorTransformChanged) {

        if (mDrawingState.colorTransform != s.colorTransform) {

            ALOGV("%s: false [eColorTransformChanged changed]", __func__);

            ATRACE_FORMAT_INSTANT("%s: false [eColorTransformChanged changed]", __func__);

            return false;

        }

    }



    if (s.what & layer_state_t::eBackgroundColorChanged) {

        if (mDrawingState.bgColorLayer || s.bgColor.a != 0) {

            ALOGV("%s: false [eBackgroundColorChanged changed]", __func__);

            ATRACE_FORMAT_INSTANT("%s: false [eBackgroundColorChanged changed]", __func__);

            return false;

        }

    }
@@ -3662,91 +3653,92 @@ bool Layer::simpleBufferUpdate(const layer_state_t& s) const { 
            mRequestedTransform.dtdy() != s.matrix.dtdy ||

            mRequestedTransform.dtdx() != s.matrix.dtdx ||

            mRequestedTransform.dsdy() != s.matrix.dsdy) {

            ALOGV("%s: false [eMatrixChanged changed]", __func__);

            ATRACE_FORMAT_INSTANT("%s: false [eMatrixChanged changed]", __func__);

            return false;

        }

    }



    if (s.what & layer_state_t::eCornerRadiusChanged) {

        if (mDrawingState.cornerRadius != s.cornerRadius) {

            ALOGV("%s: false [eCornerRadiusChanged changed]", __func__);

            ATRACE_FORMAT_INSTANT("%s: false [eCornerRadiusChanged changed]", __func__);

            return false;

        }

    }



    if (s.what & layer_state_t::eBackgroundBlurRadiusChanged) {

        if (mDrawingState.backgroundBlurRadius != static_cast<int>(s.backgroundBlurRadius)) {

            ALOGV("%s: false [eBackgroundBlurRadiusChanged changed]", __func__);

            ATRACE_FORMAT_INSTANT("%s: false [eBackgroundBlurRadiusChanged changed]", __func__);

            return false;

        }

    }



    if (s.what & layer_state_t::eBufferTransformChanged) {

        if (mDrawingState.bufferTransform != s.bufferTransform) {

            ALOGV("%s: false [eBufferTransformChanged changed]", __func__);

            ATRACE_FORMAT_INSTANT("%s: false [eBufferTransformChanged changed]", __func__);

            return false;

        }

    }



    if (s.what & layer_state_t::eTransformToDisplayInverseChanged) {

        if (mDrawingState.transformToDisplayInverse != s.transformToDisplayInverse) {

            ALOGV("%s: false [eTransformToDisplayInverseChanged changed]", __func__);

            ATRACE_FORMAT_INSTANT("%s: false [eTransformToDisplayInverseChanged changed]",

                                  __func__);

            return false;

        }

    }



    if (s.what & layer_state_t::eCropChanged) {

        if (mDrawingState.crop != s.crop) {

            ALOGV("%s: false [eCropChanged changed]", __func__);

            ATRACE_FORMAT_INSTANT("%s: false [eCropChanged changed]", __func__);

            return false;

        }

    }



    if (s.what & layer_state_t::eDataspaceChanged) {

        if (mDrawingState.dataspace != s.dataspace) {

            ALOGV("%s: false [eDataspaceChanged changed]", __func__);

            ATRACE_FORMAT_INSTANT("%s: false [eDataspaceChanged changed]", __func__);

            return false;

        }

    }



    if (s.what & layer_state_t::eHdrMetadataChanged) {

        if (mDrawingState.hdrMetadata != s.hdrMetadata) {

            ALOGV("%s: false [eHdrMetadataChanged changed]", __func__);

            ATRACE_FORMAT_INSTANT("%s: false [eHdrMetadataChanged changed]", __func__);

            return false;

        }

    }



    if (s.what & layer_state_t::eSidebandStreamChanged) {

        if (mDrawingState.sidebandStream != s.sidebandStream) {

            ALOGV("%s: false [eSidebandStreamChanged changed]", __func__);

            ATRACE_FORMAT_INSTANT("%s: false [eSidebandStreamChanged changed]", __func__);

            return false;

        }

    }



    if (s.what & layer_state_t::eColorSpaceAgnosticChanged) {

        if (mDrawingState.colorSpaceAgnostic != s.colorSpaceAgnostic) {

            ALOGV("%s: false [eColorSpaceAgnosticChanged changed]", __func__);

            ATRACE_FORMAT_INSTANT("%s: false [eColorSpaceAgnosticChanged changed]", __func__);

            return false;

        }

    }



    if (s.what & layer_state_t::eShadowRadiusChanged) {

        if (mDrawingState.shadowRadius != s.shadowRadius) {

            ALOGV("%s: false [eShadowRadiusChanged changed]", __func__);

            ATRACE_FORMAT_INSTANT("%s: false [eShadowRadiusChanged changed]", __func__);

            return false;

        }

    }



    if (s.what & layer_state_t::eFixedTransformHintChanged) {

        if (mDrawingState.fixedTransformHint != s.fixedTransformHint) {

            ALOGV("%s: false [eFixedTransformHintChanged changed]", __func__);

            ATRACE_FORMAT_INSTANT("%s: false [eFixedTransformHintChanged changed]", __func__);

            return false;

        }

    }



    if (s.what & layer_state_t::eTrustedOverlayChanged) {

        if (mDrawingState.isTrustedOverlay != s.isTrustedOverlay) {

            ALOGV("%s: false [eTrustedOverlayChanged changed]", __func__);

            ATRACE_FORMAT_INSTANT("%s: false [eTrustedOverlayChanged changed]", __func__);

            return false;

        }

    }
@@ -3755,28 +3747,28 @@ bool Layer::simpleBufferUpdate(const layer_state_t& s) const { 
        StretchEffect temp = s.stretchEffect;

        temp.sanitize();

        if (mDrawingState.stretchEffect != temp) {

            ALOGV("%s: false [eStretchChanged changed]", __func__);

            ATRACE_FORMAT_INSTANT("%s: false [eStretchChanged changed]", __func__);

            return false;

        }

    }



    if (s.what & layer_state_t::eBufferCropChanged) {

        if (mDrawingState.bufferCrop != s.bufferCrop) {

            ALOGV("%s: false [eBufferCropChanged changed]", __func__);

            ATRACE_FORMAT_INSTANT("%s: false [eBufferCropChanged changed]", __func__);

            return false;

        }

    }



    if (s.what & layer_state_t::eDestinationFrameChanged) {

        if (mDrawingState.destinationFrame != s.destinationFrame) {

            ALOGV("%s: false [eDestinationFrameChanged changed]", __func__);

            ATRACE_FORMAT_INSTANT("%s: false [eDestinationFrameChanged changed]", __func__);

            return false;

        }

    }



    if (s.what & layer_state_t::eDimmingEnabledChanged) {

        if (mDrawingState.dimmingEnabled != s.dimmingEnabled) {

            ALOGV("%s: false [eDimmingEnabledChanged changed]", __func__);

            ATRACE_FORMAT_INSTANT("%s: false [eDimmingEnabledChanged changed]", __func__);

            return false;

        }

    }
@@ -3784,12 +3776,11 @@ bool Layer::simpleBufferUpdate(const layer_state_t& s) const { 
    if (s.what & layer_state_t::eExtendedRangeBrightnessChanged) {

        if (mDrawingState.currentHdrSdrRatio != s.currentHdrSdrRatio ||

            mDrawingState.desiredHdrSdrRatio != s.desiredHdrSdrRatio) {

            ALOGV("%s: false [eExtendedRangeBrightnessChanged changed]", __func__);

            ATRACE_FORMAT_INSTANT("%s: false [eExtendedRangeBrightnessChanged changed]", __func__);

            return false;

        }

    }



    ALOGV("%s: true", __func__);

    return true;

}

services/surfaceflinger/Layer.h

+1 −1
Original line number Diff line number Diff line
@@ -866,7 +866,7 @@ public: 
    std::string getPendingBufferCounterName() { return mBlastTransactionName; }

    bool updateGeometry();



    bool simpleBufferUpdate(const layer_state_t&) const;

    bool isSimpleBufferUpdate(const layer_state_t& s) const;



    static bool isOpaqueFormat(PixelFormat format);

services/surfaceflinger/SurfaceFlinger.cpp

+10 −14
Original line number Diff line number Diff line
@@ -4444,25 +4444,26 @@ bool SurfaceFlinger::frameIsEarly(TimePoint expectedPresentTime, VsyncId vsyncId 
bool SurfaceFlinger::shouldLatchUnsignaled(const sp<Layer>& layer, const layer_state_t& state,

                                           size_t numStates, bool firstTransaction) const {

    if (enableLatchUnsignaledConfig == LatchUnsignaledConfig::Disabled) {

        ALOGV("%s: false (LatchUnsignaledConfig::Disabled)", __func__);

        ATRACE_FORMAT_INSTANT("%s: false (LatchUnsignaledConfig::Disabled)", __func__);

        return false;

    }



    if (enableLatchUnsignaledConfig == LatchUnsignaledConfig::Always) {

        ALOGV("%s: true (LatchUnsignaledConfig::Always)", __func__);

        ATRACE_FORMAT_INSTANT("%s: true (LatchUnsignaledConfig::Always)", __func__);

        return true;

    }



    // We only want to latch unsignaled when a single layer is updated in this

    // transaction (i.e. not a blast sync transaction).

    if (numStates != 1) {

        ALOGV("%s: false (numStates=%zu)", __func__, numStates);

        ATRACE_FORMAT_INSTANT("%s: false (numStates=%zu)", __func__, numStates);

        return false;

    }



    if (enableLatchUnsignaledConfig == LatchUnsignaledConfig::AutoSingleLayer) {

        if (!firstTransaction) {

            ALOGV("%s: false (LatchUnsignaledConfig::AutoSingleLayer; not first transaction)",

            ATRACE_FORMAT_INSTANT("%s: false (LatchUnsignaledConfig::AutoSingleLayer; not first "

                                  "transaction)",

                                  __func__);

            return false;

        }
@@ -4471,19 +4472,14 @@ bool SurfaceFlinger::shouldLatchUnsignaled(const sp<Layer>& layer, const layer_s 
        // as it leads to jank due to RenderEngine waiting for unsignaled buffer

        // or window animations being slow.

        if (mScheduler->vsyncModulator().isVsyncConfigEarly()) {

            ALOGV("%s: false (LatchUnsignaledConfig::AutoSingleLayer; isVsyncConfigEarly)",

            ATRACE_FORMAT_INSTANT("%s: false (LatchUnsignaledConfig::AutoSingleLayer; "

                                  "isVsyncConfigEarly)",

                                  __func__);

            return false;

        }

    }



    if (!layer->simpleBufferUpdate(state)) {

        ALOGV("%s: false (!simpleBufferUpdate)", __func__);

        return false;

    }



    ALOGV("%s: true", __func__);

    return true;

    return layer->isSimpleBufferUpdate(state);

}



status_t SurfaceFlinger::setTransactionState(