想象一下你要建造一座智慧城市：市政大厅（CPU）负责统筹规划、处理各种突发杂务；超级工厂（GPU/CDNA3）负责大规模并行生产；巨大的自动化仓库（HBM3）紧挨着工厂，货物吞吐极快；而贯穿全城的高速路网（Infinity Fabric）把市政厅、工厂、仓库连成一体。AMD MI300就是这样一座“单芯片智慧城市”——它把 CPU 和 GPU 统一封装在一起，共享同一个仓库，不用像传统方案那样在多个仓库之间来回倒腾货物。 作为 AI 编译器工程师（城市交通调度设计师），你要让计算图（货物运输路线图）在这座城市里高效运转。理解 MI300 的 APU 统一架构、CDNA3 计算单元、128GB HBM3 内存和 Infinity Fabric 互联，就掌握了为这座“城市”设计最优物流方案的全部钥匙。无论你做算子优化、内存规划还是并行策略，这些知识都会直接决定模型训练与推理是“一路畅通”还是“步步堵车”。

岗位关联

对 AI 从业者而言，理解 MI300 的硬件特性是做好计算图编译优化、算子调优与大模型部署的前提，能让你的模型在这颗芯片上跑出数倍性能差距。

目录
  1. 可视化演示
  2. APU统一架构
  3. CDNA3计算架构
  4. HBM3内存
  5. Infinity Fabric互联
  6. 大模型训练
  7. 大模型推理
  8. 编译器适配
  9. AI 应用场景
  10. Python 演示
  11. 常见误区
  12. 面试题

可视化演示

通过APU统一架构（CPU+GPU同封装共享HBM3内存）、显存带宽对比（MI300X 128GB vs H100 80GB vs A100 80GB）与LLM推理性能（MI300X领先H100约30%）三个模式，展示AMD MI300的数据中心AI加速器设计。

本节配有交互动效（进入视口后自动加载，约 3KB）。

MI300A APU统一架构 CPU与GPU集成在同一封装共享HBM3统一内存消除拷贝开销 Infinity Fabric互联提供CPU-GPU间高速数据通路 CPU+GPU → Unified HBM3 (UMA) APU统一架构实现真正的统一内存寻址

APU统一架构

想象把市政大厅（CPU）和超级工厂（GPU）建在同一个园区里，共用大厅里的档案库（物理内存）。过去，市政厅和工厂分别坐落在城市两端，资料要先从市政厅复印一份快递到工厂（一次拷贝），算完再快递回去（二次拷贝），每次都要等快递时间。MI300 的 APU 设计则让 CPU 和 GPU 直接住在同一栋楼里，档案就在脚下——谁要看，转身就能拿到。

从计算图编译器的角度看，这种“同址共享”带来一个革命性变化：计算图中不再需要显式的 HostToDevice / DeviceToHost 拷贝节点。在过去，AI 编译器生成的中间表示（IR）里，每个算子的输入往往要带一个“从 CPU 内存拷到 GPU 显存”的小尾巴；在 MI300 上，这些尾巴可以直接剪掉。剪掉的不仅是指令，更是整条流水线上反复等待的时间。

统一地址空间还意味着 CPU 和 GPU 能通过同一个指针访问同一份数据。编译器只需维护一份内存布局描述，不用担心“同一份数据在两侧各有一份副本”导致的一致性同步问题。这简化了编译器的内存别名分析、依赖分析和调度决策。

编译器的“统一视图”意味着所有算子看到的都是一个平坦的大内存。这就像城市规划师只需要画一张地图，不必操心哪块地皮属于哪个部门。最终，计算图更干净、调度更简单、端到端延迟也更低——这正是 APU 设计对 AI 编译器最大的礼物。

