[套装书]并行程序设计+高性能计算+基于CUDA的GPU并行程序开发指南+CUDA C编程权威指南+多核与GPU编程+CUDA并行程序设计（6册）

.

---------------------------5850457 - CUDA C编程权威指南---------------------------


本书主要介绍了如何使用GPU和利用CUDAC语言对其进行编程的。首先从基本的CUDA概念及结构讲起，一步一步地引导读者进入CUDA的内部世界，由浅入深地介绍了其编程要求及其内部架构，使读者对其有了整体印象后，逐步深入了解其内部机能，后介绍了GPU的一些专用函数和注意事项。



---------------------------5206918 - 多核与GPU编程：工具、方法及实践---------------------------


本书从并行软件的实现、调试、优化和剖析四个方面，详细讨论了当前主要的并行计算关键技术，主要内容包括：多核和并行程序设计、共享内存编程中的线程与OpenMP、分布式内存编程、GPU编程、Thrust模板库、负载均衡等。本书结合具体的代码和案例分析，揭示了如何使用库或者指令创建多核应用，如何使用MPI开发分布式应用程序，如何使用CUDA开发高性能GPU程序，如何实现负载均衡，以及如何针对目标多核平台进行程序剖析和调试等。本书可供从事高性能计算技术研究的专业人员参考，也可作为高校相关专业的教学用书。



---------------------------3769261 - CUDA并行程序设计：GPU编程指南---------------------------


《CUDA并行程序设计：GPU编程指南》是CUDA并行程序设计领域最全面、最详实和最具权威性的著作之一，由CUDA开发者社区技术总监亲自撰写，英伟达中国首批CUDA官方认证工程师翻译，详实地讲解了CUDA并行程序设计的技术知识点（平台、架构、硬件知识、开发工具和热点技术）和编程方法，包含大量实用代码示例，实践性非常强。

全书共分为12章。第1章从宏观上介绍流处理器演变历史。第2章详解GPU并行机制，深入理解串行与并行程序，以辩证地求解问题。第3章讲解CUDA设备及相关的硬件和体系结构，以实现最优CUDA程序性能。第4章介绍CUDA开发环境搭建和可用调试环境。第5章介绍与CUDA编程紧密相关的核心概念——网格、线程块与线程，并通过示例说明线程模型与性能的关系。第6章借助实例详细讲解了不同类型内存的工作机制，并指出实践中容易出现的误区。第7章细述多任务的CPU和GPU协同，并介绍多个CPU/GPU编程秘技。第8章介绍如何在应用程序中编写和使用多GPU。第9章详述CUDA编程性能限制因素、分析CUDA代码的工具和技术。第10章介绍编程实践中的库与软件开发工具包。第11章讲解如何设计基于GPU的系统。第12章总结CUDA应用中易犯错误以及应对建议。

.---------------------------5206918 - 多核与GPU编程：工具、方法及实践---------------------------


Gerassimos Barlas 沙迦美国大学计算机科学与工程系教授。他的研究兴趣包括并行算法、开发、分析，以及负载平衡的建模框架，分布式视频点播。Barlas教授讲授并行编程课程已有12年时间，早在20世纪90年代，他就开始研究并行计算，并积极参与并行和分布式系统可分负载理论这一新领域的研究工作。



---------------------------3769261 - CUDA并行程序设计：GPU编程指南---------------------------


Shane Cook，CUDA开发者社区技术总监，有20余年行业经验。当认识到异构系统以及CUDA对于已有串行和并行编程技术的革命性冲击时，创立了CUDA开发者社区（欧洲的咨询公司，专门帮助企业重构代码以充分利用GPU硬件的威力）。他专注于高性能软件开发、GPU利用、嵌入式系统，并参与了多个C语言编程标准的建设，包括广泛应用于汽车软件行业的汽车工业软件MISRA Safer C。他常为德国汽车行业、国防承包行业、北电网络以及福特汽车公司等机构或蓝筹股公司提供专业咨询服务和软件定制开发。
苏统华，博士，英伟达中国首批CUDA官方认证工程师，主要研究领域包括大规模并行计算、模式识别、物联网智能信息处理、智能媒体交互与计算等。2013年，其所开发的CUDA识别算法，在文档分析和识别国际会议（ICDAR’ 2013）上获得手写汉字识别竞赛的双料冠军。另外，他在手写汉字识别领域建立了里程碑式的工作，论文他引300余次；他所建立的HIT-MW库，为全世界100多家科研院所采用；目前负责国家自然科学基金项目2项。著有英文专著《Chinese Handwriting Recognition: An Algorithmic Perspective》（德国施普林格出版社），CUDA相关译作2本（机械工业出版社）。现任哈尔滨工业大学软件学院高级讲师、硕士生导师。

1.2.2　共享内存系统 11
1.2.3　并行程序设计需考虑的因素 13
1.3　HPC动态和排名 15
1.4　附加练习 17
第2章　理论背景 19
2.1　PRAM 20
2.1.1　PRAM变体 21
2.1.2　PRAM上的并行前缀计算 22
2.1.3　PRAM上稀疏数组的压缩算法 24
2.2　网络拓扑 25
2.3　Amdahl定律和Gustafson定律 29
2.4　Foster的并行算法设计方法学 34
2.5　附加练习 37
参考文献 40
第3章　现代体系结构 41
3.1　存储层次 42
3.1.1　冯·诺依曼瓶颈 42
3.1.2　高速缓冲存储器 43
3.1.3　缓存算法 44
3.1.4　优化缓存访问 45
3.1.5　高速缓存一致性 48
3.1.6　虚假共享 50
3.1.7　并发多线程技术和预取技术 50
3.1.8　展望 51
3.2　并行性的层次 51
3.2.1　Flynn分类法 51
3.2.2　SIMD概念 53
3.2.3　通用微处理器上的向量化 54
3.2.4　结构体数组和数组结构体 57
3.2.5　展望 63
3.3　附加练习 63
参考文献 67
第4章　C++多线程编程 68
4.1　多线程编程简介 69
4.1.1　多线程编程和多进程编程的区别 69
4.1.2　派生和并入线程 69
4.1.3　我们的第一个多线程程序 71
4.2　处理返回值 73
4.2.1　传统方法 74
4.2.2　使用promise和future的现代方法 75
4.2.3　异步方式 80
4.3　基于静态分发的调度机制 82
4.3.1　串行程序 83
4.3.2　线程的区块分发 87
4.3.3　线程的循环分发 90
4.3.4　虚假共享 91
4.3.5　线程的块循环分发 93
4.4　处理负载不平衡 95
4.4.1　静态调度 99
4.4.2　动态块循环分发 101
4.5　用条件变量通知线程 104
4.5.1　为一个睡觉的学生建模 105
4.5.2　使用条件变量 107
4.5.3　使用future和promise单发同步 108
4.6　隐式可数集合上的并行化 110
4.6.1　隐式可数集合 111
4.6.2　线程池用例 112
4.6.3　一个简单线程池的实现 114
4.7　附加练习 119
参考文献 121
第5章　高级C++11多线程编程 122
5.1　无锁编程 122
5.1.1　原子计数 123
5.1.2　非基本原子数据类型 124
5.1.3　利用比较交换以原子方式并行化最大值归约 126
5.1.4　任意原子操作 129
5.1.5　ABA问题 132
5.2　工作共享线程池 133
5.2.1　工作共享线程池的用例 133
5.2.2　工作共享的实现 135
5.3　并行图搜索 137
5.3.1　二元背包问题 138
5.3.2　串行实现 139
5.3.3　并行实现 144
5.4　展望 146
5.5　附加练习 148
参考文献 149
第6章　OpenMP 150
6.1　OpenMP简介 151
6.1.1　OpenMP简史 151
6.1.2　基础 151
6.2　parallel for制导语句 153
6.2.1　向量加法 154
6.2.2　变量共享和私有化 157
6.2.3　矩阵向量乘法 160
6.3　基本的并行归约 162
6.3.1　最近邻分类 162
6.3.2　手写数字数据集MNIST 163
6.3.3　完全配对距离计算的理论视角 164
6.3.4　完全配对计算的实现 165
6.3.5　并行标签预测 168
6.3.6　性能评测 169
6.4　不平衡循环调度 171
6.4.1　对称性引起的负载失衡 172
6.4.2　内积计算实现 173
6.4.3　性能评测 174
6.5　高级归约 175
6.5.1　MNIST数据集上的SOFTMAX回归分类器 175
6.5.2　定制归约操作符 183
6.5.3　OpenMP高级归约 187
6.6　任务并行 189
6.6.1　树遍历 190
6.6.2　循环中生成任务 193
6.7　SIMD向量化 193
6.7.1　数据依赖 195
6.7.2　向量化感知函数 196
6.8　展望 196
6.9　附加练习 197
参考文献 202
第7章　统一计算设备架构 203
7.1　CUDA简介 204
7.2　支持CUDA的GPU硬件架构 206
7.2.1　主机与设备之间的互连 206
7.2.2　显存和峰值宽度 207
7.2.3　计算资源的组织 207
7.3　内存访问模式 211
7.3.1　均值名人脸的计算 212
7.3.2　计算中心化的数据矩阵 218
7.3.3　计算协方差矩阵 221
7.3.4　计算特征脸 229
7.4　内存层次结构 232
7.4.1　问题简介 233
7.4.2　串行DTW的线性内存算法 237
7.4.3　线性内存DTW的一个初始CUDA移植 243
7.4.4　共享内存中的波前松弛 248
7.4.5　并发调度和bank冲突 253
7.4.6　纹理内存和常量内存 254
7.5　优化准则 257
7.6　附加练习 258
参考文献 259
第8章　高级CUDA编程 261
8.1　warp内联函数和原子操作 261
8.1.1　分段并行归约 262
8.1.2　全局并行归约 265
8.1.3　任意原子操作 267
8.1.4　展望 269
8.2　利用多块GPU和流 269
8.2.1　牛顿迭代 269
8.2.2　利用多块GPU 272
8.2.3　通信和计算交叉 274
8.2.4　多块GPU上的流式计算 278
8.3　展望 280
8.3.1　统一内存 280
8.3.2　动态并行性 281
8.3.3　协作组 281
8.3.4　张量核心 281
8.3.5　GPU集群上的分布式计算 282
8.4　附加练习 282
参考文献 284
第9章　MPI 286
9.1　MPI简介 286
9.2　基本概念 288
9.3　点到点通信 289
9.4　非阻塞通信 292
9.5　集合通信 295
9.6　计算通信重叠 300
9.7　派生数据类型 309
9.8　复杂通信域 315
9.9　展望 322
9.10　附加练习 322
参考文献 327
第10章　统一并行C++ 329
10.1　PGAS和UPC++简介 329
10.2　基本概念 331
10.3　内存亲和性和私有化 332
10.4　全局指针和集合函数 337
10.5　锁 343
10.6　远程函数调用 348
10.7　附加练习 355
参考文献 357



---------------------------8067632 - 高性能计算：现代系统与应用实践---------------------------


译者序
序言
前言
致谢
第1章　绪论 1
1.1　高性能计算学科 2
1.1.1　定义 3
1.1.2　应用程序 3
1.1.3　性能和指标 3
1.1.4　高性能计算系统 4
1.1.5　超算问题 6
1.1.6　应用编程 7
1.2　超算对科学、社会和安全的影响 8
1.2.1　促进欺诈检测和市场数据分析 8
1.2.2　发现、管理和分配石油和天然气 8
1.2.3　加快制造业的创新 9
1.2.4　个性化医药和药物发现 9
1.2.5　预测自然灾害和了解气候变化 10
1.3　超级计算机剖析 11
1.4　计算机性能 13
1.4.1　性能 13
1.4.2　峰值性能 13
1.4.3　持续性能 14
1.4.4　可扩展性 15
1.4.5　性能退化 15
1.4.6　性能提升 17
1.5　超级计算机简史 17
1.5.1　第一个阶段—利用机械技术的自动计算机 18
1.5.2　第二个阶段—真空管时代的冯·诺依曼架构 19
1.5.3　第三个阶段—指令级并行 23
1.5.4　第四个阶段—向量处理和积分 24
1.5.5　第五个阶段—单指令多数据阵列 27
1.5.6　第六个阶段—顺序处理器的通信和超大规模集成电路 27
1.5.7　第七个阶段—多核和千万亿次 30
1.5.8　新数字时代和超越摩尔定律 30
1.6　作为学生的指南和工具 31
1.7　本章小结及成果 32
1.8　练习 33
参考文献 34
第2章　HPC架构：系统和技术 35
2.1　引言 35
2.2　HPC架构的关键特性 36
2.2.1　速度 36
2.2.2　并行性 36
2.2.3　效率 37
2.2.4　功率 37
2.2.5　可靠性 38
2.2.6　可编程性 38
2.3　并行架构家族—弗林分类法 39
2.4　支持技术 41
2.4.1　技术阶段 41
2.4.2　技术的角色 44
2.4.3　数字逻辑 45
2.4.4　存储技术 47
2.5　冯·诺依曼顺序处理器 50
2.6　向量和流水线 52
2.6.1　流水线并行 53
2.6.2　向量处理 55
2.7　单指令多数据阵列 56
2.7.1　单指令多数据架构 56
2.7.2　阿姆达定律 57
2.8　多处理器 59
2.8.1　共享内存多处理器 60
2.8.2　大规模并行处理器 62
2.8.3　商品集群系统 62
2.9　异构计算机结构 63
2.10　本章小结及成果 64
2.11　练习 65
参考文献 67
第3章　商品集群 68
3.1　引言 68
3.1.1　商品集群的定义 68
3.1.2　集群的动机和理由 69
3.1.3　集群元素 70
3.1.4　对500强名单的影响 70
3.1.5　简史 71
3.1.6　章节指南 73
3.2　Beowulf集群项目 74
3.3　硬件架构 76
3.3.1　节点 76
3.3.2　系统区域网络 77
3.3.3　辅助存储 78
3.3.4　商业系统摘要 78
3.4　编程接口 78
3.4.1　高性能计算程序设计语言 78
3.4.2　并行编程模式 80
3.5　软件环境 80
3.5.1　操作系统 80
3.5.2　资源管理 82
3.5.3　调试器 83
3.5.4　性能分析 84
3.5.5　可视化 85
3.6　基本使用方法 86
3.6.1　登录 86
3.6.2　用户空间和目录系统 87
3.6.3　包的配置和构建 92
3.6.4　编译器和编译 93
3.6.5　运行应用程序 94
3.7　本章小结及成果 94
3.8　练习 95
参考文献 95
第4章　基准测试程序 97
4.1　引言 97
4.2　HPC基准测试程序的关键属性 100
4.3　标准的HPC社区的基准测试程序 101
4.4　高度并行计算的Linpack 102
4.5　HPC挑战基准测试套件 104
4.6　高性能共轭梯度 106
4.7　NAS并行基准测试程序 110
4.8　Graph500 111
4.9　小型应用作为基准测试程序 115
4.10　本章小结及成果 116
4.11　练习 117
参考文献 118
第5章　资源管理的基础 119
5.1　资源管理 119
5.2　SLURM的基础 123
5.2.1　架构概述 123
5.2.2　工作负载的组织 124
5.2.3　SLURM调度 125
5.2.4　SLURM命令概要 127
5.2.5　SLURM作业脚本 141
5.2.6　SLURM速查表 146
5.3　便携式批量系统基础 147
5.3.1　PBS概述 147
5.3.2　PBS架构 148
5.3.3　PBS命令概要 148
5.3.4　PBS作业脚本 158
5.3.5　PBS速查表 160
5.4　本章小结及成果 161
5.5　练习 162
参考文献 163
第6章　对称多处理器架构 164
6.1　引言 164
6.2　架构概览 165
6.3　阿姆达定律 168
6.4　处理器核心的架构 171
6.4.1　执行流水线 172
6.4.2　指令级并行 173
6.4.3　分支预测 173
6.4.4　直通 174
6.4.5　保留站 174
6.4.6　多线程 174
6.5　存储层次 175
6.5.1　数据重用和局部性 175
6.5.2　存储层次结构 176
6.5.3　存储系统的性能 178
6.6　PCI总线 180
6.7　外部I/O接口 184
6.7.1　网络接口控制器 184
6.7.2　串行高级技术附件 185
6.7.3　JTAG 187
6.7.4　通用串行总线 189
6.8　本章小结及成果 190
6.9　练习 191
参考文献 192
第7章　OpenMP的基础 194
7.1　引言 194
7.2　OpenMP编程模型概览 195
7.2.1　线程并行 195
7.2.2　线程变量 197
7.2.3　运行时库与环境变量 197
7.3　并行线程和循环 199
7.3.1　并行线程 199
7.3.2　私有 200
7.3.3　并行“for”语句 200
7.3.4　块 206
7.4　同步 208
7.4.1　临界同步指令 208
7.4.2　master指令 209
7.4.3　barrier指令 210
7.4.4　single指令 210
7.5　归约 210
7.6　本章小结及成果 212
7.7　练习 213
参考文献 214
第8章　MPI的基础 215
8.1　引言 215
8.2　消息传递接口标准 216
8.3　消息传递接口的基本命令 217
8.3.1　mpi.h 217
8.3.2　MPI_Init 217
8.3.3　MPI_Finalize 218
8.3.4　消息传递接口例子—Hello World 218
8.4　通信器 219
8.4.1　size 220
8.4.2　rank 220
8.4.3　例子 221
8.5　点对点消息 222
8.5.1　MPI发送 222
8.5.2　消息传递接口的数据类型 222
8.5.3　MPI接收 223
8.5.4　例子 223
8.6　同步聚合 225
8.6.1　聚合调用概览 225
8.6.2　栅栏同步 225
8.6.3　例子 226
8.7　通信聚合 227
8.7.1　聚合数据移动 228
8.7.2　广播 230
8.7.3　分散 231
8.7.4　收集 233
8.7.5　全局收集 234
8.7.6　归约操作 235
8.7.7　全局到全局 238
8.8　非阻塞式点对点通信 240
8.9　用户自定义数据类型 242
8.10　本章小结及成果 243
8.11　练习 244
参考文献 244
第9章　并行算法 245
9.1　引言 245
9.2　分支-聚合 246
9.3　分治 247
9.4　管理者-工作者 249
9.5　易并行 250
9.6　光环交换 251
9.6.1　使用有限差分的平流方程 251
9.6.2　稀疏矩阵向量乘法 254
9.7　置换：佳能算法 256
9.8　任务数据流：广度优先搜索 261
9.9　本章小结及成果 263
9.10　练习 263
参考文献 264
第10章　库 265
10.1　引言 265
10.2　线性代数 267
10.2.1　基本线性代数子程序库 267
10.2.2　线性代数包 273
10.2.3　可扩展的线性代数包 275
10.2.4　GNU科学库 276
10.2.5　Supernodal LU 276
10.2.6　用于科学计算的便携式可扩展工具包 277
10.2.7　用于特征值问题计算的可扩展库 277
10.2.8　千万亿运算级的应用的特征值求解器 278
10.2.9　Hypre：可扩展的线性求解器和多重网格方法 278
10.2.10　用于线性代数的领域特定语言 278
10.3　偏微分方程 280
10.4　图算法 281
10.5　并行输入/输出 281
10.6　网格分解 288
10.7　可视化 289
10.8　并行化 289
10.9　信号处理 289
10.10　性能监控 290
10.11　本章小结及成果 290
10.12　练习 291
参考文献 292
第11章　操作系统 294
11.1　引言 294
11.2　操作系统结构和服务 296
11.2.1　系统组件 296
11.2.2　进程管理 296
11.2.3　内存管理 296
11.2.4　文件管理 296
11.2.5　I/O系统管理 297
11.2.6　辅助存储管理 297
11.3　进程管理 297
11.3.1　进程状态 298
11.3.2　进程控制块 299
11.3.3　进程管理活动 300
11.3.4　调度 301
11.4　线程 302
11.5　内存管理 304
11.5.1　虚拟内存 304
11.5.2　虚拟页地址 304
11.5.3　虚拟地址转换 305
11.6　本章小结及成果 306
11.7　练习 307
第12章　可视化 308
12.1　引言 308
12.2　基本的可视化概念 308
12.3　Gnuplot 310
12.4　Matplotlib 312
12.5　可视化工具包 316
12.6　ParaView 323
12.7　VisIt 323
12.8　本章小结及成果 324
12.9　练习 325
参考文献 325
第13章　性能监控 326
13.1　引言 326
13.2　时间测量 327
13.3　性能分析 333
13.3.1　应用分析的重要性 333
13.3.2　gperftools基础 334
13.4　监控硬件事件 339
13.4.1　perf 339
13.4.2　性能应用程序编程接口 344
13.5　集成的性能监控套件 347
13.6　分布式环境下的分析 350
13.7　本章小结及成果 356
13.8　练习 357
参考文献 358
第14章　调试 360
14.1　引言 360
14.2　工具 362
14.2.1　GNU调试器 362
14.2.2　Valgrind 370
14.2.3　商业版并行调试器 370
14.3　调试OpenMP示例：访问不受保护的共享变量 372
14.4　调试MPI示例：死锁 373
14.5　用于调试的编译器标志 378
14.6　帮助调试的系统监控器 379
14.7　本章小结及成果 381
14.8　练习 381
参考文献 385
第15章　加速器架构 386
15.1　引言 386
15.2　简史 388
15.2.1　协处理器 390
15.2.2　处理器I/O空间中的加速器 394
15.2.3　具备行业标准接口的加速器 395
15.3　图形处理单元简介 397
15.4　图形处理单元功能的进化 399
15.5　现代GPU体系结构 403
15.5.1　计算架构 403
15.5.2　内存实现 406
15.5.3　互连 407
15.5.4　可编程环境 408
15.6　异构系统架构 408
15.7　本章小结及成果 410
15.8　练习 410
参考文献 411
第16章　OpenACC的基础 412
16.1　引言 412
16.1.1　CUDA 413
16.1.2　OpenCL 414
16.1.3　C++ AMP 414
16.1.4　OpenACC 415
16.2　OpenACC编程概念 415
16.3　OpenACC库调用 417
16.4　OpenACC环境变量 419
16.5　OpenACC指令 420
16.5.1　并行构造 420
16.5.2　内核构造 422
16.5.3　数据管理 423
16.5.4　循环调度 427
16.5.5　变量的作用范围 429
16.5.6　原子性 430
16.6　本章小结及成果 431
16.7　练习 432
参考文献 433
第17章　大容量存储器 434
17.1　引言 434
17.2　存储器简史 437
17.3　存储设备技术 438
17.3.1　硬盘驱动器 438
17.3.2　固态硬盘存储器 444
17.3.3　磁带 449
17.3.4　光存储 451
17.4　集中存储 456
17.4.1　独立磁盘冗余阵列 456
17.4.2　存储区域网络 462
17.4.3　网络附加存储 463
17.4.4　三级存储器 464
17.5　本章小结及成果 465
17.6　练习 466
参考文献 466
第18章　文件系统 468
18.1　文件系统的角色和功能 468
18.2　POSIX文件接口的基础 472
18.2.1　文件访问的系统调用 472
18.2.2　缓冲文件I/O 476
18.3　网络文件系统 480
18.4　通用并行文件系统 483
18.5　Lustre文件系统 487
18.6　本章小结及成果 492
18.7　练习 493
参考文献 494
第19章　MapReduce 495
19.1　引言 495
19.2　映射和归约 495
19.2.1　单词计数 496
19.2.2　共享的邻居 497
19.2.3　K均值聚类 498
19.3　分布式计算 499
19.4　Hadoop 500
19.5　本章小结及成果 503
19.6　练习 504
参考文献 504
第20章　检查点技术 505
20.1　引言 505
20.2　系统级检查点 505
20.3　应用级检查点 511
20.4　本章小结及成果 515
20.5　练习 516
参考文献 516
第21章　下一步和未来发展 517
21.1　引言 517
21.2　扩展的并行编程模型 518
21.2.1　消息传递接口的进展 518
21.2.2　OpenMP的进展 518
21.2.3　MPI+X 519
21.3　扩展的高性能计算架构 519
21.3.1　世界上最快的机器 519
21.3.2　轻量级架构 519
21.3.3　现场可编程门阵列 520
21.4　E级计算 521
21.4.1　E级计算的挑战 522
21.4.2　从数学角度看E级的大小 523
21.4.3　加速方法 523
21.4.4　轻量级核心 523
21.5　异步多任务 524
21.5.1　多线程 524
21.5.2　消息驱动的计算 524
21.5.3　全局地址空间 525
21.5.4　行动者同步 526
21.5.5　运行时系统软件 526
21.6　新数字时代 526
21.6.1　数据流 527
21.6.2　元胞自动机 529
21.6.3　仿神经计算 530
21.6.4　量子计算 530
21.7　练习 531
参考文献 531
附录A　C语言的基础 532
附录B　Linux的基础 547



