ARM NEON 技术详解

发表于 分类于

深入掌握 ARM NEON 技术，解析 SIMD 向量化运算、专用寄存器架构及其高效编程模型。

1. SIMD 的并行化原理

NEON 的价值只有在理解了标量运算的浪费之后才能真正体会——32-bit 寄存器处理 8-bit 数据时，高 24 位只是闲置。本节从 Flynn 分类开始，量化 SIMD 相比标量计算的实际加速效果，并厘清 NEON 与 ARMv6 整数 SIMD 的继承关系。

1.1 Flynn 分类中的 SIMD

手册 §8.1 首先给出了 Flynn 分类的四种架构定义：

类型 全称 含义 ARM 示例
SISD Single Instruction, Single Data 单指令流处理单数据流 ARMv6 之前的处理器
SIMD Single Instruction, Multiple Data 单条指令同时操作多份数据 NEON、x86 SSE、PowerPC AltiVec
MISD Multiple Instruction, Single Data 多指令流处理同一数据（容错计算机） 航天飞机飞行控制计算机
MIMD Multiple Instruction, Multiple Data 多指令流多数据流 多核超标量处理器

SIMD 的思想很简单：现代处理器的 ALU 和数据通路是为 32-bit 设计的，但大量实际数据（像素 8-bit、音频采样 16-bit）远不够 32 位宽。用标量指令一个个处理这些窄数据，寄存器高位全浪费了。SIMD 把单个寄存器当作多个窄元素的容器，一条指令对所有元素并行执行相同操作。

1.2 四路 8-bit 加法的对比

手册用一个经典例子说明了 SIMD 的优势——在不使用 SIMD 的情况下，完成四组 8-bit 加法需要四条 ADD 指令，且必须额外插入指令防止溢出从一个字节蔓延到相邻字节：

1
2
3
4
5
6
7
Scalar (SISD) — 4 条指令:
  A0+B0=C0, A1+B1=C1, A2+B2=C2, A3+B3=C3
  每次只用一个寄存器的低 8 位，高 24 位闲置

SIMD (UADD8) — 1 条指令:
  [A3|A2|A1|A0] + [B3|B2|B1|B0] = [C3|C2|C1|C0]
  四个 8-bit 通道（lane）独立并行计算，进位互不干扰
1
UADD8  R0, R1, R2    ; 4 路 8-bit 并行加法，单条指令替代四条 ADD

关键设计：各 lane 的计算是完全独立的——lane 0 的 bit[7] 进位不会影响 lane 1 的 bit[8]，各通道之间不存在进位链。这需要 ALU 在每个 byte 边界插入隔离逻辑，代价是额外的硬件，但收益是 4 倍吞吐。

1.3 NEON 与 ARMv6 SIMD 的本质区别

ARMv6 已经有了整数 SIMD，但那是在 32-bit 通用寄存器内的窄向量操作。NEON 的提升是跨越式的：

维度 ARMv6 整数 SIMD ARMv7 NEON
寄存器宽度 32-bit（通用寄存器 R0-R15） 64/128-bit（独立寄存器组）
寄存器数量 复用通用寄存器（16 个） 32×64-bit（=16×128-bit）
支持类型 8/16-bit 整数 8/16/32/64-bit 整数 + 32-bit 浮点
典型加速比 2–4× ≥2× vs ARMv6 SIMD

SIMD 原理讲清楚了，接下来看 NEON 如何通过独立的宽寄存器组把这些并行操作落地——以及在硬件层面与 VFP 的微妙关系。

2. NEON 寄存器组与 VFP 共享

NEON 最反直觉的设计可能是：它没有自己的独立寄存器文件——而是与浮点单元共用 32 个 64-bit 寄存器。这个决策深刻影响了上下文切换、编译器分配和指令宽度扩展的硬件实现。本节从寄存器架构切入，随后展开 D/Q 双视图和四种指令形状。

2.1 寄存器架构

