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

Commit cb36a876 authored by Adithya Srinivasan's avatar Adithya Srinivasan Committed by Android (Google) Code Review
Browse files

Merge changes I6cd9c4cb,I6ceef468 into sc-dev 

* changes:
  Dropping SurfaceFrames from Drawing State
  Add isBuffer to SurfaceFrame
parents 9b24e29e d11eb6bd

services/surfaceflinger/BufferStateLayer.cpp

+2 −0
Original line number Diff line number Diff line
@@ -177,6 +177,8 @@ void BufferStateLayer::onSurfaceFrameCreated( 
        // leak.

        ALOGW("Removing the front of pending jank deque from layer - %s to prevent memory leak",

              mName.c_str());

        std::string miniDump = mPendingJankClassifications.front()->miniDump();

        ALOGD("Head SurfaceFrame mini dump\n%s", miniDump.c_str());

        mPendingJankClassifications.pop_front();

    }

    mPendingJankClassifications.emplace_back(surfaceFrame);

services/surfaceflinger/FrameTimeline/FrameTimeline.cpp

+40 −6
Original line number Diff line number Diff line
@@ -296,7 +296,7 @@ SurfaceFrame::SurfaceFrame(const FrameTimelineInfo& frameTimelineInfo, pid_t own 
                           frametimeline::TimelineItem&& predictions,

                           std::shared_ptr<TimeStats> timeStats,

                           JankClassificationThresholds thresholds,

                           TraceCookieCounter* traceCookieCounter)

                           TraceCookieCounter* traceCookieCounter, bool isBuffer)

      : mToken(frameTimelineInfo.vsyncId),

        mInputEventId(frameTimelineInfo.inputEventId),

        mOwnerPid(ownerPid),