---------------------------8061305 - 基于CUDA的GPU并行程序开发指南---------------------------


译者序
前言
关于作者
第一部分　理解CPU的并行性
第1章　CPU并行编程概述 2
1.1　并行编程的演化 2
1.2　核心越多，并行性越高 3
1.3　核心与线程 4
1.3.1　并行化更多的是线程还是核心 5
1.3.2　核心资源共享的影响 6
1.3.3　内存资源共享的影响 6
1.4　第一个串行程序 7
1.4.1 　理解数据传输速度 8
1.4.2　imflip.c中的main( )函数 9
1.4.3　垂直翻转行：FlipImageV( ) 10
1.4.4　水平翻转列：FlipImageH( ) 11
1.5　程序的编辑、编译、运行 12
1.5.1　选择编辑器和编译器 12
1.5.2　在Windows 7、8、10平台上开发 12
1.5.3　在Mac平台上开发 14
1.5.4　在Unix平台上开发 14
1.6　Unix速成 15
1.6.1　与目录相关的Unix命令 15
1.6.2　与文件相关的Unix命令 16
1.7　调试程序 19
1.7.1　gdb 19
1.7.2　古典调试方法 20
1.7.3　valgrind 22
1.8　第一个串行程序的性能 22
1.8.1　可以估计执行时间吗 23
1.8.2　代码执行时OS在做什么 23
1.8.3　如何并行化 24
1.8.4　关于资源的思考 25
第2章　开发第一个CPU并行程序 26
2.1　第一个并行程序 26
2.1.1　imflipP.c中的main( )函数 27
2.1.2　运行时间 28
2.1.3　imflipP.c中main( )函数代码的划分 28
2.1.4　线程初始化 30
2.1.5　创建线程 31
2.1.6 　线程启动/执行 32
2.1.7　线程终止（合并） 33
2.1.8　线程任务和数据划分 34
2.2　位图文件 35
2.2.1　BMP是一种无损/不压缩的文件格式 35
2.2.2　BMP图像文件格式 36
2.2.3　头文件ImageStuff.h 37
2.2.4　ImageStuff.c中的图像操作函数 38
2.3　执行线程任务 40
2.3.1　启动线程 41
2.3.2　多线程垂直翻转函数MTFlipV( ) 43
2.3.3　FlipImageV( )和MTFlipV( )的比较 46
2.3.4　多线程水平翻转函数MTFlipH() 47
2.4　多线程代码的测试/计时 49
第3章　改进第一个CPU并行程序 51
3.1　程序员对性能的影响 51
3.2　CPU对性能的影响 52
3.2.1　按序核心与乱序核心 53
3.2.2　瘦线程与胖线程 55
3.3　imflipP的性能 55
3.4　操作系统对性能的影响 56
3.4.1　创建线程 57
3.4.2　线程启动和执行 57
3.4.3　线程状态 58
3.4.4　将软件线程映射到硬件线程 59
3.4.5　 程序性能与启动的线程 60
3.5　改进imflipP 61
3.5.1　 分析MTFlipH( )中的内存访问模式 62
3.5.2 　MTFlipH( )的多线程内存访问 63
3.5.3 　DRAM访问的规则 64
3.6　imflipPM：遵循DRAM的规则 65
3.6.1　imflipP的混乱内存访问模式 65
3.6.2　改进imflipP的内存访问模式 65
3.6.3　MTFlipHM( )：内存友好的MTFlipH( ) 66
3.6.4　MTFlipVM( )：内存友好的MTFlipV( ) 69
3.7　imflipPM.C的性能 69
3.7.1　imflipP.c和imflipPM.c的性能比较 70
3.7.2　速度提升：MTFlipV( )与MTFlipVM( ) 71
3.7.3　速度提升：MTFlipH( )与MTFlipHM( ) 71
3.7.4　理解加速：MTFlipH( )与MTFlipHM( ) 71
3.8　进程内存映像 72
3.9　英特尔MIC架构：Xeon Phi 74
3.10　GPU是怎样的 75
3.11　本章小结 76
第4章　理解核心和内存 77
4.1　曾经的英特尔 77
4.2　CPU和内存制造商 78
4.3　动态存储器与静态存储器 79
4.3.1　静态随机存取存储器（SRAM） 79
4.3.2　 动态随机存取存储器（DRAM） 79
4.3.3　DRAM接口标准 79
4.3.4　DRAM对程序性能的影响 80
4.3.5　SRAM对程序性能的影响 81
4.4　图像旋转程序：imrotate.c 81
4.4.1　imrotate.c的说明 82
4.4.2　imrotate.c：参数限制和简化 82
4.4.3　imrotate.c：实现原理 83
4.5　imrotate的性能 87
4.5.1　线程效率的定性分析 87
4.5.2　定量分析：定义线程效率 87
4.6　计算机的体系结构 89
4.6.1　核心、L1$和L2$ 89
4.6.2　核心内部资源 90
4.6.3 　共享L3高速缓存（L3 $） 91
4.6.4　内存控制器 92
4.6.5　主存 92
4.6.6　队列、非核心和I/O 93
4.7　imrotateMC：让imrotate更高效 94
4.7.1　Rotate2( )：平方根和浮点除法有多差 96
4.7.2　Rotate3( )和Rotate4( )：sin( )和cos( )有多差 97
4.7.3　Rotate5( )：整数除法/乘法有多差 98
4.7.4　Rotate6( )：合并计算 100
4.7.5　Rotate7( )：合并更多计算 100
4.7.6　imrotateMC的总体性能 101
4.8　本章小结 103
第5章　线程管理和同步 104
5.1　边缘检测程序：imedge.c 104
5.1.1　imedge.c的说明 105
5.1.2　imedge.c：参数限制和简化 106
5.1.3　imedge.c：实现原理 106
5.2　imedge.c：实现 108
5.2.1　初始化和时间戳 109
5.2.2　不同图像表示的初始化函数 110
5.2.3　启动和终止线程 111
5.2.4　高斯滤波 112
5.2.5　Sobel 113
5.2.6　阈值过滤 114
5.3　imedge的性能 115
5.4　imedgeMC：让imedge更高效 116
5.4.1　利用预计算降低带宽 116
5.4.2　存储预计算的像素值 117
5.4.3　预计算像素值 118
5.4.4　读取图像并预计算像素值 119
5.4.5　PrGaussianFilter 120
5.4.6　PrSobel 121
5.4.7　PrThreshold 121
5.5　imedgeMC的性能 122
5.6　imedgeMCT：高效的线程同步 123
5.6.1　屏障同步 124
5.6.2　用于数据共享的MUTEX结构 125
5.7　imedgeMCT：实现 127
5.7.1　使用MUTEX：读取图像、预计算 128
5.7.2　一次预计算一行 130
5.8　imedgeMCT的性能 131
第二部分　基于CUDA的GPU编程
第6章　GPU并行性和CUDA概述 134
6.1　曾经的Nvidia 134
6.1.1　GPU的诞生 134
6.1.2　早期的GPU架构 136
6.1.3　GPGPU的诞生 137
6.1.4　Nvidia、ATI Technologies和Intel 138
6.2　统一计算设备架构 140
6.2.1　CUDA、OpenCL和其他GPU语言 140
6.2.2　设备端与主机端代码 140
6.3　理解GPU并行 141
6.3.1　GPU如何实现高性能 142
6.3.2　CPU与GPU架构的差异 143
6.4　图像翻转的CUDA版：imflipG.cu 144
6.4.1　imflipG.cu：将图像读入CPU端数组 146
6.4.2　初始化和查询GPU 147
6.4.3　GPU端的时间戳 148
6.4.4　GPU端内存分配 152
6.4.5　GPU驱动程序和Nvidia运行时引擎 153
6.4.6　CPU到GPU的数据传输 153
6.4.7　用封装函数进行错误报告 154
6.4.8　GPU核函数的执行 155
6.4.9　完成GPU核函数的执行 157
6.4.10　将GPU结果传回CPU 158
6.4.11　完成时间戳 158
6.4.12　输出结果和清理 158
6.4.13　读取和输出BMP文件 159
6.4.14 　Vflip( )：垂直翻转的GPU核函数 160
6.4.15　什么是线程ID、块ID和块维度 163
6.4.16　Hflip( )：水平翻转的GPU核函数 165
6.4.17　硬件参数：threadIDx.x、blockIdx.x和blockDim.x 165
6.4.18　PixCopy( )：复制图像的GPU核函数 165
6.4.19　CUDA关键字 166
6.5　Windows中的CUDA程序开发 167
6.5.1　安装MS Visual Studio 2015和CUDA Toolkit 8.0 167
6.5.2　在Visual Studio 2015中创建项目imflipG.cu 168
6.5.3　在Visual Studio 2015中编译项目imflipG.cu 170
6.5.4　运行第一个CUDA应用程序：imflipG.exe 173
6.5.5　确保程序的正确性 174
6.6　Mac平台上的CUDA程序开发 175
6.6.1　在Mac上安装XCode 175
6.6.2　安装CUDA驱动程序和CUDA工具包 176
6.6.3　在Mac上编译和运行CUDA应用程序 177
6.7　Unix平台上的CUDA程序开发 177
6.7.1　安装Eclipse和CUDA工具包 177
6.7.2　使用ssh登录一个集群 178
6.7.3　编译和执行CUDA代码 179
第7章　CUDA主机/设备编程模型 181
7.1　设计程序的并行性 181
7.1.1　任务的并行化 182
7.1.2　什么是Vflip( )的最佳块尺寸 183
7.1.3　imflipG.cu：程序输出的解释 183
7.1.4　imflipG.cu：线程块和图像的大小对性能的影响 184
7.2　核函数的启动 185
7.2.1　网格 185
7.2.2　线程块 187
7.2.3　线程 187
7.2.4　线程束和通道 189
7.3　imflipG.cu：理解核函数的细节 189
7.3.1　在main( )中启动核函数并将参数传递给它们 189
7.3.2　线程执行步骤 190
7.3.3　Vflip( )核函数 191
7.3.4　Vflip( )和MTFlipV( )的比较 192
7.3.5　Hflip( )核函数 194
7.3.6　PixCopy( )核函数 194
7.4　PCIe速度与CPU的关系 196
7.5　PCIe总线对性能的影响 196
7.5.1　数据传输时间、速度、延迟、吞吐量和带宽 196
7.5.2　imflipG.cu的PCIe吞吐量 197
7.6　全局内存总线对性能的影响 200
7.7　计算能力对性能的影响 203
7.7.1　Fermi、Kepler、Maxwell、Pascal和Volta系列 203
7.7.2　不同系列实现的相对带宽 204
7.7.3　imflipG2.cu：计算能力2.0版本的imflipG.cu 205
7.7.4　imflipG2.cu：main( )的修改 206
7.7.5　核函数PxCC20( ) 208
7.7.6　核函数VfCC20( ) 208
7.8　imflipG2.cu的性能 210
7.9　古典的CUDA调试方法 212
7.9.1　常见的CUDA错误 212
7.9.2　return调试法 214
7.9.3　基于注释的调试 216
7.9.4　printf()调试 216
7.10　软件错误的生物学原因 217
7.10.1　大脑如何参与编写/调试代码 218
7.10.2　当我们疲倦时是否会写出错误代码 219
第8章　理解GPU的硬件架构 221
8.1　GPU硬件架构 222
8.2　GPU硬件的部件 222
8.2.1　SM：流处理器 222
8.2.2　GPU核心 223
8.2.3　千兆线程调度器 223
8.2.4　内存控制器 225
8.2.5　共享高速缓存（L2$） 225
8.2.6　主机接口 225
8.3　Nvidia GPU架构 226
8.3.1　Fermi架构 227
8.3.2　GT、GTX和计算加速器 227
8.3.3　Kepler架构 228
8.3.4　Maxwell架构 228
8.3.5　Pascal架构和NVLink 229
8.4　CUDA边缘检测：imedgeG.cu 229
8.4.1　CPU和GPU内存中存储图像的变量 229
8.4.2　为GPU变量分配内存 231
8.4.3　调用核函数并对其进行计时 233
8.4.4　计算核函数的性能 234
8.4.5　计算核函数的数据移动量 235
8.4.6　输出核函数性能 236
8.5　imedgeG：核函数 237
8.5.1　BWKernel( ) 237
8.5.2　GaussKernel( ) 239
8.5.3　SobelKernel( ) 240
8.5.4　ThresholdKernel( ) 242
8.6　imedgeG.cu的性能 243
8.6.1　imedgeG.cu：PCIe总线利用率 244
8.6.2　imedgeG.cu：运行时间 245
8.6.3　imedgeG.cu：核函数性能比较 247
8.7　GPU代码：编译时间 248
8.7.1　设计CUDA代码 248
8.7.2　编译CUDA代码 250
8.7.3　GPU汇编：PTX、CUBIN 250
8.8　GPU代码：启动 250
8.8.1　操作系统的参与和CUDA DLL文件 250
8.8.2　GPU图形驱动 251
8.8.3　CPU与GPU之间的内存传输 251
8.9　GPU代码：执行（运行时间） 252
8.9.1　获取数据 252
8.9.2　获取代码和参数 252
8.9.3　启动线程块网格 252
8.9.4　千兆线程调度器（GTS） 253
8.9.5　线程块调度 254
8.9.6　线程块的执行 255
8.9.7　透明的可扩展性 256
第9章　理解GPU核心 257
9.1　GPU的架构系列 258
9.1.1　Fermi架构 258
9.1.2　Fermi SM的结构 259
9.1.3　Kepler架构 260
9.1.4　Kepler SMX的结构 260
9.1.5　Maxwell架构 261
9.1.6　Maxwell SMM的结构 262
9.1.7　Pascal GP100架构 264
9.1.8　Pascal GP100 SM的结构 265
9.1.9　系列比较：峰值GFLOPS和峰值DGFLOPS 266
9.1.10　GPU睿频 267
9.1.11　GPU功耗 268
9.1.12　计算机电源 268
9.2　流处理器的构建模块 269
9.2.1　GPU核心 269
9.2.2　双精度单元（DPU） 270
9.2.3　特殊功能单元（SFU） 270
9.2.4　寄存器文件（RF） 270
9.2.5　读取/存储队列（LDST） 271
9.2.6　L1$和纹理高速缓存 272
9.2.7　共享内存 272
9.2.8　常量高速缓存 272
9.2.9　指令高速缓存 272
9.2.10　指令缓冲区 272
9.2.11　线程束调度器 272
9.2.12　分发单元 273
9.3　并行线程执行（PTX）的数据类型 273
9.3.1　INT8：8位整数 274
9.3.2　INT16：16位整数 274
9.3.3　24位整数 275
9.3.4　INT32：32位整数 275
9.3.5　判定寄存器（32位） 275
9.3.6　INT64：64位整数 276
9.3.7　128位整数 276
9.3.8　FP32：单精度浮点（float） 277
9.3.9　FP64：双精度浮点（double） 277
9.3.10　FP16：半精度浮点（half） 278
9.3.11　什么是FLOP 278
9.3.12　融合乘法累加（FMA）与乘加（MAD） 278
9.3.13　四倍和八倍精度浮点 279
9.3.14　Pascal GP104引擎的SM结构 279
9.4　imflipGC.cu：核心友好的imflipG 280
9.4.1　Hflip2( )：预计算核函数参数 282
9.4.2　Vflip2( )：预计算核函数参数 284
9.4.3　使用线程计算图像坐标 285
9.4.4　线程块ID与图像的行映射 285
9.4.5　Hflip3( )：使用二维启动网格 286
9.4.6　Vflip3( )：使用二维启动网格 287
9.4.7　Hflip4( )：计算2个连续的像素 288
9.4.8　Vflip4( )：计算2个连续的像素 289
9.4.9　Hflip5( )：计算4个连续的像素 290
9.4.10　Vflip5( )：计算4个连续的像素 291
9.4.11　PixCopy2( )、PixCopy3( )：一次分别复制2个和4个连续的像素 292
9.5　imedgeGC.cu：核心友好的imedgeG 293
9.5.1　BWKernel2( )：使用预计算的值和2D块 293
9.5.2　GaussKernel2( )：使用预计算的值和2D块 294
第10章　理解GPU内存 296
10.1　全局内存 297
10.2　L2高速缓存 297
10.3　纹理/L1高速缓存 298
10.4　共享内存 298
10.4.1　分拆与专用共享内存 299
10.4.2　每核心可用的内存资源 299
10.4.3　使用共享内存作为软件高速缓存 300
10.4.4　分配SM中的共享内存 300
10.5　指令高速缓存 300
10.6　常量内存 301
10.7　imflipGCM.cu：核心和内存友好的imflipG 301
10.7.1　Hflip6( )、Vflip6( )：使用共享内存作为缓冲区 301
10.7.2　Hflip7( )：共享内存中连续的交换操作 303
10.7.3　Hflip8( )：使用寄存器交换4个像素 305
10.7.4　Vflip7( )：一次复制4个字节（int） 307
10.7.5　对齐与未对齐的内存数据访问 308
10.7.6　Vflip8( )：一次复制8个字节 308
10.7.7　Vflip9( )：仅使用全局内存，一次复制8个字节 309
10.7.8　PixCopy4( )、PixCopy5( )：使用共享内存复制1个和4个字节 310
10.7.9　PixCopy6( )、PixCopy7( )：使用全局内存复制1个和2个整数 311
10.8　imedgeGCM.cu：核心和内存友好的imedgeG 312
10.8.1　BWKernel3( )：使用字节操作来提取RGB 312
10.8.2　GaussKernel3( )：使用常量内存 314
10.8.3　处理常量的方法 315
10.8.4　GaussKernel4( )：在共享内存中缓冲1个像素的邻居 316
10.8.5　GaussKernel5( )：在共享内存中缓冲4个像素的邻居 318
10.8.6　GaussKernel6( )：将5个垂直像素读入共享内存 320
10.8.7　GaussKernel7( )：去除边界像素的影响 322
10.8.8　GaussKernel8( )：计算8个垂直像素 324
10.9　CUDA占用率计算器 326
10.9.1　选择最佳的线程/块 327
10.9.2　SM级资源限制 328
10.9.3　什么是占用率 329
10.9.4　CUDA占用率计算器：资源计算 330
10.9.5　案例分析：GaussKernel7() 334
10.9.6　案例分析：GaussKernel8() 337
第11章　CUDA流 340
11.1　什么是流水线 342
11.1.1　重叠执行 342
11.1.2　暴露与合并的运行时间 343
11.2　内存分配 344
11.2.1　物理与虚拟内存 345
11.2.2　物理地址到虚拟地址的转换 345
11.2.3　固定内存 345
11.2.4　使用cudaMallocHost( )分配固定内存 346
11.3　CPU与GPU之间快速的数据传输 346
11.3.1　同步数据传输 346
11.3.2　异步数据传输 347
11.4　CUDA流的原理 347
11.4.1　CPU到GPU的传输、核函数的执行、GPU到CPU的传输 347
11.4.2　在CUDA中实现流 348
11.4.3　复制引擎 348
11.4.4　核函数执行引擎 349
11.4.5　并发的上行和下行PCIe传输 349
11.4.6　创建CUDA流 350
11.4.7　销毁CUDA流 350
11.4.8　同步CUDA流 350
11.5　imGStr.cu：流式图像处理 351
11.5.1　将图像读入固定内存 351
11.5.2　同步与单个流 353
11.5.3　多个流 354
11.5.4　多流之间的数据依赖 356
11.6　流式水平翻转核函数 360
11.7　imGStr.cu：流式边缘检测 362
11.8　性能对比：imGStr.cu 365
11.8.1　同步与异步结果 366
11.8.2　结果的随机性 366
11.8.3　队列优化 366
11.8.4　最佳流式结果 367
11.8.5　最差流式结果 369
11.9　Nvidia可视化分析器：nvvp 370
11.9.1　安装nvvp和nvprof 370
11.9.2　使用nvvp 370
11.9.3　使用nvprof 371
11.9.4　imGStr的同步和单流结果 372
11.9.5　imGStr的2流和4流结果 373
第三部分　拓展知识
第12章　CUDA库 376
12.1　cuBLAS 377
12.1.1　BLAS级别 377
12.1.2　cuBLAS数据类型 377
12.1.3　安装cuBLAS 378
12.1.4　变量声明和初始化 378
12.1.5　设备内存分配 379
12.1.6　创建上下文 379
12.1.7　将数据传输到设备端 379
12.1.8　调用cuBLAS函数 380
12.1.9　将数据传回主机 380
12.1.10　释放内存 381
12.1.11　cuBLAS程序示例：矩阵的标量操作 381
12.2　cuFFT 382
12.2.1　cuFFT库特征 383
12.2.2　复数到复数变换示例 383
12.2.3　实数到复数变换示例 384
12.3　Nvidia性能库（NPP） 384
12.4　Thrust库 386
第13章　OpenCL简介 388
13.1　什么是OpenCL 388
13.1.1　多平台 388
13.1.2　基于队列 389
13.2　图像翻转核函数 389
13.3　运行核函数 390
13.3.1　选择设备 390
13.3.2　运行核函数 392
13.3.3　OpenCL程序的运行时间 396
13.4　OpenCL中的边缘检测 396
第14章　其他GPU编程语言 402
14.1　使用Python进行GPU编程 402
14.1.1　imflip的PyOpenCL版本 403
14.1.2　PyOpenCL的逐元素核函数 406
14.2　OpenGL 408
14.3　OpenGL ES：用于嵌入式系统的OpenGL 409
14.4　Vulkan 409
14.5　微软的高级着色语言 409
14.5.1　着色 410
14.5.2　HLSL 410
14.6　Apple的Metal API 411
14.7　Apple的Swift编程语言 411
14.8　OpenCV 411
14.8.1　安装OpenCV和人脸识别 411
14.8.2　移动–微云–云实时人脸识别 412
14.8.3　加速即服务（AXaas） 412
第15章　深度学习中的CUDA 413
15.1　人工神经网络 413
15.1.1　神经元 413
15.1.2　激活函数 414
15.2　全连接神经网络 415
15.3　深度网络/卷积神经网络 415
15.4　训练网络 416
15.5　cuDNN深度学习库 416
15.5.1　创建一个层 417
15.5.2　创建一个网络 418
15.5.3　前向传播 418
15.5.4　反向传播 419
15.5.5　在网络中使用cuBLAS 419
15.6　Keras 419
参考文献 421
术语表 424



