首页 文章 精选 留言 我的

精选列表

搜索[infra],共607篇文章
优秀的个人博客,低调大师

AI Infra 系列 · 第三章 存储层(下):训练慢别改学习率,先看 DataLoader

## 一、一个反常识的账 书里有句话值得贴在显示器上: > **调优不当的输入管道可能浪费 50% 的 GPU 时间,而算法优化通常只给几个百分点** 这个数字不是危言耸听。数据管道的活儿听起来不高级——读文件、解码、裁剪、分词、打包成 batch——但它卡在 GPU 和存储之间,是最后一道闸门。这道闸门卡了,前面 GPU、网络、存储的所有优化全白费。 ![fig8-gpu-breakdown.png](https://developer.qcloudimg.com/http-save/yehe-11479707/1ca9c707fede0f3ad5ae4e38d3e88b9d.png) 这张图是示意。真实比例因人而异,但「等数据 30% → 5%」这个区间在行业里反复出现(PyTorch Profiler 社区案例)。核心逻辑是:GPU 利用率每提高 1%,对千卡集群都是真金白银的硬件成本下降。 ## 二、DataLoader 的几个旋钮 PyTorch 的 DataLoader 是多数人的第一站。它有几个旋钮,默认值通常偏保守: - **`num_workers`**:多少个进程并行取数、预处理。太少 GPU 饿着,太多 CPU 和 I/O 争抢。经验值是 CPU 核数的一半到四分之三,但最终要测。 - **`pin_memory=True`**:把数据锁在固定内存里,主机到 GPU 的 DMA 拷贝更快,还能真正异步。记得把 `ulimit -l` 调高,否则大块的固定内存分配会失败。 - **`prefetch_factor`**:每个 worker 提前加载几批。默认 2,I/O 有突发时调到 4 或 8。 - **`persistent_workers=True`**:worker 跨 epoch 存活,省掉每个 epoch 边界重建进程的开销,短 epoch 场景尤其明显。 这些参数没有银弹,但「默认值够用」在数据管道上是错的——绝大多数人的瓶颈就藏在这几个默认值里。 顺带提一句分布式场景:PyTorch 的 `DistributedSampler` 负责把全局数据集切片到各个 rank,每个 rank 读自己那一份。配合 DataLoader,能从几个 GPU 平滑扩到几百个而不打乱数据分布。 ## 三、CPU 准备数据,GPU 算数据,得重叠 数据管道的理想状态是一条流水线: ![fig7-pipeline.png](https://developer.qcloudimg.com/http-save/yehe-11479707/d2b35b3db8108c8412ceadf7c2ba3cf9.png) 当 GPU 在处理第 N 批时,CPU 已经在加载、预处理第 N+1 批,并把第 N+2 批准备好。GPU 算完第 N 批,直接 DMA 拿走第 N+1 批,立刻开工,中间不停。 这条流水线的关键,就是第二章反复讲的「重叠」。多数框架在开了多个 worker 后会自动这么做,但你要**监控它真的发生了**——如果看到 GPU 每次迭代开头都空转一会儿等数据,流水线就是断的。 监控方法: 1. 用 `torch.cuda.Event` 包住 `next(data_iterator)` 计时,这就是 GPU 等下一批数据的总空闲时间。 2. 把 `num_workers=0` 再测一次,隔离纯 Python 开销。 3. 用 `torch.cuda.Event` 包住 `.to("cuda")` 计时,看主机到 GPU 拷贝的代价。 两个时间和总 GPU 空闲一比,瓶颈在 Python 还是 H2D,一目了然。 ## 四、数据准备的两种姿势:离线 vs 在线 数据预处理有个根本选择:训练时现做,还是提前做好。 ![fig7-offline-online.png](https://developer.qcloudimg.com/http-save/yehe-11479707/3324dc9f13cd52278f08fd0d77d7c498.png) **在线加载**:训练循环里现读、现解码、现分词。灵活,但每一步都在和 GPU 抢时间。 **离线预处理**:训练开始前,把原始数据一次性处理成干净、定长、二进制化的数据文件,训练时只做轻量的「最后一公里」读取。代价是提前花时间、占额外存储,但换来的是训练时几乎不碰字符串处理、不现分词、读的都是大小均匀的块。 书第 5 章的结论很明确:**几乎永远不该拿原始文本直接训练**。离线预处理花的时间,会通过更快的训练、更快的迭代、更可预测的扩展,加倍赚回来。 一个省钱细节:如果你想训练 N 个 epoch 又不想每个 epoch 现洗牌,可以提前存 N 份不同洗牌顺序的数据副本。用磁盘换时间,在大规模训练里通常是划算的。 ### 一个反共识判断 离线预处理常被当作"灵活性的敌人",但大模型训练里恰恰相反。**把重预处理全部推到离线,训练时的管道越简单,你的迭代速度就越快。** 实时加载的灵活性,很多时候是算法工程师给自己找的借口。 ## 五、DALI:把预处理搬到 GPU 如果预处理太重、CPU 扛不住,NVIDIA 的 DALI(Data Loading Library)能把它搬到 GPU 上。 DALI 用声明式的算子图定义数据管道,解码 JPEG、随机裁剪、缩放、归一化这些活,全在 GPU 上干。书第 5 章有一个直观例子:一个图像视频检测任务,纯 CPU 管道要吃满 8 个核(CPU 使用率 800%),GPU 还偶尔停顿;换成 DALI 后,CPU 降到 200%(两个核),只负责读文件,真正的解码交给 GPU,还能和计算并发。 DALI 有个常见坑:如果你只拿它解压 JPEG,解完立刻把原始像素交回 CPU 做增强和打包,那会多出几趟「主机→设备→主机」的拷贝,把收益全抵消。正确的用法是把 GPU 友好的预处理操作整体融合进 GPU 计算图,让数据尽量别在 CPU 和 GPU 之间来回倒。 ## 六、NeMo Curator:LLM 数据集的离线工厂 对 LLM 来说,数据管道还有个上游问题:TB 级原始语料怎么清洗成能训练的数据集。 NVIDIA 的 NeMo Curator 就是干这个的。它把清洗、去重、分词、洗牌这些重活,分布式地铺到多个 GPU 或节点上离线做,最后打包成少量大文件,或者二进制格式。它还能去重、剔除问题内容、甚至生成合成数据来补充越来越稀缺的高质量人类数据(来源:NVIDIA NeMo Curator 文档)。 用 Curator 的意义在于:把重预处理全部推到训练之前,让训练时的数据管道退化成一个「读取准备好的数据」的简单动作。这样训练作业绝大部分时间都在做前向和反向传播,而不是处理文本、读几百万个大小不一的小文件。 ## 七、踩坑现场:num_workers 设错,GPU 利用率从 80% 掉到 30% 下面是一个基于公开资料整理的典型踩坑模式,不是某一次特定事故,但在很多图像/视频训练里反复出现: **症状**:模型配置没变,训练突然慢了一倍。`nvidia-smi` 显示 GPU 利用率在 30% 左右反复横跳,CPU 使用率也不高,好像两边都没干活。 **排查**: 1. 用 PyTorch Profiler 或 `torch.cuda.Event` 包住 `next(dataloader)`,发现每次取 batch 要等 40–60 ms。 2. 把 `num_workers=0` 再测,发现 Python 主进程单线程解码 JPEG,CPU 被占满。 3. 主机到 GPU 拷贝只有 2–3 ms,说明 H2D 不是瓶颈。 **修复**: 1. `num_workers` 从默认的 2 调到 CPU 核数的一半(例如 8)。 2. 开 `pin_memory=True` 和 `persistent_workers=True`。 3. 把 JPEG 解码和随机裁剪提前离线做,训练时只读二进制 tensor。 **结果**:GPU 利用率从 30% 回到 80%,整体吞吐提升了 2.5 倍左右。这个案例里,算法一点没变,但训练时间直接减半。 ## 八、收尾:先盯数据,再调算法 回到开头那笔账。数据管道的优化,常常比任何算法调整都值钱。 ![fig7-idle-improve.png](https://developer.qcloudimg.com/http-save/yehe-11479707/b956e951b0d57de3bc0e74e94215faa5.png) 这张图展示的是同一个意思:优化前 GPU 大量时间空转,优化后等待时间被压到很低。对千卡集群来说,这个差距就是能不能少租一半机器的区别。 下次训练慢的时候,先别急着换优化器、改学习率。先用 Profiler 看一眼 GPU 到底有多少时间在等数据——找准瓶颈再动手,往往比改算法划算得多。 到这里,存储层(上下两篇)就讲完了。加上前面的性能工程、网络层,goodput 三大元凶里的通信和存储/数据管道,都有了抓手。 --- ## 参考资料 - Chris Fregly, *AI Systems Performance Engineering*, O'Reilly Media(第 5 章 5.10–5.13) - NVIDIA DALI 官方文档 - NVIDIA NeMo Curator 官方文档 - PyTorch DataLoader / DistributedSampler 官方文档 - PyTorch Profiler 社区性能调优案例 > 说明:GPU 时间构成图(fig8-gpu-breakdown.png)为基于书第 5 章典型区间的示意值,非特定集群实测。文中 50% GPU 时间浪费等数字沿用《AI Systems Performance Engineering》第 5 章结论,并结合 PyTorch Profiler 常见案例区间说明。

优秀的个人博客,低调大师

AI Infra 系列 · 第三章 存储层(上):GPU 饿着不是算法问题,是账单问题

