第3章 SIMD 向量化

一条指令处理多个数据

章节导读

前面两章我们反复提到一个承诺：把数据排成连续的同类型数组，不仅缓存友好，还能解锁一种强大的硬件能力——SIMD。本章兑现这个承诺。SIMD是Single Instruction, Multiple Data（单指令多数据）的缩写，指一条机器指令同时对多个数据元素执行相同运算。想象一个加法器不再是"一次加一对数"，而是"一次加八对数"——这就是SIMD的本质：在CPU执行单元内部放置宽达128、256甚至512位的向量寄存器，让一条指令驱动多个并行的算术通道。

指令集	寄存器宽度	同时处理 float 数	相对标量加速比	代表 CPU 架构
标量 x87	80-bit	1	1x	所有 x86
SSE	128-bit	4	4x	Pentium III+
SSE2	128-bit	4 (double: 2)	4x	Pentium 4+
AVX	256-bit	8	8x	Sandy Bridge (2011)
AVX2	256-bit	8 (整数增强)	8x	Haswell (2013)
AVX-512	512-bit	16	16x	Skylake-X (2017)
ARM NEON	128-bit	4	4x	ARMv7+
ARM SVE	128-2048-bit	可变	可变	ARMv8+

SIMD的历史可以追溯到1970年代的向量超级计算机（Cray-1是著名代表），但进入个人计算机是1997年Intel随Pentium MMX和随后的SSE（Streaming SIMD Extensions）开始的。SSE引入8个128位XMM寄存器，一次可以处理4个单精度float；2011年Sandy Bridge架构推出AVX，寄存器加宽到256位（YMM），一次处理8个float；2017年Skylake-X引入AVX-512，寄存器达512位（ZMM），一次处理16个float，并增加了掩码寄存器等强大特性。ARM阵营对应的是NEON（128位）和SVE/SVE2（可变长度，最长2048位）。这意味着在过去二十多年里，单核的浮点峰值算力有超过一半来自SIMD宽度的增长——一个不使用SIMD的现代程序，等于自愿放弃了80%以上的理论算力。

为什么SIMD与DOD是天作之合？因为SIMD指令的操作数要求同类数据连续排列：一条"8个float相加"的指令，需要从内存一次加载8个相邻的float。这正是SoA布局的天然形态——float x[10000]数组中任意连续8个元素就是一条AVX指令的输入。反过来，AoS布局中粒子的x坐标每隔128字节才出现一次，要用SIMD处理就必须先做昂贵的gather（收集）操作或数据重排。可以说，SoA是SIMD的入场券：没有数据布局的配合，向量化无从谈起。这也是为什么游戏引擎、物理库、图形API全部采用SoA式数据组织的深层原因之一。

获得SIMD有两条路径。第一条是自动向量化：编译器分析循环，在确认无数据依赖、无别名冲突、访问连续后，自动把标量循环改写为向量指令。现代GCC和Clang在-O3下能向量化相当一部分简单循环，但它们必须保守——任何一个可能别名的指针、任何一个循环携带依赖、任何一个不规整的分支，都会让编译器放弃。第二条路径是手动向量化：用intrinsics（内建函数）直接书写向量操作，如_mm256_add_ps(a, b)表示256位寄存器中8个float对应相加。intrinsics在C/C++中以函数形式出现，但编译后就是单条向量指令，程序员获得完全控制权，代价是代码与特定指令集绑定、可移植性下降。介于两者之间还有#pragma omp simd等提示机制，告诉编译器"这个循环我保证可以向量化"。

自动向量化的条件值得详细展开，因为大多数"为什么我的循环没被向量化"的困惑都源于此。核心障碍有四类：数据依赖（循环迭代间存在读写依赖，如a[i] = a[i-1] + 1，向量化会改变语义）；指针别名（编译器无法确定两个指针不重叠，如a[i] = b[i] * 2中a和b可能指向同一数组，需要restrict关键字或编译期分析解除疑虑）；不连续访问（步长不为1的访问需要gather指令，老架构上gather很慢）；数据相关分支（循环体内含if时，SIMD无法"跳过"某些通道，需要改写为无分支的选择操作或掩码操作）。理解这四类障碍，就能主动把代码写成"可向量化形态"——这本身就是一种DOD技巧。