@@ -310,7 +310,8 @@ SurfaceFrame::SurfaceFrame(const FrameTimelineInfo& frameTimelineInfo, pid_t own 
        mActuals({0, 0, 0}),

        mTimeStats(timeStats),

        mJankClassificationThresholds(thresholds),

        mTraceCookieCounter(*traceCookieCounter) {}

        mTraceCookieCounter(*traceCookieCounter),

        mIsBuffer(isBuffer) {}



void SurfaceFrame::setActualStartTime(nsecs_t actualStartTime) {

    std::scoped_lock lock(mMutex);
@@ -395,6 +396,20 @@ nsecs_t SurfaceFrame::getDropTime() const { 
    return mDropTime;

}



void SurfaceFrame::promoteToBuffer() {

    std::scoped_lock lock(mMutex);

    LOG_ALWAYS_FATAL_IF(mIsBuffer == true,

                        "Trying to promote an already promoted BufferSurfaceFrame from layer %s "

                        "with token %" PRId64 "",

                        mDebugName.c_str(), mToken);

    mIsBuffer = true;

}



bool SurfaceFrame::getIsBuffer() const {

    std::scoped_lock lock(mMutex);

    return mIsBuffer;

}



void SurfaceFrame::dump(std::string& result, const std::string& indent, nsecs_t baseTime) const {

    std::scoped_lock lock(mMutex);

    StringAppendF(&result, "%s", indent.c_str());
@@ -407,6 +422,8 @@ void SurfaceFrame::dump(std::string& result, const std::string& indent, nsecs_t 
    StringAppendF(&result, "%s", indent.c_str());

    StringAppendF(&result, "Token: %" PRId64 "\n", mToken);

    StringAppendF(&result, "%s", indent.c_str());

    StringAppendF(&result, "Is Buffer?: %d\n", mIsBuffer);

    StringAppendF(&result, "%s", indent.c_str());

    StringAppendF(&result, "Owner Pid : %d\n", mOwnerPid);

    StringAppendF(&result, "%s", indent.c_str());

    StringAppendF(&result, "Scheduled rendering rate: %d fps\n",
@@ -444,6 +461,21 @@ void SurfaceFrame::dump(std::string& result, const std::string& indent, nsecs_t 
    dumpTable(result, mPredictions, mActuals, indent, mPredictionState, baseTime);

}



std::string SurfaceFrame::miniDump() const {

    std::scoped_lock lock(mMutex);

    std::string result;

    StringAppendF(&result, "Layer - %s\n", mDebugName.c_str());

    StringAppendF(&result, "Token: %" PRId64 "\n", mToken);

    StringAppendF(&result, "Is Buffer?: %d\n", mIsBuffer);

    StringAppendF(&result, "Present State : %s\n", toString(mPresentState).c_str());

    StringAppendF(&result, "Prediction State : %s\n", toString(mPredictionState).c_str());

    StringAppendF(&result, "Jank Type : %s\n", jankTypeBitmaskToString(mJankType).c_str());

    StringAppendF(&result, "Present Metadata : %s\n", toString(mFramePresentMetadata).c_str());

    StringAppendF(&result, "Finish Metadata: %s\n", toString(mFrameReadyMetadata).c_str());

    StringAppendF(&result, "Present time: %" PRId64 "", mActuals.presentTime);

    return result;

}



void SurfaceFrame::classifyJankLocked(int32_t displayFrameJankType, const Fps& refreshRate,

                                      nsecs_t& deadlineDelta) {

    if (mPredictionState == PredictionState::Expired ||
@@ -744,13 +776,14 @@ void FrameTimeline::registerDataSource() { 


std::shared_ptr<SurfaceFrame> FrameTimeline::createSurfaceFrameForToken(

        const FrameTimelineInfo& frameTimelineInfo, pid_t ownerPid, uid_t ownerUid, int32_t layerId,

        std::string layerName, std::string debugName) {

        std::string layerName, std::string debugName, bool isBuffer) {

    ATRACE_CALL();

    if (frameTimelineInfo.vsyncId == FrameTimelineInfo::INVALID_VSYNC_ID) {

        return std::make_shared<SurfaceFrame>(frameTimelineInfo, ownerPid, ownerUid, layerId,

                                              std::move(layerName), std::move(debugName),

                                              PredictionState::None, TimelineItem(), mTimeStats,

                                              mJankClassificationThresholds, &mTraceCookieCounter);

                                              mJankClassificationThresholds, &mTraceCookieCounter,

                                              isBuffer);

    }

    std::optional<TimelineItem> predictions =

            mTokenManager.getPredictionsForToken(frameTimelineInfo.vsyncId);
@@ -759,12 +792,13 @@ std::shared_ptr<SurfaceFrame> FrameTimeline::createSurfaceFrameForToken( 
                                              std::move(layerName), std::move(debugName),

                                              PredictionState::Valid, std::move(*predictions),

                                              mTimeStats, mJankClassificationThresholds,

                                              &mTraceCookieCounter);

                                              &mTraceCookieCounter, isBuffer);

    }

    return std::make_shared<SurfaceFrame>(frameTimelineInfo, ownerPid, ownerUid, layerId,

                                          std::move(layerName), std::move(debugName),

                                          PredictionState::Expired, TimelineItem(), mTimeStats,

                                          mJankClassificationThresholds, &mTraceCookieCounter);

                                          mJankClassificationThresholds, &mTraceCookieCounter,

                                          isBuffer);

}



FrameTimeline::DisplayFrame::DisplayFrame(std::shared_ptr<TimeStats> timeStats,

services/surfaceflinger/FrameTimeline/FrameTimeline.h

+13 −3
Original line number Diff line number Diff line
@@ -159,7 +159,7 @@ public: 
                 int32_t layerId, std::string layerName, std::string debugName,

                 PredictionState predictionState, TimelineItem&& predictions,

                 std::shared_ptr<TimeStats> timeStats, JankClassificationThresholds thresholds,

                 TraceCookieCounter* traceCookieCounter);

                 TraceCookieCounter* traceCookieCounter, bool isBuffer);

    ~SurfaceFrame() = default;



    // Returns std::nullopt if the frame hasn't been classified yet.
@@ -181,6 +181,10 @@ public: 
    void setPresentState(PresentState presentState, nsecs_t lastLatchTime = 0);

    void setRenderRate(Fps renderRate);



    // When a bufferless SurfaceFrame is promoted to a buffer SurfaceFrame, we also have to update

    // isBuffer.

    void promoteToBuffer();



    // Functions called by FrameTimeline

    // BaseTime is the smallest timestamp in this SurfaceFrame.

    // Used for dumping all timestamps relative to the oldest, making it easy to read.
@@ -192,6 +196,8 @@ public: 
                   nsecs_t displayDeadlineDelta, nsecs_t displayPresentDelta);

    // All the timestamps are dumped relative to the baseTime

    void dump(std::string& result, const std::string& indent, nsecs_t baseTime) const;

    // Dumps only the layer, token, is buffer, jank metadata, prediction and present states.

    std::string miniDump() const;

    // Emits a packet for perfetto tracing. The function body will be executed only if tracing is

    // enabled. The displayFrameToken is needed to link the SurfaceFrame to the corresponding

    // DisplayFrame at the trace processor side.
@@ -206,6 +212,7 @@ public: 
    FrameReadyMetadata getFrameReadyMetadata() const;

    FramePresentMetadata getFramePresentMetadata() const;

    nsecs_t getDropTime() const;

    bool getIsBuffer() const;



    // For prediction expired frames, this delta is subtracted from the actual end time to get a

    // start time decent enough to see in traces.
@@ -253,6 +260,9 @@ private: 
    // TraceCookieCounter is used to obtain the cookie for sendig trace packets to perfetto. Using a

    // reference here because the counter is owned by FrameTimeline, which outlives SurfaceFrame.

    TraceCookieCounter& mTraceCookieCounter;

    // Tells if the SurfaceFrame is representing a buffer or a transaction without a

    // buffer(animations)

    bool mIsBuffer;

};



/*
@@ -272,7 +282,7 @@ public: 
    // Debug name is the human-readable debugging string for dumpsys.

    virtual std::shared_ptr<SurfaceFrame> createSurfaceFrameForToken(

            const FrameTimelineInfo& frameTimelineInfo, pid_t ownerPid, uid_t ownerUid,

            int32_t layerId, std::string layerName, std::string debugName) = 0;

            int32_t layerId, std::string layerName, std::string debugName, bool isBuffer) = 0;



    // Adds a new SurfaceFrame to the current DisplayFrame. Frames from multiple layers can be

    // composited into one display frame.
@@ -431,7 +441,7 @@ public: 
    frametimeline::TokenManager* getTokenManager() override { return &mTokenManager; }

    std::shared_ptr<SurfaceFrame> createSurfaceFrameForToken(

            const FrameTimelineInfo& frameTimelineInfo, pid_t ownerPid, uid_t ownerUid,

            int32_t layerId, std::string layerName, std::string debugName) override;

            int32_t layerId, std::string layerName, std::string debugName, bool isBuffer) override;

    void addSurfaceFrame(std::shared_ptr<frametimeline::SurfaceFrame> surfaceFrame) override;

    void setSfWakeUp(int64_t token, nsecs_t wakeupTime, Fps refreshRate) override;

    void setSfPresent(nsecs_t sfPresentTime,

services/surfaceflinger/Layer.cpp

+14 −2
Original line number Diff line number Diff line
@@ -1058,6 +1058,15 @@ uint32_t Layer::doTransaction(uint32_t flags) { 
}



void Layer::commitTransaction(State& stateToCommit) {

    if (auto& bufferSurfaceFrame = mDrawingState.bufferSurfaceFrameTX;

        mDrawingState.buffer != stateToCommit.buffer && bufferSurfaceFrame != nullptr &&

        bufferSurfaceFrame->getPresentState() != PresentState::Presented) {

        // If the previous buffer was committed but not latched (refreshPending - happens during

        // back to back invalidates), it gets silently dropped here. Mark the corresponding

        // SurfaceFrame as dropped to prevent it from getting stuck in the pending classification

        // list.

        addSurfaceFrameDroppedForBuffer(bufferSurfaceFrame);

    }

    mDrawingState = stateToCommit;



    // Set the present state for all bufferlessSurfaceFramesTX to Presented. The
@@ -1537,6 +1546,7 @@ void Layer::setFrameTimelineVsyncForBufferTransaction(const FrameTimelineInfo& i 
        // Promote the bufferlessSurfaceFrame to a bufferSurfaceFrameTX

        mCurrentState.bufferSurfaceFrameTX = it->second;

        mCurrentState.bufferlessSurfaceFramesTX.erase(it);

        mCurrentState.bufferSurfaceFrameTX->promoteToBuffer();

        mCurrentState.bufferSurfaceFrameTX->setActualQueueTime(postTime);

    } else {

        mCurrentState.bufferSurfaceFrameTX =
@@ -1596,7 +1606,8 @@ std::shared_ptr<frametimeline::SurfaceFrame> Layer::createSurfaceFrameForTransac 
    auto surfaceFrame =

            mFlinger->mFrameTimeline->createSurfaceFrameForToken(info, mOwnerPid, mOwnerUid,

                                                                 getSequence(), mName,

                                                                 mTransactionName);

                                                                 mTransactionName,

                                                                 /*isBuffer*/ false);

    // For Transactions, the post time is considered to be both queue and acquire fence time.

    surfaceFrame->setActualQueueTime(postTime);

    surfaceFrame->setAcquireFenceTime(postTime);
@@ -1612,7 +1623,8 @@ std::shared_ptr<frametimeline::SurfaceFrame> Layer::createSurfaceFrameForBuffer( 
        const FrameTimelineInfo& info, nsecs_t queueTime, std::string debugName) {

    auto surfaceFrame =

            mFlinger->mFrameTimeline->createSurfaceFrameForToken(info, mOwnerPid, mOwnerUid,

                                                                 getSequence(), mName, debugName);

                                                                 getSequence(), mName, debugName,

                                                                 /*isBuffer*/ true);

    // For buffers, acquire fence time will set during latch.

    surfaceFrame->setActualQueueTime(queueTime);

    const auto fps = mFlinger->mScheduler->getFrameRateOverride(getOwnerUid());

services/surfaceflinger/tests/unittests/FrameTimelineTest.cpp

+88 −60

File changed.

Preview size limit exceeded, changes collapsed.