密级:______

硕士学位论文

基于 OpenCL 的若干机器学习算法 GPU 实现及优化

作者姓名： 王伟俨

指导教师: 龙国平 副研究员

中国科学院软件研究所

学位类别: 工学硕士

学科专业: 计算机软件与理论

培养单位: 中国科学院软件研究所

2014 年 4月
Several Machine Learning Algorithm Implementations and
Optimizations Based on GPU with OpenCL

By
Weiyan Wang

A Dissertation Submitted to

University of Chinese Academy of Sciences

In partial fulfillment of the requirement

For the degree of

Master of Computer Software and Theory

Institute of Software, Chinese Academy of Sciences

April, 2014
 独创性声明

本人声明所呈交的论文是我个人在导师指导下进行的研究工作

及取得的研究成果。尽我所知，除了文中特别加以标注和致谢的地方

外，论文中不包含其他人已经发表或撰写过的研究成果。与我一同工

作的同志对本研究所做的任何贡献均已在论文中作了明确的说明。

签名：___________________ 日期：____________________

关于论文使用授权的说明

本人完全了解中国科学院软件研究所有关保留、使用学位论文的

规定，即：中国科学院软件研究所有权保留送交论文的复印件，允许

论文被查阅和借阅；中国科学院软件研究所可以公布论文的全部或部

分内容，可以采用影印、缩印或其它复制手段保存论文。

（保密的论文在解密后应遵守此规定）

签名：__________ 导师签名：__________ 日期：__________

中国科学院软件研究所硕士论文

基于 OpenCL 的若干机器学习算法 GPU 实现及优化

摘要
与大多数其他算法不同，机器学习算法并不是对问题解决方案直接的形式化
描述。相反，当前主流的机器学习算法基于统计从大量的训练数据中提取规则训
练模型，从而得到可推断其他待检测数据的模型或规则。机器学习算法因需不断
迭代逼近最优解有计算密集的特点，因需频繁读取训练数据和检测数据中有访存
密集的特点并因检测规则的复杂具有逻辑复杂性。因此，机器学习算法往往在训
练时耗费大量时间，而在检测时常常不能满足实时性要求高的应用场景。
另一方面，当前 GPU 用于通用计算已经越来越普遍，大量的算法在 GPU 上
获得了可观的加速比。因此，可以考虑基于 GPU 优化加速机器学习算法，减小
训练开销满足检测的实时性要求。考虑到 GPU 计算平台的硬件架构特性，结合
机器学习算法计算密集，访存密集和逻辑复杂的 3 大特点，本文主要从并行粒度
选择，访存优化策略以及负载均衡策略 3 个方面研究了在 GPU 上实现并优化机
器学习算法的方法。
并行粒度的选择是并行的根基性问题，选择何种粒度进行并行将决定整个并
行实现的框架和潜在优化空间。本文分别研究了讨论粗粒度与细粒度在发起足够
多线程数掩盖延迟与通讯同步开销上的影响，从而进一步讨论粗、细两种粒度的
选择与取舍。此外，还提出了依据输入规模和参数进行动态选择并行粒度的策略。
访存优化是并行优化的关键性问题，因为 GPU 众多的计算核心与显存相对
窄的带宽间有着鸿沟，解决访存延迟是喂饱计算能力达到好的加速效果的关键。
本文立足于具体机器学习算法的访存模式，分别从减少访存开销（主要包括对存
储层次结构利用、手动 cache 等策略）和减少访存次数（主要包括基于数据流分
析的 kernel 合并、循环缓冲，无锁全局同步机制的软，硬件实现等策略）两种思
路进行优化，并结合资源消耗和活跃 wavefront 数目之间的平衡等具体情况讨论
了上述策略的适用场景。
负载均衡优化问题是并行优化的难点性问题，整个程序的最终瓶颈在于任务
量最大的计算核心。本文对 work-group 内和 work-group 间两类负载不均衡问题
分别进行了研究。对于 work-group 内的负载不均衡主要从条件分歧的起因和影
响两种思路中分别发展出任务队列消除条件分支分歧和并行粒度变换减少线程
空闲两种具体的策略；而对于 work-group 间的负载不均衡主要进行了基于统计
趋势和假设的任务分配方式研究。
为了验证提出的 GPU 优化思路和具体策略的有效性，在上述优化思路的指
导下对 2 种计算机视觉算法(Viola-Jones 人脸检测和 SIFT 特征)和 1 种自然语言
处理算法（LDA 文本分类算法）进行了优化。其中，Viola-Jones 优化中合理的
使用粗粒度并行，并有效的使用 2 维 local memory 作为手动 cache 减少访存开销，
并用变换并行粒度减少条件分支分歧引发的线程空闲提高设备使用率，最终获得
的相对于 CPU 高达 16 倍的加速比。SIFT 优化中，进一步挖掘关键点领域进行
直方图统计时的并行性从而用更细粒度并行发起足够多线程有效利用 GPU 计算
能力，并用 kernel merge 和循环缓冲 2 种具体策略减少 global memory 访问，关
键点判别时的条件分歧则使用任务队列进行消除，并让 work-group 在完成一组
i
中国科学院软件研究所硕士论文

图层搜索后互换搜索区域以缓解全局负载不均衡，最终获得的相对于 CPU 高达
15 倍以及相对于知名开源项目 SIFTGPU 高达 2 倍的加速比。在对 LDA 算法的
优化中，采取了根据输入规模和特点动态决定并行粒度的方法以适应不同输入规
模和参数选择最有利的并行粒度，并引入了一种软件实现一个无锁的全局同步消
去了缓慢的 global memory 原子操作，并进一步设计了利用片上资源实现的硬件
全局同步机制方案从而彻底解决同步时对 global memory 访问的高延迟，最终获
得的相对于 CPU 最高到 40 倍的加速比。

关键词: 机器学习算法 GPU 并行粒度 访存优化 负载均衡

ii
中国科学院软件研究所硕士论文

Several Machine Learning Algorithms Implementations and

Optimizations Based on GPU with OpenCL

Abstract
Unlike many other algorithms, the machine learning algorithm isn’t the direct
formalized description of the solution to problem. In contrast, based on statistics the
main stream machine learning algorithms extract regulations and train models from
large training data set. Machine learning algorithms are computing intensive because
of repeated iterations, I/O intensive as a result of frequently access to training and
detecting data, and logically complex due to detection rules. So it usually costs quite
much time to train, and it often can’t satisfy high real-time needs when detecting.
On the other hand, GPU is more and more popular to be used as a general
purpose computing device, many algorithms get considerable speed-up on GPU. So it
occurs naturally that implementing and optimizing machine learning algorithm on
GPU to reduce training cost and make detecting satisfies real-time needs. Taking
GPU’s hardware architecture into consideration and combining machine learning
algorithm’s computing intensive, I/O intensive and logical complex 3 main features,
this paper studies machine learning algorithm implementation and optimization based
on GPU from parallel granularity choosing, I/O optimization strategies and workload
balance strategies 3 perspectives.
Parallel granularity choosing is the parallelization’s fundamental problem,
because it determines whole parallel implementation’s main frame and optimization
potential. This paper respectively studies coarse and fine parallel granularities’
influences on invoking enough threads to hide latency and costs of communications
and synchronizations, and then how to choose parallel granularity and make trade-off
is discussed. Additionally, a dynamically choosing parallel granularity strategy
adapted to input size and arguments is brought up.
I/O optimization is the key problem to parallelization, because the gap between
hundreds of computing cores and slow global memory makes it hard to feed GPU’s
parallel computing ability. Based on specific machine learning memory access pattern,
this paper employs some effective strategies to decrease memory access cost
(strategies such as storage hierarchy exploitation, manual cache, etc.) and reduce
memory access itself (strategies such as kernel merging based on data flow analysis,
loop buffer, manual cache, lock-free global synchronization software implementation
and hardware design, etc.). Taking trade-off between resources on chip and active
wavefronts number into consideration, those strategies’ the most suitable scenes are
discussed in details as well.
Workload balance is the difficulty in parallel optimization, and the core that
assigned the most tasks is the whole program’s final bottleneck. This paper
respectively studies local workload imbalance within work-group and global
iii
中国科学院软件研究所硕士论文

imbalance among work-groups. For local imbalance resulted from branch divergences,
it develops 2 strategies one is the task queue to eliminate branch divergences and
dynamical changing parallel granularity to reduce idle threads due to branch
divergences. And for the global imbalance, the simple and effective task partition
basing on statics is used to relief global workload imbalance.
To examine GPU optimization principles and strategies mentioned above, 2
computer vision algorithms (Viola-Jones face detection and SIFT feature) and 1
natural process algorithm (LDA document classification) are implemented under
those principles guiding. The optimization of Viola-Jones face detection chooses a
reasonable coarse parallel granularity, employs 2-D local memory as manual cache to
reduce I/O cost and decreases idle threads by using dynamic changing parallel
granularity. Those effective strategies help to get 16x speed-up compared with CPU.
In SIFT optimization, finer parallel granularity is dug out when accumulating
histogram in case that key point’s number is too small to invoke enough threads, both
kernel merging and loop buffer strategies are used to reduce global memory traffic,
and task queue contributes to eliminating branch divergences and make local
workload balance, the different work-groups will swap region after searching layers in
the same octave to relief global workload balance. Those effective strategies help to
achieve 15x and 2x speed-up compared with CPU and high reputed open source
project SIFTGPU respectively. And in LDA algorithm, the parallel granularity is
dynamically chosen adapted to input size and arguments, and the implementation
brings in a software lock-free global synchronization implementation to avoid slow
atomic operation in global memory. Furthermore, a hardware global synchronization
solution using storage and network on chip is designed to avoid all global memory
accesses’ and atomic operation’s cost. Finally, it achieves 40x speed-up compared
with CPU.

Keywords: Machine Learning Algorithm, GPU, Parallel Granularity, I/O optimization,

Workload Balance

iv
中国科学院软件研究所硕士论文

图目录
图 1 机器学习算法框架...........................................................................................................1
图 2 Viola-Jones Face Detect 算法框架....................................................................................6
图 3 Haar 特征模板..................................................................................................................7
图 4 Haar 特征举例...................................................................................................................7
图 5 积分图求值示意图...........................................................................................................7
图 6 级联分类器示意图...........................................................................................................8
图 7 积分图并行算法...............................................................................................................9
图 8 尺度空间：高斯金字塔（左）和差分高斯金字塔（右）........................................10
图 9 LDA 算法概率图模型.................................................................................................... 13
图 10 条件分歧时间开销示意图.......................................................................................... 22
图 11 队列消去条件分歧时间开销示意图.......................................................................... 22
图 12 人脸检测准确性测试效果图...................................................................................... 28
图 13 检测时间.......................................................................................................................29
图 14 C2050 和 HD 7970 相对于 CPU 的加速比.................................................................29
图 15 尺度空间生成的数据流图.......................................................................................... 32
图 16 环形缓冲.......................................................................................................................33
图 17 发生条件分歧的时间轴.............................................................................................. 34
图 18 任务队列消去条件分歧的时间轴.............................................................................. 34
图 19 GPU（左）与 CPU（右）检测效果对比.................................................................. 35
图 20 3 种实现的不同计算步骤在不同平台上性能............................................................ 36
图 21 CLSIFT 与 SIFTGPU 不同尺度对比性能趋势变化.................................................. 37
图 22 硬件全局同步支持示意图.......................................................................................... 40
图 23 GPU float 精度与 CPU float 的主题概率绝对误差值................................................41
图 24 GPU double 精度与 CPU float 的主题概率绝对误差值............................................ 41

v
中国科学院软件研究所硕士论文

表目录
表 1 并行粒度比较.................................................................................................................26
表 2 cache 策略比较................................................................................................................27
表 3 测试图片参数.................................................................................................................28
表 4 测试平台参数.................................................................................................................29
表 5 CLSIFT 与 SIFTGPU 在并行粒度优化上对比.............................................................31
表 6 CLSIFT 与 SIFTGPU 在尺度空间生成步骤访存优化对比........................................ 32
表 7 CLSIFT 与 SIFTGPU 在尺度空间搜索关键点访存优化对比.................................... 33
表 8 测试平台参数..................................................................................................................35
表 9 测试平台参数.................................................................................................................42
表 10 性能测试结果...............................................................................................................42

vi
中国科学院软件研究所硕士论文

目录
A Dissertation Submitted to............................................................................................................. ii
In partial fulfillment of the requirement........................................................................................ ii
For the degree of............................................................................................................................... ii
Master of Computer Software and Theory.................................................................................... ii
Institute of Software, Chinese Academy of Sciences..................................................................... ii
April, 2014..........................................................................................................................................ii
基于 OpenCL 的若干机器学习算法 GPU 实现及优化................................................................. i
摘要......................................................................................................................................................i
Abstract.............................................................................................................................................. iii
图目录................................................................................................................................................. v
表目录................................................................................................................................................vi
目录...................................................................................................................................................vii
第一章 绪论.......................................................................................................................................1
1.1 研究背景与意义..................................................................................................................1
1.2 本文研究内容.......................................................................................................................2
1.3 论文组织结构......................................................................................................................4
第二章 相关研究...............................................................................................................................6
2.1 Viola Jones 人脸检测........................................................................................................... 6
2.1.1 算法原理....................................................................................................................6
2.1.2 已有优化实现.................................................................................................... 8
2.2 SIFT 原理及已有 GPU 加速............................................................................................... 9
2.2.1 算法原理..................................................................................................................10
2.2.2 已有优化实现.................................................................................................. 12
2.3 LDA 原理及已有 GPU 加速............................................................................................. 12
2.3.1 算法原理...........................................................................................................12
2.3.2 已有优化实现.................................................................................................. 13
2.4 已有 GPU 优化策略总结.................................................................................................. 14
第三章 并行优化思路及具体策略................................................................................................ 16
3.1 并行粒度对并行加速的影响............................................................................................ 16
3.1.1 并行粒度与访存掩盖延迟..................................................................................... 16
3.1.2 并行粒度与同步......................................................................................................17
3.1.3 并行粒度动态选择................................................................................................. 17
3.1.4 CPU 和 GPU 的协同并行性...................................................................................18
3.2 访存问题对并行加速的影响...................................................................................... 18
3.2.1 访存具体优化策略.......................................................................................... 19
3.2.2 访存优化策略选择与平衡..................................................................................... 20
3.3 负载均衡问题对并行加速的影响................................................................................... 21
3.3.1 负载均衡具体优化策略.................................................................................. 21
3.3.2 负载均衡优化策略选择与平衡............................................................................ 24
第四章 案例分析.............................................................................................................................25
vii
中国科学院软件研究所硕士论文

4.1Viola-Jones 人脸检测算法优化..........................................................................................25
4.1.1 具体优化策略..........................................................................................................25
4.1.2 优化效果测试.........................................................................................................28
4.2 SIFT 特征优化................................................................................................................... 30
4.2.1 具体优化策略..........................................................................................................30
4.2.2 优化效果测试.........................................................................................................35
4.3 LDA 文本分类算法优化................................................................................................... 37
4.3.1 具体优化策略..........................................................................................................37
4.3.2 优化效果测试..........................................................................................................40
第五章 总结与未来工作展望.................................................................................................. 43
5.1 工作成果总结....................................................................................................................43
5.2 未来研究............................................................................................................................45
参考文献...........................................................................................................................................46
简历................................................................................................................................................... 49
研究生期间发表的论文...................................................................................................................50
其他学术性成果...............................................................................................................................50
致谢................................................................................................................................................... 51

viii
中国科学院软件研究所硕士论文

第一章 绪论
本章将介绍本文研究的背景及意义，概述论文的主要工作，最后给出论文的
整体章节结构。

1.1 研究背景与意义

计算机科学是研究什么能被有效的自动完成的学科[1]。如果说机械使得人类
从一部分的体力劳动中解放出来，那么计算机则使人类从一部分脑力劳动中解放
出来。目前，大多数的计算机算法是对问题解决方案直接的形式化描述[2]。计
算机通过执行求解的过程来达到解决问题自动化的目的。但是，值得注意的是解
决方案或者说算法本身依然依靠人类自己通过脑力劳动来得到。计算机仅仅起到
了机械的执行和运算的作用。
但机器学习算法则和上述的大多数算法有很大不同，它本身并未包含解决问
题的逻辑。相反，当前主流的机器学习算法基于统计从大量的训练数据中训练模
型或提取规则，从而得到可推断其他待检测数据的模型或规则[3]。大多数的机
器学习算法都符合图 1 所示的框架。