性能收益的量化分析需要冷静。理论上AVX提供8倍于标量的吞吐，但实际加速比受制于Amdahl定律和内存带宽：如果循环是计算密集的（每字节数据做多次运算），4-8倍加速常见；如果循环是纯带宽受限的（如简单的数组拷贝加法），SIMD只能把瓶颈从"计算"推到"内存"，加速比可能只有1.5-2倍——但注意，此时前两章的缓存优化与本章的SIMD叠加，总收益依然可观。此外AVX-512在部分CPU上有降频惩罚（执行512位指令时整颗CPU降频），需要实测权衡。SIMD优化的正确心态是：先用缓存优化把数据喂到CPU嘴边，再用向量化让CPU一口吃八个。

本章的代码示例将从最基础的向量加法开始，逐步展示标量与SIMD的对照写法、自动向量化的触发与失败案例、以及矩阵乘法的向量化优化。我们还会讨论数据对齐的要求（向量加载通常要求16/32/64字节对齐）、尾数处理（数组长度不是向量宽度整数倍时的剩余元素）、以及跨平台抽象层的设计思路。学完本章，你将掌握DOD工具箱中最锋利的一件武器，并理解为什么"数据布局决定计算形态"是贯穿本书的主线。

核心概念

SSE/AVX/AVX-512
intrinsics
自动向量化
数据并行
SoA与SIMD

要点精析

SIMD指令集的演进决定了单核算力的增长曲线。SSE（1999）提供8个128位XMM寄存器，单精度浮点一次4路；SSE2（2001）扩展到双精度和整数运算，成为x86-64的基线指令集；AVX（2011）把寄存器加宽到256位并改为三操作数格式（减少寄存器搬移），浮点吞吐翻倍；AVX2（2013）把256位扩展到整数运算并加入gather指令；AVX-512（2017）提供32个512位寄存器、掩码寄存器和丰富的shuffle/permute指令，但不同微架构的支持子集碎片化严重（Skylake-X、Ice Lake、Zen 4各支持不同子集），且Intel客户端CPU已放弃AVX-512。ARM方面NEON是128位基线，SVE采用"向量长度无关"（VLA）编程模型，同一二进制可在128到2048位硬件上运行。工程建议：以AVX2为性能目标（2013年后的CPU普遍支持），用运行时CPU特性检测（CPUID）分发不同代码路径，SSE2作为保底回退。

SoA布局是SIMD的先决条件，这个论断可以从指令的操作数形态严格推出。一条AVX的向量加法vaddps ymm0, ymm1, ymm2要求ymm1和ymm2中各自装着8个"语义对应"的float：ymm1的第k个通道与ymm2的第k个通道相加。从内存加载ymm1的最优方式是vmovups连续读取8个相邻float——这恰好是SoA数组的形态。AoS布局下，8个粒子的x坐标相距128字节，需要8次独立加载加7次shuffle才能拼出一个向量寄存器，拼装开销常常超过计算本身；AVX2的vgatherdps指令理论上可以直接收集，但早期实现中gather的吞吐仅为连续加载的1/4到1/8，直到Ice Lake/Zen 4才显著改善。因此DOD社区的实践法则是：先SoA化，再向量化；如果数据无法SoA化（如异构对象），SIMD的收益就大打折扣。数据布局不仅影响缓存，还直接决定计算指令的形态——这是"数据导向"最深刻的体现。

