dart::ThreadPool Class Reference

#include <thread_pool.h>

Inheritance diagram for dart::ThreadPool:

Classes
class	Task

Public Member Functions
	ThreadPool (uintptr_t max_pool_size=0)
virtual	~ThreadPool ()
template<typename T , typename... Args>
bool	Run (Args &&... args)
bool	CurrentThreadIsWorker ()
void	MarkCurrentWorkerAsBlocked ()
void	MarkCurrentWorkerAsUnBlocked ()
void	Shutdown ()
uint64_t	workers_started () const
uint64_t	workers_stopped () const

Protected Member Functions
virtual void	OnEnterIdleLocked (MonitorLocker *ml)
bool	ShuttingDownLocked ()
bool	TasksWaitingToRunLocked ()

Detailed Description

Definition at line 20 of file thread_pool.h.

Constructor & Destructor Documentation

ThreadPool()

dart::ThreadPool::ThreadPool ( uintptr_t  max_pool_size = 0 )

explicit

Definition at line 37 of file thread_pool.cc.

    : all_workers_dead_(false), max_pool_size_(max_pool_size) {}

~ThreadPool()

dart::ThreadPool::~ThreadPool ( )

virtual

Definition at line 40 of file thread_pool.cc.

                        {
  Shutdown();
}

Member Function Documentation

CurrentThreadIsWorker()

bool dart::ThreadPool::CurrentThreadIsWorker

(

)

Definition at line 99 of file thread_pool.cc.

                                       {
  auto worker =
      static_cast<Worker*>(OSThread::Current()->owning_thread_pool_worker_);
  return worker != nullptr && worker->pool_ == this;
}

MarkCurrentWorkerAsBlocked()

void dart::ThreadPool::MarkCurrentWorkerAsBlocked

(

)

Definition at line 105 of file thread_pool.cc.

                                            {
  auto worker =
      static_cast<Worker*>(OSThread::Current()->owning_thread_pool_worker_);
  Worker* new_worker = nullptr;
  if (worker != nullptr) {
    MonitorLocker ml(&pool_monitor_);
    ASSERT(!worker->is_blocked_);
    worker->is_blocked_ = true;
    if (max_pool_size_ > 0) {
      ++max_pool_size_;
      // This thread is blocked and therefore no longer usable as a worker.
      // If we have pending tasks and there are no idle workers, we will spawn a
      // new thread (temporarily allow exceeding the maximum pool size) to
      // handle the pending tasks.
      if (idle_workers_.IsEmpty() && pending_tasks_ > 0) {
        new_worker = new Worker(this);
        idle_workers_.Append(new_worker);
        count_idle_++;
      }
    }
  }
  if (new_worker != nullptr) {
    new_worker->StartThread();
  }
}

MarkCurrentWorkerAsUnBlocked()

void dart::ThreadPool::MarkCurrentWorkerAsUnBlocked

(

)

Definition at line 131 of file thread_pool.cc.

                                              {
  auto worker =
      static_cast<Worker*>(OSThread::Current()->owning_thread_pool_worker_);
  if (worker != nullptr) {
    MonitorLocker ml(&pool_monitor_);
    if (worker->is_blocked_) {
      worker->is_blocked_ = false;
      if (max_pool_size_ > 0) {
        --max_pool_size_;
        ASSERT(max_pool_size_ > 0);
      }
    }
  }
}

OnEnterIdleLocked()

virtual void dart::ThreadPool::OnEnterIdleLocked ( MonitorLocker *  ml )

inlineprotectedvirtual

Reimplemented in dart::MutatorThreadPool.

Definition at line 99 of file thread_pool.h.

{}

Run()

template<typename T , typename... Args>

bool dart::ThreadPool::Run ( Args &&...  args )

inline

Definition at line 45 of file thread_pool.h.

                           {
    return RunImpl(std::unique_ptr<Task>(new T(std::forward<Args>(args)...)));
  }

Shutdown()

void dart::ThreadPool::Shutdown

(

)

Definition at line 44 of file thread_pool.cc.

                          {
  {
    MonitorLocker ml(&pool_monitor_);
 
    // Prevent scheduling of new tasks.
    shutting_down_ = true;
 
    if (running_workers_.IsEmpty() && idle_workers_.IsEmpty()) {
      // All workers have already died.
      all_workers_dead_ = true;
    } else {
      // Tell workers to drain remaining work and then shut down.
      ml.NotifyAll();
    }
  }
 
  // Wait until all workers are dead. Any new death will notify the exit
  // monitor.
  {
    MonitorLocker eml(&exit_monitor_);
    while (!all_workers_dead_) {
      eml.Wait();
    }
  }
  ASSERT(count_idle_ == 0);
  ASSERT(count_running_ == 0);
  ASSERT(idle_workers_.IsEmpty());
  ASSERT(running_workers_.IsEmpty());
 
  WorkerList dead_workers_to_join;
  {
    MonitorLocker ml(&pool_monitor_);
    ObtainDeadWorkersLocked(&dead_workers_to_join);
  }
  JoinDeadWorkersLocked(&dead_workers_to_join);
 
  ASSERT(count_dead_ == 0);
  ASSERT(dead_workers_.IsEmpty());
}

ShuttingDownLocked()

bool dart::ThreadPool::ShuttingDownLocked ( )

inlineprotected

Definition at line 102 of file thread_pool.h.

{ return shutting_down_; }

TasksWaitingToRunLocked()

bool dart::ThreadPool::TasksWaitingToRunLocked ( )

inlineprotected

Definition at line 105 of file thread_pool.h.

{ return !tasks_.IsEmpty(); }

workers_started()

uint64_t dart::ThreadPool::workers_started ( ) const

inline

Definition at line 65 of file thread_pool.h.

{ return count_idle_ + count_running_; }

workers_stopped()

uint64_t dart::ThreadPool::workers_stopped ( ) const

inline

Definition at line 67 of file thread_pool.h.

{ return count_dead_; }

---

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

• third_party/dart-lang/sdk/runtime/vm/thread_pool.h
• third_party/dart-lang/sdk/runtime/vm/thread_pool.cc