GPU 编程实战——基础数据传输与内存类型主机与设备内存区域理解主机内存与设备内存空间每个 GPU 项目都有一个共同

主机与设备内存区域

理解主机内存与设备内存空间

每个 GPU 项目都有一个共同点：我们的数据可能存在于两种完全不同的地方——主机内存（Host Memory）和设备内存（Device Memory）。

主机内存：也就是计算机的系统 RAM，存放所有常规的 Python 数据结构、NumPy 数组，以及操作系统和 CPU 运行的进程。
设备内存：位于 GPU 板卡上的显存（VRAM）或全局内存，仅在 CUDA kernel 或设备端操作执行时可被 GPU 的众多核心访问。

这种物理分离非常关键：CPU 无法直接访问或修改设备内存中的数据，除非先将其拷贝回主机内存；同样，GPU 也不能直接处理主机 RAM 中的数据，必须先将数据传输到设备内存中。因此，在设计 GPU 加速工作流时，我们始终要问自己：当前的数据在哪里？下一个操作应当在哪里执行？

主机内存擅长与 CPU 无缝交互，适合串行或 I/O 密集型任务；而设备内存能够提供大规模并行、高吞吐量的计算，这是 CPU 所无法比拟的。

探索内存分配方式

选择合适的分配方式决定了数组的存储位置及其交互方式。

在主机上分配（NumPy）
```
import numpy as np
host_array = np.arange(1_000_000, dtype=np.float32)
```
此时数组完全驻留在系统 RAM，可像常规 Python 对象一样传给任何 CPU 函数进行处理。GPU 对此一无所知，除非我们显式地将它移动到设备。
在设备上分配（CuPy）
```
import cupy as cp
device_array = cp.zeros(1_000_000, dtype=cp.float32)
```
立即在 GPU 上分配显存，除非我们调用 cp.asnumpy()，否则不会产生主机–设备拷贝。此后可直接在该数组上运行 GPU kernel，利用数千线程并行处理。
在设备上分配（PyCUDA）
```
import pycuda.autoinit
import pycuda.gpuarray as gpuarray
device_array_py = gpuarray.zeros(1_000_000, dtype=np.float32)
```
同样，这一操作直接在显存中分配空间。只有在调用 .get() 或类似方法时，才会发生显存到主机内存的拷贝。

无论是先在主机上创建数据再传输，还是直接在设备上分配并在此基础上连续进行多次 GPU 操作，合理管理内存位置都是关键。

访问模式的差异

CPU 内存设计偏向随机访问，并配备深度缓存与预取机制；GPU 内存则依赖高带宽、大批量并行访问，尤其当大量线程协同访问相邻地址时（共线性访问/coalesced access），能最大化吞吐量。若线程的内存访问模式散乱无章，GPU 将不得不加载多个缓存行，导致性能下降。

同时，主机–设备间的数据传输也需精心规划：一次性拷贝大块数据比多次小批量传输效率更高。因此，我们通常将多个小操作合并为单次大转移，并在 GPU 上完成尽可能多的计算，尽量减少往返次数。借助 CUDA 流（Streams）或页锁定内存（Pinned Memory）等高级功能，还能在数据传输与计算之间实现重叠，进一步提升多阶段流水线的性能。

工作流中的性能影响

主机与设备内存之间的界限直接决定了性能瓶颈。每次数据传输都有固定开销，随着数据量增长，成本成倍攀升。一次传输一百万个浮点数可能只需几百毫秒，但如果每秒重复多次，这部分开销就会迅速主导整个应用的运行时间。

此外，现代 GPU 通常只有 8GB–24GB 显存，而主机可能拥有 32GB、64GB 或更多。面对巨量数据集时，我们必须将数据切分为多个批次分批处理，以免超出显存容量。谨慎的内存管理还能避免因在主机内存上启动 kernel 而导致的错误，或因试图直接用 GPU 函数处理 NumPy 数组而引发的异常。这类错误往往难以调试，因此务必时刻关注数据所处的内存区域，并在执行 GPU 操作前确保已将数组移动到正确位置。

示例工作流：主机与设备间的转移

一个典型的 GPU 加速流程如下：

主机端准备数据

import numpy as np
host_input = np.random.rand(1_000_000).astype(np.float32)

传输到设备内存

import cupy as cp
device_input = cp.asarray(host_input)

设备端处理
```
device_output = cp.sqrt(device_input)
```

传回主机

host_output = cp.asnumpy(device_output)

