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.