← PyTorch From First Principles

性能:机器在等什么?

把 PyTorch 性能变成可测的比较:定义 workload 与指标,纠正 CUDA 计时,分离训练阶段,跟踪已分配与保留内存,分析瓶颈,把 AMP、检查点、SDPA、torch.compile 当有证据的干预来测。

这里有个 benchmark。模型、batch、循环、计时器。没什么 exotic。

model.train()
t0 = time.perf_counter()
for _ in range(20):
    optimizer.zero_grad(set_to_none=True)
    loss = F.cross_entropy(model(x), y)          # MLP, batch 256
    loss.backward()
    optimizer.step()
ms_per_step = (time.perf_counter() - t0) / 20 * 1000
naive loop of   20:   9.491 ms/step reported   + 132.0 ms still queued at the final sync   -> really 16.093 ms/step
naive loop of  100:  14.692 ms/step reported   + 138.8 ms still queued at the final sync   -> really 16.080 ms/step
naive loop of  400:  15.741 ms/step reported   + 132.1 ms still queued at the final sync   -> really 16.071 ms/step

synchronized + warmed, median of 400 :  16.430 ms/step   <- the real number
one step, host-visible return only   :   4.866 ms/step
first training step ever             :  20.890 ms

第一行再读一遍。循环跑二十轮报告每步 9.491 ms。紧接着一次 torch.cuda.synchronize() block 132 毫秒——约八步的 work,计时停时 GPU 还没做完。循环一百轮同样代码报告 14.7。四百轮 15.7。单步孤立计时像 4.9。

没抛,没 illegal。每数都是某东西的真测量。没有一个是步时间,步时间 16.4 ms,只有预热循环、设备在测量区两端同步才拿到。

优化程序前,证明你要优化的数度量了你以为的 work。

循环撒谎因为 CUDA 执行相对主机异步。model(x)、loss.backward() 可能在发出设备 work 后返回,不等做完。短 unsynchronized 循环主要测主机侧提交。长循环在 outstanding work 与分配累积时卷入 backpressure 与隐式等待,apparent 时间 drift 向完成 work 的速率。两结果都不 trusted 设备完成时间,除非测量边界迫使排队 work 做完。

honest 的数也只对一个问题 honest。同样 MLP 同样 batch,四种合法计时:

forward, inference_mode      median=    2.968 ms
forward, grad enabled        median=    2.967 ms
forward + backward           median=    8.094 ms
full training step           median=   16.450 ms

3 ms 与 16 ms 都 true。回答不同问题。“模型多快”不是一个问题。

我们在哪

第 11 章走完学习链。固定 batch 证明从任务契约到参数移动的每 link:

TASK → OBJECTIVE → DEPENDENCY → GRADIENT → OPTIMIZER OWNERSHIP → PARAMETER UPDATE → CAPABILITY

结尾一行:模型学会了。

这是本章的起始条件。不重开算子对不对的问题。问另一个问题:

代价是什么?

正确的训练循环能浪费大半 GPU。能装进内存而半数时间在优化器。能被看起来 harmless 的 list OOM。torch.compile 后能比之前慢——同样调用一 workload 快、一 workload 中性。第 11 章的仪器全都注意不到,因为它们全度量对的事发生否,没一度量花了多少。

本章的中心问题:

正确的 PyTorch workload 慢或内存太多时,哪个资源 limiting,什么测量证明诊断?

方法,第 6 章“拆步测每边界”、第 11 章“逐 link 证明链”同样位置:

测量 → 定位 → 干预 → 再测。

四词都 load-bearing。测量有意思的数。定位 limiting 资源再碰它。干预一机制。再测同样契约,报告每维度动了什么,不只希望的那个。

最深的原则

4.2 ms 不是关于程序的事实。它是六输入函数的输出:

workload + hardware + runtime + execution mode + metric + measurement boundary
= performance result

任一输入变数就变,常常比考虑的优化还大。开篇失败 workload、硬件、runtime 固定,只动测量边界——同步否、预热否、20 轮还是 400 轮——答案从 4.9 到 16.4。

所以本章每测量先写下再测。recurring device 是测量契约:

WORKLOAD     training step
MODEL        MLP, dim 1536, depth 12
INPUT        [256, 1536]
DEVICE       cuda
DTYPE        float32
MODE         train
EXECUTION    eager
METRIC       examples / second
WINDOW       steady state after warmup

受控对比固定每非目标契约部分。实验 deliberate 改 batch、dtype、执行模式或别的 factor,说出 factor 其余固定。几契约字段同时 drift,比值 uninterpretable,说不出哪个变化导致的。

这些数从什么环境来

本章每数、表、跟踪都由跑出的代码产出,种子固定,一台机器,一次 back-to-back session:

Python        3.11.4
PyTorch       2.6.0+cu118        CUDA runtime 11.8, cuDNN 9.1.0
OS            Windows 11
CPU           24 logical cores; torch.get_num_threads() == 1 (OMP_NUM_THREADS=1 in the environment)
GPU           NVIDIA GeForce RTX 2060, compute capability 7.5, 12288 MiB, 34 SMs
torch.compile triton-windows 3.2.0, MSVC toolchain

这是接显示器的桌面 GPU。实验跑前 nvidia-smi 已报告 12G 里约 2.6 GiB 被 compositor 等占用,卡 idle 40–50% 利用率。后果本章不藏:预热 benchmark 跑间 variation 几个百分点,单边——步从不比 floor 快,桌面要 GPU 时慢得多。全步基线 session 间 16.4 到 19.5 ms drift。session 内 hold-constant 对比约 1% 稳,差小于 spread 处本章说清而不报比值。

算力比 raw 速度重要。7.5 是 Turing:有 fp16 tensor core,无原生 bfloat16 tensor-core 路,这个 PyTorch 2.6 build 里下面 SDPA 实验没用 Flash-Attention 后端。几个结果因而是这个硬件/软件组合 specific。A100、RTX 4090 上机制仍重要,不同核可用时计时、内存曲线的定性形状都可能变。

这里的绝对数不 portable。可复用的 artifact 是测量流程,不是这块卡上的毫秒。

一个受控 workload

无固定 workload 调性能和无固定 batch 调训练同样错。本章基线计时、阶段分解、batch sweep、内存分析、混合精度、检查点、累积、编译用一合成训练 workload。是 deliberate GEMM-bound 分类器——方线性层堆——一训练步几十毫秒(高于计时噪声)、每秒几十次重复(便宜测)。

class MLP(nn.Module):
    def __init__(self, dim=1536, depth=12, num_classes=1000):
        super().__init__()
        layers = []
        for _ in range(depth):
            layers += [nn.Linear(dim, dim), nn.GELU()]
        self.body = nn.Sequential(*layers)
        self.head = nn.Linear(dim, num_classes)

    def forward(self, x):
        return self.head(self.body(x))
parameters: 29,866,984  (113.9 MiB in fp32)

窄注意力 microbenchmark 从第 10 章手工实现派生,出现一次——序列长实验,point 正是 MLP 从不分配的张量。GPT capstone 是第 15 章的;这里不提前建。

共享仪器住 perflab.py:固定种子模型 batch 构造、返回 warmup 外 raw 逐调用样本的计时 helper、中位/IQR summariser、CUDA 内存计数、environment_report()。本章每表从那些可复现。

