以下主机代码test.c和设备代码test0.cu的作用相同。
test.c
$ cat test.c
#include <stdio.h>
#include <string.h>
int main()
{
int data[32];
int dummy[32];
for (int i = 0; i < 32; i++)
data[i] = i;
memcpy(dummy, data, sizeof(data));
for (int i = 1; i < 32; i++)
data[i] += dummy[i - 1];
memcpy(dummy, data, sizeof(data));
for (int i = 2; i < 32; i++)
data[i] += dummy[i - 2];
memcpy(dummy, data, sizeof(data));
for (int i = 4; i < 32; i++)
data[i] += dummy[i - 4];
memcpy(dummy, data, sizeof(data));
for (int i = 8; i < 32; i++)
data[i] += dummy[i - 8];
memcpy(dummy, data, sizeof(data));
for (int i = 16; i < 32; i++)
data[i] += dummy[i - 16];
printf("kernel : ");
for (int i = 0; i < 32; i++)
printf("%4i ", data[i]);
printf("\n");
}
$
test0.cu
$ cat test0.cu
#include <stdio.h>
__global__ void kernel0(int *data)
{
size_t t_id = threadIdx.x;
if (1 <= t_id)
data[t_id] += data[t_id - 1];
if (2 <= t_id)
data[t_id] += data[t_id - 2];
if (4 <= t_id)
data[t_id] += data[t_id - 4];
if (8 <= t_id)
data[t_id] += data[t_id - 8];
if (16 <= t_id)
data[t_id] += data[t_id - 16];
}
int main()
{
int data[32];
int result[32];
int *data_d;
cudaMalloc(&data_d, sizeof(data));
for (int i = 0; i < 32; i++)
data[i] = i;
dim3 gridDim(1);
dim3 blockDim(32);
cudaMemcpy(data_d, data, sizeof(data), cudaMemcpyHostToDevice);
kernel0<<<gridDim, blockDim>>>(data_d);
cudaMemcpy(result, data_d, sizeof(data), cudaMemcpyDeviceToHost);
printf("kernel0 : ");
for (int i = 0; i < 32; i++)
printf("%4i ", result[i]);
printf("\n");
}
$
如果我编译并运行它们，它们的结果与我预期的相同。
$ gcc -o test test.c
$ ./test
kernel : 0 1 3 6 10 15 21 28 36 45 55 66 78 91 105 120 136 153 171 190 210 231 253 276 300 325 351 378 406 435 465 496
$ nvcc -o test_dev0 test0.cu
$ ./test_dev0
kernel0 : 0 1 3 6 10 15 21 28 36 45 55 66 78 91 105 120 136 153 171 190 210 231 253 276 300 325 351 378 406 435 465 496
$
但是，如果我在设备代码中使用共享内存而不是全局内存（如test1.cu中那样，则会给出不同的结果。
test1.cu
$ cat test1.cu
#include <stdio.h>
__global__ void kernel1(int *data)
{
__shared__ int data_s[32];
size_t t_id = threadIdx.x;
data_s[t_id] = data[t_id];
if (1 <= t_id)
data_s[t_id] += data_s[t_id - 1];
if (2 <= t_id)
data_s[t_id] += data_s[t_id - 2];
if (4 <= t_id)
data_s[t_id] += data_s[t_id - 4];
if (8 <= t_id)
data_s[t_id] += data_s[t_id - 8];
if (16 <= t_id)
data_s[t_id] += data_s[t_id - 16];
data[t_id] = data_s[t_id];
}
int main()
{
int data[32];
int result[32];
int *data_d;
cudaMalloc(&data_d, sizeof(data));
for (int i = 0; i < 32; i++)
data[i] = i;
dim3 gridDim(1);
dim3 blockDim(32);
cudaMemcpy(data_d, data, sizeof(data), cudaMemcpyHostToDevice);
kernel1<<<gridDim, blockDim>>>(data_d);
cudaMemcpy(result, data_d, sizeof(data), cudaMemcpyDeviceToHost);
printf("kernel1 : ");
for (int i = 0; i < 32; i++)
printf("%4i ", result[i]);
printf("\n");
}
$
如果我编译test1.cu并运行它，它将得到与test0.cu或test.c不同的结果。
$ nvcc -o test_dev1 test1.cu
$ ./test_dev1
kernel1 : 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
$
扭曲同步是否不应该与共享内存一起使用？
对此问题进行一些调查：
使用CUDA8.0时，如果我使用test1.cu选项编译-arch=sm_61（我正在使用GTX 1080进行测试），则其结果与test0.cu和test.c相同
$ nvcc -o test_dev1_arch -arch=sm_61 test1.cu
$ ./test_dev1_arch
kernel1 : 0 1 3 6 10 15 21 28 36 45 55 66 78 91 105 120 136 153 171 190 210 231 253 276 300 325 351 378 406 435 465 496
$
但是，这不适用于较新版本的CUDA。如果我使用的是比8.0更高的版本，则即使我提供了-arch=sm_61选项，测试结果也会有所不同。
答案 0 :(得分：1)
在两种情况下，使用共享内存或全局内存，由于竞争条件，您的设备代码都具有未定义的行为。您有多个线程可以同时读取和修改同一个1024对象。
扭曲同步是否不应该与共享内存一起使用？
我在您的代码中看不到任何扭曲同步。
硬件在锁定步骤中执行扭曲的事实（一开始不一定是正确的）是完全不相关的，因为不是由硬件来读取您的C ++代码。可以使用任何工具链将C ++代码转换为将在硬件上实际运行的机器代码。并且允许C ++编译器根据C ++语言的抽象规则进行优化。
让我们看看为您的示例实际生成的机器代码（在我的机器上使用CUDA 10）：
int如您所见，编译器（在这种特殊情况下，“罪魁祸首”实际上是PTX汇编程序）已将ifs序列转换为一堆指令，这些指令根据if条件设置谓词。它首先使用条件加载从共享内存中将所需的所有值全部提取到寄存器中。只有在此之后，它才会使用已加载的值执行所有加法和条件存储。这是对您的C ++代码的完全合法的解释。由于您没有指定任何同步或内存排序约束，因此编译器可以在没有潜在的并发冲突的前提下进行操作，并且所有这些加载和存储都可以按照其认为合适的方式进行重新排序。
要修复代码，请使用explicit warp synchronization：
_Z7kernel1Pi:
/*0008*/ MOV R1, c[0x0][0x20] ;
/*0010*/ S2R R9, SR_TID.X ;
/*0018*/ SHL R8, R9.reuse, 0x2 ;
/*0028*/ SHR.U32 R0, R9, 0x1e ;
/*0030*/ IADD R2.CC, R8, c[0x0][0x140] ;
/*0038*/ IADD.X R3, R0, c[0x0][0x144] ;
/*0048*/ LDG.E R0, [R2] ;
/*0050*/ ISETP.NE.AND P0, PT, R9.reuse, RZ, PT ;
/*0058*/ ISETP.GE.U32.AND P1, PT, R9, 0x2, PT ;
/*0068*/ @P0 LDS.U.32 R5, [R8+-0x4] ;
/*0070*/ { ISETP.GE.U32.AND P2, PT, R9.reuse, 0x4, PT ;
/*0078*/ @P1 LDS.U.32 R6, [R8+-0x8] }
/*0088*/ ISETP.GE.U32.AND P3, PT, R9, 0x8, PT ;
/*0090*/ @P2 LDS.U.32 R7, [R8+-0x10] ;
/*0098*/ { ISETP.GE.U32.AND P4, PT, R9, 0x10, PT SLOT 0;
/*00a8*/ @P3 LDS.U.32 R9, [R8+-0x20] SLOT 1 }
/*00b0*/ @P4 LDS.U.32 R10, [R8+-0x40] ;
/*00b8*/ { MOV R4, R0 ;
/*00c8*/ STS [R8], R0 }
/*00d0*/ @P0 IADD R5, R4, R5 ;
/*00d8*/ { @P0 MOV R4, R5 ;
/*00e8*/ @P0 STS [R8], R5 }
/*00f0*/ @P1 IADD R6, R4, R6 ;
/*00f8*/ { @P1 MOV R4, R6 ;
/*0108*/ @P1 STS [R8], R6 }
/*0110*/ @P2 IADD R7, R4, R7 ;
/*0118*/ { @P2 MOV R4, R7 ;
/*0128*/ @P2 STS [R8], R7 }
/*0130*/ @P3 IADD R9, R4, R9 ;
/*0138*/ { @P3 MOV R4, R9 ;
/*0148*/ @P3 STS [R8], R9 }
/*0150*/ @P4 IADD R10, R4, R10 ;
/*0158*/ @P4 STS [R8], R10 ;
/*0168*/ @P4 MOV R4, R10 ;
/*0170*/ STG.E [R2], R4 ;
/*0178*/ EXIT ;
.L_1:
/*0188*/ BRA `(.L_1) ;
.L_14:
此问题仅从CUDA 9.0开始体现的原因是，只有在Volta和“独立线程调度”成为必要时，才在CUDA 9.0中真正引入了扭曲级同步。在CUDA 9.0之前，正式不支持翘曲同步编程。但是在像上面的示例中那样实际破坏代码时，编译器曾经相当保守。原因可能是这样的“ warp-synchronous”编程（请注意引号）通常是接近峰值性能的唯一方法，没有真正的选择，因此人们一直在这样做。但是，这仍然是不确定的行为，NVIDIA一直警告我们。它只是在很多情况下才起作用...
答案 1 :(得分：0)
看来，我错过的重点是使用volatile限定符声明共享内存。这解决了问题。 （Test code）
但是，如the answer by Michael Kenzel中所述，即使NVIDIA本身提供的classic parallel reduction(on page 22)中引入了这种隐式扭曲同步编程，也应通常避免。
由于将来的编译器和内存硬件可能会以不同的方式工作，因此依靠它会很危险。使用类似于解决方案provided by Michael Kenzel的__syncwarp()是更好的解决方案。在this NVIDIA dev blog article的帮助下，安全的解决方案将是：
__global__ void kernel(int *data)
{
__shared__ int data_s[32];
size_t t_id = threadIdx.x;
data_s[t_id] = data[t_id];
int v = data_s[t_id];
unsigned mask = 0xffffffff; __syncwarp(mask);
mask = __ballot_sync(0xffffffff, 1 <= t_id);
if (1 <= t_id) {
v += data_s[t_id - 1]; __syncwarp(mask);
data_s[t_id] = v; __syncwarp(mask);
}
mask = __ballot_sync(0xffffffff, 2 <= t_id);
if (2 <= t_id) {
v += data_s[t_id - 2]; __syncwarp(mask);
data_s[t_id] = v; __syncwarp(mask);
}
mask = __ballot_sync(0xffffffff, 4 <= t_id);
if (4 <= t_id) {
v += data_s[t_id - 4]; __syncwarp(mask);
data_s[t_id] = v; __syncwarp(mask);
}
mask = __ballot_sync(0xffffffff, 8 <= t_id);
if (8 <= t_id) {
v += data_s[t_id - 8]; __syncwarp(mask);
data_s[t_id] = v; __syncwarp(mask);
}
mask = __ballot_sync(0xffffffff, 16 <= t_id);
if (16 <= t_id) {
v += data_s[t_id - 16]; __syncwarp(mask);
data_s[t_id] = v;
}
data[t_id] = data_s[t_id];
}