SIMD扩展指令集以及C++使用示例

发表于 分类于 阅读次数： Disqus： 本文字数： 2.1k 阅读时长 ≈ 7 分钟

什么是SIMD扩展指令集

SIMD（单指令多数据）扩展指令集是一种并行计算技术，允许一条指令同时处理多个数据元素，提升数据密集型任务的执行效率。常见示例包括：

  • x86架构：MMX、SSE、AVX系列
  • ARM架构：NEON、SVE
  • PowerPC：AltiVec

核心特点：

  1. 并行处理：单指令操作多个数据（如4个浮点数同时相加）
  2. 适用场景：多媒体处理、科学计算、机器学习推理等

例如，AVX2可在一条指令中完成8个32位浮点数的加法，相比标量指令提升吞吐量。现代CPU普遍集成SIMD单元以加速向量化计算。

关键特性：

  • 数据级并行：单指令处理多个数据元素
  • 专用寄存器：不同指令集使用不同宽度寄存器
  • 数据类型：支持整数、单/双精度浮点数
  • 编译器支持：可通过内联函数、自动向量化或汇编使用

现代编译器（GCC/Clang/MSVC）提供 intrinsic 函数直接调用 SIMD 指令，无需编写汇编代码。

SIMD 指令使用示例

以下是 C++ 中使用 SIMD 指令的详细示例：

1. 基础头文件和设置

1
2
3
4
5
6
7
8
#include <iostream>
#include <immintrin.h>  // 包含所有 SIMD intrinsic
#include <algorithm>

// 对齐内存分配（重要！）
#define ALIGNED_16 __attribute__((aligned(16)))
#define ALIGNED_32 __attribute__((aligned(32)))
#define ALIGNED_64 __attribute__((aligned(64)))

2. SSE 浮点向量加法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
void sse_float_addition() {
    ALIGNED_16 float a[4] = {1.0f, 2.0f, 3.0f, 4.0f};
    ALIGNED_16 float b[4] = {5.0f, 6.0f, 7.0f, 8.0f};
    ALIGNED_16 float result[4];
    
    // 加载数据到 SSE 寄存器
    __m128 vec_a = _mm_load_ps(a);
    __m128 vec_b = _mm_load_ps(b);
    
    // SIMD 加法（一次处理4个float）
    __m128 vec_result = _mm_add_ps(vec_a, vec_b);
    
    // 存储结果
    _mm_store_ps(result, vec_result);
    
    std::cout << "SSE Float Addition: ";
    for(int i = 0; i < 4; i++) {
        std::cout << result[i] << " ";
    }
    std::cout << std::endl; // 输出: 6 8 10 12
}

3. AVX 双精度向量运算

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
void avx_double_operations() {
    ALIGNED_32 double a[4] = {1.0, 2.0, 3.0, 4.0};
    ALIGNED_32 double b[4] = {5.0, 6.0, 7.0, 8.0};
    ALIGNED_32 double result[4];
    
    __m256d vec_a = _mm256_load_pd(a);
    __m256d vec_b = _mm256_load_pd(b);
    
    // 多种运算
    __m256d add_result = _mm256_add_pd(vec_a, vec_b);
    __m256d mul_result = _mm256_mul_pd(vec_a, vec_b);
    __m256d sub_result = _mm256_sub_pd(vec_b, vec_a);
    
    _mm256_store_pd(result, add_result);
    std::cout << "AVX Double Addition: ";
    for(int i = 0; i < 4; i++) {
        std::cout << result[i] << " ";
    }
    std::cout << std::endl;
}

4. 整数向量处理

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
void sse_integer_operations() {
    ALIGNED_16 int32_t a[4] = {10, 20, 30, 40};
    ALIGNED_16 int32_t b[4] = {5, 6, 7, 8};
    ALIGNED_16 int32_t result[4];
    
    __m128i vec_a = _mm_load_si128((__m128i*)a);
    __m128i vec_b = _mm_load_si128((__m128i*)b);
    
    // 整数加法
    __m128i add_result = _mm_add_epi32(vec_a, vec_b);
    // 整数乘法（注意：SSE4.1）
    __m128i mul_result = _mm_mullo_epi32(vec_a, vec_b);
    
    _mm_store_si128((__m128i*)result, add_result);
    std::cout << "SSE Integer Addition: ";
    for(int i = 0; i < 4; i++) {
        std::cout << result[i] << " ";
    }
    std::cout << std::endl;
}

5. 向量点积优化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
float sse_dot_product(const float* a, const float* b, int n) {
    __m128 sum = _mm_setzero_ps();
    
    for(int i = 0; i < n; i += 4) {
        __m128 vec_a = _mm_load_ps(a + i);
        __m128 vec_b = _mm_load_ps(b + i);
        
        // 乘积累加：sum += a * b
        __m128 product = _mm_mul_ps(vec_a, vec_b);
        sum = _mm_add_ps(sum, product);
    }
    
    // 水平求和：sum[0] + sum[1] + sum[2] + sum[3]
    __m128 shuf = _mm_shuffle_ps(sum, sum, _MM_SHUFFLE(2, 3, 0, 1));
    __m128 sums = _mm_add_ps(sum, shuf);
    shuf = _mm_movehl_ps(shuf, sums);
    sums = _mm_add_ss(sums, shuf);
    
    float result;
    _mm_store_ss(&result, sums);
    return result;
}

