1
#include <immintrin.h>
2

3
// SSE: 4 个浮点数同时加法
4
__m128 a = _mm_load_ps(src);           // 加载 4 个 float
5
__m128 b = _mm_set1_ps(2.0f);         // 广播 2.0 到 4 个位置
6
__m128 c = _mm_mul_ps(a, b);          // 同时乘法
7
_mm_store_ps(dst, c);                 // 存储 4 个 float

1
// AVX: 8 个浮点数同时加法
2
__m256 a = _mm256_load_ps(src);        // 加载 8 个 float
3
__m256 b = _mm256_set1_ps(2.0f);      // 广播
4
__m256 c = _mm256_mul_ps(a, b);       // 同时乘法
5
_mm256_store_ps(dst, c);              // 存储 8 个 float
6

7
// AVX2: 8 个 32 位整数同时加法
8
__m256i a = _mm256_load_si256((__m256i*)src);
9
__m256i b = _mm256_set1_epi32(1);
10
__m256i c = _mm256_add_epi32(a, b);
11
_mm256_store_si256((__m256i*)dst, c);

1
// AVX-512: 16 个浮点数 + 掩码操作
2
__m512 a = _mm512_load_ps(src);
3
__m512 b = _mm512_set1_ps(2.0f);
4
__m512 c = _mm512_mul_ps(a, b);
5

6
// 掩码操作：只处理满足条件的元素
7
__mmask16 mask = _mm512_cmp_ps_mask(a, _mm512_setzero_ps(), _MM_CMPINT_GT);
8
// mask 的每一位表示对应元素是否 > 0
9
__m512 d = _mm512_mask_mul_ps(c, mask, a, b);  // 只对 mask=1 的元素执行乘法
10
_mm512_store_ps(dst, d);

1
#include <arm_neon.h>
2

3
// NEON: 4 个浮点数同时乘法
4
float32x4_t a = vld1q_f32(src);        // 加载 4 个 float
5
float32x4_t b = vdupq_n_f32(2.0f);    // 广播
6
float32x4_t c = vmulq_f32(a, b);      // 同时乘法
7
vst1q_f32(dst, c);                     // 存储 4 个 float
8

9
// NEON: 条件选择
10
uint32x4_t mask = vcgtq_f32(a, vdupq_n_f32(0.0f));  // a > 0 ?
11
float32x4_t d = vbslq_f32(mask, c, a);  // mask ? c : a

1
// 阻碍向量化的代码
2
void add_arrays(float *a, float *b, float *c, int n) {
3
    for (int i = 0; i < n; i++) {
4
        c[i] = a[i] + b[i];  // 编译器不知道 a/b/c 是否重叠
5
    }
6
}
7

8
// 使用 restrict 告知编译器指针不重叠
9
void add_arrays(float *restrict a, float *restrict b,
10
                float *restrict c, int n) {
11
    for (int i = 0; i < n; i++) {
12
        c[i] = a[i] + b[i];  // 编译器可以安全向量化
13
    }
14
}
15

16
// 使用编译器提示
17
#pragma GCC ivdep              // 告知编译器无依赖
18
#pragma clang loop vectorize(enable)  // Clang 专用
19
for (int i = 0; i < n; i++) {
20
    c[i] = a[i] + b[i];
21
}

1
# GCC: 查看向量化报告
2
gcc -O3 -ftree-vectorize -fopt-info-vec-optimized your_code.c
3

4
# Clang: 查看向量化报告
5
clang -O3 -Rpass=loop-vectorize your_code.c
6

7
# 查看生成的 SIMD 指令
8
objdump -d your_program | grep -E "vmul|vadd|movaps|vmovaps"

1
// 对齐分配
2
float *arr = aligned_alloc(32, N * sizeof(float));  // AVX: 32 字节对齐
3
float *arr512 = aligned_alloc(64, N * sizeof(float));  // AVX-512: 64 字节对齐
4

5
// 对齐加载 vs 非对齐加载
6
__m256 a = _mm256_load_ps(aligned_ptr);    // 对齐加载，快
7
__m256 b = _mm256_loadu_ps(unaligned_ptr); // 非对齐加载，稍慢

1
// AoS 布局：不利于 SIMD
2
struct Particle {
3
    float x, y, z, w;  // 交织存储
4
};
5
Particle particles[N];
6
// 加载所有 x 值需要 gather 指令，效率低
7

8
// SoA 布局：SIMD 友好
9
struct Particles {
10
    float x[N];  // 连续存储
11
    float y[N];
12
    float z[N];
13
    float w[N];
14
};
15
// 加载 8 个 x 值：_mm256_load_ps(x + i)，一次加载！

