请求优化基于SIMD的双精度浮点阈值运算代码以提升性能

Great question! Since your function gets called extremely often even with small arrays, leveraging SIMD is absolutely the right move here—branch mispredictions and scalar loop overhead add up quickly with high call counts. Let's break down how to optimize this with AVX2 (widely supported on modern x86 CPUs, which handles 4 double-precision values per 256-bit vector):

Step 1: Use AVX2 Intrinsics to Eliminate Branches #

Instead of scalar conditional checks, we can use SIMD's vectorized selection instructions to compute multiple elements at once. Here's the optimized implementation:

#include <immintrin.h>
#include <stddef.h>

void func_simd(const double* left, const double* right, double* res, const size_t size, const double th, const double drop) {
    // Load threshold and drop values into vector registers (broadcast to all 4 elements)
    __m256d th_vec = _mm256_set1_pd(th);
    __m256d drop_vec = _mm256_set1_pd(drop);
    
    size_t i = 0;
    // Process 4 elements at a time using AVX2
    for (; i + 3 < size; i += 4) {
        // Load vectors from input arrays (use aligned loads if arrays are properly aligned!)
        __m256d left_vec = _mm256_loadu_pd(left + i);
        __m256d right_vec = _mm256_loadu_pd(right + i);
        
        // Compute mask: 1s where right[i] >= th, 0s otherwise
        __m256d mask = _mm256_cmp_pd(right_vec, th_vec, _CMP_GE_OQ);
        
        // Compute left[i] - drop for all elements
        __m256d left_minus_drop = _mm256_sub_pd(left_vec, drop_vec);
        
        // Select values based on mask: use left_vec where mask is 1, left_minus_drop where 0
        __m256d res_vec = _mm256_blendv_pd(left_minus_drop, left_vec, mask);
        
        // Store result back to res array
        _mm256_storeu_pd(res + i, res_vec);
    }
    
    // Handle remaining elements (1-3) with scalar code
    for (; i < size; ++i) {
        res[i] = right[i] >= th ? left[i] : (left[i] - drop);
    }
}

Step 2: Optimize Memory Access (Critical for Small Arrays) #

• Align your arrays: If you control the allocation of left, right, and res, declare them with alignas(32) (since AVX2 uses 256-bit registers). Then replace _mm256_loadu_pd/_mm256_storeu_pd with _mm256_load_pd/_mm256_store_pd—aligned accesses avoid alignment penalties and run faster.
  Example:

  alignas(32) double left[256], right[256], res[256];
  

Step 3: Compiler Flags to Unlock Performance #

When compiling, use these flags to enable AVX2 and full optimizations:

• GCC/Clang: -O3 -mavx2
• MSVC: /O2 /arch:AVX2

Why This Works Better Than Loop Unrolling #

Loop unrolling reduces loop overhead but still processes elements one by one with scalar conditionals. SIMD:

• Eliminates branch mispredictions entirely (we use a vector mask instead of if/else branches)
• Processes 4 elements per CPU cycle (instead of 1 with scalar code)
• Reduces total loop iterations by 75% for your array sizes (128 elements become 32 vector iterations, 256 becomes 64 vector iterations)

Testing Performance #

Since your function is called very frequently, benchmark both the original and optimized versions with your actual call pattern—you should see a 3-4x speedup (depending on CPU and alignment).

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