Ttotal=Tcompute+TtransferT_{\text{total}} = T_{\text{compute}} + T_{\text{transfer}}
公式解读：一次算子执行的总时间由纯计算时间和数据传输时间组成。在传统离散架构中 T_transfer 常占 30%-50%；MI300 的统一内存让 T_transfer 趋向于零。
  1. 总耗时T_total 表示从算子开始到结束的墙钟时间，是 CPU 和 GPU 双双等待后最终消耗的时间。
    TtotalT_{\text{total}}
  2. 计算耗时T_compute 是 GPU 真正执行矩阵乘、卷积等运算的纯算力时间，由算子复杂度和计算单元利用率决定。
    TcomputeT_{\text{compute}}
  3. 传输耗时T_transfer 是数据在内存层级之间搬移的时间。传统架构中它来自 PCIe 拷贝，而在 MI300 统一内存上，CPU 与 GPU 共享 HBM，这一项几乎归零。
    Ttransfer≈0T_{\text{transfer}} \approx 0

CDNA3计算架构

走进工厂内部，你会发现它由 228 个车间（计算单元，Compute Unit）组成，每个车间里又有大量工人（线程）并行作业。CDNA3 是专为 AI 计算优化的 GPU 架构，它最重要的装备是一台“矩阵流水线机器”——WMMA（Wave Matrix Multiply-Accumulate）指令。过去做矩阵乘法要工人一个个搬砖，现在一条 WMMA 指令能让整条流水线一次性处理一块大矩阵。

对编译器而言，WMMA 指令意味着矩阵乘法算子应该尽可能被映射成 Tile 级别的指令块，而不是拆成标量循环。编译器把一个大矩阵切成 16×16、32×32 的“瓷砖”（Tile），每一块瓷砖由一次 WMMA 指令完成乘加运算。切法与瓷砖大小直接决定寄存器压力和指令发射效率，这是 CUDA/ROCm 后端代码生成的核心议题。

CDNA3 还支持 2:4 结构化稀疏加速：权重矩阵中每 4 个元素恰好有 2 个为零时，计算量可以减半。编译器需要检查模型中是否存在这类稀疏模式，并决定要不要启用稀疏指令路径。稀疏格式转换本身有开销，所以编译器要在“节省的计算量”和“转换的代价”之间做权衡。

工厂的车间排列得越整齐，参观路线（编译器的指令调度）就越顺畅。编译器做指令调度的目标，就是让每个车间（CU）在整个生产周期内一直有活干，别让任何一条流水线闲置——这就是 CDNA3 上获得高算力利用率的关键。

Cm,ntile=∑k=1KAm,ktile×Bk,ntileC_{m,n}^{\text{tile}} = \sum_{k=1}^{K} A_{m,k}^{\text{tile}} \times B_{k,n}^{\text{tile}}
公式解读：矩阵乘法被切分成一个个 Tile 后，每个输出 Tile 是输入 Tile 沿 K 维的乘累加结果。WMMA 指令一次性完成这个累加。
  1. 输出坐标C_m,n 表示输出矩阵第 m 行第 n 列的小块（Tile），是整个大矩阵的一个局部结果。
    Cm,ntileC_{m,n}^{\text{tile}}
  2. 累加维度Σ_{k=1}^{K} 表示把 K 个中间乘积累加起来，K 是矩阵的内维大小（如隐藏层维度）。
    ∑k=1K\sum_{k=1}^{K}
  3. 输入矩阵块A_{m,k}^{\text{tile}} 是左侧输入矩阵的第 m 行第 k 列的 Tile，B_{k,n}^{\text{tile}} 是右侧输入矩阵第 k 行第 n 列的 Tile，两者相乘后累加得到输出。
    Am,ktile×Bk,ntileA_{m,k}^{\text{tile}} \times B_{k,n}^{\text{tile}}

HBM3内存

工厂旁边是一座巨大的自动化仓库：128GB 的 HBM3 内存。更关键的不是它“大”，而是门口的传送带极宽——带宽高达 5.2TB/s，相当于一秒内搬完整座图书馆的藏书。传统 GDDR 显存像窄而长的通道，而 HBM3 是用高密度堆叠技术做出的“宽体传送带”，从根本上改变了数据供给速度。

HBM3 的容量和带宽对 AI 编译器有双重意义。容量大意味着可以把大模型的权重、优化器状态、激活值全部装进显存，不用频繁换入换出；带宽高意味着每个算子从内存读数据的等待时间大幅缩短。编译器在做内存规划时，可以把更多中间张量留在 GPU 侧，减少“因为放不下而要提前写回”的保守策略。

