fml::ConcurrentMessageLoop Class Reference

#include <concurrent_message_loop.h>

Inheritance diagram for fml::ConcurrentMessageLoop:

Public Member Functions
virtual	~ConcurrentMessageLoop ()
size_t	GetWorkerCount () const
std::shared_ptr< ConcurrentTaskRunner >	GetTaskRunner ()
void	Terminate ()
void	PostTaskToAllWorkers (const fml::closure &task)
bool	RunsTasksOnCurrentThread ()

Static Public Member Functions
static std::shared_ptr< ConcurrentMessageLoop >	Create (size_t worker_count=std::thread::hardware_concurrency())

Protected Member Functions
	ConcurrentMessageLoop (size_t worker_count)
virtual void	ExecuteTask (const fml::closure &task)

Detailed Description

Definition at line 21 of file concurrent_message_loop.h.

Constructor & Destructor Documentation

~ConcurrentMessageLoop()

fml::ConcurrentMessageLoop::~ConcurrentMessageLoop ( )

virtual

Definition at line 29 of file concurrent_message_loop.cc.

                                              {
  Terminate();
  for (auto& worker : workers_) {
    FML_DCHECK(worker.joinable());
    worker.join();
  }
}

References FML_DCHECK, and Terminate().

ConcurrentMessageLoop()

fml::ConcurrentMessageLoop::ConcurrentMessageLoop ( size_t  worker_count )

explicitprotected

Definition at line 14 of file concurrent_message_loop.cc.

    : worker_count_(std::max<size_t>(worker_count, 1ul)) {
  for (size_t i = 0; i < worker_count_; ++i) {
    workers_.emplace_back([i, this]() {
      fml::Thread::SetCurrentThreadName(fml::Thread::ThreadConfig(
          std::string{"io.worker." + std::to_string(i + 1)}));
      WorkerMain();
    });
  }
 
  for (const auto& worker : workers_) {
    worker_thread_ids_.emplace_back(worker.get_id());
  }
}

References i, and fml::Thread::SetCurrentThreadName().

Member Function Documentation

Create()

std::shared_ptr< ConcurrentMessageLoop > fml::ConcurrentMessageLoop::Create ( size_t  worker_count = std::thread::hardware_concurrency() )

static

Definition at line 9 of file concurrent_message_loop_factory.cc.

                         {
  return std::shared_ptr<ConcurrentMessageLoop>{
      new ConcurrentMessageLoop(worker_count)};
}

Referenced by impeller::testing::MockVulkanContextBuilder::Build(), TEST(), TEST(), TEST(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), flutter::testing::TEST_F(), and flutter::testing::TEST_F().

ExecuteTask()

void fml::ConcurrentMessageLoop::ExecuteTask ( const fml::closure &  task )

protectedvirtual

Reimplemented in fml::ConcurrentMessageLoopDarwin.

Definition at line 115 of file concurrent_message_loop.cc.

                                                              {
  task();
}

GetTaskRunner()

std::shared_ptr< ConcurrentTaskRunner > fml::ConcurrentMessageLoop::GetTaskRunner

(

)

Definition at line 41 of file concurrent_message_loop.cc.

                                                                         {
  return std::make_shared<ConcurrentTaskRunner>(weak_from_this());
}

GetWorkerCount()

size_t fml::ConcurrentMessageLoop::GetWorkerCount

(

)

const

Definition at line 37 of file concurrent_message_loop.cc.

                                                   {
  return worker_count_;
}

PostTaskToAllWorkers()

void fml::ConcurrentMessageLoop::PostTaskToAllWorkers

(

const fml::closure &

task

)

Definition at line 125 of file concurrent_message_loop.cc.

                                                                       {
  if (!task) {
    return;
  }
 
  std::scoped_lock lock(tasks_mutex_);
  for (const auto& worker_thread_id : worker_thread_ids_) {
    thread_tasks_[worker_thread_id].emplace_back(task);
  }
  tasks_condition_.notify_all();
}

RunsTasksOnCurrentThread()

bool fml::ConcurrentMessageLoop::RunsTasksOnCurrentThread

(

)

Definition at line 172 of file concurrent_message_loop.cc.

                                                     {
  std::scoped_lock lock(tasks_mutex_);
  for (const auto& worker_thread_id : worker_thread_ids_) {
    if (worker_thread_id == std::this_thread::get_id()) {
      return true;
    }
  }
  return false;
}

Terminate()

void fml::ConcurrentMessageLoop::Terminate

(

)

Definition at line 119 of file concurrent_message_loop.cc.

                                      {
  std::scoped_lock lock(tasks_mutex_);
  shutdown_ = true;
  tasks_condition_.notify_all();
}

Referenced by ~ConcurrentMessageLoop().

---

The documentation for this class was generated from the following files:

• fml/concurrent_message_loop.h
• fml/concurrent_message_loop.cc
• fml/concurrent_message_loop_factory.cc
• fml/platform/darwin/concurrent_message_loop_factory.mm