想象你走进一家大型“共享厨房”:灶台、锅具、水电燃气一应俱全,你只要带着自己的菜谱进来就能做菜。这就是 AMD 推出的 ROCm——一套开源的 GPU 计算平台。它像一位贴心的房东,把你需要的“锅碗瓢盆”——编程模型、运行时环境、算子库——全部免费开放,让你不必从零搭建厨房。更重要的是,它提供的 HIP 编程模型像一本“中英对照菜谱”:同一道菜,写上中文版,拿到英文厨房也能做。也就是说,你为 AMD GPU 写的代码,稍作调整(甚至不改动),也能在 NVIDIA GPU 上跑起来,彻底打破了过去“用谁家卡就必须学谁家手艺”的垄断局面。

岗位关联

学习 ROCm,意味着你从“只会用 CUDA 做菜”晋升为“看得懂两家厨房、会平移手艺”的 AI 工程师,在芯片多元化的市场上,这项跨平台能力会成为你简历上的硬通货。

目录
  1. 可视化演示
  2. 平台定位:一张开源厨房的入场券
  3. 核心架构:厨房里的三大基础设施
  4. 安装配置:开火前的准备清单
  5. 框架适配:照着菜单做菜
  6. 性能特征:火候与出菜速度
  7. 生态对比:两边都熟的老师傅
  8. AI 应用场景
  9. Python 演示
  10. 常见误区
  11. 面试题

可视化演示

动态展示ROCm平台架构、HIP跨平台迁移、算子生态与CUDA性能对标四个视角,直观理解AMD GPU计算生态核心机制。

本节配有交互动效(进入视口后自动加载,约 3KB)。

平台定位:一张开源厨房的入场券

回到共享厨房的故事。过去,只有 NVIDIA 开的那家“CUDA 厨房”对外开放厨艺培训,你交了学费、学了它的规矩,才能用它家的灶台。AMD 的“ROCm 厨房”则高举“开放”的旗帜——不收学费、菜谱公开,甚至欢迎你把菜谱带到别家厨房。ROCm 的全称是 Radeon Open Compute,正是“AMD 开放计算平台”的意思。它要做的,就是给 AI 开发者提供一张不设门槛的入场券,让大家在 GPU 计算这场盛宴中能有更多选择。

从技术视角看,ROCm 是一整套面向 AMD GPU(尤其是 Instinct 系列数据中心加速卡)的开源软件栈。它不仅有编译器、运行时、数学库,还有对 PyTorch、TensorFlow 等主流框架的适配。你可以把它理解为共享厨房的“基础设施包”:燃气、水管、电力全装好,你只需带菜谱进来。它的HIP(Heterogeneous-Computing Interface for Portability)编程模型尤其贴心——接口风格几乎与 CUDA 一一对应,让习惯了 CUDA 的开发者也几乎零成本上手。

如果把“厨房的灶台能力”量化,AMD 的 MI 系列 GPU 浮点算力符合下面的概念公式:

共享厨房的入场券已经拿到,接下来我们要仔细逛逛这个厨房的布局——看看里面到底有哪些“硬件设备和基础设施”在等着你。

FLOPS=Compute Units×64×f×2\text{FLOPS} = \text{Compute Units} \times 64 \times f \times 2
这个公式告诉你:GPU 每秒能做多少次浮点运算,取决于它的并行单元数(CU)、每个单元同时处理的线程数(64)、加速频率(f),以及乘加指令本身包含了两次浮点操作。这是评价任何 GPU“火力”的通用度量衡。
  1. Compute Units(CU)AMD GPU 的最小并行调度单元,相当于厨房里的一个灶台,负责派活给一组线程。CU 越多,灶台越多,能同时炒的菜越多。
    Compute Units\text{Compute Units}
  2. 乘以 64每个 CU 内部有 64 个流处理器(Stream Processors),相当于每口灶台上有 64 个锅位,可以同时处理 64 个数据元素。
    ×64\times 64
  3. 乘以加速频率 ff 是 GPU 的加速时钟频率,单位 GHz,代表每秒钟每个流处理器翻转运算多少次,相当于翻勺的速度。
    ×f\times f
  4. 乘以 2一次乘加运算(Fused Multiply-Add,FMA)会先乘后加,计作两次浮点运算,就像一次翻勺同时完成“颠”和“压”两个动作。
    ×2\times 2

