CUDA on Keqi的博客

GASPHiA: GPU加速的光滑粒子流体动力学（SPH）代码

plloningye@gmail.com (Keqi Ye) — Tue, 17 Mar 2026 10:00:00 +0800

GASPHiA: GPU加速的光滑粒子流体动力学代码

GASPHiA 是一个高性能的三维 SPH（光滑粒子流体动力学）代码，由中山大学航空航天学院的叶科奇在其博士研究期间开发。该代码专为模拟复杂的流体动力学问题设计，特别是涉及材料强度、损伤和引力相互作用的问题。

特性

高性能与可扩展性

全并行CUDA加速：充分利用现代NVIDIA GPU的大规模计算能力。
Barnes-Hut树算法 [1-4]：实现邻居搜索（O(N log N)）和自引力计算的加速，能够高效模拟大规模粒子系统。

可配置与灵活性

可切换精度：轻松切换单精度（float）和双精度（double）计算。可以在消费级GPU上最大化性能（float），或为科学应用确保高精度（double）。
维度：原生支持2D和3D模拟域。

高级物理建模

引力模型：可选均匀外引力场或/和天体物理场景的N体自引力。
强度与屈服模型：一套精细的本构模型来定义固体的弹性极限和后续塑性流动，包括：
- Von Mises：经典的压无关屈服准则，作为塑性流动的基本模型。
- Lundborg：具有强度饱和的压相关模型，适用于脆性材料。该实现基于 Lundborg（1968）[6] 最初提出的公式，后被 Collins 等人（2004）[7] 和 Jutzi（2015）[8] 采用。
损伤与断裂模型：基于 Melosh 等人（1992）[9] 提出的概念的可选损伤模型，模拟拉伸应力下的材料弱化和失效。这对于模拟断裂和碎片化至关重要，遵循 Benz & Asphaug（1995）[5] 和 Collins 等人（2004）[7] 等开创的SPH方法。
孔隙率模型：可选的 p-α 孔隙率模型，用于模拟多孔地质材料（如浮石或风化层）的压碎，遵循 Jutzi 等人（2008）[10] 开发的经典框架。

数值方法

时间积分：目前实现了预测矫正积分与自适应 Bogacki–Shampine RK23 [11]。

用户友好工作流

INI配置：通过可读的INI文件控制模拟参数，由轻量级 inih 库解析。
标准化输出：结果以广泛采用的HDF5格式写入，并生成配套的XDMF文件，可直接在 ParaView 和 VisIt 等科学软件中可视化。

代码访问与使用政策

GASPHiA 源代码仅向学术研究人员和合作者提供，仅供非商业、教育和研究目的使用。

如需获取源代码，请发送电子邮件至：

叶科奇（作者）: yekq6@mail2.sysu.edu.cn | plloningye@gmail.com
刘晓东教授（导师，中山大学航空航天学院）: liuxd36@mail.sysu.edu.cn

请在请求中简要介绍您自己、您的机构以及您打算使用该代码的研究应用。

致谢

我要衷心感谢我的导师刘晓东教授在我博士研究期间的支持和指导。

GASPHiA 的开发也得益于开源社区。特别感谢以下项目的作者，他们的工作提供了重要的见解和架构灵感：

本项目使用以下第三方库：

HDF5：高性能数据存储（The HDF Group）
inih：解析INI配置文件（Ben Hoyt）

参考资料

[1] Schäfer, C., Riecker, S., Maindl, T. I., Schaal, K., & Speith, R. (2016). A smooth particle hydrodynamics code to model collisions between solid, self-gravitating objects. Astronomy & Astrophysics, 590, A19.

[2] Barnes, J., & Hut, P. (1986). A hierarchical O(N log N) force-calculation algorithm. Nature, 324(6096), 446–449.

[3] Nyland, L., Harris, M., & Prins, J. (2007). Fast n-body simulation with CUDA. GPU Gems, 3, 62-66.

[4] Burtscher, M., & Pingali, K. (2011). An efficient CUDA implementation of the tree-based barnes hut n-body algorithm. In GPU Computing Gems Emerald Edition (pp. 75-92). Morgan Kaufmann.

[5] Benz, W., & Asphaug, E. (1995). Simulations of brittle solids using smooth particle hydrodynamics. Computer Physics Communications, 87(1-2), 253–265.

[6] Lundborg, N. (1968). Strength of rock-like materials. International Journal of Rock Mechanics and Mining Sciences & Geomechanics Abstracts, 5(5), 427-454.

[7] Collins, G. S., Melosh, H. J., & Ivanov, B. A. (2004). Modeling damage and deformation in impact simulations. Meteoritics & Planetary Science, 39(2), 217-231.

[8] Jutzi, M. (2015). SPH calculations of asteroid disruptions: The role of pressure dependent failure models. Icarus, 250, 356-362.

[9] Melosh, H. J., Ryan, E. V., & Asphaug, E. (1992). Dynamic fragmentation in impacts: Hydrocode simulation of laboratory impacts. Journal of Geophysical Research: Planets, 97(E9), 14735-14759.

[10] Jutzi, M., Benz, W., & Michel, P. (2008). Numerical simulations of impacts involving porous bodies: I. Implementing sub-resolution porosity in a 3D SPH hydrocode. Icarus, 198(1), 242-255.

[11] Bogacki, P., & Shampine, L. F. (1989). A 3(2) pair of Runge-Kutta formulas. Applied Mathematics Letters, 2(4), 321-325.

版权

基于CUDA加速的SPH模拟代码GASPHiA的一些应用

plloningye@gmail.com (Keqi Ye) — Tue, 17 Mar 2026 00:00:00 +0000

基于CUDA的SPH代码算例

本系列文章记录了我从零自研的 CUDA SPH (Smoothed Particle Hydrodynamics) 物理引擎的基准测试与验证过程。通过经典流体动力学问题的数值模拟，验证引擎的正确性与数值鲁棒性。

系列目标

验证 SPH 核心算法的正确性
测试引擎处理多物理场、复杂冲击问题的能力
探索数值方法的改进与优化

核心方法：求和密度 vs 连续密度

在 SPH 方法中，密度计算有两种主要方式：

求和密度 (Summation Density)：

$$\rho_i = \sum_j m_j W(r_{ij}, h)$$

连续密度 (Continuity Density)：

$$\frac{d\rho}{dt} = \sum_j m_j v_{ij} \cdot \nabla_i W_{ij}$$

本系列将展示求和密度法在处理强不连续问题时的显著优势。

系列目录