6. AVX2 整数向量化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
void avx2_integer_operations() {
    ALIGNED_32 int32_t a[8] = {1, 2, 3, 4, 5, 6, 7, 8};
    ALIGNED_32 int32_t b[8] = {8, 7, 6, 5, 4, 3, 2, 1};
    ALIGNED_32 int32_t result[8];
    
    __m256i vec_a = _mm256_load_si256((__m256i*)a);
    __m256i vec_b = _mm256_load_si256((__m256i*)b);
    
    // AVX2 整数运算
    __m256i add_result = _mm256_add_epi32(vec_a, vec_b);
    __m256i sub_result = _mm256_sub_epi32(vec_a, vec_b);
    __m256i max_result = _mm256_max_epi32(vec_a, vec_b);
    
    _mm256_store_si256((__m256i*)result, add_result);
    std::cout << "AVX2 Integer Addition: ";
    for(int i = 0; i < 8; i++) {
        std::cout << result[i] << " ";
    }
    std::cout << std::endl;
}

7. 条件选择和混合操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
void sse_conditional_operations() {
    ALIGNED_16 float a[4] = {1.0f, 2.0f, 3.0f, 4.0f};
    ALIGNED_16 float b[4] = {5.0f, 6.0f, 7.0f, 8.0f};
    ALIGNED_16 float mask_val[4] = {0.0f, 2.5f, 3.5f, 0.0f};
    ALIGNED_16 float result[4];
    
    __m128 vec_a = _mm_load_ps(a);
    __m128 vec_b = _mm_load_ps(b);
    __m128 mask = _mm_load_ps(mask_val);
    
    // 创建比较掩码：如果 a > mask 则全1，否则全0
    __m128 cmp_mask = _mm_cmpgt_ps(vec_a, mask);
    
    // 根据掩码选择：mask为真选a，否则选b
    __m128 blended = _mm_blendv_ps(vec_b, vec_a, cmp_mask);
    
    _mm_store_ps(result, blended);
    std::cout << "SSE Conditional Blend: ";
    for(int i = 0; i < 4; i++) {
        std::cout << result[i] << " ";
    }
    std::cout << std::endl;
}

8. 性能测试示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
#include <chrono>

void performance_comparison() {
    const int size = 1000000;
    ALIGNED_16 float* a = (float*)_mm_malloc(size * sizeof(float), 16);
    ALIGNED_16 float* b = (float*)_mm_malloc(size * sizeof(float), 16);
    ALIGNED_16 float* result = (float*)_mm_malloc(size * sizeof(float), 16);
    
    // 初始化数据
    for(int i = 0; i < size; i++) {
        a[i] = i * 0.1f;
        b[i] = i * 0.2f;
    }
    
    // 标量版本
    auto start = std::chrono::high_resolution_clock::now();
    for(int i = 0; i < size; i++) {
        result[i] = a[i] + b[i];
    }
    auto end = std::chrono::high_resolution_clock::now();
    auto scalar_time = std::chrono::duration_cast<std::chrono::microseconds>(end - start);
    
    // SIMD 版本
    start = std::chrono::high_resolution_clock::now();
    for(int i = 0; i < size; i += 4) {
        __m128 vec_a = _mm_load_ps(a + i);
        __m128 vec_b = _mm_load_ps(b + i);
        __m128 vec_result = _mm_add_ps(vec_a, vec_b);
        _mm_store_ps(result + i, vec_result);
    }
    end = std::chrono::high_resolution_clock::now();
    auto simd_time = std::chrono::duration_cast<std::chrono::microseconds>(end - start);
    
    std::cout << "Scalar time: " << scalar_time.count() << " μs\n";
    std::cout << "SIMD time: " << simd_time.count() << " μs\n";
    std::cout << "Speedup: " << (double)scalar_time.count() / simd_time.count() << "x\n";
    
    _mm_free(a);
    _mm_free(b);
    _mm_free(result);
}

9. 主函数调用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
int main() {
    std::cout << "=== SIMD Instruction Examples ===\n" << std::endl;
    
    sse_float_addition();
    avx_double_operations();
    sse_integer_operations();
    avx2_integer_operations();
    sse_conditional_operations();
    
    // 点积示例
    ALIGNED_16 float vec1[4] = {1.0f, 2.0f, 3.0f, 4.0f};
    ALIGNED_16 float vec2[4] = {2.0f, 3.0f, 4.0f, 5.0f};
    float dot = sse_dot_product(vec1, vec2, 4);
    std::cout << "SSE Dot Product: " << dot << std::endl;
    
    performance_comparison();
    
    return 0;
}

编译命令

1
2
3
4
5
6
7
8
# 基础 SSE 支持
g++ -msse -msse2 -O3 simd_example.cpp -o simd_example

# 包含 AVX 和 AVX2
g++ -mavx -mavx2 -O3 simd_example.cpp -o simd_example