NEON 拥有 32 个 64-bit 寄存器。与 VFPv3 共享同一套物理寄存器文件——这意味着实现 NEON 的处理器必须支持 VFPv3-D32 变体（32 个双精度寄存器）。这一设计决策有两个后果：

  • 上下文切换简单：保存和恢复 VFP 上下文的同时自动覆盖 NEON 上下文——操作系统不需要单独处理 NEON 寄存器。
  • 寄存器可以混用：编译器在同一个函数中既可以用这些寄存器存浮点值（VFP），也可以用来装 NEON 向量数据，EABI 调用约定规定了哪些寄存器可被破坏、哪些必须保留。

2.2 D/Q 双视图

NEON 寄存器有两种视角，由指令形式决定，软件无需显式切换：

1
2
3
4
5
Q0 (128-bit)  ──┬── D0 (64-bit, 低半)
                └── D1 (64-bit, 高半)
Q1 (128-bit)  ──┬── D2
                └── D3
...
视图 位宽 数量 典型用途
D 寄存器 (D0–D31) 64-bit 32 个 8×8-bit / 4×16-bit / 2×32-bit / 1×64-bit
Q 寄存器 (Q0–Q15) 128-bit 16 个（映射到 D0–D31） 16×8-bit / 8×16-bit / 4×32-bit / 2×64-bit

D/Q 双视图的主要价值在于支持结果宽度变化的操作。例如，两条 D 寄存器做乘法，结果需要 Q 寄存器的宽度来容纳：

1
VMULL.S16  Q2, D8, D9    ; 4 路 16-bit 乘法 → 4 路 32-bit 结果，需要 128-bit Q 寄存器

这里 L 后缀即 Long 指令——D 寄存器输入，Q 寄存器输出，结果宽度翻倍。这个模式贯穿了 NEON 指令集的所有算术运算，是接下来要讨论的四类指令形状中的第一类。

2.3 四种指令形状

NEON 数据处理指令按操作数和结果的宽度关系分为四类——这是理解 NEON 指令集的关键组织原则：

形状 后缀 操作数 结果 含义
Normal （无） N-bit N-bit 常规向量运算，结果与操作数同宽
Long L 64-bit (D) 128-bit (Q) 结果宽度翻倍（如 D×D→Q 乘法）
Wide W 64-bit + 128-bit 128-bit (Q) 混合宽度操作数，宽结果
Narrow N 128-bit (Q) 64-bit (D) 结果宽度减半（如加法后取高位）

实例：Long 指令的运算流程

1
2
3
4
5
6
VMULL.S16 Q0, D1, D2

D1: [ a3 | a2 | a1 | a0 ]    4 个 16-bit 有符号整数
D2: [ b3 | b2 | b1 | b0 ]    4 个 16-bit 有符号整数
        ↓     ↓     ↓     ↓
Q0: [ a3×b3 | a2×b2 | a1×b1 | a0×b0 ]   4 个 32-bit 乘积，结果放进 128-bit Q 寄存器

单个 16-bit×16-bit 乘积需要 32-bit 来存储，四个乘积共需 128-bit——正好一个 Q 寄存器。这就是双视图存在的原因。

寄存器的物理形态讲完了，下一个问题是：这些寄存器里到底装什么数据？

3. 数据类型与 NEON 指令格式

上节讲了寄存器”容器”的大小和形状，本节回答”容器里装什么”——NEON 支持的数据类型涵盖整数、浮点和多项式，每种都由助记符后缀显式编码。有了类型和寄存器，最后一节将这两者组合为完整的指令格式语法。

3.1 数据类型标识

NEON 指令通过点号后缀指定数据类型，格式为 <类型字母><位宽>：

类型 字母 可用位宽 说明
无符号整数 U 8, 16, 32, 64 —
有符号整数 S 8, 16, 32, 64 —
未指定符号整数 I 8, 16, 32, 64 符号无关的操作（如加法）
浮点 F 16, 32 F16 仅用于格式转换，不作数据运算
多项式 P 8 用于加密/数据完整性算法

实例：数据类型后缀在实际指令中的体现

1
2
3
4
VADD.I8   D0, D1, D2      @ I8  = 未指定符号 8-bit 整数，8 路并行加法
VADD.U16  Q0, Q1, Q2      @ U16 = 无符号 16-bit，8 路并行加法 (Q=128-bit)
VADD.F32  Q0, Q1, Q2      @ F32 = 单精度浮点，4 路并行加法
VMUL.P8   D0, D1, D2      @ P8  = GF(2) 域多项式，8 路并行乘法

