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

Commit 4376bd84 authored by Dominik Laskowski's avatar Dominik Laskowski
Browse files

SF: Remove CompositorTiming state and lock 

Replace the CompositorTiming::interval access on layer creation with a
RefreshRateConfigs lookup.

Bug: 185535769
Test: Perfetto timeline is green.
Change-Id: I0d2240f879b60c1d0ffe68be35c96a227e495ce3
parent 5d164f2b

services/surfaceflinger/Layer.cpp

+3 −3
Original line number Original line Diff line number Diff line
@@ -155,9 +155,9 @@ Layer::Layer(const LayerCreationArgs& args) 
        mDrawingState.color.g = -1.0_hf;

        mDrawingState.color.g = -1.0_hf;

        mDrawingState.color.b = -1.0_hf;

        mDrawingState.color.b = -1.0_hf;

    }

    }

    CompositorTiming compositorTiming;



    args.flinger->getCompositorTiming(&compositorTiming);

    mFrameTracker.setDisplayRefreshPeriod(

    mFrameTracker.setDisplayRefreshPeriod(compositorTiming.interval);

            args.flinger->mScheduler->getVsyncPeriodFromRefreshRateConfigs());





    mCallingPid = args.callingPid;

    mCallingPid = args.callingPid;

    mCallingUid = args.callingUid;

    mCallingUid = args.callingUid;

services/surfaceflinger/SurfaceFlinger.cpp

+8 −18
Original line number Original line Diff line number Diff line
@@ -1886,11 +1886,6 @@ void SurfaceFlinger::onComposerHalVsync(hal::HWDisplayId hwcDisplayId, int64_t t 
    }

    }

}

}





void SurfaceFlinger::getCompositorTiming(CompositorTiming* compositorTiming) {

    std::lock_guard<std::mutex> lock(getBE().mCompositorTimingLock);

    *compositorTiming = getBE().mCompositorTiming;

}



