The Talk You've Been Await-ing For
1 like262 views
Video and slides synchronized, mp3 and slide download available at URL https://bit.ly/344PnB1. Steve Klabnik goes over the deep details of how async/await works in Rust, covering concepts like coroutines, generators, stack-less vs stack-ful, "pinning", and more. Filmed at qconsf.com. Steve Klabnik is on the core team of Rust, leads the documentation team, and is an author of "The Rust Programming Language." He is a frequent speaker at conferences and is a prolific open source contributor, previously working on projects such as Ruby and Ruby on Rails.
More Related Content
Similar to The Talk You've Been Await-ing For (20)
More from C4Media (20)
Recently uploaded (20)
The Talk You've Been Await-ing For
- 1. The Talk you’ve been .await-ing for @steveklabnik
- 2. InfoQ.com: News & Community Site • Over 1,000,000 software developers, architects and CTOs read the site world- wide every month • 250,000 senior developers subscribe to our weekly newsletter • Published in 4 languages (English, Chinese, Japanese and Brazilian Portuguese) • Post content from our QCon conferences • 2 dedicated podcast channels: The InfoQ Podcast, with a focus on Architecture and The Engineering Culture Podcast, with a focus on building • 96 deep dives on innovative topics packed as downloadable emags and minibooks • Over 40 new content items per week Watch the video with slide synchronization on InfoQ.com! https://www.infoq.com/presentations/ rust-async-await/
- 3. Purpose of QCon - to empower software development by facilitating the spread of knowledge and innovation Strategy - practitioner-driven conference designed for YOU: influencers of change and innovation in your teams - speakers and topics driving the evolution and innovation - connecting and catalyzing the influencers and innovators Highlights - attended by more than 12,000 delegates since 2007 - held in 9 cities worldwide Presented at QCon San Francisco www.qconsf.com
- 7. async fn foo(s: String) -> i32 { // … } fn foo(s: String) -> impl Future<Output=i32> { // … }
- 8. 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
- 15. Async/await is simpler syntax for Futures
- 16. Async/await is simpler syntax for Futures*
- 17. A Future represents a value that will exist sometime in the future
- 18. Let’s build a future!
- 19. 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
- 24. Four rules For using async/await
- 25. async fn foo(s: String) -> i32 { // … } fn foo(s: String) -> impl Future<Output=i32> { // … }
- 26. If you have a Future<Output=i32> and you want an i32, use .await on it
- 27. You can only .await inside of an async fn or block
- 28. To start executing a Future, you pass it to an executor
- 32. Generators aka stackless coroutines
- 33. Generators are not stable … yet
- 37. Futures need to have poll() called over and over 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
- 38. Tasks, Executors, & Reactors
- 39. “The event loop”
- 40. Task: a unit of work to execute, a chain of Futures Executor: schedules tasks Reactor: notifies the executor that tasks are ready to execute
- 41. Interface to the reactor Executor calls poll, and provides a context
- 42. Let’s build an executor!
- 43. async fn foo() { // … }
- 44. async fn foo() { // … } spawner.spawn(foo())
- 45. async fn foo() { // … } spawner.spawn(foo()) Executor task queue
- 46. async fn foo() { // … } spawner.spawn(foo()) Executor task queue Calls poll() on the Future
- 47. async fn foo() { // … } spawner.spawn(foo()) Executor task queue Calls poll() on the Future
- 48. async fn foo() { // … } spawner.spawn(foo()) Executor task queue Calls poll() on the Future Future calls wake() (reactor)
- 49. async fn foo() { // … } spawner.spawn(foo()) Executor task queue Calls poll() on the Future Future calls wake() (reactor)
- 56. A quick aside about Pin<P>
- 57. 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)
- 58. 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.
- 59. Let’s build a reactor!
- 60. (We’re not gonna build a reactor)
- 61. (We technically did build a reactor)
- 62. Bonus round: async fn in traits
- 64. A function is only one function A trait is implemented for many types, and so is many functions
- 67. It gets way more complicated
- 71. It gets way way way more complicated
- 75. Thanks! @steveklabnik ● https://rust-lang.github.io/async-book ● https://tmandry.gitlab.io/blog/posts/optimizing-await- 1/ ● https://smallcultfollowing.com/babysteps/blog/2019/ 10/26/async-fn-in-traits-are-hard/
- 76. Watch the video with slide synchronization on InfoQ.com! https://www.infoq.com/presentations/ rust-async-await/