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

Commit 8437a42d authored by Prabir Pradhan's avatar Prabir Pradhan Committed by Android (Google) Code Review
Browse files

Merge "InputTracer: Use InputThread instead of std::thread" into main

parents 611a65d5 47827688

services/inputflinger/dispatcher/trace/ThreadedBackend.cpp

+29 −33
Original line number Diff line number Diff line
@@ -21,7 +21,6 @@ 
#include "InputTracingPerfettoBackend.h"



#include <android-base/logging.h>

#include <utils/AndroidThreads.h>



namespace android::inputdispatcher::trace::impl {
@@ -39,7 +38,10 @@ struct Visitor : V... { 


template <typename Backend>

ThreadedBackend<Backend>::ThreadedBackend(Backend&& innerBackend)

      : mTracerThread(&ThreadedBackend::threadLoop, this), mBackend(std::move(innerBackend)) {}

      : mTracerThread(

                "InputTracer", [this]() { threadLoop(); },

                [this]() { mThreadWakeCondition.notify_all(); }),

        mBackend(std::move(innerBackend)) {}



template <typename Backend>

ThreadedBackend<Backend>::~ThreadedBackend() {
@@ -48,7 +50,6 @@ ThreadedBackend<Backend>::~ThreadedBackend() { 
        mThreadExit = true;

    }

    mThreadWakeCondition.notify_all();

    mTracerThread.join();

}



template <typename Backend>
@@ -74,38 +75,33 @@ void ThreadedBackend<Backend>::traceWindowDispatch(const WindowDispatchArgs& dis 


template <typename Backend>

void ThreadedBackend<Backend>::threadLoop() {

    androidSetThreadName("InputTracer");

    std::vector<TraceEntry> entries;



    std::vector<std::variant<TracedKeyEvent, TracedMotionEvent, WindowDispatchArgs>> events;



    while (true) {

    { // acquire lock

        std::unique_lock lock(mLock);

        base::ScopedLockAssertion assumeLocked(mLock);



        // Wait until we need to process more events or exit.

            mThreadWakeCondition.wait(lock, [&]() REQUIRES(mLock) {

                return mThreadExit || !mQueue.empty();

            });

        mThreadWakeCondition.wait(lock,

                                  [&]() REQUIRES(mLock) { return mThreadExit || !mQueue.empty(); });

        if (mThreadExit) {

            return;

        }



            mQueue.swap(events);

        mQueue.swap(entries);

    } // release lock



    // Trace the events into the backend without holding the lock to reduce the amount of

    // work performed in the critical section.

        for (const auto& event : events) {

    for (const auto& entry : entries) {

        std::visit(Visitor{[&](const TracedMotionEvent& e) { mBackend.traceMotionEvent(e); },

                           [&](const TracedKeyEvent& e) { mBackend.traceKeyEvent(e); },

                           [&](const WindowDispatchArgs& args) {

                               mBackend.traceWindowDispatch(args);

                           }},

                       event);

        }

        events.clear();

                   entry);

    }

    entries.clear();

}



// Explicit template instantiation for the PerfettoBackend.

services/inputflinger/dispatcher/trace/ThreadedBackend.h

+4 −4
Original line number Diff line number Diff line
@@ -16,11 +16,11 @@ 


#pragma once



#include "InputThread.h"

#include "InputTracingPerfettoBackend.h"



#include <android-base/thread_annotations.h>

#include <mutex>

#include <thread>

#include <variant>

#include <vector>
@@ -44,12 +44,12 @@ public: 


private:

    std::mutex mLock;

    std::thread mTracerThread;

    InputThread mTracerThread;

    bool mThreadExit GUARDED_BY(mLock){false};

    std::condition_variable mThreadWakeCondition;

    Backend mBackend;

    std::vector<std::variant<TracedKeyEvent, TracedMotionEvent, WindowDispatchArgs>> mQueue

            GUARDED_BY(mLock);

    using TraceEntry = std::variant<TracedKeyEvent, TracedMotionEvent, WindowDispatchArgs>;

    std::vector<TraceEntry> mQueue GUARDED_BY(mLock);



    using WindowDispatchArgs = InputTracingBackendInterface::WindowDispatchArgs;