引言：为什么选择 CMake 管理 CUDA 项目

在现代高性能计算领域，CUDA（Compute Unified Device Architecture）是 NVIDIA 推出的并行计算平台和编程模型。然而，随着项目规模的扩大，手动编写 Makefile 或使用简单的编译命令变得难以维护。CMake 作为跨平台的构建系统生成器，能够完美解决这一痛点。

核心优势：

• 跨平台兼容性：一套配置文件可在 Linux、Windows、macOS 上运行
• 依赖管理：自动查找 CUDA 工具包和相关库
• 构建灵活性：支持 Debug/Release 模式、不同计算能力（Compute Capability）的 GPU 架构
• IDE 集成：生成 Visual Studio、CLion、VSCode 等 IDE 的项目文件

第一章：环境准备与基础配置

1.1 必需软件安装

在开始之前，确保系统已安装以下组件：

# Ubuntu/Debian 示例 sudo apt update sudo apt install build-essential cmake # 验证 CUDA 安装 nvcc --version # 应显示 CUDA Toolkit 版本信息 # 检查 GPU 是否支持 CUDA nvidia-smi # 显示 GPU 驱动和 CUDA 版本 

版本兼容性建议：

• CUDA Toolkit: 11.0 或更高版本（推荐 12.x）
• CMake: 3.18+（支持 enable_language(CUDA)）
• GCC/G++: 与 CUDA 版本兼容（参考 NVIDIA 官方文档）

1.2 最简单的 CUDA CMake 项目结构

创建一个名为 cuda_project 的目录，结构如下：

cuda_project/ ├── CMakeLists.txt ├── src/ │ └── main.cu └── include/ └── utils.h 

1.2.1 基础 CMakeLists.txt

cmake_minimum_required(VERSION 3.18) project(CudaProject LANGUAGES CXX CUDA) # 设置 C++ 标准 set(CMAKE_CXX_STANDARD 17) set(CMAKE_CXX_STANDARD_REQUIRED ON) # 查找 CUDA 工具包 find_package(CUDAToolkit REQUIRED) # 添加可执行文件 add_executable(main src/main.cu) # 链接 CUDA 库（如果需要） target_link_libraries(main PRIVATE CUDA::cudart) 

1.2.2 main.cu 文件内容

#include <iostream> #include <cuda_runtime.h> // CUDA 核函数：在 GPU 上并行执行 __global__ void vectorAdd(float *a, float *b, float *c, int n) { int i = blockIdx.x * blockDim.x + threadIdx.x; if (i < n) { c[i] = a[i] + b[i]; } } // 主机代码：在 CPU 上执行 int main() { const int N = 1024; size_t size = N * sizeof(float); // 分配主机内存 float *h_a = new float[N]; float *h_b = new float[N]; float *h_c = new float[N]; // 初始化数据 for (int i = 0; i < N; i++) { h_a[i] = i * 1.0f; h_b[i] = i * 2.0f; } // 分配设备内存 float *d_a, *d_b, *d_c; cudaMalloc(&d_a, size); cudaMalloc(&d_b, size); cudaMalloc(&d_c, size); // 从主机复制到设备 cudaMemcpy(d_a, h_a, size, cudaMemcpyHostToDevice); cudaMemcpy(d_b, h_b, size, cudaMemcpyHostToDevice); // 定义线程块和网格大小 int threadsPerBlock = 256; int blocksPerGrid = (N + threadsPerBlock - 1) / threadsPerBlock; // 启动核函数 vectorAdd<<<blocksPerGrid, threadsPerBlock>>>(d_a, d_b, d_c, N); // 从设备复制回主机 cudaMemcpy(h_c, d_c, size, cudaMemcpyDeviceToHost); // 验证结果 bool success = true; for (int i = 0; i < 10; i++) { float expected = h_a[i] + h_b[i]; if (fabs(h_c[i] - expected) > 1e-5) { success = false; break; } } std::cout << "计算结果: " << (success ? "成功" : "失败") << std::0 << std::endl; // 释放内存 cudaFree(d_a); cudaFree(d_b); cudaFree(d_c); delete[] h_a; delete[] h_b; delete[] h_c; return 0; } 

