并行编程与 GPU 开发环境笔记 + C++（CUDA）示例代码

#include <iostream>
#include <cuda_runtime.h>

// CUDA核函数（设备端执行，GPU上运行）
// __global__：标识核函数，可被CPU调用，在GPU执行
__global__ void hello_cuda() {
    // 线程在块内的ID（x维度）
    int thread_id = threadIdx.x;
    // 块在网格内的ID（x维度）
    int block_id = blockIdx.x;
    // 块的大小（x维度）
    int block_size = blockDim.x;
    // 全局线程ID（唯一标识GPU上的每个线程）
    int global_thread_id = block_id * block_size + thread_id;

    // 每个线程输出信息（SIMD：所有线程执行同一指令，处理不同ID数据）
    printf("Hello from GPU! Block ID: %d, Thread ID in Block: %d, Global Thread ID: %d\n",
           block_id, thread_id, global_thread_id);
}

int main() {
    std::cout << "Hello from CPU! Starting CUDA kernel..." << std::endl;

    // 定义CUDA线程组织：1个网格（grid）包含2个块（block），每个块包含4个线程（thread）
    dim3 block_dim(4);  // 块内线程数：x维度4个
    dim3 grid_dim(2);   // 网格内块数：x维度2个（总线程数=2*4=8）

    // 启动CUDA核函数（<<<网格维度, 块维度>>>）
    hello_cuda<<<grid_dim, block_dim>>>();

    // 等待GPU核函数执行完成（同步CPU和GPU）
    cudaDeviceSynchronize();

    // 检查CUDA错误
    cudaError_t err = cudaGetLastError();
    if (err != cudaSuccess) {
        std::cerr << "CUDA Error: " << cudaGetErrorString(err) << std::endl;
        return 1;
    }

    std::cout << "CUDA kernel executed successfully!" << std::endl;
    return 0;
}

#include <iostream>
#include <vector>
#include <chrono>
#include <cuda_runtime.h>

using namespace std;
using namespace chrono;

// 向量大小（大数据集，体现并行优势）
const int VECTOR_SIZE = 10'000'000;

// CPU串行向量加法
void cpu_vector_add(const vector<float>& a, const vector<float>& b, vector<float>& c) {
    for (int i = 0; i < VECTOR_SIZE; ++i) {
        c[i] = a[i] + b[i];
    }
}

// GPU并行向量加法（CUDA核函数，数据并行）
__global__ void gpu_vector_add(const float* d_a, const float* d_b, float* d_c, int size) {
    // 计算当前线程的全局ID（对应向量索引）
    int idx = blockIdx.x * blockDim.x + threadIdx.x;
    // 避免线程索引超出向量范围
    if (idx < size) {
        d_c[idx] = d_a[idx] + d_b[idx];  // 同一加法操作，处理不同元素（数据并行）
    }
}

int main() {
    // 1. 初始化CPU端向量（主机内存）
    vector<float> h_a(VECTOR_SIZE, 1.0f);  // 向量a全1
    vector<float> h_b(VECTOR_SIZE, 2.0f);  // 向量b全2
    vector<float> h_c_cpu(VECTOR_SIZE, 0.0f);  // CPU结果
    vector<float> h_c_gpu(VECTOR_SIZE, 0.0f);  // GPU结果

    // 2. CPU串行计算（对比基准）
    auto start = high_resolution_clock::now();
    cpu_vector_add(h_a, h_b, h_c_cpu);
    auto cpu_time = duration_cast<milliseconds>(high_resolution_clock::now() - start).count();
    cout << "CPU串行向量加法耗时：" << cpu_time << "ms" << endl;

    // 3. GPU并行计算
    float *d_a, *d_b, *d_c;  // GPU设备内存指针
    // 分配GPU全局内存
    cudaMalloc((void**)&d_a, VECTOR_SIZE * sizeof(float));
    cudaMalloc((void**)&d_b, VECTOR_SIZE * sizeof(float));
    cudaMalloc((void**)&d_c, VECTOR_SIZE * sizeof(float));

    // 从CPU内存拷贝数据到GPU内存（主机→设备）
    cudaMemcpy(d_a, h_a.data(), VECTOR_SIZE * sizeof(float), cudaMemcpyHostToDevice);
    cudaMemcpy(d_b, h_b.data(), VECTOR_SIZE * sizeof(float), cudaMemcpyHostToDevice);

    // 定义CUDA线程组织：块大小=1024（GPU最佳实践），网格大小=ceil(VECTOR_SIZE/1024)
    dim3 block_dim(1024);
    dim3 grid_dim((VECTOR_SIZE + block_dim.x - 1) / block_dim.x);

    // GPU核函数执行（计时：仅计算核函数耗时，排除数据拷贝）
    start = high_resolution_clock::now();
    gpu_vector_add<<<grid_dim, block_dim>>>(d_a, d_b, d_c, VECTOR_SIZE);
    cudaDeviceSynchronize();  // 等待GPU执行完成
    auto gpu_time = duration_cast<milliseconds>(high_resolution_clock::now() - start).count();

    // 从GPU内存拷贝结果到CPU内存（设备→主机）
    cudaMemcpy(h_c_gpu.data(), d_c, VECTOR_SIZE * sizeof(float), cudaMemcpyDeviceToHost);

    // 4. 验证结果正确性（对比前10个元素）
    bool valid = true;
    for (int i = 0; i < 10; ++i) {
        if (abs(h_c_cpu[i] - h_c_gpu[i]) > 1e-5) {
            valid = false;
            break;
        }
    }
    cout << "GPU并行向量加法耗时：" << gpu_time << "ms" << endl;
    cout << "结果验证：" << (valid ? "正确" : "错误") << endl;
    cout << "GPU加速比：" << (double)cpu_time / gpu_time << "x" << endl;

    // 5. 释放GPU内存
    cudaFree(d_a);
    cudaFree(d_b);
    cudaFree(d_c);

    return 0;
}