图 1 机器学习算法框架
虽然目前还有很多类型的问题机器学习尚未能给出令人满意的解决方案，但
相对于其他领域的算法，它确实扩展了能被有效自动完成的问题范围[3]。经过
20 世纪 80 年代一段时间的低潮，随着数据收集能力，存储能力以及运算能力的
增强，机器学习在大数据时代再次吸引着学术界和工业界的目光，成为了当前学
术热点[4]。
机器学习领域在实际应用中面临着很大的挑战:为了得到准确的结果，机器学

1
中国科学院软件研究所硕士论文

习往往需要处理大量的训练数据并进行大量的迭代运算[3]，这便使得机器学习
算法的耗时十分惊人。换句话说，虽然机器学习算法理论上是能自动完成的，但
不见得是能有效的或者是非常有效的自动完成。具体来说在某些实际应用场景特
别是有强实时性要求的场景下由于速度较慢不能及时给出输出，或者是为了满足
实时性采取减少迭代或者退而求次以牺牲准确度换取速度给出近似结果。
在另一方面，当前 GPU 用于通用计算已经越来越普遍，大量的算法在 GPU
上获得了可观的加速比[5]。目前，GPU 通用计算方面的标准和工具主要有 OpenCL
和 CUDA 两种。其中，OpenCL(全称 Open Computing Language，开放运算语言)
是第一个面向异构系统通用目的并行编程的开放式、免费标准，也是一个统一的
编程环境，广泛适用于多核处理器、图形处理器、Cell 类型架构及其他并行处理
器[6]。使用 OpenCL 在 GPU 上并行实现算法，有时可以获得相对于 CPU 几十倍
甚至几百倍于的加速比，并且与 CUDA 相比它可跨平台执行，具有良好的性能可
移植性的优势。因此，考虑将若干机器学习在 GPU 上借助 OpenCL 进行并行实现
并深入优化，从而解决或者缓解以下机器学习两方面的问题:
1.更快的训练和检测速度，从而更快对需求做出反应,更好满足实时性的要
求。
2. 训练速度加快有利于机器学习算法的设计者对算法进行调优和改进。
3.在一定时间内更多的迭代次数，在规定时间内更加逼近最优解，获得更加
准确的结果。

1.2 本文研究内容

本文主要研究内容为对机器学习算法的 GPU 平台上的并行化实现以及优

化，将提炼该类算法自身特点，研究有效减少机器学习算法时间开销的策略，并
尽可能系统总结其在 GPU 上并行优化取舍原则。从而为机器学习算法能在 GPU
进行并行优化提供系统思路和启发，达到使机器学习能更快对需求做出反应，更
好满足实时性以及在有限时间内更好的逼近最优解的目的。
当今主流的机器学习算法大多基于统计从大量的训练数据集中提取规则
或训练模型，得到规则或模型后再对检测对象进行判断或做出输出。本文分别选
择了 2 种计算机视觉领域算法(Viola-Jones 人脸检测和 SIFT 特征提取)以及 1 种自
然语言处理领域算法（LDA 文本分类）2 个领域 3 种典型算法，立足于机器学习
的训练部分，检测部分以及更早的基于人工定义风格的算法对该大类算法的特点
进行提炼，发现该类算法主要有以下 3 个特点:
1.迭代训练模型以及逼近最优解时的密集计算特点。
2.因反复访问训练集或待检测目标的密集 I/O 特点。
3.检测规则的复杂造成的程序条件逻辑复杂性。
而 GPU 作为典型的 SIMD 运算设备，它拥有数以百计的计算核心以及读取位
2
中国科学院软件研究所硕士论文

宽相对高的 GDDR5 显存。要能很好的利用其众多的计算核心，GPU 并行优化首

先有着并行任务任何分配并行粒度如何划分的问题，此外机器学习的频繁读写带
来极大的访存压力，而其逻辑复杂则给 GPU 引入了条件分歧问题。因此，本文
主要研究了以下 3 个方面的策略:
（1）并行粒度策略
算法并行化的根基在于算法的可并行度，而很多时候算法本身可以在不同层
次上进行并行，并且 GPU 本身也有 global 工作空间和 work-group 空间两层。为
了达到最好的加速效果，应当选择恰当的并行粒度，既能使众多的核心充分发挥
作用，又能减免通讯和同步。
具体来说，粗粒度并行各个进程的独立性较强互相依赖少，可减少同步和通
讯开销，但由于任务数相对较少有可能使得众多运算核心不能都被有效利用。另
一方面，细粒度并行使得能并行的任务数变多能提供更多可调度的 wavefront 数
有利于掩盖访存及耗时长的运算，将众多计算核心充分利用，但由于细小任务间
的依赖度更大可能将引入更多的同步和通讯开销。因此，本文将很好的分析具体
算法的特点，从算法并行性、数据依赖以及 GPU 设备本身特点 3 方面入手研究
粗和细之间进行合理取舍的方法。
（2）访存优化策略
与数以百计的计算核心相比，GDDR5 虽然有相对主机 DDR 内存较大的显存
位宽（如 512bitsp，384bits 和 256bits），但访存延迟依然是喂饱计算资源的障碍
也是并行中不可忽视的瓶颈。访存优化策略是否得当，也因此成为填满流水线，
有效利用计算资源，获得理想加速比的关键。
本文主要立足于具体算法的访存模式进行访存优化:一是从访存局部性和存
储层次入手，研究 local memory 作为手动 cache 与自动 cache 的优势；二是从数
据流入手，合并逻辑独立但数据流上联系的 kernel 以及设置循环缓冲将数据角色
互换来减少访存；三是片上读写速度很快的寄存器以及 local memory 使用与掩盖
访存延迟的活跃 wavefront 数进行合理平衡和取舍。
（3）负载均衡策略
虽然在任务划分上对于每个计算单元能做到任务数的平均，但由于每个任务
所走的逻辑分支不一样其耗时只有运行时才能决定，这就使得任务数的平均转变
为任务量实际上的不平均。负载均衡一直是并行加速的难点，特别是对逻辑复杂
的机器学习算法以及有着独特条件分歧问题的 GPU 而且则更是获得理想加速比
的难点。
为 获 得 良 好 的 加 速 效 果 ， 本 文 针 对 GPU 硬 件 特 点 对 work-group 内 和
work-group 间的负载均衡进行了研究，work-group 内的负载不均衡主要由于 GPU
的条件分支分歧问题造成主要研究了通过并行粒度变换以及任务队列消除条件
分支分歧使 work-group 内每一个 work item 都满负荷工作；而对于 work-group
间的负载不均衡主要进行了基于统计趋势和假设的任务分配方式研究，以缓解全
3
中国科学院软件研究所硕士论文

局负载均衡问题。
除了针对具体瓶颈对具体的优化策略进行研究和分类总结外，本文还注意到
每一种优化策略虽然能克服瓶颈消除开销，但优化策略本身也将引入新的开销，
此外优化策略的使用一般也会占用一些硬件资源可能会带来新的瓶颈。因此，本
文还研究了怎样选取合适的优化策略，如何衡量弊端受益进行取舍，并在
Viola-Jones 人脸检测，SIFT 特征提取以及 LDA 算法中进行了应用。

1.3 论文组织结构
论文以下的内容共包含六章，具体安排如下：
第一章 绪论
绪论部分介绍本文工作的研究背景、研究意义，本文的主要工作和贡献，以
及本文的组织结构。
第二章 相关研究工作
本章主要介绍本文研究工作所涉及到的相关领域的基础背景知识，包括
Viola-Jones 人脸检测算法，SIFT 特征提取算法以及 LDA 算法的原理以及已有的
GPU 并行优化实现工作。此外，本章还将总结介绍当前 GPU 并行优化针对所遇
到瓶颈的所做优化的一些基本策略。
第三章 并行优化思路及具体策略
本章将结合机器学习算法的 3 大特点和 GPU 硬件架构的 3 大特性，从并行粒
度选择，访存优化策略和负载均衡策略 3 个并行优化思路研究具体优化策略。
本章对于并行粒度选择，将分别讨论粗粒度与细粒度在发起足够多任务数掩
盖延迟与通讯同步开销上的影响，从而进一步讨论粗、细两种粒度的选择与取舍。
并提出了自适应于输入规模和参数的动态选择并行粒度策略。
对于访存优化，主要立足于具体机器学习算法的访存模式，本章主要以减少
访存延迟和减少访存 2 种思路讨论了存储层次结构利用、基于数据流分析的
kernel 合并、循环缓冲，手动 cache 以及资源平衡活跃 wavefront 数目等优化策
略，并研究了上述策略的适用情况。
对于 work-group 内和 work-group 间的负载不均衡，本章分别采用了不同的
优化策略，对于 work-group 内的负载不均衡主要研究了通过并行粒度变换以及
任务队列消除条件分支分歧使 work-group 内每一个 work item 都满负荷工作；而
对于 work-group 间的负载不均衡主要进行了基于统计趋势和假设的任务分配方
式研究。
第四章 案例分析
本章主要以 Viola-Jones 人脸检测，SIFT 及 LDA 文本分类为案例讨论了针对同
一个瓶颈问题，对于不同具体的机器学习算法以及具体的环境应该如何选择恰当
的策略。通过总结和分析优化策略，本章给机器学习算法的并行优化给出了指导
4
中国科学院软件研究所硕士论文

性原则，并通过实验进行了检验。
第五章 结论及未来工作展望
本章对全文工作进行总结，并给出本文的未来下一步研究工作。

5
中国科学院软件研究所硕士论文

第二章 相关研究
本章将主要介绍已有的机器学习算法在 GPU 上优化及实现的工作和进展。具
体依次介绍了 Viola-Jones 人脸检测算法，SIFT 算法和 LDA 算法 3 种机器学习算
法的原理及其已有基于 GPU 实现及优化工作。 本章还对已有的实现和优化工作
进行了总结和评价。

2.1 Viola Jones 人脸检测

Viola-jones 算法由剑桥大学的 Paul Viola 和 Michael Jones 于 2001 年最先提出，

是目前最为成功的满足实时要求的可实用人脸检测算法。[7][8]

2.1.1 算法原理

整个人脸检测系统可分为两部分:训练部分与检测部分，如图 2 所示。其中
训练部分是脱机执行，检测部分是在线执行。

图 2 Viola-Jones Face Detect 算法框架

为了保证检测准确度和满足实时性要求，Viola-Jones 算法使用了 3 种关键技
术:haar 特征，积分图，adaboost 算法训练级联分类器。
Haar 特征有 3 种类型 4 种形式的特征，正如图 3 所示。特征模板内有白色和
黑色两种矩形，并定义该模板的特征值为白色矩形像素和减去黑色矩形像素和。
上图的特征模板称为“特征原型”；特征原型在图像子窗口中扩展(平移伸缩)得到
的特征称为“矩形特征”；矩形特征的数值称为“特征值”。通过改变特征模板的
6
中国科学院软件研究所硕士论文

大小和位置，可在图像子窗口中穷举出大量的特征。特征模板可以在子窗口内以
“任意”尺寸“任意”放置，每一种形态称为一个特征。如图 4 所示为体现人脸
眼睛部位的 haar 特征。

图 3 Haar 特征模板[8]

图 4 Haar 特征举例[8]
由于训练样本通常有近万个，并且矩形特征的数量非常庞大，如果每次计算
特征值都要统计矩形内所有像素之和，将会大大降低训练和检测的速度。因此，
viola 与 jones 引入了积分图作为输入图片的一种中间表达形式来加速特征值的计
算。在积分图中，点(x,y)的值为其左边与上边所有点的值的和，其定义如下：

ii ( x, y )  
x ' x , y ' y
i ( x, y )

该定义中，ii(x,y)表示积分图中(x,y)的值，而 i(x,y)表示原输入图像点(x,y)的值，如
图 5 所示。

图 5 积分图求值示意图[8]
当使用积分图时，每一次特征值的计算不需要重新做所有元素的加法，重用
积分图中的积分信息便能得到一个矩形内像素和。要计算图中矩形 D 的像素和，
只需要将该图对应的积分图取矩形的四个顶点，4－3－2+1 即可得到矩形 D 的像
素和。在积分图中，不管此矩形特征的尺度如何，特征值的计算所耗费的时间都
7
中国科学院软件研究所硕士论文

是常量，大大地提高了检测的速度
在训练部分，使用 Adaboost 算法对预先收集的正样本和负样本进行处理，
生成所谓的级联分类器。级联分类器起到了尽快排除明显不是人脸的部分的作
用。对于级联分类器，在每一级进行分类时，如果当前子窗口（sub-window）被
检测为未包含目标图像，则分类器停止检测，直接退出并返回子窗口不包含目标
的输出。如果当前子窗口被判为包含目标，则进入下一级分类器进行检测，直到
经过所有的级分类器。级分类器的复杂度是逐层增加的，计算量也越来越大，前
面特征量少的级分类器起到了排除明显不是人脸区域的作用，如图 6 所示。
而在检测部分，通过变换检测窗口尺度，移动检测窗口，对每一个尺度以及
每一个位置上的检测窗口内容进行检测，对检测结果进行后处理即可最后得出图
像中人脸的位置 大小等参数。

图 6 级联分类器示意图[8]

2.1.2 已有优化实现

虽然，直观上看由于每个滑动检测窗口的计算是独立的 Viola-Jones 人脸检测

算法具有天然的可并行性，但在 GPU 上由于该算法需要反复读取特征点像素还
有着访存密集特点，此外级联分类器中复杂的判断逻辑也使得 GPU 受困于其特
有的条件分支分歧问题具有严重的负载均衡问题。
具体来说，目前已有的 Viola-Jones 算法主要有以下一些加速优化工作。首先，
作为事实上的工业标准，久负盛名的计算机视觉库 OpenCV[9]提供了 CUDA 版
的 Viola-Jones 人脸检测算法。此外，Ghorayeb 等人[10]在论文中描述了借助底层
为 OpenGL 的 Brooks API 混合使用 CPU 和 GPU 进行并行加速的工作。近期，
Sharma[11]也使用 CUDA 开发了一个 GPU 加速的人脸处理系统，用于人脸检测
和跟踪，但其主要是完成 CUDA 的开发作用未能细致结合 GPU 平台特点挖掘加
速潜力。Oro David[12]则在 GPU 实现了一个较好利用 GPU 存储层次体系的工作，
但和其他上述工作一样未考虑 GPU 上负载均衡的问题。Hefenbrock[14]所提出使
用双线程处理每一个检测窗口，用更细粒度并行缓解了负载不均衡的问题，但过
8
中国科学院软件研究所硕士论文

于简单不是特别有效。总体来看，已有的工作大多回避了级联分类器的条件分支
分歧带来的负载均衡问题，主要在以下几个方面进行优化:
1.CPU 与 GPU 的混合使用与协作。为了检测不同大小的人脸，Viola-Jones
人脸检测算法将把输入图片放缩到不同大小后进行检测。已有工作借助非阻塞的
异步启动 GPU 上的人脸检测 kernel，在空闲的 CPU 上对图片进行放缩为下一个
尺寸的检测做准备，从而达到了 CPU 运行时间掩盖的目的。
2.积分图计算并行优化。积分图本质上是二维的前缀和计算，图上的每一个
点的值由其左上部分的所有值共同决定，因此各个点之间的计算有着极大的相关
性。在直观上很难找到并行的方法，可以巧妙的将积分图求值转化为每一行连续
求和与每一列的求前缀和(prefix sum，即每个点的值为前面点的值的和)如图 7
所示，从而允许每一行或列的前缀和求解可各由一个线程并行的完成。

图 7 积分图并行算法[14]
3.GPU 上层次存储体系的利用。由于相邻的检测窗口只是滑动了 1 到 2 个像
素，因此不同窗口的特征点取值时很可能会有重复。因此上述工作主要使用了
texture 或 image buffer 对图像进行存储从而利用 GPU 的 cache 来缓解访存密集问
题。此外，部分上述工作还很好的对 channel 冲突，向量化计算方面进行了优化。