1.2.3 编译与运行

# 创建构建目录 mkdir build && cd build # 配置项目 cmake .. # 编译 make -j$(nproc) # 运行 ./main 

预期输出：

计算结果: 成功 

第二章：CMake 与 CUDA 高级配置

2.1 指定 GPU 计算能力（Compute Capability）

计算能力决定了 GPU 架构版本，直接影响性能。常见 GPU 的计算能力：

• RTX 4090: 8.9
• RTX 3080: 8.6
• Tesla V100: 7.0
• Tesla P100: 6.0

在 CMake 中设置：

# 方法一：通过 CMAKE_CUDA_ARCHITECTURES（推荐） set(CMAKE_CUDA_ARCHITECTURES "7.5;8.6;8.9") # 方法二：通过 nvcc 标志（传统方式） set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -gencode arch=compute_75,code=sm_75") set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -gencode arch=compute_86,code=sm_86") 

自动检测当前 GPU 架构：

# 在 CMakeLists.txt 中添加 if(NOT DEFINED CMAKE_CUDA_ARCHITECTURES) execute_process( COMMAND nvidia-smi --query-gpu=compute_cap --format=csv,noheader OUTPUT_VARIABLE GPU_COMPUTE_CAP OUTPUT_STRIP_TRAILING_WHITESPACE ) # 移除小数点（如 8.6 -> 86） string(REPLACE "." "" GPU_ARCH "${GPU_COMPUTE_CAP}") set(CMAKE_CUDA_ARCHITECTURES "${GPU_ARCH}") message(STATUS "自动检测 GPU 架构: ${GPU_ARCH}") endif() 

2.2 优化编译标志

# Debug 模式：包含调试信息，禁用优化 set(CMAKE_CUDA_FLAGS_DEBUG "-G -O0 -g -lineinfo") # Release 模式：最高优化级别 set(CMAKE_CUDA_FLAGS_RELEASE "-O3 -use_fast_math --ptxas-options=-v") # RelWithDebInfo 模式：平衡优化与调试 set(CMAKE_CUDA_FLAGS_RELWITHDEBINFO "-O2 -g -lineinfo") # 生成 PTX 中间代码（便于未来架构兼容） set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -ptx") 

2.3 分离主机与设备代码编译

对于大型项目，建议将 .cu 文件拆分为：

• .cu：包含 __global__ 核函数的文件（必须用 nvcc 编译）
• .cpp：纯主机代码（可用 g++/clang++ 编译）
• .cuh：CUDA 头文件（包含核函数声明）

CMake 配置：

# 主机源文件（用 C++ 编译器） set(HOST_SOURCES src/host_main.cpp src/host_utils.cpp ) # 设备源文件（用 nvcc 编译） set(DEVICE_SOURCES src/kernels.cu src/memory.cu ) # 分别编译 add_library(host_lib ${HOST_SOURCES}) add_library(device_lib ${DEVICE_SOURCES}) # 链接 target_link_libraries(main PRIVATE host_lib device_lib CUDA::cudart) 

第三章：多文件项目结构与依赖管理

3.1 推荐的项目结构

project/ ├── CMakeLists.txt ├── src/ │ ├── main.cpp # 主机入口 │ ├── kernels.cu # 核函数定义 │ ├── memory.cu # 内存管理 │ └── utils.cpp # 辅助函数 ├── include/ │ ├── kernels.cuh # 核函数声明 │ ├── memory.h # 内存管理接口 │ └── utils.h # 工具函数 ├── tests/ │ └── test_kernels.cu └── third_party/ └── some_lib/ 

3.2 完整的 CMakeLists.txt 示例