核心架构:厨房里的三大基础设施

走进 ROCm 共享厨房,就像参观一个现代化中央厨房:一眼望去,整齐的灶台(GPU 硬件)、统一的水电管路(运行时)、以及冷藏室里分装好的半成品食材包(算子库)各就其位。第一样关键设施是HIP 编程模型——这是你写菜谱用的语言规范。HIP 提供了类似 CUDA 的 API 风格,让你写的代码既能编译到 AMD 平台,也能通过 nvcc 编译到 NVIDIA 平台。它就像一本“中英对照菜谱”,你写一遍,厨房负责翻译成两家都能执行的版本。

第二样是 ROCm 运行时(ROCm Runtime)——水电燃气管路本身。它管理 GPU 设备的初始化、内存的分配与释放、内核执行时的调度。你调用 hipMalloc 分配显存、hipMemcpy 在 CPU 与 GPU 间搬运数据、hipLaunchKernel 启动计算内核,这些都是运行时在背后替你张罗。第三样是 MIOpen 算子库——冷藏室里的半成品食材包。深度学习里最常用的卷积、池化、批归一化等操作,MIOpen 已经用最优算法替你预实现好了,你直接“拆包下锅”即可,不必从切菜(手写算子)开始。

GPU 与 CPU 之间的数据搬运速度,往往决定了一道“菜”能不能及时上桌。数据从内存搬到显存所花的时间,可以写成:

基础设施看完了,你大概已经“摩拳擦掌”想上手了。但共享厨房有个规矩:进门前必须先换好厨师服、检查设备——这就是我们下一节要聊的安装配置流程。

t=DBPCIet = \frac{D}{B_{\text{PCIe}}}
这个公式非常实用:D 是你要搬运的数据量(GB),B 是 PCIe 总线的实际带宽(GB/s)。数据的搬运时间等于数据量除以带宽——就像搬家用的货车,一次拉多少货、车速多快,决定了整个搬家过程要多久。
  1. 分子 D(数据量)每次训练迭代要传给 GPU 的批次数据大小,数据量越大,搬运时间越长,相当于搬家时货越多,时间越久。
    DD
  2. 分母 B(PCIe 带宽)CPU 与 GPU 之间数据通道的吞吐能力,带宽越大,同样的货搬得越快,相当于货车的装载量和车速。
    BPCIeB_{\text{PCIe}}
  3. 相除得时间搬运时长由数据量与带宽共同决定。这也是为什么 ROCm 会推荐在高性能场景中使用带宽更高的 PCIe 4.0/5.0 通道。
    DBPCIe\frac{D}{B_{\text{PCIe}}}

安装配置:开火前的准备清单

共享厨房开业前,物业会贴出一份“进店须知”:你需要什么样的楼层高度、什么型号的燃气接口、如何验证灶台能正常点火。ROCm 安装配置阶段,就相当于这份准备清单。首先说的是系统要求:ROCm 对软件版本有一定要求,通常需要较新的 Linux 内核(如 Ubuntu 22.04+)、特定版本的 GCC 编译器,以及足够的内存和磁盘空间。这不光是 AMD 苛刻,而是 GPU 生态的普遍规律——厨房的设备设施必须匹配。

第二步是驱动部署。你需要安装 AMD GPU 的专有驱动 amdgpu-dkms,然后安装 ROCm 核心软件栈到 /opt/rocm 目录。整个安装过程可以通过 amdgpu-install 脚本一条龙完成,官方也提供 Docker 镜像,帮你免去繁琐的环境配置。这一步相当于物业派人接通燃气管道,把基础设施接入你家。