2.2 SIFT 原理及已有 GPU 加速

1999 年 British Columbia 大学大卫.劳伊（David G.Lowe）教授总结了现有

的基于不变量技术的特征检测方法，并正式提出了一种基于尺度空间的、对图像
缩放、旋转甚至仿射变换保持不变性的图像局部特征描述算子－SIFT（尺度不变
特征变换）[15]。
9
中国科学院软件研究所硕士论文

2.2.1 算法原理

其算法主要包括以下三个步骤:尺度空间建立，关键点搜索和描述符生成。
其中，一个像素点为关键点有三个条件:极值点，强度超过阈值以及曲率超过阈
值。[12][15]
1）尺度空间建立原理
在 SIFT 中，一幅图像将进行不同程度的高斯模糊处理形成一组大小相同的
图像，然后再进行放缩，放缩后的图像将再进一步连续高斯模糊，从而形成如图
8 左所示的高斯金字塔。
高斯金字塔生成后，为了检测尺度不变性还需要生成 DoG(Differences of
Gaussis) 金 字 塔 。 DoG 是 LoG(Laplacion of Gaussian) 的 近 似 计 算 ， 其 中 的

Gauss ( x, y , k )  Gauss ( x, y ,  ) 部分即为高斯差分，因此如图 8 右所示，用同一大

小不同高斯模糊的相邻图像相减生成 DoG 金字塔即可准备好检测特征点的数

据。

图 8 尺度空间：高斯金字塔（左）和差分高斯金字塔（右）[15]
2)关键点搜索
为了使从高斯金字塔中抽取特征值的开销最小，SIFT 采取了级联过滤的策
略，也就是先使用开销小的过滤手段过滤再使用开销较大的过滤进行处理。具体
来说，判断一个点是否为关键点，需要以下 3 个计算步骤:
1. 尺度空间极值检测:关键点一定是 DoG 空间中的极值点。为了寻找
DoG 函数的极值点，每一个像素点要和它所有的相邻点比较，看其是否比它
的图像域和尺度域的相邻点大或者小，如图所示。

图 5 每一个点需要和图像以及尺度上相邻的点进行比较
2．对比度阈值筛选:每个极值都可作为关键点的候选者，为了保证准确
10
中国科学院软件研究所硕士论文

性，将使用公式，泰勒展开拟合出精确的极值点。如果计算出的极值低
于 0.03，则该极值点将会被去掉，以免噪音干扰时特征点无法重现。

T
 1 D
公式: D  X   D  X
  2 X
3. 很显然，DoG 算子对边缘处十分敏感，但边缘却不是稳定的特征点。
为了判断是否是边缘点，将使用 Hessian 矩阵计算，通过曲率来判断是
否为边缘。Hessian 矩阵的定义如公式 4:
 Dxx Dxy 
公式 4: H  
 Dxy Dyy 
3)方向分配与描述子生成
为了让关键点有方向不变性，可以为每个关键点指定方向参数方向，从而使
描述子对图像旋转具有不变性。确定关键点的方向具体采用梯度直方图统计法，
统计以关键点为原点，一定区域内的图像像素点对关键点方向生成所作的贡献。
具体算法为:
（1）确定计算关键点直方图的高斯函数权重函数参数 ；
（2）生成含有 36 柱的方向直方图，梯度直方图范围 0~360 度，其中每 10
度一个柱。由半径为图像区域生成；
（3） 对方向直方图进行两次平滑；
（4）将直方图中最大的方向及高于最大方向 80%的方向作为关键点方向；
（5）对方向直方图的 Taylor 展开式进行二次曲线拟合，精确关键点方向；
描述子不但包括关键点，也包括关键点周围对其有贡献的像素点。用来作为
目标匹配的依据，也可使关键点具有更多的不变特性，如光照变化、3D 视点变
化等。描述子的具体步骤如下:
（1）描述子梯度方向直方图由关键点所在尺度的模糊图像计算产生。图像
区域的半径通过下式计算：

3 oct  2   d  1  1
radius 
2
（2）将坐标移至关键点主方向
（3）在图像半径区域内对每个像素点求其梯度幅值和方向，然后对每个梯
度幅值乘以高斯权重参数，生成方向直方图。
（4）在窗口宽度为 2X2 的区域内计算 8 个方向的梯度方向直方图，绘制每
个梯度方向的累加值，即可形成一个种子点。然后再在下一个 2X2 的区域内
进行直方图统计，形成下一个种子点，共生成 16 个种子点。
（5）描述子向量元素门限化及门限化后的描述子向量规范化。

11
中国科学院软件研究所硕士论文

2.2.2 已有优化实现

在早些时候，已有两个[16][17]基于 OpenGL 的 SIFT 算法在 GPU 上的实现，

并分别获得了 10 FPS 和 20 FPS 的处理速度。而受到 sift++[18]和[17]中成果的启
发，Wu Changchang 使用 CUDA 和 OpenGL 开发并发布了负有盛名的开源项目
SIFTGPU[19]。在已知范围内，SIFTGPU 是除本文将介绍的 CLSIFT 外，目前最
成熟和最快的 SIFT 在 GPU 上的实现。SIFTGPU 目前已经被广泛集成于各类视
觉相关的系统中，如: 图片搜索引擎[20]，3D 建模[21]，增强现实[22]等。
作为过去最快速，成熟的 SIFT 在 GPU 上的实现，SIFTGPU 主要在以下 2
方面进行了改进:一方面是 GPU 上层次存储体系的利用。无论是金子塔生成阶段
还是检测阶段都有着密集访存的特点，需要频繁多次读取，生成阶段还需要写入。
因此，SIFTGPU 很好的利用了 texture 类型中 cache 的特性，尽量满足局部性访
存以提高 cache 命中率，从而减少访存开销；另一方面，sift 在确定方向和生成
描述子时有一个统计直方图的小规模归约操作，SIFTGPU 选择 1 个线程负责 1
个关键点附近领域的直方图统计。直方图统计将以串行方式进行，避免了可能的
同步和归约开销。但 SIFTGPU 的速度依然非常受制于访存，此外完全回避了条
件分支分歧没有对其引发的负载均衡进行任何处理。虽然 SIFTGPU 是最负盛名
的 SIFT 在 GPU 上的实现，但依然难以适应实时性要求高的应用场景。

2.3 LDA 原理及已有 GPU 加速

2.3.1 算法原理

LDA[23]是一种流行的基于 topic 进行文档分类贝叶斯概率生成模型。与其他

类似的模型 PLSA 以及 unigram 相比，LDA 对过度拟合有更好的处理。LDA 算
法忽略了单词出现的顺序，而主要着眼于单词出现的频次并将 topic 以隐藏变量
的形式引入到模型中。LDA 将人类写一篇文档的过程视为如下的 3 层随机过程:
1. 从狄利克雷分布 中取样生成文档 i 的主题分布

2. 从主题的多项式分布 中取样生成文档 i 第 j 个词的主题

3. 从狄利克雷分布 中取样生成主题 的词语分布

4. 从词语的多项式分布 中采样最终生成词语
在实际使用过程中，显然模型的参数是未知的，唯一已知的信息为输入的文
档集。LDA 可用概率图模型表示为图 9 所示。

12
中国科学院软件研究所硕士论文

图 9 LDA 算法概率图模型[23]

在 LDA 最初提出的时候，人们使用 EM 算法进行求解，后来人们普遍开始使用

较为简单的 Gibbs Sampling，具体过程如下：

1. 首先对所有文档中的所有词遍历一遍，为其都随机分配一个主题，即
zm,n=k~Mult(1/K),其中 m 表示第 m 篇文档，n 表示文档中的第 n 个词，k
表示主题，K 表示主题的总数，之后将对应的 n(k)m+1, nm+1, n(t)k+1, nk+1,
他们分别表示在 m 文档中 k 主题出现的次数，m 文档中主题数量的和，
k 主题对应的 t 词的次数，k 主题对应的总词数。
2. 之后对下述操作进行重复迭代。
3. 对所有文档中的所有词进行遍历，假如当前文档 m 的词 t 对应主题为 k，
则 n(k)m-1, nm-1, n(t)k-1, nk-1, 即先拿出当前词，之后根据 LDA 中 topic
sample 的概率分布 sample 出新的主题，在对应的 n(k)m, nm, n(t)k, nk 上分
别+1。

 迭代完成后输出主题-词参数矩阵φ和文档-主题矩阵θ

2.3.2 已有优化实现

值得注意的是，LDA算法参数估计所用的Gibbs Sampling算法具有很强的数据
依赖性，其本身不能直接并行。研究者为了进行加速，采用了下述3种牺牲数据

13
中国科学院软件研究所硕士论文

依赖性和收敛速度的方法进行并行：
 Dirichlet Compound Multinomial LDA(DCM-LDA)[24]：该方法探索了在不
同处理器上分布不同数据的方法，Gibbs sampling 将在各个处理器上独立
采样估计参数不会进行任何通讯和同步。最后，对主题进行一次全局的归
类。
 Approximate Distributed LDA (AD-LDA)[25] :, 该方法每个处理器在一次
迭代中都会独立进行一次本地 Gibbs sampling 接着进行一次全局更新通
讯。由于 Gibbs sampling 只在本地进行，且只有一次循环后才更新信息，
因此该方法被称为近似分布式 LDA。
 Asynchronous distributed LDA (AS-LDA) [26]：在该方法中摒弃了所有的全
局通讯，与工作极为不一样。每个处理器进行一次本地 Gibbs sampling 后，
会随机和其他处理器通讯，而不会进行全局通讯。

LDA算法往往要处理大量的文档，消耗大量内存较难在GPU上全都装下。因
此有较多的基于CPU集群的LDA实现，而GPU实现则更多的着重于内存消耗的优
化。
在CPU集群环境下，Zhiyuan Liu等提出的PLDA+是获得了显著的加速比以及
接近完美线性扩展的AD-LDA算法实现。他们主要提出了以下4大优化策略:数据
划分放置，流水线处理，单词绑定和基于优先度的调度。这四大优化策略很好的
克服了在内存以及通讯上的瓶颈。
而在单机的GPU环境下，由Mian Lu等提出的GLDA也对单CPU获得了15倍的
加速比。Mian Lu的工作贡献主要在如何在相对CPU可访问的虚拟内存空间极其
有限的显存中存储相关信息。主要采取了以下3种策略:
1.按需生成文档-主题的计数器，而非提前预生成所有的文档-主题计数器。
2.对于稀疏矩阵采用了压缩存储的方式。
3.对单词进行划分，轮流占用GPU进行计算。
GLDA作为LDA的CUDA版实现，虽然他声称其通过多种策略在极其有限的
显存空间存储了极大的数据集，但他使用了较直接和朴素的方式来做计算。
GLDA将每个单词分配一个work-group，而每个线程都计算一个主题概率但额外
引入了规约操作进行新主题的选择。并且他基本没有考虑通讯以及同步的优化，
其他的一些细节也没有被GLDA考虑在内。这使得GLDA未能完全发挥出GPU的
计算潜力，虽然有一定加速但采用训练模型的参数依然将耗费许多时间。

2.4 已有 GPU 优化策略总结

目前，已有一些基于 GPU 的机器学习算法实现，他们在降低能耗的同时获

得相对于单 CPU 可观的加速比，促进了训练速度或更好的满足了检测时实时性
的要求。这些独立的工作主要从以下角度考虑了基于 GPU 的优化问题:
1.访存优化。机器学习算法大多既是计算密集型应用又是访存密集型应用，
能否喂饱 GPU 的峰值计算能力也是克服瓶颈提高性能的关键问题。上述工作中，
多使用 texture 或 image buffer 自带的 cache 机制利用访存局部性来降低访存开销。
此外，显存的 channel 冲突也是经常被考虑的优化问题。

14
中国科学院软件研究所硕士论文

2.CPU 与 GPU 协作。虽然 GPU 本身已有较高的并行度，但可将无数据依赖

关系的两个任务分别交给 GPU 和 CPU 同时计算。若 GPU 和 CPU 的执行时间近
似，则可有效掩盖 CPU 的处理时间。
3.合理任务划分和并行粒度选择。任务划分和并行粒度选择是并行化的基础
和第一考虑要素。上述工作借助任务划分和并行粒度选择有效克服了一些诸如内
存使用和设备占用率低下的问题。
虽然，上述的工作相对于 CPU 都取得了较为显著的加速比较好的满足了应
用中对实时性的要求，但这些工作大多是单纯的对特定算法进行实现而没有总结
机器学习算法的特点，并未系统的研究机器学习算法的优化方法。此外，上述工
作的优化工作考虑尚且有很大进一步深入的空间。
1.访存优化缺乏对访存模式以及层次存储结构的深入研究和优化。
2.在并行粒度和任务划分上一般是固定的，没有动态调整。
3.几乎完全回避了负载均衡问题，事实上已有一些考虑 GPU 负载均衡的工作
[29]独立存在，并在图遍历算法实现中获得了应用[30][31]。
4.缺乏对全局同步和通讯的优化，事实上也已有一些在 GPU 上软件实现无锁
全局同步的研究工作存在[32]。
5.在任务分配上，业内还有 Persistent thread[33]的技术没有很好的被考虑。此
外，CPU 时间掩盖在很多其他应用[34][35][36]也已经广泛被应用。

15
中国科学院软件研究所硕士论文

第三章 并行优化思路及具体策略
机器学习算法因需不断迭代逼近最优解有密集计算，因反复访问训练集或待
检测目标的密集访存，因检测规则的复杂造成的程序条件逻辑复杂性。而对于
GPU 本身，则有着并行计算核心数多理论计算峰值高，显存带宽相对窄访存延迟
大，并因共享指令发射装备具有条件分歧的特点。虽然直接朴素的在 GPU 上实
现某个机器学习算法会有一些效果，但尚不能完全发挥出 GPU 的并行计算能力
达到理想的加速效果。
结合机器学习算法本身的 3 大特点和 GPU 设备硬件架构 3 大特性，对机器学
习算法在 GPU 上优化时首要应考虑其并行粒度的选择，这是并行的基础问题将
决定整个优化工作的框架和潜在空间；其次要考虑的访存优化问题，这是并行加
速的关键问题只有减少访存的延迟才能填满 GPU 的流水线使得 GPU 真正发挥出
并行计算能力；最后还特别要注意负载均衡问题，当所有其他优化都做到最佳时
整个实现的瓶颈在于任务量最多的线程，因为任务量往往和输入有关运行时才能
决定，因此负载均衡问题是并行优化的难点。

3.1 并行粒度对并行加速的影响

将一个算法或程序并行化实现的基石是寻找其可并行性，而在多数情况中算
法往往在不同的尺度下有着独立性和可并行性。并行粒度至少会有较粗并行粒度
与较细并行粒度两种。因此，选择何种并行粒度是当对某个程序进行并行时所需
要回答的第一问题，将决定整个并行工作的大方向。
特别是在 GPU 依赖于大量轻量线程快速切换掩盖访存延迟并且对同步与通
讯弱支持的硬件特点。并行粒度选择由于往往还将决定可发起的线程数和所需交
换信息量，将极大的影响 GPU 并行优化的效果。除了访存延迟掩盖与通讯问题，
并行粒度与其他技术结合还对解决负载均衡有所帮助，相关问题将在第五章进行
介绍。

3.1.1 并行粒度与访存掩盖延迟

GPU 具有数目众多的计算核心，和极高的并行计算峰值。但显存访存带宽明
显无法同时满足如此多计算核心同时发起的访存需要。为了掩盖延迟，GPU 引
入了轻量线程，线程切换时直接切换寄存器堆，避免了 CPU 上线程切换时相关
寄存器入栈和出栈进行现场保护与恢复的开销。所以，当 GPU 遇到访存或其他
耗时指令时几乎不费代价的切换到其他进行计算的线程，用计算时间掩盖延迟。
16
中国科学院软件研究所硕士论文

但进行这种掩盖的前提是，GPU 上发起了足够多的线程数和 wavefronts 数能填

