Runtimes, Wakers, and the Reactor-Executor Pattern

In this step, we’ll make the following changes:

1. Change the project structure so that it reflects our new design.
2. Find a way for the executor to sleep and wake up that does not rely directly on Poll and create a Waker based on this that allows us to wake up the executor and identify which task is ready to progress.
3. Change the trait definition for Future so that poll takes a &Waker as an argument.

Tip

You’ll find this example in the ch08/b-reactor-executor folder. If you follow along by writing the examples from the book, I suggest that you create a new project called b-reactor-executor for this example by following these steps:

 1. Create a new folder called b-reactor-executor.

 2. Enter the newly created folder and write cargo init.

 3. Copy everything in the src folder in the previous example, a-runtime, into the src folder of a new project.

 4. Copy the dependencies section of the Cargo.toml file into the Cargo.toml file in the new project.

Let’s start by making some changes to our project structure to set it up so that we can build on it going forward. The first thing we do is divide our runtime module into two submodules, reactor and executor:

1. Create a new subfolder in the src folder called runtime.
2. Create two new files in the runtime folder called reactor.rs and executor.rs.
3. Just below the imports in runtime.rs, declare the two new modules by adding these lines:

mod executor;
mod reactor;

You should now have a folder structure that looks like this:
src
 |– runtime
        |– executor.rs
        |– reactor.rs
 |– future.rs
 |– http.rs
 |– main.rs
 |– runtime.rs

To set everything up, we start by deleting everything in runtime.rs and replacing it with the following lines of code:

ch08/b-reactor-executor/src/runtime.rs
pub use executor::{spawn, Executor, Waker};
pub use reactor::reactor;
mod executor;
mod reactor;
pub fn init() -> Executor {
    reactor::start();
    Executor::new()
}

The new content of runtime.rs first declares two submodules called executor and reactor. We then declare one function called init that starts our Reactor and creates a new Executor that it returns to the caller.

The next point on our list is to find a way for our Executor to sleep and wake up when needed without relying on Poll.