GASPHiA代码介绍 - 自研CUDA SPH代码的功能与特性概述
1D Sod 激波管实验 - 验证引擎对强激波不连续面的捕捉能力
- (待续)

📁 资源位置：本系列使用的视频和图片资源存放于 /static/images/GASPHiA/1DShockTube/ 目录

1D Sod 激波管实验 - CUDA SPH 基准测试

plloningye@gmail.com (Keqi Ye) — Tue, 17 Mar 2026 10:00:00 +0800

1D Sod 激波管实验

省流

本文使用从零自研的 CUDA SPH 物理引擎复现了经典的 1D Sod 激波管 (Shock Tube) 基准测试，主要验证引擎对强激波不连续面的捕捉能力。测试中解决了一个关键的数值陷阱：在处理初始阶跃密度场时，传统的连续性方程 (Continuity Density) 会导致严重的非物理震荡，而直接求和密度 (Summation Density) 展现出了更好的鲁棒性。事实上，连续密度更适合用在高速冲击问题中。

1. 模拟结果

以下是两种密度计算方法的效果对比：

求和密度法 (成功)

连续密度法 (失败)

左图 (成功)：采用求和密度法，可以清晰看到激波波前、接触间断和稀疏波的光滑推进。
右图 (失败)：采用连续密度法，在激波管的初始密度阶跃处产生了震荡。

图 1：Sod 激波管密度分布对比。展示了三种方法在 $t=0.2$ 时刻的密度沿 $x$ 方向分布与解析解的对比。红色实线为解析解，蓝色点为求和密度法的数值结果，橙色点为连续密度法的数值结果。

2. 问题背景

2.1 什么是 Sod 激波管？

Sod 激波管是流体力学中经典的基准测试问题，用于验证数值方法对激波、接触间断和稀疏波的捕捉能力。该问题模拟了一维管道中由薄膜分隔的两种不同状态气体的瞬时释放过程。

2.2 物理模型

本模拟采用理想气体模型，方程组包括：

连续性方程：

$$\frac{\partial \rho}{\partial t} + \nabla \cdot (\rho \mathbf{v}) = 0$$

动量方程：

$$\frac{\partial (\rho \mathbf{v})}{\partial t} + \nabla \cdot (\rho \mathbf{v} \otimes \mathbf{v}) = -\nabla p$$

能量方程：

$$\frac{\partial (\rho e)}{\partial t} + \nabla \cdot (\rho e \mathbf{v}) = -p \nabla \cdot \mathbf{v}$$

状态方程（理想气体）：

$$p = (\gamma - 1) \rho e$$

其中 $\gamma = 5/3$ 为绝热指数。

3. 初始条件

初始时刻，激波管被位于 $x=0$ 的薄膜分为左右两个区域：

参数	高密度区 (左)	低密度区 (右)
密度 $\rho$	1.0	0.25
速度 $v$	0.0	0.0
内能 $e$	2.5	1.795
粒子间距 $\Delta x$	0.001875	0.0075
软化长度 $h$	0.01	0.01
区域范围	$[-1.2, 0)$	$(0, 1.2]$
粒子数	640	160

总粒子数：800 个

初始条件设置使得左侧为高压高密度区，右侧为低压低密度区。薄膜移除后，左侧的高压气体会向右加速，形成激波、接触间断和稀疏波三种波结构。

4. 数值方法

4.1 SPH 密度计算方式

本测试对比了两种 SPH 密度计算方法：

方法一：求和密度 (Summation Density)

$$\rho_i = \sum_j m_j W(r_{ij}, h)$$

其中 $W(r, h)$ 为核函数，$h$ 为软化长度。这种方法直接对邻域粒子的质量进行求和，物理意义明确。

方法二：连续密度 (Continuity Density)

$$\frac{d\rho_i}{dt} = \sum_j m_j (v_j - v_i) \cdot \nabla_i W(r_{ij}, h)$$

该方程通过对动量方程进行散度运算得到，理论上与连续性方程等价。

后续计划

2/3D 溃坝模拟
带物质强度的模拟

参考资料

Sod, G. A. (1978). A survey of several finite difference methods for systems of nonlinear hyperbolic conservation laws. Journal of Computational Physics, 27(1), 1-31.
Monaghan, J. J. (1992). Smoothed particle hydrodynamics. Annual Review of Astronomy and Astrophysics, 30, 543-574.
Liu, G. R., & Liu, M. B. (2003). Smoothed particle hydrodynamics: a meshfree particle method. World Scientific.

基于应变的孔隙度模型（ε-α 模型）

plloningye@gmail.com (Keqi Ye) — Fri, 17 Apr 2026 10:00:00 +0800

一、模型要解决什么问题？

在冲击（如陨石撞击）或爆炸加载下，多孔材料（砂土、rubble pile等）的行为与密实材料完全不同。绝大多数压力用于孔隙的压实过程，而孔隙压实又会大量放热，导致膨胀。总之冲击多孔隙度材质时，有如下特点：

吸收大量能量
产生局部高温
显著削弱冲击波强度
最终影响坑体大小和形态

传统 P-α 模型直接用压力 P 驱动压实，需要迭代求解 α 和 P（不过我根据论文实现了无需迭代的 P-α 模型）。

ε-α 模型的核心特点：改用体积应变 $\epsilon_V$ 直接驱动压实，α 与 P 解耦，先更新 α，再算 P。

二、基本物理量

由于天文撞击中，压力一般都很大，体积应变也很大，所以大家一般都默认不考虑弹性压实阶段，直接进入塑形压实（不可逆），详细关于弹性压实阶段的信息可以参考论文[1][2].

符号	含义	公式
$\phi$	孔隙度	$\phi = V_{\mathrm{V}} / V$
$\alpha$	膨胀系数	$\alpha = 1/(1-\phi) = \rho_{\mathrm{S}} / \rho$
$\rho$	体密度	$\rho = \rho_{\mathrm{S}} / \alpha$
$\epsilon_V$	体积应变	$\epsilon_V = \ln(V/V_0)$

说明：

无孔隙：$\alpha = 1$
50% 孔隙：$\alpha = 2$
压缩时 V 减小 → $\epsilon_V < 0$

三、模型的基本假设

压实不可逆：卸载时 α 不变（不回弹）
压实速率由应变控制：$\mathrm{d}\alpha/\mathrm{d}\epsilon_V$ 不直接依赖压力
先压实、后压固体：孔隙完全闭合后才进入固体压缩段

四、核心公式

因为孔隙压实是依靠体积应变驱动的，首先需要了解如何计算体积应变。在 SPH 计算中，体积应变率 $\dot{\epsilon}_V$ 可以通过速度散度来计算：

笛卡尔坐标系下：

