GPU编程实战指南04：CUDA编程示例，使用共享内存优化性能

在CUDA编程中，共享内存（Shared Memory） 比 全局内存（Global Memory） 效率高的原因主要与CUDA的硬件架构和内存访问特性密切相关。以下是详细分析：

---

1. CUDA内存层次结构

CUDA设备（GPU）具有多层次的内存架构，主要包括以下几种：

• 寄存器（Registers）：每个线程私有的高速存储单元，速度最快但容量有限。
• 共享内存（Shared Memory）：由同一个线程块（Block）中的所有线程共享，位于片上（On-Chip），速度接近寄存器。
• 全局内存（Global Memory）：位于片外（Off-Chip），供所有线程块访问，容量大但访问延迟高。
• 常量内存（Constant Memory） 和 纹理内存（Texture Memory）：特殊用途的只读内存。

共享内存是CUDA中一种非常重要的资源，其高效性主要体现在以下几个方面。

---

2. 共享内存比全局内存效率高的原理

（1）更低的访问延迟

• 共享内存：位于GPU芯片内部，属于片上存储器（On-Chip Memory）。它的访问延迟通常为几十个时钟周期。
• 全局内存：位于GPU芯片外部，属于片外存储器（Off-Chip Memory）。它的访问延迟通常为几百个甚至上千个时钟周期。

因此，共享内存的访问速度远高于全局内存。

（2）更高的带宽

• 共享内存的带宽通常是全局内存的数十倍。例如，在现代GPU中，共享内存的带宽可以达到数百GB/s，而全局内存的带宽可能只有几十GB/s。
• 高带宽意味着单位时间内可以从共享内存加载或存储更多的数据，从而提高程序的整体性能。

（3）可编程性与数据重用

• 共享内存是由程序员显式管理的，允许程序员控制数据的加载和存储。通过将频繁使用的数据加载到共享内存中，可以在同一线程块内的多个线程之间实现数据重用，避免重复从全局内存加载相同的数据。
• 这种数据重用特性特别适合需要多次访问相同数据的计算任务，例如矩阵乘法、卷积操作等。

（4）提升内存访问的局部性

• CUDA的全局内存访问性能高度依赖于合并访问（Coalesced Access），即相邻线程访问连续的内存地址。如果访问模式不连续，会导致缓存未命中率增加，进一步降低性能。
• 而共享内存允许程序员手动组织数据布局，使得数据访问更加连续，从而优化局部性并减少冲突。

（5）支持高效的并行访问

• 在CUDA中，共享内存允许多个线程同时访问，且不会产生冲突（前提是访问模式合理）。这种并行访问能力进一步提高了效率。
• 例如，在矩阵乘法中，多个线程可以同时从共享内存中读取数据进行计算，而无需等待其他线程完成。

---

3. 实际应用场景中的优化

在CUDA编程中，使用共享内存的主要目的是优化数据访问模式，减少对全局内存的依赖。以下是一些典型的应用场景及其优化原理：

（1）矩阵乘法

• 矩阵乘法是典型的计算密集型任务，涉及大量的数据重用。
• 通过将矩阵分块加载到共享内存中，可以减少对全局内存的访问次数。例如：
  • 将矩阵A的一个子块和矩阵B的一个子块加载到共享内存中。
  • 同一线程块内的所有线程共同计算这些子块的乘积。
  • 重复此过程，直到完成整个矩阵的乘法。

（2）图像卷积

• 图像卷积操作需要对每个像素点周围的邻域进行计算。
• 可以将图像的一部分加载到共享内存中，供多个线程共享使用，从而避免重复从全局内存加载邻域数据。

（3）排序算法

• 在并行排序算法（如快速排序、归并排序）中，可以使用共享内存作为中间存储，减少全局内存的交互。

---

4. 代码示例：矩阵乘法中的共享内存优化

以下是一个简单的矩阵乘法示例，展示如何利用共享内存优化性能：

__global__ void matrixMulSharedMemory(float* A, float* B, float* C, int N) {
    // 定义共享内存
    __shared__ float sharedA[TILE_SIZE][TILE_SIZE];
    __shared__ float sharedB[TILE_SIZE][TILE_SIZE];

    int row = blockIdx.y * blockDim.y + threadIdx.y;
    int col = blockIdx.x * blockDim.x + threadIdx.x;

    float result = 0.0f;

    // 分块计算
    for (int tile = 0; tile < (N + TILE_SIZE - 1) / TILE_SIZE; tile++) {
        // 将数据加载到共享内存中
        if (row < N && tile * TILE_SIZE + threadIdx.x < N)
            sharedA[threadIdx.y][threadIdx.x] = A[row * N + tile * TILE_SIZE + threadIdx.x];
        else
            sharedA[threadIdx.y][threadIdx.x] = 0.0f;

        if (col < N && tile * TILE_SIZE + threadIdx.y < N)
            sharedB[threadIdx.y][threadIdx.x] = B[(tile * TILE_SIZE + threadIdx.y) * N + col];
        else
            sharedB[threadIdx.y][threadIdx.x] = 0.0f;

        __syncthreads();  // 确保所有线程完成加载

        // 计算当前分块的结果
        for (int k = 0; k < TILE_SIZE; k++) {
            result += sharedA[threadIdx.y][k] * sharedB[k][threadIdx.x];
        }

        __syncthreads();  // 确保所有线程完成计算
    }

    // 写回结果到全局内存
    if (row < N && col < N)
        C[row * N + col] = result;
}