将所有转移操作集中一次性执行，把核心计算留给 GPU，能最大限度降低开销并提升性能。

高级内存类型

随着对 GPU 编程的深入，我们会接触到更多内存类型以优化性能：

页锁定内存（Pinned/Page-locked Memory） ：将主机内存固定在物理地址，减少数据移动开销，加速主机→设备传输。
统一内存（Unified Memory） ：提供统一地址空间，由 CUDA 运行时自动在主机与设备间迁移数据，简化编程，但会牺牲部分性能可控性。
零拷贝内存（Zero-copy Memory） ：允许 GPU 直接访问主机内存，适用于流式处理或显存受限场景。

大多数项目中，只需掌握主机内存与设备内存的基础即可；而这些高级类型则针对特定需求、能进一步提升效率。

同步拷贝与异步拷贝

定义

我们常把主机和设备间的数据传输看作一次简单的操作，但实际上存在两种截然不同的模式：同步和异步。理解它们对于高性能 GPU 编程至关重要，因为传输的调度方式不仅影响速度，还决定了 CPU 与 GPU 资源的利用效率。

同步拷贝：Python 脚本会在拷贝完成前“阻塞”后续所有操作。拷贝命令执行时，程序必须等待每一个字节都传输到位后，才会继续往下运行。对于小规模或偶发性传输，这种阻塞可能不明显；但当我们处理海量数组或频繁传输时，同步拷贝会让 CPU 空闲等待，显著拖慢整体流程。
异步拷贝：与之不同，异步拷贝在调度传输后立即返回，Python 脚本可在后台拷贝执行时继续往下跑。GPU 驱动会在后台完成数据移动，我们可以同时启动更多 kernel、准备下一批数据，或发起额外的传输。这样就能把通信与计算重叠，掩盖延迟，最大化硬件吞吐。

性能影响

在真实工作负载中，同步 vs. 异步的区别极具性能意义。同步拷贝会导致 CPU 和 GPU 相互等待，利用率偏低，尤其是在大批量数据来回传输时，应用吞吐能力受限。改用异步拷贝后，我们可以预先排入一系列操作，驱动和 GPU 会根据资源空闲情况依次执行，形成高效流水线。CPU 在准备下一批工作或处理结果的同时，GPU 可继续传输或计算，使两者协同发挥最大效能。在流式与批量处理场景中，异步拷贝有时能将整体吞吐提升近一倍。

CuPy 中的同步与异步方法

同步方法（如 cp.asarray()、cp.asnumpy()）默认即为阻塞调用：

import numpy as np
import cupy as cp

host_data = np.random.rand(100_000_000).astype(np.float32)
# 同步拷贝：脚本在此停住，直到完成为止
device_data = cp.asarray(host_data)

要使用 异步拷贝，可借助 cp.cuda.Stream(non_blocking=True)：

stream = cp.cuda.Stream(non_blocking=True)
with stream:
    # 异步调度拷贝，立即返回
    device_data_async = cp.asarray(host_data)
# 如需确保拷贝完毕再用，就手动同步
stream.synchronize()

在 with stream 块中的操作会排入该流（stream），只要不调用同步方法，脚本就能持续执行。stream.synchronize() 则用来在最合适的时机等待该流中的所有操作完成，为我们提供精细的执行控制。

示例：阻塞与队列管理对比

下面程序测量从主机到设备拷贝大数组所需时间。

同步拷贝

import time, numpy as np, cupy as cp

host_data = np.random.rand(200_000_000).astype(np.float32)
start = time.time()
device_data = cp.asarray(host_data)
end = time.time()
print("同步拷贝耗时（秒）：", end - start)

异步拷贝

import time, numpy as np, cupy as cp

host_data = np.random.rand(200_000_000).astype(np.float32)
stream = cp.cuda.Stream(non_blocking=True)

start = time.time()
with stream:
    device_data_async = cp.asarray(host_data)
# 在此可插入额外计算或 kernel 调用
stream.synchronize()
end = time.time()
print("异步拷贝耗时（秒）：", end - start)

若在 start 与 synchronize() 之间增加计算或其它 GPU 操作，通常能显著缩短总时间，因为传输和计算可并行进行。

何时使用？

同步拷贝：适合简单脚本、快速原型或偶尔传输少量数据，易于理解，保证数据就绪再执行下一步。
异步拷贝：适合复杂或大规模程序，尤其是批量处理、深度学习训练/推理等场景，可保持 CPU 与 GPU 持续繁忙，减少空等待、提升性能；借助多流，还能在不同任务之间灵活划分和重叠。