1
void add_arrays_avx(float *a, float *b, float *c, int n) {
2
    int i = 0;
3
    // AVX2: 每次处理 8 个 float
4
    for (; i + 8 <= n; i += 8) {
5
        __m256 va = _mm256_loadu_ps(a + i);
6
        __m256 vb = _mm256_loadu_ps(b + i);
7
        __m256 vc = _mm256_add_ps(va, vb);
8
        _mm256_storeu_ps(c + i, vc);
9
    }
10
    // 处理剩余元素
11
    for (; i < n; i++) {
12
        c[i] = a[i] + b[i];
13
    }
14
}

1
// AVX2 Gather: 从非连续地址收集数据
2
// 根据索引数组从源数组中收集 8 个元素
3
__m256i indices = _mm256_loadu_si256((__m256i*)idx_array);
4
__m256 result = _mm256_i32gather_ps(src, indices, 4);  // scale=4 (float 大小)
5

6
// Gather 比连续加载慢 3-5 倍，但比标量逐个加载快

1
#include <stdio.h>
2
#include <immintrin.h>
3
#include <time.h>
4

5
#define N 100000000
6

7
void add_scalar(float *a, float *b, float *c, int n) {
8
    for (int i = 0; i < n; i++) c[i] = a[i] + b[i];
9
}
10

11
void add_avx(float *a, float *b, float *c, int n) {
12
    int i = 0;
13
    for (; i + 8 <= n; i += 8) {
14
        __m256 va = _mm256_loadu_ps(a + i);
15
        __m256 vb = _mm256_loadu_ps(b + i);
16
        _mm256_storeu_ps(c + i, _mm256_add_ps(va, vb));
17
    }
18
    for (; i < n; i++) c[i] = a[i] + b[i];
19
}
20

21
int main() {
22
    float *a = aligned_alloc(32, N * sizeof(float));
23
    float *b = aligned_alloc(32, N * sizeof(float));
24
    float *c = aligned_alloc(32, N * sizeof(float));
25
    for (int i = 0; i < N; i++) { a[i] = 1.0f; b[i] = 2.0f; }
26

27
    clock_t start = clock();
28
    add_scalar(a, b, c, N);
29
    clock_t end = clock();
30
    printf("标量: %.3f 秒\n", (double)(end - start) / CLOCKS_PER_SEC);
31

32
    start = clock();
33
    add_avx(a, b, c, N);
34
    end = clock();
35
    printf("AVX2: %.3f 秒\n", (double)(end - start) / CLOCKS_PER_SEC);
36

37
    free(a); free(b); free(c);
38
    return 0;
39
}

1
#include <hwy/highway.h>
2

3
namespace hw = hwy::HWY_NAMESPACE;
4

5
void add_arrays(const float* a, const float* b, float* c, int n) {
6
    const int lanes = hw::Lanes(hw::FloatTag());
7
    for (int i = 0; i + lanes <= n; i += lanes) {
8
        auto va = hw::Load(hw::FloatTag(), a + i);
9
        auto vb = hw::Load(hw::FloatTag(), b + i);
10
        auto vc = hw::Add(va, vb);
11
        hw::Store(vc, hw::FloatTag(), c + i);
12
    }
13
    // 处理尾部...
14
}

1
# 编译并查看向量化报告
2
gcc -O3 -mavx2 -ftree-vectorize -fopt-info-vec-optimized test.c
3

4
# 查看生成的指令
5
gcc -O3 -mavx2 -S test.c -o test.s
6
grep -c "vmulps\|vaddps\|vmovaps" test.s

1
# 编译 SIMD 基准测试
2
gcc -O3 -mavx2 -o simd_test simd_test.c
3
perf stat -e cycles,instructions,flops_any ./simd_test

1
# Linux
2
cat /proc/cpuinfo | grep flags | head -1
3
# 查找 sse4_1, avx, avx2, avx512f 等标志
4

5
# 或使用
6
lscpu | grep -i flags

1
k0 = 0b1111111111111111  ← 全选（16 个元素全部操作）
2
k1 = 0b0000000011111111  ← 只操作低 8 个元素
3
k2 = 0b1010101010101010  ← 只操作偶数位元素

1
// AVX2：条件加法需要分支或 blend
2
__m256 a = _mm256_loadu_ps(src);
3
__m256 b = _mm256_loadu_ps(threshold);
4
__m256 mask = _mm256_cmp_ps(a, b, _CMP_GT_OS);  // 比较结果为全 1 或全 0
5
__m256 result = _mm256_blendv_ps(a, _mm256_add_ps(a, b), mask);  // blend 选择
6

