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

Commit 0d94320c authored by Rachel Lee's avatar Rachel Lee
Browse files

Remove vsync ID generation before multi timelines. 

Cleanup. The initial vsync ID generation logic is unnecessary because
it can be handled by generateFrameTimelines.

Bug: 205721584
Test: atest libsurfaceflinger_unittest
Change-Id: I6f5f23577c2db26f05fdbbab788624ed4339800b
parent 08d8e537

services/surfaceflinger/Scheduler/EventThread.cpp

+9 −23
Original line number Original line Diff line number Diff line
@@ -108,13 +108,12 @@ DisplayEventReceiver::Event makeHotplug(PhysicalDisplayId displayId, nsecs_t tim 




DisplayEventReceiver::Event makeVSync(PhysicalDisplayId displayId, nsecs_t timestamp,

DisplayEventReceiver::Event makeVSync(PhysicalDisplayId displayId, nsecs_t timestamp,

                                      uint32_t count, nsecs_t expectedVSyncTimestamp,

                                      uint32_t count, nsecs_t expectedVSyncTimestamp,

                                      nsecs_t deadlineTimestamp, int64_t vsyncId) {

                                      nsecs_t deadlineTimestamp) {

    DisplayEventReceiver::Event event;

    DisplayEventReceiver::Event event;

    event.header = {DisplayEventReceiver::DISPLAY_EVENT_VSYNC, displayId, timestamp};

    event.header = {DisplayEventReceiver::DISPLAY_EVENT_VSYNC, displayId, timestamp};

    event.vsync.count = count;

    event.vsync.count = count;

    event.vsync.expectedVSyncTimestamp = expectedVSyncTimestamp;

    event.vsync.expectedVSyncTimestamp = expectedVSyncTimestamp;

    event.vsync.deadlineTimestamp = deadlineTimestamp;

    event.vsync.deadlineTimestamp = deadlineTimestamp;

    event.vsync.vsyncId = vsyncId;

    return event;

    return event;

}

}
@@ -356,9 +355,8 @@ void EventThread::onVSyncEvent(nsecs_t timestamp, nsecs_t expectedVSyncTimestamp 
    std::lock_guard<std::mutex> lock(mMutex);

    std::lock_guard<std::mutex> lock(mMutex);





    LOG_FATAL_IF(!mVSyncState);

    LOG_FATAL_IF(!mVSyncState);

    const int64_t vsyncId = generateToken(timestamp, deadlineTimestamp, expectedVSyncTimestamp);

    mPendingEvents.push_back(makeVSync(mVSyncState->displayId, timestamp, ++mVSyncState->count,

    mPendingEvents.push_back(makeVSync(mVSyncState->displayId, timestamp, ++mVSyncState->count,

                                       expectedVSyncTimestamp, deadlineTimestamp, vsyncId));

                                       expectedVSyncTimestamp, deadlineTimestamp));

    mCondition.notify_all();

    mCondition.notify_all();

}

}
@@ -493,16 +491,9 @@ void EventThread::threadMain(std::unique_lock<std::mutex>& lock) { 
                const auto now = systemTime(SYSTEM_TIME_MONOTONIC);

                const auto now = systemTime(SYSTEM_TIME_MONOTONIC);

                const auto deadlineTimestamp = now + timeout.count();

                const auto deadlineTimestamp = now + timeout.count();

                const auto expectedVSyncTime = deadlineTimestamp + timeout.count();

                const auto expectedVSyncTime = deadlineTimestamp + timeout.count();

                const int64_t vsyncId = [&] {

                    if (mTokenManager != nullptr) {

                        return mTokenManager->generateTokenForPredictions(

                                {now, deadlineTimestamp, expectedVSyncTime});

                    }

                    return FrameTimelineInfo::INVALID_VSYNC_ID;

                }();

                mPendingEvents.push_back(makeVSync(mVSyncState->displayId, now,

                mPendingEvents.push_back(makeVSync(mVSyncState->displayId, now,

                                                   ++mVSyncState->count, expectedVSyncTime,

                                                   ++mVSyncState->count, expectedVSyncTime,

                                                   deadlineTimestamp, vsyncId));

                                                   deadlineTimestamp));

            }

            }

        }

        }

    }

    }
