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

Commit 42a27b56 authored by Vishnu Nair's avatar Vishnu Nair
Browse files

SF: Update InputFlinger outside main thread 

Avoids parceling data inside  main thread and hot path. Also
avoids any binder contention with one way binder calls. See
bug for more details.

Bug: 206380307
Test: presubmit
Test: systrace
Change-Id: I4f8640587c821ac471559f1e6d2fbe41a8e64c87
parent 34eb9ca5

libs/gui/LayerState.cpp

+1 −3
Original line number Diff line number Diff line
@@ -546,9 +546,7 @@ bool InputWindowCommands::merge(const InputWindowCommands& other) { 
}



bool InputWindowCommands::empty() const {

    bool empty = true;

    empty = focusRequests.empty() && !syncInputWindows;

    return empty;

    return focusRequests.empty() && !syncInputWindows;

}



void InputWindowCommands::clear() {

services/surfaceflinger/BackgroundExecutor.cpp

+5 −3
Original line number Diff line number Diff line
@@ -32,7 +32,9 @@ BackgroundExecutor::BackgroundExecutor() : Singleton<BackgroundExecutor>() { 
            std::vector<std::function<void()>> tasks;

            {

                std::unique_lock lock(mMutex);

                mWorkAvailableCv.wait(lock, [&]() { return mDone || !mTasks.empty(); });

                android::base::ScopedLockAssertion assumeLock(mMutex);

                mWorkAvailableCv.wait(lock,

                                      [&]() REQUIRES(mMutex) { return mDone || !mTasks.empty(); });

                tasks = std::move(mTasks);

                mTasks.clear();

                done = mDone;
@@ -47,7 +49,7 @@ BackgroundExecutor::BackgroundExecutor() : Singleton<BackgroundExecutor>() { 


BackgroundExecutor::~BackgroundExecutor() {

    {

        std::unique_lock lock(mMutex);

        std::scoped_lock lock(mMutex);

        mDone = true;

        mWorkAvailableCv.notify_all();

    }
@@ -57,7 +59,7 @@ BackgroundExecutor::~BackgroundExecutor() { 
}



void BackgroundExecutor::execute(std::function<void()> task) {

    std::unique_lock lock(mMutex);

    std::scoped_lock lock(mMutex);

    mTasks.emplace_back(std::move(task));

    mWorkAvailableCv.notify_all();

}

services/surfaceflinger/BackgroundExecutor.h

+4 −3
Original line number Diff line number Diff line
@@ -16,6 +16,7 @@ 


#pragma once



#include <android-base/thread_annotations.h>

#include <utils/Singleton.h>

#include <condition_variable>

#include <mutex>
@@ -33,10 +34,10 @@ public: 


private:

    std::mutex mMutex;

    std::condition_variable mWorkAvailableCv;

    std::condition_variable mWorkAvailableCv GUARDED_BY(mMutex);

    bool mDone GUARDED_BY(mMutex) = false;

    std::vector<std::function<void()>> mTasks GUARDED_BY(mMutex);

    std::thread mThread;

    bool mDone = false;

    std::vector<std::function<void()>> mTasks;

};



} // namespace android

services/surfaceflinger/SurfaceFlinger.cpp

+39 −22
Original line number Diff line number Diff line
@@ -93,6 +93,7 @@ 
#include <type_traits>

#include <unordered_map>



#include "BackgroundExecutor.h"

#include "BufferLayer.h"

#include "BufferQueueLayer.h"

#include "BufferStateLayer.h"
@@ -508,7 +509,7 @@ void SurfaceFlinger::binderDied(const wp<IBinder>&) { 
    mBootFinished = false;



    // Sever the link to inputflinger since it's gone as well.

    static_cast<void>(mScheduler->schedule([=] { mInputFlinger = nullptr; }));

    BackgroundExecutor::getInstance().execute([=] { mInputFlinger = nullptr; });



    // restore initial conditions (default device unblank, etc)

    initializeDisplays();
@@ -719,13 +720,15 @@ void SurfaceFlinger::bootFinished() { 


    sp<IBinder> input(defaultServiceManager()->getService(String16("inputflinger")));



    static_cast<void>(mScheduler->schedule([=] {

    BackgroundExecutor::getInstance().execute([=] {

        if (input == nullptr) {

            ALOGE("Failed to link to input service");

        } else {

            mInputFlinger = interface_cast<os::IInputFlinger>(input);

        }

    });



    static_cast<void>(mScheduler->schedule([=] {

        readPersistentProperties();

        mPowerAdvisor.onBootFinished();

        mBootStage = BootStage::FINISHED;
@@ -3004,32 +3007,48 @@ void SurfaceFlinger::commitTransactionsLocked(uint32_t transactionFlags) { 


void SurfaceFlinger::updateInputFlinger() {

    ATRACE_CALL();

    std::vector<WindowInfo> windowInfos;

    std::vector<DisplayInfo> displayInfos;

    bool updateWindowInfo = false;

    if (mVisibleRegionsDirty || mInputInfoChanged) {

        mInputInfoChanged = false;

        updateWindowInfo = true;

        buildWindowInfos(windowInfos, displayInfos);

    }

    if (!updateWindowInfo && mInputWindowCommands.empty()) {

        return;

    }

    BackgroundExecutor::getInstance().execute([updateWindowInfo,

                                               windowInfos = std::move(windowInfos),

                                               displayInfos = std::move(displayInfos),

                                               inputWindowCommands =

                                                       std::move(mInputWindowCommands),

                                               this]() {

        ATRACE_NAME("BackgroundExecutor::updateInputFlinger");

        if (!mInputFlinger) {

            return;

        }



    if (mVisibleRegionsDirty || mInputInfoChanged) {

        mInputInfoChanged = false;

        notifyWindowInfos();

    } else if (mInputWindowCommands.syncInputWindows) {

        if (updateWindowInfo) {

            mWindowInfosListenerInvoker->windowInfosChanged(windowInfos, displayInfos,

                                                            inputWindowCommands.syncInputWindows);

        } else if (inputWindowCommands.syncInputWindows) {

            // If the caller requested to sync input windows, but there are no

            // changes to input windows, notify immediately.

            windowInfosReported();

        }



    for (const auto& focusRequest : mInputWindowCommands.focusRequests) {

        for (const auto& focusRequest : inputWindowCommands.focusRequests) {

            mInputFlinger->setFocusedWindow(focusRequest);

        }

    });



    mInputWindowCommands.clear();

}



void SurfaceFlinger::notifyWindowInfos() {

    std::vector<WindowInfo> windowInfos;

    std::vector<DisplayInfo> displayInfos;

void SurfaceFlinger::buildWindowInfos(std::vector<WindowInfo>& outWindowInfos,

                                      std::vector<DisplayInfo>& outDisplayInfos) {

    std::unordered_map<uint32_t /*layerStackId*/,

                       std::pair<bool /* isSecure */, const ui::Transform>>

            inputDisplayDetails;



    for (const auto& [_, display] : ON_MAIN_THREAD(mDisplays)) {

        if (!display->receivesInput()) {

            continue;
@@ -3043,7 +3062,7 @@ void SurfaceFlinger::notifyWindowInfos() { 
                  layerStackId);

            continue;

        }

        displayInfos.emplace_back(info);

        outDisplayInfos.emplace_back(info);

    }



    mDrawingState.traverseInReverseZOrder([&](Layer* layer) {
@@ -3063,10 +3082,8 @@ void SurfaceFlinger::notifyWindowInfos() { 
                  layer->getDebugName(), layerStackId);

        }



        windowInfos.push_back(layer->fillInputInfo(displayTransform, isSecure));

        outWindowInfos.push_back(layer->fillInputInfo(displayTransform, isSecure));

    });

    mWindowInfosListenerInvoker->windowInfosChanged(windowInfos, displayInfos,

                                                    mInputWindowCommands.syncInputWindows);

}



void SurfaceFlinger::updateCursorAsync() {

services/surfaceflinger/SurfaceFlinger.h

+3 −1
Original line number Diff line number Diff line
@@ -689,7 +689,8 @@ private: 
    void updateLayerGeometry();



    void updateInputFlinger();

    void notifyWindowInfos();

    void buildWindowInfos(std::vector<gui::WindowInfo>& outWindowInfos,

                          std::vector<gui::DisplayInfo>& outDisplayInfos);

    void commitInputWindowCommands() REQUIRES(mStateLock);

    void updateCursorAsync();
@@ -1289,6 +1290,7 @@ private: 
    const float mInternalDisplayDensity;

    const float mEmulatedDisplayDensity;



    // Should only be accessed by BackgroundExecutor thread.

    sp<os::IInputFlinger> mInputFlinger;

    // Should only be accessed by the main thread.

    InputWindowCommands mInputWindowCommands;