Hands-On Concurrency with Rust

<Hands-On Concurrency with Rust> ▶Book Description
Most programming languages can really complicate things, especially with regard to unsafe memory access. The burden on you, the programmer, lies across two domains: understanding the modern machine and your language's pain-points. This book will teach you to how to manage program performance on modern machines and build fast, memory-safe, and concurrent software in Rust. It starts with the fundamentals of Rust and discusses machine architecture concepts. You will be taken through ways to measure and improve the performance of Rust code systematically and how to write collections with confidence. You will learn about the Sync and Send traits applied to threads, and coordinate thread execution with locks, atomic primitives, data-parallelism, and more.

The book will show you how to efficiently embed Rust in C++ code and explore the functionalities of various crates for multithreaded applications. It explores implementations in depth. You will know how a mutex works and build several yourself. You will master radically different approaches that exist in the ecosystem for structuring and managing high-scale systems.

By the end of the book, you will feel comfortable with designing safe, consistent, parallel, and high-performance applications in Rust.

▶What You Will Learn
⦁ Probe your programs for performance and accuracy issues
⦁ Create your own threading and multi-processing environment in Rust
⦁ Use coarse locks from Rust's Standard library
⦁ Solve common synchronization problems or avoid synchronization using atomic programming
⦁ Build lock-free/wait-free structures in Rust and understand their implementations in the crates ecosystem
⦁ Leverage Rust's memory model and type system to build safety properties into your parallel programs
⦁ Understand the new features of the Rust programming language to ease the writing of parallel programs

▶Key Features
⦁ Learn and improve the sequential performance characteristics of your software
⦁ Understand the use of operating system processes in a high-scale concurrent system
⦁ Learn of the various coordination methods available in the Standard library

▶Who This Book Is For
This book is aimed at software engineers with a basic understanding of Rust who want to exploit the parallel and concurrent nature of modern computing environments, safely.

▶What this book covers
The material that this book covers is very broad, and it attempts to go into that material at
some depth. The material is written so that you can work straight through, but it's also
expected that some readers will only be interested in a subset of the content.

⦁ Chapter 1, Preliminaries –Machine Architecture and Getting Started with Rust, discusses modern CPU architectures, focusing specifically on x86 and ARM. These two architectures will be the focus of the book. The reader is assumed to be familiar with Rust, but we will also discuss verifying that your installation works as expected.

⦁ Chapter 2, Sequential Rust Performance and Testing, introduces inspecting the performance of a Rust program. The details of the underlying computer hardware are especially important in this: cache interactions, memory layout, and exploiting the nature of the problem domain are key to writing fast programs. However, fast doesn't matter if the results are inaccurate. This chapter also focuses on testing in Rust.

⦁ Chapter 3, The Rust Memory Model –Ownership, References and Manipulation, discusses the memory model of Rust, focusing specifically on what makes Rust memory safe, how the language is constrained to achieve such safety and how these constraints influence the fundamental types' implementations. The reader will understand the borrow checker and its ways at the close of this chapter.

⦁ Chapter 4, Sync and Send –the Foundation of Rust Concurrency, is the first in which notions of concurrency make their appearance. The chapter discusses the Sync and Send traits, both why they exist and their implications. The chapter closes with a concrete demonstration of a multithreaded Rust program. Not the last, either.

⦁ Chapter 5, Locks –Mutex, Condvar, Barriers and RWLock, introduces the coarse synchronization methods available to the Rust programmer. Each is examined in turn and demonstrated in context of an industrial Rust project, hopper. The coarse synchronization methods are elaborated on in more detail in a series of smaller projects and data structures.

⦁ Chapter 6, Atomics –the Primitives of Synchronization, introduces fine synchronization in terms of atomic primitives available on all modern CPUs. This is an exceedingly difficult topic, and a deep investigation into atomic programming and its methods is carried out. The chapter lock-free, atomic data structures, and production-grade codebases. The reader will construct many of the coarse synchronization mechanisms seen in Chapter 5, Locks –c Mutex, Condvar, Barriers and RWLock.

⦁ Chapter 7, Atomics –Safely Reclaiming Memory, discusses at length one of the key difficulties of atomic programming in any language—safely deallocating memory. The main three methods—reference counting, hazard pointers, epoch-based reclamation—are each discussed in great detail, and production-worthy codebases are investigated. Crossbeam, especially, is discussed in great detail.

⦁ Chapter 8, High-Level Parallelism –Threadpools, Parallel Iterators and Processes, motivates and
explains the implementation of thread pooling. Having this knowledge in hand, the Rayon project is investigated and subsequently used in a complex project that benefits greatly from simple data parallelism.

⦁ Chapter 9, FFI and Embedding –Combining Rust and Other Languages, extends the final project of Chapter 8, High-Level Parallelism –Threadpools, Parallel Iterators, and Processes by embedding C code into it. The rlua project, a convenient library to extend Rust programs with lua programs, is discussed. The chapter closes by compiling Rust for embedding into C, Python, and Erlang projects.

⦁ Chapter 10, Futurism –Near-Term Rust, closes the book with a discussion of the near-term changes to the language that are apropos to parallel programmers, as well as a few miscellaneous remarks.