不过，带宽再高也有上限。编译器在调度算子时，仍然要计算每个算子的算术强度（每字节数据能做多少次浮点运算）。如果一个算子读一次数据只做一两次运算（如逐元素激活函数），它就是个“内存密集”算子，瓶颈在带宽而不是算力；编译器应尽量把这些算子与相邻算子融合，减少重复读写。

有了这座巨型仓库，AI 编译器终于可以“大手大脚”地把中间结果留在显存里，而不必精打细算地反复腾挪。正如城市规划师不用再为仓库位置发愁，编译器也能把注意力转向真正创造收益的优化——算子融合与并行调度。

Ttransfer=DBytesBWBytes/sT_{\text{transfer}} = \frac{D_{\text{Bytes}}}{BW_{\text{Bytes/s}}}
公式解读：搬运时间等于数据量除以带宽。要读 1GB 数据，在 5.2TB/s 带宽下只需约 0.19 毫秒；若换成 PCIe（约 64GB/s），就要 15.6 毫秒，差距悬殊。
  1. 数据量D_Bytes 是待搬运的数据字节数，例如一个 4096×4096 的 FP16 矩阵约 33.5MB。
    DBytesD_{\text{Bytes}}
  2. 带宽BW_Bytes/s 是内存到计算单元之间的有效带宽，HBM3 的约 5.2TB/s 就是这里的最大值。
    BWBytes/sBW_{\text{Bytes/s}}
  3. 时间比值整个公式给出搬运耗时。编译器通过比较不同算子或不同切分方案的 T_transfer，来决定最优的执行顺序。
    DBytesBWBytes/s\frac{D_{\text{Bytes}}}{BW_{\text{Bytes/s}}}

Infinity Fabric互联

园区内部还有一条高速路网——Infinity Fabric。它把 CPU 小芯片、GPU 计算小芯片（Chiplet）、HBM 内存堆叠全部连接起来。如果把 MI300 拆开，你会看到多个小芯片像拼图一样拼接在一起，而 Infinity Fabric 就是这些拼图块之间的“黄金接缝”。它既负责片内数据流动，也能跨芯片连接多颗 MI300 组建更大的集群。

对 AI 编译器来说，Infinity Fabric 是调度图上的一条“隐形边”：任何一个跨小芯片的数据依赖，都会产生通信成本。编译器在切分计算图时，要尽量把频繁通信的算子放在同一个小芯片上，就像城市规划师尽量把有业务往来的部门安排在同一个街区，减少跨区通勤。

多卡扩展时，Infinity Fabric 的片间互联带宽远高于传统 PCIe 方案，但仍是有限资源。编译器生成分布式执行计划时，需要把通信算子的耗时建模进总时间。张量并行（把一个大矩阵切成多块分给不同芯片）每层都需要一次 AllReduce 通信；如果通信量太大，增加的通信时间可能抵消并行带来的算力收益。

Infinity Fabric 让“多城市协作”成为可能，但协作必然伴随沟通成本。优秀的编译器会像精明的城市规划师一样，把沟通最频繁的部门安排在同一个片区，让城市群的协作效率最大化。

Tcomm=α+DpayloadBfabricT_{\text{comm}} = \alpha + \frac{D_{\text{payload}}}{B_{\text{fabric}}}
公式解读：一次跨片通信的延迟由固定启动开销 α 和数据量除以带宽两部分组成。数据量越大，通信时间越长；α 是即使只传 1 字节也要付出的固定代价。
  1. 固定开销α 是发起一次通信的固定延迟，包括协议握手、消息头解析等，与数据大小无关。
    α\alpha
  2. 传输数据量D_payload 是实际要传输的激活值或梯度字节数。
    DpayloadD_{\text{payload}}
  3. 互联带宽B_fabric 是 Infinity Fabric 的有效带宽。编译器通过这个公式评估两个算子分别放在不同片上是否划算。
    BfabricB_{\text{fabric}}

大模型训练

现在城市要承接一个国家级大工程——训练 700 亿参数的大语言模型。单一的工厂无论如何也堆不下全部物资和作业，必须采用“多城市联合施工”：数据并行（每个城市处理不同批次的数据）和张量并行（把一个大矩阵切成多块分给多个工厂同时加工）。

