In the previous chapter, we created our own pausable tasks (coroutines) by writing them as state machines. We created a common API for these tasks by requiring them to implement the Future trait. We also showed how we can create these coroutines using some keywords and programmatically rewrite them so that we don’t have to implement these state machines by hand, and instead write our programs pretty much the same way we normally would.
If we stop for a moment and take a bird’s eye view over what we got so far, it’s conceptually pretty simple: we have an interface for pausable tasks (the Future trait), and we have two keywords (coroutine/wait) to indicate code segments we want rewritten as a state machine that divides our code into segments we can pause between.
However, we have no event loop, and we have no scheduler yet. In this chapter, we’ll expand on our example and add a runtime that allows us to run our program efficiently and opens up the possibility to schedule tasks concurrently much more efficiently than what we do now.
This chapter will take you on a journey where we implement our runtime in two stages, gradually making it more useful, efficient, and capable. We’ll start with a brief overview of what runtimes are and why we want to understand some of their characteristics. We’ll build on what we just learned in Chapter 7, and show how we can make it much more efficient and avoid continuously polling the future to make it progress by leveraging the knowledge we gained in Chapter 4.
Next, we’ll show how we can get a more flexible and loosely coupled design by dividing the runtime into two parts: an executor and a reactor.
In this chapter, you will learn about basic runtime design, reactors, executors, wakers, and spawning, and we’ll build on a lot of the knowledge we’ve gained throughout the book.
This will be one of the big chapters in this book, not because the topic is too complex or difficult, but because we have quite a bit of code to write. In addition to that, I try to give you a good mental model of what’s happening by providing quite a few diagrams and explaining everything very thoroughly. It’s not one of those chapters you typically blaze through before going to bed, though, but I do promise it’s absolutely worth it in the end.
The chapter will be divided into the following segments:
- Introduction to runtimes and why we need them
- Improving our base example
- Creating a proper runtime
- Step 1 – Improving our runtime design by adding a Reactor and a Waker
- Step 2 – Implementing a proper Executor
- Step 3 – Implementing a proper Reactor
- Experimenting with our new runtime
So, let’s dive right in!
Technical requirements
The examples in this chapter will build on the code from our last chapter, so the requirements are the same. The examples will all be cross-platform and work on all platforms that Rust (https://doc.rust-lang.org/beta/rustc/platform-support.html#tier-1-with-host-tools) and mio (https://github.com/tokio-rs/mio#platforms) supports. The only thing you need is Rust installed and the repository that belongs to the book downloaded locally. All the code in this chapter will be found in the ch08 folder.
To follow the examples step by step, you’ll also need corofy installed on your machine. If you didn’t install it in Chapter 7, install it now by going into the ch08/corofy folder in the repository and running this command:
cargo install –force –path .
Alternatively, you can just copy the relevant files in the repository when we come to the points where we use corofy to rewrite our coroutine/wait syntax. Both versions will be available to you there as well.
We’ll also use delayserver in this example, so you need to open a separate terminal, enter the delayserver folder at the root of the repository, and write cargo run so that it’s ready and available for the examples going forward.
Remember to change the ports in the code if you for some reason have to change the port delayserver listens on.