C++ SIMD | "벡터 연산" 가이드

SIMD란?

Single Instruction Multiple Data

// 일반 연산
for (int i = 0; i < 4; ++i) {
    c[i] = a[i] + b[i];
}

// SIMD: 한 번에 4개 처리
// c = a + b (벡터 연산)

자동 벡터화

// 컴파일러 자동 벡터화
void add(float* a, float* b, float* c, int n) {
    for (int i = 0; i < n; ++i) {
        c[i] = a[i] + b[i];
    }
}

// -O3 -march=native 플래그

실전 예시

예시 1: 인트린식 (SSE)

#include <immintrin.h>

void addSSE(float* a, float* b, float* c, int n) {
    for (int i = 0; i < n; i += 4) {
        // 4개 float 로드
        __m128 va = _mm_loadu_ps(&a[i]);
        __m128 vb = _mm_loadu_ps(&b[i]);
        
        // 벡터 덧셈
        __m128 vc = _mm_add_ps(va, vb);
        
        // 저장
        _mm_storeu_ps(&c[i], vc);
    }
}

예시 2: AVX

#include <immintrin.h>

void addAVX(float* a, float* b, float* c, int n) {
    for (int i = 0; i < n; i += 8) {
        // 8개 float 로드
        __m256 va = _mm256_loadu_ps(&a[i]);
        __m256 vb = _mm256_loadu_ps(&b[i]);
        
        // 벡터 덧셈
        __m256 vc = _mm256_add_ps(va, vb);
        
        // 저장
        _mm256_storeu_ps(&c[i], vc);
    }
}

예시 3: 벡터화 힌트

// 컴파일러 힌트
void process(float* data, int n) {
    #pragma omp simd
    for (int i = 0; i < n; ++i) {
        data[i] = std::sqrt(data[i]);
    }
}

// 또는
void process2(float* data, int n) {
    #pragma GCC ivdep
    for (int i = 0; i < n; ++i) {
        data[i] = std::sqrt(data[i]);
    }
}

예시 4: 정렬

// 정렬된 데이터
alignas(32) float a[8] = {1, 2, 3, 4, 5, 6, 7, 8};
alignas(32) float b[8] = {8, 7, 6, 5, 4, 3, 2, 1};
alignas(32) float c[8];

// AVX 정렬 로드
__m256 va = _mm256_load_ps(a);  // 정렬 필요
__m256 vb = _mm256_load_ps(b);
__m256 vc = _mm256_add_ps(va, vb);
_mm256_store_ps(c, vc);

SIMD 연산

// SSE (128비트, 4개 float)
__m128 _mm_add_ps(a, b)      // 덧셈
__m128 _mm_sub_ps(a, b)      // 뺄셈
__m128 _mm_mul_ps(a, b)      // 곱셈
__m128 _mm_div_ps(a, b)      // 나눗셈

// AVX (256비트, 8개 float)
__m256 _mm256_add_ps(a, b)
__m256 _mm256_sub_ps(a, b)
__m256 _mm256_mul_ps(a, b)
__m256 _mm256_div_ps(a, b)

// AVX-512 (512비트, 16개 float)
__m512 _mm512_add_ps(a, b)

자주 발생하는 문제

문제 1: 정렬

// ❌ 비정렬 데이터
float a[8] = {1, 2, 3, 4, 5, 6, 7, 8};
__m256 va = _mm256_load_ps(a);  // 세그폴트 가능

// ✅ 정렬
alignas(32) float a[8] = {1, 2, 3, 4, 5, 6, 7, 8};
__m256 va = _mm256_load_ps(a);

// ✅ 비정렬 로드
float b[8] = {1, 2, 3, 4, 5, 6, 7, 8};
__m256 vb = _mm256_loadu_ps(b);

문제 2: 나머지

void addSIMD(float* a, float* b, float* c, int n) {
    int i = 0;
    
    // SIMD (8개씩)
    for (; i + 8 <= n; i += 8) {
        __m256 va = _mm256_loadu_ps(&a[i]);
        __m256 vb = _mm256_loadu_ps(&b[i]);
        __m256 vc = _mm256_add_ps(va, vb);
        _mm256_storeu_ps(&c[i], vc);
    }
    
    // 나머지 (스칼라)
    for (; i < n; ++i) {
        c[i] = a[i] + b[i];
    }
}

문제 3: 의존성

// ❌ 의존성 있음 (벡터화 불가)
for (int i = 1; i < n; ++i) {
    a[i] = a[i-1] + b[i];  // a[i-1] 의존
}

// ✅ 독립적 (벡터화 가능)
for (int i = 0; i < n; ++i) {
    c[i] = a[i] + b[i];
}

문제 4: 플랫폼

// SIMD는 플랫폼 의존
// - x86: SSE, AVX, AVX-512
// - ARM: NEON
// - 컴파일 플래그: -msse4.2, -mavx2

#ifdef __AVX2__
    // AVX2 코드
#elif defined(__SSE4_2__)
    // SSE4.2 코드
#else
    // 스칼라 코드
#endif

벡터화 조건

// 벡터화 가능:
// 1. 독립적 반복
// 2. 연속 메모리
// 3. 단순 연산

// 벡터화 불가:
// 1. 의존성
// 2. 분기
// 3. 함수 호출

FAQ

Q1: SIMD는?

A: 벡터 연산. 병렬 처리.

Q2: 종류?

A: SSE, AVX, AVX-512, NEON.

Q3: 자동 벡터화?

A: 컴파일러 최적화. -O3.

Q4: 인트린식?

A: 명시적 SIMD. 플랫폼 의존.

Q5: 성능?

A: 2~8배 향상 가능.

Q6: 학습 리소스는?

A:

• “Optimized C++”
• “Intel Intrinsics Guide”
• cppreference.com

---

같이 보면 좋은 글 (내부 링크)

이 주제와 연결되는 다른 글입니다.

• C++ SIMD와 병렬화: std::execution과 인트린직 가이드
• C++ Cache Optimization | “캐시 최적화” 가이드
• C++ Parallel Algorithms | “병렬 알고리즘” 가이드

관련 글

• C++ SIMD와 병렬화: std::execution과 인트린직 가이드
• C++ SIMD 최적화 실전 | SSE·AVX2·NEON 인트린직으로 4배 빠르게 [#51-2]
• C++ Algorithm Sort |
• C++ Benchmarking |
• C++ Cache Optimization |