三条 VADD 的指令操作码完全相同（VADD），唯一区分数据类型的就是后缀——.I8 做 8 个并行的 8-bit 加法，.F32 做 4 个 32-bit 浮点加法，硬件根据后缀选择不同的 ALU 通路。

多项式算术在 GF(2) 域上定义——加法即按位异或，乘法需要计算部分积后用异或合并。这与常规整数乘法的进位加法完全不同，专用于 CRC 校验和某些加密算法。

NEON 遵循 IEEE 754-1985 标准，但只支持 round-to-nearest 舍入模式（C 和 Java 的默认模式），且始终将非规格化数视为零。

3.2 指令格式全解析

NEON 指令的通用格式（以 V 开头，与 VFP 共享助记符前缀）：

1
V{<mod>}<op>{<shape>}{<cond>}.<dt>  <dest>, <src1>, <src2>
字段 含义 取值
<mod> 修饰符 Q（饱和）、H（折半）、D（翻倍+饱和）、R（舍入）
<op> 操作 ADD, SUB, MUL, MLA…
<shape> 形状 L（Long）、W（Wide）、N（Narrow）
<cond> 条件码 配合 IT 指令使用
.<dt> 数据类型 .S8, .I16, .F32 等

实例：逐字段解码

1
2
3
4
5
6
7
8
9
10
11
VQADD.S8  Q0, Q1, Q2
│││││  ││  │   │   └── 源操作数 2
│││││  ││  │   └────── 源操作数 1
│││││  ││  └────────── 目的寄存器
│││││  │└───────────── 数据类型：有符号 8-bit 整数
│││││  └────────────── 条件码（此处无）
││││└──────────────── 形状（此处 Normal，无后缀）
│││└───────────────── 操作：加法
││└────────────────── 修饰符：饱和运算
│└─────────────────── Q = 饱和（溢出时钳位而非回绕）
└──────────────────── V = 向量指令（NEON/VFP 共用前缀）

这条指令的含义：16 路有符号 8-bit 饱和加法——Q0 和 Q1 都是 128-bit 寄存器，每个包含 16 个 8-bit 有符号数，16 对数值同时相加。如果任何 lane 的加法结果溢出 8-bit 有符号范围（-128～+127），结果饱和到最值，且 FPSCR 中的粘滞 QC 位被置位。

这条指令展示的只是 NEON 指令集的一个点。接下来按算术、逻辑、比较、数据搬运四大类快速遍历整个指令集。

4. NEON 指令集速览

前面的章节覆盖了寄存器、类型和指令格式——现在进入具体指令。NEON 的指令集庞大但组织清晰：按功能划分为算术、逻辑、比较、数据搬运四大块，每块内部的修饰符和形状后缀遵循统一命名规则。

4.1 算术类

类别 代表指令 说明
加法/减法 VADD, VSUB 基本向量加减；VPADD 对相邻元素做成对加法
乘法 VMUL, VMLA, VMLS 乘、乘累加、乘减；VMULL 做 Long 乘法
倒数估算 VRECPE, VRSQRTE 倒数估算和平方根倒数估算（配合牛顿迭代实现除法）
平方根 VSQRT, VRSQRTS 平方根直接计算或迭代辅助
移位 VSHL, VSHR 左移/右移；VSLI 移位后插入

以下通过四个实例展示核心算术指令的实际运算行为。

实例一：基本向量加法与成对加法

1
2
3
4
5
6
7
VMOV.I32  D0, #1, #2          ; D0 = 0x00000002 00000001 (两个 32-bit lane)
VMOV.I32  D1, #10, #20        ; D1 = 0x00000014 0000000A
VADD.I32  D2, D0, D1          ; D2 = [1+10=11 | 2+20=22]  逐 lane 独立加法

; VPADD 的差别——相邻 lane 之间做加法：
VPADD.I32 D3, D0, D1          ; D3 = [1+2=3 | 10+20=30]
                               ; 注意：D0 内部一对、D1 内部一对——不是跨寄存器配对

VADD 和 VPADD 的差别决定了向量归约（reduction）的效率——VPADD 是水平方向求和，单独一条 VADD 是垂直方向。要把整个向量所有元素求和，通常需要多次 VPADD 级联。