自动向量化的四大障碍及对应解法。障碍一：循环携带依赖。如a[i] = a[i-1]2无法向量化（迭代i依赖i-1的结果），解法是算法层面改写（前缀和、递推展开）或确认依赖不存在后用编译器选项解除。障碍二：指针别名。void f(float a, float* b, int n)中编译器必须假设a和b可能重叠（restrict缺失时），向量化可能改变语义；解法是加restrict限定符，或C++中用引用/值语义帮助分析。障碍三：非单位步长与间接访问。a[idx[i]]形式的间接寻址需要gather，老硬件上编译器通常放弃；解法是重排数据消除间接层，或手动写gather intrinsics。障碍四：循环内分支。if (x[i] > 0) y[i] = f(x[i])这种数据相关分支，编译器可用掩码执行（AVX-512原生支持，AVX2用blend指令模拟）但收益不确定时往往放弃；解法是改写为无分支形式（用算术选择替代if）、按条件把数据分拣到不同数组分别处理、或手动用掩码intrinsics。诊断工具：GCC的-fopt-info-vec-missed和Clang的-Rpass-analysis=loop-vectorize会逐循环报告向量化失败原因。

intrinsics编程模型需要理解"寄存器即类型"的抽象。Intel intrinsics中__m128表示128位寄存器装4个float，__m256装8个float，__m256i装8个int32或16个int16等；函数命名规则为_mm_（SSE）、_mm256_（AVX）、_mm512_（AVX-512）加操作名加类型后缀（ps=packed single，pd=packed double，epi32=packed int32）。典型工作流：_mm256_loadu_ps从内存加载8个float（loadu不要求对齐，load要求32字节对齐但略快）；_mm256_add_ps等执行运算；_mm256_storeu_ps写回。水平操作（如求8个通道之和）需要log2(8)=3次shuffle加add的树形归约。intrinsics代码的可读性差、可移植性差，工程上通常封装成薄抽象层（如highway、xsimd库），或只在最内层热点使用。必须强调：intrinsics不是"更高级的汇编"，编译器仍会对intrinsics代码做寄存器分配和调度，性能通常能达到手写汇编的90%以上。

数据对齐与尾数处理是SIMD工程化的两个必答题。对齐方面：AVX的vmovaps要求32字节对齐，未对齐地址会触发异常；实践中用alignas(32)声明数组、aligned_alloc/_mm_malloc分配堆内存，或统一使用不要求对齐的loadu/storeu（现代CPU上未对齐惩罚已很小，除非跨缓存行）。尾数方面：n=10000的数组按8个一组处理，10000/8=1250组恰好整除；但n=10003时剩余3个元素，需要标量循环收尾，或用AVX-512的掩码加载只处理有效的3个通道。DOD的数组化设计让尾数处理简单化——所有数组等长，尾数逻辑写一次即可；而OOP的异构集合连"长度"都不明确。另一个工程细节是结构体数组的SoA变体：有时把4个float打包为alignas(16) struct Vec4比完全拆散更好（保留一定的概念聚合），SSE时代这是主流做法，AVX时代则倾向8个float一组。

性能收益的量化分析必须区分计算受限与带宽受限。计算受限循环（如多项式求值、矩阵乘法内层，每加载1字节做多次FMA）的SIMD加速比接近理论值：AVX2的8路float加FMA（乘加融合）双操作，峰值可达标量的16倍，实测4-8倍常见。带宽受限循环（如c[i]=a[i]+b[i]，每8字节数据只做1次加法）的瓶颈在内存带宽而非算力，SIMD加速比通常只有1.5-3倍——数据在L1/L2时收益大，打到主存时收益趋近于1（带宽已被标量代码占满）。判断方法：计算算术强度（FLOPs/字节），与机器的ridge point（峰值算力/峰值带宽）比较。这解释了为什么SIMD必须与缓存优化配合：缓存优化决定数据能否快速到达，SIMD决定到达后能否被快速消费。还有一个反直觉现象：AVX-512重指令在Skylake-X上会触发license-based降频（整核甚至整封装降频50-300MHz），混合使用轻重指令的代码可能比纯AVX2更慢，必须实测。