根据工作流规模、复杂度及对效率的需求，灵活选用同步或异步拷贝，让每个 GPU 编程项目都在简单脚本与高性能流水线间自如切换。

页锁定内存（Pinned Memory）以加速传输

为什么主机内存类型影响传输速度？

每当我们在主机（CPU）内存和设备（GPU）内存之间移动数据时，主机内存的底层类型对传输速度有巨大影响。默认情况下，NumPy 或 Python 创建的数组驻留在可分页（pageable）内存中，这种内存可被操作系统随时换出到磁盘，虽然灵活但在直接设备访问时会带来额外开销。GPU 要从可分页内存读取数据时，系统必须先将数据复制到一个临时的、固定位置的缓冲区，然后再启动真正的传输。这一步骤在处理大数组时尤其会显著拖慢速度。

页锁定内存（又称“锁页内存”）则能带来显著加速。分配页锁定内存时，我们告诉操作系统将该内存区域保留在物理 RAM 中，绝不换出到磁盘。这样，GPU 的 DMA（直接内存访问）引擎就能绕过临时拷贝，直接从主机 RAM 将数据传到设备内存，大幅提升带宽。对于高吞吐量的 GPU 应用，使用页锁定内存是加速主机–设备通信的实用方法。

如何分配页锁定内存

在 CuPy 中，分配页锁定内存非常简单。我们通过 CuPy 的 PinnedMemoryPool 来实现：

import cupy as cp

# 创建页锁定内存池，并设置分配器
pinned_pool = cp.cuda.PinnedMemoryPool()
cp.cuda.set_pinned_memory_allocator(pinned_pool.malloc)

# 定义要分配的元素数量
size = 100_000_000

# 分配驻留在页锁定内存中的数组
pinned_host = cp.ndarray(
    (size,), 
    dtype=cp.float32, 
    memptr=pinned_pool.malloc(size * cp.dtype(cp.float32).itemsize)
)

这个数组在使用上与普通 CuPy 数组无异，但它直接驻留在 GPU 可高效访问的页锁定内存中。使用它进行主机–设备传输时，可在支持的硬件上获得零拷贝（zero-copy）访问，或至少显著降低延迟、提高带宽。

可分页内存与页锁定内存对比测试

下面示例对比了可分页内存（常规 NumPy 数组）与页锁定内存的传输速度：

import cupy as cp
import numpy as np
import time

size = 100_000_000

# 1) 创建可分页主机数组（NumPy）
pageable_host = np.random.rand(size).astype(np.float32)

# 2) 创建页锁定主机数组（CuPy）
pinned_pool = cp.cuda.PinnedMemoryPool()
cp.cuda.set_pinned_memory_allocator(pinned_pool.malloc)
pinned_host = cp.ndarray(
    (size,), 
    dtype=cp.float32, 
    memptr=pinned_pool.malloc(size * cp.dtype(cp.float32).itemsize)
)
# 将数据复制到页锁定数组
pinned_host[:] = pageable_host

# 测量可分页内存传输耗时
start_pageable = time.time()
device_array_pageable = cp.asarray(pageable_host)
cp.cuda.Stream.null.synchronize()
end_pageable = time.time()
print("可分页传输耗时：", end_pageable - start_pageable, "秒")

# 测量页锁定内存传输耗时
start_pinned = time.time()
device_array_pinned = cp.asarray(pinned_host)
cp.cuda.Stream.null.synchronize()
end_pinned = time.time()
print("页锁定传输耗时：", end_pinned - start_pinned, "秒")

在确保每次拷贝都同步结束后，你会发现页锁定内存的传输时间明显更短，尤其是数组规模越大时差距越大。

何时使用页锁定内存？

大规模或高频次传输：比如流式处理、实时数据处理、或需要快速批次移动数据的机器学习任务。
对低延迟或最大带宽有严格需求：页锁定内存能显著减少传输开销。
简单脚本或便携代码：若传输量小、可接受一般速度，可继续使用可分页内存，以保持代码的易用性和跨平台兼容性。

总之，当目标是构建高吞吐量系统或在传输阶段尽可能压缩延迟时，将页锁定内存纳入工作流，就能为 GPU 加速通讯再添一把“快马”。

使用统一内存（Unified Memory）与 CuPy

简化工作流