void SurfaceFlinger::onComposerHalHotplug(hal::HWDisplayId hwcDisplayId,

void SurfaceFlinger::onComposerHalHotplug(hal::HWDisplayId hwcDisplayId,

                                          hal::Connection connection) {

                                          hal::Connection connection) {

    const bool connected = connection == hal::Connection::CONNECTED;

    const bool connected = connection == hal::Connection::CONNECTED;
@@ -2349,7 +2344,7 @@ nsecs_t SurfaceFlinger::trackPresentLatency(nsecs_t compositeTime, 
    return compositeToPresentLatency;

    return compositeToPresentLatency;

}

}





void SurfaceFlinger::setCompositorTimingSnapped(nsecs_t vsyncDeadline, nsecs_t vsyncPeriod,

CompositorTiming SurfaceFlinger::makeCompositorTiming(nsecs_t vsyncDeadline, nsecs_t vsyncPeriod,

                                                      nsecs_t compositeToPresentLatency) {

                                                      nsecs_t compositeToPresentLatency) {

    // Avoid division by 0 by defaulting to 60Hz

    // Avoid division by 0 by defaulting to 60Hz

    vsyncPeriod = vsyncPeriod ?: (60_Hz).getPeriodNsecs();

    vsyncPeriod = vsyncPeriod ?: (60_Hz).getPeriodNsecs();
@@ -2377,10 +2372,9 @@ void SurfaceFlinger::setCompositorTimingSnapped(nsecs_t vsyncDeadline, nsecs_t v 
    const nsecs_t snappedCompositeToPresentLatency =

    const nsecs_t snappedCompositeToPresentLatency =

            (extraVsyncs > 0) ? idealLatency + (extraVsyncs * vsyncPeriod) : idealLatency;

            (extraVsyncs > 0) ? idealLatency + (extraVsyncs * vsyncPeriod) : idealLatency;





    std::lock_guard<std::mutex> lock(getBE().mCompositorTimingLock);

    return {.deadline = vsyncDeadline - idealLatency,

    getBE().mCompositorTiming.deadline = vsyncDeadline - idealLatency;

            .interval = vsyncPeriod,

    getBE().mCompositorTiming.interval = vsyncPeriod;

            .presentLatency = snappedCompositeToPresentLatency};

    getBE().mCompositorTiming.presentLatency = snappedCompositeToPresentLatency;

}

}





bool SurfaceFlinger::isHdrLayer(Layer* layer) const {

bool SurfaceFlinger::isHdrLayer(Layer* layer) const {
@@ -2469,7 +2463,7 @@ void SurfaceFlinger::postComposition() { 




    // We use the CompositionEngine::getLastFrameRefreshTimestamp() which might

    // We use the CompositionEngine::getLastFrameRefreshTimestamp() which might

    // be sampled a little later than when we started doing work for this frame,

    // be sampled a little later than when we started doing work for this frame,

    // but that should be okay since setCompositorTimingSnapped has snapping logic.

    // but that should be okay since makeCompositorTiming has snapping logic.

    const nsecs_t compositeTime = mCompositionEngine->getLastFrameRefreshTimestamp();

    const nsecs_t compositeTime = mCompositionEngine->getLastFrameRefreshTimestamp();

    const nsecs_t presentLatency =

    const nsecs_t presentLatency =

            trackPresentLatency(compositeTime, mPreviousPresentFences[0].fenceTime);

            trackPresentLatency(compositeTime, mPreviousPresentFences[0].fenceTime);
@@ -2477,13 +2471,9 @@ void SurfaceFlinger::postComposition() { 
    const auto& schedule = mScheduler->getVsyncSchedule();

    const auto& schedule = mScheduler->getVsyncSchedule();

    const TimePoint vsyncDeadline = schedule.vsyncDeadlineAfter(TimePoint::fromNs(now));

    const TimePoint vsyncDeadline = schedule.vsyncDeadlineAfter(TimePoint::fromNs(now));

    const Period vsyncPeriod = schedule.period();

    const Period vsyncPeriod = schedule.period();

    setCompositorTimingSnapped(vsyncDeadline.ns(), vsyncPeriod.ns(), presentLatency);





    CompositorTiming compositorTiming;

    const CompositorTiming compositorTiming =

    {

            makeCompositorTiming(vsyncDeadline.ns(), vsyncPeriod.ns(), presentLatency);

        std::lock_guard<std::mutex> lock(getBE().mCompositorTimingLock);

        compositorTiming = getBE().mCompositorTiming;

    }





    for (const auto& layer: mLayersWithQueuedFrames) {

    for (const auto& layer: mLayersWithQueuedFrames) {

        layer->onPostComposition(display, glCompositionDoneFenceTime,

        layer->onPostComposition(display, glCompositionDoneFenceTime,

services/surfaceflinger/SurfaceFlinger.h

+2 −7
Original line number Original line Diff line number Diff line
@@ -168,10 +168,6 @@ enum class LatchUnsignaledConfig { 
using DisplayColorSetting = compositionengine::OutputColorSetting;

using DisplayColorSetting = compositionengine::OutputColorSetting;





struct SurfaceFlingerBE {

struct SurfaceFlingerBE {

    // protected by mCompositorTimingLock;

    mutable std::mutex mCompositorTimingLock;

    CompositorTiming mCompositorTiming;



    // Only accessed from the main thread.

    // Only accessed from the main thread.

    struct CompositePresentTime {

    struct CompositePresentTime {

        nsecs_t composite = -1;

        nsecs_t composite = -1;
@@ -962,8 +958,7 @@ private: 
    // Returns the composite-to-present latency of the latest presented frame.

    // Returns the composite-to-present latency of the latest presented frame.

    nsecs_t trackPresentLatency(nsecs_t compositeTime, std::shared_ptr<FenceTime> presentFenceTime);

    nsecs_t trackPresentLatency(nsecs_t compositeTime, std::shared_ptr<FenceTime> presentFenceTime);





    void getCompositorTiming(CompositorTiming* compositorTiming);

    CompositorTiming makeCompositorTiming(nsecs_t vsyncDeadline, nsecs_t vsyncPeriod,

    void setCompositorTimingSnapped(nsecs_t vsyncDeadline, nsecs_t vsyncPeriod,

                                          nsecs_t compositeToPresentLatency);

                                          nsecs_t compositeToPresentLatency);





    void postFrame() REQUIRES(kMainThreadContext);

    void postFrame() REQUIRES(kMainThreadContext);

services/surfaceflinger/fuzzer/surfaceflinger_fuzzers_utils.h

+3 −10
Original line number Original line Diff line number Diff line
@@ -535,11 +535,6 @@ public: 
        mFlinger->setVsyncConfig(vsyncConfig, fdp->ConsumeIntegral<nsecs_t>());

        mFlinger->setVsyncConfig(vsyncConfig, fdp->ConsumeIntegral<nsecs_t>());

    }

    }





    void getCompositorTiming() {

        CompositorTiming compositorTiming;

        mFlinger->getCompositorTiming(&compositorTiming);

    }



    sp<IBinder> fuzzBoot(FuzzedDataProvider *fdp) {

    sp<IBinder> fuzzBoot(FuzzedDataProvider *fdp) {

        mFlinger->callingThreadHasUnscopedSurfaceFlingerAccess(fdp->ConsumeBool());

        mFlinger->callingThreadHasUnscopedSurfaceFlingerAccess(fdp->ConsumeBool());

        const sp<Client> client = new Client(mFlinger);

        const sp<Client> client = new Client(mFlinger);
@@ -634,10 +629,8 @@ public: 




        mFlinger->postComposition();

        mFlinger->postComposition();





        getCompositorTiming();



        mFlinger->trackPresentLatency(mFdp.ConsumeIntegral<nsecs_t>(), FenceTime::NO_FENCE);

        mFlinger->trackPresentLatency(mFdp.ConsumeIntegral<nsecs_t>(), FenceTime::NO_FENCE);

        mFlinger->setCompositorTimingSnapped(mFdp.ConsumeIntegral<nsecs_t>(),

        mFlinger->makeCompositorTiming(mFdp.ConsumeIntegral<nsecs_t>(),

                                       mFdp.ConsumeIntegral<nsecs_t>(),

                                       mFdp.ConsumeIntegral<nsecs_t>(),

                                       mFdp.ConsumeIntegral<nsecs_t>());

                                       mFdp.ConsumeIntegral<nsecs_t>());

services/surfaceflinger/tests/unittests/TestableSurfaceFlinger.h

+0 −2
Original line number Original line Diff line number Diff line
@@ -501,8 +501,6 @@ public: 
    }

    }

    auto& getCompositionEngine() const { return mFlinger->getCompositionEngine(); }

    auto& getCompositionEngine() const { return mFlinger->getCompositionEngine(); }





    const auto& getCompositorTiming() const { return mFlinger->getBE().mCompositorTiming; }



    mock::FrameTracer* getFrameTracer() const {

    mock::FrameTracer* getFrameTracer() const {

        return static_cast<mock::FrameTracer*>(mFlinger->mFrameTracer.get());

        return static_cast<mock::FrameTracer*>(mFlinger->mFrameTracer.get());

    }

    }