最后一步是环境验证。装完不是直接跑 AI 模型,而是要先确认环境一切正常。常用的验证命令包括 rocm-smi(查看 GPU 状态)、rocminfo(查看 ROCm 是否识别硬件)、以及 hipconfig(查看 HIP 工具链配置)。如果这些命令都能成功输出,就说明你的“炉灶”已经可以点火了。

驱动和 ROCm 栈的兼容关系可以浓缩成一个匹配表达式:

厨房准备好了,万事俱备只欠“照单做菜”——接下来看看主流 AI 框架怎样直接在这套房子里开火。

ROCm 可用=(驱动版本≥最低要求)∧(内核版本≥最低要求)\text{ROCm 可用} = (\text{驱动版本} \geq \text{最低要求}) \wedge (\text{内核版本} \geq \text{最低要求})
"∧“在逻辑学里表示”并且"。整句话是说:只有驱动和内核两个条件同时满足,ROCm 才能正常工作。任何一个条件不达标,就像燃气管道接好了但气压不够,灶台就是点不着火。
  1. 驱动版本门槛AMD 驱动(amdgpu-dkms)必须达到 ROCm 官方文件要求的最低版本,否则运行时无法和硬件正常通信。
    驱动版本≥最低要求\text{驱动版本} \geq \text{最低要求}
  2. 内核版本门槛Linux 内核必须包含对 AMD GPU 的支持模块,版本过低时驱动可能无法装载。
    内核版本≥最低要求\text{内核版本} \geq \text{最低要求}
  3. 逻辑与运算两个门槛必须同时满足,用 ∧ 连接。你可以把它理解成“必须两个都打钩”才能进厨房。
    ∧\wedge

框架适配:照着菜单做菜

你想做一道鼎鼎大名的“毛血旺”——训练一个图像分类模型。如果要从算子开始手写,相当于从买菜、切菜、腌肉全部自己来,既费时又容易翻车。ROCm 的聪明之处在于:它直接帮你把 PyTorch、TensorFlow 这些“餐厅标准菜单”附赠在厨房里。PyTorch 的 ROCm 版本可以在官方渠道直接下载安装,安装完成后,你原有的训练代码几乎不用改动——只需把设备指定为 "cuda"(ROCm 版 PyTorch 自动将 CUDA API 翻译成 HIP 调用)或直接使用 "hip" 设备即可。

为什么能做到这一点?因为 ROCm 团队维护了一层与 CUDA 语义几乎一致的运行时接口,PyTorch 底层只需要很小的适配层——几行 #ifdef __HIP_PLATFORM_AMD__ 的条件编译——就能同时支持两家 GPU。这就像同一份菜单保留了英文版和中文版,后厨根据厨房所属国家自动切换语言。主流框架的适配还包括 TensorFlow(通过官方 ROCm 构建)、ONNX Runtime、JAX 等。

框架适配的终极目标是“换卡不换代码”。用加速比来衡量这种适配效果:

菜单已经集成完毕,菜品的风味如何,最终取决于火候和灶具——下一节我们聊 ROCm 在 AMD GPU 上的真实性能表现。

加速比=TCPU 训练TROCm GPU 训练\text{加速比} = \frac{T_{\text{CPU 训练}}}{T_{\text{ROCm GPU 训练}}}
加速比是 CPU 训练一个 epoch 的时间,除以 ROCm GPU 训练同一个 epoch 的时间。它回答了一个朴素的问题:用上 ROCm GPU 后,我的训练到底比用 CPU 快了多少倍?这也是最直观反映“菜单适配好不好”的指标。
  1. 分子 T_CPU同一模型在 CPU 上跑完一个训练轮次(epoch)的耗时,作为基线参照。
    TCPU 训练T_{\text{CPU 训练}}
  2. 分母 T_ROCm同样的模型在 ROCm GPU 上跑完一个 epoch 的耗时。如果 GPU 更快,分母更小,比值就更大。
    TROCm GPU 训练T_{\text{ROCm GPU 训练}}
  3. 比值解释加速比 S > 1 说明 GPU 有加速作用;S 越大,说明框架在 ROCm 上的适配越好,性能释放越充分。
    S=TCPUTROCmS = \frac{T_{\text{CPU}}}{T_{\text{ROCm}}}

