1、项目  -----> 生成依赖项  ----->  生成自定义，勾选cuda；

2、*.cu文件右键  -----> 属性  -----> 配置属性  -----> 常规  -----> 项类型 改为 cuda c/c++;

3、CUDA C/C++ ---->Device  ----->Code Generatio改 compute_52,sm_52;compute_75,sm_75；

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

// const关键字表明A和B是只读的，不会在函数内部被修改。
// threadIdx.x：这是CUDA内置变量，代表线程在块中的索引（从0开始）。每个线程都有一个唯一的threadIdx.x值。
// blockIdx.x：这是CUDA内置变量，代表块在网格中的索引（从0开始）。每个块都有一个唯一的blockIdx.x值。
// blockDim.x：这是CUDA内置变量，代表块中线程的数量。对于这个例子，blockDim.x被设置为256。
// idx：计算当前线程在整个向量中的位置。通过将线程索引加上块索引乘以块大小，可以确定当前线程需要处理的位置。
__global__ void vector_add(const float* A, const float* B, float* C, int N) {
    // 线程索引：每个线程都有唯一的索引，可通过 threadIdx, blockIdx, 和 blockDim 获取
    int idx = threadIdx.x + blockIdx.x * blockDim.x;
    if (idx < N) {
        C[idx] = A[idx] + B[idx];
    }
}


int main() {
    const int N = 256;
    float h_A[N], h_B[N], h_C[N];
    float* d_A, * d_B, * d_C;

    for (int i = 0; i < N; ++i) {
        h_A[i] = i * 1.0f;
        h_B[i] = i * 2.0f;
    }
    // 分配GPU内存
    size_t size = N * sizeof(float);
    cudaMalloc(&d_A, size);
    cudaMalloc(&d_B, size);
    cudaMalloc(&d_C, size);
    // cpu 拷贝到GPu
    cudaMemcpy(d_A, h_A, size, cudaMemcpyHostToDevice);
    cudaMemcpy(d_B, h_B, size, cudaMemcpyHostToDevice);

    int threadsPerBlock = 256;
    int blocksPerGrid = (N + threadsPerBlock - 1) / threadsPerBlock;
    // blocksPerGrid：表示在网格中使用的线程块数量。blocksPerGrid 的值是 (N + threadsPerBlock - 1) / threadsPerBlock，用于确保所有的元素都能被处理到。
    // threadsPerBlock：表示每个线程块中的线程数。
    vector_add <<<blocksPerGrid, threadsPerBlock >>> (d_A, d_B, d_C, N);

    cudaMemcpy(h_C, d_C, size, cudaMemcpyDeviceToHost);

    for (int i = 0; i < 10; ++i) {
        std::cout << h_C[i] << " ";
    }
    std::cout << std::endl;
     
    cudaFree(d_A);  // 释放指针 d_A 所指向的 GPU 内存。
    cudaFree(d_B);
    cudaFree(d_C);

    return 0;
}