思维导图备注

深入理解并行编程 - (美)Paul E. Mckenney
首页 收藏书籍 阅读记录
  • 书签 我的书签
  • 添加书签 添加书签 移除书签 移除书签

1.1　路线图

浏览 5 扫码
  • 小字体
  • 中字体
  • 大字体
2024-04-30 09:46:29
请 登录 再阅读
上一篇:
下一篇:
  • 书签
  • 添加书签 移除书签
  • 封面
  • 版权信息
  • 内容简介
  • 声明
  • 作者序
  • 推荐语
  • 推荐序
  • 译者序1
  • 译者序2
  • 第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.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　其他帮助
暂无相关搜索结果！
    展开/收起文章目录

    二维码

    手机扫一扫，轻松掌上学

    《深入理解并行编程 - (美)Paul E. Mckenney》电子书下载

    请下载您需要的格式的电子书，随时随地，享受学习的乐趣！
    EPUB 电子书

    书签列表

      阅读记录

      阅读进度: 0.00% ( 0/0 ) 重置阅读进度