性能特征:火候与出菜速度

一口好锅,火候均匀才能炒出好菜。AMD 的 Instinct 系列 GPU 为 ROCm 提供了“顶级火力”,而 ROCm 的性能特征可以从三个维度观察:算力表现、显存带宽与功耗效率。先说算力:AMD MI300X 的 FP16 算力在 TFLOPS 级别,能轻松支撑大模型的矩阵运算;在与 NVIDIA H100 的同级别对比中,部分场景的互有胜负,尤其在记忆体容量上,MI300X 的 192GB HBM3 显存甚至超过了 H100 的 80GB——相当于你的共享厨房不但火大,冰箱也更大,能囤下更大的整鸡。

显存带宽是 AI 训练的另一个油门。大模型训练对显存带宽极其饥渴,每次参数更新都要读写海量数据。HBM3 显存提供了高达数 TB/s 的带宽,远超传统的 GDDR 显存,这让 AMD GPU 在吞吐型任务中尤其亮眼。功耗效率则反映了“每种地能产出多少菜”——同样是每瓦特功耗,能浇灌出多少计算成果。数据中心部署 GPU 时,功耗直接决定电力成本和散热压力。

把这些维度合并起来看的综合指标是能效:

火候掌握得再好,厨师还得面对一个现实问题:如果只会烹饪一种菜系(只会写 CUDA),将来换一家厨房(换用 AMD GPU)怎么办?这就是下一节的生态对比要解决的核心痛点。

能效 (GFLOPS/W)=GFLOPS功耗 (W)\text{能效 (GFLOPS/W)} = \frac{\text{GFLOPS}}{\text{功耗 (W)}}
很简单:每瓦特功耗能带来多少亿次浮点运算。能效越高,说明这份“电费账单”换来的算力越多。它决定了同样的电价下,你能炒出几道菜来。
  1. 分子 GFLOPSGPU 实际测得的浮点运算速度,单位是每秒十亿次浮点运算。数值越高代表计算火力越猛。
    GFLOPS\text{GFLOPS}
  2. 分母功耗 WGPU 满负荷运行时的平均功耗,单位瓦特。功耗越大,电费和散热成本越高。
    功耗 (W)\text{功耗 (W)}
  3. 除法得能效两者相除得到每瓦特算力。在算力相近的两张卡中,功耗更低的那一张能效更优,长期运营成本也更低。
    GFLOPS功耗 (W)\frac{\text{GFLOPS}}{\text{功耗 (W)}}

生态对比:两边都熟的老师傅

一位老师傅如果既精通川菜又拿手粤菜,他在两家餐厅都能站稳脚跟。ROCm 生态对比的终极命题,就是让 AI 开发者从“只会 CUDA 的川菜厨师”成长为“两边都熟的老师傅”。HIP vs CUDA 的核心差异在于:CUDA 是 NVIDIA 的专属语言,只能在自家 GPU 上运行;而 HIP 是一套跨平台的 C++ 方言,它的代码可以同时编译到 AMD 和 NVIDIA 平台。HIP 的 API 刻意模仿 CUDA,像是同一个语法体系的不同方言——学会了普通话,再去学粤语,会发现大量词汇和句型是相通的。

从迁移成本来看,社区和官方长期统计的结果是:大多数 CUDA 源码迁移到 HIP 时,只需要改动约 5%~10% 的代码——主要是一些内核启动语法、内存管理函数名(cudaMalloc → hipMalloc),以及少数 CUDA 专属库需要替换成 ROCm 等价库。社区发展方面,ROCm 在开源许可证(MIT)下完全开放源代码,GitHub 上的贡献者数量逐年上升,AMD 也发布了 PyTorch 和 TensorFlow 的每日构建版。虽然现阶段相比 CUDA 二十余年积累的社区规模仍有差距,但增长势头已经不可忽视。

