simd auto vectorization
**SIMD Auto-Vectorization** is the **compiler optimization that automatically transforms scalar loop operations into SIMD (Single Instruction, Multiple Data) vector instructions**, processing multiple data elements per instruction (4-16 for SSE/AVX on x86, 4-64 for SVE on ARM) without requiring programmers to write explicit intrinsics or assembly — achieving 2-16x speedup on data-parallel loops.
**Vectorization Process**: The compiler analyzes loops to determine if iterations are independent and can be executed simultaneously:
1. **Dependence Analysis**: Check that no loop-carried dependencies prevent parallel execution. A loop like for(i) a[i] = a[i-1] + 1 has a RAW (read-after-write) dependence and cannot be vectorized.
2. **Legality Check**: Verify that SIMD execution produces identical results to scalar execution (considering floating-point associativity, overflow, etc.).
3. **Profitability Analysis**: Estimate whether vectorized code is actually faster — short trip counts, expensive gather/scatter, or poor alignment may make vectorization unprofitable.
4. **Code Generation**: Replace scalar operations with vector equivalents, handle loop remainder (epilogue for non-vector-multiple trip counts), and insert alignment/packing code.
**Vectorization Patterns**:
| Pattern | Vectorizability | Requirement |
|---------|----------------|------------|
| Element-wise: a[i] = b[i] + c[i] | Easy | No dependencies |
| Reduction: sum += a[i] | Yes (with reorder) | Associative operation |
| Conditional: if(a[i]>0) b[i]=... | Yes (masked) | Predicated execution |
| Indirect: a[idx[i]] = ... | Partial (scatter) | Hardware gather/scatter |
| Cross-iteration: a[i] = a[i-1]+... | No (general) | Loop-carried dependency |
**Compiler Pragmas and Hints**: When auto-analysis is insufficient, programmers can guide vectorization: **#pragma omp simd** — OpenMP directive asserting loop is safe to vectorize; **__restrict** — tells compiler pointers don't alias (enabling vectorization of functions with pointer arguments); **#pragma ivdep** — ignore assumed vector dependencies; **-ffast-math** — allows floating-point reassociation for reduction vectorization.
**Data Layout for Vectorization**: **Array of Structures (AoS)** like struct{x,y,z} particles[N] requires gather operations for vectorization. **Structure of Arrays (SoA)** like float x[N], y[N], z[N] enables contiguous vector loads. The **AoSoA** hybrid (Array of Structure of Arrays) provides cache-friendly access with vectorizable inner loops.
**Advanced Vectorization**: **Outer-loop vectorization** — vectorize across outer loop iterations when inner loop is not vectorizable; **SLP (Superword Level Parallelism)** — pack adjacent independent scalar operations into vector instructions without requiring loop structures; **loop interchange/tiling** combined with vectorization for multi-dimensional arrays; and **versioning** — generate both vector and scalar versions, choosing at runtime based on alignment or trip count.
**SIMD auto-vectorization is the most impactful free performance optimization modern compilers provide — it converts sequential code into parallel execution without source changes, and understanding how to write vectorization-friendly code is essential for extracting peak performance from modern processors.**