MI300 的 128GB 大内存让每个“城市”能独立承担更大的模型分片。编译器在规划分布式训练时，要决定每个张量放在哪颗芯片上、何时触发梯度同步。分片内存的策略直接影响显存峰值：模型权重、梯度、优化器状态、激活值四类数据都要有各自的“仓库位置”。如果规划不当，即使总容量达到 128GB，也可能在某一步突然爆显存。

训练吞吐量的核心指标是“每秒处理多少 Token”。编译器通过合并通信与计算（overlap）、使用混合精度、重计算（activation recomputation）等技巧，让 MI300 的算力尽量饱和。大内存带来的额外好处是：激活重计算的频率可以降低，因为不需要为了省显存而频繁丢弃中间结果再重算。

宽敞的仓库让工程队可以一次性囤够材料，宽大的传送带让材料随取随用。编译器要做的，就是安排好几支施工队（并行策略），让他们既不互相争抢物资（带宽争用），又能及时汇总进度（梯度同步）。

TokensPerSec=Bglobal×Sseqtstep\text{TokensPerSec} = \frac{B_{\text{global}} \times S_{\text{seq}}}{t_{\text{step}}}
公式解读：训练吞吐（每秒处理的 Token 数）等于全局批量大小 × 序列长度 ÷ 单步耗时。MI300 的大内存允许更大批量，从而摊薄单步里的固定开销。
  1. 全局批量B_global 是所有并行设备上的总批量大小（batch size × 设备数），越大则每一步处理的数据越多。
    BglobalB_{\text{global}}
  2. 序列长度S_seq 是每条样本的 Token 数（序列长度），与批量相乘得到一步内处理的总 Token 数。
    SseqS_{\text{seq}}
  3. 单步耗时t_step 是一次前向+反向传播的墙钟时间，它包含计算、通信、同步等全部开销。吞吐量由这两者的比值决定。
    tstept_{\text{step}}

大模型推理

工程结束后，城市转入日常运营——为海量市民提供即时问答服务。推理服务的本质是“根据历史对话生成下一个词”，而每一次生成都要回顾所有历史信息。这些历史信息被压缩成 Key 和 Value 张量，存放在一个叫 KV 缓存（KV Cache）的“服务台记录本”里。记录本越大，能同时服务的用户（并发请求）就越多。

MI300 的 128GB 内存在这里展现出巨大优势。7B 模型需要约 14GB 权重，剩下 100GB+ 都可以用来存 KV 缓存；而传统 80GB 显存的 GPU 存完权重后只剩约 60GB 留给 KV。粗略估算，MI300 能承载的并发请求数是传统方案的 1.5-2 倍。编译器在推理场景下的任务，就是把 KV 缓存的申请、释放和复用规划好，避免动态分配带来的碎片化。

大 Batch 推理是另一个关键优化方向：把多个用户的请求合并成一个大矩阵一起计算，能显著提高 GPU 利用率。编译器需要动态 batching 策略——当一个请求结束后，把它的位置让给新请求，让矩阵始终保持“满员”状态。大内存让大 Batch 成为可能，而大 Batch 又让算力充分释放，二者形成正循环。

把推理服务想象成一家大型政务服务中心：128GB 的“等待区”能容纳更多人同时办事，编译器这个“叫号系统”则保证每个窗口（计算单元）都有人可办、不空转。大内存 + 大 Batch + 智能调度，共同造就了 MI300 在大模型推理上的亮眼表现。

MKV=2×B×Sseq×L×Hdim×2 bytesM_{\text{KV}} = 2 \times B \times S_{\text{seq}} \times L \times H_{\text{dim}} \times 2\,\text{bytes}
公式解读：KV 缓存总大小 = 2（Key 和 Value 各一份）× 批量大小 × 序列长度 × 层数 × 隐藏维度 × 每个元素字节数。容量越大，能支持的并发和上下文越长。
  1. K和V双份2 × 表示每层注意力需要同时存储 Key 和 Value 两组张量。
    2×2 \times
  2. 请求规模B × S_seq 是 batch 大小与序列长度的乘积，即所有请求的总 Token 数，决定了缓存的“行数”。
    B×SseqB \times S_{\text{seq}}
  3. 模型结构L × H_dim 是层数与隐藏维度的乘积，决定每 Token 需要的缓存“列数”。乘起来就是总元素个数。
    L×HdimL \times H_{\text{dim}}
  4. 每元素字节数× 2 bytes 表示 FP16 格式下每个元素占 2 字节，最终得到以字节为单位的总量。
    2 bytes2\,\text{bytes}