关键点分析：

1. 数据加载到共享内存：
   • 将矩阵A和矩阵B的部分数据加载到共享内存sharedA和sharedB中。
   • 减少了对全局内存的访问次数。
2. 数据重用：
   • 同一线程块内的所有线程共享sharedA和sharedB中的数据，避免了重复加载。
3. 同步机制：
   • 使用__syncthreads()确保所有线程完成共享内存的加载和计算后再继续下一步。

---

5. 注意事项

虽然共享内存能显著提高性能，但在使用时需要注意以下几点：

1. 容量限制：
   • 共享内存的容量有限（通常为几十KB到几百KB）。如果数据量过大，可能会导致溢出。
2. 银行冲突（Bank Conflict）：
   • 共享内存被划分为多个存储体（Banks）。如果多个线程同时访问同一个存储体，会导致冲突，降低性能。
   • 解决方法：调整数据布局，使访问模式均匀分布。
3. 编程复杂度：
   • 使用共享内存需要手动管理数据加载和存储，增加了编程复杂度。

---

6. 总结

在CUDA编程中，共享内存比全局内存效率高的核心原因在于其低访问延迟、高带宽、数据重用以及更好的局部性。通过合理利用共享内存，可以显著减少对全局内存的访问次数，优化内存访问模式，从而提高程序的整体性能。

下面是一个矩阵乘法的示例，比较了使用共享内存和使用全局内存两种方式的性能差异：

/*
 * 矩阵乘法性能对比示例
 * 
 * 本程序实现了两种矩阵乘法的方法：
 * 1. 使用全局内存的朴素实现
 *    - 每个线程直接从全局内存读取数据
 *    - 重复访问全局内存，性能较低
 * 
 * 2. 使用共享内存的优化实现
 *    - 将矩阵分块加载到共享内存
 *    - 减少全局内存访问次数
 *    - 提高内存访问效率
 *    - 显著提升计算性能
 */

#include 
#include 
#include 

// 矩阵大小（为简化示例，使用方阵）
#define MATRIX_SIZE 1024
// 每个线程块的大小（二维）
#define BLOCK_SIZE 64

// 检查CUDA错误
void checkCudaError(cudaError_t error, const char* message) {
    if (error != cudaSuccess) {
        fprintf(stderr, "CUDA错误: %s - %s\n", message, cudaGetErrorString(error));
        exit(-1);
    }
}

// 使用全局内存的矩阵乘法核函数
__global__ void matrixMulGlobal(
    const float* A,
    const float* B,
    float* C,
    int size
) {
    // 计算当前线程负责的矩阵C中的元素位置
    int row = blockIdx.y * blockDim.y + threadIdx.y;
    int col = blockIdx.x * blockDim.x + threadIdx.x;

    if (row < size && col < size) {
        float sum = 0.0f;
        // 计算一个元素需要遍历一整行和一整列
        for (int k = 0; k < size; k++) {
            sum += A[row * size + k] * B[k * size + col];
        }
        C[row * size + col] = sum;
    }
}

// 使用共享内存的矩阵乘法核函数
__global__ void matrixMulShared(
    const float* A,
    const float* B,
    float* C,
    int size
) {
    // 声明共享内存，用于存储A和B的子矩阵
    __shared__ float sharedA[BLOCK_SIZE][BLOCK_SIZE];
    __shared__ float sharedB[BLOCK_SIZE][BLOCK_SIZE];

    // 计算线程在全局和块内的位置
    int row = blockIdx.y * blockDim.y + threadIdx.y;
    int col = blockIdx.x * blockDim.x + threadIdx.x;
    int tx = threadIdx.x;
    int ty = threadIdx.y;

    float sum = 0.0f;

    // 分块计算，每次处理BLOCK_SIZE大小的子矩阵
    for (int i = 0; i < (size + BLOCK_SIZE - 1) / BLOCK_SIZE; i++) {
        // 协作加载数据到共享内存
        if (row < size && (i * BLOCK_SIZE + tx) < size) {
            sharedA[ty][tx] = A[row * size + i * BLOCK_SIZE + tx];
        } else {
            sharedA[ty][tx] = 0.0f;
        }
        if (col < size && (i * BLOCK_SIZE + ty) < size) {
            sharedB[ty][tx] = B[(i * BLOCK_SIZE + ty) * size + col];
        } else {
            sharedB[ty][tx] = 0.0f;
        }

        // 确保所有线程都完成数据加载,以确保共享内存加载完成
        __syncthreads();

        // 计算当前子矩阵的点积
        if (row < size && col < size) {
            for (int k = 0; k < BLOCK_SIZE; k++) {
                sum += sharedA[ty][k] * sharedB[k][tx];
            }
        }

        // 同步以确保计算完成后再加载下一块数据
        __syncthreads();
    }

    // 将结果写回全局内存
    if (row < size && col < size) {
        C[row * size + col] = sum;
    }
}