实例二：乘累加——DSP 核心操作

1
2
3
4
5
6
7
8
9
10
11
12
13
; 计算 FIR 滤波器的一个 tap: acc += coeff × sample
VMOV.I16  D0, #0x03, #0x02, #0x01, #0x00    ; D0 = [3 | 2 | 1 | 0] 系数(4路16-bit)
VMOV.I16  D1, #0x30, #0x20, #0x10, #0x00    ; D1 = [48|32|16| 0] 采样(4路16-bit)
VMOV.I16  D2, #1                             ; D2 = [1 | 1 | 1 | 1] 累加器初值(看作acc)

VMLA.I16  D2, D0, D1
; D2 = D2 + D0 × D1 (逐lane)
;   = [1+3×48=145 | 1+2×32=65 | 1+1×16=17 | 1+0×0=1]
;   = [145 | 65 | 17 | 1]   4 路乘累加在一条指令内完成

; 如果需要 32-bit 精度的乘累加（避免 16-bit 溢出），用 Long 版本：
VMULL.S16 Q0, D0, D1         ; Q0 = D0 × D1, 每路 16×16→32 (结果在 128-bit Q 寄存器)
VADD.I32  Q2, Q0, Q1         ; 再独立做 32-bit 累加

实例三：牛顿-拉弗森除法——用乘法替代除法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
; 场景：8 个 float 数据 a[i] / b[i]
; 假设：
;   Q1 = b
;   Q4 = a
;   Q0/Q2 为临时寄存器

VRECPE.F32  Q0, Q1           ; Step 1: 粗略估算倒数
                              ; Q0 ≈ 1 / Q1（约 8 bit 精度）

VRECPS.F32  Q2, Q0, Q1       ; Step 2: 计算修正因子
                              ; Q2 = 2.0 - Q0 × Q1

VMUL.F32    Q0, Q0, Q2       ; Step 3: 牛顿迭代
                              ; Q0 = Q0 × (2.0 - Q0 × Q1)
                              ; 精度提升到约 16 bit

; 若需要 IEEE-754 单精度精度，再重复一次：
VRECPS.F32  Q2, Q0, Q1
VMUL.F32    Q0, Q0, Q2
                              ; 精度接近完整单精度

VMUL.F32    Q3, Q4, Q0       ; Step 4: a × (1/b)
                              ; Q3 = Q4 × Q0 = a / b

四条指令完成了 8 路并行的浮点除法。关键是 VRECPS 不产生最终结果，而是输出 Newton-Raphson 公式所需的中间修正量——它本身是一个专用的数学辅助指令。

实例四：移位操作

1
2
3
4
5
6
VSHL.S16  Q0, Q1, #4        ; 每 lane 算术左移 4 位 (×16), 符号位不参与移位
VSHR.U16  Q0, Q1, #3        ; 每 lane 逻辑右移 3 位 (÷8), 高位补零

; 移位后插入——用于拼接位域
VSLI.16   Q0, Q1, #4        ; Q0 每 lane 左移 4 位, 再将 Q1 每 lane 的低 4 位插入 Q0 低位
                             ; 典型用途: RGBA 颜色分量重排

NEON 没有 SIMD 除法指令。除法和平方根的精确值通过牛顿-拉弗森迭代获取：先用 VRECPE 快速估算倒数（精度约 8-bit），再用 VRECPS（倒数迭代步指令）多轮逼近。

4.2 逻辑与比较类

类别 代表指令
逻辑运算 VAND, VORR, VEOR, VBIC, VNOT, VORN
比较 VCEQ, VCGT, VCGE 等（输出全 1 或全 0 掩码）
最值 VMAX, VMIN（逐 lane 取最大/最小值）
位计数 VCNT（统计每 lane 的置位 bit 数），VCLZ（前导零计数）

以下通过三个实例展示比较、最值和位计数指令的实际效果。

实例一：比较生成掩码 + 位选择（无分支条件赋值）

1
2
3
4
5
6
7
8
9
10
11
12
13
; 场景：将向量中所有小于 0 的元素钳位为 0

