深入理解并行编程电子书

摘要

第1章 如何使用本书

1.1 路线图

1.2 小问题

1.3 除本书之外的选择

1.4 示例源代码

1.5 这本书属于谁

第2章 简介

2.1 导致并行编程困难的历史原因

2.2 并行编程的目标

2.2.1 性能

2.2.2 生产率

2.2.3 通用性

2.3 并行编程的替代方案

2.3.1 串行应用的多个实例

2.3.2 使用现有的并行软件

2.3.3 性能优化

2.4 是什么使并行编程变得复杂

2.4.1 分割任务

2.4.2 并行访问控制

2.4.3 资源分割和复制

2.4.4 与硬件的交互

2.4.5 组合使用

2.4.6 语言和环境如何支持这些任务

2.5 本章的讨论

第3章 硬件和它的习惯

3.1 概述

3.1.1 流水线CPU

3.1.2 内存引用

3.1.3 原子操作

3.1.4 内存屏障

3.1.5 高速缓存未命中

3.1.6 I/O操作

3.2 开销

3.2.1 硬件体系结构

3.2.2 操作的开销

3.3 硬件的免费午餐

3.3.1 3D集成

3.3.2 新材料和新工艺

3.3.3 是光，不是电子

3.3.4 专用加速器

3.3.5 现有的并行软件

3.4 对软件设计的启示

第4章 办事的家伙

4.1 脚本语言

4.2 POSIX多进程

4.2.1 POSIX进程创建和销毁

4.2.2 POSIX线程创建和销毁

4.2.3 POSIX锁

4.2.4 POSIX读/写锁

4.3 原子操作

4.4 Linux内核中类似POSIX的操作

4.5 如何选择趁手的工具

第5章 计数

5.1 为什么并发计数不可小看

5.2 统计计数器

5.2.1 设计

5.2.2 基于数组的实现

5.2.3 最终结果一致的实现

5.2.4 基于每线程变量的实现

5.2.5 本节讨论

5.3 近似上限计数器

5.3.1 设计

5.3.2 简单的上限计数实现

5.3.3 关于简单上限计数的讨论

5.3.4 近似上限计数器的实现

5.3.5 关于近似上限计数器的讨论

5.4 精确上限计数

5.4.1 原子上限计数的实现

5.4.2 关于原子上限计数的讨论

5.4.3 Signal-Theft上限计数的设计

5.4.4 Signal-Theft上限计数的实现

5.4.5 关于Signal-Theft上限计数的讨论

5.5 特殊场合的并行计数

5.6 关于并行计数的讨论

5.6.1 并行计数的性能

5.6.2 并行计数的专门化

5.6.3 从并行计数中学到什么

第6章 对分割和同步的设计

6.1 分割练习

6.1.1 哲学家就餐问题

6.1.2 双端队列

6.1.3 关于分割问题示例的讨论

6.2 设计准则

6.3 同步粒度

6.3.1 串行程序

6.3.2 代码锁

6.3.3 数据锁

6.3.4 数据所有权

6.3.5 锁粒度与性能

6.4 并行快速路径

6.4.1 读/写锁

6.4.2 层次锁

6.4.3 资源分配器缓存

6.5 分割之外

6.5.1 使用工作队列的迷宫问题并行解法

6.5.2 另一种迷宫问题的并行解法

6.5.3 性能比较I

6.5.4 另一种迷宫问题的串行解法

6.5.5 性能比较II

6.5.6 未来展望与本节总结

6.6 分割、并行化与优化

第7章 锁

7.1 努力活着

7.1.1 死锁

7.1.2 活锁与饥饿

7.1.3 不公平的锁

7.1.4 低效率的锁

7.2 锁的类型

7.2.1 互斥锁

7.2.2 读/写锁

7.2.3 读/写锁之外

7.2.4 范围锁

7.3 锁在实现中的问题

7.3.1 基于原子交换的互斥锁实现示例

7.3.2 互斥锁的其他实现

7.4 基于锁的存在保证

7.5 锁：是英雄还是恶棍