---------------------------5850457 - CUDA C编程权威指南---------------------------


译者序
推荐序
自序
作者简介
技术审校者简介
前言
致谢
第1章　基于CUDA的异构并行计算1
1.1　并行计算1
1.1.1　串行编程和并行编程2
1.1.2　并行性3
1.1.3　计算机架构4
1.2　异构计算6
1.2.1　异构架构7
1.2.2　异构计算范例9
1.2.3　CUDA：一种异构计算平台10
1.3　用GPU输出Hello World12
1.4　使用CUDA C编程难吗15
1.5　总结16
1.6　习题16
第2章　CUDA编程模型18
2.1　CUDA编程模型概述18
2.1.1　CUDA编程结构19
2.1.2　内存管理20
2.1.3　线程管理24
2.1.4　启动一个CUDA核函数29
2.1.5　编写核函数30
2.1.6　验证核函数31
2.1.7　处理错误32
2.1.8　编译和执行32
2.2　给核函数计时35
2.2.1　用CPU计时器计时35
2.2.2　用nvprof工具计时39
2.3　组织并行线程40
2.3.1　使用块和线程建立矩阵索引40
2.3.2　使用二维网格和二维块对矩阵求和44
2.3.3　使用一维网格和一维块对矩阵求和47
2.3.4　使用二维网格和一维块对矩阵求和48
2.4　设备管理50
2.4.1　使用运行时API查询GPU信息50
2.4.2　确定最优GPU53
2.4.3　使用nvidia-smi查询GPU信息53
2.4.4　在运行时设置设备54
2.5　总结54
2.6　习题55
第3章　CUDA执行模型56
3.1　CUDA执行模型概述56
3.1.1　GPU架构概述57
3.1.2　Fermi架构59
3.1.3　Kepler架构61
3.1.4　配置文件驱动优化65
3.2　理解线程束执行的本质67
3.2.1　线程束和线程块67
3.2.2　线程束分化69
3.2.3　资源分配74
3.2.4　延迟隐藏76
3.2.5　占用率78
3.2.6　同步81
3.2.7　可扩展性82
3.3　并行性的表现83
3.3.1　用nvprof检测活跃的线程束84
3.3.2　用nvprof检测内存操作85
3.3.3　增大并行性86
3.4　避免分支分化88
3.4.1　并行归约问题88
3.4.2　并行归约中的分化89
3.4.3　改善并行归约的分化93
3.4.4　交错配对的归约95
3.5　展开循环97
3.5.1　展开的归约97
3.5.2　展开线程的归约99
3.5.3　完全展开的归约101
3.5.4　模板函数的归约102
3.6　动态并行104
3.6.1　嵌套执行105
3.6.2　在GPU上嵌套Hello World106
3.6.3　嵌套归约109
3.7　总结113
3.8　习题113
第4章　全局内存115
4.1　CUDA内存模型概述115
4.1.1　内存层次结构的优点116
4.1.2　CUDA内存模型117
4.2　内存管理124
4.2.1　内存分配和释放124
4.2.2　内存传输125
4.2.3　固定内存127
4.2.4　零拷贝内存128
4.2.5　统一虚拟寻址133
4.2.6　统一内存寻址134
4.3　内存访问模式135
4.3.1　对齐与合并访问135
4.3.2　全局内存读取137
4.3.3　全局内存写入145
4.3.4　结构体数组与数组结构体147
4.3.5　性能调整151
4.4　核函数可达到的带宽154
4.4.1　内存带宽154
4.4.2　矩阵转置问题155
4.5　使用统一内存的矩阵加法167
4.6　总结171
4.7　习题172
第5章　共享内存和常量内存174
5.1　CUDA共享内存概述174
5.1.1　共享内存175
5.1.2　共享内存分配176
5.1.3　共享内存存储体和访问模式176
5.1.4　配置共享内存量181
5.1.5　同步183
5.2　共享内存的数据布局185
5.2.1　方形共享内存185
5.2.2　矩形共享内存193
5.3　减少全局内存访问199
5.3.1　使用共享内存的并行归约199
5.3.2　使用展开的并行归约202
5.3.3　使用动态共享内存的并行归约204
5.3.4　有效带宽205
5.4　合并的全局内存访问205
5.4.1　基准转置内核205
5.4.2　使用共享内存的矩阵转置207
5.4.3　使用填充共享内存的矩阵转置210
5.4.4　使用展开的矩阵转置211
5.4.5　增大并行性214
5.5　常量内存215
5.5.1　使用常量内存实现一维模板215
5.5.2　与只读缓存的比较217
5.6　线程束洗牌指令219
5.6.1　线程束洗牌指令的不同形式220
5.6.2　线程束内的共享数据222
5.6.3　使用线程束洗牌指令的并行归约226
5.7　总结227
5.8　习题228
第6章　流和并发230
6.1　流和事件概述231
6.1.1　CUDA流231
6.1.2　流调度234
6.1.3　流的优先级235
6.1.4　CUDA事件235
6.1.5　流同步237
6.2　并发内核执行240
6.2.1　非空流中的并发内核240
6.2.2　Fermi GPU上的虚假依赖关系242
6.2.3　使用OpenMP的调度操作244
6.2.4　用环境变量调整流行为245
6.2.5　GPU资源的并发限制246
6.2.6　默认流的阻塞行为247
6.2.7　创建流间依赖关系248
6.3　重叠内核执行和数据传输249
6.3.1　使用深度优先调度重叠249
6.3.2　使用广度优先调度重叠252
6.4　重叠GPU和CPU执行254
6.5　流回调255
6.6　总结256
6.7　习题257
第7章　调整指令级原语258
7.1　CUDA指令概述259
7.1.1　浮点指令259
7.1.2　内部函数和标准函数261
7.1.3　原子操作指令262
7.2　程序优化指令264
7.2.1　单精度与双精度的比较264
7.2.2　标准函数与内部函数的比较266
7.2.3　了解原子指令272
7.2.4　综合范例277
7.3　总结279
7.4　习题280
第8章　GPU加速库和OpenACC281
8.1　CUDA库概述282
8.1.1　CUDA库支持的作用域283
8.1.2　通用的CUDA库工作流283
8.2　cuSPARSE库285
8.2.1　cuSPARSE数据存储格式286
8.2.2　用cuSPARSE进行格式转换289
8.2.3　cuSPARSE功能示例289
8.2.4　cuSPARSE发展中的重要主题291
8.2.5　cuSPARSE小结291
8.3　cuBLAS库292
8.3.1　管理cuBLAS数据293
8.3.2　cuBLAS功能示例294
8.3.3　cuBLAS发展中的重要主题295
8.3.4　cuBLAS小结296
8.4　cuFFT库296
8.4.1　使用cuFFT API296
8.4.2　cuFFT功能示例298
8.4.3　cuFFT小结299
8.5　cuRAND库299
8.5.1　拟随机数或伪随机数的选择299
8.5.2　cuRAND库概述300
8.5.3　cuRAND介绍303
8.5.4　cuRAND发展中的重要主题306
8.6　CUDA 6.0中函数库的介绍307
8.6.1　Drop-In库307
8.6.2　多GPU库308
8.7　CUDA函数库的性能研究310
8.7.1　cuSPARSE与MKL的比较310
8.7.2　cuBLAS与MKL BLAS的比较311
8.7.3　cuFFT与FFTW及MKL的比较311
8.7.4　CUDA库性能小结312
8.8　OpenACC的使用312
8.8.1　OpenACC计算指令的使用315
8.8.2　OpenACC数据指令的使用321
8.8.3　OpenACC运行时API325
8.8.4　OpenACC和CUDA库的结合327
8.8.5　OpenACC小结328
8.9　总结329
8.10　习题329
第9章　多GPU编程331
9.1　从一个GPU到多GPU332
9.1.1　在多GPU上执行333
9.1.2　点对点通信334
9.1.3　多GPU间的同步335
9.2　多GPU间细分计算336
9.2.1　在多设备上分配内存336
9.2.2　单主机线程分配工作337
9.2.3　编译和执行337
9.3　多GPU上的点对点通信338
9.3.1　实现点对点访问338
9.3.2　点对点的内存复制339
9.3.3　统一虚拟寻址的点对点内存访问341
9.4　多GPU上的有限差分342
9.4.1　二维波动方程的模板计算342
9.4.2　多GPU程序的典型模式343
9.4.3　多GPU上的二维模板计算344
9.4.4　重叠计算与通信347
9.4.5　编译和执行348
9.5　跨GPU集群扩展应用程序350
9.5.1　CPU到CPU的数据传输351
9.5.2　使用传统MPI在GPU和GPU间传输数据353
9.5.3　使用CUDA-aware MPI进行GPU到GPU的数据传输356
9.5.4　使用CUDA-aware MPI进行节点内GPU到GPU的数据传输357
9.5.5　调整消息块大小358
9.5.6　使用GPUDirect RDMA技术进行GPU到GPU的数据传输359
9.6　总结361
9.7　习题362
第10章　程序实现的注意事项364
10.1　CUDA C的开发过程364
10.1.1　APOD开发周期365
10.1.2　优化因素367
10.1.3　CUDA代码编译370
10.1.4　CUDA错误处理373
10.2　配置文件驱动优化374
10.2.1　使用nvprof寻找优化因素375
10.2.2　使用nvvp指导优化379
10.2.3　NVIDIA工具扩展381
10.3　CUDA调试383
10.3.1　内核调试383
10.3.2　内存调试390
10.3.3　调试小结395
10.4　将C程序移植到CUDA C的案例研究396
10.4.1　评估crypt396
10.4.2　并行crypt397
10.4.3　优化crypt398
10.4.4　部署crypt404
10.4.5　移植crypt小结407
10.5　总结407
10.6　习题407
附录　推荐阅读409


---------------------------5206918 - 多核与GPU编程：工具、方法及实践---------------------------


译者序
前　言
第1章　概述 1
1.1　多核计算机时代 1
1.2　并行计算机的分类 3
1.3　现代计算机概览 4
1.3.1　Cell BE处理器 5
1.3.2　NVIDIA Kepler 6
1.3.3　AMD APU 9
1.3.4　从多核到众核：Tilera TILE-Gx8072和Intel Xeon Phi 10
1.4　性能指标 12
1.5　并行程序性能的预测与测量 16
1.5.1　Amdahl定律 18
1.5.2　Gustafson-Barsis定律 20
第2章　多核和并行程序设计 23
2.1　引言 23
2.2　PCAM方法学 24
2.3　分解模式 26
2.3.1　任务并行 27
2.3.2　分而治之分解 28
2.3.3　几何分解 30
2.3.4　递归数据分解 32
2.3.5　流水线分解 35
2.3.6　基于事件的合作分解 39
2.4　程序结构模式 39
2.4.1　单程序多数据 40
2.4.2　多程序多数据 40
2.4.3　主/从 41
2.4.4　map-reduce 41
2.4.5　fork/join 42
2.4.6　循环并行 44
2.5　匹配分解模式和程序结构模式 44
第3章　共享内存编程：线程 46
3.1　引言 46
3.2　线程 48
3.2.1　线程的定义 48
3.2.2　线程的作用 49
3.2.3　线程的生成和初始化 49
3.2.4　在线程间共享数据 55
3.3　设计考虑 57
3.4　信号量 58
3.5　经典问题中的信号量 62
3.5.1　生产者–消费者 63
3.5.2　终止处理 66
3.5.3　理发师问题：引入公平性 75
3.5.4　读者–写者问题 80
3.6　monitor 84
3.6.1　设计方法1：monitor内部的关键区 87
3.6.2　设计方法2：monitor控制关键区的入口 87
3.7　经典问题中的monitor 91
3.7.1　重新考虑生产者–消费者问题 91
3.7.2　重新考虑读者–写者问题 95
3.8　动态线程管理与静态线程管理 102
3.8.1　Qt线程池 102
3.8.2　线程池的创建和管理 103
3.9　调试多线程应用 111
3.10　高层次结构：无须显式利用线程的多线程编程 115
3.10.1　并发map 116
3.10.2　map-reduce 118
3.10.3　并发过滤 120
3.10.4　filter-reduce 121
3.10.5　案例研究：多线程存储 122
3.10.6　案例研究：多线程图像匹配 131
第4章　共享内存编程：OpenMP 140
4.1　引言 140
4.2　第一个OpenMP程序 141
4.3　变量作用域 144
4.3.1　定积分OpenMP版本V.0：人工划分 146
4.3.2　定积分OpenMP版本 V.1：无竞争条件的人工划分 147
4.3.3　定积分OpenMP V.2：基于锁的隐式划分 148
4.3.4　定积分OpenMP V.3：基于归约的隐式划分 150
4.3.5　变量作用域总结 151
4.4　循环级并行 152
4.4.1　数据依赖 154
4.4.2　嵌套循环 162
4.4.3　调度 162
4.5　任务并行 166
4.5.1　sections指令 166
4.5.2　task指令 171
4.6　同步结构 177
4.7　正确性与优化问题 183
4.7.1　线程安全 183
4.7.2　假共享 187
4.8　案例研究：OpenMP中的排序算法 192
4.8.1　自下而上归并排序算法的OpenMP实现 192
4.8.2　自上而下归并排序算法的OpenMP实现 195
4.8.3　性能评估 200
第5章　分布式内存编程 203
5.1　通信进程 203
5.2　MPI 204
5.3　核心概念 205
5.4　你的第一个MPI程序 206
5.5　程序体系结构 208
5.5.1　SPMD 208
5.5.2　MPMD 209
5.6　点对点通信 210
5.7　可选的点对点通信模式 214
5.8　非阻塞通信 216
5.9　点对点通信小结 220
5.10　错误报告与处理 220
5.11　集合通信简介 222
5.11.1　分发 226
5.11.2　收集 231
5.11.3　归约 233
5.11.4　多对多收集 237
5.11.5　多对多分发 240
5.11.6　多对多归约 245
5.11.7　全局同步 245
5.12　通信对象 245
5.12.1　派生数据类型 246
5.12.2　打包/解包 253
5.13　节点管理：通信器和组 254
5.13.1　创建组 255
5.13.2　建立内部通信器 257
5.14　单边通信 259
5.14.1　RMA通信函数 261
5.14.2　RMA同步函数 262
5.15　I/O注意事项 270
5.16　MPI多进程和多线程混合编程 276
5.17　时序和性能测量 279
5.18　调试和分析MPI程序 279
5.19　Boost.MPI库 283
5.19.1　阻塞和非阻塞通信 285
5.19.2数据序列化 289
5.19.3集合通信 292
5.20　案例研究：有限扩散聚合模型 295
5.21　案例研究：暴力加密破解 300
5.21.1　版本1：“基本型”MPI 300
5.21.2　版本2：MPI与OpenMP的结合 305
5.22　案例研究：主/从式并行模型的MPI实现 308
5.22.1　简单主/从式设置 309
5.22.2　多线程主/从式设置 316
第6章　GPU编程 333
6.1　GPU编程简介 333
6.2　CUDA编程模型：线程、线程块、线程网格 335
6.3　CUDA执行模型：流多处理器和warp 340
6.4　CUDA程序编译过程 344
6.5　构建CUDA项目 347
6.6　内存层次结构 349
6.6.1　本地内存/寄存器 355
6.6.2　共享内存 356
6.6.3　常量内存 363
6.6.4　texture和surface内存 368
6.7　优化技术 369
6.7.1　线程组织设计 369
6.7.2　kernel结构 378
6.7.3　共享内存访问 382
6.7.4　全局内存访问 388
6.7.5　page-locked与zero-copy内存 392
6.7.6　统一内存 394
6.7.7　异步执行和流 397
6.8　动态并行 403
6.9　CUDA程序的调试 407
6.10　CUDA程序剖析 410
6.11　CUDA和MPI 412
6.12　案例研究 417
6.12.1　分形集合计算 417
6.12.2　块加密算法 426
第7章　Thrust模板库 452
7.1　引言 452
7.2　使用Thrust的第一步 453
7.3　Thrust数据类型 456
7.4　Thrust算法 459
7.4.1　变换算法 460
7.4.2　排序与查询 463
7.4.3　归约 468
7.4.4　scan /前缀和 471
7.4.5　数据管理与处理 472
7.5　花式迭代器 475
7.6　交换设备后端 480
7.7　案例研究 481
7.7.1　蒙特卡洛积分 481
7.7.2　DNA序列比对 485
第8章　负载均衡 493
8.1　引言 493
8.2　动态负载均衡：Linda的遗赠 494
8.3　静态负载均衡：可分负载理论方法 495
8.3.1　建模开销 496
8.3.2　通信设置 502
8.3.3　分析 503
8.3.4　总结：简短的文献综述 510
8.4　DLTlib：分割工作负载的库 513
8.5　案例研究 516
8.5.1　Mandelbrot集“电影”的混合计算：动态负载均衡案例研究 516
8.5.2　分布式块加密：静态负载均衡案例研究 526
在线资源
附录A　编译Qt程序
附录B　运行MPI程序：准备与配置步骤
附录C　测量时间
附录D　Boost.MPI
附录E　CUDA环境搭建
附录F　DLTlib
术语表
参考文献


