万本电子书0元读

万本电子书0元读

顶部广告

Hands-On Concurrency with Rust电子书

售       价:¥

4人正在读 | 0人评论 9.8

作       者:Brian L. Troutwine

出  版  社:Packt Publishing

出版时间:2018-05-31

字       数:63.9万

所属分类: 进口书 > 外文原版书 > 电脑/网络

温馨提示:数字商品不支持退换货,不提供源文件,不支持导出打印

为你推荐

  • 读书简介
  • 目录
  • 累计评论(0条)
  • 读书简介
  • 目录
  • 累计评论(0条)
Get to grips with modern software demands by learning the effective uses of Rust's powerful memory safety. About This Book ? 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 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 In Detail 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. Style and approach Readers will be taken through various ways to improve the performance of their Rust code.
目录展开

Title Page

Copyright and Credits

Hands-On Concurrency with Rust

Dedication

Packt Upsell

Why subscribe?

PacktPub.com

Contributors

About the author

About the reviewer

Packt is searching for authors like you

Preface

Who this book is for

What this book covers

To get the most out of this book

Download the example code files

Conventions used

Get in touch

Reviews

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

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

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

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

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

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

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

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

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

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

Leave a review - let other readers know what you think

累计评论(0条) 0个书友正在讨论这本书 发表评论

发表评论

发表评论,分享你的想法吧!

买过这本书的人还买过

读了这本书的人还在读

回顶部