分支消除技巧是SIMD化的关键预处理，DOD提供了系统性的解法。传统代码if (particle.alive) update(particle)在SIMD下有两种处理：掩码执行（所有通道都算，用掩码决定写回哪些，浪费算力但无分支）或数据分拣（先把alive的粒子索引收集到紧凑数组，再对紧凑数组做纯SIMD处理，无浪费但多一次遍历）。Fabian推崇第三种更彻底的DOD方案：让数据组织本身消灭分支——维护一个"活跃粒子数组"，粒子死亡时与数组末尾元素交换并缩短数组（swap-and-pop），这样活跃粒子永远连续存储，更新循环根本不需要判断alive。这个O(1)的删除技巧破坏了顺序稳定性（若需要保序则用稳定分区），但换来了完全无分支、完全连续的SIMD友好循环。同理，按类型分拣实体（所有可渲染的、所有有物理的各自成数组）把运行时类型分支转化为编译时的循环选择。

跨平台SIMD抽象是工程落地的现实问题。直接写intrinsics意味着x86的_mm256系列与ARM的vaddq_f32系列各写一遍，维护成本翻倍。业界方案有三类：编译器可移植向量扩展（如Clang的vector extension：typedef float v8f __attribute__((ext_vector_type(8)))，运算符重载后代码接近标量写法，编译器负责映射到目标平台的指令）；库抽象（Google Highway提供运行时分发和统一API，xsimd提供C++模板封装，SIMD Everywhere覆盖NEON）；以及ISPC语言（Intel的SPMD编译器，写"类C的标量代码"由编译器自动生成多平台SIMD，游戏和图形行业有成功案例）。选择建议：单一平台的高性能内核直接写intrinsics榨干硬件；跨平台产品用Highway或ISPC；原型阶段依赖自动向量化加pragma提示。无论哪种方案，SoA数据布局都是共同前提——这再次印证DOD是基础设施，SIMD是上层建筑。

gather/scatter与shuffle指令决定了"不规整SIMD"的可行性上限。理想世界所有访问都是连续的，现实世界充满间接索引：粒子碰撞检测要访问邻居（空间哈希给出的随机索引）、骨骼动画要按索引取矩阵、稀疏计算天然不连续。AVX2引入vgatherdps允许用8个int32索引从任意地址收集8个float到向量寄存器，但硬件实现是串行化的多次加载，吞吐远低于连续加载；shuffle/permute指令（_mm256_permutevar8x32_ps等）则允许在寄存器内部按索引重排通道，是数据重排（AoS转SoA、转置小矩阵）的核心工具。DOD视角的解法优先级是：第一，重排数据消除间接访问（把随机访问变成顺序访问，如按处理顺序预排序实体）；第二，把间接层批量化（先收集索引，再按索引分块gather，摊薄开销）；第三，接受标量处理不规整部分。核心思想不变：与其让计算适应糟糕的数据布局，不如改造数据布局适应计算。

SIMD与多线程的关系是正交且可叠加的。SIMD挖掘单核内的数据并行（空间并行于寄存器宽度），多线程挖掘多核并行，两者组合是现代高性能计算的标准形态：外层用线程池按块划分数据（每线程处理连续的块以避免伪共享，见第2章），内层每线程用SIMD处理自己的块。以粒子更新为例：100万粒子分给8线程，每线程12.5万连续粒子，线程内按8个一组做AVX加法——理论加速8线程x8通道=64倍，实测通常30-50倍（受带宽和同步开销限制）。需要注意的交互点：每线程的块边界最好对齐到向量宽度和缓存行的公倍数（如64字节），避免跨线程共享缓存行；NUMA架构下线程应绑定到数据所在的内存节点。OpenMP的simd指令（#pragma omp simd）与parallel for可以组合使用，由编译器生成"多线程+向量化"的代码。这种分层并行策略，正是DOD数组化布局的自然延伸：连续数组既好切分给线程，又好切分给向量寄存器。

