Welcome. The aim of this book is to teach beginner and moderate Rust programmers how to exploit modern parallel machines in the Rust programming language. This book will contain a variety of information relevant specifically to the Rust programming language, especially with regard to its standard library, but it will also contain information that is more generally applicable but happens to be expressed in Rust. Rust itself is not a terribly inventive language. Its key contribution, from where I sit, is the mainstreaming of affine types with application to memory allocation tracking. In most other respects, it is a familiar systems programming language, one that ought to feel familiar—with a bit of adjustment—to those with a background in GC-less programming languages. This is a good thing, considering our aim here is to investigate concurrency—there is a wealth of information available in the papers and books written about this subject, and we understand and apply their concepts. This book will reference a number of such works, whose contexts are C++ , ATS, ADA, and similar languages.
-
Book Overview & Buying
-
Table Of Contents
-
Feedback & Rating
Hands-On Concurrency with Rust
By :
Hands-On Concurrency with Rust
By:
Overview of this book
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.
Table of Contents (12 chapters)
Preface
Free Chapter
Preliminaries – Machine Architecture and Getting Started with Rust
Sequential Rust Performance and Testing
The Rust Memory Model – Ownership, References and Manipulation
Sync and Send – the Foundation of Rust Concurrency
Locks – Mutex, Condvar, Barriers and RWLock
Atomics – the Primitives of Synchronization
Atomics – Safely Reclaiming Memory
High-Level Parallelism – Threadpools, Parallel Iterators and Processes
FFI and Embedding – Combining Rust and Other Languages
Futurism – Near-Term Rust
Other Books You May Enjoy
Customer Reviews