$$ \dot{\epsilon}_V = \frac{\partial u}{\partial x} + \frac{\partial v}{\partial y} + \frac{\partial w}{\partial z} $$

其中 $u, v, w$ 分别是 $x, y, z$ 方向的速度分量。

原始论文[1]给出的是轴对称柱坐标系下的格式：

$$ \dot{\epsilon}_V = \frac{\partial u}{\partial r} + \frac{u}{r} + \frac{\partial v}{\partial z} $$

其中 $u$ 是径向速度，$v$ 是轴向速度。

对 $\dot{\epsilon}_V$ 逐步积分即可得到体积应变 $\epsilon_V$。

此外，孔隙在强烈的压实过程中会做功并转化为大量内能（热量），温度的上升反过来会引起基质材料的热膨胀。文献[2]在改进 $\epsilon$-$\alpha$ 模型时，考虑了这种内能增加对体积应变造成的"反弹"效应（即热膨胀抵消了部分机械压实）。为了获取真实驱动孔隙压实的有效体积应变率，需要从总应变率中扣除热膨胀项：

$$ \frac{d\epsilon_V}{dt} = \left( \frac{d\epsilon_V}{dt} \right)_{\mathrm{total}} - \frac{\Gamma_{s0}}{c_{s0}^2} \frac{dE}{dt} $$

其中，$\left( \frac{d\epsilon_V}{dt} \right){\mathrm{total}}$ 为由速度散度计算得到的应变率，$\Gamma{s0}$ 为基质材料的初始 Grüneisen 参数，$c_{s0}$ 为基质材料的初始体声速，$E$ 为单位质量的内能。

在每个时间步中，根据当前的 $\epsilon_V$ 判断所处的压实阶段，进而计算对应的 $\alpha$ 值。

4.1 指数压实段（主要压实）

当 $\epsilon_V < \epsilon_X$ 时：

$$ \alpha = \alpha_0 \cdot e^{\kappa \epsilon_V} $$

其中 $\kappa$ 是压实速率，$0 < \kappa \leqslant 1$。$\kappa$ 越小，压实越"慢"（需要更大应变才能闭合）。

4.2 幂律压实段（后期硬压实）

当 $\epsilon_X < \epsilon_V < \epsilon_C$ 时：

$$ \alpha = 1 + (\alpha_X - 1) \left( \frac{-\epsilon_V}{-\epsilon_X} \right)^2 $$

其中：

$$ \alpha_X = \alpha_0 e^{\kappa \epsilon_X} $$

4.3 完全压实段

当 $\epsilon_V \leq \epsilon_C$ 时：

$$ \alpha = 1 $$

4.4 $\epsilon_C$ 的确定（保证导数连续）

$$ \epsilon_C = 2 \cdot \frac{1 - \alpha_X}{\kappa \alpha_X} + \epsilon_X $$

实际计算时，$\epsilon_C$ 其实只与材料参数有关，确定 $\alpha_X$、$\kappa$、$\epsilon_X$ 就可以得到 $\epsilon_C$。

4.5 参数汇总

参数	物理含义	典型范围
$\alpha_0$	初始膨胀系数	1.0 ~ 2.5
$\kappa$	压实速率	0.7 ~ 0.98
$\epsilon_X$	过渡应变（指数→幂律）	-0.4 ~ -0.2

五、模型验证

完成了前文所述的核心计算逻辑，特别是针对内能增加导致的热膨胀修正（即从总应变率中扣除热应变项：$d\epsilon/dt = (d\epsilon/dt){\text{total}} - (\Gamma{s0}/c_{s0}^2)(dE/dt)$）之后，我们需要一个标准的基准测试来验证程序实现的正确性。为此，我们选取了文献[2]中的案例：初始孔隙度为 75% 的多孔铁的冲击 Hugoniot 曲线计算。

1. 物理背景与为什么选择此案例？

对于极高孔隙率（>50%）的材料，在遭受强冲击压实时，孔隙空间的塌陷会转化为极高的内能（热量）。这种极端的加热效应会导致基质（固体）材料发生显著的热膨胀。

原始 $\epsilon$-$\alpha$ 模型的局限：原始模型假设基质密度永远大于初始密度（即忽略了热膨胀的贡献）。从图中可以看出，在高压区，原始模型（虚线）预测的密度持续增大，完全失效。

改进后的模型：在引入了热体积应变修正后，模型能够反映出在极高压力下，热膨胀效应甚至会超过机械压缩效应，导致宏观密度不增反降。

2. 计算结果与图表分析

在此次验证计算中，我们采用了与文献一致的参数（状态方程采用 Tillotson EOS，孔隙参数设为 $\kappa = 0.98, \epsilon_e = 0, \alpha_0 = 4$），并将我们的 SPH 程序计算结果与文献数据进行了对比。

图：初始孔隙度为 75% 的多孔铁的 Hugoniot 曲线。横轴为密度 (g/cc)，纵轴为压力 (GPa)。

通过观察上图，我们可以得出以下清晰的结论：

捕捉到Hugoniot曲线 “倒拐” (Inversion) 现象：在压力达到约 10 GPa 之后，我们的数值计算结果完美展现了曲线向左反转的特征。在 10 ~ 100 GPa 的区间内，随着压力的升高，材料密度反而减小，这正是由于极端加热引起的基质材料热膨胀所致。
与理论解析和参考 Hydrocode 吻合：我们将程序跑出的状态点与文献中改进 $\epsilon$-$\alpha$ 模型的理论解析解（实线）进行了叠加。可以看到，两者较为吻合。因为论文[2]没有给出详细的EOS信息，因此我只能推测低压力情况下的一些误差可能的原因是论文并没有使用Tillotson EOS。

参考资料

[1] Wünnemann K, Collins GS, Melosh HJ. A strain-based porosity model for use in hydrocode simulations of impacts and implications for transient crater growth in porous targets. Icarus. 2006 Feb 1;180(2):514-27.

[2] Collins GS, Melosh HJ, Wünnemann K. Improvements to the ɛ-α porous compaction model for simulating impacts into high-porosity solar system objects. International Journal of Impact Engineering. 2011 Jun 1;38(6):434-9.

SPH基础(二): 网格法邻居搜索

plloningye@gmail.com (Keqi Ye) — Fri, 09 May 2025 00:00:00 +0000

SPH 粒子领域搜索

问题描述

在光滑粒子流体动力学（Smoothed Particle Hydrodynamics，简称 SPH）方法中，“邻居搜索”（Neighbor Search）是一个至关重要的计算任务。它直接影响到模拟的效率与精度，尤其在涉及上百万粒子的三维问题中，计算瓶颈往往出现在如何高效查找每个粒子周围的邻居上。

