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

Commit a156f48c authored by Vishnu Nair's avatar Vishnu Nair
Browse files

[sf] update latch time only for layers that will not be latched 

Latching happens after the transactions are committed, so fix an
issue where we passed in the incorrect latch time for buffer layers
that was used to classify jank.

Note: this will probably cause a perf regression but this is fixing
an incorrect jank classification caused by
Ie211aa3bd5821f6052cf84a62a2e245132a19d90

Bug: 270041584
Test: presubmit
Change-Id: I632a8ee6a1ed804a17a001e87c06e617ae361b25
parent 7c41bf2e

services/surfaceflinger/Layer.cpp

+8 −5
Original line number Original line Diff line number Diff line
@@ -790,7 +790,7 @@ void Layer::transferAvailableJankData(const std::deque<sp<CallbackHandle>>& hand 
// transaction

// transaction

// ----------------------------------------------------------------------------

// ----------------------------------------------------------------------------





uint32_t Layer::doTransaction(uint32_t flags, nsecs_t latchTime) {

uint32_t Layer::doTransaction(uint32_t flags) {

    ATRACE_CALL();

    ATRACE_CALL();





    // TODO: This is unfortunate.

    // TODO: This is unfortunate.
@@ -818,12 +818,12 @@ uint32_t Layer::doTransaction(uint32_t flags, nsecs_t latchTime) { 
        mFlinger->mUpdateInputInfo = true;

        mFlinger->mUpdateInputInfo = true;

    }

    }





    commitTransaction(mDrawingState, latchTime);

    commitTransaction(mDrawingState);





    return flags;

    return flags;

}

}





void Layer::commitTransaction(State&, nsecs_t currentLatchTime) {

void Layer::commitTransaction(State&) {

    // Set the present state for all bufferlessSurfaceFramesTX to Presented. The

    // Set the present state for all bufferlessSurfaceFramesTX to Presented. The

    // bufferSurfaceFrameTX will be presented in latchBuffer.

    // bufferSurfaceFrameTX will be presented in latchBuffer.

    for (auto& [token, surfaceFrame] : mDrawingState.bufferlessSurfaceFramesTX) {

    for (auto& [token, surfaceFrame] : mDrawingState.bufferlessSurfaceFramesTX) {
@@ -835,7 +835,6 @@ void Layer::commitTransaction(State&, nsecs_t currentLatchTime) { 
        }

        }

    }

    }

    mDrawingState.bufferlessSurfaceFramesTX.clear();

    mDrawingState.bufferlessSurfaceFramesTX.clear();

    mLastLatchTime = currentLatchTime;

}

}





uint32_t Layer::clearTransactionFlags(uint32_t mask) {

uint32_t Layer::clearTransactionFlags(uint32_t mask) {
@@ -1381,7 +1380,7 @@ void Layer::addSurfaceFramePresentedForBuffer( 
    surfaceFrame->setAcquireFenceTime(acquireFenceTime);

    surfaceFrame->setAcquireFenceTime(acquireFenceTime);

    surfaceFrame->setPresentState(PresentState::Presented, mLastLatchTime);

    surfaceFrame->setPresentState(PresentState::Presented, mLastLatchTime);

    mFlinger->mFrameTimeline->addSurfaceFrame(surfaceFrame);

    mFlinger->mFrameTimeline->addSurfaceFrame(surfaceFrame);

    mLastLatchTime = currentLatchTime;

    updateLastLatchTime(currentLatchTime);

}

}





std::shared_ptr<frametimeline::SurfaceFrame> Layer::createSurfaceFrameForTransaction(

std::shared_ptr<frametimeline::SurfaceFrame> Layer::createSurfaceFrameForTransaction(
@@ -4077,6 +4076,10 @@ void Layer::setTrustedPresentationInfo(TrustedPresentationThresholds const& thre 
    }

    }

}

}





void Layer::updateLastLatchTime(nsecs_t latchTime) {

    mLastLatchTime = latchTime;

}



// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------