满流水线。
在较粗并行粒度与较细并行粒度两种选择中，较粗并行粒度各个线程所处理
的任务往往更加大块承担的任务量较多，因此线程数量相对较少。而对于较细并
行粒度，其将整个程序切分成更加细小的任务，各个线程任务量小而线程数多。
从发起足够多线程掩盖访存延迟的角度来说，细粒度并行粒度更利于发起足够多
的线程数。
但这并不意味着较细粒度比较粗粒度在访存掩盖上绝对更好。因为 GPU 的
访存指令大约为 5,6 个时钟周期，因此只要发起 5,6 倍于计算核心数的线程数就
能足够掩盖访存等其他耗时指令填满流水线。当处理的任务本身较大时较粗并行
粒度所发起的线程数有可能已经足够，此时再发起更多的线程也不能更好的掩盖
访存延迟。

3.1.2 并行粒度与同步

GPU 是典型 SIMD(single instruction multi data)的计算设备, 其硬件设计基于

数据不互相依赖不需要通讯的假设。事实上，GPU 上不直接提供也不倡导进行
全局的同步和通讯，只在 work-group 内部提供局部同步机制，全局的原子操作
也非常的耗时。很显然，在 GPU 上进行同步，特别是全局同步，是一件开销极
大的操作，此外通讯后往往跟随的归约操作也非常费时。
在较粗并行粒度与较细并行粒度两种选择中，较粗并行粒度的各个线程所处
理的任务往往独立性更强互相的依赖也更少，通讯和同步较少，所需的归约操作
也很少。而对于较细并行粒度，其将整个程序切分成更加细小的任务，任务完成
后往往需要将计算结果通过通讯和同步进行整合，随之而来的相关开销以及归约
操作较多。从减少通讯，同步和归约的开销角度来说，粗粒度并行通常更具有优
势。
但粗粒度并行在减少通讯，同步和归约上的优势也不是绝对的，当算法的数
据依赖性本身就不存在或者很少时，细粒度在这方面并不会有太多的劣势。

3.1.3 并行粒度动态选择

总体来说，粗细两种并行粒度各有其优缺点。粗粒度并行各个进程的独立性
较强互相依赖少，可减少同步和通讯开销，但由于任务数相对较少有可能无法有
效掩盖访存延迟。另一方面，细粒度并行使得能并行的任务数变多能提供更多可
调度的 wavefront 数有利于掩盖访存及耗时长的运算，将众多计算核心充分利用，
但由于细小任务间的依赖度更大可能将引入更多的同步和通讯开销。
因此，选择并行粒度应该结合具体的情况。不同的算法，所需处理的数据量
17
中国科学院软件研究所硕士论文

和数据间的依赖关系各有不同。当数据量较大，粗粒度并行可以发起足够多的线
程时粗粒度不会在掩盖延迟上有任何劣势，是不错的选择。同样当算法的数据依
赖性极少而数据量相对较少时，细粒度也不会有额外在通讯商的开销。当然，更
多时候情况会比较复杂，往往会存在有一定数据量但又不足够大，并存在一定的
数据依赖关系的情况，此时就应该考虑好哪一方的瓶颈更大做好各方面的平衡，
选择最合适的并行粒度。
另一个经常碰到的问题是，数据量与数据依赖性可能是依赖于算法的输入
的，而非一成不变，更可能在运行中发生改变。事实上，我们采取了一种变换并
行粒度的方式动态应对这一问题，根据输入的特点动态选择相对更好的并行粒
度，以变化来应对变化。

3.1.4 CPU 和 GPU 的协同并行性

虽然本文主要讨论机器学习算法的特点和 GPU 本身的特点，但事实上考虑

哪些任务应该放到 GPU 上并行和考虑 GPU 和 CPU 之间的合作也非常重要。在
机器学习算法中，还存在着一种非常粗粒度的可并行性，比如两个数据不依赖的
计算步骤。虽然 GPU 本身有很强的并行计算能力，有把两个计算步骤都加速的
很好的可能，但值得注意的是 CPU 也是拥有强大主频和计算能力的设备此时完
全闲置了。
对于上述情况，可考虑将其中一个并行性较差计算量较小的任务调配到 CPU
上执行，当计算完成后借助 PCI-E 的 DMA 传输异步上传到 GPU 设备供需要的
计算步骤使用输出的结果。这种方式下只要 CPU 上任务的执行时间加上异步传
输的时间比在 GPU 上执行的大任务时间短，则能有效完全掩盖住。

3.2 访存问题对并行加速的影响

虽然 GPU 有着高于 CPU 百倍的理论计算峰值，但在实际应用中往往不能完

全发挥出所有理论上的计算能力。特别是对于计算访存比较低应用，延迟很长的
访存指令成为其性能的最大瓶颈，其并行加速的效果离十分理想格外的远。 事
实上，无论对于 CPU 还是 GPU 而言，访存延迟都是不可忽视的对性能具有决定
性影响的因素。在 CPU 上，程序员会尽量保证程序访存的局部性，从而提高数
据预取到片上 cache 后的命中率来提高访存的性能。而在 GPU 上，虽然很多型
号也有 cache 机制，但由于其容量相对更小并且由于计算核心众多，访存发起要
求更密集更分散，它们共享的 cache 难以取得较理想的效果。此外，GPU 上轻量
线程通过切换寄存器堆的方式快速在 GPU 上调度换掩盖访存的方式一定程度上
缓解了这一矛盾，但这种方法一方面受限于活跃线程数另一方面没有从根本上减
少访存时的延误。因此，能否处理减少访存延迟是 GPU 并行取得良好效果的关
18
中国科学院软件研究所硕士论文

键问题。

3.2.1 访存具体优化策略

本节将主要讨论如何减少访存延迟，克服相关瓶颈。减少访存延迟的思路主
要有 2 条，一是通过寻找 CPU 上 cache 类似的解决方案，减少访存指令本身特
别是重复读取数据的开销；二是设法减少算法实现中访存指令的数目。下面将介
绍 3 种在此 2 种思路下设计的访存具体优化策略。

(1) Local Memory 作为手动 cache

虽然 GPU 中存在与 CPU 类似的自动 cache 机制，但由于容量相对要小，并

且由于计算核心数目众多，他们访存的行为相对而言不是特别符合局部性假设，
因此采用 Image Buffer 时 cache 的收益还不够理想。因此，需要考虑采取其他方
法替代自动 cache 减少访存指令本身特别是重复读取数据时的开销。
事实上，GPU 上除了 cache 片上还有单个线程独享的 private memory 以及可
供整个 work-group 共享的 local memory。如果仔细研究机器学习算法的访存模式
很容易发现，往往相邻线程的访存时是相邻的甚至有时会有重叠。因此当访存模
式 符 合 这 一特 性时 可 考虑 手 动的 将该 work-group 线 程需 要 的数 据从 global
memory 中手动预取到 local memory 中来，将 local memory 当作一个手动控制预
取与释放的 manual cache。
而对于一些特定的机器学习算法尤其是处理图像的计算机视觉，与其他诸如
事务处理的算法不同，其访存模式甚至是高度可预测。换句话其算法的访存模式
并不是由运行时的一些运算结果决定，而是由算法固定的。对于这种访存模式完
全有算法固定已知的情况，自动 cache 反而可能会进行错误的预取以及错误的替
换从而降低 cache 命中率导致访存速度降低。因此，对于高度可预测的固定访存
模式，也应该将 local memory 作为手动 cache 将重复使用的数据进行预取和替换。
因此，对于加速机器学习算法，当访存模式符合一个 work-group 中相邻线程
访存有重叠或者访存模式固定高度可预测的情况时，应该选择 local memory 作为
手动 cache 使用，对预取和替换手动 cache 进行控制来减少访存的延迟开销。

(2)合并逻辑独立 Kernel 减少访存

和很多其他算法类似，机器学习算法往往会有多个计算步骤，前一个计算步
骤的输出又往往是后一个步骤的输入。显然，不同的计算步骤往往有着不同的逻
辑意义，在书写代码时往往会倾向于将有不同逻辑意义的代码写入到不同的函数

19
中国科学院软件研究所硕士论文

和 kernel 中。很自然，基于逻辑意义的 kernel 划分虽然代码结构十分清晰，但前

一个计算步骤和后一个计算步骤往往需要分别通过写入和读取 global memory 来
交互输出和输入。
事实上，除了减少访存指令本身的延迟开销外，如果能减少访存指令的数目，
那么就将直接改变整个应用的计算访存比，很好的克服访存的瓶颈。因此基于减
少 global memory 访问的想法，应当考虑转换 kernel 划分的思路将逻辑上独立但
数据流上有依赖的多个 kernel 融合为 1 个 kernel，并让前面计算步骤的输出结果
写入到 local memory 或 private memory 而非 global memory。由于 local memory
和 private memory 属于片上存储，写入读取速度远快于 global memory，基于数
据流进行 kernel merge 后将大大减少 global memory 的访问从而改善访存所带来
的问题。

(3)使用循环缓冲减少访存

机器学习算法的一大特点是从大量训练数据集中进行遍历从而寻找关键点
或不断迭代逼近最优解。在遍历整个庞大的数据集时往往有多种遍历顺序的可供
选择，虽然大多数机器学习算法的不同遍历顺序在计算结果上没有不同，但遍历
数据集顺序则将根本上决定整个算法的访存模式和实现的数据流关系。
事实上，选择合理的遍历顺序的选择并结合循环缓冲技术可能有减少访存指
令。当遍历训练数据集时，若满足本轮遍历所需要的信息的一部分也是下轮遍历
所需要的，则可以考虑采用循环缓冲。所谓循环缓冲是一个分成若干份进行循环
使用的 local memory 缓冲区，当进行完本轮的循环遍历后将在淘汰那部分数据空
间上加载新一轮循环所需要的数据。这样，每次循环只需要更新一部分数据，而
每份数据都能参与多次循环从而起到了提高计算访存比和减少 global memory 访
问的作用。

3.2.2 访存优化策略选择与平衡

由上所述，对访存进行优化主要有 2 种优化思路，一是通过寻找 CPU 上 cache

类似的解决方案，减少访存指令本身特别是重复读取数据的开销；二是设法减少
算法实现中访存指令的数目。由于机器学习算法往往有访存模式十分固定，具有
高度可预测性，可使用 local memory 作为手动 cache 来替代自动 cache 从而达到
100%命中并避免无谓的错误替换，达到了减少访存指令本身延迟的目的。而
merge kernel 的策略则从数据流出发划分 kernel，虽然牺牲了 kernel 在逻辑上的
清晰但借助 local memory 减少了对 global memory 的访问次数。循环缓冲技术也
是一种减少访存指令数目的技巧，通过选择机器学习算法中遍历内存空间的合理
顺序，使得数据能够重用提高了计算访存比。
20
中国科学院软件研究所硕士论文

上述的 3 种策略确实能有效减少访存指令开销或访存次数，但消耗了 local

memory 和 private memory 作为代价。这些片上资源的过度使用，有可能导致活
跃的线程数过少而无法有效掩盖访存延迟。以上的 3 种诚然能有效减少访存指令
开销或访存次数，但依然无法完全避免访存指令以及其相对更长的延迟存在。因
此保有足够的活跃线程数作为最基本的访存优化是极其必要的。在选择具体策略
时，还应将资源消耗和活跃进程数进行很好的平衡，从而达到最佳的访存优化结
果。

3.3 负载均衡问题对并行加速的影响

虽然在程序开始运行时，每个计算核心都能被公平的分到任务数。但对于机
器学习算法而言，其往往有较复杂的逻辑，不同的任务的计算量并不见得一样。
具体的每个任务是计算时间长还是短只有运行时根据算法内在的判断逻辑才能
知道。因此，在任务划分阶段是无法保证每个计算核心能公平的布置任务，必然
有的计算核心运行时间长有的则短。虽然运行时间长的计算核心它自己并不会像
人那样抱怨这种不公平，但很显然整个程序的运行时间将由运算量最大的那个线
程决定。运算量最大的线程是整个算法实现的瓶颈，负载均衡是避免计算核心运
算能力被浪费的关键。
特别的，GPU 作为 SIMD（Single Instruction Multiple Data）思想指导下设计
的计算设备，其芯片面积主要用于 ALU（Arithmetic Logical Unit）和片上寄存器
的设计，逻辑部件十分简单多个计算核心需要共享同一套指令发射元件。因此，
相 应 的 当 遇 到条 件 分 歧时 GPU 有 着一 个 独 特的 条 件 分歧 问 题 。即 同 一 个
wavefront 中的线程若走不通的分支，则因所有核心公用一套指令发射元件，执
行时间等于各个分支执行的时间之和而不是像 CPU 中为最长的分支。因此，对
于 GPU 而言不仅有着和 CPU 一样的传统意义上的负载不均衡，更因为 GPU 独
特的条件分歧特点，当遇到逻辑复杂的机器学习算法将加剧 work-group 内部的
负载不均衡时，这是整个并行优化的难点。

3.3.1 负载均衡具体优化策略

本节将主要讨论如何处理负载不均衡问题，从而提高设备占用率达到最
终提高性能的目的。在 GPU 上做到负载均衡主要有 2 个层次：一是要处理 GPU
同 一 个 work-group 中 因 为 机 器 学 习 算 法 复 杂 逻 辑 造 成 的 条 件 分 歧 ， 使 得
work-group 内每个计算核心的任务量是平均的；二是要让每个 computing unit 的
任务量也要趋于平均。具体来说，提出了以下 3 种负载均衡的优化策略。

21
中国科学院软件研究所硕士论文

(1)任务队列：消除条件分歧

由于一个 Computing Unit 中只有一套指令发射装置，因此同一个 wavefront 中的不同

线程若走不同的分支，不同分支的指令则会被串行分别发射。因此，当条件分歧
发生时，哪怕 wavefront 中只有一个线程和其他线程走不同分支，整个执行时间
也将是执行 2 个分支的时间总和，如图 10 所示。

图 10 条件分歧时间开销示意图
由于发生条件分歧的前提是同一个 wavefront 中有线程走不同的分支路径。
一个很自然的想法是将走同一个分支的线程凑到一个 wavefront 中运行，从而从
根本上消除条件分歧。为了达到凑 wavefront 的目的，需要在 local memory 中维
护 2 个分别保存 2 个分支任务的队列。具体来说，当 64 个线程进行条件判断后
不是直接执行分支语句，而是将任务分别加入到合适的队列中。只有当队列中至
少凑满了一个 wavefront 或其他合适的 wavefront 大小倍数后，任务队列中的任务
才会被同一个 wavefront 执行。由此，当执行分支语句时，wavefront 中的任务总
是走同一个分支的。上图中的情况将演变为下图，虽然有一些维护队列操作的开
销，但执行分支 1 和分支 2 的总时间仅为原时间的一半，如图 11 所示。

图 11 队列消去条件分歧时间开销示意图
事实上，这种在 local memory 维护队列的方式并没有完全消除条件分支分歧，
上图中 64 个线程分别有 32 个线程将串行执行入队 1 和入队 2 对队列进行维护时
其实也是条件分歧。由于队列位于 local memory，由于是片上资源维护队列时使
用的 local 原子操作也非常快速，入队的开销其实非常小。因此，用维护队列很
小的开销来替代执行时间长的分支语句进行条件分歧，从而提高分支语句执行的
效率是十分值得的。

(2) 动态变换并行粒度:提高设备利用率

采用 local memory 队列能有效的以快速的队列维护操作在条件分支分歧中替

代分支语句的执行，并保证执行时间长的分支语句能高效执行。很显然，对于简
单的 if-else 等分支少的条件判断 local memory 有着良好的效果。但是，机器学习
算法以及其他领域中不仅有简单的条件判断，还可能有各种复杂的逻辑判断嵌套
22
中国科学院软件研究所硕士论文