# 检测 CPU 特性
g++ -march=native -O3 simd_example.cpp -o simd_example

关键要点

  1. 内存对齐：SIMD 操作需要16/32/64字节对齐的内存
  2. 数据布局：连续内存访问模式性能最佳
  3. 指令集检测：运行时检查 CPU 支持的指令集
  4. 编译器优化：使用 -O3 和架构特定标志
  5. 避免函数调用：在热循环中尽量减少函数调用

这些示例展示了 SIMD 在数值计算、信号处理、图像处理等领域的强大性能优势。

AVX和SSE的区别

主要区别：

  1. 指令集支持范围不同

    • -msse -msse2：仅支持 SSE/SSE2 指令（128位寄存器）
    • -mavx -mavx2：支持 AVX/AVX2 指令（256位寄存器），自动包含 SSE/SSE2

  2. 寄存器宽度不同

    • SSE：128位，一次处理4个float或2个double
    • AVX：256位，一次处理8个float或4个double

  3. 性能差异

    • AVX2 相比 SSE 理论上有2倍的吞吐量提升
    • 但需要CPU硬件支持（Haswell架构及以后）

  4. 兼容性

    • SSE/SSE2：几乎所有现代x86 CPU都支持
    • AVX/AVX2：需要较新的CPU（2011年后的Intel，2013年后的AMD）

推荐做法：使用 -march=native 自动检测并启用当前CPU支持的所有指令集。

1
2
3
4
5
6
7
8
9
10
```cpp
#ifdef __AVX__
void avx_double_operations() {
    // AVX 代码
}
#else
void avx_double_operations() {
    std::cout << "AVX not supported" << std::endl;
}
#endif
1
2
3
4
5
# 只编译 SSE 版本（移除 AVX 函数）
g++ -msse -msse2 -O3 1.cpp -o sse_example

# 或者编译 AVX 版本
g++ -mavx -mavx2 -O3 1.cpp -o avx_example

关键原则：编译选项必须与代码中使用的 SIMD 指令集匹配。

sse和AVX的区别

SSE 与 AVX 核心区别对比

特性 SSE (Streaming SIMD Extensions) AVX (Advanced Vector Extensions)
发布时间 1999年 (SSE) 2011年 (AVX)
寄存器宽度 128位 256位
数据并行度 4个float / 2个double 8个float / 4个double
寄存器数量 8个 (xmm0-xmm7) 16个 (ymm0-ymm15)
指令格式 2操作数: dst = op(dst, src) 3操作数: dst = op(src1, src2)
性能提升 2-4倍 4-8倍 (相比标量)

具体差异示例

1. 寄存器类型

1
2
3
4
5
6
7
8
9
// SSE (128位)
__m128  sse_float;   // 4个float
__m128d sse_double;  // 2个double  
__m128i sse_int;     // 各种整数

// AVX (256位)
__m256  avx_float;   // 8个float
__m256d avx_double;  // 4个double
__m256i avx_int;     // 各种整数

2. 指令前缀

1
2
3
4
5
6
7
8
9
// SSE 指令
_mm_add_ps()    // 4个float相加
_mm_add_pd()    // 2个double相加
_mm_load_ps()   // 加载4个float

// AVX 指令  
_mm256_add_ps() // 8个float相加
_mm256_add_pd() // 4个double相加
_mm256_load_ps() // 加载8个float

3. 实际性能对比

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// SSE: 一次处理4个float
void sse_vector_add(float* a, float* b, float* out, int n) {
    for(int i = 0; i < n; i += 4) {
        __m128 va = _mm_load_ps(a + i);
        __m128 vb = _mm_load_ps(b + i);
        __m128 vc = _mm_add_ps(va, vb);
        _mm_store_ps(out + i, vc);
    }
}

// AVX: 一次处理8个float  
void avx_vector_add(float* a, float* b, float* out, int n) {
    for(int i = 0; i < n; i += 8) {
        __m256 va = _mm256_load_ps(a + i);
        __m256 vb = _mm256_load_ps(b + i);
        __m256 vc = _mm256_add_ps(va, vb);
        _mm256_store_ps(out + i, vc);
    }
}

4. 内存对齐要求

1
2
3
4
5
6
7
// SSE: 16字节对齐
#define ALIGNED_16 __attribute__((aligned(16)))
ALIGNED_16 float sse_data[4];

// AVX: 32字节对齐  
#define ALIGNED_32 __attribute__((aligned(32)))
ALIGNED_32 float avx_data[8];

5. 编译器标志

1
2
3
4
5
6
7
8
# SSE 支持
g++ -msse -msse2 -msse3 -msse4.1 -msse4.2

# AVX 支持
g++ -mavx -mavx2

# 自动检测最佳指令集
g++ -march=native

选择建议

  • SSE: 兼容性要求高，老硬件支持
  • AVX: 性能优先，现代CPU（2011年后）
  • 最佳实践: 使用 -march=native 让编译器自动选择

总结: AVX 是 SSE 的扩展，提供更宽的寄存器和更优的指令格式，性能更好但需要更新的硬件支持。