想象一位老师要给全班 40 个学生讲同一道错题。如果一对一辅导，同样的话要重复 40 遍，嗓子冒烟才讲得完。聪明的做法是让全班安静，喊一声“这道题都看黑板！”——所有学生同时接收到同一句讲解。这就是单指令多数据（SIMD）的原型。CPU 里的并行算力远比我们平常用到得多，但单线程代码每次只搬一个数据，相当于老师一直坚持一对一。SIMD intrinsics 就是给这位“老师”直接发号施令的接口：用一条向量指令，同时喂给 CPU 多个数据，一次算完一整组。SSE、AVX、AVX-512 这些名字，本质上是“教室”的不断扩编：从 4 人小班到 8 人中班再到 16 人大班。当然，把学生安排进教室并不容易——数据要排好队（内存布局）、座位要对齐（内存对齐）、还不能有捣乱的分支。本文就用这位“全班口令老师”贯穿始终，从概念、指令集、数据类型、编写方法，到内存对齐、布局优化、性能分析和实战策略，一步步带你把 CPU 的并行算力真正榨干。

岗位关联

模型推理、图像预处理、向量检索的底层加速都离不开 SIMD intrinsics——掌握它，你才能在 CPU 上把延迟压到极限，成为真正懂硬件的算法工程师。

目录
  1. 可视化演示
  2. SIMD 核心概念
  3. 指令集家族
  4. 数据类型与寄存器
  5. intrinsics 编写方法
  6. 内存对齐要点
  7. 内存布局优化
  8. 并行性能分析
  9. 实战优化策略
  10. AI 应用场景
  11. Python 演示
  12. 常见误区
  13. 面试题

可视化演示

动态展示插值查找根据目标值在有序数组中的分布位置估算探测点的查找过程，直观呈现自适应查找策略的高效性。

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

插值查找 - 初始状态 根据值分布估算探测位置 命中目标值则查找完成 pos=lo+(k-a[lo])(hi-lo)/(a[hi]-a[lo]) 自适应查找

SIMD 核心概念

老师批改作业时发现，全班 40 个学生错在同一道题上。如果一对一讲解，每讲一遍都要从头开始，讲 40 遍嗓子就哑了。可如果老师站上讲台喊一声“这道题都看黑板”，所有学生同时接收同一个信息，一遍就完成。这个过程完美对应 CPU 里的两种执行模式：标量（Scalar）与向量（SIMD）。

标量代码里，CPU 每执行一条指令只完成一次运算，然后去取下一个数据，好比老师逐个点名辅导。而 SIMD（Single Instruction Multiple Data，单指令多数据）把多个数据打包进一个宽寄存器，一条指令同时作用于所有通道——老师一声令下，全班齐动。这种“同时处理多个数据”的能力叫数据级并行，它不需要多核，单核内部就能完成。

衡量 SIMD 收益的核心指标是加速比（Speedup）：用标量执行时间除以向量执行时间。这个比值越接近教室的座位数（通道数），说明并行效率越高。

加速比 4 意味着原来要讲 4 遍的内容，现在讲 1 遍全班都会了。不过，教室能坐多少人、大家有没有坐对座位，才是加速比能否兑现的关键——接下来的章节，就是安排这些细节。

S=TscalarTvectorS = \frac{T_{\text{scalar}}}{T_{\text{vector}}}
加速比 = 标量耗时 ÷ 向量耗时，理想情况下等于同时处理的通道数。
  1. 分子 T_scalar标量执行总耗时，即老师一个个单独辅导每个学生，把所有数据跑完花掉的时间
    Tscalar=数据条数×每条数据耗时T_{\text{scalar}} = \text{数据条数} \times \text{每条数据耗时}
  2. 分母 T_vector向量执行总耗时，即老师分组喊口令，每组一次搞定所有学生
    Tvector=数据条数nlanes×每组耗时T_{\text{vector}} = \frac{\text{数据条数}}{n_{\text{lanes}}} \times \text{每组耗时}
  3. 商 S 加速比两者相除得到性能提升倍数，理想状态等于每组座位数
    S=TscalarTvector≈nlanesS = \frac{T_{\text{scalar}}}{T_{\text{vector}}} \approx n_{\text{lanes}}

指令集家族