编译器适配

最后，一切还要落到“交通调度中心”——AI 编译器。它拿到一张庞大的计算图（城市交通路线图），要把图中的节点映射到真实的硬件资源上。MI300 的特殊硬件特性（统一内存、WMMA、HBM3、Infinity Fabric）决定了编译器必须做一些“量身定制”的决策。

第一是算子选择。编译器要把计算图中的每个算子（如 matmul、attention、layernorm）映射到最合适的指令序列。矩阵乘法用 WMMA，卷积可以用矩阵乘展开，归一化算子要避免频繁读写内存。ROCm 的 HIP 生态和 Triton 这样的 DSL 编译器，都在为 MI300 生成高质量代码而优化指令选择策略。

第二是内存规划。编译器要计算整张图的峰值内存，决定每个中间张量什么时候分配、什么时候释放。“内存复用”技术让生命周期不重叠的张量共用一个内存块，能把峰值内存压缩到原来的几分之一。在 128GB 的 HBM3 上，好的内存规划意味着你能塞进更大的模型、更大的 Batch，或者更长的上下文。

第三是计算图优化。包括算子融合（把多个小算子合成一个大内核）、死代码消除、公共子表达式提取等。融合不仅能减少内核启动次数，还能让中间数据留在寄存器或共享内存里，避免反复经过 HBM3。对内存密集的小算子，融合的收益尤其明显。

城市规划师的责任，是让整座城市在最高效的节奏下运转。AI 编译器之于 MI300 也是如此——理解每一条高速公路（Infinity Fabric）、每一座仓库（HBM3）、每一台机器（CDNA3）的特性，才能在计算图上做出最聪明的决策，让硬件性能彻底释放。

Mpeak=MW+MA+MG+MOM_{\text{peak}} = M_{W} + M_{A} + M_{G} + M_{O}
公式解读：训练时的峰值内存由权重、激活、梯度和优化器状态四部分组成。编译器通过重计算、分片和内存复用等多种手段压缩这四个分量，让模型“塞进”物理内存。
  1. 权重M_W 是模型参数本身占用的内存，如 7B 模型在 FP16 下约 14GB。
    MWM_{W}
  2. 激活M_A 是前向传播中所有中间张量的总和，这部分常因 Batch 和序列长度增大而暴涨。
    MAM_{A}
  3. 梯度M_G 是反向传播过程中生成的梯度张量，与权重同尺寸。
    MGM_{G}
  4. 优化器状态M_O 是 Adam 等优化器维护的动量与方差，通常比权重占用更多内存（如 FP32 的 Adam 状态是权重的 8 倍）。
    MOM_{O}

AI 应用场景

大模型训练的内存规划

阶段：AI编译器后端的内存分配与模型分片

解决的问题：传统做法中，每个设备只看到自己的显存，训练大模型时常因显存不足而被迫降低 batch size 或频繁换入换出。MI300 的 128GB 大内存让编译器可以把模型权重、优化器状态、激活值、梯度全部放进共享内存，统一做峰值内存规划，减少保守的显存释放策略，从而支持更大 batch 和更高吞吐。

具体案例：某团队在 MI300 上训练 70B 参数的 Llama 类模型，通过 ROCm 的显存池化机制让多个算子的中间张量复用同一块内存区域，峰值占用从 136GB 降到 112GB，成功把 batch size 从 96 提升到 128，训练吞吐提高约 18%。

大模型推理的 KV 缓存优化

阶段：推理服务部署与计算图优化

解决的问题：推理服务的并发能力受限于 KV 缓存大小。传统 GPU 只有 80GB 显存，存完 7B 模型权重后，KV 空间有限，只能支持较少并发。MI300 的 128GB 内存让 KV 缓存的容量大幅提升，编译器可以支持更大 Batch 的动态推理，配合 PagedAttention 类技术减少碎片。

