SIMD 명령과 커널 개발

커널 공간(Kernel Space) SIMD 활용을 성능 향상과 문맥 전환(Context Switch) 비용 관리 관점에서 심층 분석합니다. x86 SSE/AVX/AVX-512/AMX와 ARM NEON/SVE 레지스터(Register) 모델, kernel_fpu_begin/end 사용 규칙, preemption/irq 컨텍스트에서의 금지 패턴, FPU 상태 저장·복원 오버헤드(Overhead), 대체 경로(fallback scalar) 설계, 컴파일 플래그와 ISA 기능 게이팅, crypto·checksum·memcpy 가속 사례, 성능 회귀를 피하기 위한 벤치마크·프로파일링(Profiling) 절차까지 실전 커널 최적화 포인트를 다룹니다.

SIMD 기본 개념 — Single Instruction, Multiple Data

SIMD는 하나의 명령어(Single Instruction)로 여러 데이터(Multiple Data)를 동시에 처리하는 CPU 실행 모델입니다. 일반적인 스칼라(Scalar) 명령어는 한 번에 값 하나만 다루지만, SIMD 명령어는 CPU 내부의 넓은 레지스터에 여러 값을 나란히 채운 뒤 한꺼번에 같은 연산을 수행합니다. 결과적으로 동일한 클럭(Clock) 수에 더 많은 데이터를 처리하므로 처리량(Throughput)이 크게 향상됩니다.

Flynn 분류 — SIMD의 위치

Flynn 분류(Flynn Taxonomy)는 명령어와 데이터 스트림의 수에 따라 CPU 실행 모델을 네 가지로 구분합니다. 현대 CPU는 단일 코어 내부에서는 SIMD를, 멀티코어 전체로는 MIMD를 사용합니다.

스칼라 vs SIMD — 코드와 다이어그램으로 비교

4개의 32비트 정수를 더하는 단순한 예시로 스칼라와 SIMD의 차이를 비교합니다. 스칼라는 루프를 4회 반복하지만, SSE2 PADDD 명령어는 128비트 레지스터에 정수 4개를 담아 단 1사이클(Cycle)에 처리합니다.

/* 스칼라: 루프를 4회 반복, ADD 명령어 4번 실행 */
int a[4] = {1, 2, 3, 4};
int b[4] = {5, 6, 7, 8};
int c[4];
for (int i = 0; i < 4; i++)
    c[i] = a[i] + b[i];   /* c = {6, 8, 10, 12} — ADD × 4번 */

/* SSE2 SIMD: PADDD 1번으로 4개를 동시 처리 */
#include <immintrin.h>
__m128i va = _mm_loadu_si128((const __m128i *)a);  /* XMM에 a[3]|a[2]|a[1]|a[0] 로드 */
__m128i vb = _mm_loadu_si128((const __m128i *)b);  /* XMM에 b[3]|b[2]|b[1]|b[0] 로드 */
__m128i vc = _mm_add_epi32(va, vb);                 /* PADDD: 4쌍을 1사이클에 덧셈 */
_mm_storeu_si128((__m128i *)c, vc);                 /* 결과를 메모리에 저장 */
/* c = {6, 8, 10, 12} — 스칼라와 동일한 결과, 명령어 1개 */

/* AVX2로 확장: YMM(256-bit)으로 int 8개를 한 번에 처리 */
__m256i va8 = _mm256_loadu_si256((const __m256i *)a);
__m256i vb8 = _mm256_loadu_si256((const __m256i *)b);
__m256i vc8 = _mm256_add_epi32(va8, vb8);  /* VPADDD ymm: 8개 동시 처리 */

처리량 vs 지연 시간 — SIMD 이득의 정확한 이해

SIMD는 처리량을 높이지만, 개별 연산의 지연 시간(Latency)은 줄이지 않습니다. PADDD의 지연 시간은 ADD와 같은 1사이클이지만, 데이터 4개(SSE2)·8개(AVX2)·16개(AVX-512)를 동시에 처리하므로 같은 시간에 더 많은 작업을 끝냅니다. 이 특성 때문에 SIMD는 동일한 연산을 대량의 데이터에 반복 적용하는 루프에서 가장 큰 이득을 얻습니다. 반면 데이터 의존성이 깊거나 분기가 많은 코드는 SIMD 이점이 줄어들 수 있습니다.

Load → Compute → Store — SIMD 기본 프로그래밍 흐름

SIMD 코드는 항상 세 단계로 구성됩니다. 첫째, 메모리에서 SIMD 레지스터로 데이터를 로드(Load)합니다. 둘째, 레지스터 안의 데이터에 벡터 연산(Compute)을 적용합니다. 셋째, 결과를 메모리에 저장(Store)합니다. 이 흐름을 지키면 컴파일러가 레지스터 할당과 명령 스케줄링을 자동으로 최적화합니다.

/* Load → Compute → Store 기본 패턴 */
#include <immintrin.h>

void add_arrays(float *dst, const float *a, const float *b, size_t n)
{
    size_t i = 0;
    for (; i + 8 <= n; i += 8) {          /* 8개씩 처리 (AVX2, 256-bit) */
        __m256 va = _mm256_loadu_ps(a + i); /* ① Load: 메모리 → YMM 레지스터 */
        __m256 vb = _mm256_loadu_ps(b + i);
        __m256 vc = _mm256_add_ps(va, vb);  /* ② Compute: 8쌍 덧셈 */
        _mm256_storeu_ps(dst + i, vc);      /* ③ Store: YMM 레지스터 → 메모리 */
    }
    for (; i < n; i++)                     /* 나머지 스칼라 처리 (tail loop) */
        dst[i] = a[i] + b[i];
}
/* VZEROUPPER: AVX→SSE 전환 시 상위 비트 초기화 (AVX 사용 함수 끝에 권장) */
_mm256_zeroupper();

x86 SIMD 확장 역사

CPU 플래그(Flags) 매핑 — /proc/cpuinfo · lscpu

lscpu 또는 /proc/cpuinfo의 flags 필드에 나타나는 플래그(Flag) 이름과 실제 SIMD 확장·기능의 대응 관계를 정리합니다. 커널은 부팅 시 CPUID를 통해 이 플래그들을 탐지하고, arch/x86/include/asm/cpufeatures.h에 X86_FEATURE_* 매크로(Macro)로 정의합니다.

# SIMD 관련 플래그만 추출
grep -oP 'flags\s*:\s*\K.*' /proc/cpuinfo | head -1 | tr ' ' '\n' | \
  grep -iE 'mmx|sse|avx|fma|f16c|amx|vnni|gfni|vaes|vpclmul|sha|aes|pclmul|xsave|bmi|popcnt|movbe|fsrm' | sort -u

# lscpu로 확인
lscpu | grep -i flags

x86 기본 SIMD 플래그

AVX-512 서브셋(Subset) 플래그

AVX-512는 단일 확장이 아니라 Foundation + 다수 서브셋으로 구성됩니다. CPU 세대에 따라 지원 서브셋 조합이 다릅니다.

AMX · AVX10 · VEX-VNNI 플래그

암호화(Encryption)(Crypto) · 비트 조작(Bit Manipulation) 관련 플래그

SIMD 레지스터를 사용하거나 SIMD 코드와 함께 쓰이는 특수 명령어 플래그입니다.

XSAVE 상태 관리 플래그

SIMD 레지스터 상태의 저장·복원 메커니즘(Mechanism)을 결정하는 플래그입니다. 커널 FPU 컨텍스트 스위치(Context Switch)의 핵심입니다.

기타 SIMD 연관 플래그

ARM64 HWCAP 플래그 — /proc/cpuinfo · HWCAP

ARM64에서는 /proc/cpuinfo의 Features 필드 또는 getauxval(AT_HWCAP)/getauxval(AT_HWCAP2)로 확인합니다. 커널 헤더는 arch/arm64/include/asm/hwcap.h에 정의됩니다.

# ARM64 SIMD 관련 feature 확인
grep Features /proc/cpuinfo | head -1

# 프로그래밍 방식 확인 (C 코드)
unsigned long hwcap = getauxval(AT_HWCAP);
if (hwcap & HWCAP_ASIMD)  /* NEON/Advanced SIMD 지원 */
if (hwcap & HWCAP_SVE)    /* SVE 지원 */

커널에서의 플래그 확인 방법

/* x86: 커널 코드에서 SIMD 기능 확인 */
#include <asm/cpufeature.h>

/* 정적 분기(Static Branch) — 런타임 패칭으로 분기 비용 제로 */
if (static_cpu_has(X86_FEATURE_AVX2)) {
    kernel_fpu_begin();
    avx2_optimized_path(dst, src, len);
    kernel_fpu_end();
} else if (static_cpu_has(X86_FEATURE_XMM4_2)) {
    /* SSE4.2 — cpuinfo 플래그명 sse4_2 */
    kernel_fpu_begin();
    sse42_path(dst, src, len);
    kernel_fpu_end();
} else {
    generic_scalar_path(dst, src, len);
}

/* 동적 확인 — 모듈 초기화 등에서 사용 */
if (boot_cpu_has(X86_FEATURE_AVX512F) &&
    boot_cpu_has(X86_FEATURE_AVX512BW)) {
    pr_info("AVX-512F + BW detected, using 512-bit path\n");
}

/* ARM64: 커널 코드에서 확인 */
#include <asm/hwcap.h>
#include <asm/neon.h>

if (elf_hwcap & HWCAP_SVE) {
    kernel_neon_begin();
    sve_optimized_path(dst, src, len);
    kernel_neon_end();
}

레인(Lane)과 요소(Element) — SIMD 데이터 구조의 핵심

SIMD 레지스터는 넓은 비트 공간을 고정 크기의 요소(Element)로 나눠 사용합니다. 각 요소가 차지하는 슬롯을 레인(Lane)이라 부릅니다. 예를 들어 128비트 XMM 레지스터를 32비트 단위로 나누면 레인 4개가 생기고, 각 레인에 정수 하나가 들어갑니다. SIMD 연산은 모든 레인에서 독립적으로 동시에 수행됩니다. 레인 간 통신(수평 연산)은 별도의 셔플(Shuffle)/퍼뮤트(Permute) 명령어가 필요합니다.

같은 레지스터도 해석 방식에 따라 요소 유형과 레인 수가 달라집니다. PADDB는 XMM을 8비트 정수 16개 레인으로, PADDW는 16비트 정수 8개 레인으로, PADDD는 32비트 정수 4개 레인으로 처리합니다. 레지스터 자체는 하나이지만, 명령어가 해석 방식(요소 타입)을 결정합니다. Intrinsic 함수 이름의 접미사(_epi8, _epi16, _epi32, _ps, _pd 등)가 바로 이 해석 방식을 나타냅니다.

x86 SIMD 레지스터 레이아웃

x86 SIMD 핵심 명령어 패턴

로드/스토어 명령어

/* === SSE/AVX 로드/스토어 명령어 === */

/* 정렬된 로드/스토어 (16/32/64바이트 정렬 필수) */
movaps  (%rdi), %xmm0           /* 128-bit aligned load (packed single) */
movapd  (%rdi), %xmm0           /* 128-bit aligned load (packed double) */
movdqa  (%rdi), %xmm0           /* 128-bit aligned load (integer) */
vmovaps (%rdi), %ymm0           /* 256-bit aligned load (VEX) */
vmovaps (%rdi), %zmm0           /* 512-bit aligned load (EVEX) */

/* 비정렬 로드/스토어 (정렬 불필요, 약간 느릴 수 있음) */
movups  (%rdi), %xmm0           /* 128-bit unaligned (packed single) */
movdqu  (%rdi), %xmm0           /* 128-bit unaligned (integer) */
vmovdqu (%rdi), %ymm0           /* 256-bit unaligned */
vmovdqu32 (%rdi), %zmm0         /* 512-bit unaligned (EVEX, 32-bit elem) */

/* Scalar FP 이동 (low lane만 이동, upper lane merge 규칙 주의) */
movss   (%rdi), %xmm0           /* low32 로드, xmm0[127:32] = 0 */
movss   %xmm1, %xmm0            /* low32만 복사, xmm0[127:32] 유지 */
movsd   (%rdi), %xmm0           /* low64 로드, xmm0[127:64] = 0 */
movsd   %xmm1, %xmm0            /* low64만 복사, xmm0[127:64] 유지 */
vmovss  (%rdi), %xmm0           /* low32 로드, xmm0[127:32] = 0, YMM/ZMM 상위도 0 */
vmovss  %xmm2, %xmm1, %xmm0     /* xmm0[31:0]=xmm2[31:0], xmm0[127:32]=xmm1[127:32] */
vmovsd  (%rdi), %xmm0           /* low64 로드, xmm0[127:64] = 0, YMM/ZMM 상위도 0 */
vmovsd  %xmm2, %xmm1, %xmm0     /* xmm0[63:0]=xmm2[63:0], xmm0[127:64]=xmm1[127:64] */
vmovss  %xmm0, (%rdi)           /* low32 스토어 */
vmovsd  %xmm0, (%rdi)           /* low64 스토어 */

/* Non-Temporal 스토어 (캐시 오염 방지, Write-Combining) */
movntps %xmm0, (%rdi)           /* 캐시를 거치지 않고 메모리에 직접 기록 */
movntdq %xmm0, (%rdi)           /* 정수 non-temporal store */
vmovntps %ymm0, (%rdi)          /* 256-bit non-temporal */
sfence                           /* non-temporal store 후 반드시 sfence */

/* 마스크 로드/스토어 (AVX-512) */
vmovdqu32 (%rdi), %zmm0{%k1}    /* k1 마스크 비트가 1인 요소만 로드 */
vmovdqu32 (%rdi), %zmm0{%k1}{z} /* zero-masking: 마스크 0인 요소는 0 */

산술/논리 연산

/* === SSE2 정수 연산 (128-bit) === */
paddb   %xmm1, %xmm0           /* 바이트 단위 덧셈 (16개 병렬) */
paddw   %xmm1, %xmm0           /* 워드 단위 덧셈 (8개 병렬) */
paddd   %xmm1, %xmm0           /* 더블워드 단위 덧셈 (4개 병렬) */
paddq   %xmm1, %xmm0           /* 쿼드워드 단위 덧셈 (2개 병렬) */
psubb   %xmm1, %xmm0           /* 바이트 단위 뺄셈 */

/* 논리 연산 (비트 단위, 데이터 타입 무관) */
pxor    %xmm1, %xmm0           /* 128-bit XOR (RAID, 암호에 핵심) */
pand    %xmm1, %xmm0           /* 128-bit AND */
por     %xmm1, %xmm0           /* 128-bit OR */
pandn   %xmm1, %xmm0           /* ~xmm0 AND xmm1 */

/* === AVX2 정수 연산 (256-bit, VEX 3-operand) === */
vpaddd  %ymm2, %ymm1, %ymm0    /* ymm0 = ymm1 + ymm2 (비파괴적) */
vpxor   %ymm2, %ymm1, %ymm0    /* ymm0 = ymm1 XOR ymm2 */

/* === AVX-512 연산 (512-bit, EVEX) === */
vpaddd  %zmm2, %zmm1, %zmm0            /* 16개 int32 병렬 덧셈 */
vpaddd  %zmm2, %zmm1, %zmm0{%k1}       /* 마스크 적용: k1=0인 요소 유지 */
vpaddd  %zmm2, %zmm1, %zmm0{%k1}{z}    /* 마스크 적용: k1=0인 요소 = 0 */

/* === 부동소수점 연산 === */
addps   %xmm1, %xmm0           /* 4 × float 병렬 덧셈 */
mulpd   %xmm1, %xmm0           /* 2 × double 병렬 곱셈 */
vfmadd231ps %ymm2, %ymm1, %ymm0 /* FMA: ymm0 = ymm1*ymm2 + ymm0 */

셔플/퍼뮤트/비트 조작

/* 데이터 재배열 명령어 — SIMD 프로그래밍의 핵심 */

/* PSHUFB (SSSE3): 바이트 단위 임의 셔플 (look-up table 패턴) */
/* xmm0의 각 바이트를 xmm1의 인덱스에 따라 재배열 */
pshufb  %xmm1, %xmm0           /* xmm0[i] = xmm0[xmm1[i] & 0xF] */
                                /* xmm1[i] bit7=1이면 xmm0[i]=0 */

/* PSHUFD: 32-bit 요소 셔플 (즉시값으로 순서 지정) */
pshufd  $0x39, %xmm1, %xmm0   /* xmm0 = {xmm1[0],xmm1[3],xmm1[2],xmm1[1]} */

/* PUNPCKLBW/PUNPCKHBW: 인터리브 (바이트 단위) */
punpcklbw %xmm1, %xmm0         /* 하위 8바이트를 인터리브 */

/* AVX2 퍼뮤트: 128-bit 레인 간 교차 가능 */
vperm2i128 $0x31, %ymm1, %ymm0, %ymm2  /* 128-bit 레인 교환 */
vpermd  %ymm1, %ymm0, %ymm2    /* 32-bit 단위 임의 퍼뮤트 */

/* AVX-512 퍼뮤트 */
vpermb  %zmm1, %zmm0, %zmm2    /* 바이트 단위 64-way 퍼뮤트 */
vpermt2d %zmm2, %zmm1, %zmm0   /* 2-source 퍼뮤트 (merge) */

/* 비트 시프트 (요소별) */
pslld   $4, %xmm0              /* 각 32-bit 요소를 4비트 좌측 시프트 */
psrld   $4, %xmm0              /* 각 32-bit 요소를 4비트 우측 시프트 */
vpsllvd %ymm1, %ymm0, %ymm2    /* AVX2: 요소별 가변 시프트 */

비교/블렌드/변환

/* === 비교 명령어 === */
pcmpeqb %xmm1, %xmm0           /* 바이트 비교: 같으면 0xFF, 다르면 0x00 */
pcmpgtd %xmm1, %xmm0           /* 부호있는 32-bit 비교: xmm0>xmm1이면 0xFFFFFFFF */

/* SSE4.2 문자열 비교 (커널에서 문자열 처리에 활용) */
pcmpistri $0x08, %xmm1, %xmm0  /* Equal Each: 바이트 일치 인덱스 → ECX */
pcmpestri $0x00, %xmm1, %xmm0  /* Equal Any: 문자 집합 검색 */

/* AVX-512 비교 → 마스크 레지스터 */
vpcmpeqd %zmm1, %zmm0, %k1     /* 16개 int32 비교 → k1 마스크 (16-bit) */
vpcmpud $1, %zmm1, %zmm0, %k2  /* 부호없는 less-than 비교 */
kmovw   %k1, %eax               /* 마스크 → 범용 레지스터 전송 */
popcnt  %eax, %eax              /* 일치 개수 세기 */