教室会不断扩建。1999 年 Intel 推出 SSE（Streaming SIMD Extensions），带来 128 位的“4 人小教室”；2011 年的 Sandy Bridge 架构带来 AVX（Advanced Vector Extensions），扩充到 256 位的“8 人教室”；再往后 AVX-512 把容量推到 512 位，能同时坐 16 个 32 位 float 学生。每次扩建，老师一句口令能覆盖的学生就翻倍。

但教室太大也有代价。AVX-512 全宽度运算时功耗飙升，CPU 为了不“烧坏”会主动降低主频——大教室虽然座位多，老师却必须放低音量。这就是为什么在部分 CPU 上，AVX-512 的实测性能反而不如 AVX2。同时，不同代际的 CPU 支持的指令集不一样：老 CPU 听不懂新口令。跨平台发布时，要用 __builtin_cpu_supports 或 Rust 的 is_x86_feature_detected! 做运行时检测，为不同的“教室规模”准备多套代码路径。

指令集升级最直观的价值，体现在单条指令能处理的数据量上。AVX 位宽是 SSE 的两倍，理论上一条 AVX 指令抵两条 SSE。

选教室要看实际生源：如果只是处理 4 个 float，AVX 的 8 人教室并不会比 SSE 快。指令集升级是工具箱变大了，但用哪个工具，还得看数据量有多大。

R=WnewWold=256128=2R = \frac{W_{\text{new}}}{W_{\text{old}}} = \frac{256}{128} = 2
位宽比即吞吐提升比：AVX 相对 SSE 的寄存器位宽翻倍，可处理的元素数量也翻倍。
  1. 分子 W_new新一代指令集的寄存器位宽，AVX 把教室扩到了 256 位
    Wnew=256 bitW_{\text{new}} = 256 \, \text{bit}
  2. 分母 W_old旧一代指令集的寄存器位宽，SSE 时代是 128 位
    Wold=128 bitW_{\text{old}} = 128 \, \text{bit}
  3. 商 R 扩展倍数位宽之比就是单条指令处理能力的提升倍数
    R=WnewWold=2R = \frac{W_{\text{new}}}{W_{\text{old}}} = 2

数据类型与寄存器

教室里每个座位都有编号，老师喊“第三排回答问题”才能精准定位。向量寄存器里的通道（lane）就是座位编号：一个 256 位寄存器被等分成 8 个 32 位座位，每个座位装一个 float，指令按固定位置操作它们。

在 intrinsics 的世界里，数据不是随手放的。C++ 定义了一族向量类型：__m128、__m256 对应打包的单精度浮点，__m256d 是 4 个 double，__m256i 是整数家族。这些类型本质上是告诉编译器“这间教室坐的是哪类学生”，类型名字里的 ps（packed single）和 pd（packed double）就是在区分这些细节。

通道数由寄存器位宽除以元素位宽决定。搞清楚这个除法，你就能一眼判断任意组合能并行多少个数据。

明白了座位怎么排，下一步就是怎么让这些学生“进教室”——这正是 intrinsics 编写方法与加载指令的用武之地。

n=WregWtype=25632=8n = \frac{W_{\text{reg}}}{W_{\text{type}}} = \frac{256}{32} = 8
通道数 = 寄存器位宽 ÷ 元素位宽。256 位装 float（32 位）能装 8 个；装 double（64 位）只能装 4 个。
  1. 分子 W_reg向量寄存器的总位宽，相当于教室容纳座位的总宽度
    Wreg=256 bitW_{\text{reg}} = 256 \, \text{bit}
  2. 分母 W_type单个数据元素的位宽，float 占 32 位、double 占 64 位
    Wtype=32 bitW_{\text{type}} = 32 \, \text{bit}
  3. 商 n 通道数两者相除得到这条“教室”里有几个并排座位，即 lane 的个数
    n=WregWtype=8n = \frac{W_{\text{reg}}}{W_{\text{type}}} = 8

intrinsics 编写方法

老师不需要走到每个座位前亲自教，站在讲台上喊口令就够了。intrinsics 就是给 CPU 用的“口令集”：它看起来是普通函数，内部却一对一映射到一条 CPU 向量指令。函数名就是口令，喊出去，整间教室随之行动。

C++ 里先 #include <immintrin.h>，之后就能写 _mm256_add_ps(a, b) 这类接口；Rust 则通过 std::arch::x86_64 调用同名函数。名字拆开看很有规律：_mm 是历史前缀，256 指 256 位寄存器，add 是操作，ps 是打包单精度。围绕同一套运算有一整个家族：load（加载）、store（存回）、add（加）、mul（乘）、fma（乘加融合）等。编译器看到这些函数名，会直接生成对应的汇编指令，比如 _mm256_add_ps 就变成 vaddps ymm。