## 一、先算一笔钱:GPU 饿着的时候,租金照付 一个 72 卡的 NVIDIA NVL72 机柜,如果每张 GPU 需要 200 MB/s 的训练数据才不闲着,整个机柜需要 **14 到 20 GB/s 的聚合存储带宽**(书第 5 章)。这还只是纯文本 LLM,换成图像、视频这类多模态,需求还要往上翻。 存储喂不上,GPU 就停下来等。你租的卡、买的电、占的机柜,一分钱不会少。 第二章我们讲通信是把 GPU 算出来的结果互相传,存储则是把原始数据从外面送进来。通信慢了,训练卡;存储慢了,训练直接饿。**而且存储的坑最隐蔽**——大家盯着 GPU 和网络,很少有人去算「数据到底跟不跟得上」。 ## 二、数据离 GPU 越近,越快越稳 存储优化的底层逻辑不复杂:**数据离计算越近,越快越稳。** 2026 年主流 AI 数据中心通常把存储分成五层(行业通用分层,参考 disks.us 等 AI 存储架构分析): ![fig6-storage-tiers.png](https://developer.qcloudimg.com/http-save/yehe-11479707/b92d51dad719ff693004c6d37d98fc4b.png) - **GPU 本地 NVMe**:离得最近,放小批次、模型分片缓存,延迟最低 - **节点 NVMe / 本地 RAID**:放检查点,快速重启 - **NVMe-oF 共享池**:跨节点训练,靠 RDMA + GDS 喂多节点 - **高容量 SSD**:放不常访问的大数据集 - **对象存储 / 冷存储**:原始数据、归档 普通团队不用五层全上,但核心思想一样:**工作集放在最快的层,冷数据往下沉。** 别让一块 1 TB 的模型权重,每次都跨网络从对象存储里现拉。 ## 三、小文件是随机读,是存储的隐形杀手 GPU 喜欢大口吃数据,存储也一样——大块顺序读吞吐比小块随机读高一个数量级。 一个常见坑是:训练图像时存了几百万个独立小文件,结果磁盘上全是随机寻道。正确做法是把小样本合并成几个大文件,比如 Arrow、TFRecord、Parquet,或者 WebDataset 的 tar 包。一次顺序读就能拿到一批样本,每次读的开销被摊薄了(书第 5 章)。 如果确实只能随机读,就用 `io_uring` 这类 Linux 异步 I/O 并行发多个请求,把延迟藏起来。文件系统也有讲究:Linux NVMe 服务器上 XFS 是常见选择,挂载时记得 `noatime`,省掉每次读都更新访问时间的开销。 > 一句话:训练前先把数据整理成"大块连续",比换任何高端存储设备都便宜。 ## 四、2026 年的存储硬件:接口翻倍,容量上天 存储硬件这几年的迭代,比很多人意识到的快。三个变化值得记。 **先说接口。** PCIe Gen5 NVMe 已经是 2026 年的主力,顺序读能到 14 GB/s 上下,是 Gen4 的两倍。代表产品是 Samsung PM9C3a 和 Micron 9650。Gen6 还在路上,按 PCIe 规范它能翻倍到 28 GB/s 左右,2026 年内能见到更多支持平台(来源:Fact.MR 数据中心 SSD 市场报告、厂商规格)。 **容量在涨。** QLC NAND 把单盘容量推到了 60 TB 量级(Micron 6550 ION 已做到 60 TB),100 TB 以上还在路线图上。这意味着「把数据复制到每个节点本地盘」这种笨办法,现在变得越来越可行。 **AI SSD 登场。** 2026 年最值得注意的新物种。以公开报道的忆芯 STAR2000D 为例,它在 SSD 主控里集成了 8 TOPS 算力,直接在盘内做 KV Cache 的量化压缩和检索,还支持 GDS/RDMA 直通。计算开始往存储下沉,不用再把数据搬回 CPU 处理。 ## 五、GDS:让数据绕过 CPU 直达 GPU 传统路径下数据要绕道:SSD → CPU 内存 → GPU 显存。中间多一次拷贝,还占 CPU。NVIDIA 的 GPUDirect Storage(GDS)让 GPU 直接从存储 DMA 到自己的显存,跳过 CPU 内存这个中转站。 它和上一章讲的 GPUDirect RDMA 是一对:RDMA 加速网络到 GPU,GDS 加速存储到 GPU,都是去掉"主机内存"这个弹跳缓冲。 ![fig6-gds-path.png](https://developer.qcloudimg.com/http-save/yehe-11479707/abf9f62d3b35453fbf8a028169c838ef.png) 收益有多大?VAST Data 的实测是:单块 A100 顺序读提升 20%,Hopper H100 因为网卡带宽更高、CPU 负担更重,提升超过 30%(书第 5 章、VAST Data GDS 报告)。 ![fig8-gds-speedup.png](https://developer.qcloudimg.com/http-save/yehe-11479707/b65f89f77c646cfe034ed20b4c8e4cb4.png) 但这张图是示意值。真实收益取决于你的数据路径:GPU 和 NIC 是否在同一条 PCIe switch 下、文件系统是否支持 O_DIRECT、cuFile 是否配置正确。GDS 不是开了就自动生效的魔法开关。 ### 踩坑现场:GDS 没开,GPU 利用率有规律掉零 下面是一种基于公开资料整理的典型踩坑模式,不是某一次特定事故,但在很多集群里反复出现: **症状**:训练吞吐只有预期的六成,CPU 使用率居高不下,`iostat` 显示 NVMe 吞吐正常,但 GPU 利用率曲线每隔几十步就规律地掉到 0。 **排查**: 1. `nvidia-smi topo -m` 看 GPU 和 NIC 的拓扑关系,确认是不是在同一条 PCIe switch 下。 2. 单节点跑 `gdsio` 测 GDS 是否生效;如果 fallback 到普通 POSIX 路径,说明没开成功。 3. 检查 `cufile.json` 配置和文件系统是否支持 O_DIRECT,容器里还要注意权限有没有 `CAP_SYS_ADMIN`。 **修复**:把数据路径打通后,GDS 生效,CPU 不再做 memcpy 中转,GPU 利用率曲线会从"锯齿"变"平稳"。 ## 六、Checkpoint:别让它把训练卡死 提完 I/O 别忘了 checkpoint。LLM 训练里检查点写入通常几十 GB 到几 TB,写一次就要让训练停几秒到几十秒。 书第 5 章讲了 cuda-checkpoint 配合 CRIU 做进程级快照,路径和模型检查点正交(来源:书第 5 章)。生产里更常见的做法是用并行文件系统 + GDS/RDMA 写检查点,配合异步/分片策略避免阻塞训练循环。 ## 七、DeepSeek 为什么自己造了 3FS 这一章最精彩的部分,是 DeepSeek 的 3FS。 DeepSeek 观察到 AI 工作负载有一个反直觉的特点:**绝大多数读是随机读**。而随机读会让传统读缓存失效,甚至帮倒忙——缓存没命中,还白白浪费管理开销。 于是他们从头写了一个文件系统,叫 Fire-Flyer File System(3FS),2025 年 2 月 27 日开源,核心就一个激进决定:**去掉缓存,直接文件 I/O,每个请求直达 NVMe SSD**(来源:DeepSeek 3FS 官方仓库、cronfeed 深度分析)。 这套系统由四部分组成:集群管理器、无状态元数据服务、存储服务、客户端。元数据放在 FoundationDB 里,用它保证创建、删除、重命名这些操作的强一致性。数据切成等大的块,用 CRAQ(Chain Replication with Apportioned Queries)做复制,读的时候可以在多个副本间分摊。 ![fig6-3fs-vs-ceph.png](https://developer.qcloudimg.com/http-save/yehe-11479707/ebc9a4ea6059f320b5df2e29bbed8234.png) 它的吞吐数字要分开看,混在一起会误导: - **6.6 TiB/s 聚合读**:来自 180 个存储节点 + 500 多个客户端的集群,是端到端总吞吐。 - **3.66 TiB/min GraySort**:来自 25 节点的基准测试,体现单节点效率。 - **40 GiB/s 单节点 KV Cache 查找峰值**:说明 3FS 不只是训练数据盘,而是把检查点、中间输出、甚至推理 KV Cache,都当成同一个存储平面上的流量来管(来源:DeepSeek 官方技术报告、cronfeed 2026 分析)。 作为对比,Ceph 在类似硬件上只有约 1.1 TiB/s(书第 5 章)。 > 泼盆冷水:开源了设计和代码,不等于你周末就能搭起来。它需要成排的全闪存、精心运维的 RDMA 网络、独立的元数据和监控服务。3FS 是一张严肃的基础设施配方,不是开箱即用的存储设备(来源:cronfeed 2026)。 ## 八、并行文件系统、对象存储,怎么选 大部分人不会自己造文件系统,而是在现成的里面选(书第 5 章): - **NFS**:简单,但单服务器容易成瓶颈,只适合几个节点的小规模。 - **并行文件系统(Lustre、GPFS、WekaFS)**:为高并发高吞吐设计,大文件条带化到多个存储目标上,能把带宽乘起来。现代 AI 训练集群首选。 - **对象存储(S3)**:不是文件系统,但很常见。训练时直接读很慢,通常先在本地 NVMe 暂存,或者在 S3 上套一层缓存(比如 AWS FSx for Lustre)。 ### 一个反共识判断 很多人以为集群越大越要上 Lustre/GPFS。我的看法相反:**规模不到百卡,与其折腾分布式文件系统,不如先把数据合并成大文件、加一层本地 NVMe 缓存。** 并行文件系统省的是带宽,吃的是运维。小团队过早引入它,往往是给自己找罪受。 ## 九、压缩和盘内计算 数据压缩是另一个省钱的路子。存压缩数据、读的时候即时解压,能省 I/O 带宽,代价是多耗点 CPU 或 GPU。现代 GPU 带片上解压引擎,支持 LZ4、Snappy、Deflate,Blackwell 能在管道里直接解压,不占用 SM(来源:书第 5 章)。 这条线走到极致,就是前面说的 AI SSD:把量化、检索这些原本在 CPU 上做的事,下沉到盘里。核心逻辑都一样——**数据在哪,就在哪算,别搬来搬去。** ## 十、收尾 存储 I/O 的优化,本质是消灭"累积的小低效":这里 5 ms 延迟,那里 10 MB 缓冲太小。单看都不起眼,规模一大就是真金白银。 回扣到整个系列的主线:goodput 损失的三大元凶——通信、存储、数据管道。通信在第二章讲过了,存储这一半讲完了。下一篇我们钻进最后一层,讲数据怎么被预处理、打包、喂进训练循环。 --- ## 参考资料 - Chris Fregly, *AI Systems Performance Engineering*, O'Reilly Media(第 5 章) - DeepSeek 3FS 官方仓库(github.com/deepseek-ai/3FS,2025-02-27 开源) - cronfeed:《DeepSeek opened 3FS, but the fast path still begins in the machine room》(2026) - Fact.MR:《Data Center SSD Market Forecast 2026–2036》(2026) - Micron 6550 ION / 9650、Samsung PM9C3a 官方规格 - 忆芯科技 CFMS 2026 公开报道(STAR2000D AI SSD) - VAST Data GDS 性能报告 > 说明:GDS 前后对比图为基于 VAST Data 报告典型区间的示意值,非特定集群实测。文中 2026 年存储硬件数据来自厂商官方规格与市场报告,截至 2026 年 8 月;局部性、顺序读、GDS、3FS、checkpoint 等机制与数字沿用《AI Systems Performance Engineering》第 5 章。