衡量代码迁移成本的最直观指标是代码复用率:

代码复用率=HIP 可直接编译的代码行数原 CUDA 总代码行数×100%\text{代码复用率} = \frac{\text{HIP 可直接编译的代码行数}}{\text{原 CUDA 总代码行数}} \times 100\%
复用率越高,说明你辛苦积累的“老菜谱”在换厨房后还能直接使用,迁移成本越低。这直接决定了团队从 CUDA 切换或扩展到 ROCm 时的经济账。
  1. 分子(HIP 可直接编译行数)原 CUDA 代码中无需改动或仅需批量替换即可被 HIP 编译器接受的行数。
    HIP 可直接编译的代码行数\text{HIP 可直接编译的代码行数}
  2. 分母(CUDA 总行数)原有 CUDA 项目的全部代码量,作为迁移前的基础比例尺。
    原 CUDA 总代码行数\text{原 CUDA 总代码行数}
  3. 乘以 100%将比例换算成百分数,便于直观理解。一般而言,复用率在 90% 以上就属于非常健康的迁移场景。
    ×100%\times 100\%

AI 应用场景

大模型推理与微调的数据中心部署

阶段:模型训练与部署的底层算力支撑

解决的问题:传统做法是数据中心清一色部署 NVIDIA GPU,导致采购成本高、供应链单一风险大。引入 ROCm 后,AMD Instinct 系列 GPU 可以在 PyTorch 等框架下无缝接管推理或微调任务,大幅降低单卡成本。对于 LLaMA 这类大模型,MI300X 的大显存优势还能让你在单卡上装入更大的模型,减少张量并行带来的通信开销。

具体案例:一家 AI 公司计划部署 700B 参数大模型的推理服务。原先采购 H100 集群需要大量预算,评估后选用 AMD MI300X + ROCm 方案。运维团队用 Docker 启动 ROCm 版 PyTorch 容器,加载模型权重后通过 device="cuda" 映射到 HIP 后端,推理吞吐量与 H100 在误差范围内相当,但总体成本下降了约 30%。

科学计算与 HPC 集群的 GPU 加速

阶段:高性能计算(HPC)软件栈的移植与优化

解决的问题:气象模拟、分子动力学、流体力学等科学计算程序大多基于 MPI + CUDA 编写,过去无法运行在 AMD 集群上。利用 HIP 的代码平移能力,科学计算团队可以以较低成本将 CUDA 内核迁移为 HIP,从而解锁 AMD 超算中心(如 Frontier 等)的海量算力。

具体案例:某超算中心的流体力学模拟程序原本只支持 CUDA。团队主要使用 hipify 工具将内核函数中的 cudaMalloc 等 API 替换为 hipMalloc,再通过 hipcc 编译器重新编译,整个迁移仅耗时两周,代码复用率约 95%。移植后的版本在 AMD GPU 上运行速度与原生 CUDA 版本持平。

跨厂商 AI 软件交付

阶段:算法产品在多种硬件上的交付适配

解决的问题:向不同客户交付 AI 产品时,客户硬件环境不一——有的用 NVIDIA,有的用 AMD。过去需要维护两套代码仓库,工作量大且容易分叉。使用 HIP 作为统一编程模型后,一套核心代码库可同时产出两种平台的二进制包,自动化测试矩阵也只需维护一条主线。

具体案例:一家 AI 视觉公司为客户提供人脸识别 SDK。端侧服务器有 NVIDIA T4 和 AMD MI210 两种配置,团队把所有 CUDA 内核迁移为 HIP 后,在 CI 流水线分别用 hipcc 和 nvcc(通过 HIP 提供的 NVCC 兼容路径)编译两套动态库,发版周期从两周缩短到三天。

Python 演示