@@ -579,18 +570,13 @@ void EventThread::generateFrameTimeline(DisplayEventReceiver::Event& event) cons 
        if (deadline > event.header.timestamp) {

        if (deadline > event.header.timestamp) {

            if (multiplier == 0) {

            if (multiplier == 0) {

                event.vsync.preferredFrameTimelineIndex = currentIndex;

                event.vsync.preferredFrameTimelineIndex = currentIndex;

                event.vsync.frameTimelines[currentIndex] =

            }

                        {.vsyncId = event.vsync.vsyncId,

                         .deadlineTimestamp = event.vsync.deadlineTimestamp,

                         .expectedVSyncTimestamp = event.vsync.expectedVSyncTimestamp};

            } else {

            nsecs_t expectedVSync =

            nsecs_t expectedVSync =

                    event.vsync.expectedVSyncTimestamp + multiplier * event.vsync.frameInterval;

                    event.vsync.expectedVSyncTimestamp + multiplier * event.vsync.frameInterval;

            event.vsync.frameTimelines[currentIndex] =

            event.vsync.frameTimelines[currentIndex] =

                    {.vsyncId = generateToken(event.header.timestamp, deadline, expectedVSync),

                    {.vsyncId = generateToken(event.header.timestamp, deadline, expectedVSync),

                     .deadlineTimestamp = deadline,

                     .deadlineTimestamp = deadline,

                     .expectedVSyncTimestamp = expectedVSync};

                     .expectedVSyncTimestamp = expectedVSync};

            }

            currentIndex++;

            currentIndex++;

        }

        }

    }

    }

services/surfaceflinger/tests/unittests/EventThreadTest.cpp

+10 −11
Original line number Original line Diff line number Diff line
@@ -275,17 +275,16 @@ void EventThreadTest::expectVsyncEventFrameTimelinesCorrect(nsecs_t expectedTime 
                      event.vsync.frameTimelines[i - 1].expectedVSyncTimestamp)

                      event.vsync.frameTimelines[i - 1].expectedVSyncTimestamp)

                    << "Expected vsync timestamp out of order for frame timeline " << i;

                    << "Expected vsync timestamp out of order for frame timeline " << i;

        }

        }

        if (event.vsync.frameTimelines[i].deadlineTimestamp == preferredDeadline) {



            EXPECT_EQ(i, event.vsync.preferredFrameTimelineIndex)

        // Vsync ID order lines up with registration into test token manager.

                    << "Preferred frame timeline index should be " << i;

        EXPECT_EQ(i, event.vsync.frameTimelines[i].vsyncId)

            // For the platform-preferred frame timeline, the vsync ID is 0 because the first frame

            // timeline is made before the rest.

            EXPECT_EQ(0, event.vsync.frameTimelines[i].vsyncId)

                    << "Vsync ID incorrect for frame timeline " << i;

        } else {

            // Vsync ID 0 is used for the preferred frame timeline.

            EXPECT_EQ(i + 1, event.vsync.frameTimelines[i].vsyncId)

                << "Vsync ID incorrect for frame timeline " << i;

                << "Vsync ID incorrect for frame timeline " << i;

        if (i == event.vsync.preferredFrameTimelineIndex) {

            EXPECT_EQ(event.vsync.frameTimelines[i].deadlineTimestamp, preferredDeadline)

                    << "Preferred deadline timestamp incorrect" << i;

            EXPECT_EQ(event.vsync.frameTimelines[i].expectedVSyncTimestamp,

                      event.vsync.expectedVSyncTimestamp)

                    << "Preferred expected vsync timestamp incorrect" << i;

        }

        }

    }

    }

}

}