在做了一段时间 GPU 编程后，我们深刻体会到：知道数据是在主机（Host）还是设备（Device）内存中，并明确何时何地进行拷贝，对性能至关重要。到目前为止，每次要让 GPU 处理数据时，我们都必须显式地将其从主机内存拷贝到设备内存，再在需要查看结果时把它拷回主机。虽然这种方法控制力强、性能最佳，但也会让代码变得复杂、可维护性下降，尤其当算法在 CPU 与 GPU 之间动态切换、或在做快速原型时。

统一内存（CUDA 的 cudaMallocManaged 引入）则颠覆了这一切。使用统一内存，我们只需分配一块可同时被 CPU 和 GPU 直接访问的内存区域，CUDA 驱动和运行时会根据需要在主机和设备间自动迁移数据。这样，我们编写的代码只需操作这一个数组，无需管理显式拷贝或维护两份副本。统一内存特别适合快速原型开发、频繁在 CPU/GPU 之间切换的算法，以及运行时数据访问模式难以预测的场景。

当 CPU 访问数据时，CUDA 运行时会确保该页在主机 RAM 中可用；
当 GPU kernel 访问时，运行时会将它迁移到设备内存。

尽管显式拷贝在关键性能路径上依然最快，但统一内存能大幅减少代码量、防止错误，甚至支持处理超出 GPU 显存的数据（CUDA 在后台分页）。

何时使用统一内存？

快速开发与测试：最小化代码复杂度。
频繁在 CPU 和 GPU 之间切换的算法。
多 GPU 或多进程工作流：显式管理内存极其困难时。
数据量可能超出设备显存：让系统透明地分页。

对于性能敏感的部分，仍可结合显式拷贝或页锁定内存进行优化。

示例：使用统一内存做向量加法

CuPy 提供了 alloc_managed 接口分配统一内存。下面展示如何用它来做向量加法。

分配统一内存

import cupy as cp
import numpy as np

size = 1_000_000
# 分别为 a、b、c 分配统一内存缓冲区
a_managed = cp.cuda.memory.alloc_managed(size * cp.dtype(cp.float32).itemsize)
b_managed = cp.cuda.memory.alloc_managed(size * cp.dtype(cp.float32).itemsize)
c_managed = cp.cuda.memory.alloc_managed(size * cp.dtype(cp.float32).itemsize)

映射为 NumPy 数组并初始化

# 将统一内存缓冲区映射为 NumPy 数组以便主机访问
a_host = np.frombuffer(a_managed, dtype=np.float32, count=size)
b_host = np.frombuffer(b_managed, dtype=np.float32, count=size)
c_host = np.frombuffer(c_managed, dtype=np.float32, count=size)

# 初始化输入数据
a_host[:] = np.random.rand(size).astype(np.float32)
b_host[:] = np.random.rand(size).astype(np.float32)

此时无需显式拷贝——数据“就在那里”。

编写并启动 CUDA kernel

kernel_code = r'''
extern "C" __global__
void vec_add(const float* a, const float* b, float* c, int n) {
    int idx = blockDim.x * blockIdx.x + threadIdx.x;
    if (idx < n) {
        c[idx] = a[idx] + b[idx];
    }
}
'''
module = cp.RawModule(code=kernel_code)
vec_add = module.get_function('vec_add')

threads_per_block = 256
blocks_per_grid = (size + threads_per_block - 1) // threads_per_block

# 直接在统一内存上执行
vec_add(
    (blocks_per_grid,), (threads_per_block,),
    (a_managed, b_managed, c_managed, size)
)

在主机上验证结果

# GPU 计算完成后，可直接在主机端读取 c_host
expected = a_host + b_host
if np.allclose(c_host, expected):
    print("统一内存向量加法成功且正确。")
else:
    print("结果不匹配！")

使用统一内存大大简化了代码，但 CUDA 运行时仍会根据访问自动迁移数据。对于频繁在主机和设备端交替访问的工作流，与手工优化的显式拷贝相比，可能会产生一定额外开销。但在许多真实场景中，尤其是开发、原型或混合负载下，这种简便性和健壮性往往更有价值。

此外，当数据集大于 GPU 可用显存时，统一内存的自动分页机制还能让程序继续运行，而无需手动分批处理。

重叠数据传输与计算

重叠与 CUDA 流

默认情况下，数据传输和计算通常是依次发生的：先拷贝数据到 GPU，等待拷贝完成；再启动 kernel，等待 kernel 完成后才能处理下一批数据。这种方式会让 GPU 或 CPU 在大部分时间内处于空闲状态，未充分利用硬件资源。当我们将数据传输与 kernel 执行重叠（即在一批数据传输进行时，同时对上一批数据运行 kernel），就能保持资源持续忙碌，降低端到端时延。