要处理 M 个数据，每条向量指令吃掉 n 个，总共需要发多少条指令？这个数字直接决定你能省下多少时间。

口令喊得好，学生也得先坐上座位才能集体行动。下一节进入最容易翻车的地方——内存对齐。

k=⌈Mnlanes⌉=⌈10008⌉=125k = \left\lceil \frac{M}{n_{\text{lanes}}} \right\rceil = \left\lceil \frac{1000}{8} \right\rceil = 125
指令条数 = ⌈数据总量 ÷ 通道数⌉。1000 个 float 用 AVX 处理，只需 125 条向量指令。
  1. 被除数 M待处理的数据总条数，比如数组里有 1000 个浮点数要相加
    M=1000M = 1000
  2. 除数 n_lanes一条向量指令能同时处理几个数据，AVX 下是 8
    nlanes=8n_{\text{lanes}} = 8
  3. ceil 向上取整不满一整组的“散兵”也要单独发一条指令，所以只能往上取整
    k=⌈Mnlanes⌉=125k = \left\lceil \frac{M}{n_{\text{lanes}}} \right\rceil = 125

内存对齐要点

全班齐读的前提是每个人都坐在自己的座位上。如果桌椅被随意打乱，老师喊“翻到第 10 页”，有人就找不到课本。内存对齐就是给数据“固定座位”：向量加载指令要求数据起始地址是向量字节数的整数倍。

SSE 要求 16 字节对齐，AVX 要求 32 字节对齐。满足条件的地址，硬件能一次性把整段数据搬进寄存器；不满足时，load_ps 这类指令会直接崩溃，或者你用 loadu_ps 容忍未对齐，但数据可能横跨两个缓存行甚至两个内存页，付出额外的访问延迟。这就像学生被夹在两张课桌之间，读半个字要伸两次脖子。

分配对齐内存要用专门的工具：C++ 的 aligned_alloc、posix_memalign，或 C++17 的 aligned new；Rust 用 #[repr(align(32))] 控制布局。普通 malloc 通常只保证 16 字节对齐，不够 AVX 用。判断对齐是否满足，只需要一个取模运算。

座位固定好了，但学生是按什么顺序入座的？这就是“内存布局”的学问：按科目分班还是按小组就座，直接决定能不能一排坐满。

addr mod vbytes=0\text{addr} \bmod v_{\text{bytes}} = 0
起始地址必须是向量字节数的整数倍：32 字节对齐意味着地址除以 32 余数为 0。
  1. addr 起始地址数据在内存里的首地址，相当于学生第一个座位的位置
    addr mod vbytes=0\text{addr} \bmod v_{\text{bytes}} = 0
  2. v_bytes 向量字节数AVX 的 256 位对应 32 字节，这是对齐的“座位间距”
    vbytes=32v_{\text{bytes}} = 32
  3. 取模运算 mod余数为 0 说明座位恰好对齐，整排能一次坐满
    addr=32×m,m∈Z\text{addr} = 32 \times m, \quad m \in \mathbb{Z}

内存布局优化

老师想集中训练全班的口算能力。如果大家按混合小组坐（每组几人、各科学什么都有），老师要点名某个组的成员，得在座位间来回找；如果按科目分班——全班都练口算——一次就能让所有人同步训练。数据结构也有同样的两种组织方式。

假设要处理一万个三维坐标点。AoS（Array of Structures，结构体数组）是 Point 数组，每个元素 {x, y, z} 紧挨着存放；SoA（Structure of Arrays，数组结构体）是三个独立数组 xs[]、ys[]、zs[]。要对坐标做统一运算时，SoA 能一次性把连续 8 个 x 装进向量寄存器；AoS 则需要每隔 12 字节才取到一个 x，加载效率天差地别。

从缓存行（通常 64 字节）的视角看得更清楚：AoS 下读 8 个 x，数据散布在约 96 字节范围内，要跨两个缓存行搬运；SoA 下 8 个 x 只占 32 字节，一个缓存行能装 16 个，搬运效率高得多。布局转换本身有成本，所以要在数据初始化时就规划好，而不是每轮计算前临时重排。

数据排好了、教室也选好了，但最终能不能跑出应有的速度，还要算一笔“并行性能”的账——不是所有环节都能靠 SIMD 提速。