由于 SPH 是一种无网格方法，天然适合处理自由表面、大变形和断裂等复杂物理现象，因此被广泛应用于天体物理、流体力学、固体力学等领域。我主要从事小行星撞击问题的数值模拟研究，并开发了一套针对该问题的 SPH 代码。虽然不同领域在实现细节上存在差异，但“邻居搜索”作为核心模块，其数学模型相对简单，却几乎在所有 SPH 实现中都不可或缺。

本文旨在系统介绍 SPH 中邻居搜索的常见算法、性能优化方法，以及在 CUDA 等并行计算平台上的实现，作为我个人学习与研究的记录，同时希望对同领域的研究者提供参考。

首先给出 SPH 粒子邻居搜索的抽象数学问题：设在三维空间中存在 $ N $ 个粒子，每个粒子的位置已知，记为 $ \mathbf{x}_i $，每个粒子有一个核长度（smoothing length）$ h_i $。我们需要找到每个粒子 $ i $ 的邻居粒子集合 $ j $，使得满足以下条件：

\[ \|\mathbf{x}_i - \mathbf{x}_j\| < f(h_i, h_j) \]

其中，函数 $ f(h_i, h_j) $ 用于定义粒子间的交互距离，其常见定义包括：

$ f(h_i, h_j) = \eta \cdot \frac{1}{2}(h_i + h_j) $
$ f(h_i, h_j) = \eta \cdot \min(h_i, h_j) $
$ f(h_i, h_j) = \eta \cdot \max(h_i, h_j) $

这里，$ \eta $ 是一个无量纲系数，称为核支持半径因子（kernel support radius factor），通常取值在 $ [1.2, 2.5] $ 之间，用于控制粒子的影响范围（本文取2）。

在邻居搜索中，常见的方法包括：

暴力搜索（Brute Force）：简单可靠，但时间复杂度高（$O(N^2)$），在大规模问题中效率低下；
链表搜索（Linked-Cell/Grid-based）：通过空间划分显著减少搜索粒子数，是实际中常用的高效方法；
树搜索（如 Octree 或 KD-tree）：适合不均匀粒子分布，尤其适用于天体物理模拟中的自适应精度问题，良好的树代码具有非常高的鲁棒性。如果要考虑自引力，那么树搜索是效率和精度都不错的选择。

本文将以暴力搜索作为结果基线，重点介绍如何高效实现链表搜索和树搜索，并比较它们在实际 SPH 模拟中的性能表现。

1. 链表搜索（Linked-Cell/Grid-based）

在光滑长度为空间常量的情况下，也即所有粒子的$ h_i $都相等，应用链表搜索法非常有效。Monaghan 和 Gingold(1983)提出，可以通过对粒子的空间区域划分网格，记录每个网格内的粒子编号。这样在搜索粒子的邻居时，只需要遍历当前粒子网格的邻居网格内的粒子即可。此方法在传统SPH代码中使用非常多，如Monaghan(1985)，Rhoades(1992)，Simpson(1995)等。

在实现链表算法时，要在问题域上铺设一临时网格。网格单元的空间大小应选取与支持域的空间大小一致。若光滑函数支持域的计量尺度为 $ \eta h $，则网格单元的尺度也必须设置为 $ \eta h $。那么，对于给定的粒子i，其相邻粒子只能在同一网格单元内，或者在紧密相邻的单元内。所以，当 $ \eta = 2 $ 时，在一维、二维和三维空间里的搜索范围分别是在 3,9,27 个单元内。链表搜索法将每个粒子都分布在网格单元内，并通过简单的存储规则将每个网格内的所有粒子连接起来。若每个单元内的平均粒子数量足够小，则链表搜索法的复杂度阶数为 $ O(N) $。

链表搜索法存在的问题是，当光滑长度可变时，尤其是模拟分辨率变化的问题时，网格空间就不能适应每一个粒子，此时若再应用链表搜索法，则搜索效率会很低。除此之外，该方法在CUDA上实现时，需要对显存分配进行小心处理，不然很容易占用超大显存（主要在存储网格粒子编号时）。下面首先就光滑长度为空间常量的情况下进行代码说明。

光滑长度为空间常量的链表搜索

我们先来看链表搜索算法的基础版本。实现该算法需要两个步骤：

记录每个网格单元中包含哪些粒子，并记录每个粒子所属的单元；
遍历所有粒子，对每个粒子的单元及其邻接单元进行扫描，查找可能的邻居粒子。

为了提高效率，本文只展示核函数的编写，且不在每次调用中反复申请或释放内存。

第一个核函数较为简单，其用于构建粒子与网格单元之间的映射关系。

核函数声明与粒子网格索引计算

下面是用于建立粒子与网格单元之间映射关系的 CUDA 核函数 particleLoop，以及配套的粒子网格索引计算函数 particleGridIndex。本版本假设所有粒子的核长度 $h$ 是一个常量，记为 h[0]。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57


#define DIM 3 // 空间维度：可设为 1, 2 或 3
#define MAX_PARTICLES_PER_GRID 200 // 每个网格单元最多可容纳的粒子数
#define eta 2 // 核长度比例因子

// CUDA 核函数：构建每个粒子所属网格，以及每个网格中的粒子列表
__global__ void particleLoop(
 const double *x, // 粒子 x 坐标，长度为 numParticles
 const double minx, // x 方向最小坐标
 const int nx, // x 方向网格数 = ceil((maxx - minx) / (η * h))
#if DIM > 1
 const double *y, // 粒子 y 坐标
 const double miny,
 const int ny,
#endif
#if DIM > 2 
 const double *z, // 粒子 z 坐标
 const double minz,
 const int nz,
#endif
 const double *h, // 每个粒子的核长度（此版本为常量）
 int *gridParticlesList, // 网格中粒子索引列表，大小为 numGrids * MAX_PARTICLES_PER_GRID 无须初始化
 int *gridWritingPointer, // 为避免数据竞争，使用一个gridWritingPointer来记录写入位置，长度为numGrids，需要初始化为0
 int *particleGridList, // 每个粒子所属网格索引，长度为 numParticles
 int numParticles, // 粒子总数
 int numGrids // 网格总数
) {
 int tid = threadIdx.x + blockIdx.x * blockDim.x;
 if (tid >= numParticles) return;

 // 计算粒子在网格中的索引坐标
 int ix = int((x[tid] - minx) / (h[0])*eta); // η = 2
#if DIM > 1
 int iy = int((y[tid] - miny) / (h[0])*eta);
#else
 int iy = 0;
#endif
#if DIM > 2
 int iz = int((z[tid] - minz) / (h[0])*eta);
#else
 int iz = 0;
#endif

 // 获取粒子所在网格的线性索引
 int gridIndex;
#if DIM == 1
 gridIndex = ix;
#elif DIM == 2
 gridIndex = ix + iy * nx;
#else // DIM == 3
 gridIndex = ix + iy * nx + iz * nx * ny;
#endif
 particleGridList[tid] = gridIndex;

 // 获取当前网格的gridWritingPointer位置
 int writingPointer = atomicAdd(&gridWritingPointer[gridIndex], 1); // atomicAdd返回写入位置
 gridParticlesList[gridIndex * MAX_PARTICLES_PER_GRID + writingPointer] = tid;
}