python42 行
"""ROCm 环境检测与 PyTorch 矩阵乘示例""" import osimport platform  def main():    print("=== AMD ROCm 环境检测 ===")    print("操作系统:", platform.system(), platform.release())     rocm_installed = os.path.exists("/opt/rocm")    if not rocm_installed:        print("ROCm 未安装,请到 https://rocm.docs.amd.com 获取安装指引")        return     ver_file = "/opt/rocm/.info/version"    if os.path.exists(ver_file):        with open(ver_file, "r") as f:            print("ROCm 版本:", f.read().strip())    else:        print("ROCm 目录已存在,但未找到版本信息文件")     try:        import torch        hip_git = getattr(torch.version, "hip", None)        if hip_git is None:            print("当前 PyTorch 非 ROCm 版本,请安装 ROCm 版 PyTorch")            return        print("PyTorch 版本:", torch.__version__)        print("ROCm 版 PyTorch 构建号:", hip_git)        a = torch.randn(1024, 1024, device="hip")        b = torch.randn(1024, 1024, device="hip")        c = a @ b        print("矩阵乘完成,结果形状:", tuple(c.shape))        print("设备名称:", torch.hip.get_device_name(0))    except ImportError:        print("未安装 PyTorch,请运行: pip install torch --index-url "              "https://download.pytorch.org/whl/rocm5.6")  if __name__ == "__main__":    main()
目的:这是一个可运行的 ROCm 环境自检脚本,先检查 /opt/rocm 目录确认 ROCm 是否安装,再检测 PyTorch 是否为 ROCm 构建版,最后在 HIP 设备上执行一次真实的矩阵乘法,验证 GPU 是否工作。
  1. os.path.exists("/opt/rocm")检查 ROCm 是否安装在默认目录,这是判断软件栈是否存在的第一依据。
  2. torch.version.hip通过读取 PyTorch 编译时的 HIP 版本属性,判断当前安装的是否是 ROCm 专用版。
  3. device="hip"指定张量存储在 AMD GPU 显存上,这是 ROCm 版 PyTorch 的设备名。
  4. a @ b执行 1024×1024 的矩阵乘法,在 GPU 上并行计算,验证 HIP 后端已能正常跑通。
  5. torch.hip.get_device_name(0)查询索引为 0 的 GPU 设备名称,用来确认你的 AMD 显卡被正确识别。
  6. if __name__ == "__main__"标准入口写法,保证脚本被导入时不执行,仅直接运行时才工作。

常见误区

误区我听说 ROCm 就是 AMD 复刻了 CUDA,那我把 .cu 文件直接拿到 ROCm 上编译就能跑,反正都一样。

正解ROCm 是开源 GPU 计算平台,它提供的 HIP 编程模型在 API 风格上刻意贴近 CUDA,但底层实现完全不同。CUDA 源码需要先通过 hipify 工具做一次翻译(例如把 cudaMalloc 改成 hipMalloc),再使用 hipcc 编译器编译。虽然迁移成本低(改动约 5%-10%),但绝不是“原样直接跑”。

为何常见:AMD 为了降低迁移门槛,故意把 HIP API 做得和 CUDA 很像,很多人看到代码几乎形同拷贝,就误以为两者是同一套东西。

误区我把显卡驱动装好了,然后 pip install torch,怎么还提示找不到 HIP 设备?ROCm 不应该自动生效吗?

正解GPU 驱动只是最底层的基础,ROCm 还需要安装完整的软件栈(runtime、库、编译器),并确保 Linux 内核、驱动版本、ROCm 版本三者匹配。此外,安装 ROCm 版 PyTorch 需要额外指定 --index-url 指向 ROCm 的 wheel 仓库,而不是默认的 PyPI 源。

为何常见:PC 用户习惯了“装驱动就能用”的直觉,忽略 GPU 计算平台的软件栈是分层的,每一层都要单独部署。

误区HIP 是 AMD 出的东西,那我写了 HIP 代码,到了 NVIDIA 显卡上肯定跑不了,HIP 没意义。