代码示例

#include <immintrin.h>

void addScalar(float* c, const float* a, const float* b, int n) {
  for (int i = 0; i < n; ++i) c[i] = a[i] + b[i];
}

void addAVX(float* c, const float* a, const float* b, int n) {
  int i = 0;
  for (; i + 8 <= n; i += 8) {
    __m256 va = _mm256_loadu_ps(a + i);
    __m256 vb = _mm256_loadu_ps(b + i);
    __m256 vc = _mm256_add_ps(va, vb);
    _mm256_storeu_ps(c + i, vc);
  }
  for (; i < n; ++i) c[i] = a[i] + b[i];
}

这是SIMD的Hello World：向量加法。addScalar每次迭代处理1个float，addAVX每次迭代用一条vaddps指令处理8个float。核心流程是loadu加载（u表示不要求对齐）、add_ps运算、storeu写回，循环步长为8。尾部标量循环处理n不是8的倍数的剩余元素——这是所有SIMD代码的标配结构。性能上，当数组在L1/L2缓存中时addAVX约为addScalar的4-6倍（未达8倍是因为加载/存储端口带宽成为新瓶颈：每周期通常只能执行2次256位加载和1次存储）；当数组大到超出L3时，两者都受主存带宽限制，加速比降到1.2-1.5倍。这个例子生动展示了"带宽受限"概念：加法本身太便宜，瓶颈在数据搬运。若把运算换成更重的计算（如多项式求值），SIMD加速比会显著上升。编译需要-avx2标志，运行前应通过__builtin_cpu_supports("avx2")检测CPU支持。

void updateParticlesAuto(float* px, float* py, float* pz,
                         const float* vx, const float* vy, const float* vz,
                         float dt, int n) {
  for (int i = 0; i < n; ++i) {
    px[i] += vx[i] * dt;
    py[i] += vy[i] * dt;
    pz[i] += vz[i] * dt;
  }
}

void updateParticlesFMA(float* __restrict px, float* __restrict py, float* __restrict pz,
                        const float* __restrict vx, const float* __restrict vy, const float* __restrict vz,
                        float dt, int n) {
  #pragma omp simd
  for (int i = 0; i < n; ++i) {
    px[i] += vx[i] * dt;
    py[i] += vy[i] * dt;
    pz[i] += vz[i] * dt;
  }
}

这个例子展示自动向量化的触发条件。两个函数体完全相同，差别只在restrict限定符和#pragma omp simd提示。第一个版本中，编译器必须保守假设px可能与vx重叠（别名问题）：如果px和vx指向同一数组，向量化后的读写顺序会改变结果，因此GCC在-O3下可能向量化（依赖版本分析）也可能放弃。第二个版本用__restrict明确承诺六个指针互不重叠，编译器立即放心地向量化，并进一步把a += b * c识别为FMA（fused multiply-add）指令——一条指令完成乘加，延迟减半且精度更高。#pragma omp simd则显式指示编译器"此循环必须向量化"，若无法向量化会产生警告。验证方法：用GCC编译时加-fopt-info-vec-optimized，输出会列出每个被向量化的循环及使用的指令宽度。这个例子的教训是：SoA布局（六个独立数组）是自动向量化的理想输入，而程序员需要用restrict和pragma帮助编译器克服保守性——数据布局与代码提示双管齐下。

#include <immintrin.h>

