使用cuda编写一个并行化的矩阵相乘代码

以下是一个简单的使用CUDA并行化的矩阵相乘代码：

#include <stdio.h>
#include <cuda_runtime.h>

#define N 1024

__global__ void matrixMultiply(float *a, float *b, float *c) {
    int row = blockIdx.y * blockDim.y + threadIdx.y;
    int col = blockIdx.x * blockDim.x + threadIdx.x;
    float sum = 0.0f;
    for (int i = 0; i < N; i++) {
        sum += a[row * N + i] * b[i * N + col];
    }
    c[row * N + col] = sum;
}

int main() {
    float *a, *b, *c;
    float *d_a, *d_b, *d_c;

    // Allocate memory on host
    a = (float*) malloc(N * N * sizeof(float));
    b = (float*) malloc(N * N * sizeof(float));
    c = (float*) malloc(N * N * sizeof(float));

    // Initialize matrices
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++) {
            a[i * N + j] = i + j;
            b[i * N + j] = i - j;
        }
    }

    // Allocate memory on device
    cudaMalloc(&d_a, N * N * sizeof(float));
    cudaMalloc(&d_b, N * N * sizeof(float));
    cudaMalloc(&d_c, N * N * sizeof(float));

    // Copy matrices from host to device
    cudaMemcpy(d_a, a, N * N * sizeof(float), cudaMemcpyHostToDevice);
    cudaMemcpy(d_b, b, N * N * sizeof(float), cudaMemcpyHostToDevice);

    // Launch kernel
    dim3 dimBlock(16, 16);
    dim3 dimGrid(N / dimBlock.x, N / dimBlock.y);
    matrixMultiply<<<dimGrid, dimBlock>>>(d_a, d_b, d_c);

    // Copy result from device to host
    cudaMemcpy(c, d_c, N * N * sizeof(float), cudaMemcpyDeviceToHost);

    // Print result
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++) {
            printf("%f ", c[i * N + j]);
        }
        printf("\n");
    }

    // Free memory on device
    cudaFree(d_a);
    cudaFree(d_b);
    cudaFree(d_c);

    // Free memory on host
    free(a);
    free(b);
    free(c);

    return 0;
}

该代码将矩阵相乘操作放在一个名为matrixMultiply的CUDA kernel函数中。在主函数中，我们先在主机端分配并初始化矩阵，然后将它们复制到设备端的内存中。在此之后，我们定义了一个二维的网格和一个二维的线程块，以便在设备上运行matrixMultiply函数。最后，我们将结果从设备端内存复制回主机端内存，并打印出结果。

在matrixMultiply函数中，我们使用blockIdx和threadIdx来计算每个线程需要处理的行和列。然后我们遍历矩阵的行和列，计算对应元素的乘积和并将其存储在结果矩阵中。由于每个线程都只计算一个元素，因此该函数可以很容易地在GPU上并行执行