优秀的个人博客,低调大师

腾讯智算云基座护航影禾医脉医学影像基座模型:产品研发周期缩短50%、infra支持成本降低30%

腾讯健康与影禾医脉合作,依托腾讯智算云基座助力跨模态医学影像基座模型及“数字医生”产品矩阵建设,在20余款模型上完成高基准测试并实现从N卡向国产算力迁移的突破。合作使影禾医脉产品研发周期缩短50%、基础设施支持成本降低30%,推动医疗AI从通用工具迈向专属智能体,实现全链路临床赋能与自主掌控。

优秀的个人博客,低调大师

AI Infra 系列 · 第六章 · GPU 性能工程(一):训练慢,先别改代码,先做一次性能体检

## 一、先看一个案例:138ms 的训练步,一半花在"搬运"上 假设你手里有个 MoE 模型在训,一个训练步(forward + backward + 优化器)跑得很慢。直觉告诉你:肯定是专家层的矩阵乘法(matmul)太慢了,模型大、算得多嘛。 把 PyTorch Profiler 打开,按 CUDA 时间排序看前 10 个算子,结果出乎意料:专家 matmul 确实是第一瓶颈,但排第二、第三的是一对叫 **dispatch(分发)和 combine(聚合)** 的操作——token 被路由到不同 GPU 上的专家、算完再收回来,这对"搬运工"前向加反向一共吃掉了 **30.8ms**(dispatch 18.7ms + combine 12.1ms)的 GPU 时间(来源:*AI Systems Performance Engineering* 第 13 章 Profiling 实战案例)。整个训练步的 GPU 总时间是 138ms,也就是说,**超过两成的时间花在搬运上,而不是计算上**。 如果不体检,你会怎么优化?大概率是去调 matmul,或者上更激进的并行策略。但真正的病根之一,是 MoE 路由带来的通信开销——那是另一味药。 这个案例想说明一件事:**性能优化的第一步不是动手,是知道瓶颈到底在哪。** ## 二、三层体检设备:从"在哪个环节慢"到"为什么慢" GPU 性能分析工具很多,容易挑花眼。其实按"问的问题"分,就三层: | 层 | 工具 | 回答的问题 | 开销经验值 | | --- | --------------------------- | ------------------------- | ---------- | | 操作级 | PyTorch Profiler(基于 Kineto) | 哪个算子最贵?前向/反向是否失衡? | 10%-20% | | 系统级 | Nsight Systems(nsys) | 时间线全貌:GPU 空等了吗?CPU 喂得过来吗? | ~5% | | 内核级 | Nsight Compute(ncu) | 单个热点内核为什么慢?计算受限还是内存受限? | 很慢(逐个内核重放) | 顺序很重要:**先用系统级看全貌,再用操作级看分解,最后用内核级钉死原因**。别一上来就钻内核,那是给"已经知道哪个内核是热点"的人用的——ncu 会重放内核采集硬件计数器,慢到只适合精查少数几个内核(来源:*AI Systems Performance Engineering* 第 13 章;工具开销经验值来自 2025-2026 年社区 profiling 实践资料)。 这一层工具背后有个共同的语言:**NVTX 标记**。你可以把它理解成给代码打的"时间轴书签"——比如把 forward、backward、optimizer_step 各标一段。书签打上之后,同一个"forward"区间会同时出现在 PyTorch Profiler 的追踪和 nsys 的时间线里,跨工具对照就有了锚点。PyTorch 大多数关键区域已经自动打好了标记,你也可以自己用 `torch.profiler.record_function()` 加(来源:同上,第 13 章 NVTX 小节)。 ![fig12-profiling-stack.png](https://developer.qcloudimg.com/http-save/yehe-11479707/f099771d4c2a09ba073426e670e67b52.png) ## 三、体检四步法:不靠猜,靠流程 工具齐了,怎么用?给你一套可以直接照抄的四步流程: **第一步:先看一个数——MFU,而不是"利用率"。** `nvidia-smi` 显示 GPU 利用率 90%,你是不是觉得挺满意?先别高兴。利用率只说 GPU 没闲着,不等于在干正事——它可能 90% 的时间在跑低效内核。真正该盯的指标叫 **MFU(Model FLOPs Utilization,模型算力利用率)**:实际算出的有效浮点运算 ÷ 硬件理论峰值。一个粗糙的具象锚点:一张 H100 跑一个 70B 稠密模型,MFU 40% 大概相当于每卡输出 400 TFLOPS 左右——不算爆表,也不算丢人。健康线按场景不同:稠密预训练公认 **35%-50% 算健康,低于 35% 提示有瓶颈**;但 MoE 大模型走 FP8 训练时,**20%-32% 才是当前的优秀线**(DeepSeek-V3 公开材料约 21%、字节 MegaScale 报告 28%-32%),MoE 被打骨折的原因之一是 all-to-all 通信吃掉了大部分理论峰值(来源:AI Infrastructure Knowledge Base 分布式训练专题,2026;DeepSeek-V3 技术报告;MegaScale 工程分享)。注意,MFU 是个相对数,不同模型、不同并行配置下没法横向比,但同一份训练作业里,它是衡量"优化有没有见效"最诚实的尺子。 **第二步:nsys 拉一条时间线,找"气泡"。** 健康的时间线长什么样?GPU 内核一个接一个,中间只有极小的间隙,同时 CPU 侧的数据加载在后台和计算重叠。不健康的时间线有三种典型"病",一眼就能认出来: - **GPU 饿肚子**:内核之间有长长的空洞——多半是 CPU 喂不动(数据加载慢、Python 开销大); - **小内核风暴**:密密麻麻全是几微秒的小内核——启动开销把 GPU 拖垮,这是编译器和 CUDA Graph 的活儿(下一篇会讲); - **同步等待**:多卡作业里,某个 rank 在等别的 rank——通信没和计算重叠,或者出了个掉队者。 ![fig12-timeline-gaps.png](https://developer.qcloudimg.com/http-save/yehe-11479707/7e250e0574aaef9b5e25b102fb175dfb.png) **第三步:锁定 Top 内核,用 ncu 问"为什么"。** 从时间线里找出 GPU 时间占比最高的 3-5 个内核,交给 ncu。它会告诉你这个内核卡在哪:**计算受限**(SM 算力打满,需要降精度或减少冗余计算)、**内存受限**(内存带宽打满,需要提高算术强度,少搬数据)、还是**延迟受限**(占用率太低,没足够的并行任务掩盖延迟)。一个粗略的比喻:把一条流水线比作一条工厂的走廊,算力像产线上的机器,内存带宽像走廊宽度,延迟像工序之间的等待时间——ncu 的 roofline 图就是告诉你,工厂卡在机器不够、走廊太窄、还是工序空转。 **第四步:改一处,测一处。** 书上那个 MoE 案例就是这么收尾的:针对专家 matmul 做算术强度优化(融合内核、减少内存移动)之后重跑 ncu,内核的 **SM 计算峰值利用率从优化前涨到 85%,内存带宽占用降到 40%,占用率升到 80%**——内核从"内存受限"变成了"计算受限",更接近硬件极限了(来源:*AI Systems Performance Engineering* 第 13 章 Roofline 案例)。每一步改动都重新测,才知道哪味药真的起效。这也是第五章说的"先算账再动手"在单卡尺度上的版本。 ![fig12-diag-flow.png](https://developer.qcloudimg.com/http-save/yehe-11479707/1297fcad9e4eea424584434e6e82ff8c.png) ## 四、GPU 只是嫌疑人之一:CPU 和 I/O 会"装病" 体检最容易犯的错,是只盯着 GPU。训练是个流水线,任何一个环节掉链子,症状都表现为"GPU 利用率低"——但病根可能根本不在 GPU。 - **CPU 侧**:Python 解释器开销、GIL 争用、数据预处理循环,都可能让 GPU 空等。用 Linux `perf` 采样 CPU,看火焰图里时间烧在哪。书上那个案例里,`perf` 就抓到了 read 系统调用在 CPU 采样中占了 5.3%——数据读取在拖后腿,这是 PyTorch Profiler 里看不到的主机侧证据(来源:同上,第 13 章 Linux perf 小节)。 - **I/O 侧**:DataLoader 的 worker 不够、预处理太慢,GPU 就断粮。这是第三章(数据管道)和第五章(单机调优里的内存三件套)讲过的坑,但注意:**怎么发现**是这一篇的事——nsys 时间线里 GPU 空洞 + CPU 侧数据线程忙碌,就是数据管线的典型指纹。 - **通信侧**:回到开头的 MoE 案例,dispatch/combine 本质上不是"算",是"搬"——跨设备的 all-to-all。这类开销在操作级 Profiler 里看得清清楚楚,但很多人从不看第二、第三名的算子。 一句话:**GPU 利用率低只是症状,别急着给 GPU 定罪。** 时间线先拉出来,CPU、I/O、通信轮流审一遍,哪个露马脚抓哪个。 ## 五、多卡体检:一个掉队的 rank,拖垮整个集群 单机体检完了,多卡训练还有一道坎。分布式训练里所有 rank 是集体行动——一个 rank 慢,其他人全在等它,这就是 **straggler(掉队者)问题**。整机利用率再高,也被最慢的那块短板钉死。 多卡场景的体检工具:Meta 开源的 **HTA(Holistic Trace Analysis,整体追踪分析)**,把多 rank 的 PyTorch Profiler 追踪聚合到一条时间线里,专门用来找"某个 GPU 在等别的 GPU"的空闲段,还能验证通信和计算到底有没有重叠(来源:Meta HTA 项目,*AI Systems Performance Engineering* 第 13 章多卡分析小节)。再往上就是第五章下篇讲的集群级监控(DCGM 这类),那是"长期运营的血压计",跟本篇"单次作业的病理解剖"是两回事,别混。 另外提醒一句:PyTorch 与 TensorBoard 集成的 trace 插件已弃用,现在看时间线用 **Perfetto**(网页版,支持 SQL 过滤),看多卡用 HTA(来源:同上,第 13 章;PyTorch 官方 2026 教程)。

