uvco::Loop Class Reference

#include <loop.h>

Collaboration diagram for uvco::Loop:

Public Member Functions
	Loop ()
	Loop (const Loop &)=delete
	Loop (Loop &&)=delete
Loop &	operator= (const Loop &)=delete
Loop &	operator= (Loop &&)=delete
	~Loop ()
uv_loop_t *	uvloop () const
	Get a non-owned pointer to the loop.

Static Public Member Functions
static void	enqueue (std::coroutine_handle<> handle)
static void	cancel (std::coroutine_handle<> handle)
static std::coroutine_handle	getNext ()

Private Member Functions
void	run ()
void	runOne ()

Static Private Member Functions
static Scheduler &	currentScheduler ()

Private Attributes
uv_loop_t	loop_
Scheduler	scheduler_
bool	stopped_ = false

Static Private Attributes
static Loop *	defaultLoop = nullptr

Friends
void	runLoop (Loop &loop)

Detailed Description

Not used by user code! Use runMain() for the top-level interface.

A wrapper around a libuv event loop. uvloop() returns a reference to the loop, and run() starts the event loop. enqueue() schedules a coroutine to run on the default loop at a later time, enabling any part of uvco to easily schedule work on the current loop.

Typically this is only used by uvco's internal machinery. User code will pass around a reference to the loop.

Constructor & Destructor Documentation

Loop() [1/3]

uvco::Loop::Loop

(

)

           : loop_{} {
 
  if (defaultLoop != nullptr) {
    throw UvcoException(UV_EBUSY,
                        "Loop::Loop(): only one loop can be created.");
  }
 
  uv_loop_init(&loop_);
 
#ifdef UV_LOOP_USE_IO_URING_SQPOLL
  const uv_status configureStatus =
      uv_loop_configure(&loop_, UV_LOOP_USE_IO_URING_SQPOLL);
  if (configureStatus != 0) {
    fmt::print(stderr, "Could not configure io_uring for file access: {}",
               uv_strerror(configureStatus));
  }
#endif
  defaultLoop = this;
}

Loop() [2/3]

uvco::Loop::Loop ( const Loop & )

delete

Loop() [3/3]

uvco::Loop::Loop ( Loop && )

delete

~Loop()

uvco::Loop::~Loop

(

)

            {
  scheduler_.close();
 
  // Run loop again so that all handles are closed.
  // A single turn is enough.
  runOne();
 
  // Now run all scheduled handles
  scheduler_.runAll();
 
  const uv_status status = uv_loop_close(&loop_);
  if (0 != status) {
    fmt::print(stderr,
               "Loop::~Loop(): uv_loop_close() failed; there were "
               "still resources on the loop: {}\n",
               uv_strerror(status));
    // Walk the loop and print all handles that are still active.
    uv_walk(&loop_, handleWalkCallbackForDebug, nullptr);
  }
  defaultLoop = nullptr;
}

Member Function Documentation

cancel()

void uvco::Loop::cancel ( std::coroutine_handle<> handle )

static

                                              {
  currentScheduler().cancel(handle);
}

currentScheduler()

Scheduler & uvco::Loop::currentScheduler ( )

staticprivate

                                  {
  if (defaultLoop == nullptr) [[unlikely]] {
    throw UvcoException(UV_EINVAL, "Loop::getDefaultLoop(): no loop created.");
  }
  return defaultLoop->scheduler_;
}

enqueue()

void uvco::Loop::enqueue ( std::coroutine_handle<> handle )

static

                                               {
  currentScheduler().enqueue(handle);
  // If any handles are present, ensure that uv_run returns from waiting for I/O
  // soon.
  if (!defaultLoop->stopped_) [[unlikely]] {
    uv_stop(defaultLoop->uvloop());
    defaultLoop->stopped_ = true;
  }
}

getNext()

std::coroutine_handle uvco::Loop::getNext ( )

static

{ return currentScheduler().getNext(); }

operator=() [1/2]

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

delete

operator=() [2/2]

Loop & uvco::Loop::operator= ( Loop && )

delete

run()

void uvco::Loop::run ( )

private

Run the event loop. This will serve all promises initialized before calling it.

               {
  while (!scheduler_.empty() || uv_loop_alive(&loop_) != 0) {
    stopped_ = false;
    runOne();
    // Run any left-over coroutines, and check if they schedule callbacks.
    scheduler_.runAll();
  }
 
  if constexpr (logSchedulerOperations) {
    fmt::print("exiting loop due to scheduler empty? {} uv_loop_alive? {}\n",
               scheduler_.empty() ? "yes" : "no",
               uv_loop_alive(&loop_) != 0 ? "yes" : "no");
  }
}

runOne()

void uvco::Loop::runOne ( )

private

{ uv_run(&loop_, UV_RUN_ONCE); }

uvloop()

uv_loop_t * uvco::Loop::uvloop ( ) const

nodiscard

Get a non-owned pointer to the loop.

{ return &loop_; }

Friends And Related Symbol Documentation

runLoop

void runLoop ( Loop & loop )

friend

{ loop.run(); }

Member Data Documentation

defaultLoop

Loop * uvco::Loop::defaultLoop = nullptr

staticprivate

loop_

uv_loop_t uvco::Loop::loop_

mutableprivate

scheduler_

Scheduler uvco::Loop::scheduler_

private

stopped_

bool uvco::Loop::stopped_ = false

private

---

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

• uvco/loop/loop.h
• uvco/loop/loop.cc