使用上述函数时要注意，当网格个数很多时，容易超过int的表达范围。此外，前置条件是需要知道最小和最大的粒子坐标，长数组求最大最小值可以使用scan算法，以后有空也会介绍此类算法。

至此，我们已经建立了空间粒子与网格之间的联系，现在可以遍历粒子，获取他们的邻居粒子。我目前想到两种遍历方法，1. 按粒子顺序遍历（下面称A1） 2. 按网格顺序遍历（下面称A1）。

搜索

按粒子顺序遍历(A1)

首先来看第一个遍历方法：按粒子顺序遍历(A1)。事实上

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64


#define MAX_NEIGHBORS 200 // 每个粒子最多的邻居数

__global__ void neighborSearchByParticles(
 const double *x, const double *y, const double *z,
 const double *h,
 const int *gridParticlesList, // 网格中粒子索引
 const int *gridWritingPointer, // 每个网格中的粒子数量（已由atomicAdd更新）
 const int *particleGridList, // 每个粒子所在网格索引
 const double minx, const double miny, const double minz,
 const int nx, const int ny, const int nz,
 int *neighborList, // 输出：每个粒子的邻居列表，大小为 numParticles * MAX_NEIGHBORS
 int *neighborCount, // 输出：每个粒子的邻居数
 int numParticles
) {
 int tid = threadIdx.x + blockIdx.x * blockDim.x;
 if (tid >= numParticles) return;

 double xi = x[tid], yi = y[tid], zi = z[tid];
 double hi = h[0];
 double hi2 = hi * hi;
 int gridIndex = particleGridList[tid];

 // 计算该粒子所在网格的坐标索引
 int ix = gridIndex % nx;
 int iy = (gridIndex / nx) % ny;
 int iz = gridIndex / (nx * ny);

 int count = 0;

 // 遍历该粒子所在网格及其周围 3x3x3 网格
 for (int dx = -1; dx <= 1; ++dx) {
 int nix = ix + dx;
 if (nix < 0 || nix >= nx) continue;
 for (int dy = -1; dy <= 1; ++dy) {
 int niy = iy + dy;
 if (niy < 0 || niy >= ny) continue;
 for (int dz = -1; dz <= 1; ++dz) {
 int niz = iz + dz;
 if (niz < 0 || niz >= nz) continue;

 // 相邻网格索引
 int neighborGrid = nix + niy * nx + niz * nx * ny;
 int npg = gridWritingPointer[neighborGrid];

 for (int k = 0; k < npg; ++k) {
 int j = gridParticlesList[neighborGrid * MAX_PARTICLES_PER_GRID + k];
 if (j == tid) continue;

 double dx = x[j] - xi;
 double dy = y[j] - yi;
 double dz = z[j] - zi;
 double dist2 = dx*dx + dy*dy + dz*dz;

 if (dist2 < hi2 && count < MAX_NEIGHBORS) {
 neighborList[tid * MAX_NEIGHBORS + count] = j;
 count++;
 }
 }
 }
 }
 }

 neighborCount[tid] = count;
}

事实上，particleGridList 数组是专门为 A1 方案 设计的；而若采用 A2 方案，则无需该数组。

A1 的缺点在于：当粒子在数组中呈随机排布时，线程束（warp）之间对粒子属性和网格数据的访问也将是随机的。在 CUDA 编程中，访存模式对性能影响极大，因此可以预期 A1 的效率不会非常理想。

在一个失眠的深夜，我思考了两个问题：

如何优化 A1 的访存模式？
当粒子的核尺度 $ h $ 相差悬殊（例如在模拟月球遭受小行星撞击时，$h_{min} ≈ 1$，$h_{max} ≈ 500$），如何在链表结构中高效支持如此大的跨度？

关于这两个问题，我各自有一些设想和初步实现，接下来将逐一介绍，并进行测试和分析。

A2：按网格顺序遍历粒子

（此处补充 A2 的实现简介和性能特点。）更多关于树搜索的内容可以参见[树搜索]更多关于树搜索的内容可以参见树搜索.

缺陷

网格搜索我个人感觉效率是比树搜索好的，尤其是当粒子的光滑长度都一致或者差不多的时候。缺点在于，如果粒子在空间中分散的非常广泛，比如撞击引起的dust喷发。这会导致网格数量激增，显存很快就会用光，导致计算失败。因此网格搜索还是适合模拟空间分布稳定的问题，比如溃坝。

SPH基础(三): 树结构邻居搜索

plloningye@gmail.com (Keqi Ye) — Mon, 12 May 2025 00:00:00 +0000

树结构（基于根据 Burtscher 和 Pingali 的研究）

本文将介绍广泛用于 SPH 代码和 N 体模拟中的树结构（Tree Structure）。这种数据结构主要应用于以下两个核心问题：

1. 粒子领域搜索（Neighbor Search）

在 SPH（光滑粒子流体力学）模拟中，每个粒子需要在核尺度 $ h $ 范围内查找邻居粒子，以便计算密度、压强梯度、粘性等物理量。树结构能够加速邻域搜索，尤其适用于粒子分布高度非均匀的情形。

2. 自引力计算（Self-Gravity Computation）

在引力主导的粒子系统（如星系模拟、星体碰撞）中，粒子间存在万有引力作用。直接计算所有粒子对的引力开销为 $ \mathcal{O}(N^2) $，不可接受。基于树的近似方法（如 Barnes-Hut 算法）可将计算复杂度降至 $ \mathcal{O}(N \log N) $，同时保持较高精度。

接下来的章节将分别介绍树结构在上述两个问题中的构建方法、搜索策略和性能优化。

关于传统的 链表法（Linked-List） 粒子领域搜索，请参考我另一篇博文： 👉 使用链表进行 SPH 邻域搜索

实现步骤