U=vusedvloadedU = \frac{v_{\text{used}}}{v_{\text{loaded}}}
满载率 = 真正用上的字节 ÷ 加载进缓存的字节。SoA 满载率高，AoS 满载率低。
  1. 分子 v_used真正被用上的数据字节数，SoA 读 8 个 float 恰好 32 字节
    vused=8×4=32 bytesv_{\text{used}} = 8 \times 4 = 32 \, \text{bytes}
  2. 分母 v_loaded从内存搬到缓存的字节数，一个缓存行默认 64 字节
    vloaded=64 bytesv_{\text{loaded}} = 64 \, \text{bytes}
  3. 商 U 满载率两者之比衡量搬运浪费程度，越接近 1 说明越“物尽其用”
    U=3264=0.5U = \frac{32}{64} = 0.5

并行性能分析

一节课 40 分钟，老师再擅长组织纪律，也得花 5 分钟点名、发卷、布置任务。就算齐读再快，这些“串行环节”一个都省不掉，它们锁死了整节课的下限。程序也一样：总有一部分代码无法向量化，比如数据预处理、结果汇总、分支判断。

阿姆达尔定律（Amdahl's Law）精确描述了这个限制：设 p 是代码中可向量化的比例，n 是 SIMD 通道数，那么整体加速比等于串行部分 1-p 原样保留、并行部分 p 除以 n 后，总耗时的倒数。假设 80% 的代码能被向量化，用 8 通道 AVX，代入公式：S = 1 / (0.2 + 0.8/8) ≈ 3.33 倍——离理想的 8 倍差很远。串行部分的 20%，就是那 5 分钟点名，谁也省不掉。

这也解释了性能优化的第一原则：先剖析定位热点函数，再决定值不值得为它写 intrinsics。另外，SIMD 把计算压下去之后，瓶颈常常转移到内存带宽上——计算快了，但数据搬运来不及，吞吐量依然上不去。识别瓶颈，才能把钱花在刀刃上。

算清了理论天花板，就明白“榨干 CPU”不是堆指令集就行，而是把有限的口令花在刀刃上。最后一节是实战：怎么让循环乖乖向量化。

S=1(1−p)+pnS = \frac{1}{(1-p) + \frac{p}{n}}
加速比 = 1 ÷（串行比例 + 并行比例 ÷ 通道数）。串行部分决定了加速天花板。
  1. p 可并行比例代码中能被向量化的部分占比，0.8 表示八成的活能全班齐做
    p=0.8p = 0.8
  2. 分母两项之和串行部分 (1-p) 原样保留，并行部分 p 被 n 条通道平分
    (1−p)+pn=0.2+0.88=0.3(1-p) + \frac{p}{n} = 0.2 + \frac{0.8}{8} = 0.3
  3. 倒数得到加速比总耗时变成原来的 0.3，所以加速比约 3.33 倍
    S=10.3≈3.33S = \frac{1}{0.3} \approx 3.33

实战优化策略

老师真正上课时，不会只喊一次口令就放学——他会把全班分成若干轮，每轮让一组学生齐读，最后一组人数不够就单独带。循环向量化也是这个套路：分块处理，余量兜底。

假设要处理一万个点，AVX 每次处理 8 个：主循环按 8 步长跑 1250 轮全向量运算，剩下不足 8 个的余数用标量逐个处理。写成代码就是：主循环步长等于通道数，循环外单独处理尾巴。这个“整块 + 余量”模式，是手写 intrinsics 循环的骨架，几乎所有向量化改造都从这里开始。

分支是向量化的天敌——判断语句会让部分通道走一边、部分走另一边，聪明的老师不会在齐读时突然点名提问。碰上不得不判断的场景，用掩码（mask）和混合（blend）指令替代分支。能不开手工写就尽量不开：编译器自动向量化依赖连续访问、无别名、无循环携带依赖，只要代码“长得乖”，开 -O3 -march=native 后很多循环编译器自己就向量化了。最后一定要做基准测试，多做几轮取稳定值，小心 AVX-512 降频等频率波动干扰判断。

从概念到指令集、从类型到编写、从对齐到布局、从理论到实战，SIMD 这条“全班口令”路线图就走通了。下次再看到 SSE/AVX 字样的库，你可以理直气壮地拆开它，看看那间教室里到底坐了几个学生。