技术在一函数:benchmark hygiene

开篇失败三病因:无预热、无同步、summary(单循环均值)活不过 outlier。三都修。

def time_calls(fn, *, warmup=20, repeats=100, sync=True):
    for _ in range(warmup):
        fn()
    if sync:
        torch.cuda.synchronize()
    samples = []
    for _ in range(repeats):
        if sync:
            torch.cuda.synchronize()
        t0 = time.perf_counter()
        fn()
        if sync:
            torch.cuda.synchronize()
        samples.append((time.perf_counter() - t0) * 1000)
    return samples          # milliseconds, warmup already discarded

Warmup 去掉属于进程不属于步的首次代价:CUDA 上下文创建、核加载、cuDNN 算法选择、分配器生长、稍后的编译。受控 workload 上测得:

effect of warmup (repeats=100, synchronized):
  warmup= 0  median= 16.390  mean= 17.338  IQR= 0.159  min= 16.258  max= 96.243
  warmup= 1  median= 16.474  mean= 16.549  IQR= 0.166  min= 16.326  max= 17.777
  warmup=30  median= 16.480  mean= 16.608  IQR= 0.202  min= 16.347  max= 18.859

一 96.2 ms 步——第一步——warmup=0 下百步均值拉高近一毫秒。中位几乎不动,因为中位无视一坏样本。一行就是中位的论证。

Spread 与中心同样重要。四百预热步:

median 16.449   IQR 0.189   (p25..p75 = 16.383..16.572)
mean   16.525   std 0.242   max 18.030
steps above median+3*IQR: 21/400

四百步二十一步远在 bulk 上。分布单边尾——显示 GPU 被借——均值追它。四分位距 0.19 ms;标准差 0.24 ms。报告中位与 IQR。差小于 run 内 spread 是 effect 可能没 resolved 的警告;IQR 不是差的置信区间。小 effect 用重复或交错 A/B 测,按配对/块间 variation judge 差,别从单比值宣称显著。

Benchmark utility 多买一样:比的测量间更少 hidden 区别。torch.utils.benchmark.Timer 自己管预热、同步、自适应迭代数:

t = torch.utils.benchmark.Timer(stmt="step()", globals={"step": step})
m = t.blocked_autorange(min_run_time=2.0)   # -> Measurement with .median, .iqr, .mean, .times
Timer.blocked_autorange: median 16.169 ms   IQR 0.036 ms   n_per_run 10   runs 13
our helper (warmup=30, repeats=400): median 16.449 ms   IQR 0.189 ms

Timer 中位略低、紧得多:blocked_autorange() 选摊销计时与加速器同步开销的内块尺寸,报告每调用代价。两测量都 valid;测的边界 marginally 不同。Timer 能跑改 state 的语句,但自动重复意味着每次计时调用看到的模型/优化器 state 不同,除非 deliberate 控/重置。本章可变全训练步实验里显式 helper 让 state 推进可见,不藏进自适应 benchmark 循环。

预热、同步、robust summary 下受控 workload 有基线:全训练步约 16.4 ms,session 内 IQR 约 0.2 ms。下面每干预同样契约下与它比。

干预前定位:拆步

步 16ms,去哪了?每阶段 deliberate synchronize() 括起来计时。

def phase_step(model, opt, get_batch):
    m0 = time.perf_counter()
    x_cpu, y_cpu = get_batch();                 torch.cuda.synchronize(); m1 = time.perf_counter()
    x = x_cpu.to("cuda", non_blocking=True)
    y = y_cpu.to("cuda", non_blocking=True);    torch.cuda.synchronize(); m2 = time.perf_counter()
    opt.zero_grad(set_to_none=True)
    logits = model(x);                          torch.cuda.synchronize(); m3 = time.perf_counter()
    loss = F.cross_entropy(logits, y);          torch.cuda.synchronize(); m4 = time.perf_counter()
    loss.backward();                            torch.cuda.synchronize(); m5 = time.perf_counter()
    opt.step();                                 torch.cuda.synchronize(); m6 = time.perf_counter()
    float(loss.detach());                                                 m7 = time.perf_counter()
    return {"input_wait": m1-m0, "host_to_device": m2-m1, "forward": m3-m2,
            "loss": m4-m3, "backward": m5-m4, "optimizer": m6-m5, "logging": m7-m6}

synchronize() 不是装饰。异步 work 周围的 wall-clock 区间不测 work;测提交。把时间归到阶段须等该阶段设备 work 做完再读钟。等待是仪器加的真代价,实验也测它。

phase             median ms     IQR ms    share
input_wait           0.030      0.007     0.2%
host_to_device       0.311      0.020     1.8%
forward              3.047      0.077    17.4%
loss                 0.102      0.037     0.6%
backward             4.993      0.104    28.4%
optimizer            9.015      0.090    51.3%
logging              0.064      0.012     0.4%
sum of phases       17.560
measured total      16.758      0.260   (uninstrumented, one sync at the end)

先两检查。阶段中位和(17.56 ms)与单独测的无仪器步中位(16.76 ms)接近。约 0.8 ms gap 是额外同步边界 perturb 测量的证据;分开阶段分布的中位代数不可加,别把差当精确同步账单减。这里小到分解仍 useful 定位。input_wait 0.03 ms 因为 batch 住主机;真流水线里这里就是第 6 章,它主导就停在这里回第 6 章,不优化本章任何东西。

现在值得整个实验的结果:优化器占步 51%。 不是前向,不是反向。AdamW.step() 在这个模型上比前向加损失合起来久。没人预测这个数,方法说定位再干预正为这个——前向快一天动步的 17%。

同样括号去掉逐阶段 synchronize,开篇的谎言换装回来:

same brackets, NO per-phase synchronize:
  forward              1.571 ms
  backward             2.173 ms
  optimizer            0.824 ms
  logging             11.683 ms

前向看起来几乎免费,优化器看起来免费,logging——float(loss) 调——看起来 11.7 ms。它没有。float(loss) 是第一个迫使主机等设备的算子,吸了还在途的前向、反向、优化器全部 backlog。测量边界动了;时间没动。

两仪器,两问题

同步 wall clock 是一仪器。CUDA event 是另一仪器,测略不同的东西——流里两点间设备侧时长,无主机侧 launch 与同步开销:

start, end = torch.cuda.Event(enable_timing=True), torch.cuda.Event(enable_timing=True)
start.record(); fn(); end.record()
torch.cuda.synchronize()
device_ms = start.elapsed_time(end)
controlled workload (dim1536 depth12 batch256):
  synchronized wall clock : 16.281 ms  (IQR 0.181)
  CUDA events (device)    : 15.945 ms  (IQR 0.076)
  host submission only     : 15.155 ms/step
  wall - events            : +0.336 ms

两这里 agree 到 0.34 ms,因为步 device-bound:问不问同步主机都在队列上 block,流逝主机时间与设备时间几乎相同。主机提交占步真比例的 workload——很多小核、核间重 Python——同步 wall clock 含主机时间而 CUDA event 不含,gap 本身是测量:步里多少是主机而不是设备。两仪器都没“对”。“步多久”用 wall clock,“设备花多久”用 CUDA event,知道问的是哪个。

干预,再测

