SIMD 활용 분석 — Intrinsics·Auto-Vectorization·OpenMP SIMD

1
void scale(float * restrict a, float k, int N) {
2
    for (int i = 0; i < N; i++) {
3
        a[i] *= k;
4
    }
5
}

1
void copy(float *a, float *b, int N) {
2
    for (int i = 0; i < N; i++) a[i] = b[i];   /* alias 가능 → restrict 추가 */
3
}
4

5
for (int i = 0; i < N; i++) {
6
    if (a[i] > 0) b[i] = a[i];                 /* SVE/AVX mask 필요 */
7
}
8

9
for (int i = 1; i < N; i++) {
10
    a[i] += a[i-1];                            /* dependency → vectorize 불가 */
11
}

1
#include <arm_neon.h>
2

3
void add(float *a, float *b, float *c, int N) {
4
    int i = 0;
5
    for (; i + 4 <= N; i += 4) {
6
        float32x4_t va = vld1q_f32(&a[i]);
7
        float32x4_t vb = vld1q_f32(&b[i]);
8
        float32x4_t vc = vaddq_f32(va, vb);
9
        vst1q_f32(&c[i], vc);
10
    }
11
    for (; i < N; i++) c[i] = a[i] + b[i];
12
}

1
#include <arm_mve.h>
2

3
void add_mve(int16_t *a, int16_t *b, int16_t *c, int N) {
4
    int i = 0;
5
    for (int n = N; n > 0; n -= 8) {
6
        mve_pred16_t p = vctp16q(n);
7
        int16x8_t va = vld1q_z_s16(&a[i], p);
8
        int16x8_t vb = vld1q_z_s16(&b[i], p);
9
        int16x8_t vc = vaddq_x_s16(va, vb, p);
10
        vst1q_p_s16(&c[i], vc, p);
11
        i += 8;
12
    }
13
}

1
#include <arm_sve.h>
2

3
void add_sve(float *a, float *b, float *c, int N) {
4
    int i = 0;
5
    svbool_t pg = svwhilelt_b32(i, N);
6
    while (svptest_first(svptrue_b32(), pg)) {
7
        svfloat32_t va = svld1(pg, &a[i]);
8
        svfloat32_t vb = svld1(pg, &b[i]);
9
        svst1(pg, &c[i], svadd_x(pg, va, vb));
10
        i += svcntw();
11
        pg = svwhilelt_b32(i, N);
12
    }
13
}

1
#include <immintrin.h>
2

3
void add_avx(float *a, float *b, float *c, int N) {
4
    int i = 0;
5
    for (; i + 8 <= N; i += 8) {
6
        __m256 va = _mm256_load_ps(&a[i]);
7
        __m256 vb = _mm256_load_ps(&b[i]);
8
        __m256 vc = _mm256_add_ps(va, vb);
9
        _mm256_store_ps(&c[i], vc);
10
    }
11
}

1
#pragma omp simd
2
for (int i = 0; i < N; i++) {
3
    c[i] = a[i] + b[i];
4
}
5

6
#pragma omp simd reduction(+:sum)
7
for (int i = 0; i < N; i++) sum += data[i];
8

9
#pragma omp simd aligned(a:64, b:64, c:64)
10
for (int i = 0; i < N; i++) {
11
    c[i] = a[i] * b[i];
12
}

1
float32x4_t acc0 = vdupq_n_f32(0);
2
float32x4_t acc1 = vdupq_n_f32(0);
3
float32x4_t acc2 = vdupq_n_f32(0);
4
float32x4_t acc3 = vdupq_n_f32(0);
5

6
for (int i = 0; i + 16 <= N; i += 16) {
7
    acc0 = vaddq_f32(acc0, vld1q_f32(&data[i]));
8
    acc1 = vaddq_f32(acc1, vld1q_f32(&data[i+4]));
9
    acc2 = vaddq_f32(acc2, vld1q_f32(&data[i+8]));
10
    acc3 = vaddq_f32(acc3, vld1q_f32(&data[i+12]));
11
}

1
uint8x16_t va = vld1q_u8(in_a);
2
uint8x16_t vb = vld1q_u8(in_b);
3
uint8x16_t r  = vqaddq_u8(va, vb);   /* saturate at 255 */
4
vst1q_u8(out, r);

1
x86 AVX2 1 M float add
2
scalar                 1.40 ms
3
AVX2 (8-wide)          0.22 ms    6.4x
4
AVX-512 (16-wide)      0.11 ms    12.7x

1
for (int i = 0; i + 4 <= N; i += 4) { ... }
2
/* N=10 → i=8까지만 처리 */

1
float *p = malloc(N * sizeof(float));   /* 8B alignment */
2
float32x4_t v = vld1q_f32(p);           /* 16B aligned가 빠름 */

1
#include <arm_neon.h>
2
__m256 v;   /* x86 AVX — ARM에서 fail */

1
struct vec3 { float x, y, z; } v[N];
2
/* x만 vld1q_f32하려면 stride load — 효율 떨어짐 */