M=n×k+rM = n \times k + r
数据总量 = 通道数 × 满批次轮数 + 尾部余量。余数用标量兜底，保证一个元素都不漏。
  1. M 总数据量循环要处理的数据总数，比如一万个坐标点
    M=10000M = 10000
  2. n×k 整块部分每轮处理 n 个，完整跑 k 轮向量运算
    10000=8×1250+010000 = 8 \times 1250 + 0
  3. r 尾部余量剩下不足一组的零头，用标量指令逐个兜底处理
    r=M−n×k,0≤r<nr = M - n \times k, \quad 0 \le r < n

AI 应用场景

CPU 推理引擎的矩阵乘法加速

阶段：模型推理部署（算子优化）

解决的问题：传统 GEMM 用三重循环逐元素计算，CPU 利用率极低——就像老师一个一个单独辅导。用 AVX2 intrinsics 手写微内核，一条指令算 8 个乘加，矩阵乘法吞吐可以提升数倍。

具体案例：某团队在 x86 服务器上部署 7B 参数大模型，attention 里的 QKV 投影全部走手写 AVX2 GEMM，配合内存布局改成 SoA，单层算子延迟从 12ms 降到 4ms 以下，CPU 推理吞吐直接翻倍。

图像预处理的像素级加速

阶段：数据预处理

解决的问题：视频流推理前要逐帧做 resize、颜色空间转换（YUV→RGB）、归一化，全是逐像素的重复运算。标量循环处理 1080p 单帧要十几毫秒，而这些运算无分支、纯数据并行，正是 SIMD 的天然主场。

具体案例：音视频 SDK 用 SSE/AVX 写了一个 8 像素并行的 RGB 归一化 kernel，配合 32 字节对齐的连续帧缓冲，单帧预处理从 15ms 降到 3ms，让实时检测流水线从 30fps 提升到 60fps。

向量数据库的 embedding 相似度计算

阶段：向量检索（ANN 搜索内核）

解决的问题：RAG 应用要拿查询 embedding 和百万级候选 embedding 算内积、余弦相似度，这是最纯粹的数据并行——所有向量做相同的乘加。标量实现下 CPU 成了瓶颈，QPS 上不去。

具体案例：向量数据库团队用 AVX2 重写内积 kernel，把每条 1024 维 embedding 拆成 128 个 8 通道批次计算，配合 32 字节对齐存储，单机 QPS 提升 4 倍，p99 延迟下降一半。

Python 演示

python46 行
import timeimport numpy as np N = 4 * 1024 * 1024     # 总数据量: 约 400 万个 float32LANES = 8               # 模拟 AVX 的 8 个数据通道 def scalar_add(n, x, y, out):    # 标量版本: 一次只处理一个元素, 相当于老师一对一辅导    for i in range(n):        out[i] = x[i] + y[i] def simd_style_add(n, x, y, out, lanes=LANES):    # 模拟 SIMD: 一次处理 lanes 个元素, 相当于老师对全班喊口令    i = 0    while i + lanes <= n:          # 整块部分: 剩余数据够一个"满教室"        for j in range(lanes):     # 一条"向量指令"内部处理 8 个元素            out[i + j] = x[i + j] + y[i + j]        i += lanes    while i < n:                   # 尾部余量: 不足 8 个用标量逐个兜底        out[i] = x[i] + y[i]        i += 1 # 生成测试数据并计算参考答案a = np.random.rand(N).astype(np.float32)b = np.random.rand(N).astype(np.float32)c = np.empty_like(a)ref = a + b simd_style_add(1024, a, b, c)      # 预热: 让缓存和分支预测就位 t0 = time.perf_counter()scalar_add(N, a, b, c)t1 = time.perf_counter()assert np.allclose(c, ref), "scalar 结果错误" simd_style_add(N, a, b, c)t2 = time.perf_counter()assert np.allclose(c, ref), "simd_style 结果错误" np.add(a, b, out=c)                # numpy 底层 C 代码真正调用了 SIMDt3 = time.perf_counter()assert np.allclose(c, ref), "numpy 结果错误" print(f"scalar    : {t1 - t0:.4f} s")print(f"simd_style: {t2 - t1:.4f} s")print(f"numpy SIMD: {t3 - t2:.4f} s")
目的：用纯 Python 模拟 SIMD 的“分块 + 余量”执行模式，并和真正调用 SIMD 指令的 numpy 对比，直观感受数据级并行的威力。
  1. while i + lanes <= n:主循环的进入条件：剩下数据够凑满一条“向量指令”才进场
  2. for j in range(lanes):模拟向量指令内部同时给 8 个通道赋值，对应 _mm256_add_ps
  3. while i < n:尾部余量逐个兜底，对应正文公式里的 r = M - n*k
  4. np.add(a, b, out=c)numpy 底层用 C 编译的循环，真正执行了 CPU 的 SIMD 指令
  5. assert np.allclose(c, ref)三种实现结果必须一致，防止“加速”改坏了语义