优化器阶段是瓶颈。是 AdamW specific,还是优化一般?同样梯度在场,四优化器孤立计时 .step():

optimizer phase, isolated (synchronized, warmed, median ms):
  SGD                1.407 ms   IQR 0.057
  SGD momentum       3.605 ms   IQR 0.084
  AdamW foreach      8.969 ms   IQR 0.115      <- the default
  AdamW fused        5.490 ms   IQR 0.051

AdamW foreach 实现在约 3000 万参数、25 张量上跑一串多张量逐元算子——乘、加、addcmul、addcdiv、sqrt、lerp——这块 GPU 上约 9 ms。fused 实现更激进横竖 fuse,这里测 5.5 ms;别 assumed 每设备/build 字面变一核。SGD 1.4 ms,但它是不同优化算法,不是 drop-in 纯性能替换。

这是真干预真 trade-off,带正确性列。fused=True 经不同执行策略实现同样 AdamW 更新语义,浮点求值不必逐比特相同:同样 state 同样梯度,一 fused 步与一 foreach 步这个实验里每元差到 3.7e-9(参数尺度 ~2.6e-2)。换 SGD 改优化动态 entirely,归第 11 章分析,不是纯性能决定。再测量:fused=True 优化器阶段 9.0 到 5.5 ms,端到端步跟着到约 13 ms。这是这个契约下 defensible 的优化。“前向更快”不是。

延迟、吞吐、峰值内存是不同问题

“哪个 batch 最快”不说快在哪就没答案。这个实验的契约固定被 sweep 的一件事之外的所有:

WORKLOAD   training step        MODE       train
MODEL      MLP dim1536 depth12  EXECUTION  eager
INPUT      [B, 1536], B swept   METRIC     ms/step AND examples/s AND peak MiB
DEVICE     cuda / float32       WINDOW     steady state after warmup

batch sweep,模型初始化固定,测三样:

 batch    ms/step     IQR   examples/s  peak_alloc  peak_resv  ms/example
     32     13.150   0.566         2434       586.3      668.0      0.4109
     64     13.123   0.484         4877       814.3      932.0      0.2050
    128     13.226   0.240         9678       814.7      948.0      0.1033
    256     16.488   0.136        15526       815.9      926.0      0.0644
    512     23.392   0.172        21888       817.1      946.0      0.0457
   1024     37.466   0.407        27331       820.1      942.0      0.0366
   2048     66.080   0.264        30993       927.7     1130.0      0.0323

分列读,因为它们分歧。

延迟(ms/step)batch 32 到 128 平在约 13.1 ms,再爬。128 下步被固定代价主导——核 launch、30M 参数上的优化器——batch 几乎免费。128 上 GEMM 占满 SM,延迟随 batch scale。

吞吐(examples/s)一路涨,但回报锐减:batch 1024 翻倍到 2048 买 13% 吞吐花 76% 延迟与 13% 峰值内存。

峰值内存 batch 64 到 1024 几乎不动——814 到 820 MiB——2048 跳。这个 shallow-wide 模型激活小头;峰值是 persistent state 定的,与 batch 无关。(batch 32 的低值是分配器 artifact:留了更小的 workspace。)

最低延迟 batch 是 64(13.1 ms)。最高吞吐 batch 是 2048(30,993 ex/s)。不同 batch,都不是“最快”。训练跑在乎吞吐;交互推理在乎延迟;内存受限微调在乎峰值。一 sweep,三答案。

延迟、吞吐、峰值内存、冷启动代价别塌成“更快”。干预 routinely 好一个坏另一个。

内存到底去哪了

batch 256 峰值 ~816 MiB。第一步与稳态步每阶段后读 torch.cuda.memory_allocated():

allocated MiB after each phase:
step 1 (cold)    start= 115.9  zero_grad= 115.9  forward= 164.1  loss= 165.0  backward= 247.6  optimizer= 474.6   peak= 588.6
step 3 (steady)  start= 474.1  zero_grad= 360.2  forward= 405.7  loss= 406.7  backward= 475.1  optimizer= 474.1   peak= 589.0

几不同压力现在可分。

这个配置的 persistent state 约 456 MiB:参数、每参数一梯度分配、每参数两 AdamW moment 缓冲。驻留已分配 footprint 的 96%。batch 不改这些张量计数,dtype、优化器选择、梯度清零策略等训练选择能改。

活前向 state zero_grad 到 forward 返回间加约 45 MiB。这里小因为模型 shallow-wide;边界计数器不是阶段里每临时分配的完整清单。

第一步不是稳态。 step 1 优化器阶段 248 到 475 MiB 跳——与第一次 .step() 出现的 227 MiB AdamW moment state 一致。后面每步已有了。第一次优化器步前测的训练内存 substantial 低报稳态训练内存。

峰值不在任何阶段边界。 上面每检查点最多 475 MiB,峰值 589。证明额外 ~114 MiB 在某测量区里 transient 活、下一边界前释放。这个 workload 里峰值位置看,反向临时与重叠的存下激活/梯度分配是 plausible 贡献,aggregate 计数器 alone 唯一定不了这些字节。max_memory_allocated() 露 hidden 峰;峰值归属重要升级工具是内存快照。

OOM 是归属与 scale 问题

CUDA 内存爆时有用回应不是 tricks 列表。是分解:

PERSISTENT      parameters, gradients, optimizer state
SHAPE-DEPENDENT activations, temporary buffers, workspaces
ACCUMULATING    retained graph and tensor references across iterations
ALLOCATOR       reserved blocks, fragmentation, workspace behavior

再一串测量把失败派到其中之一:

干预须跟诊断。persistent state 主导——如受控 workload 96%——batch 减半几乎没用,因为 batch 从不是压力。已分配内存跨相同迭代爬,修复是找 retained 引用,缩 batch 只 delay 同一失败。下面三实验逐分支分解。

真实报告上跑一遍。假设训练 job CUDA out of memory 死,收集的证据是:

batch 32 到 8 减半峰值动 0.8 GiB——几乎不响应,因为 batch 8 下 9.9 GiB 里 9.1 还在。测得的参数字节与第一步优化器分配已 account 大 persistent 成分,平的重复步跟踪反对轮间累积。下个干预应先 target persistent footprint 或剩下固定 workspace,再 assumed batch 形激活主导。batch 缩-margin 仍可能帮忙,测量说它不是主要 lever。

参数字节容易:sum(p.numel() * p.element_size() for p in model.parameters())——受控模型 113.9 MiB。训练内存不容易。它依赖梯度 dtype、优化器、master 权重留不留、优化器 state dtype、激活形状、autograd 存了什么、workspace 行为。别 assumed 梯度总加 exactly 一参数尺寸分配、优化器 state exactly 2×。测:上面计数器就是仪器。

没有通用有用的“典型训练内存 breakdown”饼图。这个 workload 的 breakdown 约参数、梯度、AdamW state、其余 24% / 24% / 48% / 4%——那是 fp32 MLP、AdamW 下 30M 参数的属性,不是训练一般的。bf16 7B 模型、fused 优化器、梯度检查点 profile 完全不同。测你的 workload。

累积分支:retained 引用

这里有个监控循环。只读模型——不训练、不 backward()。