根据相关文献，每次执行自引力计算或粒子邻域搜索时，通常需要以下四个步骤：

确定粒子空间范围
统计所有粒子的空间边界，获取 $ x_{\min}, x_{\max}, y_{\min}, y_{\max}, z_{\min}, z_{\max} $，用于初始化树结构的根节点或空间划分范围。
构建树结构
将粒子递归划分到空间树节点中，常用的数据结构包括八叉树（Octree）或 KD 树。每个叶子节点包含若干粒子或达到最小划分条件。
粒子空间排序
对粒子进行 Morton 编码（Z-order curve）或 Hilbert 曲线编码，并按照空间位置排序，便于缓存一致性和后续并行处理。
树遍历计算
遍历树结构：
- 若执行 自引力计算，使用 Barnes-Hut 近似规则判断是否聚合节点质量；
- 若执行 邻域搜索，在每个节点中判断与查询粒子的距离是否小于核尺度 $ h $，从而筛选可能邻居。

确定粒子空间范围

直接使用规约算法求最大最小值

构建树结构

由于 GPU 上无法高效实现指针式链表结构，我们使用数组来模拟树的链接关系（例如子节点指针）。假设有一个整型数组 child，其长度远大于粒子总数 numParticles，并初始化为 -1，表示所有节点尚未使用。

区分叶子节点与根节点

在树结构中，如何区分整型数组 child 的某一个位置存储的是 叶子节点（粒子） 还是 根节点 是一个关键问题。

标识方法：

-1：表示该位置为空，未被占用。
-2：表示该位置已被锁定，当前线程正在使用该位置（通常用于进行原子操作）。
-3：表示该位置是一个节点，每个节点一定会有子树（可能是子节点，也可能是粒子，粒子的子节点一定为空：-1）。
0 到 numParticles - 1：表示粒子，每个位置对应一个粒子。

显然，如果第 i 个位置被锁定，那么：

在三维情况下，8*i+1+0 到 7（即一个八岔树及其子树等）都被锁定；
在二维情况下，4*i+1+0 到 3（即一个四岔树及其子树等）都被锁定；
在一维情况下，i 及其相邻部分也会被锁定。

注意，任意索引i的子节点计算方法为：8*i+1+0，与传统的八叉树计算方法不同，这是因为我的代码中，0节点保存的是最大的根节点信息。

– 这意味着，如果一个位置被锁定，其他线程将无法访问该位置的子树或其子树的子树，确保了并行计算中节点及其相关子节点的安全。

使用原子操作同步线程

当多个线程并发地尝试访问同一个子节点槽位时，可以使用 CUDA 提供的原子操作 atomicCAS（Compare And Swap）来进行线程间同步。

以下是原子操作的代码示例：

1

int re = atomicCAS(&child[p], -1, -2); // 尝试占用 child[p]

该操作的含义是：

若 child[p] == -1：表示该槽位尚未被占用，当前线程成功将其原子地设置为 -2，表示“锁定中”或“准备插入”；
若 child[p] != -1：说明该槽位已被其他线程占用或已被插入，当前线程需退出或重试；
返回值 re：表示操作前的旧值。如果 re == -1，则说明当前线程成功锁定了该节点。如果 re != -1 ，则 atomicCAS 函数发现比较不成立，直接返回了旧值，也不会替换-2而打乱child数组内容。

写到这里，树结构数组child的构建就很容易了。下面是伪代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175


#define childListIndex(nodeIdx, childNum) ((nodeIdx) * TREETYPE + 1 + (childNum))

#define EMPTY -1
#define LOCKED -2
#define TRUE 1
#define FALSE 0
#define NODE -3

//RealType4 是 float4 或 double4 的别名，我这样写是为了区分单双精度计算，众所周知，消费级显卡的双精度计算能力比较差。。
//粒子的w分量存放了质量，节点的w分量存放了节点半径（正方体的边长的一半）。
//目前还没有添加节点质心的计算逻辑，后续会加，用于计算粒子的引力，参考：
//A hierarchical O(N log N) force-calculation algorithm 本文发表在nature上，顶礼膜拜


