Scheduler

Classes
class	uvco::Scheduler

Functions
	uvco::Scheduler::Scheduler ()
	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::enqueue (std::coroutine_handle<> handle)
	Schedule a coroutine for resumption.
void	uvco::Scheduler::cancel (std::coroutine_handle<> handle)
void	uvco::Scheduler::runAll ()
	Run all scheduled coroutines sequentially.
std::coroutine_handle	uvco::Scheduler::getNext ()
void	uvco::Scheduler::close ()
bool	uvco::Scheduler::empty () const
std::coroutine_handle	uvco::Scheduler::getNextInner ()

Variables
static constexpr bool	uvco::logSchedulerOperations = false
	If set to true, log scheduler operations to stdout.
std::deque< std::coroutine_handle<> >	uvco::Scheduler::resumable_

Detailed Description

Function Documentation

cancel()

void uvco::Scheduler::cancel

(

std::coroutine_handle<>

handle

)

                                                   {
  BOOST_ASSERT(handle != nullptr);
  if constexpr (logSchedulerOperations) {
    fmt::print("Cancelling coroutine {:x}\n", (uintptr_t)handle.address());
  }
 
  for (auto &it : resumable_) {
    if (it == handle) {
      it = nullptr;
    }
  }
}

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(resumable_.empty()); }

empty()

bool uvco::Scheduler::empty ( ) const

inlinenodiscard

{ return resumable_.empty(); }

enqueue()

void uvco::Scheduler::enqueue

(

std::coroutine_handle<>

handle

)

Schedule a coroutine for resumption.

                                                    {
  if constexpr (logSchedulerOperations) {
    fmt::print("Enqueuing coroutine {:x}\n", (uintptr_t)handle.address());
  }
  resumable_.push_back(handle);
}

getNext()

std::coroutine_handle uvco::Scheduler::getNext

(

)

Returns a handle to the next runnable suspended coroutine. This is mainly used by Loop::getNext() which in turns is used to implement symmetric hand-off, i.e. decentralized scheduling. By using this, all suspending awaiters can hand off control directly to the next coroutine instead of going through the scheduler first. This behavior can be disabled by setting the useSymmetricHandoff compile-time variable to false in scheduler.cc.

                                         {
  if constexpr (useSymmetricHandoff) {
    return getNextInner();
  } else {
    return std::noop_coroutine();
  }
}

getNextInner()

std::coroutine_handle uvco::Scheduler::getNextInner ( )

private

                                              {
  std::coroutine_handle<> next{nullptr};
  while (!resumable_.empty() && (next == nullptr || next.done())) {
    next = resumable_.front();
    resumable_.pop_front();
  }
  if (next == nullptr || next.done()) {
    return std::noop_coroutine();
  }
  if constexpr (logSchedulerOperations) {
    fmt::print("Dequeuing coroutine {:x}, {} left\n", (uintptr_t)next.address(),
               resumable_.size());
  }
  return next;
}

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.

                       {
  while (!resumable_.empty()) {
    const std::coroutine_handle<> next = getNextInner();
    BOOST_ASSERT(next != nullptr && !next.done());
    if constexpr (logSchedulerOperations) {
      fmt::print("Resuming coroutine {:x}\n", (uintptr_t)next.address());
    }
    next.resume();
  }
}

Scheduler() [1/3]

uvco::Scheduler::Scheduler ( )

default

Scheduler() [2/3]

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

delete

Scheduler() [3/3]

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

delete

~Scheduler()

uvco::Scheduler::~Scheduler ( )

default

Variable Documentation

logSchedulerOperations

bool uvco::logSchedulerOperations = false

staticconstexpr

If set to true, log scheduler operations to stdout.

resumable_

std::deque<std::coroutine_handle<> > uvco::Scheduler::resumable_

private