cmake_minimum_required(VERSION 3.20) project(HighPerformanceCUDA LANGUAGES CXX CUDA) # === 1. 项目配置 === set(CMAKE_CXX_STANDARD 17) set(CMAKE_CXX_STANDARD_REQUIRED ON) set(CMAKE_CUDA_STANDARD 17) set(CMAKE_CUDA_STANDARD_REQUIRED ON) # 设置 GPU 架构（根据你的 GPU 调整） set(CMAKE_CUDA_ARCHITECTURES "7.5;8.6") # === 2. 查找依赖 === find_package(CUDAToolkit REQUIRED) # 如果使用第三方库（如 OpenCV） find_package(OpenCV REQUIRED) # === 3. 包含目录 === include_directories( ${PROJECT_SOURCE_DIR}/include ${CUDAToolkit_INCLUDE_DIRS} ${OpenCV_INCLUDE_DIRS} ) # === 4. 源文件 === set(SOURCES src/main.cpp src/kernels.cu src/memory.cu src/utils.cpp ) # === 5. 创建可执行文件 === add_executable(cuda_app ${SOURCES}) # === 6. 链接库 === target_link_libraries(cuda_app PRIVATE CUDA::cudart # CUDA 运行时库 CUDA::cuda_driver # CUDA 驱动 API ${OpenCV_LIBS} # OpenCV 库 pthread # 多线程支持 ) # === 7. 编译选项 === target_compile_options(cuda_app PRIVATE $<$<COMPILE_LANGUAGE:CUDA>: --ptxas-options=-v # 显示寄存器使用情况 -lineinfo # 生成行号信息 > ) # === 8. 安装规则 === install(TARGETS cuda_app RUNTIME DESTINATION bin LIBRARY DESTINATION lib ARCHIVE DESTINATION lib ) # === 10. 测试（可选） === enable_testing() add_executable(test_kernels tests/test_kernels.cu) target_link_libraries(test_kernels PRIVATE CUDA::cudart) add_test(NAME KernelTests COMMAND test_kernels) 

3.3 头文件示例

include/kernels.cuh:

#pragma once #include <cuda_runtime.h> // 核函数声明（必须在 .cuh 中） __global__ void vectorAdd(float *a, float *b, float *c, int n); __global__ void matrixMultiply(float *A, float *B, float *C, int M, int N, int K); // 设备函数声明（__device__） __device__ float deviceHelper(float x); 

src/kernels.cu:

#include "kernels.cuh" __global__ void vectorAdd(float *a, float *b, float *c, int n) { int i = blockIdx.x * blockDim.x + threadIdx.x; if (i < n) { c[i] = a[i] + b[i]; } } __device__ float deviceHelper(float x) { return x * x + 2.0f * x + 1.0f; } __global__ void matrixMultiply(float *A, float *B, float *C, int M, int N, int K) { // 矩阵乘法实现（省略具体代码） } 

第四章：性能优化与高级技巧

4.1 内存优化策略

4.1.1 统一内存（Unified Memory）

CUDA 6.0 引入的统一内存允许 CPU 和 GPU 共享同一块内存，简化编程模型。

# 在 CMake 中启用统一内存支持 set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda") 

代码示例：

// 使用 cudaMallocManaged 分配统一内存 float *data; cudaMallocManaged(&data, N * sizeof(float)); // CPU 和 GPU 都可以直接访问 // CPU 写入 for (int i = 0; cudaMemPrefetchAsync(data, size, cudaCpuDeviceId); i < N; i++) { data[i] = i; } // GPU 访问前预取 cudaMemPrefetchAsync(data, size, deviceId); // GPU 核函数调用 kernel<<<...>>>(data, N); // CPU 读取结果（自动同步） cudaMemPrefetchAsync(data, size, cudaCpuDeviceId); 

4.1.2 零拷贝内存（Zero-Copy）

对于小数据量或频繁 CPU-GPU 交互的场景：

