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

Commit 604709ca authored by Adithya Srinivasan's avatar Adithya Srinivasan Committed by Automerger Merge Worker
Browse files

Merge "Fix ts for prediction expired dropped frames" into sc-dev am: df0409b1 

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

Change-Id: Ibfa58047633eb8f1477e73700a36004831593d75
parents 6b93d6a8 df0409b1

services/surfaceflinger/FrameTimeline/FrameTimeline.cpp

+3 −1
Original line number Diff line number Diff line
@@ -653,8 +653,10 @@ void SurfaceFrame::traceActuals(int64_t displayFrameToken) const { 
            // If prediction is expired, we can't use the predicted start time. Instead, just use a

            // start time a little earlier than the end time so that we have some info about this

            // frame in the trace.

            nsecs_t endTime =

                    (mPresentState == PresentState::Dropped ? mDropTime : mActuals.endTime);

            packet->set_timestamp(

                    static_cast<uint64_t>(mActuals.endTime - kPredictionExpiredStartTimeDelta));

                    static_cast<uint64_t>(endTime - kPredictionExpiredStartTimeDelta));

        } else {

            packet->set_timestamp(static_cast<uint64_t>(mPredictions.startTime));

        }

services/surfaceflinger/tests/unittests/FrameTimelineTest.cpp

+75 −0
Original line number Diff line number Diff line
@@ -1347,6 +1347,81 @@ TEST_F(FrameTimelineTest, traceSurfaceFrame_predictionExpiredDoesNotTraceExpecte 
    validateTraceEvent(actualSurfaceFrameEnd, protoActualSurfaceFrameEnd);

}



TEST_F(FrameTimelineTest, traceSurfaceFrame_predictionExpiredDroppedFramesTracedProperly) {

    auto tracingSession = getTracingSessionForTest();

    auto presentFence1 = fenceFactory.createFenceTimeForTest(Fence::NO_FENCE);



    tracingSession->StartBlocking();

    constexpr nsecs_t appStartTime = std::chrono::nanoseconds(10ms).count();

    constexpr nsecs_t appEndTime = std::chrono::nanoseconds(20ms).count();

    constexpr nsecs_t appPresentTime = std::chrono::nanoseconds(30ms).count();

    int64_t surfaceFrameToken =

            mTokenManager->generateTokenForPredictions({appStartTime, appEndTime, appPresentTime});



    // Flush the token so that it would expire

    flushTokens(systemTime() + maxTokenRetentionTime);

    auto surfaceFrame1 =

            mFrameTimeline->createSurfaceFrameForToken({surfaceFrameToken, /*inputEventId*/ 0},

                                                       sPidOne, sUidOne, sLayerIdOne, sLayerNameOne,

                                                       sLayerNameOne, /*isBuffer*/ true);



    constexpr nsecs_t sfStartTime = std::chrono::nanoseconds(22ms).count();

    constexpr nsecs_t sfEndTime = std::chrono::nanoseconds(30ms).count();

    constexpr nsecs_t sfPresentTime = std::chrono::nanoseconds(30ms).count();

    int64_t displayFrameToken =

            mTokenManager->generateTokenForPredictions({sfStartTime, sfEndTime, sfPresentTime});



    // First 2 cookies will be used by the DisplayFrame

    int64_t traceCookie = snoopCurrentTraceCookie() + 2;



    auto protoActualSurfaceFrameStart =

            createProtoActualSurfaceFrameStart(traceCookie + 1, surfaceFrameToken,

                                               displayFrameToken, sPidOne, sLayerNameOne,

                                               FrameTimelineEvent::PRESENT_DROPPED, false, false,

                                               FrameTimelineEvent::JANK_NONE,

                                               FrameTimelineEvent::PREDICTION_EXPIRED);

    auto protoActualSurfaceFrameEnd = createProtoFrameEnd(traceCookie + 1);



    // Set up the display frame

    mFrameTimeline->setSfWakeUp(displayFrameToken, sfStartTime, Fps::fromPeriodNsecs(11));

    surfaceFrame1->setDropTime(sfStartTime);

    surfaceFrame1->setPresentState(SurfaceFrame::PresentState::Dropped);

    mFrameTimeline->addSurfaceFrame(surfaceFrame1);

    mFrameTimeline->setSfPresent(sfEndTime, presentFence1);

    presentFence1->signalForTest(sfPresentTime);



    addEmptyDisplayFrame();

    flushTrace();

    tracingSession->StopBlocking();



    auto packets = readFrameTimelinePacketsBlocking(tracingSession.get());

    // Display Frame 4 packets + SurfaceFrame 2 packets

    ASSERT_EQ(packets.size(), 6u);



    // Packet - 4 : ActualSurfaceFrameStart

    const auto& packet4 = packets[4];

    ASSERT_TRUE(packet4.has_timestamp());

    EXPECT_EQ(packet4.timestamp(),

              static_cast<uint64_t>(sfStartTime - SurfaceFrame::kPredictionExpiredStartTimeDelta));

    ASSERT_TRUE(packet4.has_frame_timeline_event());



    const auto& event4 = packet4.frame_timeline_event();

    ASSERT_TRUE(event4.has_actual_surface_frame_start());

    const auto& actualSurfaceFrameStart = event4.actual_surface_frame_start();

    validateTraceEvent(actualSurfaceFrameStart, protoActualSurfaceFrameStart);



    // Packet - 5 : FrameEnd (ActualSurfaceFrame)

    const auto& packet5 = packets[5];

    ASSERT_TRUE(packet5.has_timestamp());

    EXPECT_EQ(packet5.timestamp(), static_cast<uint64_t>(sfStartTime));

    ASSERT_TRUE(packet5.has_frame_timeline_event());



    const auto& event5 = packet5.frame_timeline_event();

    ASSERT_TRUE(event5.has_frame_end());

    const auto& actualSurfaceFrameEnd = event5.frame_end();

    validateTraceEvent(actualSurfaceFrameEnd, protoActualSurfaceFrameEnd);

}



// Tests for Jank classification

TEST_F(FrameTimelineTest, jankClassification_presentOnTimeDoesNotClassify) {

    // Layer specific increment