和多重循环等十分复杂，分支极多的条件判断。当分支过多时，需要维护很多的
队列，这显然是不现实的，local memory 队列消除条件分歧的策略只适用于分支
数较少的情况。
因此，将处理 work-group 内负载不均衡的思路由避免产生条件分歧的前提，
转换到避免条件分歧带来的恶性结果上来。条件分歧导致 work-group 中负载不
均衡的根本原因在于执行某一个分支语句时，执行不走该分支线程的计算核心都
将空闲，使得整个设备的占有率变低。因此，可考虑保留条件分歧但在执行时设
法提高设备占用率。
在前面 3.1 节对并行粒度的讨论中，本文已介绍过算法的并行粒度往往有多
个层次。因此，可以考虑当出现条件分歧后选择更细粒度的并行将原本的一个任
务拆分到多个线程来执行。很显然，分支路径不同任务数也不同，因此采用的并
行粒度也应该不同，在有些情况下由于活跃线程数还远高于 wavefront 的一半，
此时即使仅拆分成 2 倍的效果也会不好，假设 wavefront 活跃线程数为 33 拆分为
2 倍后有 66 个线程超过了 wavefront 大小，将不得不发起一个只有 2 个活跃线程
的 wavefront，依然有着低效率的问题。
为了进行并行粒度的变换，事实上依然需要在 local memory 上维护一个数据
结构保存所有走现在正在执行分支路径的任务。每次进入一个分支时，各个线程
将从 local memory 的数据结构中读取该分支需要处理的任务，退出分支前将清空
该数据结构并写入新分支中活跃的任务。而在写入任务后，各个线程将变换并行
粒度且重新分配一次任务。原来的任务将会被拆分成更多也更细小的任务，所有
线程将读取保存了任务的数据结构，重新分配一个更细小的任务进行执行。执行
完成后，有必要的话通过一次归约操作将各细小任务的合并为原来相对较大的任
务。虽然变换粒度的策略引入了维护数据结构和进行归约的开销，但是合理使用
能使得 GPU 计算资源充分利用更加接近理论计算峰值，有效避免了负载不均衡
对机器算法实现的不利影响。

(3)基于统计趋势划分:缓和全局负载不均衡

和其他的并行计算平台一样，GPU 也还忍受着全局负载不均衡的问题，即
computing units 之间任务负载的不平衡。即使 work-group 内的负载不均衡已经完
全处理好，但不同 work-group 依然非常可能要花不同的时间，这就导致整个应
用的瓶颈在于任务量最多的 work-group。
与 work-group 局部负载不均衡相比，全局负载不均衡更难处理。这主要是因
为 GPU 缺乏全局同步和通讯机制的硬件支持，很难在 work-group 之间调度任务。
因此即使用软件技术将前面所叙述过的队列和变换粒度的策略同样运用到全局
负载不均衡问题的处理上，由于必须使用 global memory 替代只能 work-group 内
共享 local memory 作为存储介质，其读取速度以及相关的原子操作都十分慢造成
23
中国科学院软件研究所硕士论文

维护数据结构的开销极大，甚至将超过负载均衡后的收益。
因此，在无硬件直接支持高效全局通讯以及任务调度的情况下，需要考虑一
个开销小的策略来缓解全局负载不均衡。对于机器学习算法而言，总是会有一些
热点地区会有更多的计算，计算机视觉中目标所在的图像部分就是这种热点地区
的典型例子。很显然，热点地区在整个数据集中的分布必然不是均匀的分布，但
在遍历数据集进行寻找和迭代时，可以让 work-group 交替处理不同部分的数据。
这样从统计上来看，work-group 处理的任务量将更加趋于平均，从而一定程度上
缓解了负载不均衡的问题。由于让 work-group 交替处理不同部分的数据，只是
数据划分上的改变，相对于负载均衡的收益而言开销极小，所以对提升性能有一
定的帮助。

3.3.2 负载均衡优化策略选择与平衡

综上所述，负载均衡优化主要牵涉到 2 个层面的负载均衡:一个是 work-group

内部主要有条件分支分歧引起的负载均衡；另一个是全局的 work-group 之间的
负载均衡。由于 GPU 硬件对 work-group 内通讯机制和全局 work-group 间通讯机
制的支持不同，所采取的策略也应该不同。
由于 work-group 内部共享的 local memory 为片上资源读写速度很快而且原子
操作开销十分小，因此可以分别从消除条件分支分歧的原因和避免条件分支分歧
降低设备占有率的结果两头出发，分别设计适用于逻辑判断简单分支少的任务队
列策略和适用于逻辑判断更复杂分支多且空闲线程多的变换并行粒度策略。
而对于全局负载均衡问题，由于 GPU 并不提倡全局通讯，硬件上也没有提
供有效快速的全局可访问的存储空间和原子操作，使得在全局上照搬任务队列或
其他已有的一些调度策略的想法开销过多，往往将超过负载均衡本身的收益。因
此，考虑到负载平衡开销和收益之间的平衡，采用了一种相对简单的基于统计趋
势划分数据，在遍历数据集是交换 work-group 处理的数据部分，使得热点能相
对均匀的分布在 work-group 间，缓解了全局负载均衡的问题。
值得注意的是，work-group 内部负载均衡的两种策略也要考虑开销和收益之
间的平衡。Local memory 的原子操作虽然相对于 global memory 要快许多，但和
local memory 和 private memory 上其他操作相比依然很慢。若条件分支语句非常
简单，计算访存比也高，则存在着不对 work-group 内负载均衡进行优化更好的
可能性。

24
中国科学院软件研究所硕士论文

第四章 案例分析
本章将在几个案例中实际运用前三章中的讨论过的优化分析思路和具体优
化策略，来验证分析上述思路和策略的有效性。具体来说，主要选择了 2 个计算
机视觉(Viola-Jones 人脸检测和 SIFT 特征)和 1 个自然语言处理（LDA 文本分类
算法）讨论了具体的不同机器学习算法的特点，以及针对这些具体特点如何选择
恰当的策略，并进行试验进行论证。

4.1Viola-Jones 人脸检测算法优化

Viola-Jones 人脸检测算法原理已在 2.1 节中进行了详细讨论。由于人脸可能

以任意大小出现在输入图片的任意位置，因此输入图片会被放缩到各个尺寸后让
检测窗口以 1 到 2 个像素为距离左右上下遍历进行人脸检测。因此，Viola-Jones
人脸检测算法具有很多的访存和计算。此外，Viola-Jones 人脸检测算法中的关键
技术级联检测具有非常复杂的逻辑判断，在 GPU 上将因条件分支分歧发生很严
重的 work-group 内线程负载不均衡问题。为了获得良好的优化效果，将从并行
粒度、访存优化、负载均衡等方面考虑优化。

4.1.1 具体优化策略

（1）并行粒度选择

事实上，Viola-Jones 人脸检测算法具有天然的可并行性。很显然，不同尺寸
的图片中是否检测出人脸是互相之间独立的，固定尺寸的图片中不同检测窗口是
否检测出人脸也是互相独立的，检测窗口在级联分类器的某一级中不同 haar 特
征的计算也是互相不依赖的。整个 Viola-Jones 在这 3 个层次上都具有可并行性。
而在这 3 层可并行中，由于图片重现被放缩的尺寸非常有限远低于 100，数
目过少远远不能满足发起足够多线程掩盖耗时长指令延迟的目的；而同一尺寸图
中的检测窗口数目就十分大了，若检测窗口为 20*20 图片为 512*512 则总的检测
窗口数为（512-20）*（512-20）=242064 个远高于所需要的计算核心数的 5~6
倍，并且值得注意的是不同检测窗口直接完全独立不需任何通讯和归约。而对于
不同的 haar 特征计算，其数目更加巨大远超过所需要的线程数，但不同的 haar
特征值计算后需要归约到一起来和阈值比较判断是否通过本级分类器，若以该粒
度并行则会引入额外开销。
因此，在 3 层并行中以每个线程负责 1 个检测窗口为最佳选择，此时有足够

25
中国科学院软件研究所硕士论文

多的线程数能充分发挥 GPU 的并行计算能力，也没有引入任何的归约开销。事实

上，由于较大图像检测窗口过多，甚至可能超过 GPU 可能支持的最大线程数，实
现时引入了 Persistent thread 策略进行处理。
所谓 Persistent thread 是一个循环不断处理不同检测窗口的线程，若还有
检测窗口未被处理则它会去处理剩下的窗口而永不退出。由于维护一个空线程也
需要一定数量的寄存器和状态寄存器，发起足够掩盖延迟的 Persistent thread
数后，不发起过多的线程反而能节约更多的片上资源用于访存的优化。因此
Persistent thread 不仅是一个处理线程数过多的策略，在此也是一种节约资源
提高性能的策略。 此外放缩图片和某个尺寸的图片相比是个计算量和开销小
不少的计算步骤。虽然放缩图片到某个尺寸是该尺寸图片检测的预处理步骤有很
强的相关性，但下一个尺寸的放缩和当前尺寸的检测并无依赖性，因此可以应当
考虑在当前尺寸图片进行检测的同时由 CPU 去做下一个尺寸的放缩，之后再将放
缩后图片通过异步传输到 GPU 供。虽然 CPU 执行放缩的速度比 GPU 慢，但由于
GPU 检测的时间更长，能有效掩盖住 CPU 的放缩使其开销变为 0。
从表 1 中对 4 种并行力度对比可以看出，采用 Persistent thread 发起固定
线程数以检测窗口为粒度并行并在 CPU 上进行放缩的效果最好。
并行粒度策略 线程数 通讯规约 放缩计算
开销 时间
粗粒度图像并行 20~30，过少 无 独立计入
开销
适中粒度检测窗口并行 数千，图像大则过大 无 独立计入
开销
Persistent thread 窗口并行 可正好调整到计算核心 无 掩盖
及 CPU 放缩 的 5~6 倍
细粒度 haar 特征并行 十万以上，过多难以维 有 独立计入
护 开销
表 1 并行粒度比较

（2）访存优化策略

每一个检测窗口在通过每一级级联分类器时，都需要在其窗口范围内读取积
分图的数值对 haar 特征值进行计算。由于积分图将任意面积的 haar 特征值计算
都简化为了 4 次数据读取，2 次加法和 2 次减法操作，其计算访存比很低访存的
频率很高，因此检测窗口通过分类器是一个访存密集的过程。对访存进行优化是
提升人脸检测性能的关键。
从单个检测窗口中访存模式分析来看，当检测窗口逐一通过级联分类器各级
时，都是在检测窗口范围内访问积分图计算 haar 特征值。因此 20*20 大小的检
测窗口内有不少数据点将在高达数十级每级可能有上百个特征值需要计算的级
联分类器中进行重复读取。由于每个检测窗口内访存的高度的确定和密集性，依
据 4.2.1 节分析应考虑使用 local memory 作为手动 cache 替代 image buffer 的
26
中国科学院软件研究所硕士论文

自动 cache 机制，从而避免了不同级的分类器再次访问数据时已被错误的淘汰从
而保证了 100%的命中率。
另一方面，非常值得注意的是相邻的检测窗口仅仅是以步长为 1 个或 2 个像
素移动有相当大面积的图像是共享的，故还应该考虑 work-group 内不同线程共
享 local memory 中数据的问题。若 work-group 按照比较直观的方法用 1 维进行
组织线程，每个线程负责左右相邻的检测窗口，则 local memory 大小为 20*
（19+work-group 中线程数）。事实上，可以考虑采用二维方式组织 work-group
内线程在左右和上下 2 个方向上相邻检测窗口上检测。虽然二维的组织方式在实
现上要稍微麻烦，特别是偏移量的计算较为麻烦，但却能在保持检测窗口数目不
变 的 情 况 下 减 少 local memory 的 使 用 ， 此 时 local memory 使 用 的 大 小 为
（work-group 数的 2 次根+19）*（work-group 数的 2 次根+19）远低于一维组织
local memory 的形式。从表 2 中对不同访存优化可以看出，采用二维组织 local
memory 作为手动 cache 的效果最好。
访存策略 命中率 对活跃线程数影响
Image Buffer cache 较低 无
1 维 local mem 手动 cache 100% 相对大
2 维 local mem 手动 cache 100% 相对小
表 2 cache 策略比较

（3）负载均衡优化策略

Viola-Jones 人脸检测算法设计时以串行执行为指导思想，其级联分类器的
设计实质上是一种快速排除法。级联分类器中前面级分类器的 Haar 特征数量较
少，用于快速排除明显不是人脸的区域，只有比较有潜力的区域才会到后面特征
数量较多的级分类器上处理，而一旦某个检测窗口在某一级上失败则会被判定并
无人脸不会被后面的级分类器检测。由于级分类器的这种设计，为检测部分引入
了条件分支分歧，进而造成了 work-group 内部的负载不均衡问题。因此，对于
Viola-Jones 人脸检测算法如何处理好负载均衡问题是提升 GPU 实现及优化效果
的难点。
由于级联分类器的级数很多，也就造成了条件分支路径很多，虽然有一半的
分支路径是不做任何事情直接退出线程，但由于级分类的级数一般在 30 以上而
且后面的级分类器 haar 特征值可能高达数百上千。这意味着如果采用队列消除
条件分支分歧便需要在 local memory 中维护所有数十个分支路径的队列，这显
然是不现实的，而且逐个队列检测是否已满开销也非常大。
由于级联分类器分支路径众多，逻辑复杂，而且前面进行并行粒度分析时发
现有多层并行性存在，因此将考虑使用变化并行粒度的方式从消除条件分支分歧
影响的角度入手解决条件分支分歧。具体的策略为在 local memory 维护一个数
据结构保存当前还幸存的检测窗口。当某一级级数很高的分类器开始时，首先读
取数据结构中的任务，然后用多线程处理一个检测窗口而不是一个线程负责一个
27
中国科学院软件研究所硕士论文

窗口，使得每个线程都有工作能做。当每个线程计算完它们被分配的 haar 特征
后，它们进行一次归约来决定该检测窗口是否通过本级分类器。当所有窗口都被
处理后，原本的数据结构被清空，而后写入新的通过本级分类器的窗口供下一级
检测时检测。

4.1.2 优化效果测试

（1）正确性检测
为了验证程序正确性，我们使用卡耐基梅隆著名的人脸检测数据集进行
了测试。不同图片的尺寸参数如下表 3:
图片编号 图片大小 人脸数
1 256 * 337 1
2 469 * 375 4
3 500 * 500 6
4 696 * 510 12
5 623 * 805 9
6 662 * 874 7
7 1280 * 1024 56
表 3 测试图片参数
如图所示，对于各种类型的照片中不同位置和不同大小的人脸都有良好的检
测效果。输出的结果和串行的 CPU 版本完全一致。

图 12 人脸检测准确性测试效果图
（2）性能检测
为了验证实现的性能，我们继续使用卡耐基梅隆著名的人脸检测数据集进行
了分别在 Nvidia 和 AMD 的平台上测试，并与在 CPU 上的 OpenCV 人脸检测性
能做对比。设备的硬件参数如表 4。

28
中国科学院软件研究所硕士论文

Platform Nvidia Tesla C2050 AMD HD 7970 Intel Core2 Q9550

Compute Unit(CU) 14 32 4
Cores 448 2048 4
Wavefronts Size 32 64 1
Flops 1.03T Flops 3.79T Flops 11.32G Flops
Local Mem/CU 48KB 32KB No Info.
Local mem banks 32 32 No Info.
Register file/CU 128KB 256KB No Info.
表 4 测试平台参数
在不同设备的这 7 幅图检测时间为:

图 13 检测时间
相对于 CPU,不同设备相对于 CPU 的加速比具体为:

图 14 C2050 和 HD 7970 相对于 CPU 的加速比

从图 13 和图 14 可以看出，检测开销和 GPU 的加速效果与图片的两项参数图
片尺寸和人脸数目有关，尺寸越大的图片加速效果越好，而人脸数多的图片加速
29
中国科学院软件研究所硕士论文

效果相对一般。其原因是大尺寸的图片可并行性更高，访存的次数也更多，因此
合理的并行粒度选择更容易发挥出 GPU 的并行计算能力，而访存优化策略则提
供了更多的收益。而人脸数目较多时意味着有更多的检测窗口会进入到级联分类
器的后面若干级，不容易被淘汰。由于区域不同这些窗口必然会分布在更多的
work-group 中造成更多的 work-group 受条件分支分歧影响。虽然动态变化并行
粒度一定程度上消除了条件分支分歧的影响，但并不是完美的绝对的解决，因此
人脸数较多的图片加速效果会受一些影响。

4.2 SIFT 特征优化

SIFT 特征的算法原理主要分为三个特点迥异的三个计算步骤，已在 2.2 节中

