顶部
收藏

程序性能优化理论与方法


作者:
韩林,高伟
定价:
139.00 元
版面字数:
880千字
开本:
16开
装帧形式:
精装
版次:
1
最新版次
印刷时间:
2025年
ISBN:
978-7-04-059928-2
物料号:
59928-00
出版时间:
2023-06-02
读者对象:
高等教育
一级分类:
计算机/教育技术类
二级分类:
计算机类专业核心课程
三级分类:
程序设计基础

本书是“十四五”时期国家重点出版物出版专项规划项目“人工智能重大基础研究丛书”图书,从计算机体系结构、编译系统、操作系统、作业管理等多角度,对程序实现中的算法、数据结构、程序设计语言特性、资源占用及程序运行过程等多维度,全面探讨程序性能优化的理论和方法。

全书共12 章,分为上下两篇。上篇第1—6 章为基础部分,主要对程序性能优化的意义、度量指标、常用流程及如何进行程序性能的分析与测量进行阐述,并从程序编码和编译的角度介绍多种优化方法。下篇第7—12章为进阶部分,结合系统硬件特性讲述更深层次的优化方法,包括单核优化、访存优化、OpenMP 程序优化、CUDA 程序优化、MPI 程序优化,以及多层次并行程序优化。

本书适用于具备一定程序设计基础并致力于程序性能优化的程序设计人员阅读,也可以作为学习高等教育计算机程序设计课程的参考书,还可作为从事性能优化专业技术人员的参考书。

  • 目录
    • 前辅文
      • 上篇
        • 第一章 程序性能优化的意义
          • 1.1 程序性能要求的不断提高
            • 1.2 处理器架构的不断发展
              • 1.2.1 单核结构
                • 1.2.2 多核结构
                  • 1.2.3 众核结构
                    • 1.2.4 异构结构
                      • 1.2.5 专用结构
                      • 1.3 存储结构的不断发展
                        • 1.4 编译器能力的局限性
                          • 1.5 编程模型的局限性
                            • 1.6 小结
                            • 第二章 程序性能的度量指标及优化流程
                              • 2.1 程序性能的度量指标
                                • 2.1.1 程序执行时间
                                  • 2.1.2 计算与访存效率
                                    • 2.1.3 吞吐量与延迟
                                      • 2.1.4 加速比
                                        • 2.1.5 Amdahl 定律
                                          • 2.1.6 Gustafson 定律
                                          • 2.2 程序性能优化的常用流程
                                            • 2.3 小结
                                            • 第三章 程序性能的分析和测量
                                              • 3.1 程序性能分析
                                                • 3.1.1 程序性能分析视角
                                                  • 3.1.2 程序性能分析方法
                                                  • 3.2 程序性能测量
                                                    • 3.2.1 程序性能测量的信息类型
                                                      • 3.2.2 程序性能测量的工具类型
                                                      • 3.3 程序性能测量工具
                                                        • 3.3.1 计数器类
                                                          • 3.3.2 跟踪类
                                                            • 3.3.3 剖析类
                                                              • 3.3.4 监控类
                                                              • 3.4 小结
                                                              • 第四章 系统配置优化
                                                                • 4.1 处理器
                                                                  • 4.1.1 处理器配置检查
                                                                    • 4.1.2 处理器参数调整
                                                                    • 4.2 内存
                                                                      • 4.2.1 内存配置检查
                                                                        • 4.2.2 内存参数调整
                                                                        • 4.3 文件系统
                                                                          • 4.3.1 文件系统配置检查
                                                                            • 4.3.2 文件系统参数调整
                                                                            • 4.4 磁盘
                                                                              • 4.4.1 磁盘配置检查
                                                                                • 4.4.2 磁盘参数调整
                                                                                • 4.5 网络
                                                                                  • 4.5.1 网络配置检查
                                                                                    • 4.5.2 网络参数调整
                                                                                    • 4.6 小结
                                                                                    • 第五章 编译与运行优化
                                                                                      • 5.1 编译器结构
                                                                                        • 5.1.1 前端
                                                                                          • 5.1.2 中端
                                                                                            • 5.1.3 后端
                                                                                            • 5.2 编译选项
                                                                                              • 5.2.1 前端选项
                                                                                                • 5.2.2 优化选项
                                                                                                  • 5.2.3 代码生成选项
                                                                                                    • 5.2.4 链接选项
                                                                                                      • 5.2.5 其他选项
                                                                                                      • 5.3 编译优化
                                                                                                        • 5.3.1 过程间优化
                                                                                                          • 5.3.2 循环优化
                                                                                                            • 5.3.3 自动向量化
                                                                                                              • 5.3.4 数据预取优化
                                                                                                                • 5.3.5 浮点优化
                                                                                                                  • 5.3.6 反馈优化
                                                                                                                    • 5.3.7 链接时优化
                                                                                                                      • 5.3.8 编译指示
                                                                                                                      • 5.4 数学库优化
                                                                                                                        • 5.4.1 数学库简介
                                                                                                                          • 5.4.2 数学库使用
                                                                                                                            • 5.4.3 用好数学库
                                                                                                                            • 5.5 运行时优化
                                                                                                                              • 5.5.1 影响程序启动的因素
                                                                                                                                • 5.5.2 程序启动性能优化
                                                                                                                                • 5.6 小结
                                                                                                                                • 第六章 程序编写优化
                                                                                                                                  • 6.1 算法优化
                                                                                                                                    • 6.1.1 算法简介
                                                                                                                                      • 6.1.2 选择适合算法
                                                                                                                                        • 6.1.3 改进算法策略
                                                                                                                                        • 6.2 数据结构优化
                                                                                                                                          • 6.2.1 典型数据结构的性能分析
                                                                                                                                            • 6.2.2 选择适合的数据类型
                                                                                                                                              • 6.2.3 选择适合的数据结构
                                                                                                                                              • 6.3 过程级优化
                                                                                                                                                • 6.3.1 别名消除
                                                                                                                                                  • 6.3.2 常数传播
                                                                                                                                                    • 6.3.3 传参优化
                                                                                                                                                      • 6.3.4 内联替换
                                                                                                                                                        • 6.3.5 过程克隆
                                                                                                                                                          • 6.3.6 全局变量优化
                                                                                                                                                          • 6.4 循环级优化
                                                                                                                                                            • 6.4.1 循环不变量外提
                                                                                                                                                              • 6.4.2 循环展开和压紧
                                                                                                                                                                • 6.4.3 循环合并
                                                                                                                                                                  • 6.4.4 循环分段
                                                                                                                                                                    • 6.4.5 循环分块
                                                                                                                                                                      • 6.4.6 循环交换
                                                                                                                                                                        • 6.4.7 循环分布
                                                                                                                                                                          • 6.4.8 循环分裂
                                                                                                                                                                            • 6.4.9 循环倾斜
                                                                                                                                                                            • 6.5 语句级优化
                                                                                                                                                                              • 6.5.1 删除冗余语句
                                                                                                                                                                                • 6.5.2 代数变换
                                                                                                                                                                                  • 6.5.3 去除相关性
                                                                                                                                                                                    • 6.5.4 公共子表达式优化
                                                                                                                                                                                      • 6.5.5 分支语句优化
                                                                                                                                                                                      • 6.6 小结
                                                                                                                                                                                    • 下篇
                                                                                                                                                                                      • 第七章 单核优化
                                                                                                                                                                                        • 7.1 指令级并行
                                                                                                                                                                                          • 7.1.1 指令流水
                                                                                                                                                                                            • 7.1.2 超标量
                                                                                                                                                                                              • 7.1.3 超长指令字
                                                                                                                                                                                              • 7.2 数据级并行
                                                                                                                                                                                                • 7.2.1 向量程序编写
                                                                                                                                                                                                  • 7.2.2 向量程序优化
                                                                                                                                                                                                  • 7.3 小结
                                                                                                                                                                                                  • 第八章 访存优化
                                                                                                                                                                                                    • 8.1 寄存器优化
                                                                                                                                                                                                      • 8.1.1 寄存器分配
                                                                                                                                                                                                        • 8.1.2 寄存器重用
                                                                                                                                                                                                        • 8.2 缓存优化
                                                                                                                                                                                                          • 8.2.1 缓存分块
                                                                                                                                                                                                            • 8.2.2 减少伪共享
                                                                                                                                                                                                              • 8.2.3 数据预取
                                                                                                                                                                                                              • 8.3 内存优化
                                                                                                                                                                                                                • 8.3.1 减少内存读写
                                                                                                                                                                                                                  • 8.3.2 数据对齐
                                                                                                                                                                                                                    • 8.3.3 直接内存访问
                                                                                                                                                                                                                      • 8.3.4 访存与计算重叠
                                                                                                                                                                                                                      • 8.4 磁盘优化
                                                                                                                                                                                                                        • 8.4.1 多线程操作
                                                                                                                                                                                                                          • 8.4.2 避免随机写
                                                                                                                                                                                                                            • 8.4.3 磁盘预读
                                                                                                                                                                                                                            • 8.5 数据布局
                                                                                                                                                                                                                              • 8.5.1 数组重组
                                                                                                                                                                                                                                • 8.5.2 数组转置
                                                                                                                                                                                                                                  • 8.5.3 结构属性域调整
                                                                                                                                                                                                                                    • 8.5.4 结构体拆分
                                                                                                                                                                                                                                      • 8.5.5 结构体数组转换
                                                                                                                                                                                                                                      • 8.6 小结
                                                                                                                                                                                                                                      • 第九章 OpenMP 程序优化
                                                                                                                                                                                                                                        • 9.1 OpenMP 编程简介
                                                                                                                                                                                                                                          • 9.1.1 OpenMP 是什么
                                                                                                                                                                                                                                            • 9.1.2 OpenMP 指导语句
                                                                                                                                                                                                                                              • 9.1.3 OpenMP 程序编写
                                                                                                                                                                                                                                                • 9.1.4 OpenMP 版矩阵乘
                                                                                                                                                                                                                                                • 9.2 并行区重构
                                                                                                                                                                                                                                                  • 9.2.1 并行区扩张
                                                                                                                                                                                                                                                    • 9.2.2 并行区合并
                                                                                                                                                                                                                                                    • 9.3 避免伪共享
                                                                                                                                                                                                                                                      • 9.3.1 分析伪共享
                                                                                                                                                                                                                                                        • 9.3.2 数据填充避免伪共享
                                                                                                                                                                                                                                                          • 9.3.3 数据私有避免伪共享
                                                                                                                                                                                                                                                          • 9.4 循环向量化
                                                                                                                                                                                                                                                            • 9.4.1 向量化指导命令
                                                                                                                                                                                                                                                              • 9.4.2 性能分析
                                                                                                                                                                                                                                                              • 9.5 负载均衡优化
                                                                                                                                                                                                                                                                • 9.5.1 循环嵌套合并调度
                                                                                                                                                                                                                                                                  • 9.5.2 线程调度配置策略
                                                                                                                                                                                                                                                                  • 9.6 线程数设置优化
                                                                                                                                                                                                                                                                    • 9.6.1 串并行切换
                                                                                                                                                                                                                                                                      • 9.6.2 选择合适的线程数
                                                                                                                                                                                                                                                                      • 9.7 避免隐式同步
                                                                                                                                                                                                                                                                        • 9.7.1 分析隐式同步
                                                                                                                                                                                                                                                                          • 9.7.2 消除隐式同步
                                                                                                                                                                                                                                                                          • 9.8 流水并行优化
                                                                                                                                                                                                                                                                            • 9.8.1 流水并行简介
                                                                                                                                                                                                                                                                              • 9.8.2 流水并行示例
                                                                                                                                                                                                                                                                                • 9.8.3 流水并行粒度
                                                                                                                                                                                                                                                                                • 9.9 小结
                                                                                                                                                                                                                                                                                • 第十章 CUDA 程序优化
                                                                                                                                                                                                                                                                                  • 10.1 CUDA 编程简介
                                                                                                                                                                                                                                                                                    • 10.1.1 CUDA 是什么
                                                                                                                                                                                                                                                                                      • 10.1.2 CUDA 编程模型
                                                                                                                                                                                                                                                                                        • 10.1.3 CUDA 程序编写
                                                                                                                                                                                                                                                                                          • 10.1.4 CUDA 版矩阵乘
                                                                                                                                                                                                                                                                                          • 10.2 线程结构优化
                                                                                                                                                                                                                                                                                            • 10.2.1 线程组织优化
                                                                                                                                                                                                                                                                                              • 10.2.2 线程布局优化
                                                                                                                                                                                                                                                                                              • 10.3 分支优化
                                                                                                                                                                                                                                                                                                • 10.3.1 基本原理
                                                                                                                                                                                                                                                                                                  • 10.3.2 代码实现
                                                                                                                                                                                                                                                                                                    • 10.3.3 性能分析
                                                                                                                                                                                                                                                                                                    • 10.4 访存优化
                                                                                                                                                                                                                                                                                                      • 10.4.1 全局内存优化
                                                                                                                                                                                                                                                                                                        • 10.4.2 共享内存优化
                                                                                                                                                                                                                                                                                                          • 10.4.3 避免存储体冲突
                                                                                                                                                                                                                                                                                                            • 10.4.4 高速缓存优化
                                                                                                                                                                                                                                                                                                            • 10.5 数据预取
                                                                                                                                                                                                                                                                                                              • 10.5.1 基本原理
                                                                                                                                                                                                                                                                                                                • 10.5.2 代码实现
                                                                                                                                                                                                                                                                                                                  • 10.5.3 性能分析
                                                                                                                                                                                                                                                                                                                  • 10.6 循环展开
                                                                                                                                                                                                                                                                                                                    • 10.6.1 基本原理
                                                                                                                                                                                                                                                                                                                      • 10.6.2 代码实现
                                                                                                                                                                                                                                                                                                                        • 10.6.3 性能分析
                                                                                                                                                                                                                                                                                                                        • 10.7 小结
                                                                                                                                                                                                                                                                                                                        • 第十一章 MPI 程序优化
                                                                                                                                                                                                                                                                                                                          • 11.1 MPI 编程简介
                                                                                                                                                                                                                                                                                                                            • 11.1.1 MPI 是什么
                                                                                                                                                                                                                                                                                                                              • 11.1.2 MPI 函数库
                                                                                                                                                                                                                                                                                                                                • 11.1.3 MPI 程序编写
                                                                                                                                                                                                                                                                                                                                  • 11.1.4 MPI 版矩阵乘
                                                                                                                                                                                                                                                                                                                                  • 11.2 数据划分优化
                                                                                                                                                                                                                                                                                                                                    • 11.2.1 按行分解
                                                                                                                                                                                                                                                                                                                                      • 11.2.2 按列分解
                                                                                                                                                                                                                                                                                                                                        • 11.2.3 棋盘式分解
                                                                                                                                                                                                                                                                                                                                        • 11.3 重叠通信和计算
                                                                                                                                                                                                                                                                                                                                          • 11.4 负载均衡优化
                                                                                                                                                                                                                                                                                                                                            • 11.4.1 串行算法
                                                                                                                                                                                                                                                                                                                                              • 11.4.2 交叉分解
                                                                                                                                                                                                                                                                                                                                                • 11.4.3 按块分解
                                                                                                                                                                                                                                                                                                                                                • 11.5 冗余计算减少通信
                                                                                                                                                                                                                                                                                                                                                  • 11.6 小结
                                                                                                                                                                                                                                                                                                                                                  • 第十二章 多层次并行程序优化
                                                                                                                                                                                                                                                                                                                                                    • 12.1 Hygon C86 同构多核平台
                                                                                                                                                                                                                                                                                                                                                      • 12.1.1 平台介绍
                                                                                                                                                                                                                                                                                                                                                        • 12.1.2 程序编写
                                                                                                                                                                                                                                                                                                                                                          • 12.1.3 性能分析
                                                                                                                                                                                                                                                                                                                                                          • 12.2 Intel KNL 同构众核平台
                                                                                                                                                                                                                                                                                                                                                            • 12.2.1 平台介绍
                                                                                                                                                                                                                                                                                                                                                              • 12.2.2 程序编写
                                                                                                                                                                                                                                                                                                                                                                • 12.2.3 性能分析
                                                                                                                                                                                                                                                                                                                                                                • 12.3 Hygon DCU 异构众核平台
                                                                                                                                                                                                                                                                                                                                                                  • 12.3.1 平台介绍
                                                                                                                                                                                                                                                                                                                                                                    • 12.3.2 程序编写
                                                                                                                                                                                                                                                                                                                                                                      • 12.3.3 性能分析
                                                                                                                                                                                                                                                                                                                                                                      • 12.4 申威26010 异构众核平台
                                                                                                                                                                                                                                                                                                                                                                        • 12.4.1 平台介绍
                                                                                                                                                                                                                                                                                                                                                                          • 12.4.2 程序编写
                                                                                                                                                                                                                                                                                                                                                                            • 12.4.3 性能分析
                                                                                                                                                                                                                                                                                                                                                                            • 12.5 “嵩山”超算同构+ 异构平台
                                                                                                                                                                                                                                                                                                                                                                              • 12.5.1 平台介绍
                                                                                                                                                                                                                                                                                                                                                                                • 12.5.2 程序编写
                                                                                                                                                                                                                                                                                                                                                                                  • 12.5.3 性能分析
                                                                                                                                                                                                                                                                                                                                                                                  • 12.6 小结
                                                                                                                                                                                                                                                                                                                                                                                  • 参考文献
                                                                                                                                                                                                                                                                                                                                                                                    • 术语表

                                                                                                                                                                                                                                                                                                                                                                                  相关图书