常见误区

误区“写普通 for 循环的代码，加上 -O3 编译器就会自动向量化，我不用专门学 intrinsics。”

正解自动向量化的前提很苛刻：循环要连续访问内存、没有循环携带依赖、没有别名冲突、没有复杂分支。编译器非常保守，只要有一处“拿不准”就放弃向量化。好比老师要全班齐读，必须先确认所有人都在同一页——编译器只要发现“有人翻页不一致”就直接放弃。真正稳定提速，还是要手写 intrinsics 或把内存重排成 SoA。

为何常见：简单循环确实能被 -O3 自动向量化，尝到甜头后容易高估编译器能力，忽略了它背后极其苛刻的前提条件。

误区“AVX-512 有 16 个 float 通道，AVX2 只有 8 个，位宽正好翻倍，速度当然翻倍。”

正解AVX-512 全宽度运算的功耗极高，CPU 会主动大幅降频来限制发热。在部分 CPU 上，同一段代码 AVX-512 的实际吞吐反而低于 AVX2。通道数只是理想上限，不是实际收益。真正选型要看目标 CPU、功耗墙和实测数据，而不是纸面位宽。

为何常见：“位宽翻倍 = 吞吐翻倍”是最直观的直觉，但散热和频率这两个隐性约束很容易被忽略。

误区“_mm256_load_ps 就是个加载函数，跟 memcpy 差不多，传什么地址都应该能正常工作。”

正解对齐是 intrinsics 的硬性契约，不是建议。传给 load_ps 的地址如果没满足 32 字节对齐，程序会直接崩溃（或产生错误结果）。内存要用 aligned_alloc 等对齐分配器获取；只有 loadu_ps 才容忍不对齐，但可能跨缓存行或页边界付出额外延迟。

为何常见：intrinsics 外观太像普通函数调用，初学者不知道它的本质是“一对一映射到汇编指令”，而指令对地址有强制要求。

误区“只要我把热点函数换成 intrinsics，性能就上去了，数据结构的排列方式根本不重要。”

正解数据布局有时候比指令选择更关键。AoS 布局下同一字段间隔散布，向量加载时每取一个元素都要跨缓存行搬运，大量带宽被浪费；SoA 布局让同类数据连续，一次加载全是有效值。老师喊齐读的前提是大家翻到同一页——内存布局就是“翻到同一页”的准备工作。

为何常见：学习路径习惯从“指令”入手，容易忽视内存子系统这个真正的最终瓶颈。

面试题

Q1. SIMD 中的字母 S 代表什么？

单选题 · easy

  • A.Single（单条指令）← 正确答案
  • B.Simple（简单指令）
  • C.Super（超级指令）
  • D.Serial（串行指令）

答案：A。SIMD 是 Single Instruction Multiple Data 的缩写，核心是“单条指令”同时驱动多个数据，就像老师对全班喊一句口令。Simple、Super、Serial 都是混淆项，SIMD 强调的是“单条指令”这个数量概念，而不是简单的或串行的。

Q2. 一条 128 位的 SSE 指令能同时处理几个 32 位 float 数据？

单选题 · easy

  • A.2 个 float 数据
  • B.4 个 float 数据← 正确答案
  • C.8 个 float 数据
  • D.16 个 float 数据

答案：B。通道数 = 寄存器位宽 ÷ 元素位宽 = 128 ÷ 32 = 4。SSE 寄存器相当于能坐 4 个学生的“小教室”。8 个是 AVX（256 位）的通道数，16 个是 AVX-512 的通道数，2 个是 double 数据在 SSE 下的情况。

Q3. 下列哪个 intrinsic 执行 AVX 的 8 个 float 加法？

单选题 · mid

  • A._mm_add_ps 指令
  • B._mm256_add_ps 指令← 正确答案
  • C._mm_add_pd 指令
  • D._mm256_add_pd 指令

