CUDA C 和 C++ 解释

使用CUDA C和C++进行并行计算

c
#include 
__global__ void vectorAdd(int *a, int *b, int *c, int n) {
    int tid = blockIdx.x * blockDim.x + threadIdx.x;
    if (tid < n) {
        c[tid] = a[tid] + b[tid];
    }
}
int main() {
    int n = 100;
    int *a, *b, *c;
    int *d_a, *d_b, *d_c;
    
    // 分配内存空间
    cudaMalloc((void**)&d_a, n * sizeof(int));
    cudaMalloc((void**)&d_b, n * sizeof(int));
    cudaMalloc((void**)&d_c, n * sizeof(int));
    
    // 初始化输入向量
    a = (int*)malloc(n * sizeof(int));
    b = (int*)malloc(n * sizeof(int));
    c = (int*)malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) {
        a[i] = i;
        b[i] = i;
    }
    
    // 将输入向量复制到GPU内存
    cudaMemcpy(d_a, a, n * sizeof(int), cudaMemcpyHostToDevice);
    cudaMemcpy(d_b, b, n * sizeof(int), cudaMemcpyHostToDevice);
    
    // 启动并行计算
    vectorAdd<<>>(d_a, d_b, d_c, n);
    
    // 将计算结果从GPU内存复制到主机内存
    cudaMemcpy(c, d_c, n * sizeof(int), cudaMemcpyDeviceToHost);
    
    // 打印计算结果
    for (int i = 0; i < n; i++) {
        printf("%d + %d = %d\n", a[i], b[i], c[i]);
    }
    
    // 释放内存空间
    free(a);
    free(b);
    free(c);
    cudaFree(d_a);
    cudaFree(d_b);
    cudaFree(d_c);
    
    return 0;
}

cpp
#include 
__global__ void matrixMul(float *a, float *b, float *c, int n) {
    int row = blockIdx.y * blockDim.y + threadIdx.y;
    int col = blockIdx.x * blockDim.x + threadIdx.x;
    
    if (row < n && col < n) {
        float sum = 0;
        for (int i = 0; i < n; i++) {
            sum += a[row * n + i] * b[i * n + col];
        }
        c[row * n + col] = sum;
    }
}
int main() {
    int n = 4;
    float *a, *b, *c;
    float *d_a, *d_b, *d_c;
    
    // 分配内存空间
    cudaMalloc((void**)&d_a, n * n * sizeof(float));
    cudaMalloc((void**)&d_b, n * n * sizeof(float));
    cudaMalloc((void**)&d_c, n * n * sizeof(float));
    
    // 初始化输入矩阵
    a = new float[n * n];
    b = new float[n * n];
    c = new float[n * n];
    for (int i = 0; i < n * n; i++) {
        a[i] = i;
        b[i] = i;
    }
    
    // 将输入矩阵复制到GPU内存
    cudaMemcpy(d_a, a, n * n * sizeof(float), cudaMemcpyHostToDevice);
    cudaMemcpy(d_b, b, n * n * sizeof(float), cudaMemcpyHostToDevice);
    
    // 启动并行计算
    dim3 grid(1, 1);
    dim3 block(n, n);
    matrixMul<<>>(d_a, d_b, d_c, n);
    
    // 将计算结果从GPU内存复制到主机内存
    cudaMemcpy(c, d_c, n * n * sizeof(float), cudaMemcpyDeviceToHost);
    
    // 打印计算结果
    for (int i = 0; i < n * n; i++) {
        std::cout << c[i] << " ";
        if ((i + 1) % n == 0) {
            std::cout << std::endl;
        }
    }
    
    // 释放内存空间
    delete[] a;
    delete[] b;
    delete[] c;
    cudaFree(d_a);
    cudaFree(d_b);
    cudaFree(d_c);
    
    return 0;
}