7.5.1 应用程序中的锁：英雄

7.5.2 并行库中的锁：只是一个工具

7.5.3 并行化串行库时的锁：恶棍

7.6 总结

第8章 数据所有权

8.1 多进程

8.2 部分数据所有权和pthread线程库

8.3 函数输送

8.4 指派线程

8.5 私有化

8.6 数据所有权的其他用途

第9章 延后处理

9.1 引用计数

9.1.1 各种引用计数的实现

9.1.2 危险指针

9.1.3 支持引用计数的Linux原语

9.1.4 计数优化

9.2 顺序锁

9.3 读-复制-修改（RCU）

9.3.1 RCU介绍

9.3.2 RCU基础

9.3.3 RCU用法

9.3.4 Linux内核中的RCU API

9.3.5“玩具式”的RCU实现

9.3.6 RCU练习

9.4 如何选择

9.5 更新端怎么办

第10章 数据结构

10.1 从例子入手

10.2 可分割的数据结构

10.2.1 哈希表的设计

10.2.2 哈希表的实现

10.2.3 哈希表的性能

10.3 读侧重的数据结构

10.3.1 受RCU保护的哈希表的实现

10.3.2 受RCU保护的哈希表的性能

10.3.3 对受RCU保护的哈希表的讨论

10.4 不可分割的数据结构

10.4.1 可扩展哈希表的设计

10.4.2 可扩展哈希表的实现

10.4.3 可扩展哈希表的讨论

10.4.4 其他可扩展的哈希表

10.5 其他数据结构

10.6 微优化

10.6.1 实例化

10.6.2 比特与字节

10.6.3 硬件层面的考虑

10.7 总结

第11章 验证

11.1 简介

11.1.1 BUG来自于何处

11.1.2 所需的心态

11.1.3 应该何时开始验证

11.1.4 开源之路

11.2 跟踪

11.3 断言

11.4 静态分析

11.5 代码走查

11.5.1 审查

11.5.2 走查

11.5.3 自查

11.6 几率及海森堡BUG

11.6.1 离散测试统计

11.6.2 滥用离散测试统计

11.6.3 持续测试统计

11.6.4 定位海森堡BUG

11.7 性能评估

11.7.1 性能基准

11.7.2 剖析

11.7.3 差分分析

11.7.4 微基准

11.7.5 隔离

11.7.6 检测干扰

11.8 总结

第12章 形式验证

12.1 通用目的的状态空间搜索

12.1.1 Promela和Spin

12.1.2 如何使用 Promela

12.1.3 Promela 示例：锁

12.1.4 Promela 示例：QRCU

12.1.5 Promela初试牛刀：dynticks和可抢占RCU

12.1.6 验证可抢占RCU和dynticks

12.2 特定目的的状态空间搜索

12.2.1 解析Litmus测试

12.2.2 Litmus测试意味着什么

12.2.3 运行Litmus测试

12.2.4 PPCMEM讨论

12.3 公理方法

12.4 SAT求解器

12.5 总结

第13章 综合应用

13.1 计数难题

13.1.1 对更新进行计数

13.1.2 对查找进行计数

13.2 使用RCU拯救并行软件性能

13.2.1 RCU和基于每CPU变量的统计计数

13.2.2 RCU及可插拔I/O设备的计数器

13.2.3 数组及长度

13.2.4 相关联的字段

13.3 散列难题

13.3.1 相关联的数据元素

13.3.2 更新友好的哈希表遍历

第14章 高级同步

14.1 避免锁

14.2 内存屏障

14.2.1 内存序及内存屏障

14.2.2 如果B在A后面，并且C在B后面，为什么C不在A后面

14.2.3 变量可以拥有多个值

14.2.4 能信任什么东西

14.2.5 锁实现回顾

14.2.6 一些简单的规则

14.2.7 抽象内存访问模型

14.2.8 设备操作

14.2.9 保证

14.2.10 什么是内存屏障

14.2.11 锁约束

14.2.12 内存屏障示例

14.2.13 CPU缓存的影响

14.2.14 哪里需要内存屏障

