Rust is good at being ergonomic and efficient, and that almost makes it difficult to remember that when Rust is faced with the choice between being efficient or ergonomic, it
Read MoreCategory: The future of asynchronous Rust
Challenges with asynchronous Rust – Creating Your Own Runtime
So, while we’ve seen with our own eyes that the executor and reactor could be loosely coupled, which in turn means that you could in theory mix and match reactors
Read MoreNOTE – 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 MoreTechnical requirements – Creating Your Own Runtime
In the last few chapters, we covered a lot of aspects that are relevant to asynchronous programming in Rust, but we did that by implementing alternative and simpler abstractions than
Read MoreSummary – Coroutines, Self-Referential Structs, and Pinning
What a ride, huh? If you’ve got to the end of this chapter, you’ve done a fantastic job, and I have good news for you: you pretty much know everything
Read Moreexecutor.rs – Coroutines, Self-Referential Structs, and Pinning
The first thing we must do is make sure our dependencies are correct. The only change we’re making here is adding Pin from the standard library: ch09/e-coroutines-pin/src/runtime/executor.rs… thread::{self, Thread},pin::Pin,}; The next
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 heap – Coroutines, Self-Referential Structs, and Pinning
Note The small code snippets we’ll present here can be found in this book’s GitHub repository in the ch09/d-pin folder. The different examples are implemented as different methods that you
Read More