VMOV.I32  Q0, #-5, #3, #-2, #8   ; Q0 = [-5  | 3  | -2 | 8 ] 4 路有符号 32-bit
VMOV.I32  Q1, #0                   ; Q1 = [ 0  | 0  |  0 | 0 ] 全零常量

VCGT.S32  Q2, Q0, Q1              ; Q2 = Q0 > Q1? (逐 lane 比较)
                                   ; Q2 = [ 0 | -1 |  0 | -1]
                                   ; 条件成立→全 1 (0xFFFFFFFF)，不成立→全 0

VBIT      Q1, Q0, Q2              ; Bitwise Insert if True:
                                   ; Q2 某位=1 → 该位取 Q0 对应位的值
                                   ; Q2 某位=0 → 该位保留 Q1 对应位的值
                                   ; 结果: Q1 = [ 0  | 3  |  0 | 8 ]

VCGT + VBIT 的组合是无分支向量化的关键模式：VCGT 生成掩码（每个 lane 要么全 1 要么全 0），VBIT 根据掩码按位选择新旧值——这比循环内的 if (x < 0) x = 0 快 4-8 倍，因为没有分支预测失败的开销。

实例二：逐 lane 最大/最小值

1
2
3
4
5
6
7
8
9
10
VMOV.I16  D0, #10, #50, #30, #20    ; D0 = [10 | 50 | 30 | 20] 4 路 16-bit
VMOV.I16  D1, #40, #25, #35, #15    ; D1 = [40 | 25 | 35 | 15]

VMAX.S16  D2, D0, D1                ; D2 = [max(10,40)=40 | max(50,25)=50 |
                                    ;        max(30,35)=35 | max(20,15)=20]
                                    ;    = [40 | 50 | 35 | 20]

VMIN.S16  D3, D0, D1                ; D3 = [min(10,40)=10 | min(50,25)=25 |
                                    ;        min(30,35)=30 | min(20,15)=15]
                                    ;    = [10 | 25 | 30 | 15]

在图像处理中，VMAX/VMIN 常用于形态学膨胀/腐蚀操作、图层 alpha 合成（max(src, dst)）和颜色空间钳位。

实例三：位计数与前导零

1
2
3
4
5
6
7
8
9
10
11
VMOV.I8   D0, #0x0F, #0x00, #0xFF, #0xAA, #0x55, #0x7B, #0x80, #0xFC

VCNT.I8   D1, D0     ; 逐 byte 统计置位 bit 数:
                      ; [popcount(0x0F)=4 | popcount(0x00)=0 | popcount(0xFF)=8 |
                      ;  popcount(0xAA)=4 | popcount(0x55)=4 | popcount(0x7B)=6 |
                      ;  popcount(0x80)=1 | popcount(0xFC)=6]

VCLZ.I8   D2, D0     ; 逐 byte 统计前导零:
                      ; [clz(0x0F)=4 | clz(0x00)=8 | clz(0xFF)=0 |
                      ;  clz(0xAA)=1 | clz(0x55)=1 | clz(0x7B)=1 |
                      ;  clz(0x80)=0 | clz(0xFC)=0]

VCNT 在密码学（汉明权重计算）和图像二值化统计中常用。VCLZ 是浮点规格化的基础——将非规格化数转换为规格化形式前需要知道”前面有多少个零”。

4.3 数据搬运与排列

NEON 支持结构化的访存指令，可在加载/存储的同时完成交织与解交织：

类别 说明
VLD1 / VST1 连续加载/存储单寄存器或多寄存器
VLD2 / VST2 双路交织加载/存储（如交错读取 RGB 的 R 和 G）
VLD3 / VST3 三路交织（RGB 三通道分离）
VLD4 / VST4 四路交织（RGBA 四通道分离）

寄存器间数据操作包括：

  • 复制：VDUP 将标量复制到向量所有 lane
  • 交换：VSWP 交换两个寄存器
  • 反转：VREV 按字/半字/字节反转元素顺序
  • 转置：VTRN, VZIP, VUZP 等矩阵重排操作
  • 提取：VEXT 从两个寄存器的拼接中提取任意偏移的向量

以下三个实例覆盖从内存加载、寄存器间重排到向量提取的完整数据搬运模式。