// 初始化矩阵数据
void initMatrix(float* matrix, int size) {
    for (int i = 0; i < size * size; i++) {
        matrix[i] = rand() / (float)RAND_MAX;
    }
}

int main() {
    int size = MATRIX_SIZE;
    size_t matrixBytes = size * size * sizeof(float);

    // 分配主机内存
    float *h_A, *h_B, *h_C1, *h_C2;
    h_A = (float*)malloc(matrixBytes);
    h_B = (float*)malloc(matrixBytes);
    h_C1 = (float*)malloc(matrixBytes);
    h_C2 = (float*)malloc(matrixBytes);

    // 初始化输入矩阵
    printf("正在初始化矩阵数据...\n");
    initMatrix(h_A, size);
    initMatrix(h_B, size);

    // 分配设备内存
    float *d_A, *d_B, *d_C;
    checkCudaError(cudaMalloc((void**)&d_A, matrixBytes), "分配设备内存d_A失败");
    checkCudaError(cudaMalloc((void**)&d_B, matrixBytes), "分配设备内存d_B失败");
    checkCudaError(cudaMalloc((void**)&d_C, matrixBytes), "分配设备内存d_C失败");

    // 将数据复制到设备
    checkCudaError(cudaMemcpy(d_A, h_A, matrixBytes, cudaMemcpyHostToDevice), "复制数据到设备d_A失败");
    checkCudaError(cudaMemcpy(d_B, h_B, matrixBytes, cudaMemcpyHostToDevice), "复制数据到设备d_B失败");

    // 设置网格和块的维度
    dim3 blockDim(BLOCK_SIZE, BLOCK_SIZE);
    dim3 gridDim((size + BLOCK_SIZE - 1) / BLOCK_SIZE, (size + BLOCK_SIZE - 1) / BLOCK_SIZE);

    // 创建CUDA事件用于计时
    cudaEvent_t start, stop;
    cudaEventCreate(&start);
    cudaEventCreate(&stop);
    float elapsedTime;

    // 运行使用全局内存的版本
    printf("\n运行使用全局内存的矩阵乘法...\n");
    cudaEventRecord(start);
    matrixMulGlobal<<>>(d_A, d_B, d_C, size);
    cudaEventRecord(stop);
    cudaEventSynchronize(stop);
    cudaEventElapsedTime(&elapsedTime, start, stop);
    printf("使用全局内存的版本耗时: %.2f ms\n", elapsedTime);

    // 复制结果到主机
    checkCudaError(cudaMemcpy(h_C1, d_C, matrixBytes, cudaMemcpyDeviceToHost), "从设备复制结果失败");

    // 运行使用共享内存的版本
    float elapsedTime1;
    printf("\n运行使用共享内存的矩阵乘法...\n");
    cudaEventRecord(start);
    matrixMulShared<<>>(d_A, d_B, d_C, size);
    cudaEventRecord(stop);
    cudaEventSynchronize(stop);
    cudaEventElapsedTime(&elapsedTime1, start, stop);
    printf("使用共享内存的版本耗时: %.2f ms\n", elapsedTime1);
    printf("加速比: %.2f\n", elapsedTime / elapsedTime1);

    // 复制结果到主机
    checkCudaError(cudaMemcpy(h_C2, d_C, matrixBytes, cudaMemcpyDeviceToHost), "从设备复制结果失败");

    // 验证两种方法的结果是否一致
    bool resultsMatch = true;
    for (int i = 0; i < size * size && resultsMatch; i++) {
        if (fabs(h_C1[i] - h_C2[i]) > 1e-5) {
            resultsMatch = false;
            break;
        }
    }
    printf("\n两种实现的结果%s\n", resultsMatch ? "一致" : "不一致");

    // 清理资源
    cudaFree(d_A);
    cudaFree(d_B);
    cudaFree(d_C);
    cudaEventDestroy(start);
    cudaEventDestroy(stop);
    free(h_A);
    free(h_B);
    free(h_C1);
    free(h_C2);

    return 0;
}

运行结果如下，使用共享内存相较于使用全局内存效率提高了3.69倍：