A lazy future is one where no work happens before it’s polled the first time. This will come up a lot if you read about futures in Rust, and since
When creating HttpGetFuture, we don’t actually do anything related to the GET request, which means that the call to Http::get returns immediately with just a simple data structure. In contrast
In this module, we’ll implement a very simple HTTP client. This client can only make GET requests to our delayserver since we just use this as a representation of a
The example we’ll use going forward is a simplified version of Rust’s asynchronous model. We’ll create and implement the following: So, to actually demystify coroutines, futures, and async/await, we will
Most often you’ll see stackless coroutines simply referred to as coroutines. To try to keep some consistency (you remember I don’t like to introduce terms that mean different things based
In Chapter 5, we covered one of the most popular ways of modeling concurrency in a programming language: fibers/green threads. Fibers/green threads are an example of stackful coroutines. The other
I want to round off this chapter by pointing out some of the advantages and disadvantages of this approach, which we went through in Chapter 2, since we now have
These are hex numbers indicating the offset from the memory pointer to which we want to read/write. I wrote down the base 10 numbers as comments, so as you can
There are a few functions we’ve referred to that are really important for our Runtime to actually work. Fortunately, all but one of them are extremely simple to understand. We’ll
Note The registers we save in our ThreadContext struct are the registers that are marked as callee saved in Figure 5.1. We need to save these since the ABI states