CUDA 流（Streams） 是实现重叠的关键。流就像 GPU 的命令队列，不同流中的操作可以并行执行（前提是硬件资源允许）。默认流（null stream）会强制所有操作串行执行；将拷贝和计算分别放入不同流，就允许 GPU 同时进行数据移动和计算。双缓冲（double‐buffering）技术常用于高性能 GPU 工作负载，以最大化吞吐。

示例程序：CuPy 中的重叠传输与计算

以下示例使用两个 CUDA 流，一条用于数据传输，一条用于计算。在一条流中我们把新一批数据传到设备，另一条流中处理上一批数据，实现传输与计算的重叠。

import cupy as cp
import numpy as np
import time

# 问题规模与批次大小
total_size = 100_000_000
batch_size = 10_000_000

# 在主机上生成数据批次
host_batches = [
    np.random.rand(batch_size).astype(np.float32)
    for _ in range(total_size // batch_size)
]

# 简单 kernel：逐元素乘以 scale
kernel_code = r'''
extern "C" __global__
void scale(float *a, float scale, int n) {
    int idx = blockDim.x * blockIdx.x + threadIdx.x;
    if (idx < n) {
        a[idx] *= scale;
    }
}
'''
mod = cp.RawModule(code=kernel_code)
scale_kernel = mod.get_function('scale')

threads_per_block = 256
blocks_per_grid = (batch_size + threads_per_block - 1) // threads_per_block

# 创建两个流：一个用于传输，一个用于计算
stream_transfer = cp.cuda.Stream(non_blocking=True)
stream_compute  = cp.cuda.Stream(non_blocking=True)

results = []
start = time.time()

for batch in host_batches:
    # 在传输流中拷贝数据到设备
    with stream_transfer:
        device_batch = cp.asarray(batch)
    # 等待传输完成，再在计算流中启动 kernel
    stream_transfer.synchronize()
    with stream_compute:
        scale_kernel(
            (blocks_per_grid,), (threads_per_block,),
            (device_batch, np.float32(1.5), batch_size)
        )
        # 异步将结果拷回主机
        result_host = cp.asnumpy(device_batch)
    # 等待计算及拷贝完成
    stream_compute.synchronize()
    results.append(result_host)

end = time.time()
print(f"重叠处理总耗时：{end - start:.2f} 秒")

要点如下：

两条流：stream_transfer 专职传输，stream_compute 专职计算。
每批次先在传输流拷贝数据，再在计算流运行 kernel 并异步拷回结果。
同步操作保证阶段正确完成，但由于下一批传输可与计算并行，后续迭代会看到真正的重叠效果。

同步模式对比

为对比性能，可以用仅使用默认流（无重叠）的版本：

start_sync = time.time()
for batch in host_batches:
    device_batch = cp.asarray(batch)
    scale_kernel(
        (blocks_per_grid,), (threads_per_block,),
        (device_batch, np.float32(1.5), batch_size)
    )
    result_host = cp.asnumpy(device_batch)
end_sync = time.time()
print(f"同步（无重叠）总耗时：{end_sync - start_sync:.2f} 秒")

在真实工作负载中，重叠常常能显著减少总耗时，使我们能够持续处理流式输入，最大化 GPU 并行度和吞吐率。

何时使用？

当需要处理连续到来的大批量数据、构建流式或批量流水线时，利用 CUDA 流实现数据传输与计算重叠，能让 CPU 与 GPU 同时繁忙，显著提升系统的整体性能。

简单带宽测量

要构建高效的 GPU 工作流，了解主机与设备之间的数据传输速度至关重要。无论 GPU 多么强大，如果一直在等待来自 CPU 的数据，它也无法发挥作用。我们可以测量系统的带宽——主机与设备间传输数据的速率。这能帮助我们发现瓶颈、评估已接近硬件极限的程度，从而决定数组大小、选择最佳批次，并判断何时使用页锁定内存或重叠传输等高级技术。

设计基本带宽基准测试

我们的目标是编写一个脚本，将不同大小的数组从主机传输到设备再传回，计时并计算出有效吞吐率（GB/s）。此实验可同时测试可分页（pageable）和页锁定内存，但我们先用最简单的同步传输和 NumPy/CuPy 来测量。

以下脚本测量多种数组大小的带宽：

import numpy as np
import cupy as cp
import time

# 从 1 KB 到 64 MB 的数组大小
sizes = [2**10, 2**14, 2**18, 2**20, 2**22, 2**24, 2**26]
dtype = np.float32

print(f"{'数组大小 (MB)':>15} | {'主机→设备 GB/s':>18} | {'设备→主机 GB/s':>18}")

for size in sizes:
    arr = np.random.rand(size).astype(dtype)
    arr_mb = arr.nbytes / (1024 * 1024)

    # 主机到设备传输
    start_htod = time.time()
    d_arr = cp.asarray(arr)
    cp.cuda.Stream.null.synchronize()
    end_htod = time.time()
    htod_time = end_htod - start_htod
    htod_gbs = arr.nbytes / (htod_time * 1e9)

    # 设备到主机传输
    start_dtoh = time.time()
    arr2 = cp.asnumpy(d_arr)
    cp.cuda.Stream.null.synchronize()
    end_dtoh = time.time()
    dtoh_time = end_dtoh - start_dtoh
    dtoh_gbs = arr.nbytes / (dtoh_time * 1e9)

    print(f"{arr_mb:15.2f} | {htod_gbs:18.2f} | {dtoh_gbs:18.2f}")

脚本要点

我们依次测试一系列翻倍的数组大小。
每种大小下，生成一个随机 NumPy 数组，并记录其 MB 大小。
使用 cp.asarray() 测量主机→设备传输时间，使用 cp.asnumpy() 测量设备→主机时间，并在每次传输后同步。
有效带宽 = 数组字节数 ÷ 传输时长，以 GB/s 报告。

结果解读

通常会发现，随着数组增大，带宽也随之提升：小数组因启动开销无法饱和总线，而大数组则能接近硬件理论极限。对于大多数基于 PCIe Gen3/Gen4 的现代 GPU，大批量传输的峰值带宽一般在 8–20 GB/s 之间，具体取决于硬件及是否使用页锁定内存。

若要进一步探索，可以改用页锁定内存进行基准测试，这对大规模传输尤其能提高带宽。若系统支持多 GPU，还可测试设备间（GPU→GPU）拷贝；或加入 CUDA 流的异步传输测量，观察并发如何影响带宽。

通过这种带宽基准，我们能切实了解主机–设备数据通路性能，为优化 GPU 工作流提供可靠依据。

总结

通过本章内容，我们已经对内存管理和数据传输的工作原理有了清晰的认识。首先，我们区分了主机内存（Host Memory）与设备内存（Device Memory），了解了它们各自的用途，以及为何必须在两者之间精心移动数据以便 GPU 执行计算。

接着，我们探索了多种内存分配方式，并认识到不同的访问模式和规划策略会对性能产生重大影响。我们比较了同步拷贝与异步拷贝的行为，发现通过流（Streams）进行异步传输时，能够将数据移动与计算重叠，从而显著提升吞吐量。

随后，我们尝试了**页锁定内存（Pinned Memory）**优化，它在处理大数组时能大幅提升带宽，缓解潜在瓶颈。我们还学习了如何利用 CUDA 流交错数据传输与 kernel 执行，在流式或实时应用中同时提升延迟和带宽表现。

最后，通过编写简单却高效的基准测试脚本，我们测量了主机–设备间的实际带宽，并掌握了评估与优化系统上数据移动的实用方法。凭借这些工具与技巧，我们已具备在任意硬件环境中进行内存与传输优化的能力。

GPU 编程实战——基础数据传输与内存类型

主机与设备内存区域

理解主机内存与设备内存空间

探索内存分配方式

访问模式的差异

工作流中的性能影响

示例工作流：主机与设备间的转移

高级内存类型

同步拷贝 与 异步拷贝

定义

性能影响

CuPy 中的同步与异步方法

示例：阻塞与队列管理对比

何时使用？

页锁定内存（Pinned Memory）以加速传输

为什么主机内存类型影响传输速度？

如何分配页锁定内存

可分页内存与页锁定内存对比测试

何时使用页锁定内存？

使用统一内存（Unified Memory）与 CuPy

简化工作流

何时使用统一内存？

示例：使用统一内存做向量加法

重叠数据传输与计算

重叠与 CUDA 流

示例程序：CuPy 中的重叠传输与计算

同步模式对比

何时使用？

简单带宽测量

设计基本带宽基准测试

脚本要点

结果解读

总结

同步拷贝与异步拷贝