实例一：VLD3 — RGB 三通道分离（解交织）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
; 内存中 RGB 像素按交错方式存储: R0 G0 B0 R1 G1 B1 R2 G2 B2 R3 G3 B3 ...
; 目标: 将 R、G、B 分离到三个独立的 D 寄存器中

; 假设 r0 指向像素数组首地址
VLD3.8   {D0, D1, D2}, [r0]!
; 加载后:
; D0 = [R7 R6 R5 R4 R3 R2 R1 R0]  ← 所有 R 分量
; D1 = [G7 G6 G5 G4 G3 G2 G1 G0]  ← 所有 G 分量
; D2 = [B7 B6 B5 B4 B3 B2 B1 B0]  ← 所有 B 分量
;
; 后缀 ! 表示 r0 自动递增 (r0 += 24), 准备指向下一组 8 个像素

; 对 G 通道做亮度调整（R 和 B 不变）
VADD.I8   D1, D1, #16             ; G += 16 (每 lane 并行加)

; 写回时重新交织:
VST3.8   {D0, D1, D2}, [r1]!

在一条 VLD3 指令内完成了 24 字节的加载和通道分离——如果用标量指令需要约 72 条 LDRB + 位操作。这就是 NEON 结构化访存的最大价值。

实例二：VTRN 和 VZIP — 矩阵转置的基石

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
; 2×2 矩阵转置: [A B] → [A C]
;               [C D]   [B D]

VMOV.I32  D0, #1, #2      ; D0 = [1 | 2]
VMOV.I32  D1, #3, #4      ; D1 = [3 | 4]

VTRN.32   D0, D1
; 执行后:
; D0 = [1 | 3]             ← A, C 被交换到同一个寄存器
; D1 = [2 | 4]             ← B, D 被交换到同一个寄存器
; 结果: D0 和 D1 的对应 lane 被互换——D0[lane0]↔D1[lane0], D0[lane1]↔D1[lane1]

; VZIP 与 VTRN 的差别:
VMOV.I32  D0, #1, #2      ; 重置 D0 = [1 | 2]
VMOV.I32  D1, #3, #4      ; 重置 D1 = [3 | 4]

VZIP.32   D0, D1
; 执行后:
; D0 = [1 | 3]             ← 交错的低半部分
; D1 = [2 | 4]             ← 交错的高半部分
; 对于 2×2 矩阵, VZIP 和 VTRN 结果相同。但在 >2 路时行为不同:
; VTRN: 偶/奇下标互换
; VZIP: 像拉链一样交错 (类似 C 的 interleave)

对于 4×4 矩阵转置，通常需要组合 VTRN + VZIP 两次来完成：第一次转置 2×2 子块，第二次交换子块。

实例三：VEXT — 窗口滑动提取

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
; 场景：从连续信号中提取 3 个重叠窗口
; D0 = [A7 A6 A5 A4 A3 A2 A1 A0]  (8 个 8-bit 采样值)
; D1 = [B7 B6 B5 B4 B3 B2 B1 B0]  (8 个 8-bit 采样值)
; D0 和 D1 在内存中是连续的, D1 紧跟 D0

VEXT.8    D2, D0, D1, #3
; 将 D0:D1 拼接为 128-bit 整体:
;   [B7 B6 ... B0 | A7 A6 A5 A4 A3 A2 A1 A0]
; 然后从偏移 3 开始截取 64-bit:
; D2 = [B2 B1 B0 | A7 A6 A5 A4 A3]
;    = 相对于 D0 右移 3 个元素, 空缺位由 D1 的低位补入

VEXT.8    D3, D0, D1, #5
; D3 = [B4 B3 B2 B1 B0 | A7 A6 A5]
;    = 偏移 5 的另一个窗口

VEXT 是 FIR 滤波器实现中的核心指令——每个 tap 对应不同的偏移量，提取出相位的输入窗口后与系数做点积。一次 VEXT 省去了用移位和掩码手动拼接寄存器的复杂操作。

指令集知识到此为止。但在工程实践中，NEON 的最高效使用方式不是手写汇编——而是让编译器帮你做向量化。手册 §8.3 提供了完整的 C 语言工具链指南。

5. C 语言中的 NEON 编程