具体案例：一家 AI 服务商在 MI300 上部署 13B 对话模型，通过把 KV 缓存分配到统一内存并使用动态批处理，并发数从 32 提升到 64，单 Token 生成延迟保持稳定在 35ms 以内，总吞吐翻倍。

算子融合与内核调优

阶段：计算图优化与代码生成

解决的问题：Transformer 计算图中存在大量逐元素小算子（激活函数、归一化、残差连接），每个算子都有内核启动开销和额外内存读写。编译器把这些算子融合进矩阵乘/注意力的大内核中，减少内核启动次数和 HBM 流量。

具体案例：在 MI300 上，编译器将 RMSNorm + Residual Add + RoPE 融合进 Attention 算子的 epilogue，单个 decoder layer 的内核启动次数从 11 次降到 6 次，端到端推理速度提升约 22%。

Python 演示

python87 行
"""演示 AI 编译器在 MI300 统一内存 vs 传统离散架构下的计算图规划差异""" import math  class IRNode:    """计算图中间表示节点"""     def __init__(self, name, output_bytes):        self.name = name        self.output_bytes = output_bytes  def build_transformer_graph(layers, batch, seq, hidden):    """构造简化 Transformer 计算图，每层产生一个激活张量"""    act_bytes = batch * seq * hidden * 4  # FP32 一个元素占 4 字节    nodes = []    for i in range(layers):        nodes.append(IRNode("linear_%d" % i, act_bytes))        nodes.append(IRNode("norm_%d" % i, act_bytes))    return nodes  def insert_copy_nodes(graph, unified_memory):    """编译器后端：决定是否需要为每个算子插入拷贝节点"""    ir = []    for node in graph:        ir.append((node.name, "compute"))        if not unified_memory:            ir.append((("copy_%s" % node.name), "copy"))    return ir  def estimate_time(ir, compute_ms_per_node, copy_ms_per_node, unified_memory):    """估算总执行时间"""    compute_time = 0.0    copy_time = 0.0    for _name, kind in ir:        if kind == "compute":            compute_time += compute_ms_per_node        elif kind == "copy":            copy_time += copy_ms_per_node    if unified_memory:        copy_time = 0.0    return compute_time + copy_time, compute_time, copy_time  def main():    layers = 32    batch = 8    seq = 1024    hidden = 4096     graph = build_transformer_graph(layers, batch, seq, hidden)    discrete_ir = insert_copy_nodes(graph, unified_memory=False)    unified_ir = insert_copy_nodes(graph, unified_memory=True)     compute_ms = 3.2   # 每个算子平均计算耗时    copy_ms = 12.5     # 每次 PCIe 拷贝耗时（远大于计算）     t_discrete, c_discrete, copy_discrete = estimate_time(        discrete_ir, compute_ms, copy_ms, unified_memory=False    )    t_unified, c_unified, copy_unified = estimate_time(        unified_ir, compute_ms, copy_ms, unified_memory=True    )     print("=== 计算图节点统计 ===")    print("离散架构 IR 节点数: %d" % len(discrete_ir))    print("统一内存 IR 节点数: %d" % len(unified_ir))    print()    print("=== 执行时间估算（毫秒） ===")    print("离散架构总耗时: %.1f ms (计算 %.1f + 拷贝 %.1f)" % (        t_discrete, c_discrete, copy_discrete    ))    print("MI300 统一内存总耗时: %.1f ms (计算 %.1f + 拷贝 %.1f)" % (        t_unified, c_unified, copy_unified    ))    speedup = t_discrete / t_unified    print("加速比: %.2fx" % speedup)     if __name__ == "__main__":        pass  if __name__ == "__main__":    main()
目的：用一个小型编译器模拟器演示 MI300 统一内存如何消除计算图中的拷贝节点，直观展示端到端加速效果。
  1. build_transformer_graph(layers, batch, seq, hidden)构建简化 Transformer 计算图，每层产生一个激活张量，大小为 batch × seq × hidden × 4 字节。
  2. insert_copy_nodes(graph, unified_memory=False)模拟编译器后端 IR 生成：传统架构下每个算子输出后都要插入一个拷贝节点，统一内存则完全跳过。
  3. estimate_time(ir, compute_ms, copy_ms, unified_memory)根据节点类型累加耗时，拷贝时间在统一内存下归零。
  4. copy_ms = 12.5模拟 PCIe 拷贝一个激活张量的耗时，这个数字远大于算子的计算耗时，是传统架构的主要瓶颈。
  5. speedup = t_discrete / t_unified计算加速比，展示消除拷贝节点带来的端到端收益。