model.eval()                        # eval() is not no_grad()
kept = []
for i in range(60):
    out = model(x)
    kept.append(out.softmax(-1).amax(-1).mean())   # mean top-1 probability
allocated MiB, every 10 iterations:
kept.append(metric)            # forgot no_grad(); metric carries the graph
  i00=  164.1  i10=  542.8  i20=  922.1  i30= 1300.9  i40= 1680.2  i50= 2059.0   -> final 2400.3 MiB
  after empty_cache(): allocated 2400.3 MiB

with torch.no_grad(): ...       # graph never built
  i00=  124.1  i10=  124.1  i20=  124.1  i30=  124.1  i40=  124.1  i50=  124.1   -> final 124.1 MiB

kept.append(metric.item())     # keep a float, not a tensor
  i00=  164.1  i10=  164.1  i20=  164.1  ...                                     -> final 162.0 MiB

三变体 metric 都是 0.001034——算子相同。不同的是 Python 活着什么。第一版 metric 是仍连该轮前向 autograd 图的张量,每轮图的每元——十二层存下激活约 38 MiB——列表握着标量就一直 reachable。六十轮,六十图,线性爬到 2.4 GiB。

这是第 3 章的课循环尺度。它不是泄漏:每字节都从活 Python 名字 reachable。model.eval() 置模块树 flag;不关 autograd,图建不建都建。torch.no_grad() 才拦建图。.item() 才留数不留张量。

torch.cuda.empty_cache() 这里什么都不做——之前 2400.3 MiB 之后 2400.3 MiB。empty_cache() 还没用缓存块给 driver。这些块不是没用;装着活激活。Python 还引用的张量分配器调用释放不了。

固定 workload 下 memory_allocated() 跨相同迭代爬,活 PyTorch 分配集在长大。这个实验病因是 retained autograd 图;不熟悉系统里也可能是故意 state 或别的长大的 owner。先跟踪归属再怪缓存分配器或只缩 batch。

已分配、保留与第三个数

三计数器,三故事。分配 400 MiB 张量,删 Python 引用,再 empty_cache(),每步读一切:

                                    allocated   reserved   max_reserved   nvidia-smi (this process)
steady state                           474.1      664.0        664.0        [N/A]
after allocating a 400 MiB tensor       874.1     1064.0       1064.0        [N/A]
after 'del big' (Python ref gone)       474.1     1064.0       1064.0        [N/A]
after torch.cuda.empty_cache()          474.1      542.0       1064.0        [N/A]
  • del big:allocated 降 400 MiB(张量释放),reserved 留 1064(缓存分配器留块,下次同样尺寸分配不用进 driver)。
  • empty_cache():allocated 不变(没释放活张量),reserved 降到 542(没用块还给 driver)。max_reserved 仍 1064——它是 high-water mark,不是当前值。
  • nvidia-smi 这个 WDDM Windows driver 上根本 attribution 不了 per-process 内存——返回 [N/A]。整机显示进程启动前 2596 / 12288 MiB 在用,compositor 等占用。那是第四个数,PyTorch 控不了。

reserved > allocated 不是泄漏。是缓存分配器干活。nvidia-smi 报大数也不是泄漏;它含 CUDA 上下文、compositor、别的进程、保留未用块。单计数器没有一个等于“模型用的内存”。

torch.cuda.empty_cache() 释放 PyTorch 握着的没占用的缓存块让别的 GPU 用户看见/用。它释放不了活张量,不增加 PyTorch 活分配可用的内存;当前 PyTorch 文档还说它某些情形可能降碎片。这让它是分配器管理工具,不是通用泄漏修复。hot 训练循环反复调它通常扔掉有用的缓存复用,还改了 benchmark 的 workload。

本章在某些孤立 benchmark 配置间 deliberate 用它降没用缓存块的 carry-over。即便如此,别把所得分配器 state 叫“干净”:活张量、CUDA 上下文 state、库 workspace、分配历史都可能不同。

深分配器 forensics 用 torch.cuda.memory_summary() 打印详细块报告,下划线 torch.cuda.memory._record_memory_history() / _dump_snapshot() API 抓分配栈离线看。当 escalation 工具、当 advanced、不太稳定接口——先 aggregate 计数器,计数器不够再快照。

同步税

loss.item() 从设备拷一标量到主机,为此须等产出 loss 的 work 做完。每步调,串行化循环吗?吞吐测,记的值 checked 不变,交错 A/B 让 effect 在跑间 drift 下 resolvable:

device-bound step (dim1536 depth12 batch256, ~16 ms/step), interleaved A/B:
  none        median 16.201 ms
  item_every  median 16.633 ms
  difference  +0.432 ms/step (+2.7%)

small fast step (dim256 depth4 batch64, ~1 ms/step):
  no host read of any device scalar                    28292 ex/s   2.262 ms/step   rel 100.0%
  loss.item() every step                               27660 ex/s   2.314 ms/step   rel  97.8%

device-bound 步税 +0.43 ms——约 2.7%,交错对比才 resolvable,因为贴着跑间噪声层。小快步约 2%。两情形税都小因为两步都 device-bound:主机几轮内反正等队列。税大只在主机本可远远跑在设备前、每步同步拦住它时。

去掉每步同步不丢数的模式:running total 留设备上,记日志时才读:

running = torch.zeros((), device="cuda")
for i in range(steps):
    loss = train_step()
    running += loss.detach()                 # stays on the device, no sync
    if (i + 1) % 50 == 0:
        print((running / 50).item())          # one sync every 50 steps
        running.zero_()

记的 running-mean 损失每步读、五十步读、设备累积读一次,小数五位相同。所以教训不是“.item() 慢”也不是“别记”。而是:

知道主机/设备同步在哪发生,频率是不是 workload 契约的一部分。每步记日志是选择;五十步记是另一选择;测你在做哪个。

print()、.cpu()、.tolist()、if loss > threshold 与别的要主机拿设备值的东西一样。

profiler 定位,不测量

粗分解不够——知道反向贵不知哪个算子——profiler 把设备时间归到单个核。schedule 让它记几代表步而不是几百,record_function 范围标自己的边界:

from torch.profiler import profile, schedule, ProfilerActivity, record_function

with profile(
    activities=[ProfilerActivity.CPU, ProfilerActivity.CUDA],
    schedule=schedule(wait=5, warmup=5, active=10, repeat=1),
    profile_memory=True,
) as prof:
    for _ in range(20):
        with record_function("forward"):   logits = model(x)
        with record_function("loss"):      loss = F.cross_entropy(logits, y)
        with record_function("backward"):  loss.backward()
        with record_function("optimizer"): opt.step()
        opt.zero_grad(set_to_none=True)
        prof.step()
record_function phase ranges (total device time over 10 steps):
  forward      device_time_total   33.591 ms
  loss         device_time_total    0.870 ms
  backward     device_time_total   78.494 ms
  optimizer    device_time_total  114.727 ms

top operators by self CUDA time:
  backward (autograd)        78.3 ms
  aten::mm                   46.5 ms
  aten::addmm                27.1 ms
  aten::_foreach_mul_        22.5 ms      \
  aten::_foreach_addcdiv_    18.6 ms       |  the AdamW step,
  aten::_foreach_addcmul_    14.6 ms       |  death by a thousand
  aten::_foreach_add_        14.0 ms       |  elementwise kernels
  aten::_foreach_sqrt        11.5 ms      /

