CUDA实现计算向量的欧氏距离的课程报告，报告格式要求：1.实验目的，2实验准备，3实验内容，4实验代码，5实验总结

实验报告：CUDA实现计算向量的欧氏距离

1. 实验目的

本实验旨在学习如何使用CUDA进行并行计算，并通过实现计算向量的欧氏距离的程序来深入理解CUDA的使用。

2. 实验准备

在进行本实验之前，需要具备以下基础知识：

- C/C++编程语言基础
- CUDA编程基础
- 线性代数基础

需要准备的软件和硬件：

- CUDA开发环境
- NVIDIA显卡

3. 实验内容

本实验的主要目标是实现计算向量的欧氏距离的程序。具体步骤如下：

3.1 数据初始化

首先，我们需要生成两个随机向量，每个向量有n个元素。

// 初始化向量
void init_vector(float *a, float *b, int n) {
    for (int i = 0; i < n; i++) {
        a[i] = static_cast<float>(rand()) / RAND_MAX;
        b[i] = static_cast<float>(rand()) / RAND_MAX;
    }
}

3.2 串行计算欧氏距离

接下来，我们先使用串行的方式计算欧氏距离，作为CUDA程序的基准。

// 计算欧氏距离（串行）
float euclidean_distance_serial(float *a, float *b, int n) {
    float sum = 0;
    for (int i = 0; i < n; i++) {
        float diff = a[i] - b[i];
        sum += diff * diff;
    }
    return sqrtf(sum);
}

3.3 CUDA并行计算欧氏距离

接下来，我们使用CUDA并行计算欧氏距离。首先，我们需要在GPU上分配内存，并将数据从主机内存复制到GPU内存。

// 计算欧氏距离（CUDA并行）
float euclidean_distance_cuda(float *a, float *b, int n) {
    float *d_a, *d_b;
    cudaMalloc(&d_a, n * sizeof(float));
    cudaMalloc(&d_b, n * sizeof(float));

    cudaMemcpy(d_a, a, n * sizeof(float), cudaMemcpyHostToDevice);
    cudaMemcpy(d_b, b, n * sizeof(float), cudaMemcpyHostToDevice);

    // ...
}

然后，我们需要编写CUDA核函数来进行并行计算。在本实验中，我们使用每个线程计算一部分元素的方式来并行计算欧氏距离。

__global__ void euclidean_distance_kernel(float *a, float *b, float *c, int n) {
    int i = blockIdx.x * blockDim.x + threadIdx.x;
    int stride = blockDim.x * gridDim.x;

    float sum = 0;
    for (int j = i; j < n; j += stride) {
        float diff = a[j] - b[j];
        sum += diff * diff;
    }

    // 使用原子操作进行求和
    atomicAdd(&c[0], sum);
}

最后，我们需要在主机上调用CUDA核函数，并将结果从GPU内存复制回主机内存。

// 计算欧氏距离（CUDA并行）
float euclidean_distance_cuda(float *a, float *b, int n) {
    float *d_a, *d_b, *d_c;
    cudaMalloc(&d_a, n * sizeof(float));
    cudaMalloc(&d_b, n * sizeof(float));
    cudaMalloc(&d_c, sizeof(float));

    cudaMemcpy(d_a, a, n * sizeof(float), cudaMemcpyHostToDevice);
    cudaMemcpy(d_b, b, n * sizeof(float), cudaMemcpyHostToDevice);

    int blockSize = 256;
    int numBlocks = (n + blockSize - 1) / blockSize;
    euclidean_distance_kernel<<<numBlocks, blockSize>>>(d_a, d_b, d_c, n);

    float c;
    cudaMemcpy(&c, d_c, sizeof(float), cudaMemcpyDeviceToHost);

    cudaFree(d_a);
    cudaFree(d_b);
    cudaFree(d_c);

    return sqrtf(c);
}

4. 实验代码

完整的程序代码如下：

#include <iostream>
#include <cstdlib>
#include <cmath>

__global__ void euclidean_distance_kernel(float *a, float *b, float *c, int n) {
    int i = blockIdx.x * blockDim.x + threadIdx.x;
    int stride = blockDim.x * gridDim.x;

    float sum = 0;
    for (int j = i; j < n; j += stride) {
        float diff = a[j] - b[j];
        sum += diff * diff;
    }

    // 使用原子操作进行求和
    atomicAdd(&c[0], sum);
}

float euclidean_distance_serial(float *a, float *b, int n) {
    float sum = 0;
    for (int i = 0; i < n; i++) {
        float diff = a[i] - b[i];
        sum += diff * diff;
    }
    return sqrtf(sum);
}

float euclidean_distance_cuda(float *a, float *b, int n) {
    float *d_a, *d_b, *d_c;
    cudaMalloc(&d_a, n * sizeof(float));
    cudaMalloc(&d_b, n * sizeof(float));
    cudaMalloc(&d_c, sizeof(float));

    cudaMemcpy(d_a, a, n * sizeof(float), cudaMemcpyHostToDevice);
    cudaMemcpy(d_b, b, n * sizeof(float), cudaMemcpyHostToDevice);

    int blockSize = 256;
    int numBlocks = (n + blockSize - 1) / blockSize;
    euclidean_distance_kernel<<<numBlocks, blockSize>>>(d_a, d_b, d_c, n);

    float c;
    cudaMemcpy(&c, d_c, sizeof(float), cudaMemcpyDeviceToHost);

    cudaFree(d_a);
    cudaFree(d_b);
    cudaFree(d_c);

    return sqrtf(c);
}

void init_vector(float *a, float *b, int n) {
    for (int i = 0; i < n; i++) {
        a[i] = static_cast<float>(rand()) / RAND_MAX;
        b[i] = static_cast<float>(rand()) / RAND_MAX;
    }
}

int main() {
    srand(0);

    const int n = 100000000;
    float *a = new float[n];
    float *b = new float[n];

    init_vector(a, b, n);

    // 串行计算欧氏距离
    float distance_serial = euclidean_distance_serial(a, b, n);
    std::cout << "Distance (serial): " << distance_serial << std::endl;

    // CUDA并行计算欧氏距离
    float distance_cuda = euclidean_distance_cuda(a, b, n);
    std::cout << "Distance (CUDA): " << distance_cuda << std::endl;

    delete[] a;
    delete[] b;

    return 0;
}

5. 实验总结

本实验通过实现计算向量的欧氏距离的程序，深入理解了使用CUDA进行并行计算的方法。通过串行计算和CUDA并行计算的比较，我们可以看到CUDA并行计算的速度要远远快于串行计算。这说明在需要进行大规模并行计算时，使用CUDA可以大大提高计算效率。