第8板块·第1节：主机与设备内存管理基础与统一内存

学习目标

学完本节你将能够：

• 理解主机内存（Host Memory）与设备内存（Device Memory）的物理分离与数据传输模型
• 掌握页锁定内存（Pinned Memory）的概念、性能优势及使用方法
• 熟练使用 cudaMalloc、cudaMemcpy，并了解其异步版本 cudaMemcpyAsync 的应用场景
• 理解统一内存（Unified Memory）的机制、优势和适用场景
• 能够根据程序需求（性能、易用性、数据规模）选择合适的内存管理策略

1. 主机内存与设备内存的分离

在 CUDA 编程模型中，CPU 和 GPU 拥有各自独立的内存空间：

• 主机内存 ：由 CPU 访问的内存，使用标准 C/C++ 分配（malloc、new）。
• 设备内存 ：由 GPU 访问的显存，必须通过 CUDA API 分配（如 cudaMalloc）。

两者之间通过 PCIe 总线连接，数据传输需要显式调用 cudaMemcpy。

基本数据流：

主机内存（CPU）  --H2D拷贝-->  设备内存（GPU）
     ↑                            │
     └──────D2H拷贝───────────────┘

2. 页锁定内存（Pinned Memory）

2.1 什么是页锁定内存

默认情况下，使用 malloc 分配的主机内存是可分页的，操作系统可能将其换出到磁盘，导致数据在物理内存中不连续。在进行 H2D 或 D2H 拷贝时，CUDA 驱动需要先将可分页内存复制到一个临时的页锁定缓冲区，然后再通过 DMA 传输到设备，增加了额外开销。

**页锁定内存（Pinned Memory，也称 Page‑Locked Memory）**是使用 cudaHostAlloc 或 cudaMallocHost 分配的主机内存，它不会被操作系统换出，物理地址固定，因此可以直接被 DMA 引擎访问，无需中间复制，显著提高传输速度。

2.2 分配与释放

float *h_data;
cudaMallocHost(&h_data, size);   // 分配页锁定内存
// 使用...
cudaFreeHost(h_data);            // 释放

2.3 性能对比

页锁定内存的传输带宽通常远高于普通可分页内存（尤其在大数据量时），但也占用物理内存，过多使用可能影响系统性能。

2.4 零拷贝内存（Zero‑Copy）

页锁定内存的一种特殊用法是零拷贝：通过 cudaHostAlloc 的 cudaHostAllocMapped 标志，将页锁定内存映射到设备地址空间，使 GPU 可以直接访问主机内存，避免显式拷贝。但受限于 PCIe 带宽，零拷贝适合少量数据或频繁访问的场景。

float *h_data, *d_data;
cudaHostAlloc(&h_data, size, cudaHostAllocMapped);
cudaHostGetDevicePointer(&d_data, h_data, 0);
// Kernel 可以直接使用 d_data 访问主机内存

3. 深入 cudaMemcpy 与异步拷贝

3.1 同步拷贝 cudaMemcpy

cudaMemcpy(dst, src, size, kind);

• 阻塞主机，直到拷贝完成。
• 适用于简单、小数据量的场景。

3.2 异步拷贝 cudaMemcpyAsync

cudaMemcpyAsync(dst, src, size, kind, stream);

• 在指定流中异步执行，主机不等待，可与其他操作重叠。
• 要求源或目标地址是页锁定内存（对于主机端）。
• 常配合流和事件实现高效的流水线。

示例：H2D 拷贝与 Kernel 执行重叠

cudaStream_t stream;
cudaStreamCreate(&stream);

// 分块处理数据
for (int i = 0; i < numChunks; i++) {
    cudaMemcpyAsync(d_in + offset, h_in + offset, chunkSize, 
                    cudaMemcpyHostToDevice, stream);
    kernel<<<grid, block, 0, stream>>>(d_in + offset, d_out + offset, chunkSize);
    cudaMemcpyAsync(h_out + offset, d_out + offset, chunkSize,
                    cudaMemcpyDeviceToHost, stream);
}
cudaStreamSynchronize(stream);

4. 统一内存（Unified Memory）

4.1 基本概念

统一内存是 CUDA 6 引入的一种内存模型，它提供一个统一的内存地址空间，主机和设备可以使用相同的指针访问数据，由 CUDA 运行时自动管理数据在 CPU 和 GPU 之间的迁移。

4.2 分配方式

float *data;
cudaMallocManaged(&data, size);
// 主机和设备都可以直接读写 data

无需显式 cudaMemcpy，但需要同步确保数据一致性。

4.3 工作原理

• 首次访问时发生页错误，数据从宿主迁移到访问方。
• 支持按需迁移和预取（cudaMemPrefetchAsync）。
• 在 Pascal 及之后的架构上，支持硬件页面故障，迁移更高效。