硬件只是故事的一半。手册 §8.3 专门讨论如何在不写汇编的前提下享用 NEON 加速——从编译器的自动向量化到运行时检测 NEON 硬件是否可用，覆盖了从开发到部署的完整工具链路径。

5.1 自动向量化

理想的 NEON 编程方式是不写汇编——让编译器自动向量化 C 代码。手册给出了启动 GCC 自动向量化的选项：

1
gcc -ftree-vectorize -mfpu=neon -O2 source.c

ARM Compiler 对应用 --vectorize 结合 -O2/-O3 和 -Otime。

编译器能自动发现循环中的并行模式，但 C 语言的别名规则会阻碍向量化——编译器必须保守地假设两个指针可能指向重叠内存。编写向量化友好的 C 代码需要：

  • 用 __restrict 关键字修饰指针，向编译器承诺内存区域不重叠
  • 将循环迭代次数设为 4 或 8 的倍数（与 NEON 的并行度对齐），避免剩余迭代的标量”尾巴”
  • 避免循环内包含函数调用、条件分支或跨迭代依赖

5.2 NEON 可用性检测

NEON 是可选扩展，程序必须具备回退路径。

编译期检测： armcc（RVCT 4.0+）和 GCC 在指定适当的处理器和 FPU 选项时会预定义宏 __ARM_NEON__（armasm 等价的宏是 TARGET_FEATURE_NEON）。可以用 #ifdef __ARM_NEON__ 在源码中条件编译 NEON 优化路径和非 NEON 回退路径，切换仅需改编译选项。

运行时检测： ARM 架构刻意不对用户模式暴露处理器能力信息，运行时检测必须依赖操作系统。

在 Linux 上，/proc/cpuinfo 直接可读：

1
2
$ cat /proc/cpuinfo
Features : swp half thumb fastmult vfp edsp thumbee neon vfpv3 ...

neon 标志明确指示硬件支持。但解析文本效率低，生产代码更常用 /proc/self/auxv——内核导出的二进制辅助向量，包含 AT_HWCAP 记录。检查 HWCAP_NEON 位（bit 4096）即可。

Ubuntu 09.10 起还利用了 ld.so 的 hwcap 机制：在 /lib/neon/vfp 路径下放置 NEON 优化版的共享库，链接器检测到 NEON 后会优先从该路径加载。应用开发者无需为此做任何代码修改——只要系统上有 NEON 优化库，就会透明使用。

5.3 NEON Intrinsics (内置函数) 编程

当编译器的自动向量化无法达到预期性能时，手写汇编又难以维护，NEON Intrinsics（内置函数） 是最佳的折中方案。包含 <arm_neon.h> 头文件即可在 C/C++ 中像调用普通函数一样执行 NEON 指令，编译器负责处理寄存器分配和指令调度。

数据类型命名规则： <基本类型><位宽>x<通道数>_t

  • uint8x8_t：对应 64-bit D 寄存器（8 个 8-bit 无符号整数）。
  • float32x4_t：对应 128-bit Q 寄存器（4 个 32-bit 单精度浮点）。
  • uint8x8x3_t：3 个 D 寄存器的结构体（通常用于 vld3 等结构化加载指令的结果）。

函数命名规则： v<指令名>[q]_[标志]<类型>

  • vadd_u16：64-bit 下的加法。
  • vaddq_u16：带 q 后缀，表示操作 128-bit Q 寄存器。
  • vmull_u8：长指令（Long），8-bit 乘法输出 16-bit 结果。

5.4 实际优化案例：RGB 转灰度图像

图像处理是 NEON 优化的经典场景。假设我们要将 RGB 图像转换为灰度图，经典的整数近似转换公式为：Gray = (R*77 + G*151 + B*28) >> 8。

标量 C 语言实现：

1
2
3
4
5
6
7
8
void rgb2gray_scalar(uint8_t *dest, uint8_t *src, int n) {
    for (int i = 0; i < n; i++) {
        int r = src[i * 3];
        int g = src[i * 3 + 1];
        int b = src[i * 3 + 2];
        dest[i] = (r * 77 + g * 151 + b * 28) >> 8;
    }
}

NEON Intrinsics 向量化实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
#include <arm_neon.h>