// 分配锁页内存（Pinned Memory） float *h_data; cudaHostAlloc(&h_data, size, cudaHostAllocDefault); // 直接 GPU 访问（无需显式复制） kernel<<<...>>>(h_data, N); // 同步 cudaDeviceSynchronize(); 

4.2 并行策略优化

4.2.1 动态并行（Dynamic Parallelism）

允许 GPU 核函数启动新的核函数：

__global__ void parent_kernel(int depth) { if (depth > 0) { // 子核函数 parent_kernel<<<1, 1>>>(depth - 1); } } 

CMake 配置：

set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --cudart static") 

4.2.2 流（Streams）与异步执行

// 创建多个流 cudaStream_t stream1, stream2; cudaStreamCreate(&stream1); cudaStreamCreate(&stream2); // 异步数据传输与计算重叠 cudaMemcpyAsync(d_a, h_a, size, cudaMemcpyHostToDevice, stream1); kernel<<<blocks, threads, 0, stream1>>>(d_a, d_b, d_c, N); cudaMemcpyAsync(h_c, d_c, size, cudaMemcpyDeviceToHost, stream1); // 流间同步 cudaStreamSynchronize(stream1); cudaStreamDestroy(stream1); 

4.3 性能分析工具集成

4.3.1 Nsight Systems

在 CMake 中添加分析目标：

# 添加分析目标 add_custom_target(profile COMMAND nsys profile --stats=true ./cuda_app DEPENDS cuda_app WORKING_DIRECTORY ${CMAKE_BINARY_DIR} ) 

4.3.2 Nsight Compute

# 添加内核分析目标 add_custom_target(analyze_kernel COMMAND nv-nsight-cu-cli --set full ./cuda_app DEPENDS cuda_app ) 

第五章：实战案例 - 高性能图像卷积

5.1 项目需求

实现一个高性能的图像卷积算子，支持：

• 任意尺寸图像
• 任意卷积核（3x3, 5x5, 7x7）
• 多流并行处理
• 性能分析

5.2 完整实现

5.2.1 CMakeLists.txt

cmake_minimum_required(VERSION 3.20) project(ImageConvolution LANGUAGES CXX CUDA) set(CMAKE_CUDA_ARCHITECTURES "7.5;8.6") set(CMAKE_CXX_STANDARD 17) find_package(CUDAToolkit REQUIRED) find_package(OpenCV REQUIRED) # 用于图像 I/O # 包含目录 include_directories(include ${OpenCV_INCLUDE_DIRS}) # 源文件 set(SOURCES src/main.cpp src/convolution.cu src/image_loader.cpp ) add_executable(convolution_app ${SOURCES}) target_link_libraries(convolution_app PRIVATE CUDA::cudart ${OpenCV_LIBS} ) # 性能优化标志 target_compile_options(convolution_app PRIVATE $<$<COMPILE_LANGUAGE:CUDA>: -O3 --use_fast_math -lineinfo -Xcompiler -fopenmp > ) 

5.2.2 核函数实现（src/convolution.cu）

#include "convolution.cuh" #include <cuda_runtime.h> // 2D 纹理内存用于边界处理 texture<uchar, 2, cudaReadModeElementType> texRef; // 基础卷积核（全局内存） __global__ void convolution2DGlobal( const uchar* input, uchar* output, const float* kernel, int kernelSize, int width, int height) { int x = blockIdx.x * blockDim.x + threadIdx.x; int y = blockIdx.y * blockDim.y + threadIdx.y; if (x >= width || y >= height) return; float sum = 0.0f; int half = kernelSize / 2; // 手动边界检查 for (int ky = -half; ky <= half; ky++) { for (int kx = -half; kx <= half; kx++) { int px = min(max(x + kx, 0), width - 1); int py = min(max(y + ky, 0), height - 1); sum += input[py * width + px] * kernel[(ky + half) * kernelSize + (kx + half)]; } } output[y * width + x] = (uchar)min(max(sum, 0.0f), 255.0f); } // 使用共享内存优化（块内数据重用） __global__ void convolution2DShared( const uchar* input, uchar* output, const float* kernel, int kernelSize, int width, int height) { // 共享内存声明 __shared__ uchar tile[32 + 6][32 + 6]; // 假设 3x3 核 int x = blockIdx.x * blockDim.x + threadIdx.x; int y = blockIdx.y * blockDim.y + threadIdx.y; // 线程在块内的局部坐标 int lx = threadIdx.x; int ly = threadIdx.y; // 加载数据到共享内存（包括 halo 区域） // ...（详细实现略） __syncthreads(); // 计算卷积（访问共享内存） // ...（详细实现略） } // 使用纹理内存优化（自动边界处理） __global__ void convolution2DTexture( uchar* output, const float* kernel, int kernelSize, int width, int height) { int x = blockIdx.x * blockDim.x + threadIdx.x; int y = blockIdx.y * blockDim.y + threadIdx.y; if (x >= width || y >= height) return; float sum = 0.0f; int half = kernelSize / 2; // 纹理内存自动处理边界和插值 for (int ky = -half; ky <= half; ky++) { for (int kx = -half; kx <= half; kx++) { sum += tex2D(texRef, x + kx + 0.5f, y + ky + 0.5f) * kernel[(ky + half) * kernelSize + (kx + half)]; } } output[y * width + x] = (uchar)min(max(sum, 0.0f), 255.0f); } 

5.2.3 主机代码（src/main.cpp）

#include <iostream> #include <vector> #include <chrono> #include "convolution.cuh" #include "image_loader.h" int main(int argc, char** argv) { if (argc < 2) { std::cerr << "Usage: " << argv[0] << " <image_path>" << std::endl; return 1; } // 1. 加载图像 cv::Mat h_image = cv::imread(argv[1], cv::IMREAD_GRAYSCALE); if (h_image.empty()) { std::cerr << "Failed to load image" << std::endl; return 1; } int width = h_image.cols; int height = h_image.rows; size_t size = width * height * sizeof(uchar); // 2. 准备卷积核（高斯模糊） const int kernelSize = 5; std::vector<float> h_kernel(kernelSize * kernelSize, 0.0f); // 填充高斯核值... h_kernel[12] = 1.0f; // 简化示例 // 3. 分配 GPU 内存 uchar *d_input, *d_output; float *d_kernel; cudaMalloc(&d_input, size); cudaMalloc(&d_output, size); cudaMalloc(&d_kernel, h_kernel.size() * sizeof(float)); // 4. 异步数据传输 cudaStream_t stream; cudaStreamCreate(&stream); auto start = std::chrono::high_resolution_clock::now(); cudaMemcpyAsync(d_input, h_image.data, size, cudaMemcpyHostToDevice, stream); cudaMemcpyAsync(d_kernel, h_kernel.data(), h_kernel.size() * sizeof(float), cudaMemcpyHostToDevice, stream); // 5. 配置执行参数 dim3 threads(16, 16); dim3 blocks((width + threads.x - 1) / threads.x, (height + threads.y - 1) / threads.y); // 6. 执行卷积 convolution2DGlobal<<<blocks, threads, 0, stream>>>( d_input, d_output, d_kernel, kernelSize, width, height); // 7. 异步回传 cv::Mat h_output(height, width, CV_8UC1); cudaMemcpyAsync(h_output.data, d_output, size, cudaMemcpyDeviceToHost, stream); // 8. 同步并计时 cudaStreamSynchronize(stream); auto end = std::chrono::high_resolution_clock::now(); auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start); std::cout << "处理时间: " << duration.count() << " ms" << std::endl; // 9. 保存结果 cv::imwrite("output.jpg", h_output); // 10. 清理 cudaFree(d_input); cudaFree(d_output); cudaFree(d_kernel); cudaStreamDestroy(stream); return 0; } 

5.2.4 编译与运行

# 编译 mkdir build && cd build cmake -DCMAKE_BUILD_TYPE=Release .. make -j$(nproc) # 运行（需要测试图像） ./convolution_app test.jpg # 性能分析 make profile # 执行 Nsight Systems 分析 

第六章：调试与错误处理

6.1 CUDA 错误检查宏

在头文件中定义：

// include/cuda_error.h #pragma once #include <iostream> #include <cuda_runtime.h> #define CHECK_CUDA(call) do { cudaError_t err = call; if (err != cudaSuccess) { std::cerr << "CUDA Error: " << cudaGetErrorString(err) << " at " << __FILE__ << ":" << __LINE__ << std::endl; exit(EXIT_FAILURE); } } while(0) #define CHECK_KERNEL() CHECK_CUDA(cudaGetLastError()) 

使用示例：

CHECK_CUDA(cudaMalloc(&d_ptr, size)); kernel<<<blocks, threads>>>(d_ptr); CHECK_KERNEL(); // 检查核函数启动错误 CHECK_CUDA(cudaMemcpy(...)); 

6.2 CMake 中的调试配置

# Debug 模式下启用 GPU 调试 if(CMAKE_BUILD_TYPE STREQUAL "Debug") set(CMAKE_CUDA_FLAGS_DEBUG "-G -O0 -g -Xcompiler -rdynamic") # 链接 CUDA 调试库 target_link_libraries(cuda_app PRIVATE CUDA::cudart_debug) endif() 

6.3 常见错误与解决方案

第七章：CMake 与现代 CUDA 特性

7.1 CUDA 11+ 新特性支持

7.1.1 异步数据拷贝（CUDA 11+）

# 需要 CUDA 11.0+ set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --extended-lambda") 

代码：

// 使用 cudaMemcpyAsync 的新参数 cudaMemcpyAsync(d_ptr, h_ptr, size, cudaMemcpyHostToDevice, stream, cudaMemcpyDevToDev); // 新增参数 

7.1.2 CUDA Graph API

// 创建执行图 cudaGraph_t graph; cudaGraphCreate(&graph, 0); // 添加节点 cudaGraphNode_t memcpyNode, kernelNode; // ... 配置节点 cudaGraphLaunch(graph, stream); // 一次性启动整个图 

CMake 配置：

set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --cudart static") 

7.2 与 C++20 协程集成（实验性）

set(CMAKE_CXX_STANDARD 20) set(CMAKE_CUDA_STANDARD 17) # CUDA 仍支持 C++17 # 需要 CUDA 12.0+ 和支持 C++20 的编译器 

第八章：生产环境部署

8.1 Docker 容器化部署

Dockerfile:

FROM nvidia/cuda:12.2.0-devel-ubuntu22.04 # 安装 CMake 和依赖 RUN apt-get update && apt-get install -y cmake build-essential libopencv-dev && rm -rf /var/lib/apt/lists/* # 复制源代码 WORKDIR /app COPY . . # 构建 RUN mkdir build && cd build && cmake -DCMAKE_BUILD_TYPE=Release .. && make -j$(nproc) # 运行 CMD ["./build/convolution_app", "input.jpg"] 

8.2 交叉编译

# 为 Jetson Nano 编译（ARM64 + CUDA） cmake -DCMAKE_SYSTEM_NAME=Linux -DCMAKE_SYSTEM_PROCESSOR=aarch64 -DCMAKE_CUDA_ARCHITECTURES=5.3 -DCMAKE_CXX_COMPILER=aarch64-linux-gnu-g++ .. 

8.3 性能基准测试

# 添加性能测试目标 add_custom_target(benchmark COMMAND ./convolution_app benchmark_images/*.jpg COMMAND python3 ${PROJECT_SOURCE_DIR}/scripts/analyze_results.py DEPENDS convolution_app ) 

第九章：常见问题解答（FAQ）

Q1: 如何处理不同 GPU 架构的兼容性？

A: 使用 CMAKE_CUDA_ARCHITECTURES 生成多架构二进制：

set(CMAKE_CUDA_ARCHITECTURES "7.5;8.6;8.9") # 生成多架构支持 

Q2: 为什么我的核函数比 CPU 慢？

A: 可能原因：

1. 数据量太小（GPU 并行优势无法发挥）
2. 内存带宽瓶颈
3. 核函数内分支过多
4. 未正确设置线程块大小

解决方案： 使用 Nsight Compute 分析内核性能。

Q3: 如何在 CMake 中同时编译主机和设备代码？

A: 使用 enable_language(CUDA) 后，CMake 会自动识别 .cu 文件并使用 nvcc 编译，.cpp 文件使用 C++ 编译器。

Q4: 如何链接静态 CUDA 库？

A:

set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --cudart static") target_link_libraries(app PRIVATE CUDA::cudart_static) 

第十章：总结与最佳实践

10.1 核心要点回顾

1. 始终使用 find_package(CUDAToolkit) 而不是硬编码路径
2. 明确指定 GPU 架构 以避免运行时错误
3. 分离主机与设备代码 提高可维护性
4. 使用异步执行和流 重叠计算与通信
5. 集成性能分析工具 持续优化

10.2 性能检查清单

• [ ] 是否使用了合适的线程块大小（通常是 256 或 512）？
• [ ] 是否启用了快速数学库（--use_fast_math）？
• [ ] 是否使用了共享内存减少全局内存访问？
• [ ] 是否使用了异步数据传输？
• [ ] 是否针对目标 GPU 架构进行了优化？

10.3 推荐资源

• 官方文档: NVIDIA CUDA Toolkit Documentation
• CMake CUDA 支持: CMake CUDA Language Support
• 性能优化: CUDA C++ Best Practices Guide
• Nsight Tools: NVIDIA Developer Tools

附录：完整 CMake 模板

# === CMakeLists.txt 模板 === cmake_minimum_required(VERSION 3.20) project(MyCudaProject LANGUAGES CXX CUDA) # === 配置 === set(CMAKE_CXX_STANDARD 17) set(CMAKE_CUDA_STANDARD 17) set(CMAKE_CUDA_ARCHITECTURES "7.5;8.6" CACHE STRING "CUDA 架构") # === 构建类型 === if(NOT CMAKE_BUILD_TYPE) set(CMAKE_BUILD_TYPE Release) endif() # === 优化标志 === set(CMAKE_CUDA_FLAGS_RELEASE "-O3 --use_fast_math -Xcompiler -O3") set(CMAKE_CUDA_FLAGS_DEBUG "-G -O0 -g -Xcompiler -O0") # === 查找依赖 === find_package(CUDAToolkit REQUIRED) # === 源文件 === file(GLOB_RECURSE SOURCES "src/*.cu" "src/*.cpp") file(GLOB_RECURSE HEADERS "include/*.cuh" "include/*.h") # === 目标 === add_executable(${PROJECT_NAME} ${SOURCES} ${HEADERS}) # === 包含目录 === target_include_directories(${PROJECT_NAME} PRIVATE ${PROJECT_SOURCE_DIR}/include ${CUDAToolkit_INCLUDE_DIRS} ) # === 链接库 === target_link_libraries(${PROJECT_NAME} PRIVATE CUDA::cudart CUDA::cuda_driver ) # === 安装 === install(TARGETS ${PROJECT_NAME} DESTINATION bin) 

结语： 通过本文的系统学习，您应该已经掌握了使用 CMake 构建高性能 CUDA 应用的完整流程。从基础配置到高级优化，再到生产部署，每一步都至关重要。记住，性能优化是一个持续的过程，建议定期使用 Nsight 工具分析并迭代改进。祝您在 GPU 加速计算的道路上取得成功！