正解HIP 全称中的 “P“ 就是 Portability(可移植性)。一套 HIP 代码可以通过两个编译器分别生成原生二进制:hipcc 编译出 AMD GPU 版本,而通过 NVIDIA 平台的 HIP 支持(nvcc 背后对接 HIP)可以编译出 NVIDIA GPU 版本。因此 HIP 代码天然具备双平台编译能力,这正是它作为”中英文对照菜谱”的核心价值。

为何常见:人们容易把“某公司推出的技术”和“某公司专属的技术”划等号,忽略了 HIP 设计之初的跨平台目标。

误区我买了一张 AMD 的游戏显卡(比如 RX 7900XTX),是不是就能跑 ROCm,训练大模型了?

正解ROCm 的官方支持矩阵主要覆盖 Instinct 数据中心卡和部分 Radeon PRO 专业卡。消费级 Radeon 显卡虽然在社区中通过 RDNA 支持补丁能部分运行,但官方不保证性能与稳定性。训练大模型前,务必查阅 ROCm 官方的 Supported Hardware 列表,确认显卡型号在列。

为何常见:人们习惯于用 PC 游戏的思维理解 GPU 计算,以为“显卡够好就能跑 AI”,但数据中心场景对显存容量、ECC、驱动稳定性都有更严苛的要求。

误区网上说 ROCm 环境配置很麻烦,PyTorch 跑起来一堆问题,所以 ROCm 根本不能用于生产,只能玩玩。

正解目前 ROCm 版 PyTorch 由 AMD 官方维护并提供每日构建版本,TensorFlow、ONNX Runtime、JAX 也都有官方构建。实践中的确存在少数算子未适配的情况,但主流 CV、NLP 模型的训练与推理都已验证通过。AMD 的超算 Frontier 常年位居 TOP500 前列,其上运行的正是 ROCm 生态。

为何常见:早期 ROCm 版本确实适配粗糙,旧印象在网络传播中被放大,而忽略了近两年它已进入快速成熟期。

面试题

Q1. AMD ROCm 的核心定位是什么?

单选题 · easy

  • A.专有闭源的 GPU 计算库
  • B.开源异构 GPU 计算平台← 正确答案
  • C.仅用于游戏画面的渲染
  • D.一种 Linux 的发行版本

答案:B。ROCm(Radeon Open Compute)是 AMD 推出的开源 GPU 计算平台,对标 NVIDIA CUDA。它不是渲染 API,也不是操作系统,而是覆盖编程模型、运行时与算子库的完整计算生态,故选 B。

Q2. HIP 编程模型的核心设计目标是什么?

单选题 · mid

  • A.只支持 AMD 自家硬件
  • B.让代码只能用于游戏开发
  • C.通过统一接口实现跨平台计算← 正确答案
  • D.用 Python 替代 C++ 做底层开发

答案:C。HIP 的 P 表示 Portability,其在 API 设计上贴近 CUDA,同一套 C++ 代码可通过 hipcc 编译到 AMD GPU、通过 nvcc 相关路径编译到 NVIDIA GPU,实现跨平台。它不是游戏工具,也不改变底层语言,故选 C。

Q3. 安装完 ROCm 软件栈后,以下哪个命令可以查看 GPU 工作状态?

单选题 · easy

  • A.rocm-smi← 正确答案
  • B.hipcc --version
  • C.echo $PATH
  • D.torch.version.cuda

答案:A。rocm-smi 是 ROCm 的 GPU 系统管理接口,类似 NVIDIA 的 nvidia-smi,可查看温度、功耗与利用率。hipcc --version 只显示编译器版本;echo $PATH 查看环境变量;torch.version.cuda 是 Python 对象的属性,都不是系统级状态查看命令。

Q4. MIOpen 在 ROCm 生态中通常扮演什么角色?

单选题 · mid

  • A.操作系统的内核模块
  • B.深度学习算子加速库← 正确答案
  • C.AMD 显卡的硬件驱动
  • D.Python 的包管理工具