常见误区

误区MI300 的 CPU 和 GPU 共享内存，编译器就不用关心数据在哪里了，计算图里不应当有任何搬运相关的开销。

正解统一内存消除的是 CPU 主存与 GPU 显存之间的 PCIe 拷贝，但 GPU 内部的 HBM3 → L2 缓存 → 寄存器/共享内存仍然有搬运成本。编译器依然要规划数据放哪个层级、何时预取、何时写回，否则计算单元会因等数据而空转。就像园区内共享仓库免去了跨城快递，但仓库到车间之间的传送带依然需要调度。

为何常见：厂商宣传“零拷贝”时强调统一内存的好处，人们容易把“跨设备拷贝没了”理解成“所有搬运都没了”。

误区128GB 就是变大了，带宽应该跟 GDDR 差不多，反正训练时主要看算力。

正解HBM3 的带宽（约 5.2TB/s）是 GDDR5 的数倍，远超 PCIe 的 64GB/s。高带宽直接改变了算子的“瓶颈归属”：很多访存密集算子过去卡在带宽上，现在可以跑满算力。编译器需要按新的带宽模型重新计算算术强度，判断哪些算子需要融合、哪些不需要。

为何常见：人们习惯用容量来理解显存规格，很少关注带宽对整体性能的支配作用。

误区MI300 有 228 个计算单元，比上一代多不少，训练速度肯定接近线性提升。

正解训练步时间由计算、内存访问、通信三部分共同决定。计算单元再多，如果 HBM 带宽喂不饱、或多卡通信在 AllReduce 上耗时长，实际速度远达不到线性。编译器需要合理选择并行策略和算子融合方案，才能把算力优势转化为真实性能。

为何常见：厂商发布时宣传峰值算力，而峰值算力只有在极理想条件下才能达到，实际训练中瓶颈往往是数据供给。

误区归一化、逐元素乘这些小算子执行只要几微秒，编译器没必要花力气去融合优化。

正解每个算子都有内核启动开销和内存读写成本，大模型计算图里几十上百个算子的累积开销非常可观。融合多个小算子进大内核，能减少启动次数、提升中间数据在寄存器和共享内存中的复用率，对访存密集场景的性能影响可达 20%-30%。

为何常见：单看一个算子确实微不足道，但放大到整张计算图的循环迭代中，积少成多就变成了显著开销。

面试题

Q1. 以下哪项是 MI300 中"APU"设计的核心特征？

单选题 · easy

  • A.在PCIe总线上外挂独立的超大容量显存
  • B.把CPU与GPU封装在同一颗芯片上共享内存← 正确答案
  • C.让GPU代替CPU独立运行整个操作系统
  • D.用FPGA电路替代所有专用AI加速单元

答案：B。APU 的核心是把 CPU 和 GPU 放进同一颗芯片，共享统一物理内存地址空间。A 是传统独立显卡方案，C 混淆了 GPU 的定位，D 则是完全无关的硬件实现。

Q2. CDNA3 架构中专门加速矩阵乘法的指令叫什么？

单选题 · easy

  • A.标量乘加运算指令
  • B.向量读写加载指令
  • C.WMMA矩阵乘累加指令← 正确答案
  • D.数据广播同步指令

答案：C。WMMA（Wave Matrix Multiply-Accumulate）是 CDNA3 中用于矩阵乘累加的核心指令，一次可处理一个矩阵 Tile。标量乘加（A）是 CPU 的指令，向量加载（B）不负责计算，广播同步（D）与计算无关。

Q3. 以下哪项是 MI300 配备的 HBM3 内存的典型特征？

单选题 · easy

  • A.容量极小但制造工艺非常先进
  • B.拥有128GB超大容量与TB级带宽← 正确答案
  • C.通过PCIe接口与GPU交换数据
  • D.仅用于存储模型权重文件

