如何利用SIMD intrinsics处理长度非向量宽度倍数的数组？

对于长度不是AVX 256位向量容量倍数的数组（比如你提到的53个32位整数），分块处理完整向量+手动收尾剩余元素是最通用、最可靠的解决方案，也是工业界代码中最常见的实现方式。当然，利用AVX2掩码指令也能优化边界处理，下面具体说明：

一、基础实现：分块+收尾 #

以两个std::vector<int32_t>的加法为例，核心步骤如下：

1. 计算完整AVX向量块的数量：53 ÷ 8 = 6，对应前48个元素（6×8）；
2. 用AVX intrinsics批量处理这些完整块；
3. 手动遍历处理剩余的5个元素。

代码示例：

#include <immintrin.h>
#include <vector>

void avx_add_int32(const std::vector<int32_t>& a, const std::vector<int32_t>& b, std::vector<int32_t>& result) {
    const size_t n = a.size();
    result.resize(n);
    
    // 处理完整的AVX向量块
    size_t i = 0;
    for (; i <= n - 8; i += 8) {
        __m256i vec_a = _mm256_loadu_si256(reinterpret_cast<const __m256i*>(&a[i]));
        __m256i vec_b = _mm256_loadu_si256(reinterpret_cast<const __m256i*>(&b[i]));
        __m256i vec_res = _mm256_add_epi32(vec_a, vec_b);
        _mm256_storeu_si256(reinterpret_cast<__m256i*>(&result[i]), vec_res);
    }
    
    // 处理剩余元素
    for (; i < n; ++i) {
        result[i] = a[i] + b[i];
    }
}

注：这里用_mm256_loadu_si256/_mm256_storeu_si256是为了兼容非对齐内存；如果你的vector内存是32字节对齐的，换成_mm256_load_si256/_mm256_store_si256能获得更好性能。

二、优化实现：利用AVX2掩码指令简化边界处理 #

如果你的CPU支持AVX2（大部分现代x86 CPU都支持），可以用掩码加载/存储指令避免单独的收尾循环，减少分支开销，让代码更紧凑：

代码示例：

#include <immintrin.h>
#include <vector>

void avx2_add_int32(const std::vector<int32_t>& a, const std::vector<int32_t>& b, std::vector<int32_t>& result) {
    const size_t n = a.size();
    result.resize(n);
    
    size_t i = 0;
    // 处理完整块
    for (; i <= n - 8; i += 8) {
        __m256i vec_a = _mm256_loadu_si256(reinterpret_cast<const __m256i*>(&a[i]));
        __m256i vec_b = _mm256_loadu_si256(reinterpret_cast<const __m256i*>(&b[i]));
        __m256i vec_res = _mm256_add_epi32(vec_a, vec_b);
        _mm256_storeu_si256(reinterpret_cast<__m256i*>(&result[i]), vec_res);
    }
    
    // 用掩码处理剩余元素
    if (i < n) {
        // 创建掩码：仅对剩余的(n - i)个元素生效，其余位设为0
        __m256i mask = _mm256_set_epi32(
            (i+7 < n) ? 0xFFFFFFFF : 0,
            (i+6 < n) ? 0xFFFFFFFF : 0,
            (i+5 < n) ? 0xFFFFFFFF : 0,
            (i+4 < n) ? 0xFFFFFFFF : 0,
            (i+3 < n) ? 0xFFFFFFFF : 0,
            (i+2 < n) ? 0xFFFFFFFF : 0,
            (i+1 < n) ? 0xFFFFFFFF : 0,
            (i+0 < n) ? 0xFFFFFFFF : 0
        );
        
        __m256i vec_a = _mm256_maskload_epi32(&a[i], mask);
        __m256i vec_b = _mm256_maskload_epi32(&b[i], mask);
        __m256i vec_res = _mm256_add_epi32(vec_a, vec_b);
        _mm256_maskstore_epi32(&result[i], mask, vec_res);
    }
}

这种方式无需单独循环，直接用掩码指令一次性处理剩余元素，能充分利用CPU的SIMD单元。

三、额外性能优化点 #

1. 内存对齐：确保输入输出vector的内存是32字节对齐的。可以用std::aligned_alloc分配内存，或者在C++17及以后使用自定义对齐分配器：

   // 用aligned_alloc分配对齐内存
   int32_t* a = static_cast<int32_t*>(aligned_alloc(32, n * sizeof(int32_t)));
   

   对齐内存能让_mm256_load_si256这类指令发挥最大性能，避免内存访问的额外开销。

2. 循环展开：把主循环展开为处理2个或4个向量的块，减少循环控制的分支开销，比如：

   for (; i <= n - 16; i += 16) {
       // 一次性处理两个AVX向量
       __m256i vec_a1 = _mm256_loadu_si256(reinterpret_cast<const __m256i*>(&a[i]));
       __m256i vec_b1 = _mm256_loadu_si256(reinterpret_cast<const __m256i*>(&b[i]));
       __m256i vec_res1 = _mm256_add_epi32(vec_a1, vec_b1);
       
       __m256i vec_a2 = _mm256_loadu_si256(reinterpret_cast<const __m256i*>(&a[i+8]));
       __m256i vec_b2 = _mm256_loadu_si256(reinterpret_cast<const __m256i*>(&b[i+8]));
       __m256i vec_res2 = _mm256_add_epi32(vec_a2, vec_b2);
       
       _mm256_storeu_si256(reinterpret_cast<__m256i*>(&result[i]), vec_res1);
       _mm256_storeu_si256(reinterpret_cast<__m256i*>(&result[i+8]), vec_res2);
   }
   

   这种方式能提升CPU流水线的利用率，减少循环迭代次数。

总结 #

• 基础的分块处理+收尾是兼容性最好的通用方案，必须掌握；
• AVX2掩码指令能简化边界处理，减少分支，提升代码简洁度；
• 内存对齐和循环展开是进一步提升性能的关键手段。

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