Hands-On Concurrency with Rust

Confidently build memory-safe, parallel, and efficient software in Rust

Brian L. Troutwine 지음

Packt(GCO Science) 2018년 05월 31일 출간

작품소개

책소개

-

목차

▶TABLE of CONTENTS
1: PRELIMINARIES ？ MACHINE ARCHITECTURE AND GETTING STARTED WITH RUST
2: SEQUENTIAL RUST PERFORMANCE AND TESTING
3: THE RUST MEMORY MODEL ？ OWNERSHIP, REFERENCES AND MANIPULATION
4: SYNC AND SEND ？ THE FOUNDATION OF RUST CONCURRENCY
5: LOCKS ？ MUTEX, CONDVAR, BARRIERS AND RWLOCK
6: ATOMICS ？ THE PRIMITIVES OF SYNCHRONIZATION
7: ATOMICS ？ SAFELY RECLAIMING MEMORY
8: HIGH-LEVEL PARALLELISM ？ THREADPOOLS, PARALLEL ITERATORS AND PROCESSES
9: FFI AND EMBEDDING ？ COMBINING RUST AND OTHER LANGUAGES
10: FUTURISM ？ NEAR-TERM RUST

책 속으로

▶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.

출판사 서평

▶Editorial Review
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―twith 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.

인물정보

저자(글) Brian L. Troutwine

Brian L. Troutwine's professional focuses on real-time, fault-tolerant and critical software in high-scale and/or embedded systems. He is a frequent international public speaker on these topics. He knows many programming languages but works primarily in Erlang/OTP, C++, Rust, Haskell.He is keenly interested in building reliable, real-time systems that have to cope with some extreme or another. He is also fascinated both by the constraints of embedded machines and networked systems. He spends time engineering custom software for unusual problem domains.