---------------------------3769261 - CUDA并行程序设计：GPU编程指南---------------------------


《CUDA并行程序设计：GPU编程指南》
致中国读者
译者序
前　言
第1章　超级计算简史 1
1.1 简介 1
1.2 冯·诺依曼计算机架构 2
1.3 克雷 4
1.4 连接机 5
1.5　Cell处理器 6
1.6 多点计算 8
1.7 早期的GPGPU编程 10
1.8 单核解决方案的消亡 11
1.9 英伟达和CUDA 12
1.10 GPU硬件 13
1.11 CUDA的替代选择 15
1.11.1　OpenCL 15
1.11.2 DirectCompute 16
1.11.3 CPU的替代选择 16
1.11.4 编译指令和库 17
1.12 本章小结 18
第2章　使用GPU理解并行计算 19
2.1 简介 19
2.2 传统的串行代码 19
2.3 串行/并行问题 21
2.4 并发性 22
2.5 并行处理的类型 25
2.5.1 基于任务的并行处理 25
2.5.2 基于数据的并行处理 27
2.6 弗林分类法 29
2.7 常用的并行模式 30
2.7.1 基于循环的模式 30
2.7.2 派生/汇集模式 31
2.7.3 分条/分块 33
2.7.4 分而治之 34
2.8 本章小结 34
第3章　CUDA硬件概述 35
3.1 PC架构 35
3.2 GPU硬件结构 39
3.3 CPU与GPU 41
3.4 GPU计算能力 42
3.4.1 计算能力1.0 42
3.4.2 计算能力1.1 43
3.4.3 计算能力1.2 44
3.4.4 计算能力1.3 44
3.4.5 计算能力2.0 44
3.4.6 计算能力2.1 46
第4章　CUDA环境搭建 48
4.1 简介 48
4.2 在Windows下安装软件开发工具包 48
4.3 Visual Studio 49
4.3.1 工程 49
4.3.2 64位用户 49
4.3.3 创建工程 51
4.4 Linux 52
4.5 Mac 55
4.6 安装调试器 56
4.7 编译模型 58
4.8 错误处理 59
4.9 本章小结 60
第5章　线程网格、线程块以及线程 61
5.1　简介 61
5.2　线程 61
5.2.1　问题分解 62
5.2.2　CPU与GPU的不同 63
5.2.3　任务执行模式 64
5.2.4　GPU线程 64
5.2.5　硬件初窥 66
5.2.6　CUDA内核 69
5.3　线程块 70
5.4　线程网格 74
5.4.1　跨幅与偏移 76
5.4.2　X与Y方向的线程索引 77
5.5　线程束 83
5.5.1　分支 83
5.5.2　GPU的利用率 85
5.6　线程块的调度 88
5.7　一个实例——统计直方图 89
5.8　本章小结 96
第6章　CUDA内存处理 99
6.1　简介 99
6.2　高速缓存 100
6.3　寄存器的用法 103
6.4　共享内存 112
6.4.1　使用共享内存排序 113
6.4.2　基数排序 117
6.4.3　合并列表 123
6.4.4　并行合并 128
6.4.5　并行归约 131
6.4.6　混合算法 134
6.4.7　不同GPU上的共享内存 138
6.4.8　共享内存小结 139
6.5　常量内存 140
6.5.1　常量内存高速缓存 140
6.5.2　常量内存广播机制 142
6.5.3　运行时进行常量内存更新 152
6.6　全局内存 157
6.6.1　记分牌 165
6.6.2　全局内存排序 165
6.6.3　样本排序 168
6.7　纹理内存 188
6.7.1　纹理缓存 188
6.7.2　基于硬件的内存获取操作 189
6.7.3　使用纹理的限制 190
6.8　本章小结 190
第7章　CUDA实践之道 191
7.1　简介 191
7.2　串行编码与并行编码 191
7.2.1　CPU与GPU的设计目标 191
7.2.2　CPU与GPU上的最佳算法对比 194
7.3　数据集处理 197
7.4　性能分析 206
7.5　一个使用AES的示例 218
7.5.1　算法 219
7.5.2　AES的串行实现 223
7.5.3　初始内核函数 224
7.5.4　内核函数性能 229
7.5.5　传输性能 233
7.5.6　单个执行流版本 234
7.5.7　如何与CPU比较 235
7.5.8　考虑在其他GPU上运行 244
7.5.9　使用多个流 248
7.5.10　AES总结 249
7.6　本章小结 249
第8章　多CPU和多GPU解决方案 252
8.1　简介 252
8.2　局部性 252
8.3　多CPU系统 252
8.4　多GPU系统 253
8.5　多GPU算法 254
8.6　按需选用GPU 255
8.7　单节点系统 258
8.8　流 259
8.9　多节点系统 273
8.10　本章小结 284
第9章　应用程序性能优化 286
9.1　策略1：并行/串行在GPU/CPU上的问题分解 286
9.1.1　分析问题 286
9.1.2　时间 286
9.1.3　问题分解 288
9.1.4　依赖性 289
9.1.5　数据集大小 292
9.1.6　分辨率 293
9.1.7　识别瓶颈 294
9.1.8　CPU和GPU的任务分组 297
9.1.9　本节小结 299
9.2　策略2：内存因素 299
9.2.1　内存带宽 299
9.2.2　限制的来源 300
9.2.3　内存组织 302
9.2.4　内存访问以计算比率 303
9.2.5　循环融合和内核融合 308
9.2.6　共享内存和高速缓存的使用 309
9.2.7　本节小结 311
9.3　策略3：传输 311
9.3.1　锁页内存 311
9.3.2　零复制内存 315
9.3.3　带宽限制 322
9.3.4　GPU计时 327
9.3.5　重叠GPU传输 330
9.3.6　本节小结 334
9.4　策略4：线程使用、计算和分支 335
9.4.1　线程内存模式 335
9.4.2　非活动线程 337
9.4.3　算术运算密度 338
9.4.4　一些常见的编译器优化 342
9.4.5　分支 347
9.4.6　理解底层汇编代码 351
9.4.7　寄存器的使用 355
9.4.8　本节小结 357
9.5　策略5：算法 357
9.5.1　排序 358
9.5.2　归约 363
9.5.3　本节小结 384
9.6　策略6：资源竞争 384
9.6.1　识别瓶颈 384
9.6.2　解析瓶颈 396
9.6.3　本节小结 403
9.7　策略7：自调优应用程序 403
9.7.1　识别硬件 404
9.7.2　设备的利用 405
9.7.3　性能采样 407
9.7.4　本节小结 407
9.8　本章小结 408
第10章　函数库和SDK 410
10.1　简介 410
10.2　函数库 410
10.2.1　函数库通用规范 411
10.2.2　NPP 411
10.2.3　Thrust 419
10.2.4　CuRAND 434
10.2.5　CuBLAS库 438
10.3　CUDA运算SDK 442
10.3.1　设备查询 443
10.3.2　带宽测试 445
10.3.3　SimpleP2P 446
10.3.4　asyncAPI和cudaOpenMP 448
10.3.5　对齐类型 455
10.4　基于指令的编程 457
10.5　编写自己的内核 464
10.6　本章小结 466
第11章　规划GPU硬件系统 467
11.1　简介 467
11.2　CPU处理器 469
11.3　GPU设备 470
11.3.1　大容量内存的支持 471
11.3.2　ECC内存的支持 471
11.3.3　Tesla计算集群驱动程序 471
11.3.4　更高双精度数学运算 472
11.3.5　大内存总线带宽 472
11.3.6　系统管理中断 472
11.3.7　状态指示灯 472
11.4　PCI-E总线 472
11.5　GeForce板卡 473
11.6　CPU内存 474
11.7　风冷 475
11.8　液冷 477
11.9　机箱与主板 479
11.10　大容量存储 481
11.10.1　主板上的输入/输出接口 481
11.10.2　专用RAID控制器 481
11.10.3　HDSL 483
11.10.4　大容量存储需求 483
11.10.5　联网 483
11.11　电源选择 484
11.12　操作系统 487
11.12.1　Windows 487
11.12.2　Linux 488
11.13　本章小结 488
第12章　常见问题、原因及解决方案 489
12.1　简介 489
12.2　CUDA指令错误 489
12.2.1　CUDA错误处理 489
12.2.2　内核启动和边界检查 490
12.2.3　无效的设备操作 491
12.2.4　volatile限定符 492
12.2.5　计算能力依赖函数 494
12.2.6　设备函数、全局函数和主机函数 495
12.2.7　内核中的流 496
12.3　并行编程问题 497
12.3.1　竞争冒险 497
12.3.2　同步 498
12.3.3　原子操作 502
12.4　算法问题 504
12.4.1　对比测试 504
12.4.2　内存泄漏 506
12.4.3　耗时的内核程序 506
12.5　查找并避免错误 507
12.5.1　你的GPU程序有多少错误 507
12.5.2　分而治之 508
12.5.3　断言和防御型编程 509
12.5.4　调试级别和打印 511
12.5.5　版本控制 514
12.6　为未来的GPU进行开发 515
12.6.1　开普勒架构 515
12.6.2　思考 518
12.7　后续学习资源 519
12.7.1　介绍 519
12.7.2　在线课程 519
12.7.3　教学课程 520
12.7.4　书籍 521
12.7.5　英伟达CUDA资格认证 521
12.8　本章小结 522

.　　苏统华
　　哈尔滨工业大学软件学院
　　

