Hands-On Concurrency with Rust : Confidently Build Memory-Safe, Parallel, and Efficient Software in Rust.

Cover -- Title Page -- Copyright and Credits -- Dedication -- Packt Upsell -- Contributors -- Table of Contents -- Preface -- Chapter 1: Preliminaries - Machine Architecture and Getting Started with Rust -- Technical requirements -- The machine -- The CPU -- Memory and caches -- Memory model -- Getting set up -- The interesting part -- Debugging Rust programs -- Summary -- Further reading -- Chapter 2: Sequential Rust Performance and Testing -- Technical requirements -- Diminishing returns -- Performance -- Standard library HashMap -- Naive HashMap -- Testing with QuickCheck -- Testing with American Fuzzy Lop -- Performance testing with Criterion -- Inspecting with the Valgrind Suite -- Inspecting with Linux perf -- A better naive HashMap -- Summary -- Further reading -- Chapter 3: The Rust Memory Model - Ownership, References and Manipulation -- Technical requirements -- Memory layout -- Pointers to memory -- Allocating and deallocating memory -- The size of a type -- Static and dynamic dispatch -- Zero sized types -- Boxed types -- Custom allocators -- Implementations -- Option -- Cell and RefCell -- Rc -- Vec -- Summary -- Further reading -- Chapter 4: Sync and Send - the Foundation of Rust Concurrency -- Technical requirements -- Sync and Send -- Racing threads -- The flaw of the Ring -- Getting back to safety -- Safety by exclusion -- Using MPSC -- A telemetry server -- Summary -- Further reading -- Chapter 5: Locks - Mutex, Condvar, Barriers and RWLock -- Technical requirements -- Read many, write exclusive locks - RwLock -- Blocking until conditions change - condvar -- Blocking until the gang's all here - barrier -- More mutexes, condvars, and friends in action -- The rocket preparation problem -- The rope bridge problem -- Hopper-an MPSC specialization -- The problem -- Hopper in use -- A conceptual view of hopper -- The deque.

The Receiver -- The Sender -- Testing concurrent data structures -- QuickCheck and loops -- Searching for crashes with AFL -- Benchmarking -- Summary -- Further reading -- Chapter 6: Atomics - the Primitives of Synchronization -- Technical requirements -- Linearizability -- Memory ordering - happens-before and synchronizes-with -- Ordering::Relaxed -- Ordering::Acquire -- Ordering::Release -- Ordering::AcqRel -- Ordering::SeqCst -- Building synchronization -- Mutexes -- Compare and set mutex -- An incorrect atomic queue -- Options to correct the incorrect queue -- Semaphore -- Binary semaphore, or, a less wasteful mutex -- Summary -- Further reading -- Chapter 7: Atomics - Safely Reclaiming Memory -- Technical requirements -- Approaches to memory reclamation -- Reference counting -- Tradeoffs -- Hazard pointers -- A hazard-pointer Treiber stack -- The hazard of Nightly -- Exercizing the hazard-pointer Treiber stack -- Tradeoffs -- Epoch-based reclamation -- An epoch-based Treiber stack -- crossbeam_epoch::Atomic -- crossbeam_epoch::Guard::defer -- crossbeam_epoch::Local::pin -- Exercising the epoch-based Treiber stack -- Tradeoffs -- Summary -- Further reading -- Chapter 8: High-Level Parallelism - Threadpools, Parallel Iterators and Processes -- Technical requirements -- Thread pooling -- Slowloris - attacking thread-per-connection servers -- The server -- The client -- A thread-pooling server -- Looking into thread pool -- The Ethernet sniffer -- Iterators -- Smallcheck iteration -- rayon - parallel iterators -- Data parallelism and OS processes - evolving corewars players -- Corewars -- Feruscore - a Corewars evolver -- Representing the domain -- Exploring the source -- Instructions -- Individuals -- Mutation and reproduction -- Competition - calling out to pMARS -- Main -- Running feruscore -- Summary -- Further reading.

Chapter 9: FFI and Embedding - Combining Rust and Other Languages -- Embedding C into Rust - feruscore without processes -- The MARS C interface -- Creating C-structs from Rust -- Calling C functions -- Managing cross-language ownership -- Running the simulation -- Fuzzing the simulation -- The feruscore executable -- Embedding Lua into Rust -- Embedding Rust -- Into C -- The Rust side -- The C side -- Into Python -- Into Erlang/Elixir -- Summary -- Further reading -- Chapter 10: Futurism - Near-Term Rust -- Technical requirements -- Near-term improvements -- SIMD -- Hex encoding -- Futures and async/await -- Specialization -- Interesting projects -- Fuzzing -- Seer, a symbolic execution engine for Rust -- The community -- Should I use unsafe? -- Summary -- Further reading -- Other Books You May Enjoy -- Index.

Writing safe and correct parallel programs is tough. Reasoning about concurrent memory modification is tough; efficiently exploiting the modern computing environment (with its multi-layered caches and deep execution pipelines) is also tough. Most systems programming languages add a further complication: unsafe memory access. The burden on you,.

Description based on publisher supplied metadata and other sources.

Electronic reproduction. Ann Arbor, Michigan : ProQuest Ebook Central, 2024. Available via World Wide Web. Access may be limited to ProQuest Ebook Central affiliated libraries.