/* === 블렌드: 조건부 선택 === */
blendvps %xmm0, %xmm1, %xmm2   /* SSE4.1: xmm0 MSB로 xmm1/xmm2 선택 */
vpblendvb %ymm3, %ymm2, %ymm1, %ymm0 /* AVX2: 바이트별 조건부 선택 */
vpblendmd %zmm2, %zmm1, %zmm0{%k1}   /* AVX-512: 마스크 기반 블렌드 */

/* === 데이터 타입 변환 === */
cvtdq2ps  %xmm0, %xmm1         /* 4 × int32 → 4 × float */
cvtps2dq  %xmm0, %xmm1         /* 4 × float → 4 × int32 (반올림) */
cvttps2dq %xmm0, %xmm1         /* 4 × float → 4 × int32 (truncate) */
vpmovzxbw %xmm0, %ymm1         /* 16 × uint8 → 16 × uint16 (zero-extend) */
vpmovsxwd %xmm0, %ymm1         /* 8 × int16 → 8 × int32 (sign-extend) */

암호화 전용 SIMD 명령어

/* === AES-NI 명령어 (커널 crypto 핵심) === */
aesenc    %xmm1, %xmm0         /* AES 한 라운드 암호화 */
aesenclast %xmm1, %xmm0        /* AES 마지막 라운드 암호화 */
aesdec    %xmm1, %xmm0         /* AES 한 라운드 복호화(Decryption) */
aesdeclast %xmm1, %xmm0        /* AES 마지막 라운드 복호화 */
aeskeygenassist $1, %xmm0, %xmm1 /* AES 라운드 키 생성 보조 */
aesimc    %xmm0, %xmm1         /* InvMixColumns (복호화 키 변환) */

/* VAES: 256/512-bit AES (AVX-512 + VAES) */
vaesenc   %ymm2, %ymm1, %ymm0  /* 2블록 병렬 AES 암호화 */
vaesenc   %zmm2, %zmm1, %zmm0  /* 4블록 병렬 AES 암호화 */

/* === PCLMULQDQ: 갈루아 필드 곱셈 (GCM, CRC) === */
pclmulqdq $0x00, %xmm1, %xmm0  /* Carry-less multiply: xmm0[63:0] × xmm1[63:0] */
pclmulqdq $0x11, %xmm1, %xmm0  /* xmm0[127:64] × xmm1[127:64] */
vpclmulqdq $0x00, %zmm1, %zmm0, %zmm2 /* 512-bit VPCLMULQDQ (4 병렬) */

/* === SHA-NI 명령어 === */
sha256rnds2 %xmm0, %xmm1       /* SHA-256 2라운드 처리 */
sha256msg1  %xmm1, %xmm0       /* SHA-256 메시지 스케줄 1 */
sha256msg2  %xmm1, %xmm0       /* SHA-256 메시지 스케줄 2 */
sha1rnds4   $0, %xmm1, %xmm0   /* SHA-1 4라운드 처리 */
sha1nexte   %xmm1, %xmm0       /* SHA-1 다음 E값 계산 */

/* === CRC32 (SSE4.2) === */
crc32b  (%rdi), %eax            /* CRC32C: 1바이트 누적 */
crc32q  (%rdi), %rax            /* CRC32C: 8바이트 누적 */

Gather/Scatter (AVX2/AVX-512)

/* Gather: 불연속 메모리 주소에서 벡터로 모아 읽기 */
/* 기존 스칼라 코드:
 *   for (i = 0; i < 8; i++) result[i] = base[index[i]];
 * → 단일 Gather 명령어로 대체 */

/* AVX2 Gather */
vgatherdps %ymm2, (%rdi,%ymm1,4), %ymm0
/* ymm0[i] = MEM[rdi + ymm1[i]*4] (ymm2 마스크 기반)
 * ymm2는 마스크 겸 오류 추적, 실행 후 0으로 클리어됨 */

vgatherdpd %xmm2, (%rdi,%xmm1,8), %ymm0
/* 4개 인덱스(xmm1, 32-bit) → 4개 double 로드 → ymm0 */

/* AVX-512 Gather (마스크 레지스터 사용, 더 효율적) */
vgatherdps (%rdi,%zmm1,4), %zmm0{%k1}
/* k1 마스크가 1인 요소만 로드, 완료된 요소의 k1 비트 클리어 */

/* AVX-512 Scatter: 벡터에서 불연속 메모리 주소로 흩뿌려 쓰기 */
vscatterdps %zmm0, (%rdi,%zmm1,4){%k1}
/* MEM[rdi + zmm1[i]*4] = zmm0[i] (k1 마스크 적용)
 * Gather의 역연산. AVX-512 이전에는 없었음 */

ARM SIMD 확장

ARM NEON 핵심 명령어

/* ARM NEON (Advanced SIMD) 레지스터 구조
 *
 * V0-V31: 128-bit 벡터 레지스터
 * 접근 방식:
 *   Vn.16B  = 16 × byte    Vn.8B  = 하위 8 × byte (64-bit)
 *   Vn.8H   = 8 × halfword Vn.4H  = 하위 4 × halfword
 *   Vn.4S   = 4 × single   Vn.2S  = 하위 2 × single
 *   Vn.2D   = 2 × double   Vn.1D  = 하위 1 × double
 *   Bn/Hn/Sn/Dn = 스칼라 접근 (byte/half/single/double)
 */

/* === 로드/스토어 === */
ld1     {v0.16b}, [x0]          /* 128-bit 연속 로드 */
ld1     {v0.16b, v1.16b}, [x0]  /* 256-bit 연속 로드 (2 레지스터) */
ld1     {v0.4s-v3.4s}, [x0]     /* 512-bit 연속 로드 (4 레지스터) */
st1     {v0.16b}, [x0]          /* 128-bit 스토어 */

/* Structure 로드: 인터리브 해제 (SoA 변환) */
ld2     {v0.4s, v1.4s}, [x0]    /* 2-way 디인터리브: ABABAB → A,B */
ld3     {v0.4s, v1.4s, v2.4s}, [x0] /* RGB → R,G,B 분리 */
ld4     {v0.4s-v3.4s}, [x0]     /* 4-way 디인터리브 */
st2     {v0.4s, v1.4s}, [x0]    /* 2-way 인터리브 저장 */

/* === 산술 연산 === */
add     v0.4s, v1.4s, v2.4s     /* 4 × int32 덧셈 */
sub     v0.8h, v1.8h, v2.8h     /* 8 × int16 뺄셈 */
mul     v0.4s, v1.4s, v2.4s     /* 4 × int32 곱셈 */
mla     v0.4s, v1.4s, v2.4s     /* v0 += v1 * v2 (multiply-accumulate) */
fmul    v0.4s, v1.4s, v2.4s     /* 4 × float 곱셈 */
fmla    v0.4s, v1.4s, v2.4s     /* fused multiply-add (FP) */

/* === 논리/비트 연산 === */
eor     v0.16b, v1.16b, v2.16b  /* 128-bit XOR */
and     v0.16b, v1.16b, v2.16b  /* 128-bit AND */
bsl     v0.16b, v1.16b, v2.16b  /* Bitwise Select: bit=1 → v1, bit=0 → v2 */

/* === 비교 === */
cmeq    v0.4s, v1.4s, v2.4s     /* 같으면 0xFFFFFFFF, 다르면 0 */
cmgt    v0.4s, v1.4s, v2.4s     /* 부호있는 greater-than */
cmhi    v0.4s, v1.4s, v2.4s     /* 부호없는 greater-than (higher) */

/* === 셔플/퍼뮤트 === */
tbl     v0.16b, {v1.16b}, v2.16b /* 테이블 룩업 (x86 PSHUFB와 유사) */
tbl     v0.16b, {v1.16b, v2.16b}, v3.16b /* 32바이트 테이블 룩업 */
trn1    v0.4s, v1.4s, v2.4s     /* Transpose (짝수 요소 인터리브) */
trn2    v0.4s, v1.4s, v2.4s     /* Transpose (홀수 요소 인터리브) */
zip1    v0.4s, v1.4s, v2.4s     /* 하위 절반 인터리브 */
uzp1    v0.4s, v1.4s, v2.4s     /* 짝수 요소 추출 */
rev64   v0.16b, v1.16b          /* 64-bit 단위 내 바이트 역순 */
ext     v0.16b, v1.16b, v2.16b, #4 /* 연결 후 4바이트 시프트 추출 */

/* === 암호 확장 (ARMv8 Crypto Extension) === */
aese    v0.16b, v1.16b          /* AES 단일 라운드 암호화 */
aesd    v0.16b, v1.16b          /* AES 단일 라운드 복호화 */
aesmc   v0.16b, v1.16b          /* AES MixColumns */
aesimc  v0.16b, v1.16b          /* AES InvMixColumns */
pmull   v0.1q, v1.1d, v2.1d     /* 다항식 곱셈 (GHASH) */
sha256h  q0, q1, v2.4s          /* SHA-256 해시(Hash) 업데이트 */
sha256su0 v0.4s, v1.4s          /* SHA-256 스케줄 업데이트 */

ARM SVE 프로그래밍 모델

SVE(Scalable Vector Extension)는 벡터 길이를 하드웨어 구현에 의존하는 벡터 길이 비종속 (Vector Length Agnostic, VLA) 프로그래밍 모델입니다. 동일한 바이너리가 128비트~2048비트 구현에서 동작합니다.

/* SVE 레지스터 구조
 *
 * Z0-Z31: 스케일러블 벡터 (128~2048-bit, 하드웨어 정의)
 *   Zn의 하위 128비트 = NEON Vn과 공유 (아키텍처 보장)
 * P0-P15: 프레디케이트 레지스터 (VL/8 비트)
 *   각 비트가 벡터의 한 바이트에 대응
 *   P0-P7: governing predicate로 사용 가능
 * FFR: First Fault Register (투기적 로드용)
 * VL: Vector Length (cntb로 바이트 단위 조회)
 */

/* === 벡터 길이 조회 === */
cntb    x0                      /* x0 = VL (바이트 단위). 예: 512-bit → 64 */
cnth    x0                      /* x0 = VL / 2 (halfword 개수) */
cntw    x0                      /* x0 = VL / 4 (word 개수) */
cntd    x0                      /* x0 = VL / 8 (doubleword 개수) */

/* === 프레디케이트 생성 === */
ptrue   p0.b                    /* 모든 바이트 활성 (all-true) */
ptrue   p0.s                    /* 모든 word 활성 */
whilelt p0.s, x0, x1            /* x0 < x1인 요소만 활성 (루프 테일 처리) */
pfalse  p0.b                    /* 모든 비트 비활성 (all-false) */

/* === VLA 루프 패턴 (커널에서 가장 중요) === */
/* memcpy를 SVE로 구현하는 예시 */
/*   x0 = dst, x1 = src, x2 = len (바이트) */
    mov     x3, #0              /* 오프셋 초기화 */
    whilelt p0.b, x3, x2        /* 프레디케이트 설정 */
.loop:
    ld1b    z0.b, p0/z, [x1, x3] /* 프레디케이트 기반 로드 */
    st1b    z0.b, p0, [x0, x3]   /* 프레디케이트 기반 스토어 */
    incb    x3                    /* x3 += VL (바이트 수만큼 증가) */
    whilelt p0.b, x3, x2         /* 잔여 요소 프레디케이트 갱신 */
    b.first .loop                 /* 활성 요소 있으면 계속 */