void rgb2gray_neon(uint8_t *dest, uint8_t *src, int n) {
    int i;
    uint8x8_t r_fac = vdup_n_u8(77);   // 将标量复制到 8 个通道
    uint8x8_t g_fac = vdup_n_u8(151);
    uint8x8_t b_fac = vdup_n_u8(28);

    // 每次并行处理 8 个像素
    for (i = 0; i <= n - 8; i += 8) {
        // vld3 自动将 RGB 交错的数据分离到三个向量中 (解交织)
        uint8x8x3_t rgb = vld3_u8(src + i * 3);
        uint16x8_t acc;
        
        // R*77 (8位乘法，16位结果避免溢出，对应 vmull 指令)
        acc = vmull_u8(rgb.val[0], r_fac);
        // 累加上 G*151 和 B*28 (对应 vmlal 指令)
        acc = vmlal_u8(acc, rgb.val[1], g_fac);
        acc = vmlal_u8(acc, rgb.val[2], b_fac);
        
        // 右移 8 位并窄化为 8-bit (Narrow 指令)
        uint8x8_t res = vshrn_n_u16(acc, 8); 
        
        // 交错前不用，直接按照一维顺序存回内存
        vst1_u8(dest + i, res);
    }
    
    // 尾部不足 8 个像素的边界处理（此处省略）
}

在核心循环中，我们利用 vld3 完美呼应了硬件的解交织加载设计，用 vmull / vmlal 并行完成了 8 组像素的 24 次乘法和 16 次累加。因为彻底消灭了冗余运算且充分填充了流水线，其速度通常是标量代码的数倍。

从硬件架构到指令集再到工具链，NEON 的全景已经展开。以下八条要点是贯穿本章的核心结论。

6. 学习要点总结

从标量浪费到向量并行，从 32-bit 通用寄存器到 128-bit 独立寄存器组，从汇编助记符到 C 编译器的自动向量化——NEON 的全景由以下八条核心结论串联。

  1. NEON = 128-bit 独立向量引擎。不要把它和 ARMv6 的 32-bit 整数 SIMD 搞混——前者有独立寄存器组和流水线，后者只是在通用寄存器内做窄向量操作。NEON 的吞吐是 ARMv6 SIMD 的至少 2 倍以上。

  2. D/Q 双视图是理解 NEON 寄存器架构的核心。Q0 = D0+D1 的映射关系使得 Normal/Long/Wide/Narrow 四种指令形状可以无缝复用同一套物理寄存器组。

  3. 数据类型通过指令后缀编码，不是寄存器属性。同一个 D0 可被一条指令当作 8×8-bit 来用，下一条当成 4×16-bit——灵活性由指令决定，寄存器本身无类型。

  4. NEON 和 VFP 共享寄存器。这意味着上下文切换的开销是统一的——保存 VFP 就同时保存了 NEON。代价是 NEON 不支持双精度浮点（留给 VFP），也不支持除法和平方根的直接计算（需要牛顿迭代）。Cortex-A 系列可配置为无 NEON/VFP、仅 VFP 或 NEON+VFP 三种组合。

  5. 运算修饰符 Q/H/D/R 构成了一套功能层——饱和（Q）用于音视频的溢出钳位，折半（H）用于均值计算，翻倍（D）用于 Q15 定点数校正，舍入（R）等效于加 0.5 后截断。

  6. Auto-vectorization 是 NEON 的首选编程路径。__restrict、4/8 倍数循环、-ftree-vectorize 三个要素配合，能让许多图像和音频循环在零汇编代码的前提下享受 NEON 加速。

  7. Linux 的 NEON 检测有三层机制：编译期 __ARM_NEON__ 宏（切换优化路径）、运行时 /proc/cpuinfo（可读性）和 AT_HWCAP（性能）、ld.so hwcap 路径（完全透明）。生产代码建议用 auxv 方式。

  8. NEON Intrinsics 是 C/C++ 编程的首推利器：当自动向量化失败时，引入 <arm_neon.h> 编写内置函数，既能拥有和手写汇编相近级的细粒度控制力（如 vld3 解交织、vmlal 乘累加），又能避免手分配寄存器的高昂维护成本。