Rust Atomics and Locks

Foreword
Preface
Who This Book Is For
Overview of the Chapters
Code Examples
Conventions Used in This Book
Contact Information
Acknowledgments

1. Basics of Rust Concurrency
Threads in Rust
Scoped Threads
Shared Ownership and Reference Counting
Statics
Leaking
Reference Counting
Borrowing and Data Races
Interior Mutability
Cell
RefCell
Mutex and RwLock
Atomics
UnsafeCell
Thread Safety: Send and Sync
Locking: Mutexes and RwLocks
Rust’s Mutex
Lock Poisoning
Reader-Writer Lock
Waiting: Parking and Condition Variables
Thread Parking
Condition Variables
Summary

2. Atomics
Atomic Load and Store Operations
Example: Stop Flag
Example: Progress Reporting
Example: Lazy Initialization
Fetch-and-Modify Operations
Example: Progress Reporting from Multiple Threads
Example: Statistics
Example: ID Allocation
Compare-and-Exchange Operations
Example: ID Allocation Without Overflow
Example: Lazy One-Time Initialization
Summary

3. Memory Ordering
Reordering and Optimizations
The Memory Model
Happens-Before Relationship
Spawning and Joining
Relaxed Ordering
Release and Acquire Ordering
Example: Locking
Example: Lazy Initialization with Indirection
Consume Ordering
Sequentially Consistent Ordering
Fences
Common Misconceptions
Summary

4. Building Our Own Spin Lock
A Minimal Implementation
An Unsafe Spin Lock
A Safe Interface Using a Lock Guard
Summary

5. Building Our Own Channels
A Simple Mutex-Based Channel
An Unsafe One-Shot Channel
Safety Through Runtime Checks
Safety Through Types
Borrowing to Avoid Allocation
Blocking
Summary

6. Building Our Own “Arc”
Basic Reference Counting
Testing It
Mutation
Weak Pointers
Testing It
Optimizing
Summary

7. Understanding the Processor
Processor Instructions
Load and Store
Read-Modify-Write Operations
Load-Linked and Store-Conditional Instructions
Caching
Cache Coherence
Impact on Performance
Reordering
Memory Ordering
x86-64: Strongly Ordered
ARM64: Weakly Ordered
An Experiment
Memory Fences
Summary

8. Operating System Primitives
Interfacing with the Kernel
POSIX
Wrapping in Rust
Linux
Futex
Futex Operations
Priority Inheritance Futex Operations
macOS
os_unfair_lock
Windows
Heavyweight Kernel Objects
Lighter-Weight Objects
Address-Based Waiting
Summary

9. Building Our Own Locks
Mutex
Avoiding Syscalls
Optimizing Further
Benchmarking
Condition Variable
Avoiding Syscalls
Avoiding Spurious Wake-ups
Reader-Writer Lock
Avoiding Busy-Looping Writers
Avoiding Writer Starvation
Summary

10. Ideas and Inspiration
Semaphore
RCU
Lock-Free Linked List
Queue-Based Locks
Parking Lot–Based Locks
Sequence Lock
Teaching Materials

Index
About the Author