向量双精度双浮点数运算：能否用SIMD实现带分支的Double-Double操作？

Great question—this is a common pain point when trying to accelerate extended-precision math with modern CPU vectorization. Let's unpack this:

First, let's address the core concern: yes, those conditional branches in scalar Double-Double implementations are a problem for SIMD, but they don't make vectorization impossible.

Why Branches Block SIMD (At First Glance) #

SIMD relies on executing the same instruction across all elements in a vector simultaneously. When you hit a conditional branch (like an if/else), the CPU has to handle divergent execution paths for different vector elements—this either forces the vector to split (killing performance) or fall back to scalar execution. The Double-Double code you referenced uses branches to handle things like carry propagation in addition, or adjusting high/low word values after multiplication, which look like showstoppers at first.

Workarounds to Vectorize Double-Double Operations #

The key is to eliminate those branches by replacing them with branchless arithmetic or vector mask operations:

• Mask-based selection: Instead of an if statement, compute both possible outcomes for every vector element, then use a vector mask (generated from the original branch condition) to select the correct result for each element. Modern SIMD instruction sets (like AVX-512, NEON) have dedicated blend/select instructions (e.g., vpblendvpd for AVX) that do this efficiently without branching.
• FMA instruction leverage: Fusion Multiply-Add (FMA) instructions compute a*b + c with full intermediate precision, which is perfect for Double-Double operations. FMA lets you avoid some of the conditional checks needed in scalar implementations, since it preserves more precision through intermediate steps, reducing the need for corrective branches.
• Predicated execution: For cases where most vector elements follow the same branch path, you can use predication to execute both paths conditionally, but this is less efficient than full branchless code if branch divergence is high.

Adapting the Scalar Double-Double Code #

The Julia implementation you looked at is written for clarity in scalar code, but it can be refactored for SIMD. For example:

• Instead of checking if a carry needs to be propagated with an if, compute the carry value as a vector, create a mask where the carry is non-zero, then blend the adjusted high/low words using that mask.
• Replace scalar conditional adjustments with vectorized arithmetic operations that handle all cases at once, no branches required.

Real-World Precedents #

This isn't just theoretical—several numerical computing libraries already implement vectorized Double-Double operations using these techniques. The performance gains are significant, especially when working with large arrays of Double-Double values, since you're leveraging the full width of your CPU's vector units.

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