详细讨论。为了实现不同尺寸下的不变性，SIFT 需要通过频繁 I/O 由输入图像
建立高斯金字塔和差分高斯金字塔。而当搜索关键点时，不仅需要频繁读取遍历
整个尺度空间的图像，还要对 3 个关键点判别条件进行判断引入了条件分支分
歧。而当关键点分配方向以及产生描述符时，本质上是生成统计直方图，为一个
规约过程，需要设法选择合适的并行方式。以下依然从从并行粒度、访存优化、
负载均衡等方面考虑具体的优化策略并完成了自行实现的 CLSIFT,并与采用其
他优化思路的著名的开源软件 SIFTGPU 进行策略和性能上的对比。

4.2.1 具体优化策略

（1）并行粒度选择

在前面建立尺度空间和定位关键点的计算步骤中，并行粒度都非常明确，即
每个像素的计算和判别都是独立的。这些像素点数目众多能发起足够线程且互相
之间不需要任何通讯，是 GPU 上并行的理想粒度。虽然大图的像素点数目众多
有可能超过最多支持的线程数，但可以依旧使用 Persistent thread 进行处理。
比较难处理的部分主要在运用了直方图统计的关键点方向分配和描述符生
成中。他们都需要对非常小的范围内的所有像素点计算并统计方向与强度。然后，
这些结果被统计成直方图来确定准确的方向或者是用来描绘图像的特征。
在著名开源 SIFTGPU 的实现中，为了避免规约操作直接将每个特征点被分
配到一个线程。这样特征点将串行计算领域中像素的方向和强度然后逐一累加到
直方图中。该策略的问题是有的图像（如标准测试图 lena.jpg 中）的关键点数量
较少可能只在 100 左右，这些少量的关键点不足以开辟足够的线程数去隐藏访存
延迟。
为了避免这种地利用率的情况发生，本文选择一个更细粒度的并行，将每一
个关键点分配给一个工作组。显然的，在小的邻域内的每个像素的方向和强度计
算能被同时处理。但在直方图的累加中依然存在冲突，因为可能有多个像素同时

30
中国科学院软件研究所硕士论文

需要在一个 bin 中累加。为了避免过多的原子操作，在局部内存中设置 8 个子直

方图，同时所有的像素点被分成 8 部分使他们可以分别累积。最终，使用 8 个附
属直方图的方法可以在不同的 bins 之间增加并行度去完成最终的直方图，从而
为特征点分配准确的方向和特征。通过选择合理的并行粒度和 Persistent thread，
使得所实现的 SIFT 和知名开源软件 SIFTGPU 有如下优势:
此外，Gaussian Blur 需要一个小矩阵(Gaussian 核)作为高斯因子来完成运算。
而 Gaussian 核的矩阵计算量很小，所以我们在 CPU 上异步计算该矩阵使得其计
算时间和传输时间用上一次的 Gaussian Blur 来掩盖住。换句话说，我们以非阻
塞的方式触发 Gaussian Blur 的 kernel，则在触发函数返回后，CPU 将为下一次
Gaussian Blur 计算 Gaussian 核。这样 CPU 的执行时间将掩盖在 GPU 的上一次
Gaussian Blur 的计算中。并且，有可能将有多个 Gaussian Blur 的 kernel 在任务
队列中，所以 GPU 可能并行执行来自不同 kernel 的 wavefront，从而得到好的
GPU 使用效率。
与 SIFTGPU 相比，CLSIFT 在并行粒度这一方面的优化上优势如表 5 所示。
处理大图像 性能是否依赖关键点数 高斯核计算时间
CLSIFT 是 否 掩盖
SIFTGPU 否 是 独立计入开销
表 5 CLSIFT 与 SIFTGPU 在并行粒度优化上对比

（2）访存优化

在创建高斯金字塔的过程中，高斯模糊被反复使用来生成金子塔的各层图
像。这就引入了大量的 global memory 访存，成为了该步骤的最大瓶颈。
在一次高斯模糊独立的计算过程中，很显然每个新生成的像素计算是互相独
立的。值得注意的是，相近的两个像素往往会共享一部分的图像部分和中间计算
结果，如果这些计算过程完全独立则无法重用。为了重用中间计算结果，事实上
可以将高斯模糊拆成 2 部在横向和纵向分别进行。先在横向高斯模糊生成的中间
结果再乘上纵向高斯模糊时的因子后进行累加即为二维高斯卷积的结果。由于一
般情况下，程序员将按照逻辑独立性划分函数和 kernel 接口，那么整个建立金子
塔过程中数据流如下。

31
中国科学院软件研究所硕士论文

图 15 尺度空间生成的数据流图
为了减少 global memory 访存，我们可考虑合并两个分别在不同方向进行
Gaussian Blur 的 kernel。在合并后的 kernel 中，纵向的卷积操作后，中间结果不
写入较慢 Global memory 而是写入 local memory。这样，横向的卷积就能从 local
memory 中直接取到输入数据避免了 global memory 访问。
此外，数据流图显示一次 Gaussian Blur 的输入输出数据是相邻的两层，正好
是产生 1 层 DoG 的输入。虽然功能逻辑上独立，我们将相减和 Gaussian Blur 也
合并。因此，DoG 金字塔的生成将不需要额外的 global memory 读取而只依赖于
Gaussian Blur 的中间数据。
一次 Gaussian Blur 的输出也正是下次 Gaussian Blur 的输入，所以也存在将
两个以及多个 Gaussian Blur 合并的机会。进一步的，还可将 DoG（差分金子塔）
生成这一更加逻辑无关的步骤合并入 kernel，从而避免生成 DoG 图层时对两层
高斯金子塔的读取。因此，在生成尺度空间时对访存进行优化的关键在于以数据
流为脉络和依据，对逻辑独立的 kernel 进行合并，用 local memory 和 private
memory 等片上资源访问替代 global memory 访问。
值得注意的是，合并 kernel 也不是合并的越多越好。虽然合并 kernel 的数越
多 global memory 的访问就越少，但也会消耗更多的 local memory。Local memory
的过度消耗将大大降低活跃的线程数，则访存延迟将难以被掩盖。在尺度空间生
成步骤访存优化对比 CLSIFT 和 SIFTGPU 对比如表 6:
Global memory 访问 数据重用 活跃线程数
CLSIFT nOctave×nLayer 手动 cache(100%命中) 足够多
SIFTGPU 3 nOctave×nLayer 自动 cache 多
表 6 CLSIFT 与 SIFTGPU 在尺度空间生成步骤访存优化对比
除了尺度空间的生成，在关键点定位时对尺度空间的遍历也涉及很多的
global memory 读取。一种普遍接受习以为常的遍历顺序是先左到右，再自上而

32
中国科学院软件研究所硕士论文

下遍历完一层后继续下一层的左右上下遍历，从而完成整个空间的寻找。但值得
注意的是，寻找关键点时不仅需要的是当前遍历的图层，还需要相邻的上下 2 个
图层寻找 3 维的极值点。因此，每个点都要与他身边的三维空间的 26 个点进行
对比，并且所有的层都将作为前一层，正在使用层和后一层在检查中分别使用。
所以我们选择的处理顺序是在同一组中穿越各层的方式而不是在同一层中按照
本层图像的大小进行顺序的处理。并且，我们在局部内存中使用三个环形缓存，
这使得在处理时，每层可以迅速的消除和更新，如所示。使用环形缓存的好处在
于，对于每一层的数据从全局内存的读取只需要一次并扮演三个角色，减少了全
局内存的访问。
此外，虽然朴素的认为 26 个对比是必不可少的，但是我们将其变成寻找最
值和对比检测像素点。特定的情况下，我们首先获得同意水平线上联系的三个点
的附加值作为中间结果。接着，我们获得垂直方向上的连续三个点的极值作为中
间结果，也就是说，在同一层中相邻九个点的极值。最后，我们获得了三层的极
值，并且用已经检测到的关键点来进行比较。环形缓存在存储中间结果的方面显
示了他的价值。在环形缓存中重用中间结果，使得 CLSIFT 只需要并行的完成 6
次对比。因此，在该步骤中 CLSIFT 和 SIFTGPU 的对比如

图 16 环形缓冲

线程数量 运算操作数
CLSIFT 64×nKeypoint ~ NeighborRegionSize /8
s
SIFTGPU nKeypoints NeighborRegionSize
表 7 CLSIFT 与 SIFTGPU 在尺度空间搜索关键点访存优化对比

（3）负载均衡优化

当在整个尺度空间遍历寻找关键点时，显然不会是所有的点都满足需要
33
中国科学院软件研究所硕士论文

判定的条件。在每一个 wavefront 中，只有几个点是极值点并需要计算对比强度

和曲率。所以，产生了条件分支并且导致了低的硬件资源利用率如图 17 所示。

图 17 发生条件分支分歧的时间轴
在局部内存中设置队列和索引帮助 CLSIFT 来处理这些问题。这一个工作组
中，当 wavefront 运行来寻找极值，队列的索引会原子加，并且此时这个点会被
存放在队列中并被索引指出。并且，response 和曲率不会计算，除非队列的大小
超过了 wavefront 的大小或者是到了循环结束的时候。通过使用队列，分支被减
少。图 7 的结果变成图 18 的结果。

图 18 任务队列消去条件分支分歧的时间轴

对比图 17 和图 18，可以肯定的是队列减少了分支并且提高了运算速度。通
过测试我们知道，如果我们只进行一次计算，一些点将进入队列，此时的时间消
耗并不比没有队列时候的情况高。所以没有副作用，维持队列消耗很少但是得到
很高的效果。
除了 work-group 内的负载不均衡，sift 在 GPU 的实现同样因为关键点在图片
内分布的不均匀也还忍受着全局负载不均衡的问题。即使 work-group 内的负载
不均衡已经完全被任务队列处理好，整个应用的瓶颈在于处理关键点最多的
work-group。由于 global memory 的访问以及原子操作开销过大且缺少全局同步
的硬件支持，前面所叙述过的队列以及其他的变换粒度的策略难以使用，这些策
略运用到全局的开销甚至将超过负载均衡后的收益。
因此，需要考虑寻找一个开销小的策略来缓解全局负载不均衡。在统计趋势
上，很显然关键点在图片的二维空间里不会服从均匀分布，在关键点边沿和物体
附件关键点较多而较为平缓的背景上数目较少。但值得注意的是，某一块区域关
键点在高斯金字塔和差分高斯金子塔不同层中应该趋于服从均匀分布，因为物体
或者边沿的特征在不同尺度上都会展现出一定的特征。因此，应该基于不同层次
上的均匀分布对 work-group 进行划分，即完成一组图层的搜索后不同 work-group
交换搜索的区域继续检索从而使得各个 work-group 处理的任务量将更加趋于平
均，从而一定程度上缓解了负载不均衡的问题。
从全局负载均衡的角度上来说，扫描完每一层后即让 work-group 交换搜索的
区域效果会更好关键点的分布应该更趋于平均。但是若每一层就交换则环形缓冲
的策略会因上下层区域变化无法实施，引入更多的访存。考虑到高斯金字塔和差
34
中国科学院软件研究所硕士论文

分高斯金字塔本身就以放缩不同尺寸进行分组，因此可以考虑不同大小的图组
中，work-group 的区域进行互换，使得负载均衡和访存优化上进行平衡取得总体
上较好的结果。

4.2.2 优化效果测试

（1）正确性检测

为了验证程序正确性，使用著名的图像测试用例 lena.jpg 进行了测试。如所

图 19 示，我们的 CLSIFT 和 OpenCV 得到了基本一致的视觉效果。但由于 CLSIFT
使用了 float 类型，比 OpenCV 的 short 类型精度更高，更多地在主边缘不太稳定
的关键点被 CLSIFT 排除了。

图 19 GPU（左）与 CPU（右）检测效果对比
（2）性能检测

再次使用 lena.jpg 作为测试用例，我们检查了所有在各个步骤应用的优化手

段的效果，并在 3 种平台与 OpenCV 和 SIFTGPU 进行了比较。各平台的性能参
数如表 8 测试平台参数。
Platform Nvidia Tesla C2050 AMD HD 7770 Intel Core2 Q9550
Compute Unit(CU) 14 10 4
Cores 448 640 4
Wavefronts Size 32 64 1
Flops 1.03T Flops 1.28T Flops 11.32G Flops
Local Mem/CU 48KB 32KB No Info.
Local mem banks 32 32 No Info.
Register file/CU 128KB 256KB No Info.
表 8 测试平台参数
针对 lena，CLSIFT 和 SIFTGPU 不同计算步骤在 AMD 和 Nvidia 平台上与
CPU 对比的测试结果如图 1 图 20 所示。
35
中国科学院软件研究所硕士论文

在 第 一 步 金 字 塔 的 构 建 中 ， CLSIFT 和 OpenCV 严 格 遵 循 SIFT 算 法 比

SIFTGPU 有更多的层次，但 CLSIFT 依然更快。这主要是由于更少的 global
memory 访问，手动 cache 并在片上资源的使用上，高斯核计算时间掩盖和活跃
线程数之间找到一个良好的平衡点。
在识别关键点并给其分配方向产生特征的步骤中，CLSIFT 有着显著的优势。
CLSIFT 首先得益于在 global memory 访问，中间结果重用上由于环形缓冲的存
在具有优势，此外任务队列也很好的消除了条件分支带来的 work-group 内的负
载不均衡，最后 work-group 间的不均衡则使用基于统计趋势的任务划分进行了
缓和。
CLSIFT 在生成关键点特征上的优势主要归功于 CLSIFT 更合适的并行粒度，
使得 GPU 设备的利用率提升从而改善了性能。

图 20 3 种实现的不同计算步骤在不同平台上性能
显然，CLSIFT 中所应用的优化策略使得其在整个算法过程中获得了良好的
性能。CLSIFT 对于 lena.jpg 的处理速度在 GPU 上分别达到了 43.4FPS，这比 CPU
的 10PFS 的速度要快了很多，同时也比已知的最快的 SIFTGPU 版本的 13FPS 快。
使用一组内容相同但大小不一的图像作为测试用例，测试了 CLSIFT，SIFTGPU
以及 OpenCV 的性能随图片大小变化趋势。依据图 21，CLSIFT 在各种情况下都
能实时的完成任务。在图片较小时有高达近 50FPS 的处理速度，甚至对 1080P
的高清图像 CLSIFT 依然有 25FPS 或 13.5FPS 的处理速度，相对于 OpenCV 的
2FPS 多和 SIFTGPU 的不到 10FPS 有可观的加速比。
值得注意的是，CLSIFT 在图片较小时对 SIFTGPU 的优势更为明显，随着图
片增大这一优势有减少的趋势。这主要是因为大图片有较多的关键点，此时
SIFTGPU 在分配方向和生成特征步骤中由于并行粒度较粗造成的设备利用率下
降的问题得到了一些缓解，减少了性能差距。

36
中国科学院软件研究所硕士论文

图 21 CLSIFT 与 SIFTGPU 不同尺度对比性能趋势变化

4.3 LDA 文本分类算法优化

LDA 文本分类算法的原理如 2.3 节所述，用来估算其模型参数的 Gibbs

Sampling 是典型的蒙特卡洛随机算法，在不停的迭代中逼近能使模型参数收敛到
最优解。如 2.3.2 节中所介绍的，Gibbs Sampling 算法具有很强的数据依赖性，
其本身不能直接并行。DCM-LDA 直接先将文档分成几个大子集分别进行 Gibbs
Sampling 后聚类，只适用于文档数巨大的情况。AD-LDA 与 AS-LDA 都是牺牲
部分的数据依赖性和收敛速度换取并行性，但由于 AS-LDA 需要线程间异步随
机通讯这在 GPU 上是难以低开销实现的，因此选择使用 AD-LDA 的方式，即在
本地进行 Gibbs Sampling，但每次迭代后进行一次全局通讯同步参数的更新。
由于 LDA 算法本身不具有可并行性，研究重点放在如何并行以及并行粒度
的选择上。此外，每次迭代后进行的全局同步也极具开销，是优化的重点。在访
存上，由于几乎没有重用数据每轮迭代后会根据新数据重新计算，优化空间较小。
此外，由于每个单词和每一论的计算路径都一样可不考虑条件分支分歧和负载均
衡问题。

4.3.1 具体优化策略

（1）并行粒度选择

采用 AD-LDA 法并行 LDA 算法时让各个单词忽略数据依赖关系，对所有主

题进行采样计算概率，并重新选定最高概率的主题为新主题。当一次迭代完成后
进行全局同步更新信息。很显然，在 AD-LDA 进行一次 Gibbs Sampling 的过程