14.3 非阻塞同步

14.3.1 简单NBS

14.3.2 NBS讨论

第15章 并行实时计算

15.1 什么是实时计算

15.1.1 软实时

15.1.2 硬实时

15.1.3 现实世界的实时

15.2 谁需要实时计算

15.3 谁需要并行实时计算

15.4 实现并行实时系统

15.4.1 实现并行实时操作系统

15.4.2 实现并行实时应用

15.5 实时VS.快速：如何选择

第16章 易于使用

16.1 简单是什么

16.2 API设计的Rusty准则

16.3 修整Mandelbrot集合

第17章 未来的冲突

17.1 曾经的CPU技术不代表未来

17.1.1 单处理器Uber Alles

17.1.2 多线程Mania

17.1.3 更多类似的场景

17.1.4 撞上内存墙

17.2 事务内存

17.2.1 外部世界

17.2.2 进程修改

17.2.3 同步

17.2.4 讨论

17.3 硬件事务内存

17.3.1 HTM与锁相比的优势

17.3.2 HTM与锁相比的劣势

17.3.3 HTM与增强后的锁机制相比的劣势

17.3.4 HTM最适合的场合

17.3.5 潜在的搅局者

17.3.6 结论

17.4 并行函数式编程

附录A 重要问题

A.1“After”的含义是什么

A.2“并发”和“并行”之间的差异是什么

A.3 现在是什么时间

附录B 同步原语

B.1 组织和初始化

B.1.1 smp_init()

B.2 线程创建、销毁及控制

B.2.1 create_thread()

B.2.2 smp_thread_id()

B.2.3 for_each_thread()

B.2.4 for_each_running_thread()

B.2.5 wait_thread()

B.2.6 wait_all_threads()

B.2.7 用法示例

B.3 锁

B.3.1 spin_lock_init()

B.3.2 spin_lock()

B.3.3 spin_trylock()

B.3.4 spin_unlock()

B.3.5 用法示例

B.4 每线程变量

B.4.1 DEFINE_PER_THREAD()

B.4.2 DECLARE_PER_THREAD()

B.4.3 per_thread()

B.4.4__get_thread_var()

B.4.5 init_per_thread()

B.4.6 用法示例

B.5 性能

附录C 为什么需要内存屏障

C.1 缓存结构

C.2 缓存一致性协议

C.2.1 MESI状态

C.2.2 MESI协议消息

C.2.3 MESI状态图

C.2.4 MESI协议示例

C.3 存储导致不必要的停顿

C.3.1 存储缓冲

C.3.2 存储转发

C.3.3 存储缓冲区及内存屏障

C.4 存储序列导致不必要的停顿

C.4.1 使无效队列

C.4.2 使无效队列及使无效应答

C.4.3 使无效队列及内存屏障

C.5 读和写内存屏障

C.6 内存屏障示例

C.6.1 乱序体系结构

C.6.2 示例1

C.6.3 示例2

C.6.4 示例3

C.7 特定的内存屏障指令

C.7.1 Alpha

C.7.2 AMD64

C.7.3 ARMv7-A/R

C.7.4 IA64

C.7.5 PA-RISC

C.7.6 POWER/Power PC

C.7.7 SPARC RMO、PSO及TSO

C.7.8 x86

C.7.9 zSeries

C.8 内存屏障是永恒的吗

C.9 对硬件设计者的建议

附录D 小问题答案

D.1 如何使用本书

D.2 简介

D.3 硬件和它的习惯

D.4 办事的家伙

D.5 计数

D.6 对分割和同步的设计

D.7 锁

D.8 数据所有权

D.9 延迟处理

D.10 数据结构

D.11 验证

D.12 形式验证

D.13 综合应用

D.14 高级同步

D.15 并行实时计算

D.16 易于使用

D.17 未来的冲突

D.18 重要问题

D.19 同步原语

D.20 为什么需要内存屏障

附录E 术语

附录F 感谢

F.1 评审者

F.2 硬件提供者

F.3 原始出处

F.4 图表作者

F.5 其他帮助