优秀的个人博客,低调大师

AI Infra 系列 · 第五章 训练与调度(下):一万张 GPU 怎么排班,调度器才是训练场的隐形老板

## 一、先算一笔账:GPU 排队一小时,等于烧掉多少钱 如果你管过一个训练集群,下面这个场景一定不陌生:周三下午,三个团队同时提交作业——A 要 512 卡训大模型,B 要 64 卡微调,C 只要 8 卡跑实验。调度器该怎么排?先到先得?大作业优先?还是按配额公平分? 排不好就是纯烧钱。一张 H100 按市价算,一小时租金几十块,一个 512 卡的作业排队一小时,白烧的钱够吃一顿好的。更麻烦的是 GPU 之间的"排班"还有硬约束:多卡作业必须同时拿到所有卡才能开工(要么一起上,要么都不上);卡与卡之间的物理位置决定了通信快慢,放错位置性能打骨折。 所以集群调度说白了就三件事:**哪张卡、什么时候、给谁**。三件事互相打架,调度器就是那个"拉架"的。 ![fig11-scheduler-evolution.png](https://developer.qcloudimg.com/http-save/yehe-11479707/0eddaa8158f890c2b6689327b1f3584a.png) ## 二、K8s 调度 GPU 的十年:从"数设备"到"说需求" 2017 年之前,K8s 根本不知道 GPU 是什么。后来 NVIDIA 出了设备插件(Device Plugin),把 GPU 变成一种可计数的资源:`nvidia.com/gpu: 8`,调度器按"张"分配。这是第一代,够用,但很糙——只能按整卡分,不知道卡之间怎么连的,也不管 NUMA。 第二代是**拓扑感知**。K8s 拓扑管理器 + GPU Operator 用 GPU Feature Discovery 给每个 GPU 打标签(NUMA 节点、NVLink 域、PCIe 总线),调度多卡作业时尽量把卡安排在共享 NVLink 的同一服务器上。 第三代是 **DRA(Dynamic Resource Allocation,动态资源分配)**。打个**比**——DRA 像外卖平台:Pod 不再"数卡",而是提需求("我要 8 张卡、要 NVLink 互连、最好同 NUMA 节点"),由设备驱动(NVIDIA 的 DRA driver)响应"派单"。DRA 在 Kubernetes 1.34(2025 年 8 月)正式 GA,为 MIG 切片、DPU、可编程网络设备等异构资源打开了大门(来源:Kubernetes 官方博客)。2026 年 KubeCon EU 上,NVIDIA 把 DRA 驱动(含 GPU 调度相关组件)捐给了 CNCF,社区接管;同期 KAI Scheduler 进入 CNCF Sandbox(来源:KubeCon EU 2026 公告)。 但 DRA 解决的是"资源怎么给",没解决"作业怎么排队"。排队是**配额与队列系统**的活:CNCF 生态里的 **Kueue**(K8s 原生工作负载队列)和 **Volcano**(华为 2019 年开源,2024 年底晋升 CNCF 毕业项目,Gang Scheduling 一等公民)。2025 年底 K8s 1.35 引入原生 Workload/PodGroup API(KEP-4671,alpha、默认关闭),实现了 Gang Scheduling 的核心逻辑,但生产环境目前还得靠 Volcano/Kueue 这类成熟方案(来源:Kubernetes 1.35 发布说明、Volcano 社区)。 **我的判断**:如果你是 2026 年从零搭集群,别再用裸 K8s 手搓调度了。DRA + Kueue(或 Volcano)是标准答案,前者管资源、后者管排队。 ## 三、Gang 调度:要么一起上,要么都不上 大模型训练作业是"一损俱损"的:512 张卡里 511 张到了、1 张没到,作业也跑不起来,跑起来的卡还空占资源。这就是 **Gang Scheduling(组调度)** 要解决的问题——整个 Pod 组要么同时被调度,要么一起等。 为什么需要它?想象没有 Gang 调度会怎样:A 作业的 512 个 Pod 一个个被调度,前 400 个先占着卡等后面 112 个,而这些卡被 B 作业的小 Pod 见缝插针占走,最后 A 的 400 个 Pod 永远等不齐——**死锁**,卡白占,作业白等。Gang 调度就是把"整组"当成一个调度单元,凑不齐就不放行。 Gang 调度带来的收益在生产里往往是数量级的。Volcano + KubeRay 的多个生产案例分享都报告过类似的跃升:裸 K8s 时大量卡被"永远凑不齐的作业"占着,切换后利用率、排队时间、失败重跑率全面好转(具体数字因集群而异,见 Volcano 社区 2024-2025 年的若干案例讨论)。 ![fig11-gpu-share.png](https://developer.qcloudimg.com/http-save/yehe-11479707/a617c31bad9518e11cdbf08de44e64a0.png) ## 四、拓扑感知:GPU 放错位置,性能差数倍 调度不只看"有没有卡",还要看"卡在哪"。GPU 之间的通信带宽差异是数量级的: | 通信路径 | 典型延迟 | 带宽量级 | | ----------------- | ---------- | ----------------------- | | 同机同卡 NVLink(域内) | ~100ns | NVLink5 域内最高约 1.8TB/s/卡 | | 机柜内 InfiniBand 子网 | ~200ns | 800G(XDR)级 | | 跨机柜/跨组网 | ~300-500ns | 视拓扑,明显衰减 | (来源:NVIDIA NVLink 规格、2026 年调度相关技术分析) **白话解释**:GPU 集群里的"距离"不是按米算的,是按纳秒算的。NVLink 域内的卡互相通信像邻桌说话,跨机柜就像隔了两条街喊话。一个 8 卡作业,如果 8 张卡在同一个 NVLink 域,通信开销极小;如果被调度器撒到 8 台机器上,每次梯度同步都要跨网络走一圈。 原书给了一个重要参考:在 NVLink5 NVL72 系统上,单机架 NVLink 域提供最高约 130TB/s 聚合双向带宽(每 GPU 约 1.8TB/s)。调度集合通信密集的训练作业时,要优先让流量留在快速 NVLink 域内,再考虑跨越较慢的网络(来源:*AI Systems Performance Engineering* 第 3 章)。 实操手段: - K8s:拓扑管理器策略配 `single-numa-node`(最严格,全部资源来自同一 NUMA 节点)或 `restricted`,配 GPU Operator 的拓扑感知标签。 - SLURM:用 GPU 通用资源(Generic Resource)声明 GPU 挂载的 NUMA/NVLink 域,作业请求时指定"要同一 NUMA 的卡"(来源:*AI Systems Performance Engineering* 第 3 章 3.6.2 节)。 - 排错位置性能差距通常在**数倍**以上,具体取决于集合通信模式与拓扑跨度(NCCL 相关分析,2025-2026)。 **我的判断**:拓扑感知是最容易被忽略的"隐形税"。很多团队调度器一升级、节点一扩容,多卡作业莫名变慢,查半天发现是新节点拓扑标签没打对,GPU 被撒到不同 NUMA 域。建议把"拓扑标签正确性"写进集群验收 checklist。 ## 五、SLURM vs K8s:训练和推理从来不是一套班子 传统分工很明确:**训练用 SLURM,推理用 K8s**。SLURM 是 HPC 世界的调度器,按"作业"排队、支持 Gang、支持 MIG 分区调度,多节点训练启停干净利落;K8s 是云原生世界的编排器,弹性扩缩容、服务发现、健康检查一应俱全,天然适合推理服务。 但混合趋势明显: - **Volcano / KubeRay**:在 K8s 上补齐训练调度(Gang、队列、公平),让 K8s 也能跑好分布式训练。 - **CoreWeave SUNK**:实现 "Slurm-in-Kubernetes" 混合,把 SLURM 的作业管理嵌进 K8s 集群,兼顾两边的生态。 - 原书提到开源项目 Slinky 也做了类似的事:简化跨训练和推理工作负载的集群管理(来源:*AI Systems Performance Engineering* 第 3 章 3.6.2 节)。 **我的判断**:1000 卡以内,Volcano/Kueue + K8s 一套班子完全够用,别两套系统了;万卡级纯训练基地,SLURM 的成熟度和 HPC 生态(作业会计、记账、依赖管理)仍是优势,用 SUNK 这类方案做混合桥接是主流路径。 ## 六、万卡架构:单集群的墙,和跨集群的桥 卡多了也有烦恼。单集群超过一定规模(原书和业界共识大约 5000 节点量级)会撞上三堵墙: 1. **调度墙**:调度器要处理的 Pod/作业状态爆炸,调度延迟失控; 2. **网络墙**:单集群全网状拓扑成本指数上升,集合通信的全局同步越来越难; 3. **故障墙**:规模越大,单位时间内必有节点出故障,作业中断成了常态而非例外。 于是 2025-2026 年的主流路线是**多集群联邦**:把万卡拆成若干个"千卡级"集群,每个集群内用 NVLink/IB 高速互连,集群之间用高带宽广域/数据中心间链路连接,配合统一的作业队列层(如 Kueue 的多集群模式)和全局存储(第三章的 3FS 这类)。 ![fig11-federation.png](https://developer.qcloudimg.com/http-save/yehe-11479707/4c5d3ecb9b54743ad483fb1b4ffceeb4.png) 有个标杆数据:据多家媒体转述,OpenAI 在 2025 年披露的运营实践中提到其 2.5 万卡集群做到了约 **97% 的有效利用率**——注意这是"有效"利用率,不是 GPU 通电利用率,意味着把调度、故障、checkpoint、重启的损耗压到了 3% 以内。能做到这一点的前提,就是把下面第七节说的容错做到了极致。 **白话解释**:万卡集群像一支几万人的军队,光有兵力没用,得靠"连-营-团"的建制把指挥成本降下来。多集群联邦就是建制,97% 利用率就是纪律严明的结果。 ## 七、容错:万卡训练不可能不挂,问题是挂了怎么办 先给个让人清醒的数字:一份 32K-GPU 规模的预训练部署报告(被 PHOENIX 论文 [arXiv:2607.01646](https://arxiv.org/abs/2607.01646) 引用为现场数据)统计,一次完整训练跑下来经历了 **678 次意外中断**,其中 **HBM 内存故障、PCIe 故障、NCCL watchdog 超时**三类合计占 **49.9%**——也就是说,一半的故障来自最"底层"的硬件和通信。万卡规模下,"不挂"是幻想,"挂了快速恢复"才是工程。 容错三板斧: **① Checkpoint:异步 + 分布式是标配。** 同步 checkpoint(所有 rank 停下来等写盘)在千卡规模还能忍,万卡规模就是灾难。2026 年主流是异步 checkpoint(训练继续跑,后台写盘)+ 分布式分片 checkpoint(FSDP/DeepSpeed 把状态分片到各节点,各写各的,不再有"单点全量快照")。DeepSeek 3FS 这类高性能存储进一步把 checkpoint 写盘时间压缩到分钟级(见第三章)。 **② 热替换 + 快速恢复。** 学术界和工业界都在做"零中断换卡":比如 PHOENIX 提出的内存 checkpoint + hot-swapping 方案,把恢复时间压到 **约 40 秒**(512 卡 A100 集群验证,来源:arXiv:2607.01646,2026)。据 NVIDIA 官方口径,Resiliency Extension + Mission Control 自治恢复引擎可让恢复提速 10 倍(来源:NVIDIA 2026 发布)。 **③ 故障检测要快。** 据天翼云公开宣传,其「息壤」平台的万卡集群做到秒级故障检测、分钟级恢复。检测慢 10 分钟,一个 512 卡作业就多烧 10 分钟的钱,所以"故障发现速度"本身就是性能指标。 ![fig11-failover.png](https://developer.qcloudimg.com/http-save/yehe-11479707/4baf02f9fd3aa8ecb42ad1739182f7bb.png) ## 八、监控与 AI 辅助运营:让集群自己"看门" 万卡集群人工盯不过来,监控 + AI 辅助是 2026 年的标配: - **硬件监控**:DCGM(NVIDIA 数据中心 GPU 管理器)采集温度、功耗、显存 ECC 错误、SM 利用率等指标,喂给 Prometheus 体系。GPU 显存突然下降 = 内存泄漏或数据停顿,这类异常用阈值规则 + AI 辅助定位根因。 - **AI 排障副驾驶**:作业跑了一半失败,人工翻日志要几小时;AI 副驾驶消化日志 + 指标 + 警报,直接给结论——"节点 42 崩溃前有 5 个 ECC 错误,疑似 HBM 通道问题",或"loss 在第 10000 步变 NaN,检查梯度裁剪"。Splunk/Cisco、PagerDuty 已经在用 AI 预测数据中心故障,扩展到 AI 工作负载专属遥测是自然延伸。 - **AI 调度代理**:观察整个集群状态,学习哪些作业可以共存(计算密集 + 内存带宽密集互补),动态调整资源分配,目标从"GPU 不闲着"升级为"GPU 忙在有用的神经计算上"——传统利用率指标会骗人,100% 忙在冗余数据传输上的 GPU 并不高效。 **我的判断**:别等万卡才上这套。几百卡的集群,DCGM + Prometheus + 一个 LLM 排障助手,能把故障定位从小时级压到分钟级,投入产出比极高。最贴合本书主题的地方——AI 帮助创造更好的 AI,性能工程师的角色从"手动拧每个旋钮"变成"设定目标和护栏、处理 AI 没见过的新情况"。 ## 九、串起来:从单机到万卡的完整视角 第五章上下两篇其实是一条线: - **单机**:NUMA 绑定、内存固定、GPU 持久化、MPS/MIG——把每张卡的性能榨干; - **集群**:DRA 管资源、Kueue/Volcano 管排队、Gang 管整组、拓扑感知管位置、联邦管规模、checkpoint + AI 运营管容错。 这套方法论落到数字上就两行:调度浪费 30%,拓扑错位数倍——先拧这两个,胜过所有花哨优化。 ## 参考资料 - Chris Fregly, *AI Systems Performance Engineering*, O'Reilly Media(第 3 章 K8s/SLURM 调度、第 20 章 AI 辅助集群运营) - Kubernetes 官方发布记录(1.34 DRA GA、1.35 原生 PodGroup alpha) - NVIDIA 2026 公告(GPU 调度组件捐赠 CNCF、Resiliency Extension、Mission Control) - Volcano / Kueue 社区文档与 2025 年 1024 卡 H100 集群案例分享 - CoreWeave SUNK 项目文档 - OpenAI 2025 年工程分享(2.5 万卡集群运营,97% 有效利用率,媒体报道) - arXiv:2607.01646(PHOENIX,内存 checkpoint + hot-swapping,2026) - 2025-2026 年公开的 32K-GPU 预训练部署报告(678 次中断统计) - 天翼云「息壤」公开技术分享(万卡集群故障检测与恢复)

