[套装书]并行程序设计：概念与实践+CUDA并行程序设计：GPU编程指南（2册）

第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



---------------------------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

.　　过去的五年中，计算领域目睹了英伟达（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应用程序时易犯的错误类型，并对如何检测和避免这些错误给出了建议。
　　

.　　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是一项翻天覆地的技术革新，它使每个人拥有超级计算机级别的计算能力成为可能。