AVX2双精度对数函数比常规C/C++版本慢14倍的问题排查

Let's break down why your AVX2 log function is running 14x slower than the scalar version, and why removing _mm256_sub_pd suddenly gives you a 3x speedup—especially since your AVX ports of sincos and exp worked so well.

Core Problem: Unnecessary Float-Double Conversion Overhead #

The biggest performance killer here is your workaround for handling double-precision exponents. Since AVX2 lacks _mm256_cvtepi64_pd (that's an AVX-512 instruction), you're converting 256-bit doubles to 128-bit floats to process exponents, then converting back. This is catastrophic for AVX2 throughput because:

• Cross-width conversions (256-bit ↔ 128-bit) have high latency and cannot be pipelined efficiently with other AVX2 instructions.
• You're throwing away AVX2's 256-bit parallelism by narrowing your data to 128 bits, which negates most of the benefit of using SIMD in the first place.

When you comment out all _mm256_sub_pd calls, your compiler likely detects that the expensive float-double conversion chain has no meaningful impact on the final result (since the subtractions were part of the exponent adjustment logic) and optimizes away most of that costly code path. That's why you suddenly see a 3x speedup—you're effectively skipping the worst part of the implementation.

Secondary Issue: Long Dependency Chains #

The _mm256_sub_pd instructions you removed were part of a long dependency chain tied to the exponent conversion logic. Each subtraction waited on the result of the previous conversion or arithmetic operation, preventing the CPU from overlapping instruction execution in the pipeline. This made the conversion bottleneck even more noticeable, as the CPU couldn't do useful work while waiting for the slow cross-width operations to finish.

In contrast, your sincos and exp AVX implementations probably don't require this float-double detour—they handle exponents or angles directly with 256-bit double-precision instructions, keeping the dependency chains short and the pipeline full.

Fixes to Restore AVX2 Performance #

Here's how to rewrite the exponent handling to avoid float-double conversions and get back the 3-5x speedup you expect:

1. Process Double Exponents with AVX2 Integer Instructions #

Instead of converting to floats, use AVX2's integer operations to extract and adjust the double-precision exponent directly:

// Extract exponent bits from double (AVX2-compatible)
__m256i x_bits = _mm256_castpd_si256(x);
__m256i exp_bits = _mm256_srli_epi64(x_bits, 52); // Shift to isolate 11-bit exponent
exp_bits = _mm256_and_si256(exp_bits, _mm256_set1_epi64x(0x7FF)); // Mask out exponent field
__m256i exp_bias = _mm256_set1_epi64x(0x3FF); // Double-precision exponent bias
exp_bits = _mm256_sub_epi64(exp_bits, exp_bias);

// Convert 64-bit exponent integers to doubles (AVX2 workaround)
__m256i exp_low = _mm256_castsi256_si128(exp_bits);
__m256i exp_high = _mm256_extracti128_si256(exp_bits, 1);
__m256d e_low = _mm256_cvtepi32_pd(_mm_cvtepi64_epi32(exp_low));
__m256d e_high = _mm256_cvtepi32_pd(_mm_cvtepi64_epi32(exp_high));
__m256d e = _mm256_permute2f128_pd(e_low, e_high, 0x20); // Combine back to 256-bit double

This keeps all operations in 256-bit width, eliminating the cross-conversion overhead entirely.

2. Optimize Dependency Chains #

Rearrange your instruction order to overlap arithmetic operations (multiplies, adds) with logical operations (masks, shifts). For example, start computing the polynomial approximation while handling the exponent adjustment—this lets the CPU pipeline work on multiple parts of the computation at once.

3. Use Safe Constant Loading #

Replace direct pointer casts like *(__m256d*)_pd_1 with explicit AVX2 load instructions:

__m256d one = _mm256_load_pd(_pd_1);

This is safer and helps the compiler optimize memory access patterns.

Final Notes #

Once you fix the exponent handling to avoid float-double conversions, you can reintroduce the _mm256_sub_pd instructions without the massive performance hit. The key difference will be that the subtractions now operate on 256-bit double data with short dependency chains, allowing the CPU to execute them in parallel with other instructions.

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