SLIDE 1
The Talk you’ve been .await-ing for
@steveklabnik
The Talk youve been .await-ing for @steveklabnik async fn foo(s: - - PowerPoint PPT Presentation
The Talk youve been .await-ing for @steveklabnik async fn foo(s: - - PowerPoint PPT Presentation
The Talk youve been .await-ing for @steveklabnik async fn foo(s: String) -> i32 { // } fn foo(s: String) -> impl Future<Output=i32> { // } Stuff were going to talk about async/await and Futures Generators:
SLIDE 2
SLIDE 3
SLIDE 4
SLIDE 5
async fn foo(s: String) -> i32 { // … } fn foo(s: String) -> impl Future<Output=i32> { // … }
SLIDE 6
Stuff we’re going to talk about
- async/await and Futures
- Generators: the secret sauce
- Tasks, Executors, & Reactors, oh my!
- … maybe async fn in traits
SLIDE 7
async/await and Futures
SLIDE 8
SLIDE 9
SLIDE 10
SLIDE 11
SLIDE 12
SLIDE 13
Async/await is simpler syntax for Futures
SLIDE 14
Async/await is simpler syntax for Futures*
SLIDE 15
A Future represents a value that will exist sometime in the future
SLIDE 16
Let’s build a future!
SLIDE 17
A timer future
- Mutex around a boolean
- Spins up a new thread that sleeps for some
amount of time
- When the thread wakes up, it sets the boolean to
true and ‘wakes up’ the future
- Calls to poll check the boolean to see if we’re
done
SLIDE 18
SLIDE 19
SLIDE 20
SLIDE 21
SLIDE 22
Four rules
For using async/await
SLIDE 23
async fn foo(s: String) -> i32 { // … } fn foo(s: String) -> impl Future<Output=i32> { // … }
SLIDE 24
If you have a Future<Output=i32> and you want an i32, use .await on it
SLIDE 25
You can only .await inside of an async fn or block
SLIDE 26
To start executing a Future, you pass it to an executor
SLIDE 27
SLIDE 28
SLIDE 29
SLIDE 30
Generators aka stackless coroutines
SLIDE 31
Generators are not stable … yet
SLIDE 32
SLIDE 33
SLIDE 34
SLIDE 35
Futures need to have poll() called over and
- ver until a value is produced
Generators let you call yield over and over to get values async/await is a simpler syntax for a generator that implements the Future trait
SLIDE 36
Tasks, Executors, & Reactors
SLIDE 37
“The event loop”
SLIDE 38
Task: a unit of work to execute, a chain of Futures Executor: schedules tasks Reactor: notifies the executor that tasks are ready to execute
SLIDE 39
Interface to the reactor Executor calls poll, and provides a context
SLIDE 40
Let’s build an executor!
SLIDE 41
async fn foo() { // … }
SLIDE 42
async fn foo() { // … } spawner.spawn(foo())
SLIDE 43
async fn foo() { // … } spawner.spawn(foo()) Executor task queue
SLIDE 44
async fn foo() { // … } spawner.spawn(foo()) Executor task queue
Calls poll() on the Future
SLIDE 45
async fn foo() { // … } spawner.spawn(foo()) Executor task queue
Calls poll() on the Future
SLIDE 46
async fn foo() { // … } spawner.spawn(foo()) Executor task queue
Calls poll() on the Future
Future calls wake() (reactor)
SLIDE 47
async fn foo() { // … } spawner.spawn(foo()) Executor task queue
Calls poll() on the Future
Future calls wake() (reactor)
SLIDE 48
SLIDE 49
SLIDE 50
SLIDE 51
SLIDE 52
SLIDE 53
SLIDE 54
A quick aside about Pin<P>
SLIDE 55
Before a future starts executing, we need to be able to move it around in memory. (For example, to create a task out of it, we need to move it to the heap) Once a future starts executing, it must not move in memory. (otherwise, borrows in the body of the future would become invalid)
SLIDE 56
When you turn some sort of pointer type into a Pin<P>, you’re promising that what the pointer to will no longer move. Box<T> turns into Pin<Box<T>> There’s an extra trait, “Unpin”, that says “I don’t care about this”, similar to how Copy says “I don’t care about move semantics.
SLIDE 57
Let’s build a reactor!
SLIDE 58
(We’re not gonna build a reactor)
SLIDE 59
(We technically did build a reactor)
SLIDE 60
Bonus round: async fn in traits
SLIDE 61
SLIDE 62
A function is only one function A trait is implemented for many types, and so is many functions
SLIDE 63
SLIDE 64
SLIDE 65
It gets way more complicated
SLIDE 66
SLIDE 67
SLIDE 68
SLIDE 69
It gets way way way more complicated
SLIDE 70
SLIDE 71
SLIDE 72
SLIDE 73
Thanks!
@steveklabnik
- https://rust-lang.github.io/async-book
- https://tmandry.gitlab.io/blog/posts/optimizing-await-
- https://smallcultfollowing.com/babysteps/blog/2019/