C# SIMD加速差异：AABB与圆相交性能悬殊原因及优化

Hey there, let's dig into why your SIMD performance varies so drastically between AABB and circle intersection checks, and walk through actionable optimizations for the circle case.

1. Why the Performance Gap Exists #

First, let's break down the core reasons behind the huge speedup difference:

a) Algorithm Parallelism & Instruction Latency #

• AABB checks are SIMD-friendly: AABB intersection relies almost entirely on simple, low-latency operations: min, max, addition/subtraction, and vector comparisons. These operations are fully pipelined on Haswell (AVX2) — each can execute in 1-2 cycles, and you can chain them without stalls. With AVX2's 256-bit vectors, you process 8 float values at once, which explains the massive speedup (your numbers show ~21x, which is even better than the theoretical 8x because of reduced loop overhead and efficient memory access).
• Circle checks have inherent bottlenecks: Circle intersection involves math that's harder to vectorize efficiently:
  • Dot products & squared terms: Calculating the ray-to-center distance requires dot products (multiple multiplies + adds) and squared values. Even with FMA3 support, these operations have higher latency (~3 cycles for FMA, vs 1 for min).
  • Division/square roots: If you're computing the actual distance (not using squared comparisons), sqrtps has a latency of ~13-19 cycles on Haswell — a huge stall for the pipeline. Division (for normalizing direction vectors) is even worse (~14-24 cycles).
  • Conditional logic: Circle checks often require multiple conditions (e.g., distance ≤ radius, ray parameter t ≥ 0). Poorly handled conditions can force SIMD masks or even fall back to scalar execution, killing parallelism.

b) Memory & Data Layout Overhead #

• AABB's packed structure (BoundingBoxPack) likely aligns perfectly with SIMD memory access patterns — contiguous, aligned memory lets the CPU load vectors in a single cycle.
• For CirclePack, if you're broadcasting the single circle's center/radius to vectors inside the loop, that adds unnecessary overhead. Haswell's broadcast instructions are efficient, but repeating them per iteration wastes cycles that could be spent on actual computation.

c) .NET JIT Limitations #

While .NET Framework 4.72 supports AVX2, the JIT compiler isn't always as aggressive as C++ compilers at optimizing complex SIMD logic. It might fail to eliminate scalar fallbacks for conditional checks, or miss opportunities to merge operations into FMA instructions.

2. Optimization Strategies for Circle SIMD Intersection #

Here's how to squeeze more performance out of your circle code:

a) Eliminate High-Latency Instructions #

• Ditch square roots entirely: Compare squared distances to the squared radius instead of computing actual distances. This removes the costly sqrtps instruction entirely.
• Replace division with multiplication: If your rays aren't unit-length, precompute the inverse of the direction vector's squared length (1/(dx² + dy²)) once per ray pack, then use multiplication instead of division. Multiplication has 1/5th the latency of division on Haswell.
• Leverage FMA for dot products: Use Vector.MultiplyAdd (or let the JIT generate FMA instructions automatically) to merge multiply-add operations into a single, low-latency instruction. For example, compute the dot product ocX*dx + ocY*dy as a single FMA operation instead of two multiplies plus an add.

b) Optimize Data Layout & Precomputation #

• Pre-broadcast circle parameters: Before entering the loop, create vectors for the circle's center X/Y and squared radius (e.g., new Vector<float>(circle.Center.X)). This avoids re-broadcasting the same values in every iteration.
• Ensure aligned memory: Mark your RayPack struct with [StructLayout(LayoutKind.Sequential, Pack = 32)] to guarantee 256-bit alignment for AVX2 vectors. Unaligned memory access adds small but cumulative overhead on Haswell.

c) Vectorize Conditional Logic #

• Use mask operations instead of scalar branches: Replace if/else checks with Vector.LessThanOrEqual, Vector.GreaterThanOrEqual, and Vector.BitwiseAnd to create a mask of valid intersections. Then use Vector.ConditionalSelect to pick results based on the mask, keeping the pipeline flowing without stalls.
• Avoid scalar fallbacks: Ensure all operations stay in SIMD space. For example, instead of checking individual ray results in a loop, use Vector.Dot to count valid intersections from the mask vector.

d) Tune for Haswell's Pipeline #

• Loop unrolling: Manually unroll your loop to process 16 rays at a time (two AVX2 vectors) to reduce loop control overhead and keep the CPU's execution ports busy.
• Check generated assembly: Use BenchmarkDotNet's DisassemblyDiagnoser to verify the JIT is generating AVX2/FMA instructions. Look for vfmadd231ps, vminps, vcmpps — if you see scalar instructions like sqrtss or divss, that's a red flag.

Example Optimized Code Snippet #

Here's a simplified version of what optimized circle intersection might look like:

// Precompute circle parameters as vectors (outside loop)
Vector<float> cxVec = new Vector<float>(circle.Center.X);
Vector<float> cyVec = new Vector<float>(circle.Center.Y);
Vector<float> rSqVec = new Vector<float>(circle.Radius * circle.Radius);

// Precompute inverse squared direction (if rays aren't unit-length)
Vector<float> dirXSq = Vector.Multiply(rayPack.DirX, rayPack.DirX);
Vector<float> dirYSq = Vector.Multiply(rayPack.DirY, rayPack.DirY);
Vector<float> invDirSq = Vector.Divide(Vector<float>.One, dirXSq + dirYSq);

// Compute OC = Circle Center - Ray Origin
Vector<float> ocX = cxVec - rayPack.OriginX;
Vector<float> ocY = cyVec - rayPack.OriginY;

// Dot product of OC and ray direction (using FMA)
Vector<float> dotOcDir = Vector.MultiplyAdd(ocX, rayPack.DirX, Vector.Multiply(ocY, rayPack.DirY));

// Squared distance calculations
Vector<float> ocSq = Vector.MultiplyAdd(ocX, ocX, Vector.Multiply(ocY, ocY));
Vector<float> dotSq = Vector.Multiply(dotOcDir, dotOcDir);
Vector<float> distSq = ocSq - Vector.Multiply(dotSq, invDirSq);

// Create intersection mask (distSq <= rSq AND dotOcDir >= 0 for forward rays)
Vector<float> maskDist = Vector.LessThanOrEqual(distSq, rSqVec);
Vector<float> maskForward = Vector.GreaterThanOrEqual(dotOcDir, Vector<float>.Zero);
Vector<float> intersectMask = Vector.BitwiseAnd(maskDist, maskForward);

// Count intersections (convert mask to integer count)
int intersectCount = Vector.Dot(intersectMask, Vector<float>.One).ToInt32();

内容的提问来源于stack exchange，提问作者Willem124