答案：B。MI300 的 HBM3 内存容量达 128GB，带宽约 5.2TB/s。HBM3 是堆叠式高带宽内存，不是 PCIe 外设（C 错），也远非“容量极小”（A 错），它存储所有类型的张量数据（D 错）。

Q4. 统一内存对 AI 编译器最直接的好处是什么？

单选题 · mid

  • A.通信带宽获得无限提升
  • B.内核启动开销直接消失
  • C.所有算子自动进行融合
  • D.计算图无需插入拷贝节点← 正确答案

答案：D。统一内存让 CPU 和 GPU 共享同一物理内存，编译器生成计算图 IR 时不再需要 HostToDevice/DeviceToHost 拷贝节点。通信带宽不会无限提升（A 错），内核启动和算子融合都与统一内存无直接关系（B、C 错）。

Q5. Infinity Fabric 在 MI300 中主要承担什么角色？

单选题 · mid

  • A.管理HBM3的刷新策略与纠错编码
  • B.连接片内Chiplet与多卡之间互连← 正确答案
  • C.替代CPU自主调度所有计算算子
  • D.充当GPU内部寄存器的缓存层级

答案：B。Infinity Fabric 是 MI300 的高速互连总线，负责连接片内的 CPU/GPU Chiplet 以及多颗芯片之间的通信。它不管理内存刷新（A 错）、不算子调度（C 错）、也不是寄存器缓存（D 错）。

Q6. 大模型推理时，KV 缓存主要存储什么内容？

单选题 · mid

  • A.训练过程中产生的反向传播梯度
  • B.注意力机制的Key与Value张量← 正确答案
  • C.输入词元的词表概率分布
  • D.模型优化器的动量状态值

答案：B。KV 缓存保存的是自注意力中历史 Token 的 Key 和 Value 张量，用于增量解码时避免重复计算。梯度（A）和优化器状态（D）是训练阶段的产物，词表概率分布（C）只是输出层的临时结果。

Q7. 为什么 MI300 的大容量 HBM3 特别有利于大模型推理？

单选题 · hard

  • A.能缓存更多KV数据并提高Batch大小← 正确答案
  • B.使每个算子的数值精度自动提升
  • C.彻底消除了权重读取的带宽成本
  • D.可以让模型在运行时完全不访问内存

答案：A。128GB 内存让模型权重之外有更多空间存放 KV 缓存，从而支持更大的并发 Batch 和更长上下文。内存容量不改变数值精度（B 错），也不会消除带宽成本（C、D 错），数据和权重仍然需要从 HBM 读入。

Q8. AI 编译器在 MI300 上做内存规划时，通常要考虑哪些部分？

多选题 · mid

  • A.图形化界面渲染开销
  • B.模型权重和优化器状态← 正确答案
  • C.前向激活张量的峰值← 正确答案
  • D.反向传播梯度存储← 正确答案

答案：BCD。训练内存规划需覆盖权重、优化器状态、激活值和梯度四大类。图形化界面渲染是主机侧任务，与 GPU 内存规划无关，编译期计算峰值内存时不会纳入这部分。

Q9. 关于张量并行（Tensor Parallelism），以下说法正确的是？

多选题 · hard

  • A.完全消除了设备间的通信开销
  • B.可切分超大规模矩阵到多设备← 正确答案
  • C.需要在层间同步通信中间结果← 正确答案
  • D.允许模型跨多颗芯片部署推理← 正确答案

答案：BCD。张量并行把权重矩阵按行/列切分到多设备，同时需要在每层计算后做 AllReduce 同步通信，因此 B、C、D 都是正确描述。通信开销不会消失，反而可能成为瓶颈，A 错。

Q10. 关于算子融合优化，以下说法正确的是？

多选题 · hard

  • A.一定能把数值精度提升到双精度
  • B.有效减少内核启动等待开销← 正确答案
  • C.可将多个小算子合并执行← 正确答案
  • D.提升中间数据的复用效率← 正确答案

答案：BCD。算子融合把多个小算子合成一个大内核，减少启动次数、让中间结果留在寄存器或共享内存中复用。融合关注性能而非数值精度，双精度与否取决于数据格式设置，A 错。