__global__ void buildTreeKernel(SPHState *deviceP, treeData *tree)
{
 // 为避免混淆，明确区分粒子和节点的位置数组
 RealType4 *particlePositions = deviceP->positions;
 volatile RealType4 *nodePositions = tree->positions;
 RealType4 *nodeRoot = tree->nodeRoot;
 volatile int *childList = tree->childList;
 int childListLength = tree->childListLength;
 int numParticles = tree->numParticles;
 int inc = blockDim.x * gridDim.x;
 int i = threadIdx.x + blockIdx.x * blockDim.x;
 int k;
 int childIndex, child;
 int lockedIndex;
 RealType x, y, z;
 RealType rootRadius = nodeRoot->w;
 RealType rootX = nodeRoot->x;
 RealType rootY = nodeRoot->y;
 RealType rootZ = nodeRoot->z;

 // 添加跟踪当前节点位置的变量
 RealType currentX, currentY, currentZ, currentR;

 int depth = 0;
 int isNewParticle = TRUE;
 int currentNodeIndex;
 bool isInsert;

 while (i < numParticles)
 {
 isInsert = false;
 while (!isInsert)
 {
 RealType4 pos = particlePositions[i];
 depth = 0;
 x = pos.x;
 y = pos.y;
 z = pos.z;

 // 开始于根节点（索引0）
 currentNodeIndex = 0;
 currentX = rootX;
 currentY = rootY;
 currentZ = rootZ;
 currentR = rootRadius;

 childIndex = 0;
 if (x > currentX)
 childIndex = 1;
 if (y > currentY)
 childIndex += 2;
 if (z > currentZ)
 childIndex += 4;

 // 跟随路径到叶节点
 currentNodeIndex = childListIndex(currentNodeIndex, childIndex);
 currentR *= 0.5;
 currentX += ((childIndex & 1) ? currentR : -currentR);
 currentY += ((childIndex & 2) ? currentR : -currentR);
 currentZ += ((childIndex & 4) ? currentR : -currentR);
 child = childList[currentNodeIndex];
 depth++;
 //下面这个while循环是为了寻找叶子节点
 while (child == NODE)
 {
 // 确定在新节点中的子节点索引
 childIndex = 0;
 if (x > currentX)
 childIndex = 1;
 if (y > currentY)
 childIndex += 2;
 if (z > currentZ)
 childIndex += 4;

 // 跟随路径到叶节点
 currentNodeIndex = childListIndex(currentNodeIndex, childIndex);
 currentR *= 0.5;
 currentX += ((childIndex & 1) ? currentR : -currentR);
 currentY += ((childIndex & 2) ? currentR : -currentR);
 currentZ += ((childIndex & 4) ? currentR : -currentR);
 child = childList[currentNodeIndex];
 depth++;
 }

 // 插入粒子到当前节点的子节点
 //三种情况：
 //1.当前叶子节点被占用，那么重试
 //2.当前叶子节点为空，这是最简单的情况，直接插入即可
 //3.当前叶子节点被粒子占用，本线程读取old节点信息，对他们两个节点进行细分，直到他们被分属到不同的象限
 if (child != LOCKED)
 {
 lockedIndex = currentNodeIndex;
 if (child == atomicCAS((int *)&childList[lockedIndex], child, LOCKED))
 {
 if (child == EMPTY)
 {
 // 直接插入粒子
 childList[lockedIndex] = i;
 isInsert = true;
 }
 else
 {
 //此处处理两个节点细分的情形
 。。。。。。
 //这个循环尝试细分，直到他们俩被分开到不同的象限
 do
 {
 // 确定已存在粒子在新节点中的位置
 int childNewIndex = 0;
 if (oldParPos.x > currentX)
 childNewIndex = 1;
 if (oldParPos.y > currentY)
 childNewIndex += 2;
 if (oldParPos.z > currentZ)
 childNewIndex += 4;

 // 确定当前粒子在新节点中的位置
 int currentNewIndex = 0;
 if (x > currentX)
 currentNewIndex = 1;
 if (y > currentY)
 currentNewIndex += 2;
 if (z > currentZ)
 currentNewIndex += 4;

 if (childNewIndex != currentNewIndex)
 {
 // 两个粒子在不同子节点，可以插入
 childList[childListIndex(currentNodeIndex, childNewIndex)] = child;
 childList[childListIndex(currentNodeIndex, currentNewIndex)] = i;
 isInsert = true;
 break; // 退出循环
 }
 else
 {
 // 仍在同一子节点，需要继续细分
 // 注意每次细分都会创建新节点，需要保存节点的包围盒信息 用于领域搜索
 // // 写入新节点的中心和半径
 nodePositions[currentNodeIndex].x = currentX;
 nodePositions[currentNodeIndex].y = currentY;
 nodePositions[currentNodeIndex].z = currentZ;
 nodePositions[currentNodeIndex].w = currentR;
 childList[currentNodeIndex] = NODE;
 // 内存同步，保证所有线程都可以看到有新的节点被写入了
 __threadfence();
 }

 } while (true);

 // 确保所有子树的写入完成
 __threadfence();
 //释放锁
 childList[lockedIndex] = NODE;
 }

 i += inc;
 }
 }
 }
 }
}

当前实现的局限性

虽然稀疏树在数据结构上直观且灵活，但在并行构建和 GPU 加速场景下，它仍然存在一些明显的局限：

节点访问不连续：稀疏树的节点在内存中通常分散存放，导致 GPU 在并行访问时频繁出现非连续内存读取，影响带宽利用率。
显存需求高：由于稀疏树存储方式不连续，GPU 在构建和查询过程中需要额外的显存来管理指针和节点结构，这使得在大规模数据下显存压力大，很容易超过显存限制。

为了解决这些问题，我们提出了 稠密存储的并行树构建方案。该方案将树节点连续存储在内存中，并结合优化的并行算法，使 GPU 能够高效地访问数据，从而显著提升构建速度和查询性能。同时，稠密存储方案能够更合理地利用显存，降低显存占用，提高处理大规模数据的能力。

更多关于实现细节和性能优化的方法，可以参考：基于稠密存储的并行树构建。

[1] Burtscher, Martin, and Keshav Pingali. “An efficient CUDA implementation of the tree-based barnes hut n-body algorithm.” GPU computing Gems Emerald edition. Morgan Kaufmann, 2011. 75-92.

title: 基于稠密存储的并行树构建实现方案 description: date: 2025-08-15 slug: dense-tree-build categories: - 并行计算 - 树结构 - CUDA draft: false

基于稠密存储的并行树构建实现方案

引言

在空间划分与邻域搜索等算法中，树形数据结构（如八叉树、四叉树、Barnes-Hut 树）是高效的加速手段。
构建这类树结构时，存储方式是影响性能与内存效率的关键因素之一。
常见的存储方式有两种：

稀疏存储（Sparse Storage）：为每个节点预留较大索引空间，按需填充，易实现，但会浪费内存。
稠密存储（Dense Storage）：节点存储在连续数组中，按照构建顺序紧密排列，节省内存，但需要额外的管理逻辑。

你之前的实现采用了稀疏存储，在高粒子数时内存占用明显增加。
本文将介绍如何基于稠密存储实现高效的树构建，并给出 CUDA 并行版本的实现思路。

稠密存储的基本思想

稠密存储的目标是：

节点数组紧凑存放，不留大块未使用空间
节点索引直接映射到数组下标
在插入新节点时，通过一个全局 maxNodeIndex 递减分配新位置

这种方法类似“倒着分配”节点空间：

1

[粒子0] [粒子1] ... [粒子N-1] [内部节点M] [内部节点M-1] ...

其中：

0 ~ numParticles-1 区间存放叶子节点（粒子）
numParticles ~ maxNodeIndex-1 区间存放内部节点

数据结构设计

在稠密存储中，核心数据结构通常包括：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


// 粒子数据
struct Particles {
 double *x, *y, *z; // 坐标
 double *m; // 质量
 double *ax, *ay, *az; // 加速度
 int *depth; // 树深度
};

// 树节点信息
struct Tree {
 volatile double *x, *y, *z; // 节点中心
 volatile double *m; // 节点半径（或质量等）
 int *childList; // 存储子节点索引
 int maxNodeIndex; // 当前可分配的最大索引（递减）
};

关键点：childList 是一维数组，通过 childListIndex(nodeIndex, childSlot) 映射到节点的第几个子节点位置。这样存储方式天然紧凑。

构建流程详解

稠密存储的构建逻辑如下：

初始化根节点
- 根节点索引为 numNodes-1（数组末尾）
- 保存中心坐标和半径
遍历粒子（并行）
- 每个线程处理多个粒子，步长为 blockDim.x * gridDim.x
- 缓存粒子坐标，加速比较
下行查找插入位置
- 从根节点开始，判断粒子属于哪个子象限（八叉树中 0~7）
- 如果子节点是内部节点，继续下行
- 如果子节点是空的，直接插入粒子
- 如果子节点是另一个粒子，创建新的内部节点
创建新内部节点
- 使用 atomicSub 从 maxNodeIndex 分配新的节点索引
- 计算新节点的中心和半径
- 将已有粒子与新粒子分别插入到不同的子槽中
- 如果两者仍落在同一个槽内，继续细分
解锁与同步
- 通过 atomicCAS 实现插入位置的原子锁定
- 使用 __threadfence() 确保内存可见性