答案：B。_mm256 前缀表示 256 位 AVX，ps 表示 packed single（打包单精度 float），合起来就是 _mm256_add_ps。_mm_add_ps 是 128 位 SSE 版本，只能处理 4 个 float；pd 后缀是 double，通道数减半。

Q4. 使用 _mm256_load_ps 加载数据时，起始地址必须满足什么条件？

单选题 · mid

  • A.4 字节对齐
  • B.8 字节对齐
  • C.16 字节对齐
  • D.32 字节对齐← 正确答案

答案：D。AVX 的 256 位寄存器对应 32 字节，load_ps 要求地址是 32 的整数倍，即 addr % 32 == 0。16 字节对齐是 SSE 的要求，普通 malloc 通常只保证 16 字节对齐。地址不满足要用 loadu_ps 容忍未对齐加载。

Q5. 某程序 80% 代码可向量化（p=0.8），用 8 通道 SIMD 后理论加速比约为？

单选题 · mid

  • A.1.6 倍加速比
  • B.2.5 倍加速比
  • C.3.3 倍加速比← 正确答案
  • D.8.0 倍加速比

答案：C。阿姆达尔定律 S = 1 / ((1-p) + p/n) = 1 / (0.2 + 0.8/8) = 1 / 0.3 ≈ 3.33。串行的 20% 是天花板，8 倍只是理想加速比。1.6、2.5 是把公式算错了，8.0 忽略了串行部分的拖累。

Q6. 为什么在部分 CPU 上 AVX-512 实际性能反而不如 AVX2？

单选题 · hard

  • A.编译器默认不支持
  • B.触发降频和功耗升高← 正确答案
  • C.寄存器数量反而更少
  • D.数据过宽导致易出错

答案：B。AVX-512 全宽度运算功耗极高，CPU 为了散热会主动大幅降频，吞吐随之下降。编译器只要开启 -mavx512f 就支持；寄存器数量没变少；位宽本身不会增加出错率。这就像 16 人大教室声音太大，老师只好让大家压低音量。

Q7. 处理三维坐标点集时，下列哪种内存布局最适合 SIMD 向量化？

单选题 · mid

  • A.所有 x 坐标连续存放← 正确答案
  • B.每个点 xyz 紧挨存放
  • C.随机打乱顺序存放
  • D.链表式动态分配存储

答案：A。所有 x 连续存放是 SoA（Structure of Arrays）布局，一次向量加载全是同字段数据，满载率高。xyz 紧挨是 AoS，加载 x 要跨多个缓存行；随机打乱破坏了连续性；链表把连续内存拆散，三种都不利于向量化。

Q8. 以下哪些属于 x86 平台的 SIMD 指令集？

多选题 · mid

  • A.SSE 向量指令集← 正确答案
  • B.AVX 向量指令集← 正确答案
  • C.NEON 向量指令集
  • D.AVX-512 向量指令集← 正确答案

答案：ABD。SSE、AVX、AVX-512 都是 Intel/AMD x86 平台上的 SIMD 指令集，对应不断扩编的“教室”。NEON 是 ARM 平台的 SIMD 指令集，跑在手机和嵌入式的 ARM CPU 上，跟 x86 的 intrinsics 不是一回事。

Q9. 编译器自动向量化通常需要满足哪些条件？

多选题 · hard

  • A.使用递归调用实现
  • B.内存访问必须连续← 正确答案
  • C.循环内无数据依赖← 正确答案
  • D.开启 O2 及以上优化← 正确答案

答案：BCD。自动向量化要求循环连续访问内存、迭代之间无数据依赖（否则后一次要等前一次的结果），并开启 O2 及以上的优化让编译器敢做变换。递归调用压根不是循环，无法向量化。编译器像谨慎的老师，条件不全就放弃齐读。

Q10. 手写 intrinsics 加速时，下列哪些做法是正确的？

多选题 · extreme

  • A.用 aligned_alloc 分配对齐内存← 正确答案
  • B.处理尾部余量用标量兜底← 正确答案
  • C.出现分支时继续使用向量化
  • D.用基准测试验证真实收益← 正确答案

答案：ABD。对齐分配让 load_ps 安全使用；尾部余量用标量兜底是“整块 + 余量”模式的标准收尾；基准测试验证收益，防止降频等因素干扰判断。分支会让向量通道分叉，正确做法是用 mask/blend 替代分支，而不是硬着头皮向量化。