如何在无性能损失的前提下抽象SIMD代码以支持不同数据类型

针对你的需求，这里有两种无性能损失的抽象方案，分别适配C和C++场景，核心都是在编译期完成类型与架构的映射，完全避免运行时开销：

方案1：C语言类型泛型宏 + 架构条件编译 #

这种方式保持纯C兼容性，宏会在编译期直接展开为对应架构的SIMD指令，和手写的原生SIMD代码性能完全一致。

实现思路 #

先为不同数据类型、不同架构定义对应的SIMD寄存器类型、加载/存储/运算指令，再通过泛型宏封装通用的加法逻辑：

#include <stdint.h>

// --------------------------
// 架构与SIMD指令映射
// --------------------------
#ifdef __x86_64__
// x86 AVX 256位指令集映射
#define SIMD_WIDTH_FLOAT 8    // 256位寄存器可容纳8个float
#define SIMD_REG_FLOAT __m256
#define SIMD_LOAD_FLOAT _mm256_load_ps
#define SIMD_ADD_FLOAT _mm256_add_ps
#define SIMD_STORE_FLOAT _mm256_store_ps

#define SIMD_WIDTH_DOUBLE 4   // 256位寄存器可容纳4个double
#define SIMD_REG_DOUBLE __m256d
#define SIMD_LOAD_DOUBLE _mm256_load_pd
#define SIMD_ADD_DOUBLE _mm256_add_pd
#define SIMD_STORE_DOUBLE _mm256_store_pd

#define SIMD_WIDTH_INT32 8    // 256位寄存器可容纳8个int32_t
#define SIMD_REG_INT32 __m256i
#define SIMD_LOAD_INT32 _mm256_load_si256
#define SIMD_ADD_INT32 _mm256_add_epi32
#define SIMD_STORE_INT32 _mm256_store_si256

#elif __aarch64__
// ARM NEON 128位指令集映射
#define SIMD_WIDTH_FLOAT 4    // 128位寄存器可容纳4个float
#define SIMD_REG_FLOAT float32x4_t
#define SIMD_LOAD_FLOAT vld1q_f32
#define SIMD_ADD_FLOAT vaddq_f32
#define SIMD_STORE_FLOAT vst1q_f32

#define SIMD_WIDTH_INT32 4    // 128位寄存器可容纳4个int32_t
#define SIMD_REG_INT32 int32x4_t
#define SIMD_LOAD_INT32 vld1q_s32
#define SIMD_ADD_INT32 vaddq_s32
#define SIMD_STORE_INT32 vst1q_s32
#endif

// --------------------------
// 泛型SIMD加法宏
// --------------------------
#define SIMD_ADD(type, len, a, b, dst) do { \
    int k = 0; \
    const int simd_width = SIMD_WIDTH_##type; \
    /* 处理SIMD批量计算 */ \
    for (; k + simd_width <= len; k += simd_width, a += simd_width, b += simd_width, dst += simd_width) { \
        SIMD_REG_##type x = SIMD_LOAD_##type(a); \
        SIMD_REG_##type y = SIMD_LOAD_##type(b); \
        SIMD_REG_##type z = SIMD_ADD_##type(x, y); \
        SIMD_STORE_##type(dst, z); \
    } \
    /* 处理剩余不足SIMD宽度的元素 */ \
    for (; k < len; k++) { \
        dst[k] = a[k] + b[k]; \
    } \
} while(0)

使用示例 #

// 浮点数组加法
float a_float[100], b_float[100], dst_float[100];
SIMD_ADD(FLOAT, 100, a_float, b_float, dst_float);

// 32位整型数组加法
int32_t a_int[100], b_int[100], dst_int[100];
SIMD_ADD(INT32, 100, a_int, b_int, dst_int);

方案2：C++模板 + 模板特化 #

如果使用C++开发，模板特化是更优雅的选择，编译器会在编译期自动匹配对应类型的SIMD实现，同样无运行时开销。

实现思路 #

先定义通用的标量加法模板作为 fallback，再针对不同数据类型、不同架构做模板特化：

#include <cstdint>

// 通用标量加法模板（作为 fallback）
template<typename T>
void simd_add(const T* a, const T* b, T* dst, int len) {
    for (int i = 0; i < len; i++) {
        dst[i] = a[i] + b[i];
    }
}

// --------------------------
// x86 AVX 特化实现
// --------------------------
#ifdef __x86_64__
#include <immintrin.h>

// float类型的AVX特化
template<>
void simd_add<float>(const float* a, const float* b, float* dst, int len) {
    int k = 0;
    const int simd_width = 8;
    for (; k + simd_width <= len; k += simd_width, a += simd_width, b += simd_width, dst += simd_width) {
        __m256 x = _mm256_load_ps(a);
        __m256 y = _mm256_load_ps(b);
        __m256 z = _mm256_add_ps(x, y);
        _mm256_store_ps(dst, z);
    }
    // 处理剩余元素
    for (; k < len; k++) {
        dst[k] = a[k] + b[k];
    }
}

// double类型的AVX特化
template<>
void simd_add<double>(const double* a, const double* b, double* dst, int len) {
    int k = 0;
    const int simd_width = 4;
    for (; k + simd_width <= len; k += simd_width, a += simd_width, b += simd_width, dst += simd_width) {
        __m256d x = _mm256_load_pd(a);
        __m256d y = _mm256_load_pd(b);
        __m256d z = _mm256_add_pd(x, y);
        _mm256_store_pd(dst, z);
    }
    for (; k < len; k++) {
        dst[k] = a[k] + b[k];
    }
}
#endif

// --------------------------
// ARM NEON 特化实现
// --------------------------
#ifdef __aarch64__
#include <arm_neon.h>

// float类型的NEON特化
template<>
void simd_add<float>(const float* a, const float* b, float* dst, int len) {
    int k = 0;
    const int simd_width = 4;
    for (; k + simd_width <= len; k += simd_width, a += simd_width, b += simd_width, dst += simd_width) {
        float32x4_t x = vld1q_f32(a);
        float32x4_t y = vld1q_f32(b);
        float32x4_t z = vaddq_f32(x, y);
        vst1q_f32(dst, z);
    }
    for (; k < len; k++) {
        dst[k] = a[k] + b[k];
    }
}
#endif

使用示例 #

float a_float[100], b_float[100], dst_float[100];
simd_add(a_float, b_float, dst_float, 100);

double a_double[100], b_double[100], dst_double[100];
simd_add(a_double, b_double, dst_double, 100);

关键注意事项 #

1. 内存对齐：SIMD指令通常要求内存地址按寄存器宽度对齐（比如x86 AVX要求32字节对齐，ARM NEON要求16字节对齐），可以用_mm_malloc（x86）、posix_memalign或C++17的std::aligned_alloc分配对齐内存；如果无法保证对齐，要改用非对齐加载指令（比如x86的_mm256_loadu_ps）。
2. 编译器宏适配：不同编译器的架构检测宏略有差异，比如MSVC用_M_X64标识x86_64架构，需要根据实际使用的编译器调整条件编译逻辑。
3. 剩余元素处理：必须补上对不足SIMD宽度的剩余元素的标量处理，否则会遗漏部分数据。

内容的提问来源于stack exchange，提问作者Karim Mohamed Hasebou