std::ostream& operator<<(std::ostream& stream, const Layer::FrameRate& rate) {

std::ostream& operator<<(std::ostream& stream, const Layer::FrameRate& rate) {

services/surfaceflinger/Layer.h

+3 −2
Original line number Original line Diff line number Diff line
@@ -347,6 +347,7 @@ public: 
    void useSurfaceDamage();

    void useSurfaceDamage();

    void useEmptyDamage();

    void useEmptyDamage();

    Region getVisibleRegion(const DisplayDevice*) const;

    Region getVisibleRegion(const DisplayDevice*) const;

    void updateLastLatchTime(nsecs_t latchtime);





    /*

    /*

     * isOpaque - true if this surface is opaque

     * isOpaque - true if this surface is opaque
@@ -623,7 +624,7 @@ public: 
     * doTransaction - process the transaction. This is a good place to figure

     * doTransaction - process the transaction. This is a good place to figure

     * out which attributes of the surface have changed.

     * out which attributes of the surface have changed.

     */

     */

    virtual uint32_t doTransaction(uint32_t transactionFlags, nsecs_t currentLatchTime);

    virtual uint32_t doTransaction(uint32_t transactionFlags);





    /*

    /*

     * Remove relative z for the layer if its relative parent is not part of the

     * Remove relative z for the layer if its relative parent is not part of the
@@ -860,7 +861,7 @@ protected: 
    void preparePerFrameCompositionState();

    void preparePerFrameCompositionState();

    void preparePerFrameBufferCompositionState();

    void preparePerFrameBufferCompositionState();

    void preparePerFrameEffectsCompositionState();

    void preparePerFrameEffectsCompositionState();

    virtual void commitTransaction(State& stateToCommit, nsecs_t currentLatchTime = 0);

    virtual void commitTransaction(State& stateToCommit);

    void gatherBufferInfo();

    void gatherBufferInfo();

    void onSurfaceFrameCreated(const std::shared_ptr<frametimeline::SurfaceFrame>&);

    void onSurfaceFrameCreated(const std::shared_ptr<frametimeline::SurfaceFrame>&);

services/surfaceflinger/SurfaceFlinger.cpp

+4 −2
Original line number Original line Diff line number Diff line
@@ -3863,7 +3863,7 @@ void SurfaceFlinger::commitOffscreenLayers() { 
    for (Layer* offscreenLayer : mOffscreenLayers) {

    for (Layer* offscreenLayer : mOffscreenLayers) {

        offscreenLayer->traverse(LayerVector::StateSet::Drawing, [](Layer* layer) {

        offscreenLayer->traverse(LayerVector::StateSet::Drawing, [](Layer* layer) {

            if (layer->clearTransactionFlags(eTransactionNeeded)) {

            if (layer->clearTransactionFlags(eTransactionNeeded)) {

                layer->doTransaction(0, 0);

                layer->doTransaction(0);

                layer->commitChildList();

                layer->commitChildList();

            }

            }

        });

        });
@@ -3899,7 +3899,7 @@ bool SurfaceFlinger::latchBuffers() { 
    // second frame. But layer 0's second frame could be waiting on display.

    // second frame. But layer 0's second frame could be waiting on display.

    mDrawingState.traverse([&](Layer* layer) {

    mDrawingState.traverse([&](Layer* layer) {

        if (layer->clearTransactionFlags(eTransactionNeeded) || mForceTransactionDisplayChange) {

        if (layer->clearTransactionFlags(eTransactionNeeded) || mForceTransactionDisplayChange) {

            const uint32_t flags = layer->doTransaction(0, latchTime);

            const uint32_t flags = layer->doTransaction(0);

            if (flags & Layer::eVisibleRegion) {

            if (flags & Layer::eVisibleRegion) {

                mVisibleRegionsDirty = true;

                mVisibleRegionsDirty = true;

            }

            }
@@ -3910,6 +3910,8 @@ bool SurfaceFlinger::latchBuffers() { 
            mLayersWithQueuedFrames.emplace(sp<Layer>::fromExisting(layer));

            mLayersWithQueuedFrames.emplace(sp<Layer>::fromExisting(layer));

        } else {

        } else {

            layer->useEmptyDamage();

            layer->useEmptyDamage();

            // If the layer has frames we will update the latch time when latching the buffer.

            layer->updateLastLatchTime(latchTime);

        }

        }

    });

    });

    mForceTransactionDisplayChange = false;

    mForceTransactionDisplayChange = false;