So, in this chapter, we did two things. First, we made some rather minor changes to our runtime so it works as an actual runtime for Rust futures. We tested
Read MoreCategory: Discovering self-referential structs
NOTE – Creating Your Own Runtime
Calling Runtime::new creates a multithreaded Tokio runtime, but Tokio also has a single-threaded runtime that you can create by using the runtime builder like this: Builder::new_current_thread().enable_all().build().unwrap(). If you do that,
Read MoreExperimenting with our runtime – Creating Your Own Runtime
Note You’ll find this example in the book’s repository in the ch10/b-rust-futures-experiments folder. The different experiments will be implemented as different versions of the async_main function numbered chronologically. I’ll indicate
Read Morereactor.rs – Creating Your Own Runtime
The first thing we do is to make sure our dependencies are correct. We have to remove the dependency on our old Waker implementation and instead pull in these types
Read MoreINFO – Creating Your Own Runtime
This is an example of Rust adopting what turns out to be best practices from the ecosystem. For a long time, a popular way to construct wakers was by implementing
Read Morehttp.rs – Coroutines, Self-Referential Structs, and Pinning
The first thing we need to do is pull in Pin from the standard library. The start of the file should look like this: ch09/e-coroutines-pin/src/http.rsuse crate::{future::PollState, runtime::{self, reactor, Waker}, Future};use
Read MorePin projections and structural pinning – Coroutines, Self-Referential Structs, and Pinning
Before we leave the topic of pinning, we’ll quickly explain what pin projections and structural pinning are. Both sound complex, but they are very simple in practice. The following diagram
Read MorePinning to the stack – Coroutines, Self-Referential Structs, and Pinning
Pinning to the stack can be somewhat difficult. In Chapter 5, we saw how the stack worked and we know that it grows and shrinks as values are popped and
Read MorePinning in Rust – Coroutines, Self-Referential Structs, and Pinning
The following diagram shows a slightly more complex self-referential struct so that we have something visual to help us understand: Figure 9.3 – Moving a self-referential struct with three fields
Read MoreDiscovering self-referential structs – Coroutines, Self-Referential Structs, and Pinning
What happened is that we created a self-referential struct, initialized it so that it took a pointer to itself, and then moved it. Let’s take a closer look: You’ve now
Read More