4.4 优势与限制

优势

• 简化编程，无需显式拷贝。
• 方便处理复杂数据结构（如链表、树）。
• 适合快速原型开发。

限制

• 可能引入隐式迁移开销，不如手动管理高效。
• 在大规模 HPC 应用中，性能通常低于显式拷贝（除非精心预取）。
• 需要 GPU 支持（sm_30+ 部分功能，sm_60+ 完整支持）。

4.5 性能优化：预取

// 预取数据到设备，避免首次访问时页错误
cudaMemPrefetchAsync(data, size, deviceId, stream);

也可以将数据预取回主机，以准备后续 CPU 访问。

5. 代码演示：对比页锁定内存与普通内存的拷贝性能

#include <cstdio>
#include <cuda_runtime.h>
#include <chrono>

#define CUDA_CHECK(call) \
    do { \
        cudaError_t err = call; \
        if (err != cudaSuccess) { \
            fprintf(stderr, "CUDA error at %s:%d: %s\n", __FILE__, __LINE__, cudaGetErrorString(err)); \
            exit(EXIT_FAILURE); \
        } \
    } while (0)

int main() {
    const int N = 1 << 26;   // 64M floats = 256 MB
    size_t bytes = N * sizeof(float);

    // 普通主机内存
    float *h_regular = (float*)malloc(bytes);
    // 页锁定内存
    float *h_pinned;
    CUDA_CHECK(cudaMallocHost(&h_pinned, bytes));

    float *d_data;
    CUDA_CHECK(cudaMalloc(&d_data, bytes));

    // 初始化数据
    for (int i = 0; i < N; i++) h_regular[i] = 1.0f;
    for (int i = 0; i < N; i++) h_pinned[i] = 1.0f;

    // 计时普通内存 H2D 拷贝
    auto start = std::chrono::high_resolution_clock::now();
    CUDA_CHECK(cudaMemcpy(d_data, h_regular, bytes, cudaMemcpyHostToDevice));
    CUDA_CHECK(cudaDeviceSynchronize());
    auto end = std::chrono::high_resolution_clock::now();
    double regular_ms = std::chrono::duration<double, std::milli>(end - start).count();

    // 计时页锁定内存 H2D 拷贝
    start = std::chrono::high_resolution_clock::now();
    CUDA_CHECK(cudaMemcpy(d_data, h_pinned, bytes, cudaMemcpyHostToDevice));
    CUDA_CHECK(cudaDeviceSynchronize());
    end = std::chrono::high_resolution_clock::now();
    double pinned_ms = std::chrono::duration<double, std::milli>(end - start).count();

    printf("Regular H2D: %f ms\n", regular_ms);
    printf("Pinned  H2D: %f ms\n", pinned_ms);
    printf("Speedup: %.2fx\n", regular_ms / pinned_ms);

    // 统一内存示例
    float *unified;
    CUDA_CHECK(cudaMallocManaged(&unified, bytes));
    // 无需显式拷贝，直接初始化（在主机端）
    for (int i = 0; i < N; i++) unified[i] = 2.0f;
    // 可以启动一个 Kernel 直接使用 unified 指针
    // 简单起见省略 Kernel

    // 清理
    free(h_regular);
    CUDA_CHECK(cudaFreeHost(h_pinned));
    CUDA_CHECK(cudaFree(d_data));
    CUDA_CHECK(cudaFree(unified));
    return 0;
}

预期结果：页锁定内存的拷贝速度通常比普通内存快 1.5~3 倍。

6. 课后练习

练习1：测量拷贝带宽

编写程序，分别测量普通内存和页锁定内存的 H2D、D2H 带宽，并分析差异。

练习2：异步拷贝重叠实验

使用 cudaMemcpyAsync 和多个流，将一个大数组分块，实现 H2D 拷贝与 Kernel 执行的重叠。用 Nsight Systems 观察时间线，确认重叠是否发生。

练习3：统一内存的简单使用

使用 cudaMallocManaged 分配一个数组，在主机端初始化，然后启动 Kernel 进行平方操作，最后在主机端验证结果。注意需要适当同步。

练习4：统一内存预取优化

对一个大规模数组，分别测试不使用预取和使用 cudaMemPrefetchAsync 预取到设备后的 Kernel 执行时间，分析性能差异。

练习5：零拷贝尝试

使用 cudaHostAlloc 的 cudaHostAllocMapped 标志创建零拷贝内存，在 Kernel 中直接访问，并测量与显式拷贝的性能差异。

7. 下一步

下一节将深入 统一内存的高级特性与性能调优，你将学习：

• 统一内存的按需迁移与预取策略
• 使用 cudaMemAdvise 优化数据放置
• 多 GPU 环境下的统一内存管理
• 统一内存与显式拷贝的性能对比与选择准则