float dotProductAVX(const float* a, const float* b, int n) {
  __m256 sum0 = _mm256_setzero_ps();
  __m256 sum1 = _mm256_setzero_ps();
  int i = 0;
  for (; i + 16 <= n; i += 16) {
    __m256 a0 = _mm256_loadu_ps(a + i);
    __m256 b0 = _mm256_loadu_ps(b + i);
    __m256 a1 = _mm256_loadu_ps(a + i + 8);
    __m256 b1 = _mm256_loadu_ps(b + i + 8);
    sum0 = _mm256_fmadd_ps(a0, b0, sum0);
    sum1 = _mm256_fmadd_ps(a1, b1, sum1);
  }
  __m256 sum = _mm256_add_ps(sum0, sum1);
  __m128 lo = _mm256_castps256_ps128(sum);
  __m128 hi = _mm256_extractf128_ps(sum, 1);
  __m128 s = _mm_add_ps(lo, hi);
  s = _mm_add_ps(s, _mm_movehl_ps(s, s));
  s = _mm_add_ss(s, _mm_shuffle_ps(s, s, 1));
  float result = _mm_cvtss_f32(s);
  for (; i < n; ++i) result += a[i] * b[i];
  return result;
}

点积展示了SIMD归约的完整套路。难点在于加法是顺序依赖的：sum += a[i]*b[i]看似循环携带依赖，无法直接向量化。解法分三步。第一步，多累加器打破依赖链：使用sum0和sum1两个独立的向量累加器，每次迭代处理16个元素，两条FMA链互不依赖，充分利用CPU的乱序执行和FMA单元的流水线（FMA延迟4-5周期，吞吐每周期2条，单累加器会被延迟卡住）。第二步，水平归约：先把sum0和sum1相加得到一个256位向量（8个部分和），然后extractf128拆成两个128位半区相加，movehl把高2个float移到低位相加，最后shuffle把剩下2个通道相加——log2(8)=3层树形归约得到标量结果。第三步，标量尾循环处理剩余元素。这个模式（多累加器+树形水平归约+尾处理）适用于所有SIMD归约：求和、求最大值、求长度平方。物理引擎中每帧数百万次的距离计算、投影运算都依赖它。注意浮点加法不满足结合律，改变求和顺序会引入微小数值差异——对精度敏感的场景需要评估。

void transformVertices(float* __restrict out, const float* __restrict in,
                       const float* __restrict mat4x4, int vertexCount) {
  for (int v = 0; v < vertexCount; ++v) {
    __m256 x = _mm256_set1_ps(in[v*4+0]);
    __m256 y = _mm256_set1_ps(in[v*4+1]);
    __m256 z = _mm256_set1_ps(in[v*4+2]);
    __m256 w = _mm256_set1_ps(in[v*4+3]);
    __m256 r = _mm256_mul_ps(x, _mm256_loadu_ps(mat4x4 + 0));
    r = _mm256_fmadd_ps(y, _mm256_loadu_ps(mat4x4 + 8), r);
    r = _mm256_fmadd_ps(z, _mm256_loadu_ps(mat4x4 + 16), r);
    r = _mm256_fmadd_ps(w, _mm256_loadu_ps(mat4x4 + 24), r);
    _mm256_storeu_ps(out + v*4, r);
  }
}

矩阵变换顶点展示了一种巧妙的SIMD技巧：当"向量宽度"与"数据宽度"恰好错配时，用广播替代转置。逻辑上我们要对每个顶点（4个float）做4x4矩阵乘法，标量写法是4次点积。这里反过来：把矩阵的两行打包进一个256位寄存器（两个128位半区各放一行），把顶点的单个分量用set1_ps广播到全部8个通道，然后4次FMA完成计算——结果的每个128位半区装着变换后顶点的x,y,z,w。这种做法避免了昂贵的4x4转置，代价是每个顶点的处理只用了一半的寄存器宽度（128位有效）。更彻底的方案是真正的SoA化：把顶点坐标拆成x[]、y[]、z[]三个数组，则8个顶点的x分量正好装满一个ymm寄存器，矩阵乘法变成纯粹的向量FMA，宽度利用率100%——这就是为什么渲染管线内部（如GPU的顶点着色器）全部采用SoA。这个例子说明SIMD优化没有唯一答案，数据布局决定最优策略：AoS小向量用广播技巧，SoA大数组用满宽度向量化。

struct ParticleArrays {
  float* px; float* py; float* pz;
  float* vx; float* vy; float* vz;
  int count;
  int capacity;
};