优秀的个人博客,低调大师

AI Infra 系列 · 第六章 GPU 性能工程(三):torch.compile 不是开关——碎算子能快一倍,GEMM 基本白搭

先别急着读下去。花两分钟跑一下这段,它会把你后面要看的东西全部验证一遍。 ```python import torch, time dev = "cuda" def bench(fn, iters=200, warmup=30): for _ in range(warmup): fn() # 预热:compile 的编译时间在这里花掉 torch.cuda.synchronize() t0 = time.perf_counter() for _ in range(iters): fn() torch.cuda.synchronize() return (time.perf_counter() - t0) / iters * 1000 # ms/次 x = torch.randn(1024, 1024, device=dev) w_small = torch.randn(1024, 1024, device=dev) w_big = torch.randn(4096, 4096, device=dev) def many_small_ops(): # A:8 段逐元素链 + 小 matmul,像 MoE / 归一化密集的负载 h = x for _ in range(8): h = torch.relu(h + 1.0) * 0.5 h = torch.matmul(h, w_small) return h def one_big_gemm(): # B:就一个大矩阵乘,从头算到尾 return torch.matmul(x, w_big) for name, fn in [("A 碎算子密集", many_small_ops), ("B 单 GEMM 主导", one_big_gemm)]: eager = bench(fn) cfn = torch.compile(fn) cfn() # 触发编译 compiled = bench(cfn) print(f"{name:16s} eager {eager:7.3f} ms compile {compiled:7.3f} ms {eager/compiled:.2f}x") ``` 跑出来的样子(数字随你的卡变化,看**两行的倍数差**,不看绝对值): ``` A 碎算子密集 eager 0.412 ms compile 0.198 ms 2.08x B 单 GEMM 主导 eager 1.847 ms compile 1.781 ms 1.04x ``` 同一个 `torch.compile`,A 快了一倍,B 基本没动。这就是本篇全部内容的缩影:**编译器省的是开销,不是算力**。算子越碎、Python 胶水越重,能省的越多;模型里已经是一个大 GEMM 从头算到尾,编译器没什么开销可省。 我在自己的机器上测过好几次,规律稳定:开 compile 之前瞄一眼 GPU 利用率,已经 80% 以上基本不用指望,三四十还上不去的往往能救回来一点。 ![fig12-compile-pipeline.png](https://developer.qcloudimg.com/http-save/yehe-11479707/6d81736519c9872cf5a3a266ac9a7d6d.png) --- ## 一、这行代码背后,是四个阶段在干活 `torch.compile` 听起来是一个东西,其实是四段流水线串起来。断在哪一段,丢的加速比不一样。 **① TorchDynamo 抓图。** PyTorch 默认是 eager 的,你写一行它算一行。Dynamo 挂在 CPython 的字节码求值上,边跑边把张量操作记成一张 FX 图的节点。碰到它跟不上的代码——一个 `print`,或者 `if x.sum() > 0` 这种拿 Python 布尔值做判断的控制流——就**断开**,那段退回 eager 跑完,之后再接着抓。比老一代 `torch.jit.trace` 强的地方在于,它不会偷偷只跟一条分支。 **② AOT Autograd 拼前后向。** eager 模式下反向图是前向跑的时候动态记录的,编译器没法提前优化。AOT Autograd 把前向和反向拼成一张联合图,于是"前向某个算子"和"它为反向存的激活"可以一起融合。这也是 compile 对训练的收益常常比推理更大的原因。 **③ TorchInductor 生成内核。** 拿到图之后做算子融合,GPU 上吐 Triton 内核,CPU 上吐 C++。上面脚本里 A 那个 `(h + 1.0) → relu → * 0.5` 的链条,eager 要 3 个内核、3 读 3 写,Inductor 合成 1 个内核、1 读 1 写——这正是上一篇讲的"少搬数据"。而 GEMM 它不自己造,转手交给 cuBLAS/CUTLASS,所以 B 那行几乎没变化。 **④ CUDA Graph 收尾。** 把整个 step 的几百次 kernel launch 录成一张图,之后一次 CPU 调用重放,几乎零启动开销。只在特定模式下开,第四节展开。 业界实践资料常引用的区间是训练 **1.3-2×**、推理常见 **1.3-2×**,轻量算子密集的负载能到 **3×**。这是经验区间不是官方基准,不同模型结构能差出好几倍——所以才让你先跑那段脚本。 ## 二、图断点:加速比是怎么被吃掉的 图断点是"开了 compile 怎么没变快"最常见的原因。每断一次,前面攒好的一段图就被掐断,Python 解释器重新登场。 打个比方:编译器抓图像把整个方队带进车间,队伍里有人擅自离队(一个 print、一个数据相关的 if),车间只能让他出去、整队重列一次——每断一次,前面攒的加速全白费。 诊断工具是现成的: ```python # 开发期:一断点就报错,把问题全逼出来 torch.compiler.set_stance("fail_on_recompile") # 看每个断点是谁造成的、断在哪一行 torch._dynamo.explain(model, *inputs) # 日志里直接读原因,比 explain 更细 # TORCH_LOGS="graph_breaks,guards,recompiles" python train.py ``` 最常见的凶手是**数据相关的 Python 控制流**。把 `if x.sum() > 0:` 换成 `torch.where(mask, a, b)`,整段就能被抓进去。新版本还有 `torch.cond`,能把 if/else 两个分支都编进图里(要求两个分支返回结构和 dtype 一致、运行时形状一致)。 想亲手见一次断点长什么样,跑这个: ```python import torch def with_break(x): h = torch.relu(x) if h.sum() > 0: # ← 用 Python 布尔值做判断,Dynamo 跟不上去 h = h * 2 return h def no_break(x): h = torch.relu(x) return torch.where(h.sum() > 0, h * 2, h) x = torch.randn(1024, 1024, device="cuda") print(torch._dynamo.explain(with_break, x).graph_break_count) # 1 print(torch._dynamo.explain(no_break, x).graph_break_count) # 0 ``` 有一类断点不用管:FSDP 这类分布式策略在 all-gather、reduce-scatter 处通常会有断点,这是设计使然,PyTorch 靠它把通信和计算重叠起来。真正要做的是把每个 transformer block 包成独立的 FSDP 子模块,让 Dynamo 在子模块边界显式断点;不包的话整个模型退化成一个大桶,编译收益明显缩水(来源:PyTorch 官方 FSDP2 与 torch.compile 集成文档)。 还有个容易忽略的信号:**训练循环跑到前几步之后应该就零重编译了**。如果几百步还在重编,八成是每步都有东西在变——带自增计数器的 debug print、或者某一步传 CPU 张量下一步传 GPU 张量,都会触发 guard 失效。 ## 三、CUDA Graph:专治"启动开销" CUDA Graph 是这套流水线里最容易被低估、也最容易踩坑的一环。 它解决什么问题?自 2016 年 GP100 以来,NVIDIA GPU 的半精度算力涨了约 **47 倍**,显存带宽只涨了 **4.6 倍**(来源:Fireworks AI 公开分析,GP100 21 TFLOPS / 730 GB/s → H100 989 TFLOPS / 3350 GB/s)。GPU 越来越快,主机 CPU 没跟上。一个 7B transformer 的前向要发几千次小内核启动,batch=1 的 decode 步里 GPU 算完只要几微秒,CPU 派活的时间比它算的时间还长。 CUDA Graph 的做法是:预热时把一次前向的所有内核启动、内存分配、同步事件录下来,之后一次 `cudaGraphLaunch` 重放。 实测收益的规律很一致(来源:2026 年 LLM 推理调度实测汇总): | 场景 | 无 CUDA Graph | 有 CUDA Graph | 加速比 | | --------------------------- | ------------ | ------------ | -------- | | GPT-2 Decode (batch=1) | 2.8 ms/token | 1.2 ms/token | **2.3×** | | LLaMA-7B Decode (batch=1) | 8.5 ms/token | 5.1 ms/token | **1.7×** | | LLaMA-70B Decode (batch=32) | 45 ms/token | 38 ms/token | **1.2×** | batch 越小、内核越碎收益越大;batch 一大,内核计算本身占主导,边际收益就塌了。另有 H100 上 7B 量级 decode 实测约 **1.4-1.7×**,小 batch 下 CPU 启动开销会吃掉 20%-30% 的步时间(来源:blog.prompt20.com 2026 年 CUDA Graph 生产实践资料)。 ![fig12-cudagraph.png](https://developer.qcloudimg.com/http-save/yehe-11479707/f1fd06b5f991c21b08a6b894085281db.png) 主流框架 2026 年都把它当标配:**vLLM 在 decode 阶段默认开启**,启动时按 batch size 分桶预录若干张图;**SGLang 用 CUDAGraphRunner** 按 (batch_size, seq_len) 索引管理;**TRT-LLM 深度集成**,支持 inflight batching 下的图切换(来源:各框架公开文档)。 代价也得说清楚: - **静态形状的硬约束。** 图录制时锁死了张量地址和形状,形状一变就得重录。生产上都是"分桶 + padding"——把输入向上取整到 512/1024/2048/4096 这些档位,每档预录一张。 - **内存开销。** 每张图要占一个私有内存池,地址被锁住不能给别人用。70B 模型带 30 多张图,预留 8-12 GB 给图池是常态(来源:2026 年 CUDA Graph 生产实践资料)。 - **和 `dynamic=True` 互斥。** 开了动态形状,CUDA Graph 就不生效了。道理很直白:录的时候尺寸已经焊死,下一句长度一变这张图就作废;动态形状会改 guard 和内存规划,直接禁用图捕获(来源:PyTorch 官方文档)。 想确认图到底捕获了没有,在日志里搜这行: ```bash TORCH_LOGS="cudagraphs" python train.py 2>&1 | grep -i cudagraph # 看到 "cudagraph static input" / capturing 就说明抓到了; # 看到 "skipping cudagraphs due to" 后面会直接写原因 ``` ## 四、库 / 编译器 / 手写:三层怎么分工 这是本篇最容易被误读的一节。 "编译器时代"常常被理解成"手写内核已死"。PyTorch 官方博客 2026 年发的一份实测,把这个判断劈成了两半。他们用 **Helion**(PyTorch 自己的内核 DSL)重写了 vLLM 里 Qwen3 FP8 推理的融合内核,在 H100 和 B200 上对比 CUTLASS(来源:PyTorch 官方博客 *Portable vLLM Model Inference Kernels in Helion*, 2026)。下面是 Helion 内核对 CUTLASS 的加速比: | 内核 | H100 vs CUTLASS | B200 vs CUTLASS | | ---------------------------- | --------------- | --------------- | | rms_norm + per-block 量化 | **2.055×** | **2.128×** | | silu_and_mul + per-block 量化 | **2.269×** | **2.325×** | | per-token group FP8 量化 | 1.408× | 1.446× | | scaled_mm(标准 GEMM) | **1.080×** | **0.739×** | | scaled_mm_blockwise(分块 GEMM) | 0.957× | 0.782× | 量化、归一化、融合这类"杂活"上,编译器生成的内核把 CUTLASS 甩开一倍多;但一到 GEMM,H100 上 Helion 的 scaled_mm 还能赢 8%,B200 上两个 GEMM 内核一起输(0.739× 和 0.782×),输 22%-26%。官方原话是 *On H100, scaled_mm outperformed CUTLASS; On B200, both GEMM kernels currently lagged behind CUTLASS*——分界线正好卡在硬件换代上。 官方给的原因是:卡点不在 Helion 的编程模型,而在 Triton 在 Blackwell 上生成 GEMM 内核的当前水平。Blackwell 的 TCGEN05、TMEM 这些新硬件单元,Triton 还没吃透。这和上一篇 FA4 那篇论文说的是同一件事:新架构刚出来,软件栈要追一阵子。 所以 2026 年比较务实的分工是这样: - **通用算子、融合杂活 → 交给编译器。** 自己写的 CUDA 大概率打不过自动调优搜出来的版本,而且硬件一换代就得重写。 - **GEMM 和注意力 → 交给库,但也别迷信"库永远更快"。** cuBLAS、CUTLASS、cuDNN、FlashAttention 系列仍是主力,不过同一份库代码在 H100 和 B200 上的表现能差出四分之一。 - **真正的长尾定制算子 → 才考虑手写。** 而且先用 Triton 或 Helion 试,别直接上 CUDA C++。 ![fig12-kernel-layers.png](https://developer.qcloudimg.com/http-save/yehe-11479707/f6146634526d8fc4d211c48e8c921baa.png) ## 五、Helion:200 行 CUDA 变成 15 行 既然提到了,多说两句。Helion 是 PyTorch 官方的 Python 嵌入式 DSL,定位比 Triton 再高一层抽象: ```python import torch, helion, helion.language as hl @helion.kernel() def matmul(x, y): m, k = x.size() k2, n = y.size() out = torch.empty([m, n], dtype=x.dtype, device=x.device) for tile_m, tile_n in hl.tile([m, n]): acc = hl.zeros([tile_m, tile_n], dtype=torch.float32) for tile_k in hl.tile(k): acc = torch.addmm(acc, x[tile_m, tile_k], y[tile_k, tile_n]) out[tile_m, tile_n] = acc return out ``` 同样的矩阵乘,CUDA C++ 要 200 多行,Triton 约 80 行,Helion 大概 15 行(来源:Red Hat Developer, *From 200 lines to 15: How Helion is rewriting the rules of GPU programming*, 2026-04)。索引、掩码、stride、grid 尺寸、内存布局全自动生成。 真正的杀器是**自动调优**:一个 Helion 内核,编译器会生成成百上千个 Triton 变体(不同块大小、循环顺序、PID 映射、warp 数、流水线深度、展开策略),再用 LFBO 这类搜索策略挑最快的,通常几分钟搜完。打个比方:同一道菜做几百遍,每遍改点火候、换个盘子,挑最好吃那版锁死。锁定之后运行时零调优成本,同一份代码拿到 Ampere、Hopper、Blackwell 上都能自动适配。 后端也不只 Triton:Pallas(TPU)、CuTe(CUTLASS Python DSL,要 CUDA 13+)、TileIR(Blackwell 专用)。上面那张表里 B200 的 GEMM 输了,官方正在做的 CuTe 后端就是来补这个洞的。 ## 六、四种模式怎么选,以及三个坑 | 模式 | 干什么 | 什么时候用 | | ---------------------------- | ---------------------------- | ------------------ | | `default` | 完整 Inductor 融合,不开 CUDA Graph | 先拿它试,调图断点时也用它 | | `reduce-overhead` | 融合 + CUDA Graph 捕获 | 形状固定的生产推理 | | `max-autotune` | 穷举搜索内核变体 + CUDA Graph | 延迟敏感、离线基准,能忍较长编译时间 | | `max-autotune-no-cudagraphs` | 穷举搜索但不要图 | 动态形状场景 | 三个坑: **坑一:`reduce-overhead` 首次调用要 30-90 秒。** 这是内核编译时间,省不掉,只能缓存。vLLM 就是这么做的——一个 60GB 模型的编译产物只有约 15MB(Triton 内核源 + .cubin),缓存下来新 Pod 直接复用。AWS EKS 文档的实测:同节点冷启动从约 53 秒降到 6 秒,整体新节点从 8-15 分钟降到约 5 分钟(来源:AWS EKS 机器学习推理文档,2026)。生产环境记得配 `TORCHINDUCTOR_CACHE_DIR`,指向持久卷。 **坑二:`dynamic=True` 会关掉 CUDA Graph。** 前面说过。形状稳定的用 `reduce-overhead` 拿图;变长序列用 `default` 或 `max-autotune-no-cudagraphs`,再配合**在 ±10-20% 范围内分桶/填充**把重编译次数压下去。 **坑三:短任务不划算。** 编译开销要摊到足够多的迭代里才有得赚。跑几十步的小实验,编译时间可能比省下的还多——这也是开头那段脚本为什么先跑 30 次预热再计时。 ## 七、我一般按这个顺序查 不一定适合所有人,供参考: 1. **先看利用率。** 已经 80%+ 就不用指望 compile,去查算法和并行。 2. **查图断点。** `explain()` 或 `TORCH_LOGS=graph_breaks`。目标是整个模型一张图;FSDP 通信处的断点是预期的,跳过。 3. **确认零重编译。** 跑几十步后应该不再重编。还在编,查是不是每步有东西在变。 4. **形状稳不稳。** 稳定就用 `reduce-overhead` 拿 CUDA Graph,不稳定就分桶 + `max-autotune-no-cudagraphs`。 5. **热点是不是 GEMM/注意力。** 是的话 compile 帮不上多少,去换库(更新的 FA 版本、FP8/FP4 量化)。 6. **还是不行就写内核。** 先用 Triton/Helion 试。 7. **缓存编译产物。** 生产环境不配这个,每次重启白等几分钟。 ## 参考资料 - PyTorch 官方博客:*Portable vLLM Model Inference Kernels in Helion*(2026,Qwen3 FP8 在 H100/B200 上的内核级与端到端实测) - Red Hat Developer:*From 200 lines to 15: How Helion is rewriting the rules of GPU programming*(2026-04) - PyTorch 官方文档:FSDP2 与 torch.compile 集成、CUDA Graph 与动态形状的互斥说明 - PyTorch 官方博客:*PyTorch 2.9: FlexAttention Optimization Practice on Intel GPUs*(2026) - AWS 文档:*Accelerate model loading on Amazon EKS*(2026,torch.compile 冷启动与编译产物缓存) - Fireworks AI 公开分析:GPU 算力与带宽增长剪刀差(GP100 21 TFLOPS / 730 GB/s → H100 989 TFLOPS / 3350 GB/s,半精度算力约 47×、带宽约 4.6×) - blog.prompt20.com:*Speeding Up PyTorch: CUDA Graphs, torch.compile, FlashAttn*(2026 年 CUDA Graph 生产实践资料) - jonathanding 调度与执行优化专栏:CUDA Graph 在 GPT-2 / LLaMA-7B / LLaMA-70B 上的加速比 - vLLM、SGLang、TensorRT-LLM 公开文档:CUDA Graph 在主流推理框架的 2026 集成现状 **延伸阅读**(本篇的数据不依赖这本书,想系统性补内核与编译器基础可以翻):Chris Fregly, *AI Systems Performance Engineering*, O'Reilly Media(第 12-14 章讲 CUDA Graph、TorchDynamo/AOT Autograd/Inductor/Triton 与图断点)。 > 说明:本文所有数字都来自公开可查来源或可自行复现的脚本,没有引用任何闭源案例。CUDA Graph 三组加速比(2.3×/1.7×/1.2×)引自 jonathanding 专栏 2026 年汇总,属特定配置下的测量值,无原始基准,只看量级;Helion 的 H100/B200 对比数字引自 PyTorch 官方博客,B200 上 GEMM 落后反映的是 Triton 在 Blackwell 上生成 GEMM 内核的当前水平,不是 Helion 编程模型本身的局限;"训练/推理 1.3-2×,轻量算子密集可达 3×"为业界经验区间而非官方基准,以你自己的实测为准。

优秀的个人博客,低调大师

AI Infra 系列 · 第四章 推理引擎 (下):投机解码、量化、KV 池化、MoE 并行,一张卡当两张用

## 一、投机解码:让快的小模型"打草稿",大模型"批改作业" decode 慢的根源是串行:一次只能生成一个 token,每步都要把全部权重搬一遍。 投机解码(Speculative Decoding)的思路很妙:让一个便宜的小模型(draft)一次猜出 K 个候选 token,大模型(target)用一次前向把所有候选一次性验证掉。猜对的直接收下,猜错的位置从大模型的真实分布重新采样。 这里有个关键细节:验证不是简单的"对/错",而是对每个草稿 token 按大模型的分布做 **rejection sampling 修正**。正是这个修正过程保证了输出分布和大模型自己逐 token 生成**完全一致(bit-exact)**,不是近似,是同一个分布(2026 年投机解码技术综述)。 ![fig10-speculative.png](https://developer.qcloudimg.com/http-save/yehe-11479707/9cec15778184c4604003d4171f436965.png) 加速多少,取决于三个数:接受率 α(draft 猜中的比例)、猜测长度 K、draft 相对 target 的成本比 c。代入典型值 α=0.7、K=4、c=0.1,加速约 2 倍(来源:appscale 2026 分析)。也就是说同样的硬件,吞吐翻倍。 2026 年的主流方案对比(来源:CallSphere/appscale 2026 综述): | 方案 | 思路 | 接受率 | 额外开销 | | ------------------------- | -------------------------- | --------------- | --------- | | **EAGLE-3**(2025) | 用 target 的深层隐藏状态做草稿头 + 草稿树 | 70–78% | 需训练草稿头,小 | | **Medusa-V2** | 给 target 挂多个预测头,同时猜多个未来位置 | 60–70% | 需训练头,部署简单 | | **MTP**(DeepSeek V3/V4) | 训练时就让模型学会一次预测多个 token | 80%+ | 无,但要重训模型 | | **自推测(Self-speculation)** | 用模型自己前面的 token 当草稿 | 40–55%(单一来源,参考) | 零额外内存 | 一个真实的生产案例:据报道(PayPal 技术论文与多家媒体),PayPal 在电商 agent 上实测 EAGLE-3,吞吐提升两到五成、延迟降低两到三成,输出质量无损;最震撼的是,一张 H100 用投机解码,追平了两张 H100 跑 NVIDIA NIM,推理 GPU 成本直接减半。注意这是领域模型实测,接受率只有约三成多,远低于通用基准的 70%+,说明真实收益必须自己测。 ### 什么时候别用投机解码 - 高温采样(creative 场景):draft 和 target 分歧大,接受率暴跌。 - 长上下文:接受率会随上下文变长而衰减。 - draft 太贵:7B 草稿配 70B target 基本没用,draft 成本占比必须很小。 ## 二、量化:FP8 是安全默认,FP4 是 Blackwell 的王牌 量化是把权重从 FP16 降精度存储,换内存减半或减四分之一。2026 年的格局很清楚(来源:ai.rs、mubibai 等 2026 量化评测): | 精度 | 适用硬件 | 吞吐提升(vs FP16) | 代价 | | -------------------- | -------------------- | -------------------- | ---------------------- | | **FP8** | Hopper(H100/H200) | 1.4–1.7x | 质量损失可忽略(0.3–0.5pp) | | **INT4**(GPTQ/AWQ) | 任意 GPU | 提速视场景(低并发 decode 明显) | 省显存但没有 4-bit 计算,先反量化再算 | | **FP4**(NVFP4/MXFP4) | Blackwell(B200/B300) | 约 2–5 倍(视对比基线) | 精度损失 1–3%,硬推理退化明显 | ![fig10-quant.png](https://developer.qcloudimg.com/http-save/yehe-11479707/85c0e70b175aa1c8503f43063beb320c.png) 三个关键判断: **① Hopper 上用 FP8,别碰 INT4。** INT4 只省带宽、不省计算(权重要反量化回 FP16 才做矩阵乘),FP8 是 Hopper 原生精度,又快又准。 **② FP4 是 Blackwell 才有的玩法。** Blackwell 的第五代 Tensor Core 原生支持 FP4,带宽和计算一起省:MLPerf 实测相对 H100 FP16 最高约 5 倍,相对同卡 FP8 约 2 倍。但要注意:NVFP4 在通用任务上能恢复九成七的质量,硬推理任务(数学、逻辑)只恢复八成左右,MMLU-Pro 和数学竞赛类基准会掉到约 80%(2026 年 Qwen3-8B 实测)。做数学应用前必须自己测。 **③ 优先用模型官方发布的量化版。** 比如 Kimi K2 Thinking 的 MoE 组件直接发布 INT4 QAT(量化感知训练)版本,训练时就带着量化在练,精度接近 FP16。官方出了 QAT 版就别自己折腾 GPTQ/AWQ。 ## 三、KV 池化:prefill 一次,处处复用 回到上篇的 KV Cache。每个请求都要重新算 prefill 生成 KV Cache,但很多 KV 是重复劳动:多轮对话的历史、RAG 检索的文档、所有人的系统提示,都是同一个前缀。 第二章下篇已经讲过 KV Cache 怎么在网络上传(NIXL、Mooncake 的分离式架构),这篇聚焦引擎侧的缓存复用。 **前缀缓存**:把相同前缀的 KV 缓存下来,新请求直接复用,跳过这段 prefill。SGLang 的 RadixAttention 用前缀树(radix tree)组织缓存,多轮对话、共享前缀场景吞吐能比 vLLM 高约 25–45%(视前缀命中率,来源:SGLang 论文与 2026 评测)。 **KV 池化**:把 KV Cache 从各 GPU 的私有显存里拿出来,放进一个统一的池子(GPU→CPU→NVMe→远端对象存储多级分层),引擎之间共享,像把散落各卡的行李寄存进统一仓库。 ![fig10-kvpool.png](https://developer.qcloudimg.com/http-save/yehe-11479707/033bf201f38efb1db6dd6341dd7b90ca.png) 2026 年这条赛道的几个玩家(来源:各项目 2026 发布与评测): - **LMCache**:给 vLLM/SGLang 加 KV 复用层,TTFT 最多降五到九成;分层卸载(GPU→CPU→SSD→Redis/S3)加 CacheBlend 支持任意位置复用(不止前缀匹配)。2026 年 agent 多轮流量把传统前缀缓存打崩(命中率跌破两成),LMCache 用 CacheBlend 做到数倍提升。 - **Mooncake**(月之暗面开源):以 KV Cache 为中心的分离式架构,128K 长上下文场景吞吐提升最高约 5–6 倍(复用它主要看缓存命中收益,架构细节见第二章下篇)。 - **NVIDIA Dynamo**:Smart Router 用 RadixTree 做前缀匹配,对话场景前缀共享率可达六到八成(第三方生产实测区间),配合分布式 KV Cache 管理器跨节点共享。 - **阿里云 Tair KVCache**:RDMA 全链路加速,长上下文 TTFT 降近八成、吞吐提升数倍。 KV Cache 正在从"用完即弃的临时缓冲"变成"和模型权重一样重要的资产"。谁缓存做得好,谁的单位 token 成本就低一截。 ## 四、MoE 推理并行:万亿参数怎么在集群上跑 1 万亿参数的模型,任何单卡都装不下,必须并行。推理侧有五种基本并行策略(书第 15 章): | 策略 | 切什么 | 适合场景 | 代价 | | ------------ | ------------ | -------------- | ------------------------ | | **张量并行 TP** | 层内的权重矩阵 | 单层太宽放不下一张卡 | 每层都要 all-reduce,需 NVLink | | **流水线并行 PP** | 按层切 | 模型太深 | 流水线气泡,逐 token 解码收益小 | | **专家并行 EP** | MoE 专家分布到不同卡 | 大 MoE 模型(关键策略) | 每层 all-to-all 通信 | | **数据并行 DP** | 复制整个模型,不同请求 | 扩吞吐最简单 | 内存×副本数 | | **上下文并行 CP** | 长序列切块 | 100k+ 超长上下文 | 注意力跨分区通信 | MoE 推理的核心是 **EP**:每个 token 只激活少数专家(如 top-2),专家分布在不同 GPU 上,token 通过 all-to-all 通信"打车"去找自己的专家。 ![fig10-moe.png](https://developer.qcloudimg.com/http-save/yehe-11479707/dd96726d52f021e1a0af1c687f5a7587.png) EP 有两大坑,对应两个关键参数: - **容量因子(capacity factor)**:限制每个专家每批最多接多少 token(通常设为平均负载的 1.2–1.5 倍)。否则热点专家会被塞爆,成为 straggler,拖慢整个推理(书第 15 章)。 - **专家负载不均衡**:门控网络如果总把 token 路由到少数"热"专家,这些专家就成了瓶颈。解法是训练时的负载均衡损失,加推理时把热专家复制到多张卡分担。 实践中没人用单一策略:常见组合是 EP + TP + DP(EP 切专家、TP 切层内权重、DP 复制副本扩吞吐),必要时再加 CP 处理超长上下文,组成"5D 并行"(EP+TP+DP+CP 组合,DeepSeek 惯例另含 attention 层的 DP)。 ## 五、顺序别搞反:先量化再投机 很多人一上来就冲投机解码,听起来酷。但我的经验是:量化优先于投机,先算账再炫技。 投机解码的收益高度依赖接受率,而接受率是你上线前算不准的(PayPal 实测只有约三成多,远低于论文里的 70%+)。量化则不同:FP8 的收益是确定的,风险是可控的,几乎零成本上手。 正确的顺序:先量化(确定的收益),再前缀缓存(看流量结构),然后投机解码(算清接受率再上)。PD 分离的落地细节见第二章下篇,这里不重复。 --- ## 参考资料 - Chris Fregly, *AI Systems Performance Engineering*, O'Reilly Media(第 15 章并行、第 17 章分离式、第 18 章 KV Cache 调优) - CallSphere:《Speculative Decoding in 2026: EAGLE-3, Medusa-V2, Self-Speculation》 - appscale:《Speculative Decoding in Production LLM Inference (2026)》 - PayPal 工程博客/技术论文(2026,投机解码生产实践,报道见 The Agent Times / Gentic News) - ai.rs:《4-Bit Quantization Decoded: INT4 QAT, MXFP4, NVFP4》《Quantization Methods Compared》 - mubibai:《FP4 goes production: how MR-GPTQ and Blackwell killed the 4-bit quality penalty》(2026) - LMCache / Mooncake / NVIDIA Dynamo / 阿里云 Tair KVCache 官方文档与 2026 评测 - ZOOZ Engineering:《LLM Inference Concepts and Optimization Techniques》(2026) > 说明:图都为示例。投机解码接受率、量化精度数据来自 2026 年公开论文与评测,不同模型/负载下差异明显;PayPal 案例为媒体报道量级,具体数字以其官方披露为准,文中已标注"据报道"。

资源下载

更多资源
Mario

Mario

马里奥是站在游戏界顶峰的超人气多面角色。马里奥靠吃蘑菇成长,特征是大鼻子、头戴帽子、身穿背带裤,还留着胡子。与他的双胞胎兄弟路易基一起,长年担任任天堂的招牌角色。

Nacos

Nacos

Nacos /nɑ:kəʊs/ 是 Dynamic Naming and Configuration Service 的首字母简称,一个易于构建 AI Agent 应用的动态服务发现、配置管理和AI智能体管理平台。Nacos 致力于帮助您发现、配置和管理微服务及AI智能体应用。Nacos 提供了一组简单易用的特性集,帮助您快速实现动态服务发现、服务配置、服务元数据、流量管理。Nacos 帮助您更敏捷和容易地构建、交付和管理微服务平台。

Spring

Spring

Spring框架(Spring Framework)是由Rod Johnson于2002年提出的开源Java企业级应用框架,旨在通过使用JavaBean替代传统EJB实现方式降低企业级编程开发的复杂性。该框架基于简单性、可测试性和松耦合性设计理念,提供核心容器、应用上下文、数据访问集成等模块,支持整合Hibernate、Struts等第三方框架,其适用范围不仅限于服务器端开发,绝大多数Java应用均可从中受益。

Rocky Linux

Rocky Linux

Rocky Linux(中文名:洛基)是由Gregory Kurtzer于2020年12月发起的企业级Linux发行版,作为CentOS稳定版停止维护后与RHEL(Red Hat Enterprise Linux)完全兼容的开源替代方案,由社区拥有并管理,支持x86_64、aarch64等架构。其通过重新编译RHEL源代码提供长期稳定性,采用模块化包装和SELinux安全架构,默认包含GNOME桌面环境及XFS文件系统,支持十年生命周期更新。

用户登录
用户注册