/* === Scatter/Gather (SVE 기본 지원) === */
ld1w    z0.s, p0/z, [x0, z1.s, uxtw #2] /* Gather: x0 + z1[i]*4 */
st1w    z0.s, p0, [x0, z1.s, uxtw #2]   /* Scatter */

/* === First Fault 로드 (투기적 로드, 커널 문자열 처리) === */
ldff1b  z0.b, p0/z, [x0, x1]    /* First Fault 로드 */
rdffr   p1.b                     /* FFR 읽기: 성공한 요소만 p1=1 */

ARM SME — 행렬 연산 엔진

SME(Scalable Matrix Extension)는 ARMv9.2-A에 도입된 행렬 연산 전용 확장으로, 2D 타일 구조의 ZA 레지스터와 Streaming SVE 모드(SSVE)를 제공합니다. SVE2가 1차원 벡터를 다루는 데 반해, SME는 2차원 행렬 외적(Outer Product)을 하드웨어에서 직접 수행합니다.

/* Streaming SVE 모드 제어 */
smstart                          /* Streaming SVE 모드 + ZA 동시 활성화 */
smstart sm                       /* Streaming SVE 모드만 활성화 (ZA 제외) */
smstart za                       /* ZA 레지스터만 활성화 (SM 모드 제외) */
smstop                           /* Streaming SVE 모드 + ZA 비활성화 */

/* SVL(Streaming Vector Length) 조회 — VL과 독립 */
rdsvl   x0, #1                  /* x0 = SVL (바이트 단위) */

/* ZA 타일 로드/스토어 (가로/세로 슬라이스 단위) */
ld1w    za0h.s[w12, #0], p0/z, [x0, x1, lsl #2]
/* za0의 가로(h) 슬라이스를 로드. w12: 슬라이스 인덱스 */
st1w    za0v.s[w12, #0], p0, [x0, x1, lsl #2]
/* za0의 세로(v) 슬라이스를 스토어 */

/* 외적 누적 (Outer Product Accumulate) — SME 핵심 연산 */
fmopa   za0.s, p0/m, p1/m, z0.s, z1.s
/* za0 += z0 × z1^T  (부동소수점 외적, 마스크 p0/p1 적용) */
smopa   za0.s, p0/m, p1/m, z0.b, z1.b
/* za0 += z0 × z1^T  (INT8→INT32 누적, SME2 행렬 곱) */
bfmopa  za0.s, p0/m, p1/m, z0.h, z1.h
/* za0 += z0 × z1^T  (BF16→FP32 누적) */

/* 커널 SME 감지 — arch/arm64/include/asm/cpufeature.h */
#include <asm/cpufeature.h>

if (system_supports_sme()) {
    /* SME 사용 가능: ZA 타일, FMOPA, SMOPA 등 */
    unsigned int svl = task_get_svl(current);
    /* SVL 예: 512-bit → ZA 크기 = 64×64/8 = 512바이트 */
}

if (system_supports_sme2()) {
    /* SME2: 다중 벡터 ZA 연산, INT8/FP8 지원 */
}

/* ZA 상태 저장 비용 — arch/arm64/include/asm/fpsimd.h
 *
 * 스케줄러(Scheduler)가 컨텍스트 스위치 시 자동 처리:
 *   fpsimd_save_state() → thread.uw.fpsimd_state에 NEON 저장
 *   za_state는 thread.za_state 별도 영역에 저장
 *
 * 크기 예시 (SVL 기준):
 *   SVL =  512-bit → ZA =  64× 64/8 =   512 bytes
 *   SVL = 1024-bit → ZA = 128×128/8 = 2,048 bytes
 *   SVL = 2048-bit → ZA = 256×256/8 = 8,192 bytes
 * → SME 활성 프로세스는 context switch 비용이 현저히 증가
 */

/* 커널에서 SME를 직접 사용하지 않는 이유:
 * 1. ZA 상태 저장 비용이 크고, 커널 경로 지연 증가
 * 2. Streaming SVE 모드에서 일부 SVE 명령어 동작 변경
 * 3. smstart/smstop이 모드 전환 비용(마이크로초 단위) 수반
 * → SME는 유저 공간 라이브러리(BLAS, NN 추론)에서 사용
 * → 커널 역할: SMAN 상태 저장/복원, cpufeature 노출만 담당
 */

Intrinsic 함수 실전 가이드

Intrinsic 함수는 C/C++ 코드에서 특정 CPU 명령어를 직접 호출할 수 있는 컴파일러 내장 함수(Compiler Built-in Function)입니다. 인라인 어셈블리와 달리 C 함수 호출 문법을 사용하면서도, 컴파일러가 1:1에 가깝게 기계 명령어로 변환합니다. 레지스터 할당, 명령 스케줄링(Instruction Scheduling), 루프 언롤링(Loop Unrolling) 등의 최적화를 컴파일러에 위임할 수 있어 인라인 어셈블리보다 유지보수가 쉽습니다.

Intrinsic 컴파일 파이프라인(Pipeline)

Intrinsic 함수가 최종 기계 코드로 변환되는 과정을 이해하면, 최적화 결과를 예측하고 디버깅(Debugging)하는 데 도움이 됩니다.

Intrinsic 데이터 타입 체계

Intrinsic 함수는 고유한 벡터 데이터 타입을 사용합니다. 이 타입은 실제 CPU 레지스터에 1:1 대응하며, 컴파일러가 타입 불일치(Type Mismatch)를 검사할 수 있게 합니다.

헤더 체계와 네이밍 규칙

네이밍 규칙 예시:

• _mm256_add_epi32 → vpaddd ymm0, ymm1, ymm2 (어셈블리 변환)
• _mm512_mask_add_epi32 → vpaddd zmm0{k1}, zmm1, zmm2

초기화 패턴

벡터 레지스터의 초기값 설정은 SIMD 코드의 시작점입니다. 초기화 Intrinsic 종류에 따라 생성되는 명령어와 성능이 크게 달라집니다.

SSE/SSE2 기본 Intrinsic

SSE2는 x86-64에서 필수 지원되므로, 별도 CPU 기능 검사 없이 사용할 수 있는 가장 기본적인 SIMD 계층입니다.

#include <emmintrin.h>  /* SSE2 — x86-64 기본 포함 */
#include <smmintrin.h>  /* SSE4.1 — blend, extract 등 */
#include <nmmintrin.h>  /* SSE4.2 — CRC32, 문자열 비교 */

/* ── SSE2 기본 연산 ── */

/* 128-bit 정수 로드/스토어 */
__m128i a = _mm_loadu_si128((const __m128i *)src);
_mm_storeu_si128((__m128i *)dst, a);

/* 4 × int32 산술 */
__m128i sum  = _mm_add_epi32(a, b);    /* paddd  → 4개 int32 덧셈 */
__m128i diff = _mm_sub_epi32(a, b);    /* psubd  → 4개 int32 뺄셈 */

/* 16 × uint8 포화(Saturating) 연산 — 오버플로 시 255로 클램프 */
__m128i sat_sum = _mm_adds_epu8(a, b); /* paddusb → 이미지 밝기 조절 등에 활용 */
__m128i sat_sub = _mm_subs_epu8(a, b); /* psubusb → 결과가 음수면 0으로 클램프 */

/* 128-bit 논리 연산 */
__m128i x = _mm_xor_si128(a, b);     /* pxor   → 128-bit XOR */
__m128i y = _mm_and_si128(a, b);     /* pand   → 128-bit AND */
__m128i z = _mm_andnot_si128(a, b); /* pandn  → (~a) AND b */

/* 시프트 — 즉시값(Immediate) */
__m128i sl = _mm_slli_epi32(a, 4);   /* pslld  → 각 int32를 4비트 좌측 시프트 */
__m128i sr = _mm_srli_epi32(a, 4);   /* psrld  → 각 int32를 4비트 논리 우측 시프트 */
__m128i sa = _mm_srai_epi32(a, 4);   /* psrad  → 각 int32를 4비트 산술 우측 시프트 */

/* 비교 → 마스크 */
__m128i eq = _mm_cmpeq_epi8(a, b);   /* pcmpeqb → 같으면 0xFF, 다르면 0x00 */
int mask = _mm_movemask_epi8(eq);    /* pmovmskb → 각 바이트 MSB → 16-bit 마스크 */
/* mask의 각 비트가 해당 바이트의 비교 결과
 * __builtin_ctz(mask)로 첫 매치 위치 계산 가능 */

/* ── SSE2 셔플 ── */
__m128i shuf = _mm_shuffle_epi32(a, _MM_SHUFFLE(3,1,2,0));
/* pshufd → [a3, a1, a2, a0] — 즉시값으로 32-bit 요소 재배치
 * _MM_SHUFFLE(z,y,x,w) = (z<<6)|(y<<4)|(x<<2)|w */

/* 언팩(Unpack) — 인터리브 */
__m128i lo = _mm_unpacklo_epi8(a, b);
/* punpcklbw → a[0],b[0],a[1],b[1],...,a[7],b[7] 하위 8바이트 인터리브 */

/* ── SSE4.1 추가 ── */
__m128i blend = _mm_blendv_epi8(a, b, mask128);
/* pblendvb → mask의 MSB에 따라 a 또는 b 선택. 조건부 치환에 필수 */

__m128i min32 = _mm_min_epi32(a, b);   /* pminsd  → signed int32 최솟값 */
__m128i max32 = _mm_max_epi32(a, b);   /* pmaxsd  → signed int32 최댓값 */
__m128i mulo  = _mm_mullo_epi32(a, b); /* pmulld  → int32 곱셈 하위 32비트 (SSE2에는 없었음) */
int elem2 = _mm_extract_epi32(a, 2);  /* pextrd  → 벡터에서 32-bit 요소 추출 */

/* ── SSE4.2 문자열 처리 ── */
int idx = _mm_cmpestri(needle, nlen, haystack, hlen, _SIDD_CMP_EQUAL_ORDERED);
/* pcmpestri → 명시적 길이(Explicit Length) 문자열 비교, 매치 인덱스 반환
 * _SIDD_CMP_EQUAL_ORDERED: 부분 문자열(Substring) 검색 모드 */

uint32_t crc = _mm_crc32_u64(init, data);
/* crc32q → CRC32C (Castagnoli) 하드웨어 가속. iSCSI, Btrfs, ext4 체크섬 */

핵심 연산 데이터 흐름 시각화

SIMD Intrinsic의 동작을 이해하는 가장 빠른 방법은 요소별(Element-wise) 데이터 흐름을 시각화하는 것입니다.

AVX2 핵심 Intrinsic 예제

#include <immintrin.h>
#include <stdint.h>

/* 로드/스토어 */
__m256i a = _mm256_load_si256((const __m256i *)p);  /* 32B 정렬 필수 */
__m256i b = _mm256_loadu_si256((const __m256i *)p); /* 비정렬 OK */
_mm256_storeu_si256((__m256i *)p, a);
_mm256_stream_si256((__m256i *)p, a);              /* Non-Temporal */

/* 정수 산술 — int32 */
__m256i sum  = _mm256_add_epi32(a, b);   /* 8개 int32 덧셈 */
__m256i diff = _mm256_sub_epi32(a, b);   /* 8개 int32 뺄셈 */
__m256i mul  = _mm256_mullo_epi32(a, b); /* 하위 32비트 곱셈 */

/* 논리 연산 */
__m256i x = _mm256_xor_si256(a, b);     /* 256-bit XOR */
__m256i y = _mm256_and_si256(a, b);     /* 256-bit AND */

/* 부동소수점 FMA */
__m256 r = _mm256_fmadd_ps(a_ps, b_ps, c_ps);
/* r[i] = a[i]*b[i] + c[i]  (단정밀도 8개 병렬 FMA) */

/* 셔플/퍼뮤트 */
__m256i perm = _mm256_permute2x128_si256(a, b, 0x31);
/* 결과 상위 128-bit = b 하위, 결과 하위 128-bit = a 상위 */
__m256i shuf = _mm256_shuffle_epi8(a, mask); /* PSHUFB 기반 바이트 셔플 */

/* 비교 → 마스크 */
__m256i cmp   = _mm256_cmpeq_epi32(a, b);
int     mask32 = _mm256_movemask_epi8(cmp); /* 각 바이트 MSB → 비트 마스크 */

/* 실용 예: 8개 uint32 배열 XOR */
void xor_8x32(uint32_t *dst, const uint32_t *src, size_t n)
{
    for (size_t i = 0; i < n; i += 8) {
        __m256i vd = _mm256_loadu_si256((const __m256i *)(dst + i));
        __m256i vs = _mm256_loadu_si256((const __m256i *)(src + i));
        _mm256_storeu_si256((__m256i *)(dst + i), _mm256_xor_si256(vd, vs));
    }
}

AVX-512 마스크 연산 Intrinsic

/* AVX-512 고유 특성: __mmask8 / __mmask16 / __mmask32 / __mmask64 */
#include <immintrin.h>

/* 마스크 생성: 비교 결과 → 마스크 */
__mmask16 k = _mm512_cmp_epi32_mask(a, b, _MM_CMPINT_LT);
/* 16개 int32 비교: a[i] < b[i]이면 k 비트 i = 1 */

/* 마스크 적용 산술 — zeroing (k=0인 레인은 0) */
__m512i result = _mm512_maskz_add_epi32(k, a, b);

/* 마스크 적용 산술 — merging (k=0인 레인은 src 유지) */
__m512i merged = _mm512_mask_add_epi32(src, k, a, b);

/* 마스크 로드/스토어 (루프 테일 처리에 활용) */
__m512i data = _mm512_maskz_loadu_epi32(k, ptr);
_mm512_mask_storeu_epi32(ptr, k, data);

/* 마스크 비트 연산 */
__mmask16 k_and = _kand_mask16(k1, k2);
__mmask16 k_not = _knot_mask16(k1);

/* 루프 테일 처리 패턴 */
void process_avx512(float *arr, size_t n)
{
    size_t i;
    for (i = 0; i + 16 <= n; i += 16) {
        __m512 v = _mm512_loadu_ps(arr + i);
        _mm512_storeu_ps(arr + i, _mm512_mul_ps(v, v));
    }
    if (i < n) {
        __mmask16 tail = (__mmask16)((1u << (n - i)) - 1u);
        __m512 v = _mm512_maskz_loadu_ps(tail, arr + i);
        _mm512_mask_storeu_ps(arr + i, tail, _mm512_mul_ps(v, v));
    }
}

/* 커널에서 Intrinsic보다 인라인 어셈블리 선호 이유:
 * 1. 커널 기본 CFLAGS: -mno-sse, -mno-avx 등 SIMD 전면 비활성화
 *    → 개별 파일/함수에 __attribute__((target("avx2"))) 필요
 * 2. 컴파일러 버전별 VZEROUPPER 삽입 위치 불확실
 * 3. 레지스터 clobber 목록의 명시적 제어 필요
 * 4. 크리티컬 패스에서 어셈블리가 코드 검토를 더 명확히 함
 * → 커널 crypto/RAID 코드는 거의 모두 인라인 asm 또는 .S 파일 */

실전 패턴 분석

수평 합산(Horizontal Sum) — 벡터 전체를 단일 스칼라로 축소

배열의 전체 합산처럼 SIMD로 병렬 누적한 후 최종 결과를 하나의 값으로 줄여야 할 때 사용합니다. SIMD에서 수평 축소(Horizontal Reduction)는 수직 연산보다 비용이 높으므로, 루프 안이 아닌 루프 종료 후 한 번만 수행하는 것이 핵심입니다.

#include <immintrin.h>

/* int32 배열의 전체 합계를 AVX2로 계산 */
int32_t sum_array_avx2(const int32_t *arr, size_t n)
{
    __m256i acc = _mm256_setzero_si256();  /* 8×int32 누적기 초기화 */
    size_t i;

    /* ── 메인 루프: 8개씩 수직 덧셈 ── */
    for (i = 0; i + 8 <= n; i += 8) {
        __m256i v = _mm256_loadu_si256((const __m256i *)(arr + i));
        acc = _mm256_add_epi32(acc, v);  /* 8개 레인 독립 누적 */
    }

    /* ── 수평 축소: 256-bit → 128-bit → 스칼라 ──
     *
     * acc = [a7, a6, a5, a4 | a3, a2, a1, a0]  (| = 레인 경계)
     *
     * Step 1: 상위 128-bit + 하위 128-bit
     *   hi128 = [a7, a6, a5, a4]
     *   sum128 = [a7+a3, a6+a2, a5+a1, a4+a0]
     *
     * Step 2: PSHUFD로 [2,3] → [0,1] 위치로 이동 후 덧셈
     *   sum128 = [*, *, a7+a3+a5+a1, a6+a2+a4+a0]
     *
     * Step 3: PSHUFD로 [1] → [0] 위치로 이동 후 최종 덧셈
     *   sum128 = [*, *, *, 전체합]
     */
    __m128i hi128  = _mm256_extracti128_si256(acc, 1);
    __m128i sum128 = _mm_add_epi32(_mm256_castsi256_si128(acc), hi128);
    __m128i shuf   = _mm_shuffle_epi32(sum128, _MM_SHUFFLE(1,0,3,2));
    sum128 = _mm_add_epi32(sum128, shuf);
    shuf   = _mm_shuffle_epi32(sum128, _MM_SHUFFLE(0,1,0,1));
    sum128 = _mm_add_epi32(sum128, shuf);

    int32_t total = _mm_cvtsi128_si32(sum128); /* 최하위 int32 추출 */

    /* ── 테일 처리: 나머지 요소 스칼라 덧셈 ── */
    for (; i < n; i++)
        total += arr[i];

    return total;
}
/* 성능 분석:
 * - 메인 루프: vpaddd 1개/iter, 레이턴시 1 cycle, 처리량 0.5 cycle (포트 0/5)
 * - 수평 축소: 고정 비용 ~6 cycle (전체 루프 밖 1회)
 * - 1024개 int32: 스칼라 ~1024 cycle vs AVX2 ~128+6 ≈ 134 cycle (7.6배 가속) */

바이트 검색(memchr) — SIMD 문자열/메모리 탐색 패턴

특정 바이트 값을 대량 데이터에서 찾는 패턴입니다. _mm_cmpeq_epi8 + _mm_movemask_epi8 조합은 glibc memchr, strlen, strchr 등의 핵심입니다.

/* SSE2 기반 memchr 구현 — 16바이트씩 병렬 비교 */
const uint8_t *fast_memchr_sse2(const uint8_t *buf, uint8_t needle, size_t len)
{
    __m128i pattern = _mm_set1_epi8((char)needle); /* 16바이트 모두 동일 값 */
    size_t i;

    for (i = 0; i + 16 <= len; i += 16) {
        __m128i chunk = _mm_loadu_si128((const __m128i *)(buf + i));
        __m128i cmp   = _mm_cmpeq_epi8(chunk, pattern);
        int mask = _mm_movemask_epi8(cmp);
        /* mask의 각 비트: 해당 위치 바이트가 needle과 같으면 1 */

        if (mask != 0)
            return buf + i + __builtin_ctz(mask); /* 첫 1-비트 위치 = 매치 오프셋 */
    }

    /* 테일 처리 */
    for (; i < len; i++)
        if (buf[i] == needle) return buf + i;

    return NULL;
}
/* 패턴 분석:
 * pcmpeqb + pmovmskb + tzcnt → 3개 명령으로 16바이트 동시 검색
 * 스칼라 대비 약 8~12배 빠름 (캐시 상태에 따라 다름)
 * glibc, musl, 커널 lib/string.c 등에서 동일 패턴 사용 */

4×4 행렬 전치(Transpose) — 셔플 조합의 전형

4×4 float 행렬 전치는 이미지 처리, 선형 대수(Linear Algebra), AoS↔SoA 변환에서 빈번합니다. SSE의 _MM_TRANSPOSE4_PS 매크로가 이 패턴을 제공합니다.

/* 4×4 float 행렬 전치 — _MM_TRANSPOSE4_PS의 내부 동작 */
void transpose_4x4(__m128 *r0, __m128 *r1, __m128 *r2, __m128 *r3)
{
    /* 입력:
     * r0 = [a0, a1, a2, a3]
     * r1 = [b0, b1, b2, b3]
     * r2 = [c0, c1, c2, c3]
     * r3 = [d0, d1, d2, d3]
     */

    /* Step 1: 하위 절반 인터리브 */
    __m128 t0 = _mm_unpacklo_ps(*r0, *r1); /* [a0,b0,a1,b1] */
    __m128 t1 = _mm_unpackhi_ps(*r0, *r1); /* [a2,b2,a3,b3] */
    __m128 t2 = _mm_unpacklo_ps(*r2, *r3); /* [c0,d0,c1,d1] */
    __m128 t3 = _mm_unpackhi_ps(*r2, *r3); /* [c2,d2,c3,d3] */

    /* Step 2: 64-bit 블록 이동 */
    *r0 = _mm_movelh_ps(t0, t2); /* [a0,b0,c0,d0] ← 전치된 열 0 */
    *r1 = _mm_movehl_ps(t2, t0); /* [a1,b1,c1,d1] ← 전치된 열 1 */
    *r2 = _mm_movelh_ps(t1, t3); /* [a2,b2,c2,d2] ← 전치된 열 2 */
    *r3 = _mm_movehl_ps(t3, t1); /* [a3,b3,c3,d3] ← 전치된 열 3 */

    /* 총 8개 명령어, 레이턴시 약 4 cycle (포트 5 경합)
     * unpacklo/hi: 각 1 cycle 레이턴시, 포트 5
     * movelh/hl:   각 1 cycle 레이턴시, 포트 5
     * 스칼라(16회 로드+16회 스토어)보다 ~4배 빠름 */
}

값 범위 제한(Clamp) — min/max 조합

/* float 배열을 [lo, hi] 범위로 클램프 — AVX */
void clamp_avx(float *arr, size_t n, float lo, float hi)
{
    __m256 vlo = _mm256_set1_ps(lo);
    __m256 vhi = _mm256_set1_ps(hi);

    for (size_t i = 0; i + 8 <= n; i += 8) {
        __m256 v = _mm256_loadu_ps(arr + i);
        v = _mm256_max_ps(v, vlo);  /* v < lo인 요소를 lo로 올림 */
        v = _mm256_min_ps(v, vhi);  /* v > hi인 요소를 hi로 내림 */
        _mm256_storeu_ps(arr + i, v);
    }
    /* ... 테일 처리 생략 ... */
}
/* vmaxps + vminps: 각 1 cycle 레이턴시, 서로 다른 포트 사용 가능 → 파이프라인 병렬
 * 분기(branch) 없이 8개 float를 동시에 클램프 */

ARM NEON Intrinsic (arm_neon.h)

ARM NEON Intrinsic은 <arm_neon.h> 헤더를 통해 제공됩니다. x86과 달리 타입 이름에 요소 크기와 개수가 명시적으로 포함되어 있어 가독성이 높습니다.

NEON 타입 체계

NEON 네이밍 규칙

#include <arm_neon.h>

/* ── 기본 연산 ── */
int32x4_t a = vld1q_s32(src);              /* 128-bit 로드 → ld1 {v0.4s},[x0] */
int32x4_t b = vdupq_n_s32(42);             /* 브로드캐스트 → dup v1.4s, w0 */
int32x4_t sum = vaddq_s32(a, b);           /* 4×int32 덧셈 → add v0.4s,v1.4s,v2.4s */
vst1q_s32(dst, sum);                       /* 128-bit 스토어 → st1 {v0.4s},[x0] */

/* ── 곱셈-누적(Multiply-Accumulate) — NEON의 강점 ── */
int32x4_t acc = vmlaq_s32(acc, a, b);      /* acc += a * b → mla v0.4s,v1.4s,v2.4s */
float32x4_t facc = vfmaq_f32(facc, fa, fb); /* FMA: facc += fa * fb → fmla */

/* ── 비교와 선택 ── */
uint32x4_t mask = vcgtq_s32(a, b);         /* a > b → 0xFFFFFFFF, else 0 */
int32x4_t sel = vbslq_s32(mask, a, b);     /* mask=1→a, mask=0→b (x86 blendv) */

/* ── 내적(Dot Product) — Armv8.2+ (asimddp) ── */
int32x4_t dot = vdotq_s32(acc, a8, b8);
/* 4그룹 × 4바이트 내적 누적. 머신러닝 추론 핵심 명령.
 * 각 int32 요소 = Σ(a8[i*4+k] × b8[i*4+k]), k=0..3 */

/* ── 구조적 로드/스토어(Structure Load/Store) ── */
uint8x16x3_t rgb = vld3q_u8(pixel_data);
/* ld3 {v0.16b-v2.16b},[x0]
 * RGBRGBRGB... → R=rgb.val[0], G=rgb.val[1], B=rgb.val[2]
 * x86에서는 셔플 조합으로 구현해야 할 것을 1 명령으로 처리
 * 이미지 처리, 센서 데이터 파싱에서 NEON의 큰 강점 */

/* ── 수평 합산 ── */
int32_t hsum = vaddvq_s32(sum);             /* addv s0, v0.4s → 4개 요소 합산 스칼라 */
/* Armv8.1+ 단일 명령 수평 축소. x86은 셔플 조합이 필요하지만
 * NEON은 ADDV/SMAXV/SMINV/UMAXV/UMINV 등으로 직접 지원 */

/* ── 포화 연산(Saturating Arithmetic) ── */
uint8x16_t bright = vqaddq_u8(pixels, offset);
/* uqadd: 255 초과 시 255로 클램프. 이미지 밝기 조절.
 * x86의 _mm_adds_epu8과 동일 */

NEON vs x86 Intrinsic 핵심 차이

Intrinsic 사용 시 흔한 실수

Intrinsic ↔ 어셈블리 주요 매핑 레퍼런스

자주 사용하는 Intrinsic과 대응 어셈블리 명령어, 지연(Latency), 처리량의 빠른 참조입니다. 지연/처리량은 Intel Skylake 기준입니다.

Lat = 지연, TP = 처리량. * = L1 캐시 히트 기준. † = 레지스터 리네이밍으로 실행 유닛 불필요.

커널에서의 SIMD 사용 — 핵심 제약

왜 kernel_fpu_begin()과 kernel_fpu_end()가 꼭 필요한가

핵심은 XMM/YMM/ZMM 레지스터가 함수마다 새로 생기는 개인 메모장이 아니라, 현재 CPU가 실제로 들고 있는 공용 작업 공간이라는 점입니다. 유저 프로세스가 이미지 처리, 브라우저 엔진, 데이터베이스 계산처럼 SIMD를 많이 쓰는 작업을 하다가 시스템 콜(System Call)이나 인터럽트(Interrupt)로 커널에 들어올 수 있습니다. 그 순간 커널이 같은 레지스터를 곧바로 덮어쓰면, 유저 프로세스는 자신이 계산하던 중간값을 잃어버린 채 다시 실행됩니다.

이 문제를 더 정확히 표현하면, 커널은 FP/SIMD 레지스터를 일반 커널 문맥의 일부로 항상 저장·복원하도록 설계되지 않았습니다는 뜻입니다. 유저 태스크(Task)의 FP 상태는 필요할 때 관리되지만, 일반 커널 경로는 기본적으로 "커널은 FP를 쓰지 않습니다"는 전제를 깔고 돌아갑니다. 따라서 커널이 예외적으로 SIMD를 사용하려면 kernel_fpu_begin()으로 지금부터 FP/SIMD 레지스터를 커널이 잠깐 점유하겠다고 선언하고, 그 구간이 다른 문맥과 섞이지 않도록 보호해야 합니다. kernel_fpu_end()는 그 점유를 끝내고 원래 규칙으로 복귀시키는 호출입니다.

설계가 이렇게 된 가장 큰 이유는 비용이 너무 크기 때문입니다. 커널은 시스템 콜, 예외, 인터럽트, 선점(Preemption)처럼 매우 자주 실행되는 경로를 지날 때마다 가능한 한 적은 상태만 저장하려고 합니다. 그런데 FP/SIMD 상태는 x87 수준에서 끝나지 않고 SSE, AVX, AVX-512, AMX로 갈수록 저장해야 할 레지스터 집합이 크게 늘어납니다. 이 큰 상태를 모든 커널 진입과 모든 커널 선점에서 항상 저장·복원하면, FP를 전혀 쓰지 않는 대부분의 커널 코드까지 매번 비용을 부담하게 됩니다. 그래서 Linux는 기본 경로를 가볍게 유지하고, 정말 필요한 코드만 짧은 보호 구간 안에서 비용을 지불하는 방식을 택합니다.

여기에 구현 단순성도 있습니다. 일부 아키텍처는 성능과 단순성을 위해 FP 레지스터를 지연 저장/복원(lazy preserve/restore)하거나, 커널 모드에서는 별도 보존 메커니즘을 넉넉하게 두지 않는 방식을 사용합니다. 또한 컴파일러가 최적화 과정에서 개발자가 의도하지 않은 FP/SIMD 명령을 끼워 넣을 수 있으므로, 커널 문서는 FP 코드를 별도 파일로 분리하고 비FP 코드 밖으로 새어나가지 않게 하라고 요구합니다. 즉 이 API는 단순히 문맥 전환 경로의 한계를 메우는 보조 함수가 아니라, 커널 전체가 "FP/SIMD는 예외적으로만, 명시적으로만 사용합니다"는 정책을 지키게 만드는 경계선입니다.

설계 배경에는 성능과 단순성 이유가 있지만, 호출 규칙 자체는 정확성 보장 규칙입니다. SIMD 명령은 매우 빠르지만, 보호 절차 없이 쓰면 다른 프로세스의 부동소수점 계산 결과를 망가뜨릴 수 있습니다. 이런 버그는 즉시 커널 패닉(Kernel Panic)으로 드러나지 않고, 어떤 프로그램에서만 숫자가 틀리는 식으로 늦게 나타나기 때문에 더 위험합니다.

생략하면 실제로 무엇이 망가지는가

예를 들어 유저 공간의 동영상 인코더가 YMM 레지스터에 색 변환 계수와 누산값을 담아 둔 상태에서 파일 입출력(I/O) 시스템 콜을 호출했다고 가정하겠습니다. 이때 커널이 체크섬(Checksum) 계산이나 암호화 가속을 위해 AVX 명령을 직접 실행하면서 상태를 보존하지 않으면, 시스템 콜이 끝난 뒤 유저 프로그램은 손상된 레지스터 값으로 계산을 이어 가게 됩니다. 소스 코드 관점에서는 서로 다른 함수처럼 보여도, 실제 하드웨어 레지스터는 같은 CPU 위에서 번갈아 사용되므로 보호 절차가 필요합니다.

보호 구간이 필요한 직접적인 이유 중 하나는 선점과 스케줄링(Scheduling)입니다. 커널이 SIMD 레지스터를 잡은 채 다른 태스크로 전환되면 어떤 상태가 누구 것인지 관리가 어려워지고, 복원 시점도 복잡해집니다. 그래서 kernel_fpu_begin()은 보통 선점을 막고, 환경에 따라서는 softirq 개입도 제한하며, 개발자에게 "이 구간에서는 자지 말고 아주 짧게 끝내라"는 제약을 함께 부여합니다. 따라서 이 API는 단순 저장 함수가 아니라, 짧고 엄격한 임계 구간을 여는 장치로 이해하는 편이 정확합니다.

/* ⚠ 커널 코드에서 SIMD 레지스터를 직접 사용할 수 없습니다! */
/*
 * 이유:
 * 1. 커널은 유저 프로세스의 FPU/SIMD 상태를 보존해야 함
 * 2. 인터럽트/softirq 컨텍스트에서 FPU 상태가 정의되지 않음
 * 3. preempt 시 FPU 상태가 손상될 수 있음
 *
 * 해결: kernel_fpu_begin() / kernel_fpu_end()
 * 이 API가 유저 FPU 상태를 저장/복원하고 preempt를 비활성화
 */

#include <asm/fpu/api.h>

void my_aes_encrypt(u8 *dst, const u8 *src, const u8 *key)
{
    /* FPU/SIMD 사용 전에 반드시 호출 */
    kernel_fpu_begin();

    /* 이 구간에서만 SSE/AVX/AES-NI 명령어 사용 가능 */
    asm volatile(
        "movdqu (%[key]), %%xmm0\\n"
        "movdqu (%[src]), %%xmm1\\n"
        "pxor   %%xmm0, %%xmm1\\n"
        "aesenc %%xmm0, %%xmm1\\n"
        "movdqu %%xmm1, (%[dst])\\n"
        :: [dst] "r"(dst), [src] "r"(src), [key] "r"(key)
        : "xmm0", "xmm1", "memory"
    );

    /* FPU/SIMD 사용 후 반드시 호출 */
    kernel_fpu_end();
}

/* ARM64에서의 SIMD 사용 */
#include <asm/neon.h>
kernel_neon_begin();
/* NEON/SVE 명령어 사용 가능 */
kernel_neon_end();

XSAVE/XRSTOR 메커니즘 상세

XSAVE는 FPU/SIMD 상태를 확장 가능한 방식으로 저장/복원하는 x86 메커니즘입니다. kernel_fpu_begin()의 핵심 구현이며, 새로운 SIMD 확장이 추가될 때마다 자동으로 대응합니다.

/* XSAVE 상태 컴포넌트 (CPUID Leaf 0x0D로 확인) */
/*
 * 비트  컴포넌트              크기       오프셋
 * ─────────────────────────────────────────────────
 *  0   x87 FPU              512 bytes  0 (고정)
 *  1   SSE (XMM0-XMM15)     (위에 포함)  0 (고정)
 *  2   AVX (YMM 상위 128)   256 bytes  576
 *  3   MPX BNDREGS          64 bytes   (가변)
 *  4   MPX BNDCFG           64 bytes   (가변)
 *  5   AVX-512 opmask (k)   64 bytes   (가변)
 *  6   AVX-512 ZMM_Hi256    512 bytes  (가변)
 *  7   AVX-512 Hi16_ZMM     1024 bytes (가변)
 *  9   PKRU                 8 bytes    (가변)
 * 11   CET_U                16 bytes   (가변)
 * 12   CET_S                24 bytes   (가변)
 * 17   TILECFG (AMX)        64 bytes   (가변)
 * 18   TILEDATA (AMX)       8192 bytes (가변)
 */

/* 커널의 XSAVE 영역 크기 결정 — arch/x86/kernel/fpu/xstate.c */
void fpu__init_system_xstate(unsigned int legacy_size)
{
    u64 xfeatures_mask;
    unsigned int eax, ebx, ecx, edx;

    /* CPUID Leaf 0x0D, Sub-leaf 0: 지원 컴포넌트 마스크 */
    cpuid_count(0x0D, 0, &eax, &ebx, &ecx, &edx);
    xfeatures_mask = eax | ((u64)edx << 32);
    /* ebx = 현재 XCR0 기준 XSAVE 크기 */
    /* ecx = 지원되는 모든 컴포넌트의 최대 XSAVE 크기 */

    /* 각 컴포넌트의 크기/오프셋 조회 */
    for (int i = 2; i < 64; i++) {
        if (!(xfeatures_mask & (1ULL << i))) continue;
        cpuid_count(0x0D, i, &eax, &ebx, &ecx, &edx);
        /* eax = 컴포넌트 크기, ebx = 오프셋 */
        /* ecx bit 1: 이 컴포넌트가 compacted XSAVE에서 정렬 필요 */
    }
}

/* XSAVE 변종 명령어 */
/* XSAVE:    모든 컴포넌트 저장 (느림, 초기 변종) */
/* XSAVEOPT: 변경된 컴포넌트만 저장 (최적화) */
/* XSAVEC:   Compacted 형식으로 저장 (커널 기본) */
/* XSAVES:   Supervisor 컴포넌트 포함 + compacted */
/* XRSTOR:   컴포넌트 복원 */
/* XRSTORS:  Supervisor 컴포넌트 포함 복원 */

/* kernel_fpu_begin() 내부 흐름 */
void kernel_fpu_begin_mask(unsigned int kfpu_mask)
{
    preempt_disable();

    if (!test_thread_flag(TIF_NEED_FPU_LOAD)) {
        /* 유저 FPU 상태가 레지스터에 live → 메모리에 저장 */
        fpu_save_regs(fpu);
        /* 내부적으로 XSAVES 또는 XSAVEC 실행 */
    }
    /* 이제 커널 코드가 FPU/SIMD 레지스터를 자유롭게 사용 가능 */
}

void kernel_fpu_end(void)
{
    /* TIF_NEED_FPU_LOAD 플래그 설정 → 다음 유저 복귀 시 lazy restore */
    set_thread_flag(TIF_NEED_FPU_LOAD);
    preempt_enable();
}

FPU Lazy Restore 메커니즘 상세

Linux 커널은 FPU 상태 복원을 최대한 지연시켜 컨텍스트 스위치 비용을 줄입니다. TIF_NEED_FPU_LOAD 플래그가 이 최적화의 핵심입니다.

/* arch/x86/kernel/fpu/core.c — switch_fpu_finish() */
static inline void switch_fpu_finish(void)
{
    /* 컨텍스트 스위치 직후 (새 태스크로 전환) */
    if (!test_thread_flag(TIF_NEED_FPU_LOAD))
        return;   /* FPU가 이미 올바른 상태 — 복원 불필요 */

    /*
     * FPU 상태가 레지스터에 없음 → 유저 복귀 전에 복원 필요
     * 이 시점에서는 아직 복원하지 않음!
     * 유저 복귀 경로(exit_to_user_mode)에서 실제 XRSTOR 수행
     *
     * 최적화 이유:
     *   커널 코드 실행 중에는 FPU 레지스터 불필요
     *   → 유저 복귀 직전까지 복원을 지연하면
     *   → 같은 태스크가 연속 컨텍스트 스위치되는 경우 복원 생략 가능
     */
}

/* arch/x86/kernel/fpu/core.c — fpregs_restore_userregs() */
void fpregs_restore_userregs(void)
{
    struct fpu *fpu = &current->thread.fpu;

    if (!test_thread_flag(TIF_NEED_FPU_LOAD))
        return;

    /* 실제 XRSTOR 수행 — 유저 복귀 직전에만 호출됨 */
    restore_fpregs_from_fpstate(fpu->fpstate, XFEATURE_MASK_FPSTATE);
    clear_thread_flag(TIF_NEED_FPU_LOAD);
}

/* kernel_fpu_begin()이 lazy restore에 미치는 영향:
 *
 * 1. 유저 FPU 상태가 레지스터에 live:
 *    → XSAVE로 메모리에 저장
 *    → TIF_NEED_FPU_LOAD 설정
 *    → 커널 SIMD 코드 실행
 *
 * 2. 이미 TIF_NEED_FPU_LOAD 상태 (이전 컨텍스트 스위치 이후):
 *    → XSAVE 불필요 (이미 메모리에 있음)
 *    → 바로 커널 SIMD 코드 실행 가능
 *    → 이 경우 kernel_fpu_begin()의 비용이 현저히 줄어듦!
 *
 * 결론: 컨텍스트 스위치 직후의 kernel_fpu_begin()은 매우 저렴
 *       유저 코드가 FPU를 집중적으로 쓰는 태스크에서는 비용이 높음
 */

kernel_fpu_begin/end 오버헤드 측정

데이터 정렬 — #GP 예외와 진단

SIMD 정렬 명령어(movaps, vmovaps 등)는 데이터가 정해진 바이트 경계에 맞지 않으면 #GP(General Protection Fault)를 발생시킵니다. 커널에서 이를 잘못 처리하면 oops로 이어집니다.

정렬 요구사항 상세 테이블

커널 정렬 보장 패턴

/* 커널에서 정렬을 보장하는 주요 방법 */
#include <linux/align.h>
#include <linux/slab.h>

/* 1. DECLARE_ALIGNED: 정적 배열 정렬 */
DECLARE_ALIGNED(32, u8, simd_buf[256]); /* 32B 정렬 */
DECLARE_ALIGNED(64, u8, avx512_buf[512]); /* 64B 정렬 */

/* 2. __attribute__((aligned(N))): GCC 정렬 지시 */
struct my_simd_ctx {
    u8 key[32] __attribute__((aligned(32)));
    u8 state[64] __attribute__((aligned(64)));
};

/* 3. PTR_ALIGN: 런타임 포인터 정렬 조정 */
void *buf = kmalloc(size + 63, GFP_KERNEL);
void *aligned = PTR_ALIGN(buf, 64); /* 64B 경계로 올림 */

/* 4. IS_ALIGNED: 정렬 여부 런타임 검사 */
if (!IS_ALIGNED((unsigned long)ptr, 32)) {
    /* 비정렬 → vmovdqu 변종 사용 경로 */
    do_simd_unaligned(ptr, len);
} else {
    /* 정렬 확인 → vmovaps 사용 경로 (최적) */
    do_simd_aligned(ptr, len);
}

/* 5. ROUND_UP: 정렬된 크기로 올림 */
size_t aligned_size = ROUND_UP(size, 64);

#GP 예외 진단 및 수정

# 1. dmesg에서 #GP 확인
dmesg | grep "general protection"
# 출력 예: general protection fault#GP 0000 [#1] SMP NOPTI
#          RIP: 0010:my_aes_encrypt+0x2a/0x60

# 2. RIP 주소에서 위반 명령어 특정
objdump -d vmlinux | grep -A 3 "<my_aes_encrypt>"
# 출력 예:
#   movaps (%rsi), %xmm0     ← 16B 정렬 필요인데 위반!

# 3. 즉시 수정: 비정렬 변종으로 교체
# movaps  → movups  (SSE)
# vmovaps → vmovups  (AVX/AVX-512)
# vmovdqa → vmovdqu  (AVX 정수)

# 4. 근본 수정: 구조체/버퍼(Buffer) 정렬 보장
# DECLARE_ALIGNED(32, u8, buf[256]);

# 5. 정렬 상태 확인 도구
pahole -C my_struct vmlinux        # 구조체 레이아웃 출력

커널 내 SIMD 활용 사례

crypto API와 SIMD 통합 구조

/* 커널 crypto API는 SIMD 가속을 투명하게 관리하는 구조를 갖추고 있음 */
/* arch/x86/crypto/aesni-intel_glue.c — 실제 등록 예시 */

static struct skcipher_alg aesni_skciphers[] = {
    {
        .base.cra_name        = "cbc(aes)",
        .base.cra_driver_name = "cbc-aes-aesni",  /* AES-NI 가속 */
        .base.cra_priority    = 400,             /* generic(100)보다 높은 우선순위(Priority) */
        .setkey               = aesni_skcipher_setkey,
        .encrypt              = cbc_encrypt,      /* SIMD 사용 */
        .decrypt              = cbc_decrypt,
    },
};

/* 우선순위 기반 자동 선택:
 *   cbc(aes) 요청 시:
 *     1. cbc-aes-aesni   (priority=400, AES-NI 필요)
 *     2. cbc-aes-generic (priority=100, 항상 사용 가능)
 *   → CPU가 AES-NI를 지원하면 자동으로 #1 선택 */

/* simd_skcipher_create_compat(): softirq에서의 SIMD 안전 처리 */
/*
 * 문제: softirq 컨텍스트에서 kernel_fpu_begin()이 실패할 수 있음
 *       (이미 process context에서 FPU를 사용 중일 때)
 *
 * 해결: simd 래퍼가 softirq를 감지하면 자동으로 generic fallback
 *       → cryptd (crypto daemon) 워크큐로 지연 처리
 */
struct simd_skcipher_alg *simd_skcipher_create_compat(
    const char *algname,      /* "cbc(aes)" */
    const char *drvname,      /* "cbc-aes-aesni" (내부 SIMD 알고리즘) */
    const char *basename);    /* "cbc(aes)" (fallback) */

/* 실제 호출 경로:
 *   유저 요청 → crypto_alloc_skcipher("cbc(aes)")
 *   → 커널이 "cbc-aes-aesni"의 simd 래퍼 선택
 *   → process context → kernel_fpu_begin() + AES-NI 직접 사용
 *   → softirq context → cryptd 워크큐 → process context에서 실행
 */

RAID6 SIMD 최적화

/* RAID6는 GF(2^8) 갈루아 필드 연산을 대량으로 수행 → SIMD 핵심 활용처 */
/* lib/raid6/algos.c — 런타임 벤치마크로 최적 알고리즘 자동 선택 */

const struct raid6_calls *const raid6_algos[] = {
    /* 속도 순 (느림 → 빠름) */
    &raid6_intx1,     /* 순수 정수 (fallback) */
    &raid6_intx2,     /* 정수, 2-way unroll */
    &raid6_sse1x1,    /* SSE 128-bit */
    &raid6_sse1x2,    /* SSE 128-bit, 2-way unroll */
    &raid6_sse2x1,    /* SSE2 128-bit */
    &raid6_sse2x2,    /* SSE2 128-bit, 2-way unroll */
    &raid6_sse2x4,    /* SSE2 128-bit, 4-way unroll */
    &raid6_avx2x1,    /* AVX2 256-bit */
    &raid6_avx2x2,    /* AVX2 256-bit, 2-way unroll */
    &raid6_avx2x4,    /* AVX2 256-bit, 4-way unroll */
    &raid6_avx512x1,  /* AVX-512 512-bit */
    &raid6_avx512x2,  /* AVX-512 512-bit, 2-way unroll */
    &raid6_avx512x4,  /* AVX-512 512-bit, 4-way unroll */
    NULL,
};

/* 부팅 시 각 알고리즘을 벤치마크하여 최적 선택 */
/* dmesg 출력 예시:
 * raid6: avx512x4  gen() 29430 MB/s
 * raid6: avx512x2  gen() 27891 MB/s
 * raid6: avx2x4    gen() 18560 MB/s
 * raid6: using algorithm avx512x4 gen() 29430 MB/s
 */

/* AVX2 RAID6 P+Q 신드롬 계산 핵심 루프 */
/* lib/raid6/avx2.c */
static void raid6_avx21_gen_syndrome(int disks, size_t bytes, void **ptrs)
{
    kernel_fpu_begin();

    asm volatile(
        "vmovdqa %[x0f], %%ymm3\\n"   /* 마스크 0x0F */
        "vpxor   %%ymm0, %%ymm0, %%ymm0\\n" /* P = 0 */
        "vpxor   %%ymm1, %%ymm1, %%ymm1\\n" /* Q = 0 */
        /* 각 디스크 데이터를 순회하며:
         *   P ^= data[i]          (단순 XOR)
         *   Q = GF_MUL(Q) ^ data[i]  (GF(2^8) 곱셈 후 XOR)
         * GF 곱셈은 VPSHUFB로 4-bit 룩업테이블 사용 */
        ::: "ymm0","ymm1","ymm2","ymm3","ymm4","ymm5","memory"
    );

    kernel_fpu_end();
}

커널 memcpy/memset SIMD 최적화

x86 리눅스 커널의 arch/x86/lib/memcpy_64.S는 복사 크기에 따라 여러 전략을 동적으로 선택합니다. 단순한 SIMD 루프가 아닌, CPU 마이크로아키텍처와 크기에 따른 계층적 결정 트리를 사용합니다.

arch/x86/lib/memcpy_64.S 구조

/* arch/x86/lib/memcpy_64.S — 단순화된 구조 */
/* 실제 구현은 CPU 특성 플래그를 런타임에 패치(alternatives)함 */

/* 소형 복사 (len < 64바이트): 레지스터 직접 이동 */
/*   1~7B:  rep movsb (또는 개별 mov 명령어) */
/*   8~15B: mov + 겹침 허용 (end 기준 마지막 8B) */
/*  16~31B: movdqu × 2 (겹침 허용) */
/*  32~63B: vmovdqu × 2 (겹침 허용) */

/* 중형 복사 (64B ≤ len < 2KB): AVX2 루프 */
.memcpy_avx2_loop:
    vmovdqu  (%rsi),       %ymm0
    vmovdqu  32(%rsi),    %ymm1
    vmovdqu  %ymm0,       (%rdi)
    vmovdqu  %ymm1,       32(%rdi)
    add      $64, %rsi
    add      $64, %rdi
    sub      $64, %rcx
    jg       .memcpy_avx2_loop
    vzeroupper                    /* AVX→SSE 전환 페널티 방지 */

/* 대형 복사 (len ≥ 2KB): Non-Temporal 스토어 */
.memcpy_nt_loop:
    vmovdqu  (%rsi),       %ymm0  /* 소스: 일반 로드 (캐시 경유) */
    vmovdqu  32(%rsi),    %ymm1
    vmovntdq %ymm0,       (%rdi)  /* 목적지: NT 스토어 (캐시 우회) */
    vmovntdq %ymm1,       32(%rdi) /* Write-Combining Buffer 사용 */
    add      $64, %rsi
    add      $64, %rdi
    sub      $64, %rcx
    jg       .memcpy_nt_loop
    sfence                        /* NT 스토어 가시성 보장 (필수!) */
    vzeroupper

ERMS / FSRM vs AVX 수동 루프 선택 로직

/* 커널이 런타임에 memcpy 전략 선택 — alternatives 메커니즘 */
/* arch/x86/lib/memcpy_64.S에서 alternatives 패치로 결정 */

/* FSRM 검사 예시 (arch/x86/include/asm/cpufeatures.h) */
#define X86_FEATURE_ERMS   (0*32+9) /* Enhanced REP MOVSB/STOSB */
#define X86_FEATURE_FSRM   (3*32+4) /* Fast Short REP MOVSB */

/* 런타임 기능 검사 */
if (static_cpu_has(X86_FEATURE_FSRM)) {
    /* rep movsb → 하드웨어가 최적화 수행 */
    asm volatile("rep movsb"
                 : "+D"(dst), "+S"(src), "+c"(len) :: "memory");
} else if (static_cpu_has(X86_FEATURE_AVX2)) {
    __memcpy_avx2(dst, src, len); /* AVX2 수동 루프 */
} else {
    __memcpy_sse2(dst, src, len); /* SSE2 fallback */
}

Non-Temporal 스토어와 sfence

/* Non-Temporal 스토어 사용 패턴 — 커널 대형 복사 핵심 */
/*
 * 일반 스토어: 데이터를 캐시에 올리고 → 메모리에 쓰기
 *   → 대형 복사 시 캐시를 오염시켜 다른 데이터 축출
 *
 * NT 스토어: Write-Combining Buffer(WCB)에 누적 → 메모리 직접 기록
 *   → 캐시 오염 없음, 메모리 대역폭 집중 활용
 *   → 단, sfence로 WCB 플러시 보장 필수
 */

void large_memcpy_nt(void *dst, const void *src, size_t len)
{
    kernel_fpu_begin();

    asm volatile(
        ".Lnt_loop:\\n"
        "vmovdqu  (%[s]),    %%ymm0\\n"  /* 소스: 일반 로드 */
        "vmovdqu  32(%[s]),  %%ymm1\\n"
        "vmovntdq %%ymm0,   (%[d])\\n"   /* 목적지: NT 스토어 */
        "vmovntdq %%ymm1,   32(%[d])\\n"
        "add      $64, %[s]\\n"
        "add      $64, %[d]\\n"
        "sub      $64, %[n]\\n"
        "jg       .Lnt_loop\\n"
        "sfence\\n"                       /* NT 스토어 완료 보장 */
        "vzeroupper\\n"                   /* AVX→SSE 전환 페널티 방지 */
        : [d] "+r"(dst), [s] "+r"(src), [n] "+r"(len)
        :: "ymm0", "ymm1", "memory"
    );

    kernel_fpu_end();
}

/* 경고: sfence 없이 NT 스토어를 사용하면 다른 CPU 코어에서
 * 데이터가 보이지 않을 수 있음 (Write-Combining Buffer에 잔류).
 * 특히 DMA, 크로스-CPU 공유 메모리 시나리오에서 치명적. */

AVX-512 커널 사용 시 특별 주의

SIMD 대안: 컴파일러 자동 벡터화

/* 커널 코드에서 직접 SIMD 인라인 어셈블리 대신 */
/* 컴파일러 자동 벡터화를 활용하는 방법 */

/* GCC/Clang __attribute__((target)) 으로 특정 ISA 확장 활성화 */
__attribute__((target("avx2")))
void xor_block_avx2(u8 *dst, const u8 *src, size_t len)
{
    /* 컴파일러가 루프를 자동으로 AVX2 벡터화 */
    for (size_t i = 0; i < len; i++)
        dst[i] ^= src[i];
}

/* 주의: 커널 빌드 시 기본적으로 -mno-sse, -mno-mmx 플래그 적용 */
/* SIMD를 사용하는 .c 파일은 Makefile에서 명시적으로 활성화: */
/* CFLAGS_myfile.o += -msse2 -mavx2 */

# GCC 벡터화 보고서: -fopt-info-vec
gcc -O2 -march=native -fopt-info-vec-optimized myfile.c -o myfile
# 출력 예시:
# myfile.c:42:5: optimized: loop vectorized using 32-byte vectors
# myfile.c:58:5: optimized: basic block part vectorized using 32-byte vectors
# myfile.c:71:5: missed: couldn't vectorize loop (data dependency)

# 벡터화 실패 원인 상세 확인
gcc -O2 -march=native -fopt-info-vec-missed myfile.c -o myfile
# 실패 이유: aliasing, 정렬 불확실, 복잡한 제어 흐름 등

# __builtin_assume_aligned으로 힌트 제공
# void process(float *p, size_t n) {
#     p = __builtin_assume_aligned(p, 32);  // 32B 정렬 보장
#     for (size_t i = 0; i < n; i++) p[i] *= 2.0f;  // 자동 벡터화
# }

SIMD 코드 디버깅과 성능 분석

# SIMD 레지스터 확인 (GDB)
(gdb) info vector                   # SSE/AVX 레지스터 전체 출력
(gdb) p $xmm0.v4_float              # XMM0을 4개 float로 해석
(gdb) p $xmm0.v16_int8              # XMM0을 16개 int8로 해석
(gdb) p $ymm0.v8_int32              # YMM0을 8개 int32로 해석
(gdb) p $zmm0.v64_int8              # ZMM0을 64개 int8로 해석

# perf로 SIMD 명령어 사용 분석
perf stat -e fp_arith_inst_retired.128b_packed_single \
          -e fp_arith_inst_retired.256b_packed_single \
          -e fp_arith_inst_retired.512b_packed_single \
          -- ./my_program
# 128/256/512비트 packed FP 명령어 사용 횟수 측정

# AVX-512 다운클럭 모니터링
perf stat -e core_power.lvl0_turbo_license \
          -e core_power.lvl1_turbo_license \
          -e core_power.lvl2_turbo_license \
          -- ./my_program
# Level 0=기본, Level 1=AVX2 offset, Level 2=AVX-512 offset

# 커널 RAID6 벤치마크 결과 확인
dmesg | grep raid6
# raid6: avx512x4  gen() 29430 MB/s
# raid6: using algorithm avx512x4 gen() 29430 MB/s

# 현재 CPU의 SIMD 지원 확인
grep -o 'sse\|sse2\|ssse3\|sse4_1\|sse4_2\|avx\|avx2\|avx512' /proc/cpuinfo | sort -u

# XSAVE 상태 크기 확인
cat /proc/cpuinfo | grep -o 'xsave[^ ]*'

# Intel PMU SIMD 전용 이벤트 (Skylake 기준)
perf stat -e avx_insts.all \
          -e fp_arith_inst_retired.256b_packed_single \
          -e fp_arith_inst_retired.256b_packed_double \
          -e fp_arith_inst_retired.512b_packed_single \
          -- ./my_program
# avx_insts.all: AVX/AVX2/AVX-512 명령어 총 실행 횟수

# SSE-AVX 전환 페널티 측정
perf stat -e assists.sse_avx_mix -- ./my_program
# 0이 아닌 값 → VEX/EVEX 인코딩 혼용 → vzeroupper 누락 의심

SIMD 명령어는 objdump으로 확인할 수 있습니다:

objdump -d vmlinux | grep -E 'vmov|vpxor|vaes|vpshufb|vpadd'

커널 SIMD 코드의 일반적인 실수와 디버깅:

1. kernel_fpu_begin/end 누락
   • 증상: 유저 프로세스의 부동소수점 결과가 무작위로 틀립니다.
   • 진단: KASAN/UBSAN으로는 감지할 수 없습니다. CONFIG_X86_DEBUG_FPU를 활성화해야 합니다.
2. clobber 리스트 누락
   • 증상: 최적화 수준에 따라 간헐적 오류가 발생합니다.
   • 진단: -O0에서 정상이고 -O2에서 비정상이면 clobber를 확인합니다.
3. 정렬 문제
   • 증상: movaps에서 #GP (General Protection) 예외가 발생합니다.
   • 해결: movdqu/vmovdqu (비정렬 변종) 사용 또는 __attribute__((aligned(32)))으로 정렬을 보장합니다.
4. SSE/AVX 전환 페널티
   • 증상: 예상보다 성능이 낮습니다.
   • 진단: perf stat -e assists.sse_avx_mix로 확인합니다.
   • 해결: VZEROUPPER로 상위 YMM을 클리어하거나 VEX 인코딩을 통일합니다.

VZEROUPPER와 SSE/AVX 전환

/* AVX→SSE 전환 시 발생하는 성능 페널티 방지 */
/*
 * 문제: AVX 코드(ymm 사용)에서 SSE 코드(xmm만 사용)로 전환 시,
 *       CPU가 상위 128비트 상태를 추적하느라 성능 저하
 *
 * Intel Sandy Bridge~Haswell: 큰 전환 페널티
 * Intel Skylake+: "dirty upper state" 추적 비용 (더 작지만 존재)
 * AMD Zen: 전환 페널티 없음 (다른 물리 레지스터 파일)
 */

/* AVX 코드 종료 시 반드시 실행 */
vzeroupper                       /* 모든 YMM/ZMM의 상위 비트를 0으로 */

/* 커널에서의 적용: kernel_fpu_end() 전에 호출 */
/* 또는 AVX 함수 끝에 __attribute__((target("avx"))) + vzeroupper */

/* 커널 crypto 코드에서의 전형적 패턴 */
asm volatile(
    /* ... AVX2 연산 ... */
    "vzeroupper"                 /* SSE 코드로 돌아가기 전 필수 */
    ::: "ymm0", "ymm1", ..., "memory"
);

하이브리드 CPU AVX-512 비대칭 처리

Intel Alder Lake(12세대) 이후 하이브리드 CPU는 P-core(고성능)와 E-core(효율) 간 SIMD 지원 능력이 비대칭적입니다. 커널은 이 차이를 투명하게 처리하기 위한 특별한 로직을 포함합니다.

/* 커널의 하이브리드 CPU AVX-512 처리 전략
 * arch/x86/kernel/cpu/intel.c */

/* Alder Lake/Raptor Lake에서 BIOS가 AVX-512를 CPUID에 노출할 수 있음.
 * 하지만 E-core가 없으면 P-core에서만 실행할 때 문제가 없습니다.
 * E-core 존재 시: 태스크가 E-core로 이주되면 AVX-512 명령 → #UD 예외!
 *
 * 커널 해결책: 하이브리드 CPU에서 E-core AVX-512 미지원 감지 시
 * CPUID에서 AVX-512 비트를 강제 클리어하여 사용 불가 처리 */

static void intel_clear_avx512_on_hybrid(struct cpuinfo_x86 *c)
{
    if (cpu_feature_enabled(X86_FEATURE_HYBRID_CPU) &&
        !cpu_feature_enabled(X86_FEATURE_AVX512F_ECORE)) {
        /* E-core가 AVX-512를 지원하지 않으면 시스템 전체에서 비활성화 */
        setup_clear_cpu_cap(X86_FEATURE_AVX512F);
        pr_info("Disabling AVX-512 on hybrid CPU (E-core lacks support)\n");
    }
}

/* 런타임 AVX-512 사용 가능 여부 확인 패턴 */
void my_simd_function(u8 *data, size_t len)
{
    if (cpu_feature_enabled(X86_FEATURE_AVX512F)) {
        /* AVX-512 경로: 커널이 시스템 전체에서 안전 보장 */
        kernel_fpu_begin();
        process_avx512(data, len);
        kernel_fpu_end();
    } else if (cpu_feature_enabled(X86_FEATURE_AVX2)) {
        /* AVX2 fallback */
        kernel_fpu_begin();
        process_avx2(data, len);
        kernel_fpu_end();
    } else {
        /* 스칼라 fallback (항상 동작) */
        process_scalar(data, len);
    }
}

/* clearcpuid 부트 파라미터로 수동 비활성화:
 *   clearcpuid=avx512f     → AVX-512F 비활성화
 *   clearcpuid=avx512f,avx → AVX-512와 AVX 모두 비활성화
 *
 * /proc/cpuinfo에서 확인:
 *   grep avx512 /proc/cpuinfo  → 항목 없으면 비활성화됨
 */

SIMD 성능 엔지니어링

SIMD 명령어를 사용한다고 자동으로 성능이 향상되지 않습니다. 레지스터 압력, 명령어 수준 병렬성(ILP), 실행 포트 병목(Bottleneck), 메모리 대역폭 한계를 이해해야 최적의 SIMD 코드를 작성할 수 있습니다.

레지스터 압력과 스택 스필

/* 레지스터 압력(Register Pressure) — SIMD 성능의 핵심 제약 */
/*
 * 사용 가능한 벡터 레지스터 수:
 *
 *   ISA              벡터 레지스터    마스크 레지스터
 *   ─────────────────────────────────────────────────
 *   SSE/AVX          16개 (xmm/ymm)   없음
 *   AVX-512          32개 (zmm)        8개 (k0-k7)
 *   ARM NEON         32개 (v0-v31)     없음
 *   ARM SVE          32개 (z0-z31)     16개 (p0-p15)
 *   RISC-V RVV       32개 (v0-v31)     v0 (1개)
 *
 * LMUL/레지스터 그룹핑 시 사용 가능 수 감소:
 *   RVV LMUL=4 → 8개 논리 레지스터
 *   RVV LMUL=8 → 4개 논리 레지스터 (매우 제한적)
 */

/* 레지스터가 부족하면 스택 스필(Stack Spill) 발생 */
/*
 * ❌ 나쁜 예: 너무 많은 라이브 변수 (SSE/AVX, 16개 레지스터)
 *
 * void bad_example(float *a, float *b, float *c, ...) {
 *     __m256 v0 = _mm256_load_ps(a);
 *     __m256 v1 = _mm256_load_ps(b);
 *     __m256 v2 = _mm256_load_ps(c);
 *     ...
 *     __m256 v17 = _mm256_load_ps(r);  // 17번째 → 스택에 스필!
 *     // vmovaps %ymm0, -0x120(%rsp)  ← 레지스터 → 스택 저장
 *     // ... 나중에 ...
 *     // vmovaps -0x120(%rsp), %ymm0  ← 스택 → 레지스터 복원
 * }
 *
 * 스필 비용: ymm 스필 = L1 캐시 접근 (~4 사이클)
 *           zmm 스필 = L1 캐시 접근 (~5-6 사이클, 64바이트)
 *
 * ✓ 좋은 예: 루프 내에서 8-12개 레지스터만 라이브
 */

/* 커널 인라인 asm에서의 clobber 목록 관리 */
asm volatile(
    /* 8개 레지스터만 사용 → 나머지 8개는 컴파일러가 활용 가능 */
    "vmovdqu (%[src]), %%ymm0\n"
    "vmovdqu 32(%[src]), %%ymm1\n"
    "vmovdqu 64(%[src]), %%ymm2\n"
    "vmovdqu 96(%[src]), %%ymm3\n"
    "vpxor   %%ymm4, %%ymm0, %%ymm0\n"
    "vpxor   %%ymm5, %%ymm1, %%ymm1\n"
    "vpxor   %%ymm6, %%ymm2, %%ymm2\n"
    "vpxor   %%ymm7, %%ymm3, %%ymm3\n"
    "vzeroupper\n"
    :: [src] "r"(src)
    : "ymm0", "ymm1", "ymm2", "ymm3",
      "ymm4", "ymm5", "ymm6", "ymm7", "memory"
    /* ⚠ clobber에 ymm0-ymm7을 명시 → 컴파일러가 이 레지스터를 다른 용도로 쓰지 않음 */
    /* clobber 목록이 너무 크면(16개 전부) 컴파일러가 주변 코드에서 스필 유발 */
);

명령어 수준 병렬성(ILP)과 파이프라이닝

/* ILP(Instruction-Level Parallelism) — SIMD 처리량 극대화 */

/* ❌ 데이터 의존성 체인 — 직렬 실행, ILP 없음 */
/*
 * vaddps %ymm0, %ymm1, %ymm1    ; 3 사이클 레이턴시
 * vaddps %ymm1, %ymm2, %ymm2    ; ← ymm1 대기 (3 사이클)
 * vaddps %ymm2, %ymm3, %ymm3    ; ← ymm2 대기 (3 사이클)
 * vaddps %ymm3, %ymm4, %ymm4    ; ← ymm3 대기 (3 사이클)
 * 총: 4 × 3 = 12 사이클 (의존성 체인 길이)
 */

/* ✓ 독립 연산으로 ILP 확보 — 병렬 실행 */
/*
 * vaddps %ymm0, %ymm1, %ymm1    ; 포트 0/1에서 실행
 * vaddps %ymm2, %ymm3, %ymm3    ; 동시에 다른 포트에서 실행 (독립)
 * vaddps %ymm4, %ymm5, %ymm5    ; 동시에 실행 가능 (독립)
 * vaddps %ymm6, %ymm7, %ymm7    ; 동시에 실행 가능 (독립)
 * 총: ~3-4 사이클 (4개가 병렬 실행)
 */

/* SIMD 명령어 레이턴시 vs 처리량 (Skylake/Ice Lake) */
/*
 * 명령어                레이턴시  처리량(CPI)  실행 포트
 * ──────────────────────────────────────────────────────
 * vaddps  (FP 덧셈)     4 clk    0.5 (p0/p1)  FMA 유닛
 * vmulps  (FP 곱셈)     4 clk    0.5 (p0/p1)  FMA 유닛
 * vfmadd* (FMA)         4 clk    0.5 (p0/p1)  FMA 유닛
 * vpaddd  (INT 덧셈)    1 clk    0.33 (p0/p1/p5) 다중 포트
 * vpshufb (바이트셔플)  1 clk    0.5 (p5)     셔플 유닛
 * vaesenc (AES 라운드)  4 clk    1.0 (p0)     AES 유닛
 * vdivps  (FP 나눗셈)  11 clk    5.0 (p0)     분할기
 * vsqrtps (제곱근)     12 clk    6.0 (p0)     분할기
 *
 * 핵심: 레이턴시가 높은 명령어(div, sqrt, AES)는
 *       독립된 연산을 인터리빙하여 파이프라인 채워야 함
 */

/* AES-NI 파이프라이닝 예시 — 커널 crypto 코드의 실제 패턴 */
/* arch/x86/crypto/aesni-intel_asm.S 스타일 */

/* ❌ 단일 블록 AES — 파이프라인 미활용 */
aesenc  %xmm0, %xmm1            ; 라운드 1 → 4 사이클 대기
aesenc  %xmm0, %xmm1            ; 라운드 2 → 4 사이클 대기
; ... 총 10 라운드 = 40 사이클/블록

/* ✓ 4블록 인터리빙 AES — 파이프라인 충만 */
aesenc  %xmm0, %xmm1            ; 블록1 라운드1 (포트0 사용)
aesenc  %xmm0, %xmm2            ; 블록2 라운드1 (다음 사이클, 독립)
aesenc  %xmm0, %xmm3            ; 블록3 라운드1
aesenc  %xmm0, %xmm4            ; 블록4 라운드1
aesenc  %xmm0, %xmm1            ; 블록1 라운드2 (xmm1 ready)
aesenc  %xmm0, %xmm2            ; 블록2 라운드2
; ... 4블록 × 10라운드 = 40 aesenc → ~10-12 사이클/블록
; 처리량: 단일 블록 대비 ~3.5x 향상!

메모리 대역폭과 SIMD

SIMD 코드의 병목 판별 — 연산 vs 메모리

산술 강도(Arithmetic Intensity) = 연산 수 / 메모리 접근 바이트

메모리 바운드 (산술강도 ≤ 2): SIMD 레지스터 폭을 늘려도 성능 향상이 제한적입니다. NT 스토어, 프리페치, 캐시 최적화가 더 효과적이며, memcpy의 경우 REP MOVSB(FSRM)이 AVX보다 나을 수 있습니다.

연산 바운드 (산술강도 ≥ 4): SIMD 폭 증가가 직접적인 성능 향상으로 이어집니다. AES는 128-bit SSE → 256-bit AVX → 512-bit VAES로, SHA는 파이프라인 인터리빙으로 처리량을 극대화합니다.

커널 memcpy에서 SIMD가 유리한 구간:

perf stat으로 확인할 수 있습니다:

perf stat -e L1-dcache-load-misses,LLC-load-misses \
  -- taskset -c 0 dd if=/dev/dm-0 of=/dev/null bs=4K count=10000

RISC-V 벡터 확장 (RVV)

RISC-V V 확장(RVV 1.0, 2021년 비준)은 ARM SVE와 유사한 벡터 길이 비종속(VLA) 프로그래밍 모델을 채택합니다. 하드웨어 구현에 따라 VLEN(최소 128비트, 최대 65536비트)이 달라지며, 동일 바이너리가 모든 구현에서 동작합니다. 커널에서의 RVV 사용은 ARM NEON/SVE와 동일한 원칙(FPU 상태 보존, preempt 비활성화)을 따릅니다.

RVV 핵심 명령어

/* RISC-V 벡터 확장 — 핵심 명령어 패턴 */

/* === vsetvli: 벡터 길이/타입 설정 (모든 벡터 연산 전에 필수) === */
vsetvli a0, a1, e32, m4, ta, ma
/*   a0 = 실제 처리될 요소 수 (출력)
 *   a1 = 요청 요소 수 (AVL: Application Vector Length)
 *   e32 = SEW=32비트 요소
 *   m4  = LMUL=4 (v0-v3 그룹으로 사용)
 *   ta  = tail agnostic (테일 요소 미정의)
 *   ma  = mask agnostic (마스크 비활성 요소 미정의) */

vsetivli a0, 16, e8, m1, ta, ma
/* 즉시값 16으로 AVL 설정 (vsetvli의 즉시값 변종) */

/* === 벡터 로드/스토어 === */
vle32.v  v4, (a0)              /* 연속 로드: 32비트 요소, v4에 저장 */
vse32.v  v4, (a1)              /* 연속 스토어 */
vlse32.v v4, (a0), a2          /* Strided 로드: stride = a2 바이트 간격 */
vluxei32.v v4, (a0), v8        /* Indexed(Gather): base + v8[i]*4 */
vsuxei32.v v4, (a0), v8        /* Indexed(Scatter): v4[i] → base + v8[i]*4 */

/* 마스크 기반 로드 (v0이 마스크 레지스터) */
vle32.v  v4, (a0), v0.t        /* v0[i]=1인 요소만 로드, 나머지 유지 */

/* === 벡터 산술 === */
vadd.vv  v4, v8, v12           /* v4[i] = v8[i] + v12[i] */
vadd.vx  v4, v8, a0            /* v4[i] = v8[i] + a0 (스칼라 브로드캐스트) */
vadd.vi  v4, v8, 5             /* v4[i] = v8[i] + 5 (즉시값) */
vsub.vv  v4, v8, v12           /* 뺄셈 */
vmul.vv  v4, v8, v12           /* 곱셈 */
vmacc.vv v4, v8, v12           /* v4[i] += v8[i] * v12[i] (Multiply-Accumulate) */

/* === 벡터 논리/시프트 === */
vxor.vv  v4, v8, v12           /* XOR (RAID, 암호에 핵심) */
vand.vv  v4, v8, v12           /* AND */
vor.vv   v4, v8, v12           /* OR */
vsll.vx  v4, v8, a0            /* 좌측 시프트 (스칼라) */
vsrl.vv  v4, v8, v12           /* 논리 우측 시프트 */

/* === 비교 → 마스크 레지스터 === */
vmseq.vv v0, v4, v8            /* v0[i] = (v4[i] == v8[i]) ? 1 : 0 */
vmslt.vv v0, v4, v8            /* v0[i] = (v4[i] < v8[i]) ? 1 : 0 */
vcpop.m  a0, v0                /* a0 = popcount(v0) 활성 요소 수 */
vfirst.m a0, v0                /* a0 = 첫 번째 활성 비트 인덱스 */

/* === 리덕션 (벡터 → 스칼라) === */
vredsum.vs v4, v8, v12         /* v4[0] = v12[0] + sum(v8[0..vl-1]) */
vredmax.vs v4, v8, v12         /* v4[0] = max(v12[0], max(v8[0..vl-1])) */
vredxor.vs v4, v8, v12         /* v4[0] = v12[0] ^ xor(v8[0..vl-1]) */

/* === 퍼뮤테이션 === */
vslidedown.vx v4, v8, a0       /* v4[i] = v8[i + a0] (요소 슬라이드 다운) */
vslideup.vx   v4, v8, a0       /* v4[i + a0] = v8[i] (요소 슬라이드 업) */
vrgather.vv   v4, v8, v12      /* v4[i] = v8[v12[i]] (임의 퍼뮤트) */
vcompress.vm  v4, v8, v0       /* v0=1인 요소만 v4에 밀착 배치 */

커널 RVV 사용 패턴

/* arch/riscv/include/asm/vector.h — 커널 벡터 API */
#include <asm/vector.h>

/* 커널에서 RVV 사용 전 필수 API */
void my_rvv_xor(u8 *dst, const u8 *src, size_t len)
{
    if (!has_vector())
        return my_scalar_xor(dst, src, len);

    kernel_vector_begin();    /* preempt_disable() + 벡터 상태 저장 */

    /* RVV 명령어 사용 가능 구간 */
    asm volatile(
        "1:\\n"
        "  vsetvli t0, %[len], e8, m8, ta, ma\\n"
        "  vle8.v  v0, (%[src])\\n"
        "  vle8.v  v8, (%[dst])\\n"
        "  vxor.vv v8, v8, v0\\n"
        "  vse8.v  v8, (%[dst])\\n"
        "  add     %[src], %[src], t0\\n"
        "  add     %[dst], %[dst], t0\\n"
        "  sub     %[len], %[len], t0\\n"
        "  bnez    %[len], 1b\\n"
        : [dst] "+r"(dst), [src] "+r"(src), [len] "+r"(len)
        :: "t0", "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7",
           "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15",
           "memory"
    );

    kernel_vector_end();      /* preempt_enable() + lazy restore 설정 */
}

/* 벡터 상태 관리 내부 — arch/riscv/kernel/vector.c */
/*
 * kernel_vector_begin():
 *   1. preempt_disable()
 *   2. 현재 태스크의 벡터 상태가 레지스터에 live이면 메모리에 저장
 *      → riscv_v_vstate_save(current, task_pt_regs(current))
 *   3. 벡터 레지스터를 커널이 자유롭게 사용 가능
 *
 * kernel_vector_end():
 *   1. TIF_RISCV_V_DEFER_RESTORE 플래그 설정 (lazy restore)
 *   2. preempt_enable()
 *   3. 다음 유저 복귀 시 벡터 상태 복원
 *
 * 컨텍스트 스위치 시:
 *   riscv_v_vstate_save()  → vsseg/vse 명령어로 벡터 레지스터 저장
 *   riscv_v_vstate_restore() → vlseg/vle 명령어로 복원
 *   저장 크기: 32 × VLEN/8 바이트 (VLEN=256 → 1024바이트)
 */

/* 커널 RVV 활용 사례 (v6.5+) */
/* arch/riscv/lib/xor.S          — RAID XOR 벡터화 */
/* arch/riscv/crypto/aes-riscv64-zvkned.S — AES (Zvkned 확장) */
/* arch/riscv/crypto/sha256-riscv64-zvknha.S — SHA-256 (Zvknha 확장) */
/* arch/riscv/crypto/chacha-riscv64-zvkb.S  — ChaCha20 (Zvkb 확장) */
/* arch/riscv/lib/memcpy.S       — 벡터화된 memcpy */
/* arch/riscv/lib/memset.S       — 벡터화된 memset */

AMX — 행렬 연산 가속

Intel AMX(Advanced Matrix Extensions)는 Sapphire Rapids(2023)에서 도입된 타일 기반 행렬 곱셈 가속기입니다. 8개의 타일 레지스터(TMM0-TMM7, 각 최대 1KB)를 사용하여 INT8/BF16 행렬 외적(Outer Product)을 하드웨어에서 수행합니다. 커널에서는 직접 사용하지 않지만, 유저 공간 상태 관리가 커널의 핵심 역할입니다.

/* 커널의 AMX 상태 관리 — Lazy Allocation via XFD */
/*
 * 문제: AMX TILEDATA는 태스크당 8,192바이트. 모든 프로세스에
 *       미리 할당하면 메모리 낭비 (대부분의 프로세스는 AMX를 쓰지 않음)
 *
 * 해결: XFD (eXtended Feature Disable) 메커니즘
 *
 *   1. 프로세스 생성 시: TILEDATA에 대한 XFD 비트 = 1 (사용 금지)
 *   2. 처음 TILELOAD/TDPB* 명령 실행 시: CPU가 #NM 예외 발생
 *   3. 커널 #NM 핸들러:
 *      a. TILEDATA용 8,192바이트 메모리 동적 할당
 *      b. thread.fpu.fpstate 확장
 *      c. XFD 비트 = 0으로 클리어 (이제 AMX 사용 가능)
 *   4. 이후 컨텍스트 스위치에서 XSAVE/XRSTOR로 저장/복원
 *
 * → 실제로 AMX를 사용하는 프로세스만 8KB 추가 메모리 소비
 */

/* arch/x86/kernel/fpu/xstate.c */
static int xfd_enable_feature(u64 xfd_err)
{
    struct fpu *fpu = &current->thread.fpu;
    int ret;

    /* TILEDATA 요청인지 확인 */
    if (!(xfd_err & XFEATURE_MASK_XTILE_DATA))
        return -EINVAL;

    /* fpstate를 확장하여 TILEDATA 공간 할당 */
    ret = fpstate_realloc(xfd_err, 0, fpu);
    if (ret)
        return ret;

    /* XFD MSR에서 해당 비트 클리어 → 이후 AMX 명령 정상 실행 */
    xfd_update_state(fpu->fpstate);
    return 0;
}

/* AMX 명령어 요약 */
/*
 * ldtilecfg  mem64  — TILECFG를 메모리에서 로드 (팔레트, 행/열 설정)
 * sttilecfg  mem64  — TILECFG를 메모리에 저장
 * tileloadd  tmm, mem — 타일에 행렬 데이터 로드 (stride 지정)
 * tilestored mem, tmm — 타일에서 행렬 데이터 저장
 * tilerelease        — 모든 타일 상태 해제 (INIT 상태로)
 * tilezero   tmm     — 지정 타일을 0으로 초기화
 *
 * tdpbssd  tmm0, tmm1, tmm2 — C += A × B (signed×signed → int32)
 * tdpbsud  tmm0, tmm1, tmm2 — C += A × B (signed×unsigned → int32)
 * tdpbusd  tmm0, tmm1, tmm2 — C += A × B (unsigned×signed → int32)
 * tdpbuud  tmm0, tmm1, tmm2 — C += A × B (unsigned×unsigned → int32)
 * tdpbf16ps tmm0, tmm1, tmm2 — C += A × B (BF16×BF16 → FP32)
 * tdpfp16ps tmm0, tmm1, tmm2 — C += A × B (FP16×FP16 → FP32, AMX-FP16)
 */

/* XSAVE 크기 비교 (태스크당 FPU 상태 메모리) */
/*
 * SSE만 사용:     ~576 바이트
 * + AVX:          ~832 바이트  (+256)
 * + AVX-512:      ~2,688 바이트 (+1,856)
 * + AMX:          ~10,880 바이트 (+8,192)
 *
 * → AMX 활성 프로세스는 컨텍스트 스위치 시 ~10KB 저장/복원
 * → XFD Lazy Allocation으로 실제 사용 프로세스만 부담
 */

아키텍처별 SIMD 비교

x86, ARM, RISC-V 세 아키텍처의 SIMD 확장을 직접 비교합니다. 커널 개발자가 크로스 플랫폼 SIMD 코드를 작성할 때 참고할 수 있습니다.

크로스 아키텍처 커널 SIMD 코드 패턴

/* 커널에서 아키텍처 독립적 SIMD 가속 구현 패턴 */
/* 예: crypto 서브시스템의 multi-arch 알고리즘 등록 */

/* === 아키텍처별 구현 파일 구조 === */
/*
 * crypto/chacha_generic.c          ← 순수 C fallback (모든 아키텍처)
 * arch/x86/crypto/chacha_glue.c    ← x86 SIMD 가속 (SSE3/AVX2/AVX-512)
 * arch/arm64/crypto/chacha-neon-glue.c ← ARM64 NEON 가속
 * arch/riscv/crypto/chacha-riscv64-zvkb.S ← RISC-V RVV 가속
 *
 * 각 아키텍처 구현은 동일한 crypto API 인터페이스를 제공:
 *   .cra_name = "chacha20"
 *   .cra_priority = 300 (SIMD) > 100 (generic)
 *   → 런타임에 가장 높은 우선순위의 구현이 자동 선택
 */

/* 조건부 컴파일 가드 패턴 */
#if defined(CONFIG_X86_64)
#include <asm/fpu/api.h>
#define SIMD_BEGIN()  kernel_fpu_begin()
#define SIMD_END()    kernel_fpu_end()
#define HAS_SIMD      cpu_feature_enabled(X86_FEATURE_AVX2)

#elif defined(CONFIG_ARM64)
#include <asm/neon.h>
#define SIMD_BEGIN()  kernel_neon_begin()
#define SIMD_END()    kernel_neon_end()
#define HAS_SIMD      cpu_have_named_feature(ASIMD)

#elif defined(CONFIG_RISCV) && defined(CONFIG_RISCV_ISA_V)
#include <asm/vector.h>
#define SIMD_BEGIN()  kernel_vector_begin()
#define SIMD_END()    kernel_vector_end()
#define HAS_SIMD      has_vector()

#else
#define HAS_SIMD      0
#endif

/* 공통 호출 패턴 */
void my_crypto_op(u8 *dst, const u8 *src, size_t len)
{
    if (HAS_SIMD && may_use_simd()) {
        SIMD_BEGIN();
        my_crypto_simd(dst, src, len); /* arch별 SIMD 구현 */
        SIMD_END();
    } else {
        my_crypto_generic(dst, src, len); /* C fallback */
    }
}

/* may_use_simd(): softirq/hardirq 컨텍스트에서는 false 반환
 * → 이미 다른 코드가 FPU를 사용 중일 수 있으므로 중첩 방지
 * → crypto API의 simd_skcipher 래퍼가 자동으로 cryptd 워크큐 fallback */

커널 암호 서브시스템 SIMD 통합 상세

Linux crypto API는 SIMD 가속을 투명하게 관리하는 다층 구조를 제공합니다. 디스크 암호화(dm-crypt), 네트워크 암호화(IPsec/WireGuard), 파일시스템(Filesystem) 암호화(fscrypt)가 모두 이 프레임워크를 통해 SIMD 가속의 혜택을 받습니다.

dm-crypt SIMD 가속 경로

dm-crypt 디스크 암호화의 SIMD 가속 데이터 흐름:

1. 유저 write() 호출
2. VFS → Block Layer → dm-crypt
3. dm-crypt가 crypto API를 호출합니다:

   skcipher_request_set_crypt(req, src_sg, dst_sg, nbytes, iv);
   crypto_skcipher_encrypt(req);

4. crypto API 내부 동작:
   • process context (kcryptd 워크큐): may_use_simd() == true이면 kernel_fpu_begin() → AES-NI/VAES로 직접 암호화 → kernel_fpu_end()
   • softirq context (드물지만 가능): may_use_simd() == false이면 cryptd 워크큐로 지연하거나 aes-generic fallback을 사용합니다.
5. 암호화된 데이터 → Block Layer → 디스크 기록

dm-crypt 성능 최적화 포인트:

• kernel_fpu_begin/end 호출 빈도 최소화: dm-crypt는 여러 섹터를 한 번의 FPU 구간에서 처리합니다. crypto_skcipher_encrypt()가 scatterlist 전체를 처리하며, FPU begin/end는 알고리즘 내부에서 한 번만 호출됩니다.
• 워커 스레드(Thread) 수 조정: kcryptd_crypt 워크큐는 unbound workqueue로 CPU별로 분산됩니다.
• AES-XTS 모드 선택 근거: XTS는 블록 단위 독립적이므로 병렬화에 유리합니다. VAES + AVX-512로 4블록(64B) 동시 암호화가 가능하며, 이전 블록 스토어와 현재 블록 연산을 동시에 수행하는 파이프라이닝을 활용합니다.

dm-crypt 설정 시 SIMD 확인:

$ cat /proc/crypto | grep -A4 "aes"
  driver       : aes-aesni
  module       : aesni_intel
  priority     : 300
  type         : cipher

driver가 "aesni"이면 AES-NI 가속이 활성화된 것이고, "aes-generic"이면 소프트웨어 fallback을 사용 중입니다.

SIMD로 구현된 커널 암호 알고리즘 지도

여기서 중요한 점은 커널 SIMD 암호가 AES 몇 종만의 문제로 끝나지 않는다는 것입니다. 최신 커널 소스를 기준으로 보면 arch/x86/crypto/, arch/arm64/crypto/, arch/riscv/crypto/에는 아키텍처별 등록 구현이 있고, lib/crypto/에는 ChaCha, Poly1305, GHASH, POLYVAL, NH, BLAKE2s, Curve25519, SHA 계열 같은 공용 primitive 최적화가 들어 있습니다. 즉 상위 알고리즘 하나를 빠르게 만들려면 내부 primitive까지 함께 SIMD화되어 있어야 합니다.

이 표를 실무적으로 읽는 방법은 간단합니다. 상위 알고리즘 이름과 실제 SIMD primitive를 분리해서 봐야 합니다. 예를 들어 AES-GCM은 AES 라운드만 빠르다고 끝나지 않고 GHASH도 빨라야 하며, ChaCha20-Poly1305는 ChaCha와 Poly1305 양쪽이 동시에 최적화되어야 의미가 있습니다. Adiantum도 마찬가지로 XChaCha12보다 NH와 Poly1305 품질이 전체 처리량에 큰 영향을 줍니다.

x86 SIMD crypto 구현 목록

x86은 현재 커널에서 가장 넓은 SIMD 암호 구현 범위를 제공합니다. Kconfig와 실제 소스 파일 기준으로 보면 AES 계열뿐 아니라 Camellia, Serpent, Twofish, ARIA, SM4, AEGIS128까지 별도 SIMD fast path가 존재합니다.

x86에서 놓치기 쉬운 지점은 블록 암호 외의 보조 primitive입니다. lib/crypto에는 x86/chacha-avx2-x86_64.o, x86/chacha-avx512vl-x86_64.o, x86/ghash-pclmul.o, x86/polyval-pclmul-avx.o, x86/poly1305-x86_64-cryptogams.o, x86/sha256-avx2-asm.o, x86/sha1-ni-asm.o, x86/blake2s-core.o가 함께 존재합니다. 따라서 AES-GCM, WireGuard, HCTR2 같은 상위 알고리즘의 실효 성능은 주변 primitive까지 포함한 묶음 최적화 품질로 결정됩니다.

ARM64·RISC-V SIMD crypto 구현 목록

ARM64는 NEON과 ARMv8 Crypto Extensions, RISC-V는 Zvk* 벡터 암호 확장이 중심입니다. 둘 다 x86보다 arch 등록 알고리즘 수는 적어 보일 수 있지만, lib/crypto 층까지 합치면 실제 범위는 꽤 넓습니다.

RISC-V에서 특히 봐야 할 것은 arch/riscv/crypto/보다 lib/crypto/riscv/입니다. 커널은 여기서 chacha-riscv64-zvkb.o, ghash-riscv64-zvkg.o, sha256-riscv64-zvknha_or_zvknhb-zvkb.o, sha512-riscv64-zvknhb-zvkb.o, sm3-riscv64-zvksh-zvkb.o, poly1305-core.o를 함께 제공합니다. 즉 "RISC-V는 AES만 벡터화되었다"라고 이해하면 현재 트리를 지나치게 단순화하게 됩니다.

라이브러리 primitive와 상위 알고리즘의 연결

IPsec/WireGuard SIMD 가속

/* IPsec: ESP 변환에서의 SIMD 사용 */
/*
 * IPsec ESP 패킷(Packet) 처리 경로:
 *   xfrm_output() → esp_output() → crypto_aead_encrypt()
 *   → GCM(AES) = AES-CTR + GHASH
 *
 * AES-CTR: AES-NI/VAES로 가속
 * GHASH:   PCLMULQDQ/VPCLMULQDQ (Galois Field 곱셈)
 *
 * 주의: IPsec은 softirq(NET_RX)에서도 실행됨
 *   → 이미 process ctx에서 FPU 사용 중이면 충돌
 *   → simd_skcipher 래퍼가 자동으로 cryptd 워크큐 fallback
 *
 * ESP 가속 알고리즘 등록:
 *   rfc4106(gcm(aes))  — RFC4106 GCM-AES (IPsec 표준)
 *   cra_driver_name = "rfc4106-gcm-aesni"
 *   cra_priority = 400  (generic보다 높음)
 */

/* WireGuard: ChaCha20-Poly1305 SIMD 가속 */
/*
 * WireGuard는 ChaCha20-Poly1305 AEAD 사용 (고정 알고리즘)
 *
 * ChaCha20:
 *   x86: AVX2로 8블록(512B) 병렬 처리 → ~7 GB/s
 *        AVX-512로 16블록(1KB) 병렬 → ~12 GB/s
 *   ARM64: NEON으로 4블록(256B) 병렬 → ~4 GB/s
 *
 * Poly1305:
 *   x86: AVX2로 radix 2^26 표현, 4-way 병렬 → ~10 GB/s
 *   ARM64: NEON 4-way 병렬 → ~5 GB/s
 *
 * WireGuard 특수성:
 *   chacha20poly1305_encrypt()가 직접 구현 사용 (crypto API 미경유)
 *   → include/crypto/chacha20poly1305.h
 *   → lib/crypto/chacha20poly1305.c + arch별 SIMD 구현
 *   → kernel_fpu_begin/end를 내부에서 직접 관리
 */

/* 실제 WireGuard SIMD 호출 경로 */
/* drivers/net/wireguard/noise.c */
bool chacha20poly1305_encrypt(
    u8 *dst, const u8 *src, const size_t src_len,
    const u8 *ad, const size_t ad_len,
    const u64 nonce, const u8 key[CHACHA20POLY1305_KEY_SIZE])
{
    /* 내부적으로 may_use_simd() 확인 후 경로 분기:
     *   SIMD 가능: chacha20_simd() + poly1305_simd()
     *   SIMD 불가: chacha20_generic() + poly1305_generic()
     */
}

/* 성능 비교: cryptsetup benchmark (4KB 블록) */
/*
 * 알고리즘           generic     AES-NI      AVX2       AVX-512
 * ────────────────────────────────────────────────────────────
 * aes-xts-256        200 MB/s   3,500 MB/s     —       6,000 MB/s
 * chacha20-poly1305  350 MB/s      —        5,500 MB/s  8,000 MB/s
 * aes-gcm-256        180 MB/s   4,200 MB/s     —       7,000 MB/s
 * sha256             250 MB/s   1,200 MB/s     —       2,000 MB/s
 * crc32c             800 MB/s   9,000 MB/s     —          —
 */

x86 데이터 이동 명령어 시각화

SIMD 연산의 첫 단계는 데이터를 메모리에서 레지스터로, 또는 레지스터 간에 이동하는 것입니다. 정렬 여부, 논템포럴 힌트, 브로드캐스트 패턴에 따라 명령어 선택이 성능에 큰 영향을 미칩니다.

x86 스칼라 FP 이동 — MOVSS/VMOVSS와 MOVSD/VMOVSD

MOVSS/VMOVSS와 MOVSD/VMOVSD는 SIMD 레지스터를 사용하지만 실제로는 하위 32비트 또는 64비트만 이동합니다. 중요한 점은 low lane만 바꾸고 나머지 비트를 어떻게 처리하는지가 인코딩마다 다르다는 것입니다. 또한 AVX scalar move는 128비트 form만 유효하므로 VEX.L=0 규칙을 따릅니다. 커널에서 마지막 잔여 원소를 처리하거나, 이미 계산된 XMM 누산기의 low lane만 덮어쓸 때 이 차이를 잘못 이해하면 상위 lane이 남아 오염되거나 반대로 0으로 지워질 수 있습니다.

/* low lane만 새 값으로 교체하고 상위 3개 lane은 그대로 유지 */
#include <immintrin.h>

static inline __m128 replace_lane0_f32(__m128 acc, const float *tail)
{
    __m128 scalar = _mm_load_ss(tail);   /* MOVSS/VMOVSS mem → xmm */
    return _mm_move_ss(acc, scalar);      /* acc[127:32] 유지, low32만 교체 */
}

static inline double load_store_scalar_f64(const double *src)
{
    __m128d v = _mm_load_sd(src);        /* MOVSD/VMOVSD mem → xmm */
    double out;
    _mm_store_sd(&out, v);               /* low64만 저장 */
    return out;
}

/* broadcast + FMA 닷프로덕트: 4×4 float 행렬 곱 한 행 */
#include <immintrin.h>

static inline __m128 dot_row_4x4(
    const float *row_a,   /* 1×4 행 벡터  */
    const float *mat_b)   /* 4×4 열-우선 행렬 */
{
    __m128 col0 = _mm_load_ps(mat_b);       /* B 열 0 */
    __m128 col1 = _mm_load_ps(mat_b + 4);   /* B 열 1 */
    __m128 col2 = _mm_load_ps(mat_b + 8);
    __m128 col3 = _mm_load_ps(mat_b + 12);

    /* a[i]를 broadcast 후 FMA 누적 */
    __m128 sum = _mm_mul_ps(_mm_set1_ps(row_a[0]), col0);
    sum = _mm_fmadd_ps(_mm_set1_ps(row_a[1]), col1, sum);
    sum = _mm_fmadd_ps(_mm_set1_ps(row_a[2]), col2, sum);
    sum = _mm_fmadd_ps(_mm_set1_ps(row_a[3]), col3, sum);
    return sum;  /* 결과 행 [C00,C01,C02,C03] */
}

/* NT store 대용량 memcpy 패턴 — LLC 크기 초과 복사에 유리 */
void nt_memcpy_avx(void *dst, const void *src, size_t n)
{
    const char *s = src;
    char *d = dst;
    for (size_t i = 0; i < n; i += 64) {
        __m256 v0 = _mm256_load_ps((float*)(s + i));
        __m256 v1 = _mm256_load_ps((float*)(s + i + 32));
        _mm256_stream_ps((float*)(d + i),      v0);  /* VMOVNTPS */
        _mm256_stream_ps((float*)(d + i + 32), v1);
    }
    _mm_sfence();  /* NT store 가시성 보장 */
}

x86 정수 산술 명령어 상세

SIMD 정수 산술은 이미지/비디오 코덱, 양자화, 해싱 등에서 핵심입니다. 포화 연산과 확장 곱셈-누적(PMADDWD)은 고정소수점 DSP 패턴의 기반이며, VNNI는 INT8 추론 가속의 핵심입니다.

/* PSADBW 기반 8×8 블록 SAD — 비디오 코덱 모션 추정 핵심 */
#include <immintrin.h>

uint32_t sad_8x8_sse2(const uint8_t *blk1, int stride1,
                       const uint8_t *blk2, int stride2)
{
    __m128i sum = _mm_setzero_si128();
    for (int y = 0; y < 8; y++) {
        __m128i a = _mm_loadl_epi64((__m128i*)(blk1 + y * stride1));
        __m128i b = _mm_loadl_epi64((__m128i*)(blk2 + y * stride2));
        sum = _mm_add_epi64(sum, _mm_sad_epu8(a, b));  /* |a-b| 합 */
    }
    return (uint32_t)_mm_cvtsi128_si32(sum);
}

/* VPDPBUSD (VNNI) INT8 행렬 곱 누적 — 4×u8 · 4×i8 → i32 */
__m256i int8_matmul_vnni(const uint8_t *A, const int8_t *B, int K)
{
    __m256i acc = _mm256_setzero_si256();
    for (int k = 0; k < K; k += 4) {
        __m256i a = _mm256_set1_epi32(*(uint32_t*)(A + k));  /* broadcast 4B */
        __m256i b = _mm256_loadu_si256((__m256i*)(B + k * 8));
        acc = _mm256_dpbusd_epi32(acc, a, b);  /* u8·i8 누적 */
    }
    return acc;
}

x86 부동소수점 SIMD 명령어 상세

FMA(Fused Multiply-Add)는 현대 SIMD 연산의 핵심입니다. 단일 반올림으로 a×b+c를 계산해 정밀도와 처리량 모두 향상시킵니다. 반면 VDIVPS/VSQRTPS는 높은 지연시간으로 병목이 되므로, 근사 역수 + Newton-Raphson 반복이 실전 패턴입니다.

Scalar FP 연산 — ADDSS/MULSS/VDIVSS/VFMADDSS

ADDSS/ADDSD와 VADDSS/VADDSD 계열은 SIMD 레지스터를 사용하지만 계산은 low lane 하나에만 적용합니다. packed 연산으로 올리기 애매한 마지막 잔여 원소, 보상합, 단일 누산기 갱신, vector 루프 뒤의 정리(cleanup) 단계에 적합합니다. 특히 VEX scalar 연산은 결과 low lane만 새로 계산하고 나머지 low 128비트는 merge source에서 복사하므로, 이미 계산된 누산기 상위 lane을 보존하면서 low lane만 갱신하기 쉽습니다.

/* vector 루프 뒤 1개 남은 float를 scalar FMA로 처리 */
#include <immintrin.h>

static inline float tail_fma_ss(const float *x,
                                 const float *y,
                                 float acc)
{
    __m128 vx = _mm_load_ss(x);
    __m128 vy = _mm_load_ss(y);
    __m128 vacc = _mm_set_ss(acc);

    vacc = _mm_fmadd_ss(vx, vy, vacc);  /* low lane만 vx*vy+acc */
    return _mm_cvtss_f32(vacc);
}

/* 커널 inline asm 스타일 scalar update */
static inline float tail_fma_ss_asm(const float *x,
                                     const float *y,
                                     const float *acc)
{
    float out;

    asm volatile(
        "vmovss   (%1), %%xmm1\n\t"         /* low32 = *x, 상위는 0 */
        "vmovss   (%2), %%xmm2\n\t"         /* low32 = *y */
        "vmovss   (%3), %%xmm0\n\t"         /* low32 = acc */
        "vfmadd231ss %%xmm2, %%xmm1, %%xmm0\n\t"
        "vmovss   %%xmm0, %0\n\t"
        : "=m"(out)
        : "r"(x), "r"(y), "r"(acc)
        : "memory", "xmm0", "xmm1", "xmm2");

    return out;
}

/* Newton-Raphson 1/sqrt(x) — 게임 물리, 정규화에서 사용 */
#include <immintrin.h>

static inline __m256 fast_rsqrt_nr(__m256 x)
{
    __m256 half  = _mm256_set1_ps(0.5f);
    __m256 three = _mm256_set1_ps(3.0f);
    __m256 y0    = _mm256_rsqrt_ps(x);              /* 12-bit 초기 근사 */

    /* NR: y1 = 0.5 * y0 * (3 - x * y0 * y0) */
    __m256 xy0   = _mm256_mul_ps(x, y0);
    __m256 xy0y0 = _mm256_mul_ps(xy0, y0);
    __m256 diff  = _mm256_sub_ps(three, xy0y0);
    __m256 y1    = _mm256_mul_ps(_mm256_mul_ps(half, y0), diff);
    return y1;  /* ~23-bit 정밀도 (float 유효숫자 충분) */
}

/* Horner 다항식 FMA 체인 — sin(x) 근사 (5차) */
static inline __m256 horner_sin_approx(__m256 x)
{
    /* sin(x) ≈ x(1 + c3·x² + c5·x⁴) = x·P(x²)
     * Horner: P(x²) = c5·x² + c3, then ×x² +1, then ×x */
    const __m256 c3 = _mm256_set1_ps(-0.16666667f);  /* -1/3! */
    const __m256 c5 = _mm256_set1_ps(0.00833333f);   /* +1/5! */
    const __m256 one = _mm256_set1_ps(1.0f);

    __m256 x2 = _mm256_mul_ps(x, x);
    __m256 p  = _mm256_fmadd_ps(c5, x2, c3);        /* c5·x²+c3 */
    p = _mm256_fmadd_ps(p, x2, one);                 /* p·x²+1 */
    return _mm256_mul_ps(p, x);                      /* p·x */
}

x86 셔플/퍼뮤트 명령어 시각화

셔플과 퍼뮤트는 SIMD 프로그래밍에서 가장 복잡하면서도 가장 강력한 범주입니다. 레인 내/간 데이터 재배치(Relocation)는 AoS↔SoA 변환, 전치, 엔디안 변환의 핵심이며, 명령어마다 고유한 선택 패턴을 가집니다.

/* PSHUFB 엔디안 변환 — 네트워크 바이트 순서 ↔ 호스트 순서 */
#include <immintrin.h>

static inline __m128i bswap32_x4(__m128i v)
{
    /* 각 4바이트 dword 내에서 바이트 역순 */
    const __m128i mask = _mm_set_epi8(
        12,13,14,15,  8, 9,10,11,  4, 5, 6, 7,  0, 1, 2, 3);
    return _mm_shuffle_epi8(v, mask);  /* PSHUFB */
}

/* 4×4 float 행렬 전치 — AoS→SoA 변환 핵심 */
void transpose_4x4_ps(__m128 r0, __m128 r1, __m128 r2, __m128 r3,
                       __m128 *c0, __m128 *c1, __m128 *c2, __m128 *c3)
{
    /* 2단계 unpack으로 전치
     * r0 = [a0 a1 a2 a3], r1 = [b0 b1 b2 b3], ...
     * 결과: c0 = [a0 b0 c0 d0], c1 = [a1 b1 c1 d1], ... */
    __m128 t0 = _mm_unpacklo_ps(r0, r1);  /* [a0 b0 a1 b1] */
    __m128 t1 = _mm_unpackhi_ps(r0, r1);  /* [a2 b2 a3 b3] */
    __m128 t2 = _mm_unpacklo_ps(r2, r3);  /* [c0 d0 c1 d1] */
    __m128 t3 = _mm_unpackhi_ps(r2, r3);  /* [c2 d2 c3 d3] */

    *c0 = _mm_movelh_ps(t0, t2);  /* [a0 b0 c0 d0] */
    *c1 = _mm_movehl_ps(t2, t0);  /* [a1 b1 c1 d1] */
    *c2 = _mm_movelh_ps(t1, t3);  /* [a2 b2 c2 d2] */
    *c3 = _mm_movehl_ps(t3, t1);  /* [a3 b3 c3 d3] */
}

x86 패킹/언패킹/확장 명령어

데이터 폭 변환은 이미지/비디오 파이프라인의 핵심입니다. uint8 픽셀을 float로 올려 연산하고, 결과를 다시 uint8로 내려야 합니다. 인터리브(PUNPCK)와 패킹(PACK) 명령어가 이 "깔때기"를 형성합니다.

/* uint8→float 이미지 업변환 + float→uint8 포화 다운변환 */
#include <immintrin.h>

/* 16×u8 픽셀 → 4×__m128(float) — SSE4.1 PMOVZX 체인 */
void u8_to_float_x16(const uint8_t *src, __m128 out[4])
{
    __m128i raw = _mm_loadu_si128((__m128i*)src);       /* 16×u8 */
    __m128i lo16 = _mm_cvtepu8_epi16(raw);              /* 하위 8→8×u16 */
    __m128i hi16 = _mm_cvtepu8_epi16(_mm_srli_si128(raw, 8));

    out[0] = _mm_cvtepi32_ps(_mm_cvtepu16_epi32(lo16));        /* 4×float */
    out[1] = _mm_cvtepi32_ps(_mm_cvtepu16_epi32(
                 _mm_srli_si128(lo16, 8)));
    out[2] = _mm_cvtepi32_ps(_mm_cvtepu16_epi32(hi16));
    out[3] = _mm_cvtepi32_ps(_mm_cvtepu16_epi32(
                 _mm_srli_si128(hi16, 8)));
}

/* 4×__m128(float) → 16×u8 — 포화 다운변환 */
__m128i float_to_u8_x16(__m128 f0, __m128 f1, __m128 f2, __m128 f3)
{
    __m128i i0 = _mm_cvtps_epi32(f0);                  /* 4×i32 */
    __m128i i1 = _mm_cvtps_epi32(f1);
    __m128i i2 = _mm_cvtps_epi32(f2);
    __m128i i3 = _mm_cvtps_epi32(f3);
    __m128i w01 = _mm_packs_epi32(i0, i1);             /* 8×i16 */
    __m128i w23 = _mm_packs_epi32(i2, i3);
    return _mm_packus_epi16(w01, w23);                  /* 16×u8 포화 */
}

AVX-512 마스크 연산 상세

AVX-512의 핵심 혁신은 8개 전용 마스크 레지스터(k0–k7)입니다. 모든 SIMD 명령에 프레디케이트를 부여해, 분기 없는 조건부 처리와 루프 테일 마스킹을 가능하게 합니다.

/* 분기없는 조건부 처리 — 양수만 제곱근, 음수는 0 */
#include <immintrin.h>

void sqrt_positive_only(float *data, int n)
{
    for (int i = 0; i < n; i += 16) {
        __m512 v = _mm512_loadu_ps(data + i);
        __mmask16 pos = _mm512_cmp_ps_mask(v,
                            _mm512_setzero_ps(), _CMP_GT_OQ);
        /* zeroing 마스크: 음수 레인 → 0, 양수 레인 → sqrt */
        __m512 result = _mm512_maskz_sqrt_ps(pos, v);
        _mm512_storeu_ps(data + i, result);
    }
}

/* 루프 테일 마스킹 — 배열 길이가 16의 배수가 아닐 때 */
float sum_array_avx512(const float *arr, int n)
{
    __m512 acc = _mm512_setzero_ps();
    int i = 0;
    for (; i + 16 <= n; i += 16)
        acc = _mm512_add_ps(acc, _mm512_loadu_ps(arr + i));

    /* 나머지 요소: 마스크로 유효 레인만 처리 */
    if (i < n) {
        __mmask16 tail = (__mmask16)((1u << (n - i)) - 1);
        acc = _mm512_mask_add_ps(acc, tail, acc,
                  _mm512_maskz_loadu_ps(tail, arr + i));
    }
    return _mm512_reduce_add_ps(acc);
}

/* VCOMPRESSPS — 조건 필터링 (양수만 출력) */
int filter_positive_avx512(const float *in, float *out, int n)
{
    int written = 0;
    for (int i = 0; i < n; i += 16) {
        __m512 v = _mm512_loadu_ps(in + i);
        __mmask16 pos = _mm512_cmp_ps_mask(v,
                            _mm512_setzero_ps(), _CMP_GT_OQ);
        _mm512_mask_compressstoreu_ps(out + written, pos, v);
        written += _mm_popcnt_u32((unsigned)pos);
    }
    return written;
}

x86 수평 연산 및 축소

SIMD의 기본 모델은 "수직"(레인별 독립) 연산이지만, 전체 벡터를 하나의 스칼라로 축소(reduction)하거나 인접 쌍을 합산하는 "수평" 연산이 필요한 경우가 있습니다. 수평 명령은 셔플+수직 연산의 조합이므로, 처리량이 낮고 주의가 필요합니다.

/* YMM 8×float → 스칼라 합 (최적 리덕션 패턴) */
#include <immintrin.h>

static inline float hsum_avx(__m256 v)
{
    /* ① 상위 128b를 하위에 더함 */
    __m128 hi = _mm256_extractf128_ps(v, 1);
    __m128 lo = _mm256_castps256_ps128(v);
    __m128 sum4 = _mm_add_ps(lo, hi);       /* 4×float */

    /* ② 상위 64b를 하위에 더함 */
    __m128 shuf = _mm_movehdup_ps(sum4);     /* [s1,s1,s3,s3] */
    __m128 sum2 = _mm_add_ps(sum4, shuf);    /* 2×float */

    /* ③ 인접 교환 후 최종 합 */
    shuf = _mm_movehl_ps(shuf, sum2);
    __m128 sum1 = _mm_add_ss(sum2, shuf);
    return _mm_cvtss_f32(sum1);
}

/* 닷프로덕트 3가지 방식 비교 */

/* 방법 1: DPPS (SSE4.1) — 간단하지만 느림 */
static inline float dot_dpps(__m128 a, __m128 b) {
    return _mm_cvtss_f32(_mm_dp_ps(a, b, 0xF1));
}

/* 방법 2: MUL + HADD×2 — 직관적이지만 비효율 */
static inline float dot_hadd(__m128 a, __m128 b) {
    __m128 prod = _mm_mul_ps(a, b);
    __m128 s1 = _mm_hadd_ps(prod, prod);
    __m128 s2 = _mm_hadd_ps(s1, s1);
    return _mm_cvtss_f32(s2);
}

/* 방법 3: FMA + 셔플 리덕션 — 최적 (권장) */
static inline float dot_fma(__m128 a, __m128 b) {
    __m128 prod = _mm_mul_ps(a, b);
    __m128 shuf = _mm_movehdup_ps(prod);
    __m128 sum2 = _mm_add_ps(prod, shuf);
    shuf = _mm_movehl_ps(shuf, sum2);
    return _mm_cvtss_f32(_mm_add_ss(sum2, shuf));
}

ARM NEON 명령어 시각화

ARM NEON(Advanced SIMD)은 128비트 고정 폭 벡터로, 모바일/임베디드에서 미디어 코덱과 신호 처리의 핵심입니다. x86과 달리 구조적 로드(ld2/3/4)와 테이블 룩업(TBL)이 ISA에 내장되어 있어, 데이터 재배치에서 독보적 효율을 보입니다.

/* NEON LD3 RGB 디인터리브 — x86에서는 셔플 체인 필요 */
#include <arm_neon.h>

void rgb_brightness_neon(uint8_t *img, int n_pixels, uint8_t boost)
{
    uint8x16_t vboost = vdupq_n_u8(boost);
    for (int i = 0; i < n_pixels; i += 16) {
        /* LD3: R,G,B 채널을 자동 분리 (하드웨어 디인터리브) */
        uint8x16x3_t rgb = vld3q_u8(img + i * 3);

        /* 각 채널에 포화 덧셈 */
        rgb.val[0] = vqaddq_u8(rgb.val[0], vboost);  /* R */
        rgb.val[1] = vqaddq_u8(rgb.val[1], vboost);  /* G */
        rgb.val[2] = vqaddq_u8(rgb.val[2], vboost);  /* B */

        /* ST3: 자동 인터리브 저장 */
        vst3q_u8(img + i * 3, rgb);
    }
}

/* NEON REV + EXT 엔디안 변환 (32비트 단위) */
uint32x4_t bswap32_neon(uint32x4_t v)
{
    return vreinterpretq_u32_u8(
        vrev32q_u8(vreinterpretq_u8_u32(v))  /* 각 32비트 내 바이트 역순 */
    );
}

/* 쌍선형 보간 (2D) — NEON 고정소수점 */
uint8x8_t bilinear_neon(uint8x8_t tl, uint8x8_t tr,
                        uint8x8_t bl, uint8x8_t br,
                        uint8x8_t fx, uint8x8_t fy)
{
    /* 가중 평균: result = (1-fx)(1-fy)·tl + fx(1-fy)·tr
     *                     + (1-fx)fy·bl + fx·fy·br */
    uint8x8_t ifx = vsub_u8(vdup_n_u8(255), fx);
    uint8x8_t ify = vsub_u8(vdup_n_u8(255), fy);

    uint16x8_t top  = vmull_u8(ifx, tl);           /* u8×u8→u16 */
    top = vmlal_u8(top, fx, tr);                     /* += fx·tr */
    uint16x8_t bot  = vmull_u8(ifx, bl);
    bot = vmlal_u8(bot, fx, br);

    uint16x8_t row  = vmull_u8(ify, vshrn_n_u16(top, 8));
    row = vmlal_u8(row, fy, vshrn_n_u16(bot, 8));
    return vshrn_n_u16(row, 8);                      /* u16→u8 축소 */
}

ARM SVE 프레디케이트 연산 시각화

SVE(Scalable Vector Extension)는 하드웨어 벡터 길이에 무관한 코드를 작성할 수 있게 합니다. 핵심은 프레디케이트 레지스터(p0–p15)로, WHILELT로 루프 테일을 자동 처리하고, BRKA/COMPACT로 조건부 데이터 조작을 수행합니다.

/* SVE strlen — first-fault 로드 + BRKA로 null 위치 탐색 */
#include <arm_sve.h>

size_t sve_strlen(const char *s)
{
    size_t i = 0;
    svbool_t pg;

    do {
        pg = svwhilelt_b8(i, (uint64_t)SIZE_MAX);
        svuint8_t data = svld1(pg, (uint8_t*)(s + i));
        svbool_t match = svcmpeq(pg, data, 0);  /* null 바이트 비교 */

        if (svptest_any(pg, match)) {
            /* BRKA: 첫 null 위치까지만 활성 → CNTP로 개수 */
            svbool_t before_null = svbrka_z(match, match);
            return i + svcntp_b8(pg, before_null);
        }
        i += svcntb();  /* VL 바이트만큼 전진 */
    } while (svptest_any(pg, pg));

    return i;
}

/* SVE 배열 필터링 — COMPACT로 양수만 추출 */
int filter_positive_sve(const float *in, float *out, int n)
{
    int written = 0;
    for (int i = 0; i < n; i += (int)svcntw()) {
        svbool_t pg = svwhilelt_b32(i, n);
        svfloat32_t v = svld1(pg, in + i);

        /* 양수 마스크 */
        svbool_t pos = svcmpgt(pg, v, 0.0f);
        int cnt = (int)svcntp_b32(pg, pos);

        /* COMPACT: 활성 요소를 앞으로 압축 */
        svfloat32_t packed = svcompact(pos, v);
        svbool_t store_pg = svwhilelt_b32(0, cnt);
        svst1(store_pg, out + written, packed);
        written += cnt;
    }
    return written;
}

RISC-V RVV 명령어 시각화

RVV(RISC-V Vector Extension)는 SVE처럼 구현 정의 벡터 길이(VLEN)를 지원하되, vsetvli로 동적으로 SEW(요소 폭)와 LMUL(레지스터 그룹 배수)을 설정하는 독특한 모델입니다. 이 명령어가 VL(실제 처리 요소 수)을 반환하므로, 루프 제어가 자동화됩니다.

/* RVV memcpy 루프 — vsetvli가 자동으로 VL 관리 */
void rvv_memcpy(void *dst, const void *src, size_t n)
{
    const uint8_t *s = src;
    uint8_t *d = dst;
    while (n > 0) {
        size_t vl;
        asm volatile(
            "vsetvli %0, %1, e8, m8, ta, ma\n"  /* SEW=8, LMUL=8 → 최대 대역 */
            "vle8.v  v0, (%2)\n"
            "vse8.v  v0, (%3)\n"
            : "=r"(vl)
            : "r"(n), "r"(s), "r"(d)
            : "memory"
        );
        s += vl;
        d += vl;
        n -= vl;
    }
}

/* RVV RAID XOR 패리티 — 다중 디스크 XOR */
void rvv_xor_parity(uint8_t *parity, uint8_t **disks,
                     int ndisks, size_t len)
{
    for (size_t offset = 0; offset < len; ) {
        size_t vl;
        asm volatile(
            "vsetvli %0, %1, e8, m8, ta, ma"
            : "=r"(vl) : "r"(len - offset));

        /* 첫 디스크 로드 */
        asm volatile("vle8.v v0, (%0)" :: "r"(disks[0] + offset));

        /* 나머지 디스크들과 XOR */
        for (int d = 1; d < ndisks; d++) {
            asm volatile(
                "vle8.v v8, (%0)\n"
                "vxor.vv v0, v0, v8"
                :: "r"(disks[d] + offset) : "memory");
        }

        asm volatile("vse8.v v0, (%0)" :: "r"(parity + offset));
        offset += vl;
    }
}

/* RVV 리덕션 합 — VREDSUM.VS로 벡터→스칼라 */
int32_t rvv_sum(const int32_t *arr, size_t n)
{
    int32_t total = 0;
    for (size_t i = 0; i < n; ) {
        size_t vl;
        asm volatile(
            "vsetvli  %0, %1, e32, m4, ta, ma\n"
            "vle32.v  v4, (%2)\n"
            "vmv.s.x  v0, %3\n"             /* 스칼라 초기값 */
            "vredsum.vs v0, v4, v0\n"        /* v0[0] += Σv4 */
            "vmv.x.s  %3, v0"               /* 스칼라 추출 */
            : "=r"(vl), "+r"(total)
            : "r"(n - i), "r"(arr + i)
            : "memory"
        );
        i += vl;
    }
    return total;
}

SIMD 명령어 패밀리 지도

앞선 시각화 섹션은 핵심 명령어를 깊게 설명하는 데 초점을 맞췄습니다. 그러나 실제 SIMD 명령어셋은 데이터 폭, 부호 여부, 포화 여부, 마스크 여부, 인코딩(VEX/EVEX/SVE/RVV) 조합까지 포함하면 개별 mnemonic 수가 폭발적으로 늘어납니다. 커널 개발자는 개별 opcode 이름을 외우기보다 어떤 문제를 해결하는 패밀리인지를 먼저 구분해야 합니다. 아래 표는 x86, ARM NEON/SVE, RISC-V RVV를 동일한 관점으로 정리한 실전 지도입니다.

x86 논리·비교·선택 명령어 상세

문자열 검색, 패킷 분류, 비트마스크 생성, 조건부 merge는 커널 SIMD 코드에서 매우 자주 등장합니다. 핵심 패턴은 비교(compare) → 마스크(mask) 추출 → 첫 hit 계산 또는 마스크로 선택(blend/select)입니다. AVX2까지는 movemask로 벡터 상태를 스칼라 비트마스크로 내리고, AVX-512에서는 k-mask 레지스터를 유지한 채 kortest, compress, 마스크 스토어로 이어갑니다.

/* AVX2 memchr — compare → movemask → ctz 패턴의 정석 */
#include <immintrin.h>

ssize_t memchr_avx2(const uint8_t *buf, size_t len, uint8_t needle)
{
    __m256i key = _mm256_set1_epi8((char)needle);
    size_t i = 0;

    for (; i + 32 <= len; i += 32) {
        __m256i v = _mm256_loadu_si256((const __m256i *)(buf + i));
        __m256i eq = _mm256_cmpeq_epi8(v, key);
        unsigned mask = (unsigned)_mm256_movemask_epi8(eq);

        if (mask)
            return (ssize_t)(i + (size_t)__builtin_ctz(mask));
    }

    for (; i < len; i++) {
        if (buf[i] == needle)
            return (ssize_t)i;
    }
    return -1;
}

x86 Gather·Scatter·Prefetch·Streaming 상세

연속 메모리라면 일반 로드/스토어가 가장 빠릅니다. 하지만 라우팅(Routing) 테이블(Routing Table), 희소 인덱스, 압축 블록 메타데이터처럼 주소가 흩어진 자료구조에서는 gather/scatter가 코드 복잡도를 크게 줄여줍니다. 다만 성능은 주소 분산도(index entropy)와 캐시 히트율에 극단적으로 민감합니다. 연속 접근으로 재구성할 수 있다면 대부분 gather보다 낫습니다.