profiler 独立支持阶段分解的意外:优化器是记录的最大阶段,trace 被一长串多张量逐元算子主导,不是一 GEMM 样核。那是定位——更 fuse 的 AdamW 实现值得测。每阶段 total 被 profiling perturb(优化器 11.5 ms/step 对无 profile 9.0 ms),profiling 扭曲比例也扭曲绝对时间。trace 形成机制假设,再用无 profile 干预验证假设。

看代价:

profiled step:   median 26.121 ms
unprofiled step: median 16.532 ms
profiler overhead: +9.589 ms (+58.0%)

profile 步比真步慢 58%。profiler 的工作是告诉你时间在哪,按比例——不是步花多少。工作流固定:

unprofiled benchmark  ->  profile a few representative steps  ->  hypothesis
->  change one mechanism  ->  unprofiled benchmark again

拿 profile 计时和无 profile 基线比,差叫加速,是错的。profiler 是定位仪器,每仪器 perturb 被测的东西。

混合精度:实验,不是建议

torch.autocast 让选定算子低精度 dtype 跑。帮不帮是这个硬件这个 workload 的问题,三测量分开回答——时间、内存、数值——永不合成一 verdict。

scaler = torch.amp.GradScaler("cuda", enabled=(dtype == torch.float16))
with torch.autocast(device_type="cuda", dtype=dtype):   # float16 or bfloat16
    loss = F.cross_entropy(model(x), y)
scaler.scale(loss).backward()
scaler.step(opt)
scaler.update()

单步数值,对 fp32:

fp32   loss 6.90711   grad-norm 0.06892
fp16   loss 6.90710  (Δ 1.05e-05)   grad-norm rel Δ 8.33e-05
bf16   loss 6.90735  (Δ 2.34e-04)   grad-norm rel Δ 1.70e-03

单步两者都在训练 tolerance 内;bf16 偏差大是尾数短。百步三者损失都有限。现在时间内存,两 batch:

batch 256:   config             ms/step   examples/s   peak MiB
             fp32                16.469       15544       588.1     time 100.0%  mem 100.0%
             autocast fp16       15.722       16283       588.1     time  95.5%  mem 100.0%
             autocast bf16       22.301       11480       588.1     time 135.4%  mem 100.0%

batch 2048:  config             ms/step   examples/s   peak MiB
             fp32                66.262       30907       699.7     time 100.0%  mem 100.0%
             autocast fp16       26.590       77020       603.9     time  40.1%  mem  86.3%
             autocast bf16       94.186       21744       603.9     time 142.1%  mem  86.3%

同样 autocast(dtype=torch.float16) 调用 batch 256 近中性(95.5%——几个百分点,噪声边)、batch 2048 transformative(fp32 时间 40%,吞吐 2.5×)。batch 256 步 optimizer-bound,fp32 优化器 autocast 碰不到,GEMM 加速几乎不动。batch 2048 GEMM 主导步,Turing fp16 tensor core 减半它们。

bfloat16 两尺寸慢 35–42%,因为算力 7.5 无 bf16 tensor-core 路——API 接受,核 fallback 慢路。

峰值内存只 batch 2048 降(86%),激活真占比处;batch 256 峰值是 persistent fp32 state,autocast 不改。这与按阶段内存实验同一发现,换方向到来。

“AMP 该更快”是假设。答案是这个硬件这个 batch 的三数——时间、内存、数值。

激活检查点:先测量再挣

激活检查点反向重算激活不存它们。拿算子换内存。加上前先确立激活内存是不是问题——按阶段内存实验已 show batch 256 下它是 816 MiB 峰值里的 ~45 MiB,答案否。反正两 batch 都测:

from torch.utils.checkpoint import checkpoint

def forward(self, x):
    for block in self.blocks:
        x = checkpoint(block, x, use_reentrant=False) if self.training else block(x)
    return self.head(x)

同样仪器,相反 verdict。batch 256 检查点多花 33% 时间,什么都没省——丢的激活不是定峰值的。batch 4096 多花 31% 时间,省 288 MiB(28%),装得下与装不下的区别。verdict 不是检查点的属性;是激活占不占峰值主导的属性,先测。

这个确定性 MLP 检查点复现测得损失与梯度范数 exact。别把这个观察 promote 成通用不变量:检查点反向重跑前向区,随机、可变全局/模块 state、设备移动、前向/重算 mismatch 都能改行为。PyTorch 默认保留相关 RNG state 让常见随机情形一致,有性能代价,当前推荐显式传 use_reentrant=False 因为那个实现支持更多 autograd 功能。

梯度累积:动什么,不动什么

batch B 切 K micro-batch,每损失除 K,step 一次,近似全 batch 梯度:

opt.zero_grad(set_to_none=True)
for k in range(K):
    xs, ys = micro_batch(k)
    (F.cross_entropy(model(xs), ys) / K).backward()
opt.step()
gradient equivalence (accumulated K micro-batches vs one full batch of 4096):
  K=2: max abs diff 4.64e-10   (gradient scale ~1.70e-03)
  K=4: max abs diff 2.02e-09
  K=8: max abs diff 2.01e-09

  K   micro-batch   ms/step   peak MiB
  1         4096    121.115    1249.1     peak 100%   time 100%
  2         2048    126.096    1054.2     peak  84%   time 104%
  4         1024    129.921     892.7     peak  72%   time 107%
  8          512    138.977     838.5     peak  67%   time 115%

累积梯度与全 batch 梯度对到浮点 roundoff(梯度尺度 ~2e-3 下 ~2e-9)。峰值内存 K=8 到 67%——活激活集现在是一 micro-batch,不是整 batch——时间代价 15%,多核 launch 与更小低效 GEMM。

K 不改的是模型参数、梯度缓冲、优化器 state 的形状与存储需求。累积梯度值这里数值等价——上表已测 roundoff 差到 2e-9,逐字节不相同。累积降活 micro-batch 相关 footprint;去不掉模型优化器 state。K=8 下观测 ~839 MiB 因而是这个实验的实用 floor,不是剩每字节都是 persistent state 的证明:一 micro-batch 与临时 workspace 还在。

一正确性 caveat:等价 assumed 每算子 batch 线性或样本独立。BatchNorm、某些对比损失、别的依赖 micro-batch 里别的样本的东西不复现全 batch 结果。你的模型数值验证等价而不是 assumed。

序列长与核物理分配什么

注意力的代价常说“序列长二次”。精确说什么。逻辑关系是 Tq × Tk——每 query 位置对每 key 位置打分——每注意力实现都 true。变的是核物理分配什么。

第 10 章手工实现显式物化分数矩阵:

scores = (q @ k.transpose(-2, -1)) / math.sqrt(Dh)   # [B, H, T, T], stored for backward
weights = scores.softmax(dim=-1)                       # another [B, H, T, T]
out = weights @ v