37
中国科学院软件研究所硕士论文

中每个单词的采样是独立的，而单词的每一个主题的概率计算也是独立的，具有
2 个层次的并行性。值得注意的是，一般而言待分类文档集的单词量是巨大的，
将远超过所需掩盖延迟的线程数甚至超过了 GPU 支持的最多线程数。因此，无
论采取哪种并行粒度都需要引入 Persistent thread 的策略保证实现能对所有单词
都正确处理。
若采用细粒度的并行方式，则每个单词将分配到一个 work-group 上计算，每
个线程计算一个主题的概率，之后规约找出最大可能的概率再重新分配主题和更
新信息，如下代码。
For all work-groups in parallel do
Initialize to progress one word only
For all threads in parallel do
Sampleone topic basing on other words’ topics and counters, ignoring the data dependency.
Reduce operation to find the most probable topic to be the new one
Update word’s topic and counter
很显然，这种细粒度的并行方式在主题数较小的情况下将降低设备效率，引
发一些问题。具体为:
1. 在某些较极端情况下，主题数较小可能远低于 64 的 wavefront 的大小。造
成大量的线程和计算设备空闲。
2. 各个线程计算主题概率后需要一次规约操作来获得最可能的新主题，在规
约过程中一些线程势必要空闲。
3. 规约前各个主题的概率和一些中间结果必须存储在 local memory，导致
GPU 片上资源消耗增多，使得活跃线程数变少潜在影响了延迟的掩盖。
由于单词数一般是巨大的，将每个单词分配到一个线程中进行计算采用粗粒
度的并行也是可以考虑的，此时每个主题的概率计算式串行的，不会出现因为主
题数小于 wavefront 大小导致线程空闲，也不会存在规约带来的额外开销和 local
memory 消耗。在各个主题概率串行逐个计算的过程中，这一最值就能被记下。
但该粗粒度并行也存在如下的问题:
1. 当采用粗粒度并行时，将会有更多的单词同时进行采样并更新所分配的主
题。这将对数据依赖带来更大的破坏，更多的单词进行采样时依据的旧数
据而不是新数据。这将导致收敛的速度变慢。.
2. 更多的单词同时进行采样并更新所分配的主题还意味着更多的 global
memory 上的原子操作和数据竞争。这也将使得更新信息的速度变慢。
综上所述，无论是细粒度还是粗粒度的并行都有着其各自优点和不足。因此
在实践才用了根据输入规模和特点动态决定并行粒度的方法。当主题数超过
wavefront 大小时，采用细粒度的主题概率计算并行，使得计算并行的前提下尽
可能减少数据依赖的破坏保证收敛的速度，并有效减少数据竞争。而当主题数较
小可能造成线程空闲过多时采用粗粒度的单词并行，避免 wavefront 中线程空闲
和规约操作的开销。
此外，值得注意的是作为蒙特卡洛算法，Gibbs Sampling 在采样过程中需要
大量的随机数。而 GPU 的 kernel 中并不直接提供 RNG (Random Number Generator)
的 API 和扩展，若使用 CPU 串行生成再上传到 GPU 将引入极大的开销而且将占
据宝贵的存储资源。因此，将研究 GPU 上实现 RNG 的方法。

38
中国科学院软件研究所硕士论文

伪随机数产生算法中应用最广泛的是线性同余法。所谓线性同余算法是将随
机数种子与 2 个满足一定特殊要求的质数做线性变换后取余数生成下一个伪随
机数，如公式。

在 CPU 中用线性同余算法时，可见时间作为初始种子保证 RNG 的随机性。

而在 GPU 上有众多线程需要产生随机，为了保证随机数的均匀和随机性，则需
由 CPU 为每个线程产生一个随机数作为种子。
（2）访存优化策略
在 Gibbs Sampling 的计算过程中将产生一些可重用的中间计算结果，使用
local memory 和 private memory 片上资源缓存都是非常直观的。事实上，Gibbs
Sampling 的难点不在于计算，而在于每次迭代后 GPU 不支持的硬件同步。
进行全局同步首先有两个直观的方法。一是利用 kernel 结束时线程都将运行
到 return 语句，用重复启动 kernel 的方式同步；二是 2 级同步，work-group 内用
local barrier 同步，而 work-group 间用原子加操作到一个计数器上，当计数器等
于 work-group 总数时所有线程都同步到一点可以继续执行。这两种方案都以很
高的代价完成了同步，前者有着重复启动 kernel 的开销，后者则有原子操作和反
复轮询的开销。
事实上，可以在 global memory 中为每个 work-group 指定一个标志变量，然
后让一个完成计算的 work-group 利用局部 local barrier 并行的检测这一组标志变
量。当发现所有 work-group 都运行到一个位置后，该检测 work-group 再通过 global
memory 给出同步完成继续执行的信号。具体方法如下:
Global arrayIn[work-groupNum]=0, arrayout[work-groupNum]=0;
If(local_Id==0)
arrayIn[work-groupID]=1;
If(Work-groupID==0){
if(local_id<work-groupNum)
while(arrayIn[local_id]!=1);
barrier();
if(local_id<work-groupNum)
arrayOut[local_id]=1;
}
If(local_Id==0)
while(arrayOut[work-groupID]!=1);
Barrier();
在该方法中，没有任何全局锁和原子操作被运用，只有一个开销相对很小的
local barrier 被使用和相对较快无数据竞争的 global memory 访问。但该方法中因
为 global memory 中的标志数组被频繁的轮询且不能缓存而存在这极大的瓶颈。
事实上可提出一种片上专用标志和信号寄存器从硬件上支持无锁的全局同步，并
用片上全互联网络进行消息传递，如下图:

39
中国科学院软件研究所硕士论文

图 22 硬件全局同步支持示意图
GroupID: work-group 的 ID
OutFlag: 该 work-group 的同步标志，可为 0 或 1，表示该 work-group 是否到达
全局同步点。
OutMask ： 其 他 work-group 的 ID 掩 码 数 组 ， 表 示 该 work-group 哪 些 其 他
work-group 所依赖，需要向他们的发送同步到达信息。
InFlags:从片上网络收到的其他 work-groups 的同步信号信息标志数组。
InMask: 其他 work-group 的 ID 掩码数组，表示该 work-group 依赖于哪些其他
work-group，需要向等待他们的送来的同步到达信息。
Pattern: 行为决定逻辑，决定何时对标志位进行全 clear，全 set，以及轮询等待
等操作。
Sync: 根据 inflags 标志数组以及 pattern 逻辑做出同步判别逻辑。当每收到一个
inflags 更新信号，对 inflags 和 pattern 进行一轮检查判断是否满足同步条件。
Packet generator logic: 根据 outMask 掩码，生成发送到其他 work-group 的 outflag
包。
Packet receives logic: 接收由其他 work-group 发送到本 work-group 的 outflag 包，
并在 inflags 中保存。.

4.3.2 优化效果测试

（1）正确性检测
为了验证 GPU 并行实现的正确性，选取了 1000 篇英文新闻由 CPU 和 GPU
分别进行文本分类。实验结果表明，两者给出了相似的分类效果，但不 100%一
致。比如，CPU 与 GPU 分别给出经贸相关主题中最高概率的 20 个单词分别为：
CPU:
Stock price market rate roseshare dollar bond tradindustry fell month
centdateline dealer treasuri York yield govern decemb novemb
GPU:
Price stock market exchange trade trade bond York rate trader
rosedollar share Chicago jefferi industry fell future feder secur
虽然结果只是相似，但很显然这些单词都有着经贸相关性，这 2 种结果都是
能被人理解的。造成这一差别的原因主要有:
1.如 2.3 节所述，LDA 算法本身不能并行。AD-LDA 并行实现 LDA 是以牺
牲数据依赖性为代价的，因此 AD-LDA 算法和串行实现相比结果肯定有差别。
2.Gibbs Sampling 作为蒙特卡洛算法在计算过程中需要用到随机数，即使是
40
中国科学院软件研究所硕士论文

串行的实现 2 次运行的结果也会有不完全一致的地方。随机数的存在也使得结果
会有差别。
3.GPU 上的 FPU 和 CPU 的运算结果不完全一致，在多次迭代累中计误差，
将造成结果上的差异。
为了验证 GPU 运算精度对结果的影响，本文进行了一些实验。实验中，GPU
只发起一个线程工作来维护数据的依赖性，并让 CPU 和 GPU 使用同一个随机数
种子来消除随机数不同的影响。实验记录了多种主题数下 GPU 分别以 float 与
double 两种数据类型进行运算，和 CPU 以 float 类型进行运算时，在某一个单词
在某一个主题上的主题概率差的绝对值，如下图。

图 23 GPU float 精度与 CPU float 的主题概率绝对误差值

图 24 GPU double 精度与 CPU float 的主题概率绝对误差值

从图中我们能得到以下结论:
1.LDA 算法的不稳定性和主题数是正相关，主题数越大存在的误差可能越
大。主题数为 25 时明显高于主题数为 2 时较平缓的绝对误差曲线。
2.GPU 使用 double 进行运算和 float 的 CPU 相比时会更加稳定，但由于单词
数目众多，任何一点误差都非常容易累积，double 类型的运算也有误差的积累 从
而 导致结果的不同。
（2）性能测试
为了验证性能选择了 GTX 680、A-6 和 CPU 这 3 种平台进行测试，平台参数
如表 9 测试平台参数表 9:
Platform Nvidia GTX680 A-6（Radeon 7520G） Intel Core2 Q9550
41
中国科学院软件研究所硕士论文

Compute Unit(CU) 48 3 4
Cores 1536 192 4
Wavefronts Size 32 64 1
Flops 2.37T Flops 131.52 G Flops 11.32G Flops
Local Mem/CU 48KB 16KB No Info.
Local mem banks 32 32 No Info.
Register file/CU 128KB 128KB No Info.
表 9 测试平台参数
依旧对 1000 英文新闻进行 1000 次迭代，OpenCL 在 APU 和 Nvidia GPU 上
相对于 CPU 的加速比分别为 1.35 和 40，比较可观，如表 10:
平台 时间 加速比
Intel Core2 Q9550 527s None
（CPU 实现）
GLDA 开源项目 36s 15
A-6 389s 1.35
GTX 680 13.6s 40
表 10 性能测试结果
从上表可知，LDA 的 GPU 实现最高达到了 40 倍的加速比，非常可观。但
GTX-680 和 A-6 两个不同平台上表现差异较大，这主要是因为 2 大硬件平台在
以下 3 方面的差异。
1. GTX680 本身有更多的计算核心和更高的理论计算峰值在并行度很高时更
具有优势，而 AD-LDA 忽略单词间采样的依赖关系后每个单词的计算十分独立。
2. 此外 GTX680 具有更多的 local memory 和 private memory 片上资源有利于
发起更多 Persistent thread 数。
3. 最为重要的是，A-6 将普通的 DDR3 主机内存中的一部分独立划分作为显
存，而 DDR3 与 GDDR5 相比带宽更窄访存延迟更大。

42
中国科学院软件研究所硕士论文

第五章 总结与未来工作展望

5.1 工作成果总结

与大多数算法有很大不同，机器学习算法本身并未包含解决问题的逻辑。它
们大多基于统计从大量的训练数据中提取规则训练模型，从而得到可推断其他待
检测数据的模型或规则。因此，机器学习算法有着如下的特点:
1.迭代训练模型以及逼近最优解时的密集计算特点。
2.因反复访问训练集或待检测目标的密集 I/O 特点。
3.检测规则的复杂造成的程序条件逻辑复杂性。
因此，机器学习算法在训练阶段往往会消耗很长的时间，而在检测部分则往
往难以满足实时性要求强的应用场景要求。针对这一问题，本文研究了基于
OpenCL 在 GPU 并行实现并优化机器学习算法的方法，并针对机器学习算法的特
点在以下三个方面提出了具体的优化策略。
（1）并行粒度策略
机器学习算法的可并行性是进行 GPU 并行的根基性问题，而很多时候机器学
习算法本身可以在不同层次上进行并行。对于 GPU 而言，选择何种并行粒度将
决定整个并行实现的主体框架和优化空间。一般而言，粗粒度并行各个线程的独
立性较强互相依赖少，无同步和通讯开销，但由于任务数相对较少无足够线程切
换填满流水线掩盖延迟。而细粒度并行使得能并行的任务数变多能提供更多可调
度的 wavefront 数将众多计算核心充分利用，但更可能将引入更多的同步和通讯
开销。因此，本文从具体算法的特点出发，从算法并行性、数据依赖以及 GPU
设备本身特点 3 方面入手研究粗和细之间进行合理取舍的方法。
在 Viola-Jones 人脸检测中，虽然有检测窗口和特征值计算 2 层可并行性，由
于检测窗口数目本身已经超过所需活跃线程数且可以避免特征值计算并行额外
的归约开销，因此选择较粗粒度的检测窗口并行粒度并使用 Persistent thread 策
略只发起足够的线程数来处理过大的图像。而在 SIFT 特征提取中，由于特征点
可能过少方向分配和描述子生成往往无法发起足够多的线程使得设备使用率低
下，因此采用各个线程分区域首先在子直方图上统计，再归约为总直方图的策略
挖掘更细粒度的并行从而有效利用 GPU 的计算能力。而在 LDA 算法中，也存在
单词和主题概率计算的 2 层可并行性，无论是细粒度还是粗粒度的并行都有着其
各自优点和不足。因此采取了根据输入规模和特点动态决定并行粒度的方法。当
主题数超过 wavefront 大小时，采用细粒度的主题概率计算并行，尽可能减少数
据依赖的破坏保证收敛的速度。而当主题数较小可能造成线程空闲过多时采用粗
粒度的单词并行，避免 wavefront 中线程空闲和规约操作的开销。

43
中国科学院软件研究所硕士论文

（2）访存优化策略
在训练阶段和检测阶段机器学习算法都需要频繁的访问训练样本集和待检
测数据，由于 global memory 访问延迟较大如何填满 GPU 流水线喂饱 GPU 并行
计算能力是优化的关键问题。本文主要立足于具体算法的访存模式进行访存优化:
一是从访存局部性和存储层次入手，研究 local memory 作为手动 cache 与自动
cache 的优势；二是从数据流入手，合并逻辑独立但数据流上联系的 kernel 以及
设置循环缓冲将数据角色互换来减少访存；三是平衡好片上读写速度很快的寄存
器以及 local memory 使用与用来掩盖访存延迟的活跃 wavefront 数进行合理平衡
和取舍。
在 Viola-Jones 人脸检测算法中，主要是设计了 2 维的 local memory 作为手动
cache，达到了 100%的命中率并尽量减少了片上资源使用。SIFT 算法中除了将 local
memory 作为手动 cache 使用，在尺度空间生成步骤依据数据流图对逻辑独立的
kernel 进行合并，在尺度空间中寻找关键点时则使用了循环缓冲。Kernel merge
和循环缓冲都有效的减少了 global memory 的访存。而在 LDA 文本分类算法的计
算过程中每次迭代后都需要读取最新的数据本身没有数据重用，但每次迭代后的
全局同步中的 global memory 原子操作和访存有很大提升空间，本文在软件实现
一个无锁的全局同步后进一步设想了利用片上资源实现的硬件全局同步机制彻
底解决因访存和原子操作带来的高消耗。
（3）负载均衡策略
虽然在任务划分很容易能做到任务数的平均，但由于每个任务所走的逻辑分
支不一样其耗时只有运行时才能决定，所以绝对的负载均衡在逻辑负载的机器学
习算法中很难实现。由于 GPU 特有的条件分支分歧问题，负载均衡更是 GPU 优
化的难点问题。对于 work-group 内的由于条件分支分歧引发的负载不均衡，本
文主要从消除条件分支分歧的来源和消除条件分支分歧的影响 2 方面分别提出
了任务队列和动态变换并行粒度的策略，前者适用于分支较少的情况后者时候分
支较多的情况。而在 work-group 间的全局负载均衡问题，为了避免全局调度的
开销比负载均衡受益还大，主要是采用了简单的基于统计趋势的任务划分方法，
缓解了全局负载均衡问题。
在 Viola-Jones 人脸检测算法中，由于级联分类器的级数一般有 2,30 之多，造
成条件判断语句的分支很多，故采用了动态变化并行粒度的方案消去条件分支分
歧造成的设备利用率下降的影响。而在 SIFT 的关键点检索中，由于只需要判断 3
个条件分支较少，则采用了队列的方式当队列里的任务数凑满一个 wavefront 的
倍数后再运行，从而直接从根源上消去了条件分支分歧。而针对 SIFT 的全局负
载不均衡，则利用关键点在同一区域不同图层分布区域均匀的特点，让
work-group 搜索完一组图层后互换区域扫描使得处理任务量趋于一致，缓解问
题。
总体来说，本文很好的总结了现有机器学习算法本身的 3 大特点，并针对性
44
中国科学院软件研究所硕士论文

