Asynchronous Programming in Rust: Building Working Examples of Futures, Green Threads, and Runtimes

Cover
Title Page
Copyright
Dedication
Contributors
Table of Contents
Preface
Part 1:Asynchronous Programming Fundamentals
Chapter 1: Concurrency and Asynchronous Programming: a Detailed Overview
	Technical requirements
	An evolutionary journey of multitasking
		Non-preemptive multitasking
		Preemptive multitasking
		Hyper-threading
		Multicore processors
		Do you really write synchronous code?
	Concurrency versus parallelism
		The mental model I use
		Let’s draw some parallels to process economics
		Concurrency and its relation to I/O
		What about threads provided by the operating system?
		Choosing the right reference frame
		Asynchronous versus concurrent
	The role of the operating system
		Concurrency from the operating system’s perspective
		Teaming up with the operating system
		Communicating with the operating system
	The CPU and the operating system
		Down the rabbit hole
		How does the CPU prevent us from accessing memory we’re not supposed to access?
		But can’t we just change the page table in the CPU?
	Interrupts, firmware, and I/O
		A simplified overview
		Interrupts
		Firmware
	Summary
Chapter 2: Concurrency and Asynchronous Programming: a Detailed OverviewHow Programming Languages Model Asynchronous Program Flow
	Definitions
		Threads
	Threads provided by the operating system
		Creating new threads takes time
		Each thread has its own stack
		Context switching
		Scheduling
		The advantage of decoupling asynchronous operations from OS threads
		Example
	Fibers and green threads
		Each stack has a fixed space
		Context switching
		Scheduling
		FFI
	Callback based approaches
	Coroutines: promises and futures
		Coroutines and async/await
	Summary
Chapter 3: Understanding OS-Backed Event Queues, System Calls, and Cross-Platform Abstractions
	Technical requirements
		Running the Linux examples
	Why use an OS-backed event queue?
		Blocking I/O
		Non-blocking I/O
		Event queuing via epoll/kqueue and IOCP
	Readiness-based event queues
	Completion-based event queues
	epoll, kqueue, and IOCP
	Cross-platform event queues
	System calls, FFI, and cross-platform abstractions
		The lowest level of abstraction
		The next level of abstraction
		The highest level of abstraction
	Summary
Part 2:Event Queues and Green Threads
Chapter 4: Create Your Own Event Queue
	Technical requirements
	Design and introduction to epoll
		Is all I/O blocking?
	The ffi module
		Bitflags and bitmasks
		Level-triggered versus edge-triggered events
	The Poll module
	The main program
	Summary
Chapter 5: Creating Our Own Fibers
	Technical requirements
	How to use the repository alongside the book
	Background information
		Instruction sets, hardware architectures, and ABIs
		The System V ABI for x86-64
		A quick introduction to Assembly language
	An example we can build upon
		Setting up our project
		An introduction to Rust inline assembly macro
		Running our example
	The stack
		What does the stack look like?
		Stack sizes
	Implementing our own fibers
		Implementing the runtime
		Guard, skip, and switch functions
	Finishing thoughts
	Summary
Part 3:Futures and async/await in Rust
Chapter 6: Futures in Rust
	What is a future?
	Leaf futures
	Non-leaf futures
	A mental model of an async runtime
	What the Rust language and standard library take care of
	I/O vs CPU-intensive tasks
	Summary
Chapter 7: Coroutines and async/await
	Technical requirements
	Introduction to stackless coroutines
	An example of hand-written coroutines
		Futures module
		HTTP module
		Do all futures have to be lazy?
		Creating coroutines
	async/await
		coroutine/wait
		corofy—the coroutine preprocessor
		b-async-await—an example of a coroutine/wait transformation
	c-async-await—concurrent futures
	Final thoughts
	Summary
Chapter 8: Runtimes, Wakers, and the Reactor-Executor Pattern
	Technical requirements
	Introduction to runtimes and why we need them
		Reactors and executors
	Improving our base example
		Design
		Changing the current implementation
	Creating a proper runtime
	Step 1 – Improving our runtime design by adding a Reactor and a Waker
		Creating a Waker
		Changing the Future definition
	Step 2 – Implementing a proper Executor
	Step 3 – Implementing a proper Reactor
	Experimenting with our new runtime
		An example using concurrency
		Running multiple futures concurrently and in parallel
	Summary
Chapter 9: Coroutines, Self-Referential Structs, and Pinning
	Technical requirements
	Improving our example 1 – variables
		Setting up the base example
		Improving our base example
	Improving our example 2 – references
	Improving our example 3 – this is… not… good…
	Discovering self-referential structs
		What is a move?
	Pinning in Rust
		Pinning in theory
		Definitions
		Pinning to the heap
		Pinning to the stack
		Pin projections and structural pinning
	Improving our example 4 – pinning to the rescue
		future.rs
		http.rs
		Main.rs
		executor.rs
	Summary
Chapter 10: Creating Your Own Runtime
	Technical requirements
		Setting up our example
		main.rs
		future.rs
		http.rs
		executor.rs
		reactor.rs
	Experimenting with our runtime
	Challenges with asynchronous Rust
		Explicit versus implicit reactor instantiation
		Ergonomics versus efficiency and flexibility
		Common traits that everyone agrees about
		Async drop
	The future of asynchronous Rust
	Summary
	Epilogue
Index
About PACKT