答案:B。MIOpen(AMD's Machine Intelligence Library)是 ROCm 内置的深度学习算子库,对卷积、池化、归一化等操作做了高度优化,类似 NVIDIA 的 cuDNN。它不是内核、驱动也不是包管理器,故选 B。

Q5. 下列说法中,关于 ROCm 安装与迁移正确的有哪些?

多选题 · mid

  • A.CUDA 代码可直接在 ROCm 运行无需修改
  • B.官方主要支持 Instinct 数据中心卡← 正确答案
  • C.HIP 代码可跨 AMD 与 NVIDIA 平台编译← 正确答案
  • D.安装 ROCm 无需安装任何 AMD 驱动

答案:BC。HIP 与 CUDA API 相近但仍有少量差异,CUDA 代码需 hipify 翻译后才编译,A 错;ROCm 官方支持矩阵以 Instinct 数据中心 GPU 和专业卡为主,B 对;HIP 的设计目标就是跨平台编译,C 对;ROCm 必须先装 amdgpu 驱动,D 错。故选 B、C。

Q6. 如果一个 CUDA 项目的代码复用率为 95%,这意味着什么?

单选题 · hard

  • A.只有 5% 的算子需要重写
  • B.95% 的代码可直接被 HIP 编译← 正确答案
  • C.代码运行速度提升了 95%
  • D.CUDA 生态覆盖率达 95%

答案:B。代码复用率指原 CUDA 代码中无需改动或仅批量替换即可被 HIP 编译的行数占比。95% 复用率表示绝大多数代码可平移,不涉及性能提速比例,也不代表生态覆盖率,故选 B。

Q7. 在 ROCm 版 PyTorch 中,将张量放置在 AMD GPU 上应使用哪个设备名?

单选题 · easy

  • A.device="npu"
  • B.device="hip"← 正确答案
  • C.device="mps"
  • D.device="gpu"

答案:B。ROCm 版 PyTorch 通过 torch.hip 接口访问 AMD GPU,张量设备名使用 “hip“;ROCm 实现兼容层也允许部分场景下使用 ”cuda“ 作为别名,但首选写法是 ”hip”。npu 是昇腾,mps 是 Apple 平台,gpu 不是合法设备名。

Q8. 关于 AMD MI300X 与 ROCm 的性能特征,说法正确的有哪些?

多选题 · hard

  • A.HBM3 显存带宽可达 TB/s 级别← 正确答案
  • B.大显存有利于单卡部署大模型← 正确答案
  • C.ROCm 的能效与算法优化无关
  • D.FP16 算力通常高于 FP64 算力← 正确答案

答案:ABD。HBM3 带宽达数 TB/s,A 对;MI300X 192GB 显存支持大模型单卡部署,B 对;能效受内核实现、算子库选择等优化因素强烈影响,C 错;消费与数据中心芯片的 FP16 算力普遍数倍于 FP64,D 对。故选 A、B、D。

Q9. HIP 与 CUDA 在 API 上的关系最接近以下哪种描述?

单选题 · mid

  • A.完全相同的源码实现
  • B.风格相近的方言式接口← 正确答案
  • C.毫无关联的两套语言
  • D.CUDA 是 HIP 的子集

答案:B。HIP 刻意模仿 CUDA 的接口风格,降低迁移成本,但两者的底层实现不同、编译器不同,并非字面完全相同。HIP 独立于 CUDA,也不是 CUDA 的扩展子集。因此最贴切的比喻是“风格相近的方言”。

Q10. 下面关于 ROCm 社区与生态现状描述正确的有哪些?

多选题 · mid

  • A.开源代码托管在 GitHub 上← 正确答案
  • B.PyTorch 提供 ROCm 每日构建版← 正确答案
  • C.完全无法运行 TensorFlow
  • D.超算 Frontier 使用了该生态← 正确答案

答案:ABD。ROCm 以 MIT 开源协议托管于 GitHub,A 对;AMD 官方维护 ROCm 版 PyTorch 每日构建包,B 对;TensorFlow 有官方 ROCm 构建,C 错;基于 ROCm 的 Frontier 长期位居超算前列,D 对。故选 A、B、D。