F.scaled_dot_product_attention 是 dispatcher:CUDA 上可能选 fused/内存高效后端,输入可用性看 fallback math 实现。这个 PyTorch 2.6 / Turing 实验选了不像手工实现物化同样完整分数/权重张量的内存高效后端。选定的路与手工版前向反向比序列长,B=4, H=8, Dh=64:

     T  manual ms  manual MiB   SDPA ms   SDPA MiB   max|Δ out|
   256      0.951        58.3      1.349       38.3    5.66e-07
   512      3.111       168.3      4.840       62.4    7.75e-07
  1024     11.023       576.3     16.095      108.6    7.75e-07
  2048     42.616      2160.3     60.200      201.0    8.49e-07
  4096        OOM         OOM    234.921      353.8           -

手工版峰值内存 T 翻倍快速四倍,因为显式存 B·H·T·T 分数概率张量;B·H·T·T·4 字节 T=2048 下单 fp32 矩阵 512 MiB。T=4096 手工路 OOM。这台机器选的 SDPA 后端测得峰值分配慢得多,T=4096 354 MiB 跑了。输出 agree 到约 8e-7。

选定的后端没去掉的是稠密两两算子:精确稠密注意力仍 Tq × Tk 交互,内存不大时 runtime 仍可序列长二次。这个 specific PyTorch 2.6 / Turing setup 选的是内存高效 SDPA 后端而不是 Flash Attention。T 小手工 matmul/softmax 路反而快,固定开销与后端选择是 workload-specific 结果的另一提醒。

两两关系 Tq × Tk 结构性。选定的核为它分配什么是实现选择。两都测,别 assumed 现代注意力核物化分数矩阵。

torch.compile 当优化候选

默认 Inductor 后端,torch.compile 试图捕获 Python/PyTorch 程序的可编译区,优化,生成或调用高效核。可能 fuse pointwise work,对已高度优化的算子调 cuBLAS 等外部库,编译区间留图断裂。帮不帮像别的干预一样测——两边契约 hold constant:

                    eager                 compiled
MODEL               same state            same state (deepcopy)
INPUT               [256, ...]            [256, ...]  same shape
DTYPE / DEVICE      float32 / cuda        float32 / cuda
MODE               eval, no_grad          eval, no_grad
SYNC BOUNDARY       synchronize both ends  synchronize both ends
MEASURED ITERS      N                     N   (never cold-compiled vs warm-eager)

用交错 A/B,共享 GPU 上的机器 drift 变不出不存在的加速。

def interleaved_ab(step_eager, step_compiled, blocks=12, inner=30):
    for _ in range(20): step_eager(); step_compiled()   # warm both
    torch.cuda.synchronize()
    a, b = [], []
    for _ in range(blocks):
        # time a block of eager, then a block of compiled, and repeat
        a.append(timed_block(step_eager, inner))
        b.append(timed_block(step_compiled, inner))
    return median(a), median(b)

两 workload 跑:受控 GEMM-bound MLP,pointwise-only 链(四十层 tanh、scale、shift、mean-subtract、sigmoid——无大 matmul)。

[GEMM-bound MLP  (dim1536 d12, batch256, forward)]
  eager steady (interleaved median)   :    2.924 ms   (block spread 2.90..3.21)
  compiled steady (interleaved median):    2.959 ms   (block spread 2.94..2.98)
  speedup                             :    0.988x
  correctness max|Δ| vs eager         : 1.30e-08
  peak MiB  eager 130.0  compiled 130.0

[pointwise chain (dim4096 depth40, batch256)]
  eager steady (interleaved median)   :    9.009 ms
  compiled steady (interleaved median):    0.727 ms
  speedup                             :   12.399x
  correctness max|Δ| vs eager         : 4.35e-04
  peak MiB  eager 144.1  compiled 140.1

同样 torch.compile(model) 调用 GEMM-bound MLP 中性(0.99×,块间 spread 内),pointwise 链 12.4× 加速。机制解释 split:MLP 时间在大 cuBLAS GEMM 核,已近最优,Inductor 原样调入;pointwise 链是两百小逐元核,代价是 launch 开销与内存往返,Inductor fuse 成 essentially 一核。同样方法,两 workload,相反 verdict,机制预测哪个是哪个。

正确性列让性能数可用。MLP 输出与 eager 差至多 1.3e-8;pointwise 链差 4.3e-4。编译器允许选数值不同的浮点 schedule 而实现同样意图函数,两差都不该单从 dtype 标 acceptable。4.3e-4 接受否归算子的 tolerance 或任务层契约;本章记数不 assumed 答案。

编译代价不是一数。新进程编 pointwise 链跑脚本,一次清盘上 Inductor 缓存、一次复用:

MODE=cold  first_compiled_call_s=10.945   steady_state_ms=0.892
MODE=warm  first_compiled_call_s= 2.542   steady_state_ms=0.885

冷 Inductor 缓存首编译调用 10.9 s。复用盘上缓存的新进程 2.5 s。稳态两种一样。所以 break-even——稳态收益还编译代价要多少调用——取决于哪个编译代价:

百万步训练跑,任一都 trivial。编译、跑五十推理、退出的脚本,编译就是整个 runtime。

编译结果失望——稳态慢、新形状停下再编、日志提重编译、图断裂打碎程序——本章的工作是分类它(编译代价主导 / 稳态更慢 / 新形状 / 图断裂)并停。第 13 章拥有图断裂、守卫、重编译、动态形状、后端选择。第 12 章只回答“编译改善这个 workload 吗,测了哪个代价”。

性能台账

第 7 章有阶段报告,第 8 章有形状台账,第 10 章有注意力台账,第 11 章有学习台账。本章的仪器机制挣到后组装,记录性能结果须暴露的东西,让读者问哪个资源边界主导。

PERFORMANCE LEDGER   MLP dim1536 depth12   AdamW   CUDA

workload    train step | batch [256, 1536] | float32 | cuda | eager
benchmark   warmup 30 | repeats 400 | step latency 16.4 ms (IQR 0.19) | 15500 examples/s
phases      input wait 0.2% | h2d 1.8% | forward 17% | backward 28% | optimizer 51%
memory      peak allocated 589 MiB | peak reserved 664 MiB | persistent 456 MiB | activations 45 MiB
correctness loss finite | one fused-optimizer step within 4e-9/element of foreach
measurement synchronized at both ends | uninstrumented | first step excluded

价值不是具体数。而是性能断言该说什么 workload 被测、时间在哪累积、内存在哪见顶、怎么测的——下个问题(“哪个资源是 limit”)才有证据而不是反射。

测不诚实的 row 别发明。无 CUDA 机器阶段行仍拆前向/反向/优化器,内存行用子进程 VmHWM,行写 CPU,不做 fp16、CUDA-event 断言。

完整走一遍:测量、定位、干预、再测

四词是流程。受控 workload 端到端跑一遍。

测量。 benchmark 预热同步。中位步延迟 16.4 ms,IQR 0.19 ms,四百步。契约记下:train step、MLP dim 1536 depth 12、batch [256, 1536]、float32、cuda、eager、指标 ms/step、窗口稳态。

定位。 阶段分解说:前向 17%、反向 28%、优化器 51%。profiler 十代表步上同意排序,加细节:优化器阶段含一长串 _foreach_* 逐元核,单无主导,十 profile 步合 115 ms 设备时间记录。trace 支持机制假设——AdamW 逐元更新的重复内存流量加 launch 开销——但计时 alone 不是硬件带宽证明。

