One global atomicAdd per element versus one per block

Both kernels below compute the same correct sum over a large array using one thread per element, launched with many blocks. Which is faster at scale, and why?

kernel.cu
// Kernel A: every thread atomics directly into one global counter
__global__ void sumGlobalAtomic(float* result, const float* data, int n) {
    int i = blockIdx.x * blockDim.x + threadIdx.x;
    if (i < n) atomicAdd(result, data[i]);
}

// Kernel B: block-level shared-memory reduction, one atomic per block
__global__ void sumHierarchical(float* result, const float* data, int n) {
    __shared__ float partial;
    if (threadIdx.x == 0) partial = 0.0f;
    __syncthreads();
    int i = blockIdx.x * blockDim.x + threadIdx.x;
    float v = (i < n) ? data[i] : 0.0f;
    atomicAdd(&partial, v);         // fast, block-local shared-memory atomic
    __syncthreads();
    if (threadIdx.x == 0) atomicAdd(result, partial);   // one global atomic per block
}

16 of 46 in GPU / CUDA