Rust Atomics and Locks 1st edition by Mara Bos ISBN 1098119444 978-1098119447

Rust Atomics and Locks 1st edition by Mara Bos – Ebook PDF Instant Download/Delivery: 1098119444, 978-1098119447
Full download Rust Atomics and Locks 1st edition after payment

Product details:

ISBN 10: 1098119444
ISBN 13: 978-1098119447
Author: Mara Bos

The Rust programming language is extremely well suited for concurrency, and its ecosystem has many libraries that include lots of concurrent data structures, locks, and more. But implementing those structures correctly can be very difficult. Even in the most well-used libraries, memory ordering bugs are not uncommon.

In this practical book, Mara Bos, leader of the Rust library team, helps Rust programmers of all levels gain a clear understanding of low-level concurrency. You’ll learn everything about atomics and memory ordering and how they’re combined with basic operating system APIs to build common primitives like mutexes and condition variables. Once you’re done, you’ll have a firm grasp of how Rust’s memory model, the processor, and the role of the operating system all fit together.

Rust Atomics and Locks 1st Table of contents:

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

People also search for Rust Atomics and Locks 1st :

rust atomics mara bos

rust atomics and locks book

rust atomics and locks

atomics and locks book

mara bos atomics

Tags: Mara Bos, Rust Atomics