7
// AVX-512：掩码直接嵌入操作
8
__m512 a = _mm512_loadu_ps(src);
9
__m512 b = _mm512_loadu_ps(threshold);
10
__mmask16 k = _mm512_cmp_ps_mask(a, b, _MM_CMPINT_GT);  // 16 位掩码
11
__m512 result = _mm512_mask_add_ps(a, k, a, b);  // k=1 的位置加法，k=0 保留原值

1
// GCC: 告知编译器无循环依赖
2
#pragma GCC ivdep
3
for (int i = 0; i < n; i++) {
4
    a[i] = b[i] + c[i];
5
}
6

7
// GCC: 指定向量化宽度
8
#pragma GCC vector aligned
9
#pragma GCC unroll 4
10
for (int i = 0; i < n; i++) {
11
    a[i] = b[i] * c[i];
12
}
13

14
// Clang: 显式启用/禁用向量化
15
#pragma clang loop vectorize(enable)
16
#pragma clang loop interleave(enable)
17
for (int i = 0; i < n; i++) {
18
    a[i] = b[i] + c[i];
19
}
20

21
// OpenMP: 便携的向量化提示
22
#pragma omp simd
23
for (int i = 0; i < n; i++) {
24
    a[i] = b[i] + c[i];
25
}
26

27
// OpenMP: 指定 SIMD 宽度
28
#pragma omp simd simdlen(8)
29
for (int i = 0; i < n; i++) {
30
    a[i] = b[i] + c[i];
31
}

1
// 原因 1：指针别名（编译器不确定 a/b/c 是否重叠）
2
void add(float *a, float *b, float *c, int n) {
3
    for (int i = 0; i < n; i++)
4
        a[i] = b[i] + c[i];  // 编译器可能不向量化
5
}
6

7
// 使用 restrict 消除别名
8
void add(float *restrict a, float *restrict b,
9
         float *restrict c, int n) {
10
    for (int i = 0; i < n; i++)
11
        a[i] = b[i] + c[i];  // 编译器可以安全向量化
12
}
13

14
// 原因 2：循环携带依赖
15
for (int i = 1; i < n; i++) {
16
    a[i] = a[i-1] + b[i];  // a[i] 依赖 a[i-1]，无法向量化
17
}
18

19
// 原因 3：复杂控制流
20
for (int i = 0; i < n; i++) {
21
    if (complex_condition(a[i])) {  // 不可预测的分支
22
        a[i] = b[i] + c[i];
23
    } else {
24
        a[i] = b[i] - c[i];
25
    }
26
}
27

28
// 用数学运算替代分支
29
for (int i = 0; i < n; i++) {
30
    int mask = (a[i] > 0);  // 0 或 1
31
    a[i] = b[i] + (2 * mask - 1) * c[i];  // 无分支
32
}

1
# GCC: 优化信息
2
gcc -O3 -mavx2 -ftree-vectorize -fopt-info-vec-optimized test.c
3
# 输出: test.c:8:3: note: loop vectorized
4

5
# GCC: 查看未向量化的原因
6
gcc -O3 -mavx2 -ftree-vectorize -fopt-info-vec-missed test.c
7
# 输出: test.c:15:3: missed: not vectorized: loop carried dependency
8

9
# Clang: 向量化报告
10
clang -O3 -mavx2 -Rpass=loop-vectorize test.c
11
# 输出: test.c:8:3: remark: vectorized loop (vectorization width: 8)
12

13
# Clang: 查看失败原因
14
clang -O3 -mavx2 -Rpass-missed=loop-vectorize test.c

1
// 混合使用 SSE 和 AVX 指令导致部分寄存器停顿
2
__m128 a = _mm_load_ps(src);       // 只写 XMM 低 128 位
3
__m256 b = _mm256_load_ps(src2);  // 使用完整 YMM 256 位
4
// CPU 需要插入 vzeroupper 指令清除 YMM 高位
5
// 如果不插入，后续 AVX 指令会有 2-3 周期停顿
6

7
// 统一使用 AVX 指令
8
__m256 a = _mm256_load_ps(src);    // 统一 256 位
9
__m256 b = _mm256_load_ps(src2);

1
# 检查是否有 vzeroupper 插入
2
objdump -d your_program | grep vzeroupper
3
# 如果大量出现，说明有 SSE/AVX 混合