的提出了 GPU 上并行优化机器学习算法的 3 个分别为根基、关键和难点的优化

问题和方向。在找到 GPU 优化方向的基础上，进而分别提出了包括动态并行粒
度，local memory 作为手动 cache，kernel merge，循环缓冲，任务队列，基于统
计的任务划分等具体优化策略，并提出了一个硬件实现 GPU 全局同步的设想。
此外，本文还注意到每一种优化策略虽然能克服瓶颈消除开销，但优化策略本身
也将引入新的开销，额外占用一些硬件资源可能会带来新的瓶颈。因此，本文还
在具体的 Viola-Jones 人脸检测，SIFT 以及 LDA 算法中研究了怎样选取合适的优化
策略，如何衡量弊端受益进行取舍。上诉 3 个算法从这 3 个方面进行恰当的优化
后，在 GPU 获得了理想的加速效果，从而验证了该研究工作的有效性。

5.2 未来研究

本文已较系统的总结了机器学习算法的 3 大特点，并分别提出了 GPU 优化中

需要考虑的并行粒度选择问题，访存优化问题和负载均衡优化问题。这 3 大问题
都提出了具体有效的优化策略，并在 Viola-Jones 人脸检测，SIFT 以及 LDA 算法的
中针对具体的算法进行了实践，取得了理想的加速效果。但目前的研究依然存在
着一些不足，未来可从以下 3 个方面进行进一步的推进。
1.本文研究优化的是以串行计算思想指导下进行设计的机器学习算法，这些
机器学习算法在设计时主要考虑的是串行计算下的时间复杂度和空间负载度，甚
至 LDA 本身因为数据依赖不能被并行。串行思想指导下设计的算法在 GPU 并行
优化存在着各种弊端甚至难以融合的问题，如 Viola-Jones 的级联分类器就是串行
中典型的排除法。因此可以进一步考虑基于并行思想重新设计新的机器学习算
法，使新算法本身的基因是适应并行实现和优化的。
2.本文提出了 3 大需要解决的问题，并提出了不少有效的具体解决问题的策
略。这些提出的策略也和已有实现进行了一些量化的比较，在理论上和试验上都
有优势。但是目前还缺乏一个系统化的量化并行计算模型，用以衡量并行优化机
器学习算法时不同策略的效果。当具体优化某一个算法时就不得不要进行很多的
手工调优和尝试。因此，下一步还需考虑发展类似于串行实现中时间、空间复杂
度分析的理论，系统的量化的解决 GPU 并行优化问题。
3. 目前的优化工作主要还是针对较为传统的“浅度”机器学习算法，这些机
器学习算法的特征或模型大多由人设定。而当今兴起的深度学习算法能直接学习
特征，去除了特征选择的人为主观因素，能更加客观更加科学的刻画数据特点和
规则。下一步的工作应当尝试优化深度学习算法，并总结深度学习算法在学习特
征的过程中的特点和问题，并加以解决。

45
中国科学院软件研究所硕士论文

参考文献
[1]. Denning, P.J.. Computer Science: The Discipline (PDF). Encyclopedia of
Computer Science. 2000.
[2]. TH Cormen,CE Leiserson, and RL Rivest. Introductions to Algorithms. MIT
Press, 1990
[3]. Bishop C M. Pattern recognition and machine learning[M]. New York: springer,
2006.
[4]. Mayer-Schönberger V, Cukier K. Big data: A revolution that will transform how
we live, work, and think[M]. Houghton Mifflin Harcourt, 2013.
[5]. Cook S. CUDA Programming: A Developer's Guide to Parallel Computing with
GPUs[M]. Newnes, 2012.
[6]. Khronos OpenCL Working Group. The OpenCL Specification; 2011[J]. URL
http://www. khronos. org/opencl.
[7]. Viola P, Jones M. Rapid Object detection using a boosted cascade of simple
features[C]//Computer Vision and Pattern Recognition, 2001. CVPR 2001.
Proceedings of the 2001 IEEE Computer Society Conference on. IEEE, 2001, 1:
I-511-I-518 vol. 1.
[8]. Viola P, Jones M J. Robust real-time face detection[J]. International journal of
computer vision, 2004, 57(2): 137-154.
[9]. willowgarage, opencv, http://opencv.willowgarage.com/wiki/
[10]. Ghorayeb H, Steux B, Laurgeau C. Boosted algorithms for visual object
detection on graphics processing units[M]//Computer Vision–ACCV 2006.
Springer Berlin Heidelberg, 2006: 254-263.
[11]. Sharma B, Thota R, Vydyanathan N, et al. Towards a robust, real-time face
processing system using cuda-enabled gpus[C]//High Performance Computing
(HiPC), 2009 International Conference on. IEEE, 2009: 368-377.
[12]. Oro David, Fernández C, Saeta J R, et al. Real-time GPU-based face
detection in HD video sequences[C]//Computer Vision Workshops (ICCV
Workshops), 2011 IEEE International Conference on. IEEE, 2011: 530-537.
[13]. Lowe D G. Object recognition from local scale-invariant
features[C]//Computer vision, 1999. The proceedings of the seventh IEEE
international conference on. Ieee, 1999, 2: 1150-1157.
[14]. Hefenbrock D, Oberg J, Thanh N, et al. Accelerating Viola-Jones Face
Detection to FPGA-Level Using GPUs[C]//FCCM. 2010: 11-18.
[15]. Lowe D G. Local feature view clustering for 3D object

46
中国科学院软件研究所硕士论文

recognition[C]//Computer Vision and Pattern Recognition, 2001. CVPR 2001.

Proceedings of the 2001 IEEE Computer Society Conference on. IEEE, 2001, 1:
I-682-I-688 vol. 1.
[16]. S. Sinha, J.-M. Frahm, M. Pollefeys, and Y. Genc, Feature tracking and
matching in video using programmable graphics hardware, Machine Vision and
Applications, 2007
[17]. S. Heymann, K. Muller, A. Smolic, B. Froehlich, and T. Wiegand, SIFT
implementation and optimization for general-purpose GPU, in WSCG’07,2007.
[18]. A. Vedaldi. sift++, http://vision.ucla.edu/~vedaldi/code/siftpp/siftpp.html.
[19]. Wu C. SIFTGPU: A GPU implementation of scale invariant feature transform
(SIFT)[J]. 2007.
[20]. Cevahir, Ali Torii, Junji, GPU-Enabled High Performance Online Visual
Search with High Accuracy, Multimedia (ISM), 2012 IEEE International
Symposium on
[21]. H. Du, P. Henry, X. Ren, M. Cheng, D. B. Goldman,S. Seitz, and D. Fox.
Interactive 3D modeling of indoor environments with a consumer depth camera.
ACM Conference on Ubiquitous Computing, 2011.
[22]. J Jung, J Ha, SW Lee, FA Rojas, HS Yang, Efficient mobile AR technology
using scalable recognition and tracking based on server-client model, Computers
Graphic, 2012
[23]. Blei, David M., Andrew Y. Ng, and Michael I. Jordan. "Latent dirichlet
allocation." the Journal of machine Learning research 3 (2003): 993-1022.
[24]. Mimno, David, and Andrew McCallum. "Organizing the OCA: learning
faceted subjects from a library of digital books." Proceedings of the 7th
ACM/IEEE-CS joint conference on Digital libraries. ACM, 2007.
[25]. Newman, David, et al. "Distributed inference for latent dirichlet allocation."
Advances in Neural Information Processing Systems. 2007.
[26]. NEWMAN, D.,ASUNCION, A., SMYTH, P., ANDWELLING, M. 2009.
Distributed algorithms for topic models. J. Mach.
[27]. Liu, Zhiyuan, et al. "Plda+: Parallel latent dirichlet allocation with data
placement and pipeline processing." ACM Transactions on Intelligent Systems
and Technology (TIST) 2.3 (2011): 26.
[28]. Lu, Mian, et al. "Accelerating Topic Model Training on a Single Machine."
Web Technologies and Applications. Springer Berlin Heidelberg, 2013. 184-195.
[29]. Stanley Tzeng, Anjul Patney, John D. Owens, “Task management for
irregular-parallel workloads on the GPU”, Proceedings of the Conference on
High Performance Graphics(HPG’10): 29-37, June 2010.
47
中国科学院软件研究所硕士论文

[30]. Duane Merrill, Michael Gariand, Andrew Grimshaw, “High Performance and
Scalable GPU Graph Traversal”: 2011.
[31]. Timo Aila, Samuli Laine, “Understanding the efficiency of ray traversal on
GPUs”, Proceedings of the Conference on High Performance Graphics 2009:
145-150 August 2009.
[32]. Xiao, Shucai, and Wu-chun Feng. "Inter-block GPU communication via fast
barrier synchronization." Parallel & Distributed Processing (IPDPS), 2010 IEEE
International Symposium on. IEEE, 2010.
[33]. Aila T, Laine S. Understanding the efficiency of ray traversal on
GPUs[C]//Proceedings of the Conference on High Performance Graphics 2009.
ACM, 2009: 145-149.
[34]. Volkov, Vasily, and James Demmel. "LU, QR and Cholesky factorizations
using vector capabilities of GPUs." EECS Department, University of California,
Berkeley, Tech. Rep. UCB/EECS-2008-49, May (2008): 2008-49.
[35]. Fatica, Massimiliano. "Accelerating Linpack with CUDA on heterogenous
clusters." Proceedings of 2nd Workshop on General Purpose Processing on
Graphics Processing Units. ACM, 2009.
[36]. Panetta, Jairo, et al. "Accelerating Kirchhoff migration by CPU and GPU
cooperation." Computer Architecture and High Performance Computing, 2009.
SBAC-PAD'09. 21st International Symposium on. IEEE, 2009

48
中国科学院软件研究所硕士论文

简历

基本情况
王伟俨，男，湖南省邵阳市人，1989 年出生。中国科学院软件研究所计算机
软件与理论专业硕士研究生。
教育背景
2011.9——至今 中国科学院大学（培养单位:软件研究所）攻读工学硕士学位
2007.9——2011.7 华中科技大学计算机科学与技术学院计算机科学与技术专
业获工学学士学位
2008.9——2011.7 华中科技大学外国语学院英语专业获文学学士学位（第二学
位）
获奖情况
2012 年 AMD GPU\APU 异构编程大赛全国第 3 名
2009 年全国大学生数学建模大赛湖北省二等奖
华中科技大学 2009 年度科技创新先进个人荣誉称号
2008 年华中科技大学飞航杯数学建模大赛优胜奖
2008 年华中科技大学飞航杯 ACM 校园赛三等奖
2011 年华中科技大学优秀毕业生
2010 年华中科技大学校级优秀学生干部
2009 年自强奖学金
社会兼职
CSDN 论坛 OpenCL 及异构计算版块版主及 CSDN 领域顾问
研究兴趣
机器学习，并行计算
联系方式
通讯地址:北京市海淀区中关村南四街 4 号，中国科学院软件研究所并行软件
与计算科学实验室。
邮编:100190
E-mail：[email protected]

49
中国科学院软件研究所硕士论文

研究生期间发表的论文
1. Wang Weiyan, Zhang Y, Yan S, et al. Parallelization and performance optimization
on face detection algorithm with OpenCL: A case study[J]. Tsinghua Science and
Technology, 2012, 17(3): 287-295.
2. Weiyan Wang, Yunquan Zhang, Guoping Long, Shengen Yan and Haipeng Jia
CLSIFT: An Optimization Study of the Scale Invariant Feature Transform on GPUs
IEEE 15th International Conference on. High Performance Computing and
Communication 2013
3. Jia H, Zhang Y, Wang Weiyan, et al. Accelerating Viola-Jones Facce Detection
Algorithm on GPUs[C]//High Performance Computing and Communication & 2012
IEEE 9th International Conference on Embedded Software and Systems
(HPCC-ICESS), 2012 IEEE 14th International Conference on. IEEE, 2012: 396-403.

其他学术性成果
1.计算机视觉算法优化工作进入著名开源项目 OpenCV 函数库（该领域的工业界
事实标准）
2. 2012 年 AMD GPU\APU 异构编程大赛全国第 3 名

50
中国科学院软件研究所硕士论文

致谢
白驹过隙，转眼间我已经在中国科学院软件所度过了近三年的美好时光，又
将踏上新的人生旅途。在这三年里，我有幸能受到国内高性能计算领域颇有造诣
的老师们指导，并在朝夕相处中获得了很多同窗的帮助和友谊，最重要的亲身感
受到了中国科学院勇攀科学高峰的精神以及严谨务实的学术氛围。在临别之际，
往日美好的一幕幕又浮现在我的眼前，我希望能对所有陪伴我走过这美好三年的
人们道一声谢谢。
首先，我想要衷心感谢的是我现在的导师龙国平副研究员。您不仅在硕士在
读的最后一年里以导师身份指导我，而且在我大四时进入实验室实习时就对我在
具体技术问题有很多的指导和帮助。您借助自己在计算机体系结构的经验和心得
进行指导，让我更深入的理解 GPU 硬件结构的特点。而您在思考问题和写作的
方法上给我了不少好的建议，也让我有很大的收获。在此，我对您所付出的辛劳
表示最真诚的感谢！
其次，我还想对研一和研二的导师张云泉研究员表达深深的谢意。张老师一
方面对学术严肃认真，另一方面在生活上却平易近人，在学习和生活上都给予我
很大的帮助。虽然我最终没有转博，但张老师还是给我提供了很多的学术交流机
会，让我在和学术界、工业界的前辈的交流中看到了新的一片天地，获得了更多
更快的成长。除了具体的技术知识，我从您身上还学到了一些沟通交流的软技巧。
在此，我想对您给予的帮助和关心表示诚挚的谢意！
此外，我想由衷的感谢实验室的李玉成研究员、孙家昶研究员、曹建文研究
员、李会元研究员、徐进研究员、杨超研究员、姚继峰高级工程师、马文静副研
究员、邓攀副研究员，王婷副研究员，张常有副研究员，马菲菲副研究员。你们
在计算机科学领域的深厚造诣以及严谨治学的态度是我学习的榜样。尤其要感谢
马文静老师对本文提出了很多宝贵和细致的建议！
衷心的感谢实验室的张先轶、刘芳芳、解庆春、杨聪利、吴学淞等员工，感
谢你们对实验室的辛勤工作和在工程上学习上对我的帮助和支持。衷心的感谢实
验室的郭丹、李希代、李佳晨和张广婷 4 位秘书，感谢你们多年如一日不怕繁琐
不畏麻烦的服务和支持。
衷心的感谢我的师兄师姐颜深根、贾海鹏、张樱、王茜、刘益群、袁良、乔
海军、肖玄基、庞旭、蒋丽媛等，你们在学习和生活上为我提供了很多宝贵的帮
助和建议，特别是颜深根师兄和王茜师姐给予了我很多启发。衷心的感谢我的同
级同窗孙乔，单炜琨，张慧荣和袁伟，感谢你们和我一起度过在科院的这些一起
成长的美好日子，入学甚至保送复试的日子还仿如隔日。衷心的感谢我的师弟吴
振华、王迪林、敖玉龙、张鹏等，感谢你们给实验室带来新的欢笑和乐趣。

51
中国科学院软件研究所硕士论文

衷心的感谢我的父母，你们不仅用心血养育了我，而且一直是我最坚强的后
盾。衷心的感谢在北京的外公、外婆、舅舅、舅妈以及妹妹，你们让我不仅在异
乡吃到家乡菜还感受到了家的味道。
最后，谨向百忙中抽出宝贵时间评审本论文的专家和学者致以最诚挚的谢
意！

52