Scheduler

Classes
class	uvco::Scheduler

Enumerations
enum class	uvco::Scheduler::RunMode { uvco::Scheduler::RunMode::Immediate = 0 , uvco::Scheduler::RunMode::Deferred = 1 }

Functions
	uvco::Scheduler::Scheduler (RunMode mode=RunMode::Deferred)
	uvco::Scheduler::Scheduler (const Scheduler &)=delete
	uvco::Scheduler::Scheduler (Scheduler &&)=delete
Scheduler &	uvco::Scheduler::operator= (const Scheduler &)=delete
Scheduler &	uvco::Scheduler::operator= (Scheduler &&)=delete
	uvco::Scheduler::~Scheduler ()
void	uvco::Scheduler::setUpLoop (uv_loop_t *loop)
void	uvco::Scheduler::enqueue (std::coroutine_handle<> handle)
	Schedule a coroutine for resumption.
void	uvco::Scheduler::runAll ()
	Run all scheduled coroutines sequentially.
void	uvco::Scheduler::close ()
bool	uvco::Scheduler::empty () const

Variables
std::vector< std::coroutine_handle<> >	uvco::Scheduler::resumableActive_
std::vector< std::coroutine_handle<> >	uvco::Scheduler::resumableRunning_
RunMode	uvco::Scheduler::run_mode_

Detailed Description

Enumeration Type Documentation

RunMode

enum class uvco::Scheduler::RunMode

strong

Enumerator
Immediate	Run an enqueued coroutine immediately, in the stack of the enqueuing function.
Deferred	Run all enqueued coroutines sequentially, after all I/O has been completed, before the next I/O poll.

                     {
    Immediate = 0,
    Deferred = 1,
  };

Function Documentation

close()

void uvco::Scheduler::close

(

)

close() should be called once the main promise has finished, and the process is preparing to exit; however, while the event loop is still running. Example: Once a user has pressed Ctrl-D in a tty application.

Otherwise, resources may be leaked. (This is usually not super important, because the event loop is finishing soon after anyway).

{ BOOST_ASSERT(resumableActive_.empty()); }

empty()

bool uvco::Scheduler::empty ( ) const

inline

{ return resumableActive_.empty(); }

enqueue()

void uvco::Scheduler::enqueue

(

std::coroutine_handle<>

handle

)

Schedule a coroutine for resumption.

                                                    {
  // Use of moved-out Scheduler?
  BOOST_ASSERT(resumableActive_.capacity() > 0);
 
  if (run_mode_ == RunMode::Immediate) {
    handle.resume();
    return;
  }
 
  resumableActive_.push_back(handle);
}

operator=() [1/2]

Scheduler & uvco::Scheduler::operator= ( const Scheduler &  )

delete

operator=() [2/2]

Scheduler & uvco::Scheduler::operator= ( Scheduler &&  )

delete

runAll()

void uvco::Scheduler::runAll

(

)

Run all scheduled coroutines sequentially.

                       {
  // In order to not delay checking for new I/O in the UV loop, we only run up
  // to a fixed number of times.
  static constexpr unsigned maxTurnsBeforeReturning = 5;
  unsigned turns = 0;
 
  while (!resumableActive_.empty() && turns < maxTurnsBeforeReturning) {
    resumableRunning_.swap(resumableActive_);
    for (unsigned i = 0; i < resumableRunning_.size(); ++i) {
      auto &coro = resumableRunning_[i];
      // Defend against resuming the same coroutine twice in the same loop pass.
      // This happens when SelectSet selects two coroutines which return at the
      // same time. Resuming the same handle twice is not good, very bad, and
      // will usually at least cause a heap use-after-free.
 
      // Check if this coroutine handle has already been resumed. This has
      // quadratic complexity, but appears to be faster than e.g. a Bloom
      // filter, because it takes fewer calculations and is a nice linear search
      // over a usually short vector.
      if (findFirstIndexOf(resumableRunning_, coro) == i) {
        // This is only true if the coroutine is a false positive in the bloom
        // filter, and has not been run before. The linear search is slow (but
        // not too slow), and only happens in the case of a false positive.
        coro.resume();
      }
    }
    resumableRunning_.clear();
    ++turns;
  }
}

Scheduler() [1/3]

uvco::Scheduler::Scheduler ( const Scheduler &  )

delete

Scheduler() [2/3]

uvco::Scheduler::Scheduler ( RunMode  mode = RunMode::Deferred )

explicit

Construct a scheduler.

If immediate_resume is true, resumed coroutines will be run immediately in the call stack of the resuming function. Otherwise the coroutine will be resumed upon the next turn of the event loop, i.e. after all activity has finished and before the next I/O poll, by call to runAll().

Call setUpLoop() to attach the scheduler to a libuv event loop.

                                 : run_mode_{mode} {
  resumableActive_.reserve(16);
  resumableRunning_.reserve(16);
}

Scheduler() [3/3]

uvco::Scheduler::Scheduler ( Scheduler &&  )

delete

setUpLoop()

void uvco::Scheduler::setUpLoop

(

uv_loop_t *

loop

)

Set up scheduler with event loop. This is required for all uvco code to find the scheduler.

{ uv_loop_set_data(loop, this); }

~Scheduler()

uvco::Scheduler::~Scheduler ( )

default

Variable Documentation

resumableActive_

std::vector<std::coroutine_handle<> > uvco::Scheduler::resumableActive_

private

resumableRunning_

std::vector<std::coroutine_handle<> > uvco::Scheduler::resumableRunning_

private

run_mode_

RunMode uvco::Scheduler::run_mode_

private