核心代码片段

下面是简化版的稠密存储节点分配逻辑：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


if (child == atomicCAS(&childList[lockedIndex], child, LOCKED)) {
 if (child == EMPTY) {
 childList[lockedIndex] = particleIndex;
 } else {
 // 分配新节点
 newNodeIndex = atomicSub(&maxNodeIndex, 1) - 1;
 // 设置新节点中心与半径
 px[newNodeIndex] = currentX - r + dx;
 py[newNodeIndex] = currentY - r + dy;
 pz[newNodeIndex] = currentZ - r + dz;
 pm[newNodeIndex] = r * 0.5;
 // 初始化子节点
 for (int k = 0; k < numChildren; k++) {
 childList[childListIndex(newNodeIndex, k)] = EMPTY;
 }
 // 将旧粒子和新粒子分别放入不同槽
 childList[childListIndex(newNodeIndex, oldChildSlot)] = oldParticle;
 childList[childListIndex(newNodeIndex, newChildSlot)] = newParticle;
 __threadfence();
 childList[lockedIndex] = newNodeIndex;
 }
}

并发与同步

由于多线程同时构建树，必须保证以下两点：

原子操作
- atomicCAS（Compare And Swap）防止多个线程同时插入同一位置
- atomicSub 分配新节点索引
内存同步
- __threadfence() 确保其他线程能看到已更新的节点数据

注意：稠密存储的节点数组在分配时是倒着使用的，所以不会和粒子索引冲突。

性能分析与优化建议

优点：

内存占用大幅减少（只存实际存在的节点）
索引紧凑，缓存命中率高
遍历效率提升

缺点：

节点分配依赖 atomicSub，在极高并发下可能成为瓶颈
实现复杂度高于稀疏存储

优化方向：

批量分配节点索引，减少 atomicSub 次数
合并锁与节点写入步骤，减少原子操作冲突
在共享内存中缓存部分子节点

总结与应用场景

稠密存储特别适合：

粒子数量大、空间分布均匀的模拟（如 SPH、N-body）
对内存占用敏感的 GPU 应用
需要频繁重建树结构的实时计算

与稀疏存储相比，稠密存储在 GPU 环境下通常能获得更高的性能与更低的内存消耗，尤其是在节点数量接近粒子数量时优势明显。

参考实现：本文的构建思路源自 CUDA 并行 Barnes-Hut 树构建的常见模式，并结合了你的原始代码进行稠密化处理。

[向量加法] LeetGPU 第一题详解 - 基础 CUDA 核函数与性能分析

plloningye@gmail.com (Keqi Ye) — Thu, 22 May 2025 00:00:00 +0000

写在前面

本系列是 LeetGPU 平台的刷题记录，每道题我会给出从基础实现到优化的完整思路。如果你是 CUDA 新手，建议先掌握以下基础知识：

CUDA 核函数编写（__global__）
线程层次结构（Grid / Block / Thread）
显存分配与传递

题目描述

给定两个浮点数组 A 和 B，将它们对应位置的元素相加，结果存入数组 C 中。数学表达式为：

$$ C_i = A_i + B_i \quad (i = 0, 1, 2, \dots, N-1) $$

输入输出

输入：设备指针 A, B 和数据规模 N
输出：设备指针 C

解法 v0：基础实现

1
2
3
4
5


__global__ void vector_add_v0(const float* A, const float* B, float* C, int N) {
 int idx = blockDim.x * blockIdx.x + threadIdx.x;
 if (idx < N)
 C[idx] = A[idx] + B[idx];
}

代码解读

每个线程处理一个元素的加法运算
使用一维线程块布局：blockDim.x * blockIdx.x + threadIdx.x 计算全局索引
边界检查 if (idx < N) 防止越界访问

性能特点

优点	缺点
实现简洁，易于理解	网格配置与数据规模强绑定
天然并行，无数据依赖	盲目启动海量线程增加调度开销
合并访存，连续线程访问连续显存

优化1：跨步循环（Grid-Stride Loop）

v0 的问题在于网格配置与数据规模强绑定。为了达到最佳 Occupancy，我们通常希望根据设备 SM 数量固定启动线程数。跨步循环完美解耦了两者：

1
2
3
4
5
6


__global__ void vector_add_v1(const float* A, const float* B, float* C, int N) {
 int idx = blockDim.x * blockIdx.x + threadIdx.x;
 int step = blockDim.x * gridDim.x; // 所有线程总数
 for (int i = idx; i < N; i += step)
 C[i] = A[i] + B[i];
}

核心思想

每个线程处理多个数据，步长 = 总线程数
任意启动配置都能处理全部数据
甚至可以退化为 <<<1, 1>>> 串行执行

优化2：向量化读取

进一步减少循环开销，一次处理 4 个元素：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


__global__ void vector_add_v2(const float* A, const float* B, float* C, int N) {
 int idx = blockDim.x * blockIdx.x + threadIdx.x;
 int step = blockDim.x * gridDim.x;
 const float4* a4 = (const float4*)A;
 const float4* b4 = (const float4*)B;
 float4* c4 = (float4*)C;
 int N4 = N / 4;

 for (int i = idx; i < N4; i += step) {
 float4 at = a4[i];
 float4 bt = b4[i];
 c4[i] = make_float4(at.x + bt.x, at.y + bt.y, at.z + bt.z, at.w + bt.w);
 }

 // 处理尾部剩余元素
 int tail = 4 * N4;
 for (int i = idx + tail; i < N; i += step)
 C[i] = A[i] + B[i];
}

性能提升

v1 中处理 4 个元素需要 4 次循环、4 次边界判断、4 次步长累加。v2 只需 1 次循环，大幅减轻 ALU 和指令发射器的负担。

性能对比

N = (1 « 28) + 3

版本	执行总指令数	相对v0指令变化
v0	268,435,456	100% (基准)
v1	139,657,216	减少48%
v2	48,758,784	减少82%

由于该核函数完全受访存带宽限制，总指令数降低对执行时间无明显提升。但对于计算密集型核函数，v2 预期能带来显著性能提升。

小结

本题是 GPU 并行计算的入门级题目，关键要点：

索引计算 — 掌握一维线程索引 mapping
边界检查 — 防止越界访问
合并访问 — 连续线程访问连续内存
跨步循环 — 解耦网格配置与数据规模
向量化 — 减少循环开销