[论文解读] GPU Multisplit: an extended study of a parallel algorithm

Saman Ashkiani, Andrew Davidson+2 more|arXiv (Cornell University)|Jan 5, 2017

Parallel Computing and Optimization Techniques参考文献 28被引用 12

一句话总结

本文提出 GPU Multisplit，一种高性能并行算法，可基于用户定义的关键字标准高效地将数据划分为连续的桶。通过使用 warp 同步编程、分层子问题分解以及优化的内存访问模式，该算法在 GeForce GTX 1080 上实现了 18.93 Gkeys/s 的性能，优于基于排序的替代方案，并实现了 3.0 Gkeys/s 的快速基数排序吞吐量。

ABSTRACT

Multisplit is a broadly useful parallel primitive that permutes its input data into contiguous buckets or bins, where the function that categorizes an element into a bucket is provided by the programmer. Due to the lack of an efficient multisplit on GPUs, programmers often choose to implement multisplit with a sort. One way is to first generate an auxiliary array of bucket IDs and then sort input data based on it. In case smaller indexed buckets possess smaller valued keys, another way for multisplit is to directly sort input data. Both methods are inefficient and require more work than necessary: the former requires more expensive data movements while the latter spends unnecessary effort in sorting elements within each bucket. In this work, we provide a parallel model and multiple implementations for the multisplit problem. Our principal focus is multisplit for a small (up to 256) number of buckets. We use warp-synchronous programming models and emphasize warp-wide communications to avoid branch divergence and reduce memory usage. We also hierarchically reorder input elements to achieve better coalescing of global memory accesses. On a GeForce GTX 1080 GPU, we can reach a peak throughput of 18.93 Gkeys/s (or 11.68 Gpairs/s) for a key-only (or key-value) multisplit. Finally, we demonstrate how multisplit can be used as a building block for radix sort. In our multisplit-based sort implementation, we achieve comparable performance to the fastest GPU sort routines, sorting 32-bit keys (and key-value pairs) with a throughput of 3.0 G keys/s (and 2.1 Gpair/s).

研究动机与目标

• 为解决 GPU 上缺乏高效多分裂原语的问题，该问题迫使程序员使用次优的基于排序的替代方案。
• 设计一种并行多分裂算法，以最小化内存移动并避免桶内不必要的排序。
• 通过分层子问题组织和 warp 同步通信优化内存访问，以减少分支发散并提高内存访问合并度。
• 展示多分裂作为高性能 GPU 原原子（如基数排序）构建模块的实用性。
• 在现代 GPU 上实现峰值性能，尤其针对小数量桶（最多 256 个）的情况。

提出的方法

• 采用 warp 同步编程模型，以消除分支发散并减少内存使用。
• 使用多级子问题局部化的分治方法，以最小化全局内存操作。
• 通过分层重排输入元素，以改善全局内存访问的合并性。
• 利用 warp 内的原原子（如 shuffle 和 ballot 指令）高效管理数据流和归约操作。
• 设计多级局部化方案，参数为 $L_0, L_1, ..., L_{\lambda-1}$，以平衡本地计算与全局同步。
• 通过在分层子问题中递归求和桶计数，计算最终排列。

实验结果

研究问题

• RQ1 如何设计一种多分裂算法，以避免基于排序的实现方案在 GPU 上的性能陷阱？
• RQ2 分层子问题分解在减少全局内存访问和同步开销方面起到什么作用？
• RQ3 warp 同步原原子和内存访问优化如何影响吞吐量和可扩展性？
• RQ4 多分裂能否作为其他 GPU 原原子（如基数排序）的高效构建模块？
• RQ5 现代 GPU 上多分裂实现的理论与实际性能上限是什么？

主要发现

• 所提出的 GPU Multisplit 实现方案在 GeForce GTX 1080 GPU 上，对仅键（或键值）多分裂的峰值吞吐量达到 18.93 Gkeys/s（或 11.68 Gpairs/s）。
• 该算法通过避免桶内排序，减少了不必要的计算开销，而这是基于排序的多分裂方法固有的问题。
• 通过采用分层局部化和 warp 同步编程，该方法显著减少了全局内存访问和分支发散。
• 基于多分裂的基数排序实现方案达到了 3.0 Gkeys/s（2.1 Gpairs/s）的吞吐量，与目前最快的 GPU 排序例程性能相当。
• 分层方法有效利用了本地内存（寄存器和共享内存），降低了对昂贵全局内存操作的依赖。
• 与基于排序的替代方案相比，该方法在小桶数量（≤256）情况下展现出显著的性能提升。