.　　本书的目的
　　高性能计算（HPC）是一个多学科领域，结合了硬件技术和架构、操作系统、编程工具、软件以及最终用户问题和算法。为了有能力参与HPC活动，需要一些必要的概念、知识和技能，通常需要在相关机构进行学习，这些机构拥有专家、设施和任务目标，但这样的机构并不太多。无论一个人的目标是与特定的最终用户领域（如科学、工程、医学或商业应用）相关联，还是专注于使超级计算有效地支持系统技术和方法，入门级从业者必须紧密结合广泛的、清晰的且相互关联和依存的领域，而且需要了解其协同作用才能领悟这些专业知识。学习材料可能很容易就找到十几本书和手册，但即使它们组合在一起，也无法提供充分体现整个领域的必要视角，无法成为指导学生获得足够专业知识的有效途径。
　　本书旨在弥合无数狭隘的焦点问题来源与跨越和互连各种学科（构成HPC领域）的单一来源需求之间的差距。它是一本入门级读物，需要最少的预备知识，提供了对这些领域及其相互影响（使超级计算成为一个跨学科领域）的完整理解。从实践的角度来看，本书针对并行编程、调试、性能监控、系统资源使用和工具以及结果可视化等有用的技术来培养读者的特定技能。这些技能涉及的基础概念相对而言变化较小，而关于硬件和软件系统组件的详细属性的知识更有可能随着时间的推移而发展。
　　本书支持单学期课程，以便初学者为超级计算中的各种角色做好准备，实现他们所选择的职业目标。它适合致力于使用超级计算机来解决科学、工程或社会领域等应用需求的未来的计算科学家。它为系统设计人员和工程师提供硬件和软件的可能目标功能的基本描述。对于希望研究超级计算本身的研究人员，作为传统系统和实践的介绍性演示，以及作为这个激动人心的探索领域面临的挑战的代表，本书也是一本基础读物。本书同样适合那些为超级计算环境提供技术支持的人员，例如数据中心和系统管理员、操作员和管理人员。在提供给未来的专业人员时，本书可以以多种方式来使用。它可为超级计算提供基础信息，为课堂教学提供一系列讲座内容。它使用大量示例来说明实际操作方法，所有这些都可以在并行计算机上执行，以及在实践时指导学生进行练习。它通过易于学习的风格明确了技能组合和训练方法。概念以详细且易于理解的形式呈现，以揭示方法背后的“原因”，并根据基本事实、相关因素和敏感性协助未来用户进行决策。最后，本书在同一上下文中统一了与多个子学科相关的许多事实，这些子学科组合构成了超级计算领域。
　　本书的组织结构
　　本书可以满足读者最初的好奇心、兴趣和参与HPC活动所需技能要求，通过学习本书，可以最终搭建起知识、能力和熟练程度之间的桥梁。对于追求各种潜在专业路径的人来说，本书是一个起点，其中这些路径在先进系统的性质和用途方面具有共同的基础。无论读者是否最终能够搭建硬件或软件系统，他们都能使用此类系统作为追求科学、工程、商业或安全等其他领域的关键工具来进行研究，从而有助于设计和推动支持当前HPC发展的未来方法，或管理、经营和维护供其他用户使用的HPC系统。本书的各个章节构成了一个无缝的主题流，每个主题都可以从前导主题中受益，同时也为后续主题提供基础。因此，本书按HPC使用的早期基本技能的顺序讲解主要主题，即使有可能过早涉及需要深入理解这些复杂系统及其使用才能掌握的基础概念。必要时，书中会给出主题的介绍性描述，其中包含足够的信息以帮助读者了解其他相关的主题，但只在后面的章节中进行更深入的回顾。通过学习多样化的相互关联的主题领域，读者的理解力和能力可以逐步增强。
　　本书是关于计算性能的。对于当前和下一代系统，这意味着可以利用工作负载并行性来实现可扩展性和管理数据的方法，从而实现操作效率。下面列出了4个主要的总体主题领域。
　　系统硬件架构和支持技术。
　　编程模型、接口和方法。
　　系统软件环境、支持和工具。
　　并行算法和分布式数据结构。
　　基于逻辑流程，本书给出了一目了然的教学组织结构。但HPC还有另一个方面：组织与协调并行性和数据管理的替代策略，以及有助于每个组件层的角色。
　　本书介绍了4种主要策略。
　　作业流并行性、吞吐量或容量计算。
　　顺序进程的通信或消息传递。
　　多线程共享内存。
　　SIMD或图形处理单元（GPU）加速。
　　从教学角度来看，作者希望传达三种信息以促进学习过程，并希望也能让读者得到享受。基础层面是概念，建立对基本原则的理解以帮助学习HPC的形式和功能。接下来会介绍许多基本信息及文化（什么人、什么事情、什么时候），这些事实构成了必要的知识集合，提供了该领域的框架。最后讲授一些实践技能。诚然，这三个层面彼此并不交叉。在每种情况下，本书都将案例的所有材料以这三种形式之一的方式来呈现。例如，标题以“……的基础”结尾的章节（例如“OpenMP的基础”）被精心设计为具有教程演示风格的模块，以便简化学习。虽然概念和知识的混合是不可避免的，但是我们会单独强调其中的一项。这种区别的重要性在于，虽然关于这个快速发展的领域的大部分知识将会改变，甚至在某些情况下已经过时，但基本概念随着时间的推移而保持不变，即使某些特定机器或语言的细节可能变得无关紧要，但这些知识也将帮助读者加强对相关领域的长期理解。
　　本书首先根据4个独立的并行计算模型来组织章节，然后根据基本概念对每个模型展开讨论，重点关注支持它们的系统体系结构的相关知识，以及针对每类系统进行编程的相关技能。在准备本书内容时，一些初始材料（包括介绍性章节）构成了本书的基本前提和背景。4个并行计算模型中的每一个都是根据概念、知识细节和编程技巧来描述的。虽然本书涵盖了理解和编程HPC系统所需的大部分有用信息，但忽略了与环境和工具相关的一些交叉主题，这些主题也是系统完整上下文的一个重要甚至普遍的方面。但是，对这些主题的介绍超出了初学者学习的范围。毕竟，本书目的是为读者提供高效的工作能力，以便在专业工作场所利用超级计算机实现各种目的。因此，本书以有效的顺序给出了许多重要且有用的工具和使用方法。最后，读者可以清楚地了解HPC应用的广泛领域，并且在这个背景下选择贴合本书的主题。这可以用来指导未来的计划，以及根据读者的最终职业目标选择更高级的课程。本书的总体结构和流程总结如下。
　　Ⅰ.绪论和基本思想（第1～4章）
　　这些章节介绍基础知识，主要包括：执行模型，体系结构的概念、性能和并行度量，以及并行计算系统（商品集群）的主流类型等。通过使用专门的基准测试程序来提供运行并行程序的初次实验，这些基准测试程序可以在不同的HPC系统之间进行测量和比较。正是在这些章节中，我们首先为读者营造了一种历史感，帮助初学者了解对领域有贡献的思想演变过程以及该领域的文化。
　　Ⅱ.针对作业流并行的吞吐量计算（第5章和第11章）
　　在利用并行计算机的最简单方法中，广泛使用的吞吐量计算（也称为容量计算）足以满足许多目标和工作流。可以证明它是效率最高的，因为它通常表现出最粗粒度的任务和最少的控制开销。我们将介绍管理作业流工作负载时广泛使用的中间件，如SLURM和PBS，包括独立作业和相关集的管理等案例，例如参数扫描和蒙特卡罗模拟应用程序。
　　Ⅲ.共享内存的多线程计算（第6章和第7章）
　　用户并行处理的主要模型之一是共享内存上下文的任务（或线程）并行。所有用户数据都可以由任何用户线程直接访问，并且顺序一致性由硬件高速缓存一致性来保证。本书的这部分描述了这种并行执行模型、共享内存多处理器的特性以及OpenMP并行编程语言。
　　Ⅳ.消息传递计算（第8章）
　　对于可在单个应用上使用100万个或更多个处理器核的真正可扩展并行计算而言，分布式内存架构和顺序进程执行模型间的通信是主流方法。本书的这部分建立在一些主题的基础之上，包括用于SMP的节点，以及先前针对吞吐量计算描述的集群方法等，并添加了消息传递、聚合操作和全局同步的语义。这一章介绍了消息传递接口（MPI），这是最广泛用于可扩展科学和工程应用的编程接口。
　　Ⅴ.加速GPU计算（第15章和第16章）
　　对于某些广泛使用的数据流模式，专用核心的更高级结构可以提供卓越的性能和能源效率。这种在最一般意义上被分类为“加速器”的子系统可以多次加速应用程序，有时可以获得超过一个数量级的加速。这些加速器也被称为GPGPU，它们通常采用附加阵列处理器的形式，但在某些情况下集成在单插槽封装甚至相同的芯片中。本书的这部分描述了GPU结构、可用产品和编程，重点是编程接口OpenACC。
　　Ⅵ.构建重要的程序（第9、10、12～14章）
　　至此，读者要非常了解HPC的主要模式，了解主要编程接口的规则，并具有在这些框架内使用基本并行函数的实践经验。但是对于更复杂、更尖端、更有用或者说更专业的超级计算程序来说，还需要许多其他方法和工具。本书的这部分会将HPC新手从初学者级别提升到有一定能力的学徒级别。这里介绍了几个关键主题和技能，帮助学生掌握关于系统设计和应用的必要能力。在这些技能之中，首要的是针对各种需求的各类并行算法。其中许多已经在称为“库”的集合中提供了，如果使用得当，它们可以为应用程序开发人员节省大量时间。要使程序从初稿发展到最终正确有效的形式，需要采用并行调试的组合方法，以通过操作监控来确定答案的正确性和性能优化。这里介绍了有关工具和方法，包括所需的详细技能组合。最后，HPC运行往往会在单次执行中产生大量的数据，多达太字节（terabyte，即1012字节）或拍字节（petabyte，即1015字节）。从大量数据集生成图像甚至视频的科学可视化，是我们了解计算的模拟结果的唯一实用方法。本部分提供了用于此目的的广泛使用的工具示例，并对其基本技术进行了说明，使读者能掌握用法。
　　Ⅶ.使用真实系统（第11、17～20章）
　　HPC系统并不是在真空中运行的，如果不与外界连接则没有什么价值。在本书中，读者可以看到系统环境的必要部分，这些章节对操作系统及其与外部世界的接口进行了有针对性的全面描述。特别是在硬件和软件级别描述了大容量存储，它通过文件系统持久存储大块数据。作为使用文件系统的示例，我们详细描述了MapReduce算法，它对于大数据问题非常流行。文件系统还可通过检查点-重启方法提高可靠性。在系统可能发生故障的情况下，该技术周期性地将应用程序的中间数据状态的快照存储在大容量存储器上。如果发生这种情况，应用程序可以不必从头开始重新启动，而是在最后一个已知的良好检查点重新启动，从而节省了大量时间来获得解决方案。
　　Ⅷ.下一步（第21章）
　　到了这里，读者已经学完了关于HPC的介绍性内容，但是接下来去哪里？这些系统及其应用领域还有很多，可以纳入任何单独的教科书中，本书已经做了很好的铺垫工作。学生可以清楚地了解前面的内容，并根据个人的兴趣或目标，明确下一步要了解哪些方面。这一章列出了超出本书范围的HPC领域，并突出了与不同专业目标相关的不同领域。但是接下来还有另一个方面：HPC领域会走向哪里？因为这一领域正在迅速变化，本章最后概述了HPC面临的挑战及推动它继续发展的机遇。
　　目标读者
　　本书面向具有不同背景的广大读者，希望每个人都能够成功地学习这些主题。具有C语言编程知识是最基本的先决条件，并且需要熟悉类UNIX操作系统，而且能操作。但据了解，这些要求对某些人来说可能过于严格。因此，本书的附录包括两个教程。附录A讲解C编程语言，包含足够多的细节知识。但它并不是计算机编程的入门读物，因为我们预期读者有使用Python、Java、Fortran或MATLAB等其他编程语言编写程序的经验。附录B提供了完成本书中所有任务所需的用户界面相关知识和技术。
　　本书可为广泛的读者群体提供服务，包括（但不限于）：
　　研究科学家。
　　科学、工程和社会领域的计算科学家。
　　HPC研究人员。
　　未来的工程师和HPC系统开发人员。
　　HPC系统管理员和数据中心经理。
　　如何使用本书
　　本书旨在根据特定读者的需求，提供多种不同的学习和讲授方法。
　　要想一开始就对HPC有全面深入的了解，可以从头到尾阅读本书。本书章节的顺序是经过精心组织的，每章都建立在前几章的基础上，涉及相关的概念、知识和技能。文中的示例足以代表这些知识点，以便读者顺利掌握。
　　另一方面，可以阅读以“……的基础”为标题的章节，以将本书作为一本教程来学习。这些章节旨在以最少的背景和上下文信息培养读者的技能。
　　通过选择关键章节可以实现重点阅读。本书呈现了4种并行计算模型：吞吐量、消息传递、共享内存和基于加速器。但在某些情况下，读者或教育工作者只需要了解其中一个，因此读者可能只需要沉浸在所需章节的子集中。例如，课程可以使用OpenMP或MPI，但不需要同时使用两者。对于基本的作业流并行，这两者都可以跳过，而是专注于SLURM或PBS进行吞吐量计算。
　　
　　
　　---------------------------8061305 - 基于CUDA的GPU并行程序开发指南---------------------------
　　
　　
　　我经历过在IBM大型机上编写汇编语言来开发高性能程序的日子。用穿孔卡片编写程序，编译需要一天时间；你要留下在穿孔卡片上编写的程序，第二天再来拿结果。如果出现错误，你需要重复这些操作。在那些日子里，一位优秀的程序员必须理解底层的机器硬件才能编写出好的代码。当我看到现在的计算机科学专业的学生只学习抽象层次较高的内容以及像Ruby这样的语言时，我总会感到有些焦虑。尽管抽象是一件好事，因为它可以避免由于不必要的细节而使程序开发陷入困境，但当你尝试开发高性能代码时，抽象就变成了一件坏事。
　　自第一个CPU出现以来，计算机架构师在CPU硬件中添加了令人难以置信的功能来“容忍”糟糕的编程技巧。20年前，你必须手动设置机器指令的执行顺序，而如今在硬件中CPU会为你做这些（例如，乱序执行）。在GPU世界中也能清晰地看到类似的趋势。由于GPU架构师正在改进硬件功能，5年前我们在GPU编程中学习的大多数性能提升技术（例如，线程发散、共享存储体冲突以及减少原子操作的使用）正变得与改进的GPU架构越来越不相关，甚至5～10年后，即使是一名非常马虎的程序员，这些因素也会变得无关紧要。当然，这只是一个猜测。GPU架构师可以做的事取决于晶体管总数及客户需求。当说晶体管总数时，是指GPU制造商可以将多少个晶体管封装到集成电路（IC）即“芯片”中。当说客户需求时，是指即使GPU架构师能够实现某个功能，但如果客户使用的应用程序不能从中受益，就意味着浪费了部分的晶体管数量。
　　从编写教科书的角度出发，我考虑了所有的因素，逐渐明确讲授GPU编程的最佳方式是说明不同系列GPU（如Fermi、Kepler、Maxwell和Pascal）之间的不同并指明发展趋势，这可以让读者准备好迎接即将到来的下一代GPU，再下一代，……我会重点强调那些相对来说会长期存在的概念，同时也关注那些与平台相关的概念。也就是说，GPU编程完全关乎性能，如果你了解程序运行的平台架构，编写出了与平台相关的代码，就可以获得更高的性能。所以，提供平台相关的解释与通用的GPU概念一样有价值。本书内容的设计方式是，越靠后的章节，内容越具有平台特定性。
　　我认为本书最独特的地方就是通过第一部分中的CPU多线程来解释并行。第二部分介绍了GPU的大规模并行（与CPU的并行不同）。由于第一部分解释了CPU并行的方式，因此读者在第二部分中可以较为容易地理解GPU的并行。在过去的6年中，我设计了这种方法来讲授GPU编程，认识到从未学过并行编程课程的学生并不是很清楚大规模并行的概念。与GPU相比，“并行化任务”的概念在CPU架构中更容易理解。
　　本书的组织如下。第一部分（第1章至第5章）使用一些简单的程序来演示如何将大任务分成多个并行的子任务并将它们映射到CPU线程，分析了同一任务的多种并行实现方式，并根据计算核心和存储单元操作来研究这些方法的优缺点。本书的第二部分（第6章至第11章）将同一个程序在多个Nvidia GPU平台（Fermi、Kepler、Maxwell和Pascal）上并行化，并进行性能分析。由于CPU和GPU的核心和内存结构不同，分析结果的差异有时很有趣，有时与直觉相反。本书指出了这些结果的不同之处，并讨论了如何让GPU代码运行得更快。本书的最终目标是让程序员了解所有的做法，这样他们就可以应用好的做法，并避免将不好的做法应用到项目中。
　　尽管第一部分和第二部分已经完全涵盖了编写一个好的CUDA程序需要的所有内容，但总会有更多需要了解的东西。本书的第三部分为希望拓宽视野的读者指明了方向。第三部分并不是相关主题的详细参考文档，只是给出了一些入门介绍，读者可以从中获得学习这些内容的动力。这部分主要介绍了一些流行的CUDA库，比如cuBLAS、cuFFT、Nvidia Performance Primitives和Thrust（第12章）；OpenCL编程语言（第13章）；使用其他编程语言和API库进行GPU编程，包括Python、Metal、Swift、OpenGL、OpenGL ES、OpenCV和微软HLSL（第14章）；深度学习库cuDNN（第15章）。
　　书中代码的下载地址为：https://www.crcpress.com/GPU-Parallel-ProgramDevelopment-Using- CUDA /Soyata/p/book/9781498750752。
　　Tolga Soyata
　　
　　
　　---------------------------5850457 - CUDA C编程权威指南---------------------------
　　
　　
　　欢迎来到用CUDA C进行异构并行编程的奇妙世界！
　　现代的异构系统正朝一个充满无限计算可能性的未来发展。异构计算正在不断被应用到新的计算领域—从科学到数据库，再到机器学习的方方面面。编程的未来将是异构并行编程的天下！
　　本书将引领你通过使用CUDA平台、CUDA工具包和CUDA C语言快速上手GPU（图形处理单元）计算。本书中设置的范例与练习也将带你快速了解CUDA的专业知识，助你早日达到专业水平！
　　本书写给谁
　　本书适用于任何想要利用GPU计算能力来提高应用效率的人。它涵盖了CUDA C编程领域最前沿的技术，并有着以下突出的优势：
　　风格简洁
　　描述透彻
　　大量范例
　　优质习题
　　覆盖面广
　　内容聚焦高性能计算的需求
　　如果你是一个经验丰富的C程序员，并且想要通过学习CUDA C来提高高性能计算的专业才能，本书中建立在你现有知识之上的例题和习题，将使掌握CUDA C编程更加简单。仅需掌握一些C语言延伸的CUDA知识，你便可以从大量的并行硬件中获益。CUDA平台、编程模型、工具和库将使得异构架构编程变得简捷且高效。
　　如果你是计算机科学领域以外的专业人士，而且想要通过GPU上的并行编程来最大限度地提高工作效率，并提高应用性能，那么本书正是为你量身打造的。书中的阐述清晰而简明，专人精心设计的示例，使用配置文件驱动的方法，这些都将帮助你深入了解GPU编程并迅速掌握CUDA。
　　如果你是教授或任何学科的研究者，希望通过GPU计算推进科学发现和创新，本书中将有你找到解决方案的捷径。即使你没有多少编程经验，在并行计算概念和计算机科学的知识方面也不够精通，本书也可带你快速入门异构架构并行编程。
　　如果你是C语言初学者并且有兴趣探索异构编程，本书也完全适合你，因为它不强制要求读者有丰富的C语言编程经验。即使CUDA C和C语言使用相同的语法，二者的抽象概念和底层硬件也是全然不同的，因而对其中之一的经验并不足以使你在学习另一个时感到轻松。所以，只要你对异构编程有浓厚的兴趣，只要你乐于学习新事物且乐于尝试全新的思维方式，只要你对技术相关的话题有深入探索的热情，本书也完全适合你。
　　即使你有不少关于CUDA C的经验，本书还是有助于知识更新、探索新工具以及了解最新CUDA功能。虽然本书旨在从零开始培养CUDA的专业人才，但它也含有许多先进的CUDA概念、工具和框架的概述，它们将对CUDA开发人员大有裨益。
　　本书的内容
　　本书讲解了CUDA C编程的基本概念与技术，用于大幅加速应用程序的性能，并包含了随着CUDA工具包6.0和NVIDIA Kepler GPU一起发布的最新功能。在对从同质架构到异构架构的并行编程模式转变进行了简要介绍之后，本书将引导你学习必要的CUDA编程技能和最佳的练习实践，包含但不仅限于CUDA编程模型、GPU执行模型、GPU内存模型、CUDA流和事件、多GPU编程的相关技术、CUDA感知MPI编程和NVIDIA开发工具。
　　本书采用一种独特的方法来教授CUDA知识，即将基础性的概念讲解与生动形象的示例相结合，这些示例使用配置文件驱动的方法来指导你实现最佳性能。我们对每一个主题都进行了详尽的讲解，清晰地展示出了采用代码示例形式详细操作的过程。书中不仅教授如何使用基于CUDA的工具，还介绍了如何以抽象编程模型为基础并凭借悟性与直觉对开发过程每一步骤的结果做出解释，从而帮助你快速掌握CUDA的开发流程。
　　每章围绕一个主题展开讲解，运用可行的代码示例来演示GPU编程的基本功能和技术，这之后就是我们精心设计的练习，以便你进一步探索加深理解。
　　所有的编程示例都是在装有CUDA 5.0（或更高版本）和Kepler或Fermi GPU的Linux系统上运行的。由于CUDA C是一种跨平台的语言，因而书中的示例在其他平台上也同样适用，比如嵌入式系统、平板电脑、笔记本电脑、个人电脑、工作站以及高性能计算服务器。许多OEM供应商支持各种类型的NVIDIA GPU。
　　本书的结构
　　本书共有10章，包含了以下主题。
　　第1章：基于CUDA的异构并行计算
　　本章首先简要介绍了使用GPU来完善CPU的异构架构，以及向异构并行编程进行的模式转变。
　　第2章：CUDA编程模型
　　本章介绍了CUDA编程模型和CUDA程序的通用架构，从逻辑视角解释了在CUDA中的大规模并行计算：通过编程模型直观展示的两层线程层次结构。同时也探讨了线程配置启发性方法和它们对性能的影响。
　　第3章：CUDA执行模型
　　本章通过研究成千上万的线程是如何在GPU中调度的，来探讨硬件层面的内核执行问题。解释了计算资源是如何在多粒度线程间分配的，也从硬件视角说明了它如何被用于指导内核设计，以及如何用配置文件驱动方法来开发和优化内核程序。另外，本章还结合示例阐述了CUDA的动态并行化和嵌套执行。
　　第4章：全局内存
　　本章介绍了CUDA内存模型，探讨全局内存数据布局，并分析了全局内存的访问模式。本章介绍了各种内存访问模式的性能表现，阐述了统一内存和CUDA 6.0中的新功能是如何简化CUDA编程的，以及如何提高程序员工作效率。
　　第5章：共享内存和常量内存
　　本章阐释了共享内存，即管理程序的低延迟缓存，是如何提高内核性能的。它描述了共享内存的优化数据布局，并说明了如何避免较差的性能。最后还说明了如何在相邻线程之间执行低延迟通信。
　　第6章：流和并发
　　本章介绍了如何使用CUDA流实现多内核并发执行，如何重叠通信和计算，以及不同的任务分配策略是如何影响内核间的并发的。
　　第7章：调整指令级原语
　　本章解释了浮点运算、标准的内部数学函数和CUDA原子操作的性质。它展示了如何使用相对低级别的CUDA原语和编译器标志来优化应用程序的性能、准确度和正确性。
　　第8章：GPU加速库和OpenACC
　　本章将介绍实现程序并行的CUDA专用函数库，包括线性代数、傅里叶变换和随机数生成等范例。本章还解释了OpenACC和基于编译器指令的GPU编程模型是如何利用更简单的方法辅助CUDA挖掘GPU计算能力的。
　　第9章：多GPU编程
　　本章介绍了支持P2P GPU内存访问的GPUDirect技术，阐述了如何在多个GPU上管理和执行计算问题，还说明了在GPU加速计算集群上的大规模应用是如何利用MPI与GPUDirect RDMA来实现性能线性扩展的。
　　第10章：程序实现的注意事项
　　本章介绍了CUDA的开发过程和各种配置文件驱动的优化策略，演示了如何使用CUDA调试工具来调试内核和内存错误，通过案例教你如何将一个传统的C程序一步步移植到CUDA C中，以有助于加强你对于这一方法的理解，同时将此过程可视化，并验证了这些工具。
　　阅读本书前的准备
　　本书不对GPU作特殊要求，使用本书前也不需要你具备并行编程的相关经验，不过你最好会一些Linux的基本操作。运行本书各示例代码的理想机器环境是：安装有CUDA 6.0工具包的Linux系统，C/C++ 6.0编译程序和NVIDIA Kepler GPU。
　　尽管某些使用CUDA 6.0的示例可能需要Kepler GPU，但大多数示例仍需在Fermi设备上运行。它们中的大多数可以使用CUDA 5.5来编译。
　　CUDA工具包的下载
　　你可以从https://developer.nvidia.com/cuda-toolkit下载CUDA 6.0工具包。
　　该CUDA工具包包括了NVIDIA GPU编译器、CUDA数学库以及用于调试和优化应用程序性能的工具，此外还有编程指南、用户手册、API参考指南和其他文档，它们都将帮助你快速掌握GPU应用程序的开发。
　　规范
　　为了使你的阅读体验达到最佳，我们在书中使用了一些规范。对于新出现的术语和重要的词语，在其第一次被引入时，我们会对它们进行突出强调。文中出现的文件名、URL地址和代码表示如下：
　　我们用以下方式表示代码：
　　我们按如下方式介绍CUDA运行时的函数：
　　我们按如下方式显示程序输出：
　　我们用以下方式给出命令行指令：
　　源代码
　　在学习本书中的示例时，你可以选择手动输入所有代码或者使用附在本书上的源代码。所有本书中的源代码都可在www.wrox.com/go/procudac下载。在页面上，只要找到本书的标题（通过搜索框查找或直接查看书名列表），然后单击书中的详细信息页面上的代码下载链接，就可以获取书中所有的源代码。
　　在完成每章结尾的练习时，推荐你利用参考示例代码亲自编写代码。所有练习用的代码文件同样也可从Wrox网站下载。
　　勘误表
　　尽管我们已竭尽所能来避免书中出现文本或代码错误，然而事实上，难免百密一疏。如果你在阅读本书的过程中发现了如拼写或编码上的错误，并愿意与我们联系进行反馈，我们将不胜感激。若你能帮助勘误，这将会使其他读者免于在困惑中长久徘徊，同时，你也是在帮助我们给读者提供更加高质量的信息。
　　本书的勘误表可在www.wrox.com/go/procudac处找到。在本书的详细信息页面，点击图书勘误表链接即可。在这个页面上，你可以查看所有已提交并由Wrox的编辑发布的勘误表。
　　
　　
　　---------------------------5206918 - 多核与GPU编程：工具、方法及实践---------------------------
　　
　　
　　多核架构出现在21世纪的第一个10年里，给并行计算带来了勃勃生机。新平台需要新方法来进行软件开发，其中一个新方法就是把工具和工作站网络时代的惯例同新兴软件平台（如CUDA）相结合。
　　为满足这种需求，本书将介绍目前主流的工具和技术，不仅是各自独立的工具和技术，更重要的是将它们相互结合。书中会提供多平台和程序设计范例（如消息传递和线程）高效结合的实例。顾名思义，“Hybrid”（混合）计算，是高性能计算的一个新趋势，针对百亿亿级的性能需求，使软件有可能扩展到数百万的线程上。
　　所有章节都包含丰富的示例和实际问题，并比较了不同的设计脚本，重点在于如何使其实际运作起来。那些能使得高效的软件开发区别于徒劳无功的软件开发训练的所有细节，都以有序的形式呈现出来。
　　本书介绍了从20世纪90年代继承而来的最新的先进工具（例如OpenMP和MPI标准），并包括更前沿的平台，如具有复杂线程管理功能的Qt库，以及具有在不同多核架构（包括CPU和GPU）上配置相同软件功能的Thrust模板库。
　　我不可能面面俱到地给出多核开发中的所有可用工具。即使是POSIX线程之类的一些行业标准，书中也并未涉及。
　　本书不仅旨在介绍主流范型（范围从OpenMP的串行代码半自动并行化到用来巩固MPI的显式通信“plumping”）的实例，还要讲解高效的多核软件开发背后的原理，并指导读者进行实践。
　　本书内容
　　本书可以分成如下几个逻辑单元，虽然书中没有明确地这样区分。
　　多核软件的设计概述概述：第1章介绍多核硬件，讨论了一些具有影响力的体系结构范型示例。第1章也介绍了加速比和效率，在评估多核和并行软件时这些是基本的度量方式。1.5节告诉读者如何从多核和众核硬件激动人心的新进展中预测出什么是人们所期待的方法。
　　第2章讨论可应用于并行和多核软件开发的方法论与设计模式，包括工作分解模式和程序结构模式。
　　共享内存编程：讨论了两种不同的共享内存并行编程方法——显式并行化和隐式并行化。在显式方面，第3章覆盖了线程和两种最常用的同步机制——信号和monitor。对于通常遇到的设计模式（如生产者–消费者模式和读者–写者模式），均给出了详细解释并应用于一系列示例中。
　　在隐式方面，第4章介绍了OpenMP标准，该标准的设计使得我们能以最少的工作量将现有串行代码并行化。它可使开发时间大大缩短。该标准还有其他的好处，如解决了循环间存在的依赖。
　　分布式内存编程：第5章介绍了分布式内存并行编程的事实标准——消息传递接口（MPI）。MPI同多核编程相关，因为它旨在把程序从一个共享内存多核机器上扩展到一个具有上百万节点的超级计算机上。就其本身而言，MPI能够为利用多核机器的多重分解提供基础，以作为独立的虚拟平台。
　　这部分涉及的特征包括点对点通信和集合通信，也包括单边通信。有一节内容专门针对Boost.MPI库，虽然还未实现全部的功能，但它的确简化了使用MPI的过程。
　　GPU编程：GPU是把本书内容组织在一起的最初原因之一。以此类推到共享内存编程，这里从两个方面讨论了针对GPU软件开发的问题。一方面是NVIDIA的CUDA中的具体方法，该方法中的内存传输、数据放置和线程执行配置都需要仔细计划。这将在第6章进行介绍。
　　另一方面是高级的Thrust模板库算法方法，这部分在第7章中讨论。程序设计的类标准模板库（STL-like）方法为Thrust提供了把CPU和GPU平台均作为目标的能力，在本书所介绍的工具中，这是一个独特的特性。
　　负载均衡：第8章讨论在多核开发中经常被低估的一个方面。一般来说，一旦异构计算资源开始运行，就应该认真考虑负载均衡。举例来说，一个CPU和一个GPU构成这一组资源，我们在满足需求时不能只考虑一群不同机器的集合。第8章简要讨论了Linda语言，这可以被看做动态负载均衡的高级抽象。
　　书中主要的关注点在静态负载均衡，以及可以用于驱动负载分区和数据通信序列的数学模型。
　　很多场景中都应用了一种已经得到认可的方法论——可分负载理论（DLT），并且给出了解释。书中还介绍了一个简单的C++库，它实现了部分过去20年中已经发表过的DLT研究结果。
　　软件和硬件要求
　　书中的示例都是在Ubuntu Linux系统上开发和测试的。本书中使用的所有软件都是可以免费获取或者是开源的。其中包括：
　　GNU C/C++ 编译器组件 4.8.x（兼容 CUDA），组件4.9.x （兼容OpenMP 4.0）
　　Digia的 Qt 4.x 库或者Qt 5.x 库
　　OpenMPI 1.6
　　MPE
　　NVIDIA的 CUDA SDK 6.5
　　Thrust 库 （版本1.7）
　　如果拥有近期正确安装的Linux，并装有版本等于或高于上述软件列表中版本号的软件，那么执行本书中提供的示例代码应该不会有任何问题。虽然我没有提供Windows平台下的生成文件或者使用Visual Studio编译和执行示例代码的指令，但未安装Linux的用户只需进行少量代码改动就可以把示例移植到Windows上。考虑到我们使用的是标准C/C++库，因此对于代码的改动（如果存在）应该只会影响头文件，也就是那些需要被包括的（include）文件。
　　硬件部分唯一的实际局限是需要计算能力为2.x或者更高的NVIDIA GPU。早期芯片也可以使用，但是它们的独特性，尤其是关于全局内存的访问，在书中没有给出解释。没有NVIDIA GPU的用户可以通过使用附录E中介绍的方法来成功执行CUDA程序。
　　示例代码
　　书中的程序可在Elsevier网站(http://store.elsevier.com/9780124171374)上获取压缩包。
　　程序存放在特定的文件夹中，以章名区分，如图1所示。
　　对于书中的代码清单，均在第1行给出了相对于该章目录的对应文件的位置。
　　单文件程序的第一行注释里包含编译和链接命令。多文件项目存放在它们自己的目录中，其中也包含一个生成文件或者一个项目（.pro）文件。如果需要输入样本值，该部分数据也在该目录下的文件中提供。
　　图1截屏显示了示例代码在特定章节的文件夹中的组织方式
　　教学建议
　　本书中所涉及的内容适合高年级本科生或者研究生课程。学生需要具备的背景知识包括掌握C和C++编程（两种语言的使用贯穿整本书）、基本的操作系统概念，以及基本的计算机体系结构常识。
　　根据各自的需求，教师可以选择使用以下列出的一些教学建议。前两章是为后面的章节奠定基础，因此它们在所有的路径中都包括：
　　重点在并行编程（本科生）：
　　第1章：Flynn分类法、当代的多核设备、性能标准。1.1～1.5节。
　　第2章：设计、PCAM方法论、分解模式、程序结构模式。2.1～2.5节。
　　第3章：线程、信号、monitor。3.1～3.7节。
　　第4章：OpenMP的基本概念、工作共享结构， 4.1～4.4节。
　　第5章：MPI、点对点通信、集合操作、目标/结构通信，以及调试和性能分析。5.1～5.12节、5.15～5.18节和5.20节。
　　第6章：CUDA编程模型，内存层次结构，针对GPU的优化。6.1～6.6节、 6.7.1节、6.7.3节、 6.7.6节、6.9～6.11节和6.12.1节。
　　第7章：Thrust基本的知识。7.1～7.4节。
　　第8章：负载均衡。8.1～8.3节。
　　重点在多核编程（本科生）：
　　第1章：Flynn分类法、当代的多核设备、性能标准。1.1～1.5节。
　　第2章：设计、PCAM方法论、分解模式、程序结构模式。2.1～2.5节。
　　第3章：线程、信号、monitor。3.1～3.10节。
　　第4章：基本的OpenMP、工作共享结构，以及正确性和性能问题。4.1～4.8节。
　　第5章：MPI，点对点通信、集合操作、目标/结构通信，以及调试和性能分析。5.1～5.12节、 5.16～5.18节和5.21节。
　　第6章：CUDA编程模型、内存层次结构，以及针对GPU的优化。6.1～6.10节、 6.12.1节。
　　第7章： Thrust基本的知识。7.1～7.4节。
　　第8章：负载均衡。8.1～8.3节。
　　高级多核编程：
　　第1章：Flynn分类法、当代的多核设备、性能标准。1.1～1.5节。
　　第2章：设计、PCAM方法论、分解模式、程序结构模式。2.1～2.5节。
　　第3章：线程、信号、monitor、高级线程管理。3.1～3.10节。
　　第4章：OpenMP基本的知识，工作共享结构，以及正确性和性能问题。4.1～4.8节。
　　第5章：MPI、点对点通信、集合操作、目标/结构通信，以及调试和性能分析。5.1～5.12节、 5.15～5.18节和 5.21～5.22节。
　　第6章：CUDA编程模型、内存层次结构，以及针对GPU的优化。6.1～6.12节。
　　第7章：Thrust数据类型和算法。7.1～7.7节。
　　第8章：负载均衡、基于DLT的分割。8.1～8.5节。
　　
　　
　　---------------------------3769261 - CUDA并行程序设计：GPU编程指南---------------------------
　　
　　
　　过去的五年中，计算领域目睹了英伟达（NVIDIA）公司带来的变革。随后的几年，英伟达公司异军突起，逐渐成长为最知名的游戏硬件制造商之一。计算统一设备架构（Compute Unified Device Architecture，CUDA）编程语言的引入，第一次使这些非常强大的图形协处理器为C程序员日常所用，以应对日益复杂的计算工作。从嵌入式设备行业到家庭用户，再到超级计算机，所有的一切都因此而改变。
　　计算机软件界最大的变迁是从串行编程转向并行编程。其中，CUDA起到了重要的作用。究其本质，图形处理单元（Graphics Processor Unit，GPU）是为高速图形处理而设计的，它具有天然的并行性。CUDA采用一种简单的数据并行模型，再结合编程模型，从而无须操纵复杂的图形基元。
　　实际上，CUDA与之前的架构不同。它不要求程序员对图形或者图形基元有所了解，也不用程序员有任何这方面的知识。你也不一定要成为游戏开发人员。CUDA语言使得GPU看起来与别的可编程设备一样。
　　本书并不假定读者有CUDA或者并行编程的任何经验，仅假定读者有一定的C/C++语言编程知识。随着本书的不断深入，读者将越来越胜任CUDA的编程工作。本书包含更高级的主题，帮助你从不知晓并行编程的程序员成长为能够全方位发掘CUDA潜力的专家。
　　对已经熟悉并行编程概念和CUDA的程序员来说，本书包含丰富的学习资料。专设章节详细讨论GPU的架构，包括最新的费米（Fermi）和开普勒（Kepler）硬件，以及如何将它们的效能发挥到极致。任何可以编写C或C++程序的程序员都可以在经过几个小时的简单训练后编写CUDA程序。通过对本书的完整学习，你将从仅能得到数倍程序加速的CUDA编程新手成长为能得到数十倍程序加速的高手。
　　本书特别针对CUDA学习者而写。在保证程序正确性的前提下，侧重于程序性能的调优。本书将大大扩展你的技能水平和对编写高性能代码的认识，特别是GPU方面。
　　本书是实践者在实际应用程序中使用CUDA编程的实用指南。同时我们将提供所需的理论知识和背景介绍。因此，任何人（不管有无基础）都可以使用本书，从中学习如何进行CUDA编程。综上，本书是专业人士和GPU或并行编程学习者的理想之选。
　　本书编排如下：
　　第1章从宏观上介绍流处理器（streaming processor）的演变历史，涉及几个重要的发展历程，正是它们把我们带入今天的GPU处理世界。
　　第2章介绍并行编程的概念。例如，串行与并行程序的区别，以及如何采用不同的策略寻找求解问题之道。本章意在为既有串行程序员建立一个基本的认识，这里的概念将在后面进一步展开。
　　第3章详尽地讲解CUDA设备及与其紧密相关的硬件和架构。为了编写最优性能的CUDA程序，适当了解设备硬件的相关知识是必要的。
　　第4章介绍了如何在Windows、Mac和Linux等不同操作系统上安装和配置CUDA软件开发工具包，另外介绍可用于CUDA的主要调试环境。
　　第5章介绍CUDA线程模型，并通过一些示例来说明线程模型是如何影响程序性能的。
　　第6章我们需要了解不同的内存类型，它们在CUDA中的使用方式是影响性能的最大因素。本章借助实例详细讲解了不同类型内存的工作机制，并指出实践中容易出现的误区。
　　第7章主要详述了如何在若干任务中恰当地协同CPU和GPU，并讨论了几个有关CPU/GPU编程的议题。
　　第8章介绍如何在应用程序中编写和使用多GPU。
　　第9章对CUDA编程中限制性能的主要因素予以详解，考察可以用来分析CUDA代码的工具和技术。
　　第10章介绍了CUDA软件开发工具包的示例和CUDA提供的库文件，并介绍如何在应用程序中使用它们。
　　第11章关注构建自己的GPU服务器或者GPU集群时的几个相关议题。
　　第12章检视多数程序员在开发CUDA应用程序时易犯的错误类型，并对如何检测和避免这些错误给出了建议。
　　

.　　书中首先介绍基础知识，包括执行模型、体系结构、性能度量、商品集群等；接着讲解吞吐量计算、共享内存计算、消息传递计算和加速GPU计算，围绕这些模型的概念、细节及编程实践展开讨论；然后引导读者构建应用程序，涵盖并行算法、库、可视化及性能优化等；最后，考虑真实系统环境，讨论了操作系统、大容量存储、文件系统及MapReduce算法等。书中通过大量示例来说明实际操作方法，这些均可在并行计算机上执行，以帮助读者更好地理解方法背后的原因。
　　推荐阅读方式
　　本书提供了多种学习路径，建议读者按照自己的需求进行学习：
　　·全面式阅读。从头到尾的细读将帮助你获得全面且深入的理解。所有章节都经过精心组织，知识结构层层递进。
　　·指南式阅读。挑选以“……的基础”为标题的章节，作为一本快捷知识指南或教程，所要求的预备知识最少。
　　·精选式阅读。根据自己的需求，精读关键章节，如从四种并行计算模型中进行挑选，或在学习基本的作业流并行时专注于SLURM或PBS。
　　
　　
　　---------------------------8061305 - 基于CUDA的GPU并行程序开发指南---------------------------
　　
　　
　　本书详细介绍GPU编程方法，展示了不同的GPU系列之间的区别。这样的讲授方式能使读者更好地应对下一代或未来的GPU系列。本书重点关注基础性概念，同时也关注与平台相关的概念。提供平台相关的内容与通用的GPU概念一样有价值。
　　本书分为三个部分，第一部分利用CPU的多线程概念介绍了并行性的基础知识，通过一些简单的代码示例展示了如何将一个大任务分成若干并行的子任务，然后将它们映射到CPU线程。对于同一个任务，尝试了多种不同的并行实现方法，并针对核心和内存操作分析了这些方法的优缺点。
　　第二部分介绍了GPU的大规模并行性。在多个Nvidia GPU平台上对相同的程序进行了并行化实现，并分析了它们的性能。由于CPU和GPU的核心与内存结构不同，运行结果也显示出了很多有趣的差异。最终目标是希望程序员既能掌握有益的思想，也能了解那些不好的做法，这样在自己开发的程序中能采用有用的策略，同时避免犯错。
　　第三部分为想要拓展知识的读者提供了建议。该部分简要介绍了一些常用的CUDA库（例如cuBLAS、cuFFT、NPP和Thrust），OpenCL编程语言，其他GPU编程语言和API（如Python、OpenCV、OpenGL、Swift与Metal），以及深度学习库cuDNN。
　　
　　
　　---------------------------5850457 - CUDA C编程权威指南---------------------------
　　
　　
　　图形处理器（GPU）已经有了很大的发展。从最初能够瞬时生成图像输出的专业图形处理器，发展到显示单元，GPU已经成为人们在进行超高速数据处理时热衷的技术手段。在过去的几年中，GPU已经越来越多地附加到CPU上，用于加速异构计算中的各种计算。如今，许多桌面系统、计算集群，甚至世界上许多最大的超级计算机都配置有GPU。图形处理器有着用于专业技术计算的大数据计算能力，它们已经在广泛的学科领域中实现了科学和工程的巨大进步，因为它们使大量计算核心并行工作，同时又将功耗预算保持在合理范围内。
　　所幸，GPU编程接口也一直与时俱进。过去，要在应用功能之外使用它们要费好大一番功夫，GPU编程人员不得不去熟练掌握那些通常只有图形程序员才能理解到位的诸多概念。如今的系统提供了一个更加便捷的手段来创建可以在其上运行的应用软件，这就是CUDA。
　　CUDA是最受欢迎的应用编程接口之一，可用于加速GPU上的一系列计算内核。它可以让C或C++代码在GPU上合理高效地运行。CUDA既满足了为使其良好运行而了解其架构的需要，又有为了使用和输出可读程序的编程接口，并且完美地平衡了这两项功能。
　　对任何想要使用GPU来进行科研或技术编程的人来说，该书都将是一个珍贵的资源宝库。它全面介绍了CUDA编程接口及其用法。首先，它描述了在异构架构上并行计算的基础知识，并介绍了CUDA的功能。其次，它解释了CUDA程序的执行方式。由于CUDA为程序员提供了操作手段和内存模型，因而CUDA程序员直接掌控了大规模并行环境。除了提供CUDA内存模型的细节之外，该书还提供了丰富的关于如何使用CUDA的信息。接下来的章节将讨论流，以及如何执行并行和重叠的内核。然后是关于调整指令级原语，关于如何使用CUDA库，以及关于使用OpenACC指令进行GPU编程的部分。在第9章之后，本书还提供了一些应用时的注意事项。此外，书中列举大量的范例来帮助读者更好地入门，读者可以下载并亲自运行体验。
　　实践证明，CUDA在表现力和可编程性之间实现了绝佳的平衡。但是，以简化应用开发为使命的人深知，路漫漫其修远兮。在过去的几年中，CUDA的研究人员一直在努力改善异构编程工具。CUDA 6.0引入了许多新功能，包括统一的内存和插件库，极大地简化了GPU编程。它们还提供了一组名为OpenACC的指令，这在书中也有所涉及。OpenACC有望进一步完善CUDA，它将减少在程序执行中所需的直接控制，与此同时提供一个更加便捷的方法来利用GPU的编程能力。目前看来，收效良好。无论是OpenACC、CUDA 6.0，还是书中讲到的其他主题，都将帮助CUDA开发人员加快应用程序的运行，从而实现前所未有的高性能。请相信我，这本书值得占据你书架的一席之地！
　　祝大家编程愉快！
　　芭芭拉·查普曼
　　休斯敦大学计算机辅助创新设计系统与计算机系
　　
　　
　　---------------------------3769261 - CUDA并行程序设计：GPU编程指南---------------------------
　　
　　
　　本书旨在为读者学习CUDA打下坚实基础。涵盖如何理解串行程序并把它转化到单指令流多数据流编程模型下，以及如何基于CUDA实现高效的并行程序。本书除了提供多个实例，还深入讨论了GPU程序的优化，同时对共享内存、内存预读和线程的使用均有涉及。
　　——Nagarajan Kandasamy博士，德雷塞尔大学电子与计算机工程系副教授
　　

.　　4.8GT/s（标准配置） 19.2GB/s 4.8GB/s
　　6.4GT/s（最大配置） 25.6GB/s 6.4GB/s
　　注意：QPI指快速通道互联（Quick Path Interconnect）
　　当考虑处理器的时钟速度时，你遇到的第一个问题是关于内存带宽的。用速度为4GHz的处理器，你可能每个时钟周期需要取来一条指令（操作码）和某个数据（操作数）。
　　通常，每个指令长32位。所以，假设你在每个核上只执行一组不带数据的、顺序执行的指令，则每秒钟你需要取来4.8GB/s÷4=1.2GB条指令。这是假设处理器平均每个时钟周期执行一条指令的情况。不过，通常你还需要读取和写回数据，这里假设数据与指令的比例是1∶1，那么这意味着我们的实际吞吐量将减少一半。
　　内存速度和时钟速度的比率是限制CPU和GPU吞吐量的一个重要因素，这一点我们将在后续的章节中讨论。深入分析你就会发现，除了CPU和GPU中的一些例外，大多数应用程序属于“内存受限型”，而不是“处理器时钟周期或负载受限型”。
　　CPU厂商试图通过使用缓存和突发内存访问来解决这个问题，这利用了程序的局部性原理。下面是一个典型的C程序，请仔细观察该函数中相关操作的类型：
　　让我们看看处理器是如何实现的。首先，数组array的地址被装入某个内存访问寄存器，然后参数i被装入到另一个寄存器。循环退出条件为100，这个退出条件既可以装入一个寄存器，也可以编码的形式，成为指令流中的一个字面值。这时，计算机将重复执行这几条指令，循环100次。对于每一个计算出的值，我们需要取来并执行“控制指令”、“访存指令”和“计算指令”。
　　这显然是低效的，因为计算机执行的是相同的指令，只是处理的数据不同。因此，硬件设计者就为几乎所有的处理器设置了容量很小的缓存，并且在更复杂的处理器中，设置多级缓存（如图1-1所示）。当需要从内存中取数据或指令时，处理器首先查询缓存。如果数据或指令在缓存中，则高速缓存直接将其交给处理器。
　　图1-1典型的现代CPU缓存组成结构
　　如果数据不在一级缓存（L1）中，则处理器向二级或三级（L2或L3）缓存发出读取请求。如果缓存中没有此数据，则需要从主存（即内存）中读取。一级缓存的工作速度通常能达到或接近处理器的时钟速度。因此，假设写入和读取都是在缓存中完成，则循环的执行就很有可能接近处理器全速。然而，这是有一定成本的：一级缓存的大小，通常只有16K或32KB大小。二级缓存就要慢些，但空间会大些，通常约为256K。三级缓存则要大得多，通常几兆字节大小，但是比二级缓存要慢得多。
　　在实际程序中，循环程序往往非常大，可能达几兆字节大小。即便是程序可以存放在缓存中，但数据集往往就存不下了。所以尽管设置了缓存，处理器仍然会因为受到内存吞吐率或带宽的限制，而无法发挥其所具有的处理能力。
　　当处理器从缓存而不是主存中取来一条指令或一个数据时，称为缓存命中（cache hit）。但是随着缓存容量的不断增大，使用更大容量缓存所带来的增速收益却迅速下降。这意味着，现代处理器中使用大容量缓存并不是提高性能的一个有效办法，除非有办法将问题的整个数据集都装入缓存。
　　英特尔I7-920处理器有8MB的片内三级缓存。这个缓存的设计是有代价的，看一下英特尔I7处理器的模型，我们会知道三级缓存占用了约30％左右的芯片面积（如图1-2所示）。
　　随着缓存容量的增长，用于制造处理器的硅片的物理尺寸也逐渐变大。芯片越大，制造成本越昂贵，在制造过程中因发现差错而将芯片丢弃的可能性也就越高。尽管通过屏蔽掉有缺陷的核，这些有生产缺陷的芯片可以当作三核或双核芯片低价售出。但是对最终用户而言，容量不断增大而效率却不断下降的缓存，会导致更高的成本。
　　1.3?克雷
　　众所周知，计算革命始于20世纪50年代第一批微处理器的出现。以当下的标准来衡量，当时的那些计算设备是很慢的，今天你的智能手机里都可能有一个比它们强大得多的处理器。然而，正是它们导致了超级计算机的诞生。这些超级计算机通常为政府部门、大型学术机构或公司拥有。它们的功能比如今普通的计算机强大数千倍。它们的生产费用高达几百万美元，会占用庞大的空间，通常有特殊的冷却要求，并且需要专门的技术团队进行管理和维护。它们的运行需要消耗大量的电能，从某种程度上说，它们每年的运行费用和生产它们的费用一样昂贵。事实上，电力供应是人们在规划是否构建一台超级计算机时考虑的关键因素之一，也是当下超级计算机发展的主要限制条件之一。
　　现代超级计算机的创始人之一是西蒙·克雷（Seymour Cray），他主持设计的Cray-1超级计算机由克雷研究所（Cray Research）于1976年制造完成。在Cray-1的内部，所有的器件都是通过成千上万条独立的电线连接在一起。为此，他们聘请了许多女工，因为女人的手要比大多数男人的手小些，便于在狭小的空间里将成千上万条电线连接起来。
　　通常用以小时为单位的正常运行时间（两个停机故障之间的实际运行时间）来评价一台超级计算机。如果能让超级计算机持续运行一整天而不出任何问题，那就是一个了不起的成就。按照今天的标准，这似乎很落后。然而，我们今天拥有的很多产品和技术都要归功于克雷和那个时代的其他人所开展的研究。
　　克雷持续生产了很多以Cray命名的、极具突破性的超级计算机。最初的Cray-1超级计算机耗资880万美元，计算速度达到了160 MFLOPS（每秒百万次浮点运算）。而今天衡量计算速度的标准是TFLOPS（每秒万亿次浮点运算），是原来指标MFLOPS的一百万倍（1012与106对比）。今天，一个费米（Fermi）型GPU卡性能的理论峰值已经超过了1 TFLOPS。
　　Cray-2在Cray-1的基础上有了明显的改进。它采用分成若干内存条的共享内存架构，这些内存条可以与一个、两个或四个处理器相连，进而发展成为今天基于服务器的对称多处理器（Symmetrical MultiProcessor，SMP）系统。在该系统中，多CPU共享同一个内存空间。跟那个时代的很多计算机一样，Cray-2是一台基于向量的计算机（如图1-3所示）。在向量机中，一个操作同时处理多个操作数。诸如MMX、SSE和AVX这样的处理器扩展部分，以及GPU设备，它们的核心都是向量处理器。而时至今日，这些向量处理器仍然与早期的超级计算机在设计上有很多相似之处。
　　Cray系列超级计算机通过硬件来支持“散布”（scatter）类和“收集”（gather）类操作原语，这些原语在并行计算中非常有用，我们将在后面的章节中介绍。
　　今天，Cray系列超级计算机仍然活跃于超级计算机市场。由Cray公司研发的、安装在美国橡树岭国家实验室（The Oak Ridge National Laboratory）的超级计算机Jaguar（http://www.nccs.gov/computingresources/jaguar/），依然位于2010年年底发布的世界超级计算机500强排行榜中。建议你登录Cray公司的网站（http://www.cray.com），了解一下这个伟大公司的历史，它将告诉你计算机发展的内在规律以及我们今天所处的位置。
　　1.4?连接机
　　早在1982年，一家名为Thinking Machines的公司提出了一个非常有趣的设计方案，即连接机（Connection Machine，CM）。
　　这是一个比较简单的概念，却引发了一场现代并行计算机的革命。他们通过一遍又一遍地使用一些简单的零部件创造了一个16核的CPU，并在一台机器上安装了4096个这样的设备。这是一个完全不同的概念。它们并不是通过一个高速处理器处理数据集，而是通过64K个处理器来完成一个任务。
　　举一个简单的例子，假如我们要处理一个RGB（红Red，绿Green，蓝Blue）图像的颜色。其中，每种颜色用单字节表示，用3个字节表示1个像素的颜色。现在假设我们的问题是要将蓝色值降为零。
　　假设内存不是交替地存储各个像素点的颜色值，而是被分成红、绿、蓝三条。在传统的处理器中，我们会用一个循环来将蓝色内存条中每个像素的颜色值减1。这个操作对每个数据项都是相同的，即每次循环迭代，我们都要对指令流进行取指、译码和执行三个操作。
　　连接机采用的是单指令多数据（Single Instruction，Multiple Data，SIMD）型并行处理。今天，这种技术以诸如单指令多数据流扩展指令（Streaming SIMD Extensions，SSE）、多媒体扩展（Multi-Media eXtension，MMX）以及高级矢量扩展（Advanced Vector eXtensions， AVX）的名称，广泛应用于现代处理器中。这个技术先定义好一个数据范围，然后让处理器在这个数据范围内进行某种操作。尽管SSE和MMX是基于一个处理器核的，但连接机却拥有64K个处理器核，每个核都在其数据集上执行SIMD指令。
　　诸如Intel I7这样的处理器是64位的处理器，一次最多可以处理64位（即8个字节）的数据。而SSE的SIMD指令集已经扩展到了128位。在这样的处理器上运行SIMD指令，我们就可以消除所有多余的访问内存取指令的操作，并将内存读/写周期变为原来的1/16，而原来是每次取出和写入1个字节。AVX将这种技术扩展到了256位，使其效率更高。
　　对于分辨率为1920×1080的高清（High-Definition，HD）视频图像，它的数据大小为2?073?600字节，即每种颜色平面约为2MB。如果使用常规的SSE/MMX处理器来处理，将需要约260?000个SIMD周期。对于SIMD周期，我们仅需要一个“读、计算和写”周期。实际需要的处理器时钟数可能会差别很大，这取决于实际的处理器架构。
　　连接机有64K个处理器。因此对于每个处理器，2MB大小的帧将需要约32个SIMD的处理周期。显然，这种方法要远远优于现代处理器的SIMD方法。不过，有一点需要注意，如果将现在CPU采用的粗线程方案迁移至这种采用大规模并行方式处理的机器，处理器之间的同步和通信将是很大的问题。
　　1.5Cell处理器
　　超级计算机的另一个有趣的发展，源于IBM公司发明的Cell处理器（如图1-4所示）。
　　图1-4IBM Cell处理器芯片布局（8个SPE版本）
　　它的思想是用一个常规处理器作为监管处理器，该处理器与大量的高速流处理器相连。在Cell处理器中，常规的PowerPC（PPC）处理器担任与流处理器和外部世界的接口。而SIMD流处理器，IBM称其为SPE，则在常规处理器的管理下，处理数据集。
　　对我们来说，Cell是一个非常有趣的处理器，因为它与英伟达公司的G80和随后生产的GPU在设计上很相似。索尼公司也将其应用到游戏产业中的PS3控制台机器上，游戏产业是与GPU的主要应用领域非常类似的一个领域。
　　要想为Cell处理器编程，你需要写一个在PowerPC核心处理器上运行的程序。该程序会用一个互不相同的二进制码，在每个流处理单元SPE（Stream Processing Element）上，调用执行一个程序。实际上，每个SPE本身就是一个核。它可以从自己的本地内存取出一个独立的程序来执行，这个程序与旁边的SPE执行的程序是不同的。另外，通过一个共享的互连网络，SPE之间、SPE与PowerPC核之间可以相互通信。当然，针对这种混合架构进行编程是很困难的。程序员必须从程序和数据两个方面，明确管理8个SPE，以及在PowerPC核上运行的串行程序。
　　由于具有和相应处理器直接对话的能力，因此很多问题的求解就可以通过一系列简单的步骤来实现。例如在前述的RGB示例中，PPC核可以取来一组待处理的数据，然后将其分配给8个SPE处理。每个SPE所做的处理是相同的，即读取一个字节，将其减一，然后存回本地内存。当所有SPE完成工作后，PC核再从每个SPE中取回数据，然后将这组数据（或数据条）写入内存区域，整个图像在内存中被组合起来。Cell处理器被设计为以组的方式工作，这样就重复了我们前面介绍过的连接机的设计。
　　当连接到一个高速的环形网络时，SPE还可以按顺序排列起来，以执行一个包括多个步骤的流式操作（如图1-5所示）。
　　图1-5Cell处理器的流处理器连接路径示例
　　这种流或流水线处理方法的问题是，系统运行的最快速度等于最慢节点的运行速度。它和工厂里生产线的实际运行情况是完全相同的，整条生产线的运行速度和最慢那个点的运行速度一样。就像装配生产线上的工人一样，每一个SPE（工人）只执行一小部分任务，所以它可以非常迅速和高效地完成这部分任务。然而，跟其他处理器一样，SPE也存在带宽限制以及数据传递至下一阶段的开销问题。因此，当通过在每个SPE上执行一个一致的程序来提高效率时，我们也会在处理器间通信上有所损失，并最终受到最慢的那个处理步骤的限制。这是任何基于流水线模型的工作都会遇到的一个共性问题。
　　还有一种效率更高的方法是，将所有待处理的数据放在一个SPE上，然后让其余SPE分别处理一小块数据。这相当于培训所有装配线上的工人去装配一个完整的部件。对于简单的任务，这是很容易的，但是每个SPE受限于可用的程序和数据内存。这时，PowerPC核就必须面向8个SPE进行数据的分发和收集，而不是原先的两个，因此主机和SPE间的管理开销及通信量就增加了。
　　在2010年超级计算机500强排名中位列第三的Roadrunner超级计算机中，IBM使用了高功率版本的Cell处理器。该计算机由12?960块PowerPC核加上总共103?680块流处理器组成。每个PowerPC板由一个双核AMD（Advanced Micro Device）Opteron处理器监控，总共有6912个PowerPC板。Opteron处理器的作用是协调各个节点工作。建造Roadrunner超级计算机耗资1.25亿美元，占地560平方米，理论吞吐率为1.71 petaflops。工作时需要消耗2.35兆瓦的电能！
　　1.6?多点计算
　　随着对单台计算机硬件（如CPU、主存、辅存）要求的提升，所需成本快速增加。若购买一个主频为2.6GHz的处理器需要花费250美元，而购买一个时钟速度增加不到1GHz的、主频为3.4GHz的类似处理器则需要1400美元。在运算速度、主存容量与存储容量上，也能看到类似的关系。
　　计算性能要求的提高，不仅会带来成本的上升，而且对电力的需求以及相应的散热方面的要求也随之增加。在足够的电力供应和充分的散热条件下，处理器能达到4～5GHz的时钟频率。
　　在计算领域里，你经常能遇见“收益递减规律”（The law of diminishing returns）。即便你在一个单一方面投入再多，结果也没有太大改变，因为它受限于成本、空间、电力供应、散热等因素。解决办法是在各个影响因素之间选择一个平衡点，然后多次地复制它。
　　随着时钟频率的不断增长，集群计算在20世纪90年代开始流行起来，其原理非常简单。用一些成套的或是自己从市场上购买零部件组装的PC机，把它们连接到市场上买来的8端口、16端口、24端口或者32端口的以太网交换机上，你得到的性能就比单一主机的性能高32倍。与其花费1600美元购买一个高性能处理器，不如花250美元购买6个中等性能的处理器。如果你的应用程序需要巨大的存储容量，则可以先把多台机器上的DIMM内存条扩充满，然后互联在一起，这样就可以获得足够的存储容量了。同时工作时，多台机器联合起来达到的计算能力要远远大于花同样的钱购买到的任何一台单机。
　　一夜之间，大学、中/小学校、政府机关和计算机系都能够制造出计算性能比以前强很多的计算机，不再因资金短缺而被排斥在高速计算市场为外。如今天的GPU计算一样，集群计算在当年就是一种能改变计算机世界面貌的革命性技术。与不断增加的单核处理器时钟速度结合在一起，这种技术为使用多个单核CPU来实现并行处理，提供了一种比较省钱的方式。
　　PC集群通常运行Linux操作系统的集群版本。在这个版本中，它的每个节点从中央主控节点上获取引导指令和操作系统（Operating System，OS）。例如，在CudaDeveloper环境中，我们有一个由低功耗、带嵌入式CUDA GPU的独立PC机组成的小型集群，很便宜就能买来建立一个集群。有时也可以使用已经被替换掉的旧PC机来组建集群，硬件就几乎不花钱了。
　　然而，集群计算存在的问题是它的速度受到节点之间通信总量的限制，而这些通信是求解问题所必需的。如果你有32个运算节点，问题正好被划分成32个子任务，并且各个节点之间无须通信，那么你的问题求解是最适合集群计算的。如果每个数据点都要从所有节点上获取数据，那么你就是把一个很糟糕的问题交给了集群。
　　在现代的CPU和GPU中都能看到集群技术，比如前面的图1-1。如果我们把图中的每个CPU核作为一个节点，二级缓存作为内存（Dynamic Random Access Memory，DRAM），三级缓存作为网络开关，将内存作为大容量的辅存，我们就得到一个集群的微缩模型（如
　　图1-6所示）。
　　图1-6典型的集群层次结构
　　现代GPU的体系结构也完全相同。一个GPU内有许多流处理器簇（Streaming Multiprocessor，SM），它们就类似CPU的核。这些SM与共享存储（一级缓存）连接在一起，然后又与相当于SM间互联开关的二级缓存相连。数据先是存储在全局存储中，然后被主机取出并使用。除留一部分自己处理外，主机将剩余的数据通过PCI-E互联开关直接送往另一个GPU的存储空间。PCI-E互联开关的传输速度比任何一个互联网络快好多倍。
　　如图1-7所示，节点可以在集群中重复设置。通过在一个可控的环境下，重复设置节点就可以构造一个集群。集群设计的一个进步是分布式应用程序。分布式应用程序可以运行在许多节点上，而每个节点又由包含多个GPU的许多处理单元组成。分布式应用程序可以运行在一个受集中控制的集群平台上，也可以运行在随机连接在一起、自主控制的机器上，来求解一个共同的问题。BOINC和Folding@Home是此类应用的两个最大实例。在这两个实例中，求解问题的计算机是通过因特网（Internet）连接起来的。
　　图1-7类似集群的GPU簇
　　1.7?早期的GPGPU编程
　　图形处理器（Graphics Processing Unit，GPU）是现代PC机中的常见设备。它们向CPU提供一些基本的操作，比如，对内存中的图像进行着色，然后将其显示在屏幕上。一个GPU通常会处理一个复杂的多边形集合，即需要着色的图片映像，然后给这些多边形涂上图片的纹理，进而再做阴影和光照处理。英伟达5000系列显卡第一次给我们带来逼真的图片效果，请查看2003年英伟达发布的“晨光中的花仙子”（Dawn Fairy）图片示例。
　　请浏览http://www.nvidia.com/object/cool_stuff.html#/demos，并下载一些旧的图片示例，从中你可以看出在过去的十几年里GPU的发展变化有多大，详见表1-2。
　　表1-2GPU技术发展历程表
　　演示 显卡 年份
　　Dawn GeForce FX 2003
　　Dusk Ultra GeForce FX 2003
　　Nalu GeForce 6 2004
　　Luna GeForce 7 2005
　　Froggy GeForce 8 2006
　　Human Head GeForce 8 2007
　　Medusa GeForce 200 2008
　　Supersonic Sled GeForce 400 2010
　　A New Dawn GeForce 600 2012
　　重要的进步之一就是可编程着色器（programmable shader）的出现。它们是GPU运行的一些用来计算各种图片效果的小程序。这样，着色就不必固定在GPU中进行。通过可下载的着色器，就可以完成这些操作。这就是最初的通用图形处理器（General-Purpose Graphical Processor Unit，GPGPU）编程。这表示GPU设计朝着“处理单元功能不再是固定的”方向迈出了第一步。
　　然而，这些着色器很自然地取来那些表示一个多边形图像的三维（3D）点集进行处理。着色器以一种高度并行的方式，对许多这样的数据集进行相同的操作，从而提供了巨大的计算能力。
　　现在即使多边形是用三个点的集合来表示的，其他的一些数据集，比如RGB图片，也能够用三个点的集合来表示，但还有许多数据集不是这样表示。因此，有一些勇敢的研究人员就尝试着用GPU技术来提高通用计算的速度。这导致开发出了许多新产品（如Brook GPU、Cg及CTM等），研发这些产品的目标都是将GPU变成一个具有和CPU一样运行模式的可编程设备。遗憾的是，它们既有优点也存在不足，这些产品都不容易学习和编程使用，而且愿意学习它们的人并不多。一句话，一项不容易学习的技术不可能获得程序员的追捧，也不可能激起程序员广泛的兴趣。这些产品一直没有在市场上获得成功。而CUDA可能是首次实现了上述目标，同时向程序员提供了一个真正通用的GPU编程语言。
　　1.8?单核解决方案的消亡
　　现代处理器的问题之一是它们已经达到了4GHz左右的时钟速度极限。就目前的技术而言，处理器在这个极限点上工作会产生太多的热量，从而导致需要特殊的、昂贵的冷却措施。产生热量的原因是随着时钟频率的提升，电力功耗增大了。事实上，在电压不变的情况下，一个CPU的电力功耗大约是它时钟频率的三次方。更糟糕的是，如果CPU产生的热量增加，那么即使时钟频率不变，根据硅材料的性质，CPU的功耗也会进一步增加。这个电/热转换是对能源的一个浪费。这个不断增加的无效的电能消耗，意味着你要么不能充分为处理器提供电力，要么不能够有效地冷却处理器，已经达到了电子设备或芯片封装的散热极限，即所谓的“功耗墙”（power wall）。
　　面对不能再提高时钟频率的挑战，却还需要制造更快的处理器，处理器制造商只好另辟蹊径。两个主要的PC机处理器制造商，Intel和AMD，已经采取了另外一种方案。他们已经从持续地提高时钟频率或者通过指令级并行处理技术提高每个时钟周期内执行的指令条数的旧的发展道路，转移到向处理器里添加更多核的新的发展道路。现在已经有了双核、3核、4核、6核、8核，12核甚至16核和32核的处理器，这就是以CPU和GPU为核心的计算技术未来的发展方向。从CPU的角度说，费米（Fermi）型GPU已经是一个真正的16核处理器了。
　　然而，这种方法有一个很大的问题——它需要编程者从以前的串行、单线程的问题求解方法切换到多线程同时执行的问题求解方法。现在，编程人员必须考虑2个、4个、6个或8个线程以及线程之间的交互和通信。当双核CPU出现时，还相对简单，因为正好有一些程序需要在后台运行，将这些程序迁移到第二个核上运行即可。当4核CPU出现时，并没有修改这么多的程序来支持4核运算，还是会买4核CPU以运行单线程的应用程序。甚至游戏厂商也不想很快地转向4核编程，而我们通常认为这个领域是最希望采用最新技术的。
　　在一定程度上，处理器制造商也应该为此负责，因为单核程序可以在4核处理器的一个核中运行得很好。当只有一个核在工作时，一些设备甚至会动态地提升时钟频率来提高性能，这就导致编程人员变得懒惰，不愿充分使用已经可用的硬件。
　　当然，这也有经济上的原因，软件开发公司需要尽早把产品推向市场。开发出一个更好的4核程序固然是很好的，但如果竞争对手抢先一步占领市场就不好了。当硬件制造商仍然继续生产单核和双核设备的时候，软件市场自然就稳定在最低配置上，因为这样的软件销售范围是最广的。只有当4核CPU变成市场上产品的最低配置时，市场才会迫使软件开发朝着多核编程的方向发展。
　　1.9?英伟达和CUDA
　　如果留意GPU和CPU的计算能力，可以得到一张有意思的图（见图1-8）。我们看到，最初CPU和GPU计算能力的差距不是很大。但是在2009年之后，当GPU的性能最终突破了1万亿每秒大关后，它们的差距就越来越大了，而在2009年，GPU从G80硬件设备发展为G200硬件设备。然后在2010年，发展到革命性的费米型GPU。这其中的发展动力是大规模并行硬件的引入。G80是一个具备128个CUDA核的设备，G200是一个具备256个CUDA核的设备，而Fermi则是一个具备512个CUDA核的设备。
　　我们看到英伟达的GPU，从G200架构到费米型架构，浮点计算性能实现了每秒3千亿次（300 gigaflops）的飞跃，在吞吐量方面提高了接近30%。相比之下，英特尔公司从Core 2（酷睿2）架构升级到Nehalem架构仅有小幅的改进。只有改为Sandy Bridge架构后，CPU性能才显著地提升。这并不意味着孰优孰劣，传统CPU的目标是执行串行代码，在这方面它们还是做得非常好的。它们包含了一些特殊硬件，例如，分支预测单元、多级缓存等，所有这些都是针对串行代码的执行。但GPU并不是为执行串行代码而设计的，且只有完全按照并行模式运行时才能发挥它的峰值性能。
　　2007年，英伟达发现了一个能使GPU进入主流的契机，那就是为GPU增加一个易用的编程接口，也就是所谓的统一计算架构（Compute Unified Device Architecture，CUDA）。这为无须学习复杂的着色语言或者图形处理原语，就能进行GPU编程提供了可能。
　　CUDA是C语言的一种扩展，它允许使用标准C来进行GPU代码编程。这个代码既适用于主机处理器（CPU），也适用于设备处理器（GPU）。主机处理器负责派生出运行在GPU设备处理器上的多线程任务（CUDA称其为内核程序）。GPU设有内部调度器来把这些内核程序分配到相应的GPU硬件上。调度方法将在本书的后面详细介绍。假设这些任务有足够的并行度，随着GPU中流处理器簇数量的增加，程序的运算速度就会提升。
　　但是，这里仍然有一个大问题：程序中能够并行运行的代码占多大比例呢？可能达到的最大加速比受限于程序中串行代码的数量。即便你有无限的计算能力，并且使得并行任务的运行时间趋近于零，但你还需要付出运行串行代码的时间。因此，我们必须从一开始就考虑是否能够把大量的工作并行化。
　　英伟达一直致力于为CUDA开发提供支持。在其官方网站（http://www.nvidia.com）上的CudaZone栏目中，英伟达提供了大量有助于CUDA开发的信息、示例和工具。
　　与之前的处理器不同，CUDA已经开始进入发展的快车道，并且成为首个有可能发展成为GPU开发的候选编程语言。假如有数以百万计的GPU支持CUDA，那么基于CUDA的应用程序将成为一个巨大的市场。
　　现在有很多基于CUDA的应用，并且数量还在逐月递增。英伟达在它的社区网站http://www.nvidia.com/object/cuda_apps_flash_new.html中列出了其中的诸多应用。
　　在程序需要做大量计算工作的领域，例如，从家庭录影带翻录成一个DVD盘（视频转码），我们发现大部分主流的视频开发包现在都已支持CUDA。这个领域的平均加速比达到5～10倍。
　　图1-8CPU和GPU峰值性能（单位：十亿次浮点操作每秒（gigaflops））
　　随着CUDA一起引入的，是Tesla系列板卡。这些并不是图形卡，事实上这些卡既没有DVI接口，也没有VGA接口。它们是专用于科学计算的计算卡。使用它们可以为科学计算提供很大的加速比。这些卡既可以安装在常规的桌面PC上，也可以安装在专用的服务器机架上。在http://www.nvidia.com/object/preconfigured_clusters.html网站上，英伟达提供了一个示例系统，据称该系统的计算能力相当于普通集群系统的30倍。CUDA和GPU正在改变着高性能计算领域的形式。
　　1.10?GPU硬件
　　英伟达G80系列处理器及其后续产品是采用类似连接机和IBM的Cell处理器的设计方案来实现的。每个图形卡由若干个流处理器簇（SM）组成，每个SM配备8个或更多的流处理器（Stream Processor，SP）。先前的9800 GTX卡有8个SM，总共有128个SP。但是与IBM的超级计算机Roadrunner不同，购买一块GPU板卡只需要几百美元，并且还不需要2.35兆瓦的电力去驱动它。后面当我们讲到建立GPU服务器时就会看到，电能的问题是不能忽视的。
　　GPU卡大致可以看成是一种加速卡或协处理器卡。目前，一个GPU卡必须与基于CPU的主机相连才能工作。在这方面，它完全遵循Cell处理器搭配一个常规的串行处理核和N个SIMD SPE核的方法。每个GPU设备包括一组SM，每个SM又包含一组SP或者CUDA核。这些SP最高可以实现32个单元并行工作。它们消除了CPU上为实现高速串行执行而设计的大量复杂的指令级并行处理电路。取而代之的是由程序员指定的显式的并行模型，使得同样大小的硅片可以容纳更强的计算能力。
　　GPU的总体性能主要由其所具有的SP的数量、全局内存的带宽和程序员利用并行架构的充分程度等因素决定。表1-3是当前英伟达生产的GPU卡的列表。
　　表1-3当前英伟达生产的GPU卡
　　GPU系列 设备 SP数目 最大存储空间 GFlops（FMAD） 带宽（GB/s） 能耗（瓦）
　　9800 GT G92 96 2GB 504 57 125
　　9800 GTX G92 128 2GB 648 70 140
　　9800 GX2 G92 256 1GB 1152 2×64 197
　　260 G200 216 2GB 804 110 182
　　285 G200 240 2GB 1062 159 204
　　295 G200 480 1.8GB 1788 2×110 289
　　470 GF100 448 1.2GB 1088 134 215
　　480 GF100 448 1.5GB 1344 177 250
　　580 GF110 512 1.5GB 1581 152 244
　　590 GF110 1024 3GB 2488 2×164 365
　　680 GK104 1536 2GB 3090 192 195
　　690 GK104 3072 4GB 5620 2×192 300
　　Tesla C870 G80 128 1.5GB 518 77 171
　　Tesla C1060 G200 240 4GB 933 102 188
　　Tesla C2070 GF100 448 6GB 1288 144 247
　　Tesla K10 GK104 3072 8GB 5184 2×160 250
　　对于一个指定的应用程序，如何选择一块合适的板卡，其实就是在指定的应用程序的内存能耗和GPU处理能耗之间找到一个平衡。注意，9800 GX2、295、590、690和K10卡其实是双卡，所以如果要完全利用这些卡，就要把它们当作两个设备来编程而非单个设备。另外需要说明的是，以上描述GPU的数据是针对单精度浮点数（32位）而不是双精度浮点数（64位）。同样需要注意的是，GF100（Fermi型）系列，作为Tesla的衍生型，双精度运算单元的数量是标准桌面单元的两倍，所以获得了明显更好的双精度输出。即将发布的开普勒（Kepler）型GPU K20，与已经发布的兄弟款K10相比，双精度运算性能也将有显著改进。
　　虽然没有提及，但仍应注意到在新一代产品中，每个SM的时钟和能耗已经降低了。但是总体能耗却显著增加，这是任何一个基于多GPU的解决方案都要考虑的关键问题之一。一个典型的例子是，由于使用了共享电路和降低了时钟频率，基于双GPU的卡（9800 GX2、295、590、690）的能耗，比等价的两个单卡的总能耗稍低一些。
　　为了实现高密度运算，英伟达提供了采用共享PCI-E总线相连的、由2～4块Tesla卡组成的多种机架（M系列计算模块）。这样就可以利用标准PC部件来建立你自己的GPU集群或者微型超级计算机。在本书的后面，我们将介绍如何实现这些想法。
　　对于CUDA来说，一件了不起的事情是，无论硬件设备如何变动，为早期的CUDA设备编写的程序依然能够运行在如今的CUDA设备上。CUDA编译模型使用了和Java语言一样的编译原则——基于虚拟指令集的运行时编译。这允许现代的GPU可以运行即便是最老的GPU上的程序代码。当针对新GPU而需要修改程序的某些特性时，原先的程序常常可以为程序员的工作提供很多便利。事实上，针对不同硬件版本的更新，可以对程序做很多的优化调整，这些将在本书的最后部分介绍。
　　1.11?CUDA的替代选择
　　1.11.1OpenCL
　　那么其他的GPU制造商，如ATI（现在是AMD）能够成为主要的厂商吗？从计算能力上看，AMD的产品和英伟达的产品是旗鼓相当的。但是，在英伟达引入CUDA很长时间之后，AMD才将流计算技术引入市场。从而导致英伟达针对CUDA可用的应用程序要远远多于AMD/ATI在其技术框架上的应用程序。
　　OpenCL（Open Computing Language）和“直接计算”（Direct Compute）不是本书详细讨论的内容，但是作为CUDA的替代选择，应当提及。目前，CUDA仅仅能够正式运行于英伟达的硬件产品上。虽然英伟达在GPU市场上占有很大的份额，但是其他竞争者所拥有的份额也不小。作为开发者，我们希望开发出的产品能够面向的市场越大越好，尤其是消费者市场。同样的，人们也关心是否有能够同时支持英伟达和其他厂商硬件产品的CUDA的替代品。
　　OpenCL是一个开放的、免版税的标准，由英伟达、AMD和其他厂商所支持。OpenCL的商标持有者是苹果公司，它制定出一个允许使用多种计算设备的开放标准。计算设备可以是GPU、CPU或者其他存在OpenCL驱动程序的专业设备。截至2012年，OpenCL支持绝大多数品牌的GPU设备，包括那些至少支持SSE3的CPU。
　　任何熟悉CUDA的程序员都可以相对轻松地使用OpenCL，因为它们的基础概念十分相似。但是，与CUDA相比，使用OpenCL会复杂一些，因为很多由CUDA运行时API（应用程序编程接口）所完成的功能，在OpenCL中需要由程序员显式地编程实现。
　　在http://www.khronos.org/opencl/网站上有更多关于OpenCL的内容。而且也有很多关于OpenCL的书籍。我个人推荐：在学习OpenCL之前，先学习CUDA。因为在某种意义上讲，CUDA是一种比OpenCL更高级的语言扩展。
　　1.11.2?DirectCompute
　　DirectCompute是微软开发的可替代CUDA和OpenCL的产品。它是集成在Windows操作系统，特别是DirectX 11 API上的专用产品。对于之前从事显卡编程的人来说，DirectX API是一个巨大的飞跃。这种产品使得开发者只需掌握一个API库，就可以对所有的显卡进行编程，而不必为每个主要的显卡生产商编写或发布驱动程序。
　　DirectX 11是最新的标准并且Windows 7操作系统能够支持它。由于标准背后的支持厂商是微软，你可以想象得到它会被开发者群体迅速接受。对于已经熟悉DirectX API的开发人员，情况更是这样的。如果你熟悉CUDA和DirectCompute，那么将一个CUDA应用程序移植到OpenCL的确是一项轻松的任务。据微软所言，对同时熟悉两种产品的人来说，这通常仅仅是一个下午的工作量。但是，由于以Windows操作系统为核心，DirectCompute技术被排除在各种版本的UNIX占主导地位的高端系统之外。
　　微软还推出了基于C++的AMP（加速大规模并行计算）库，它是标准模板库（Standard Template Library，STL）的补充部分。对于熟悉C++风格的STL的程序员，它更具有吸引力。
　　1.11.3?CPU的替代选择
　　主要的并行程序设计扩展语言有MPI和OpenMP，在Linux下开发时，还有Pthreads。Windows操作系统下有Windows线程模型和OpenMP。MPI和Pthreads被用作与UNIX进行联系的接口。
　　MPI（Message Passing Interface）可能是目前使用最广泛的消息传递接口。它是基于进程的，通常在各个大规模计算实验室中得到应用。它需要一个系统管理员来正确地安装配置，并且它适合于可控的计算环境。它实现的并行处理表现为，在集群的各个节点上，派生出成百上千个进程，通常这些进程通过基于网络的高速通信链路（如，以太网或InfiniBand）显式地交换消息，以协同完成一个大的任务。MPI被广泛使用和学习。在可控的集群环境下，它是一个很好的解决方案。
　　OpenMP（Open Multi-Processing）是专门面向单个节点或单个计算机系统而设计的并行计算平台，它的工作方式是完全不同的。在使用OpenMP时，程序员需要利用编译器指令精确写出并行运算指令。然后编译器根据可用的处理器核数，自动将问题分为N部分。很多编译器对OpenMP的支持都是内嵌的，包括用于CUDA的NVCC编译器。OpenMP希望根据底层的CPU架构，实现对问题的可扩展并行处理。但是，CPU内的访存带宽常常不够大，满足不了所有核连续将数据写入内存或者从内存中取出数据的要求。
　　pthreads是一个主要应用于Linux上的多线程应用程序库。同OpenMP一样，pthreads使用线程而不是进程，因为它是设计用来在单个节点内实行并行处理的。和OpenMP不同的是，线程管理和线程同步由程序员来负责。这提供了更多的灵活性，因此精心设计的程序会带来很好的性能。
　　ZeroMQ（0MQ）也值得一提，这是一个你可以链接的简单的库。在本书的后面，我们将使用它来开发一个多节点、多GPU的例子。ZeroMQ使用一个跨平台的API来支持基于线程、基于进程和基于网络的通信模型。Linux和Windows平台都支持ZeroMQ。它是针对分布式计算而设计的，所以连接是动态的，节点失效不会影响它的工作。
　　Hadoop也是你应当考虑的技术。Hadoop是谷歌MapReduce框架的一个开源版本。它针对的是Linux平台。其概念是你取来一个大数据集然后将其切割或映射（map）成很多小的数据块。然而，并不是将数据发送到各个节点，取而代之的是数据集通过并行文件系统已经被划分给上百个或者上千个节点。因此，归约（reduce）步骤是把程序发送到已经包含数据的节点上。输出结果写入本地节点并保存在那里。后续MapReduce程序取得之前的输出并以某种方式对其进行转换。由于数据实际上映射到了多个节点上，因此它可以应用于高容错和高吞吐率系统。
　　1.11.4?编译指令和库
　　很多编译器厂商，如PGI、CAPS以及最著名的Cray，都支持最近发布的针对GPU的OpenACC编译器指令集。在本质上，这些是OpenMP方法的复制。它们都要求程序员在程序中插入编译器指令来标注出“应该在GPU上执行”的代码区域。然后编译器就做些简单的工作，即从GPU上移入或移出数据、调用内核程序等。
　　若使用pthreads替代OpenMP，由于pthreads提供更底层的控制，所以你可以获得更高的性能。使用CUDA替代OpenACC也是这样。但是，对额外层面的控制，要求程序员掌握更高水平的编程知识，也会带来更高的出错风险，进而对开发进度产生影响。目前，OpenACC不仅要求用指令标注出哪些区域的代码需要运行在GPU上，而且还要指明数据要存储在哪种类型的内存上。英伟达宣称使用这类指令可以获得5倍以上的速度提升。对于那些想要程序跑得更快的程序员来说，这是一个很好的选择。对于那些把程序设计放在次要位置，仅仅考虑在合理的时间内完成任务的人来说，这也是一个很棒的选择。
　　库的使用也是很重要的，因为它可以让你的生产效率以及执行程序时间的加速比提高。一些库提供的通用函数的执行效率很高，例如，SDK提供的Thrust。诸如CUBLAS这样的库是针对线性代数最好的库。很多诸如Matlab和Mathematica这样著名的应用程序中都有库的存在。在某些语言中，如Python、Perl、Java和许多其他的语言中，库是以语言绑定的形式存在的。CUDA甚至还被集成进Excel里。
　　在现代化软件开发的各个方面，很多你准备开发的东西别人已经做好了。在你准备花费数周时间开发一个库之前，请先去互联网上搜索一下，看看哪些是已经存在的。除非你是一个CUDA专家，否则你自己开发不大可能比使用已有的更快。
　　1.12?本章小结
　　也许你在想，为什么要使用CUDA进行开发？答案是，在技术支持、调试工具和驱动程序等方面，CUDA是目前最容易进行开发的语言。CUDA在各个方面都领先一步，在成熟性方面更是遥遥领先。即便你的应用程序需要支持非“英伟达”的硬件，但最好的方式也是先在CUDA上开发，然后将其移植为其他API的应用程序。同理，我们应专注于CUDA，因为当你成为一个CUDA专家后，使用开发所需的其他API也是很容易的。理解CUDA的工作原理，可以帮助你更好地利用任何一个高层API，并有助于理解它们的局限性。
　　我衷心地希望，你能从由单线程CPU程序员转变成GPU上的并行程序员的旅程中，找到乐趣。即使将来不做GPU开发，你获得的知识也会对设计多线程程序有极大帮助。如果你，像我们一样，看到世界正在向并行编程模型转变，那么你将会渴望能够站在技术挑战与创新浪潮的最前沿。单线程工业正在慢慢衰落。要想保持自身价值、成为公司渴望的人才，你需要掌握那些代表计算机世界发展方向的技术，而不是那些日趋没落的技术。
　　GPU正在改变计算机世界的面貌。突然之间，十几年前超级计算机的计算能力现在已经能够出现在你的办公桌上。你不再需要：排队、分批提交任务，然后用几个月的时间等待管理员（committee）批准你的请求——在一个超负荷运行的计算系统上使用有限的计算机资源。现在，最多花5000～10?000美元，你就可以在你的办公桌上添置一台超级计算机，或者花一小部分钱买来一台运行CUDA的机器。GPU是一项翻天覆地的技术革新，它使每个人拥有超级计算机级别的计算能力成为可能。