假设。 foreach 实现的核/内存流量开销是优化器阶段大的原因,更激进 fuse 的 AdamW 实现该缩减该阶段,同时保留优化器意图更新语义。torch.optim.AdamW(..., fused=True) 是待测干预。

干预。 改一处:foreach=True → fused=True。别无其他。

正确性检查。 同样 state 同样梯度后一更新步,与 foreach 更新每元差至多 3.7e-9。这个实验里性能干预保留意图 AdamW 更新的强单步证据;不是逐比特相同,不保证两长浮点轨迹数值锁死。真任务用显式 tolerance 或任务层等价标准。

同样契约再测。 孤立优化器阶段 9.0 到 5.5 ms。端到端 back-to-back 步 19.1 到 14.4 ms——延迟低 24%、吞吐高 32%。(这里 19.1 ms foreach 数跑在上面基线之上,因为这对 desktop 更忙;配对比较是相关证据,与另一 session 的测量比比值不是。)

记录测得的 trade-off。 延迟降 ~24%。吞吐涨 ~32%。这个 workload 测得峰值分配没涨。预热排除首步行为。陈述的契约内没测得的维度 regress,比叫优化“免费”窄得多、defensible 得多。

与它替代的反射对比。“模型慢,加 torch.compile” target 模型 body,阶段分解说优化器是最大代价。下面编译实验里 GEMM-bound 模型 body 中性 0.99×;只编那个模型解决不了测得的优化器瓶颈。测量才指向对的机制。

Forensic 模式 vs 性能模式

本书重度 lean 仪器:hook、detect_anomaly、profiler、内存历史记录、verbose 断言、到处 record_function。每样都花时间,本章测了几样:

instrument                              measured cost on the controlled step
per-phase torch.cuda.synchronize (x7)   +0.8 ms   (+5%)
torch.profiler with a schedule           +9.6 ms   (+58%)
.item() every step                       +0.4 ms   (+3%)

两模式分开,测量别搞混:

FORENSIC MODE     maximize evidence: hooks, anomaly detection, profiler,
                  memory-history, verbose logging, per-phase synchronization
PERFORMANCE MODE  remove every instrument that is not part of production behavior

别优化仪器版 assumed 生产 workload 同样变。profile 步减半的优化可能对真步什么都不做,忘关的仪器是 ship 的回归。

无 CUDA 设备

上面全 assumed GPU。CPU 上问题相同,仪器缩小:

  • 开篇失败不是异步——CPU work 同步——而是冷 vs 稳态陷阱:eager vs torch.compile 的没预热 benchmark 能报告编译版慢几倍,纯因首调含编译。预热交错对比看稳态差,GEMM-bound 步通常噪声内。
  • 阶段分解、batch sweep、profiling、torch.compile、CPU autocast、检查点、累积仍可用,设备相关计时内存仪器须替换不能照抄。
  • CUDA 的 memory_allocated() / max_memory_allocated() 计数器 CPU 无直接等价。进程层峰值内存,fresh 子进程隔离配置,OS 恰当指标如 Linux VmHWM;那测进程 RSS high-water mark,不是 PyTorch 张量分配台账。
  • CUDA-only 机制——memory_allocated vs reserved、empty_cache、CUDA event、.item() 同步税、fp16 tensor core——对装的 PyTorch 验证,给 runnable 代码,计时写明那台机器没跑。

约束说一次在前,别再道歉。

在慢 workload 上用 AI

问助手“怎么更快”,得到列表——AMP、大 batch、torch.compile、更多 worker、empty_cache()、检查点。每项都是真瓶颈的真优化。没有一项是关于你瓶颈的证据,用错的那个花一天什么都不动。

下面 prompt 拒绝优化,先要重建。故意长;结构就是价值。

My PyTorch training step is slower (or uses more memory) than I expect.

Do not suggest optimizations yet. Do not mention AMP, torch.compile,
checkpointing, larger batches, empty_cache or more workers until a
measurement identifies a mechanism one of them could affect.

First, reconstruct the measurement contract from what I give you:
  workload (train / inference), model, input shape, dtype, device,
  execution mode (eager / compiled), metric (latency / throughput /
  peak memory), measurement window (cold / warm), synchronization boundary.
State which of these I have not specified.

Then classify the evidence I provide:
  - step latency, warmed and synchronized, with a robust spread
  - time by phase: input wait, host-to-device, forward, loss, backward,
    optimizer, logging  -- and whether the phase sum matches the total
  - memory: allocated, reserved and peak, phase by phase, and their trend
    across identical iterations
  - if compiled: eager steady state, compiled first call, compiled steady
    state, and whether new shapes trigger fresh compilation

Identify the FIRST measurement or resource boundary that is not yet
supported by evidence.
  - If the benchmark itself is invalid (no warmup, no sync, a metric that
    does not match the question), stop there. The benchmark is the bug.
  - Otherwise: state the bottleneck hypothesis, the smallest intervention
    that tests it, which metric should improve if the hypothesis is right,
    which correctness property must stay unchanged, and which competing
    explanation the experiment distinguishes.

三句赚回位置。禁干预段拦住助手在任何测量 justify 前伸手拿训练数据里讨论最多的优化。问哪个正确性属性须不变,proposed 实验可证伪而不只是 confirmatory——混合精度、检查点、编译实验全带正确性列正为这个。问区分哪个竞争解释,不让“试试 AMP 看看”,它发生什么事后都圆得上。

让 AI 先重建 benchmark,再让它优化代码。

性能调试序列

 1. Define the workload. Write the measurement contract: model, input shape,
    dtype, device, mode, execution, metric, window.

 2. Define the metric. Latency, throughput, peak memory and cold-start cost are
    different questions. Pick the one the job cares about.

 3. Prove the benchmark. Warm it. Synchronize around the region. Take repeated
    measurements and a robust summary (median, IQR). If the number moves with
    loop length or a stray sync, it is not measuring the work.

 4. Record the baseline. This is what every later change is compared against,
    under the same contract.

 5. Separate the phases. Input wait, host-to-device, forward, loss, backward,
    optimizer, logging. Synchronize deliberately at each boundary. Check the
    phase sum against the uninstrumented total.

 6. If input wait dominates, stop here and return to Chapter 6.

 7. Profile only after the coarse boundary is known. Use a schedule and
    record_function ranges. Measure the profiler's own overhead. Never compare
    a profiled timing to an unprofiled one.

  8. Distinguish allocated, reserved and peak -- phase by phase, and across
    repeated identical iterations. If allocated memory keeps climbing under a
    fixed workload, some set of live PyTorch allocations is growing; trace its
    owner. High reserved memory alone is not evidence of a live-tensor leak.

  9. Decompose any OOM: persistent state, shape-dependent memory, accumulating
    references, allocator behavior. Choose the intervention that matches the
    diagnosed source.

10. Form one mechanism hypothesis. Name the resource you believe is the limit.

11. Change one thing.

12. Verify correctness. A performance change that alters the computation is a
    regression. Use explicit tolerances for transformations expected to differ
    numerically (AMP, fused kernels, compilation).

13. Rerun the uninstrumented benchmark under the original contract.

14. Record the tradeoff across every dimension: latency, throughput, peak
    memory, cold-start cost. An improvement in one is not an improvement.

15. Only then test a larger intervention -- mixed precision, checkpointing,
    accumulation, compilation -- each as its own measured experiment.

