CUDA编程- __syncthreads()函数

基本概念

__syncthreads() 是CUDA编程中非常关键的一个同步原语。它的功能是确保在某个线程块中的所有线程在执行到这个函数之前都已完成它们之前的所有指令。一旦所有线程都到达这个同步点，它们才可以继续执行__syncthreads()之后的指令。这个函数只能在设备代码（如CUDA内核）中使用。

以下是__syncthreads()的几个关键点：

1. 作用域：它只对一个线程块内的线程起作用。换句话说，它只同步调用它的线程块内的线程，而不是整个网格的所有线程。

2. 使用场景：

   • 共享内存的读写：当线程写入共享内存，并且这些数据将被线程块中的其他线程所读取时，通常需要一个__syncthreads()调用来确保写入完成。
   • 避免竞态条件：当线程块内的线程可能同时写入同一个位置（导致不确定的结果）或在其它线程完成某些操作之前需要读取数据时，使用__syncthreads()可以避免这些问题。

3. 注意事项：

   • 不要在分支条件下不均匀地调用：如果线程块中的一些线程调用了__syncthreads()，但其他线程由于某些条件（如if语句）没有调用，那么可能会导致死锁。
   • 不要在循环中过度使用：过度使用__syncthreads()可能会降低性能，因为它会阻止线程并行地执行。

4. 与全局同步：CUDA本身不提供跨线程块的同步机制。为了在全网格范围内实现同步，程序员通常需要结束当前的kernel执行并启动一个新的kernel，因为kernel启动之间存在隐式的全局同步。

为了更好地理解其工作原理，考虑以下情境：假设有一个线程块，其中的线程首先将数据写入共享内存，然后从共享内存中读取数据。为了确保在任何线程尝试读取数据之前所有的写操作都已完成，可以在写操作之后和读操作之前插入一个__syncthreads()调用。这样，当任何线程到达读取步骤时，确保数据已经被正确地写入共享内存中。

示例

下面的例子演示了如何使用__syncthreads()来确保线程块内的线程在读取共享内存之前已经完成了写入。

我们考虑一个简单的情境，即计算线程块内所有线程的数据之和，并将结果存储在共享内存中的第一个位置。

__global__ void sumWithinBlock(float* input, float* output, int n) {
    // 声明共享内存
    __shared__ float sharedData[256]; // 假设我们有256个线程每个线程块

    int tid = threadIdx.x; 
    int globalId = blockIdx.x * blockDim.x + threadIdx.x;

    // 将数据加载到共享内存中
    sharedData[tid] = (globalId < n) ? input[globalId] : 0;

    // 同步确保所有线程已完成写入
    __syncthreads();

    // 下面的代码使用了一个简单的归约模式来求和
    for (int s = blockDim.x / 2; s > 0; s >>= 1) {
        if (tid < s) {
            sharedData[tid] += sharedData[tid + s];
        }
        __syncthreads(); // 再次同步，确保每一步的归约操作已完成
    }

    // 将每个线程块的结果写入输出数组
    if (tid == 0) {
        output[blockIdx.x] = sharedData[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

在上述代码中，我们使用了共享内存来进行数据之和的计算。我们在每次归约操作之后使用了__syncthreads()来确保所有线程在继续下一步之前都已完成其当前步骤。这是必要的，因为在后续的归约步骤中，某些线程可能需要读取其他线程在上一步中写入的数据。归约操作是一种逐步减少数据量的并行计算模式，通过两两合并数据来达到最后的结果。

下面，让我们来详细解析这个归约求和算法：

1. 初始化:

   • 假设我们有一个长度为blockDim.x的数据数组sharedData，该数组已经被加载到共享内存中，每个线程已经加载了它自己的数据到这个数组。这个数组可以表示为 [a, b, c, d, e, f, g, h]，其中每个字母表示一个数据项，由一个线程加载。

2. 归约过程:

   • 初始步骤，s = blockDim.x / 2：这是归约的第一步，我们将数据项的数量减半。在我们的例子中，s = 4（假设blockDim.x为8）。

   • 在第一个迭代中（s = 4），线程0将sharedData[0]和sharedData[4]加在一起，线程1将sharedData[1]和sharedData[5]加在一起，以此类推。此时数组变为：[a+e, b+f, c+g, d+h, e, f, g, h]。请注意，只有前一半的线程（在这种情况下，是前4个线程）参与计算。

   • 之后，__syncthreads()确保所有线程都完成了此步骤。这是必要的，因为我们正在修改sharedData，并且要确保在进行下一步操作之前，所有线程都已经完成了他们的数据更新。

   • 下一次迭代，s减半为2。此时，只有线程0和1是活跃的。线程0将sharedData[0]和sharedData[2]加在一起，线程1将sharedData[1]和sharedData[3]加在一起。此时数组变为：[a+e+c+g, b+f+d+h, c+g, d+h, e, f, g, h]。

   • 再次进行__syncthreads()同步，然后再次减半s。但由于s已经为1，循环结束。

3. 结果:

   • 在上述归约操作完成后，sharedData[0]包含整个数组的总和。

总之，这是一个高效的方法来并行计算数组的总和，因为它充分利用了所有的线程，并且减少了全局内存访问次数，而只使用了共享内存。同时，这也是__syncthreads()在实践中的一个应用示例，确保线程块内的所有线程在继续之前都在同一个同步点。

---

补充

归约（Reduction）是并行计算中的一个常见操作模式，它将一个输入集合的所有元素结合在一起，生成一个单一的输出。简单来说，归约就是把多个值"归"到一个值上。在计算领域中，这通常是通过某种特定的二元操作来完成的，例如加法、乘法、逻辑与、逻辑或等。

以加法为例，对于一个数组[1, 2, 3, 4]，其归约操作（求和）的结果是10。

在并行计算中，执行归约操作的挑战在于高效、并行地处理数据，而不引入竞争条件或其他并发问题。因此，设计一个高效的并行归约算法是非常重要的。

在CUDA中进行归约操作时，常见的模式是如下所示：

1. 线程加载数据：每个线程从全局内存加载数据到共享内存。
2. 层次减少：通过一系列步骤，逐渐减少共享内存中的数据。在每一步中，一半的线程将其值与另一个线程的值相加，并将结果存回共享内存。这就是所谓的"归约"步骤。
3. 同步：在每一步归约操作之后使用__syncthreads()进行同步，确保所有线程都已完成其计算。
4. 结果写回：在完成所有的归约步骤后，一个线程（通常是threadIdx.x == 0）将结果写回到全局内存。

归约的一个关键特性是其结合性。例如，加法是结合的，因为(a + b) + c == a + (b + c)。这使得我们可以在不改变结果的情况下重新排序操作，从而更有效地并行化归约。