Memory management 是否可以在CUDA设备上定义全局内存阵列？

I tr分配cuda全局内存阵列。求和的核心是：

__device__ float R_d = 0;
__global__ void perform_summation(float* A, int N){
    int idx = blockDim.x*blockIdx.x+threadIdx.x;
    extern __shared__ float sharedArray [];
    float result[]; //THIS IS THE THING i TRIED TO CREATE
    if(idx < N){
        sharedArray[threadIdx.x] = A[idx];
        //  }else{
        //      sharedArray[threadIdx.x] = 0 ;
        //  }

        for (unsigned int stride = 1; stride < blockDim.x; stride *= 2) {
            __syncthreads();
            if(threadIdx.x % (2*stride) == 0){
                sharedArray[threadIdx.x]+=sharedArray[threadIdx.x+stride];
            }
        }
    }
    if(idx % blockDim.x == 0){
//      R_d += sharedArray[threadIdx.x];
        result[blockIdx.x] = sharedArray[threadIdx.x];
    }
    for (int i = 0; i < gridDim.x; ++i) {
        R_d += result[i];
    }
}

---

所以我有两个问题。对于我提出的第一个解决方案，如何在设备内存中定义全局内存数组？对于第二个解决方案，是否有只使用

R\u d

变量的解决方案？

您可以通过

但是您不想在内核中这样做，您需要在调用内核并将指针传递到内核之前这样做

至于减价，看一下，它解释得很好。基本上，这取决于您使用了多少块和线程。假设有几个街区。因此，在共享内存中定义一个数组：

__shared__ float cache[BLOCK_THREADS];

共享内存分配给每个块，因此我们将每个块中的值相加到

缓存中的第一个元素

__syncthreads();

int step = (BLOCK_THREADS >> 1); //the same result as BLOCK_THREADS/2
while(step > 0) {
    if (threadInBlock < step) {
        cache[threadInBlock] += cache[threadInBlock + step];
    }
    __syncthreads();
    step = (step >> 1);
}

请注意，
result
是指向全局内存中单个值的指针。还要注意的是，只有当
BLOCK\u THREADS
是2的幂时，这才有效，这是很常见的，因为每个块的线程数应该是32的倍数（与扭曲对齐）。
R\u d甚至在任何地方都没有定义。如果您要发布代码，至少要确保它能够编译。就目前而言，这段代码完全是胡说八道。你说得对，我只是更新了上面的代码
__shared__ float cache[BLOCK_THREADS];

__syncthreads();

int step = (BLOCK_THREADS >> 1); //the same result as BLOCK_THREADS/2
while(step > 0) {
    if (threadInBlock < step) {
        cache[threadInBlock] += cache[threadInBlock + step];
    }
    __syncthreads();
    step = (step >> 1);
}

__syncthreads();
if (threadInBlock == 0) {
    atomicAdd(result, cache[0]);
}