16. If torch.compile itself becomes the unexplained problem -- seconds on the
    first call, a new shape pausing again, logs suggesting recompilation,
    graph breaks -- gather enough evidence to classify it and hand off to
    Chapter 13. Preserve the baseline and the contract.

你现在应该能回答什么

先自己走一遍再看 resolution。

“GPU 利用率低,所以加 num_workers。” 利用率是有很多病因的症状:输入等待、主机到设备传输、主机同步、launch 与 Python 开销、填不满 SM 的小核、带宽 limit、核间 gap、并行 work 不够。先来的测量是阶段分解:步里输入等待到底占多少?不是最大阶段,worker 是错 lever。

“nvidia-smi 说内存满,所以 PyTorch 泄漏。” nvidia-smi 与 PyTorch 分配器计数器回答不同问题,这台机器显示栈在 workload 开始前已占可观 GPU 内存。固定 workload 下看已分配、保留、峰值。已分配平、保留高可以是正常缓存分配器行为。已分配在相同迭代 climb,活 PyTorch 分配在累积;再跟踪归属,别单从计数器点名病因。

“empty_cache() 让数降了,所以修了泄漏。” 它降的是 reserved,把没用缓存块还给 driver。allocated 没动,因为活张量释放不了。泄漏是 retained-graph 列表,empty_cache() 对它什么都没做——监控循环爬到 2.4 GiB,empty_cache() 后还是 2.4 GiB。

“batch 64 比 batch 32 慢。” 延迟差不多,吞吐翻倍,峰值内存更高。“慢”不说指标就不是 batch 的属性。

“torch.compile 更慢。” 怎么慢?首调用 2.5–10.9 秒与稳态结局无关。测的是首调用,测的是编译。预热稳态还慢,那是第 13 章的问题。MLP 编到 0.99×——中性——pointwise 链到 12.4×,同样调用。

“AMP 该更快。” 这块 Turing GPU 上 autocast(float16) batch 256 几个百分点内、batch 2048 2.5×;autocast(bfloat16) 两尺寸慢 35–42%,因为硬件无 bf16 tensor core。答案是你硬件你 batch 的时间、内存、数值——三数,测的,不是一假设。

“profiler 说 aten::mm 贵。” 十 profile 步上自 CUDA 时间 47 ms——但 profile 步比真步慢 58%。问题是 mm 在无 profile 在乎的指标里占比够不够打。这里是:GEMM 是优化器后第二大真代价。

“阶段计时加起来比步大。” 逐阶段同步 perturb workload,分开测的阶段中位和数学上不必等于整步中位。这里 gap 约 0.8 ms,分解仍定位主导阶段。别把 gap 当精确修正减掉。gap 大到改变诊断,用 CUDA event、profiler 范围或别的 perturb 小的归因办法,无仪器 benchmark 验证干预。

“第一次 optimizer.step() 前测了训练内存。” 那测的是无优化器 state 的内存,AdamW 第一步 lazy 分配它——受控模型 227 MiB,构造 OOM 里 3.1 GiB。内存 profile 至少第二步起,冷步与稳态分开。

“序列长翻倍内存四倍。” 那是显式物化 [B, H, T, T] 分数矩阵的签名。是那个实现的属性,不是注意力。fused/内存高效核保持 T×T 逻辑关系而分配少得多;算子仍 O(T²)。先查跑的是哪个核再下结论。

“编译比 eager 快 3%。” 共享机器上 3% 比两测量间 drift 大吗?交错 A/B 跑——轮流块抽样 pool——看块间 spread。3% 在里面,差没 resolved,报加速是报噪声。

“怎么优化?” 先给测量契约与基线。其余都是猜。

练习

  1. 复现撒谎的 benchmark。 受控训练步 10、50、400 轮 unsynchronized 计时,每循环后 torch.cuda.synchronize() 记 block 多久。再预热同步计时。解释短循环为什么低估、长循环为什么收敛、两者为什么都低于同步数。
  2. 四问题。 一模型一 batch 四计时:inference_mode 下前向、开 grad 前向、前向加反向、全训练步。解释每数何用。再加 torch.compile 四都计时,首调用与稳态分开。
  3. 阶段分解与优化器。 自己训练步七阶段逐阶段同步分解。阶段和与无仪器步对。认出最大阶段。是优化器,孤立 .step() 比 SGD、SGD(momentum=0.9)、AdamW(foreach=True)、AdamW(fused=True),说出哪个交换只换性能、哪个换训练动态。
  4. 延迟 vs 吞吐。 batch 至少五值 sweep。记 ms/step、examples/s、峰值已分配内存。别预设曲线形状。再答三独立问题——最低延迟、最高吞吐、装得下的最大 batch——证明三答案不同。
  5. 按阶段内存,第一步 vs 稳态。 step 1 与 step 4 每阶段后读 memory_allocated(),再记 max_memory_allocated()。判定峰值在阶段边界可见还是某阶段里 transient。量化第一优化器步出现、后面留下的 persistent state 多少。
  6. 建 retained-引用泄漏。 监控循环往列表 append 图连标量,看已分配内存线性爬。torch.no_grad() 与 .item() 两种修,确认监控量不变。泄漏版上调 empty_cache() 证明什么都收不回。
  7. 已分配、保留、nvidia-smi。 大 transient 分配、删引用,再 empty_cache(),每步读三计数器。解释 del 为什么动 allocated 不动 reserved,empty_cache() 为什么动 reserved 不动 allocated,nvidia-smi 报告两 PyTorch 计数器都没有的什么。
  8. 两 batch 检查点。 先确立测得 footprint 里 batch/激活相关多少。再正常与检查点在小 batch、大 batch 各比。记峰值内存、步时间、正确性检查四数。verdict 不同别 assumed;测到的 trade-off 是什么解释什么。
  9. 混合精度,三数。 fp32 对 autocast fp16、bf16(硬件支持的)比。时间、吞吐、峰值内存、单步数值检查分开报告。小 batch、大 batch 各做,verdict 不同解释差。
  10. torch.compile,两 workload。 GEMM-heavy 模型与 pointwise-heavy 模型各编。交错 A/B 对 eager。记 eager 稳态、编译首调用(冷热缓存)、编译稳态、正确性、峰值内存。每推 break-even。机制解释 verdict 不同。

下一步:编译本身成谜

第 12 章留下正确性第 11 章确立、契约下基线测好、时间定位到阶段与算子、内存分解成 persistent、形状相关、累积、分配器压力的模型,候选优化——混合精度、检查点、累积、编译——能诚实比,每带正确性列。

性能调试动作走完:

define the workload  ->  prove the measurement  ->  localize the limiting resource
->  change one mechanism  ->  remeasure every dimension

但末实验开了没走进去的门。torch.compile 一 workload 中性、一 workload 12.4×。首调用 2.5 到 10.9 秒。那里面有套有自己隐藏结构的系统——捕获图、守卫、重编译——它 misbehave 时性能方法没问题可问。

第 12 章问:编译帮忙了吗?

第 13 章问:编译器捕获什么,什么假设让图失效,为什么又编?

那是不同的调查,从这里止处开始。

性能不是从机器读的数。是你构造的比较。定义 workload,证明测量,定位 limiting 资源,改一机制,再测。