void removeDeadParticles(ParticleArrays* p, const float* lifetime) {
  int write = 0;
  for (int read = 0; read < p->count; ++read) {
    if (lifetime[read] > 0.0f) {
      p->px[write] = p->px[read];
      p->py[write] = p->py[read];
      p->pz[write] = p->pz[read];
      p->vx[write] = p->vx[read];
      p->vy[write] = p->vy[read];
      p->vz[write] = p->vz[read];
      lifetime[write] = lifetime[read];
      write++;
    }
  }
  p->count = write;
}

void compactUpdate(ParticleArrays* p, float dt) {
  int i = 0;
  for (; i + 8 <= p->count; i += 8) {
    __m256 vdt = _mm256_set1_ps(dt);
    __m256 x = _mm256_loadu_ps(p->px + i);
    __m256 vx = _mm256_loadu_ps(p->vx + i);
    _mm256_storeu_ps(p->px + i, _mm256_fmadd_ps(vx, vdt, x));
  }
  for (; i < p->count; ++i) p->px[i] += p->vx[i] * dt;
}

这组代码展示DOD的"数据组织消灭分支"哲学与SIMD的结合。removeDeadParticles用紧凑化（compaction）代替逐粒子分支：粒子死亡时不是标记alive=false然后每次更新都检查，而是直接把存活粒子向前搬移、缩短count——经典的swap-and-pop的稳定版本（保序紧凑）。紧凑化之后，compactUpdate面对的永远是一个无空洞、无标志位、完全连续的数组，更新循环不含任何if，是SIMD的理想输入：8个一组FMA，满宽度利用。对比传统OOP写法（遍历所有粒子，if(alive)则虚调用update()），DOD版本消除了三层开销：分支预测压力、虚函数间接跳转、死粒子占据的缓存空间。紧凑化本身的成本是O(存活数)的搬移，但只在粒子死亡帧发生，且搬移是纯顺序读写，缓存和SIMD都友好。这个"维护紧凑不变量，让主循环无条件化"的模式，在剔除（culling）、碰撞对过滤、活跃实体管理中反复出现，是DOD+SIMD工程实践的标志性手法。

实验笔记

本实验的目标是亲手实现并测量SIMD优化的完整流程，建立对向量化收益与限制的定量认识。第一部分：自动向量化观察。编写数组加法、点积、位置更新三个循环的标量版本，分别用gcc -O2、-O3、-O3 -march=native -fopt-info-vec编译，记录哪些循环被向量化、使用了什么指令（从fopt-info输出中提取）；然后给点积函数加上restrict和#pragma omp simd，观察向量化行为的变化。用Google Benchmark或自写计时框架测量各版本在n=1024（L1内）、n=100万（L2/L3）、n=1亿（主存）三种规模下的吞吐（GB/s和GFLOPS），绘制"数据规模-加速比"曲线，解释曲线形状与缓存层次和内存带宽的关系。第二部分：手写intrinsics。用AVX2 intrinsics实现向量加法和点积（含双累加器和水平归约），与编译器自动向量化的版本对比性能；实现尾数处理，用n=10003等非整倍数验证正确性。第三部分：分支消除实验。实现粒子系统的两个版本：版本A遍历所有粒子并用if(alive)过滤（存活率50%），版本B先紧凑化再无分支更新；测量不同存活率（10%、50%、90%）下两个版本的性能，找到交叉点并解释。第四部分（进阶）：用_mm256_i32gather_ps实现按索引收集，与"预排序后连续访问"方案对比，量化gather的吞吐损失；查阅你所用CPU的微架构资料，解释实测数据。提交：完整基准代码、三部分的数据表格与曲线图、以及对"为什么带宽受限时SIMD收益下降"的书面分析。环境要求：支持AVX2的x86 CPU（2013年后），Linux下perf可用；若使用ARM机器，改用NEON intrinsics完成等价实验。