Point to the low end of the allocated stack

Try stealing from all queues the scheduler knows about. This naive implementation can steal from our own queue or from other special schedulers.

Write the contents of `buf` at position `pos`. If `pos` is -1, then the data will be written at the current position in the file.

Borrow a reference to the local event loop. If there is no local event loop, or the local event loop is already borrowed, then an error is returned.

Check at runtime that the task has *not* transplanted itself to a different I/O loop while executing.

Invokes uv_close This is unsafe as there is no guarantee that this handle is not actively being used by other objects.

Close an event loop. This function is unsafe because there is no guarantee that the event loop is not currently active elsewhere. If the event loops

Dequeue a blocked task with a specified token. This is unsafe because it is only safe to invoke while on the home event loop, and there is no guarante

Point one uint beyond the high end of the allocated stack

First step in the process is to find a task. This function does that by first checking the local queue, and if there is no work there, trying to steal

Same as `get_host_addresses`, but specifies what event loop to run on.

This function will move tasks to run on their home I/O scheduler. Note that this function does *not* pin the task to the I/O scheduler, but rather it

Grants access to half of a duplex stream, timing out if necessary. On success, Ok(Guard) is returned and access has been granted to the stream. If a

Run the idle callback if one is registered

FIXME: Seems like a really weird requirement to have an event loop provide.

Gain access to the underlying raw tty object. This function is unsafe as there is no guarantee that any safe modifications to the tty handle are actu

Gain access to the underlying raw pipe object. This function is unsafe as there is no guarantee that any safe modifications to the pipe handle are ac

Gain access to the underlying raw tcp object. This function is unsafe as there is no guarantee that any safe modifications to the tcp handle are actu

Destroy coroutine and try to reuse std::stack segment.

Execute the main function in a pool of M:N schedulers. Configures the runtime according to the environment, by default using a task scheduler with th

This function is run from the idle callback on the uv loop, indicating that there are no I/O events pending. When this function returns, we will fall

Take a non-homed task we aren't allowed to run here and send it to the designated friend scheduler to execute.

See documentation for `spawn`.

Called by a running task to end execution, after which it will be recycled by the scheduler for reuse in a new task.

Gain access to the underlying event loop. This method is unsafe as there is no guarantee that further safe methods called on the `Loop` will be valid