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) 절차까지 실전 커널 최적화 포인트를 다룹니다.

x86 SIMD 확장 역사

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) */

/* 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) */

암호화(Encryption) 전용 SIMD 명령어

/* === AES-NI 명령어 (커널 crypto 핵심) === */
aesenc    %xmm1, %xmm0         /* AES 한 라운드 암호화 */
aesenclast %xmm1, %xmm0        /* AES 마지막 라운드 암호화 */
aesdec    %xmm1, %xmm0         /* AES 한 라운드 복호화 */
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 해시 업데이트 */
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
 *
 * 스케줄러가 컨텍스트 스위치 시 자동 처리:
 *   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 함수 실전 가이드

x86 Intrinsic 함수는 인라인 어셈블리 없이 C/C++ 코드에서 SIMD 명령어를 직접 호출하는 인터페이스입니다. 커널은 주로 어셈블리를 선호하지만, Intrinsic은 유저 공간 최적화와 컴파일러 생성 SIMD 이해에 필수적입니다.

헤더 체계와 네이밍 규칙

/* 네이밍 규칙 예시 */
/* _mm256_add_epi32 → vpaddd ymm0, ymm1, ymm2  (어셈블리 변환) */
/* _mm512_mask_add_epi32 → vpaddd zmm0{k1}, zmm1, zmm2 */

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 파일 */

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

/* ⚠ 커널 코드에서 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. 근본 수정: 구조체/버퍼 정렬 보장
# 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)보다 높은 우선순위 */
        .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 코드 디버깅(Debugging)과 성능 분석

# 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 누락 의심

/* objdump으로 SIMD 명령어 확인 */
/* 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) = 연산 수 / 메모리 접근 바이트
 *
 * ┌─────────────────────────────────────────────────────────┐
 * │ 워크로드 유형           산술강도   병목           SIMD 효과  │
 * ├─────────────────────────────────────────────────────────┤
 * │ memcpy                 0 ops/B   메모리 대역폭    낮음     │
 * │ XOR (RAID)             1 ops/B   메모리 대역폭    중간     │
 * │ AES-CTR               ~8 ops/B   연산(CPU)        높음     │
 * │ GHASH (GCM)           ~4 ops/B   연산             높음     │
 * │ SHA-256              ~10 ops/B   연산             매우 높음│
 * │ 행렬 곱셈 (AMX)      ~16 ops/B   연산             매우 높음│
 * └─────────────────────────────────────────────────────────┘
 *
 * 메모리 바운드 (산술강도 ≤ 2):
 *   SIMD 레지스터 폭을 늘려도 성능 향상 제한적
 *   → NT 스토어, 프리페치, 캐시 최적화가 더 효과적
 *   → memcpy: REP MOVSB(FSRM)이 AVX보다 나을 수 있음
 *
 * 연산 바운드 (산술강도 ≥ 4):
 *   SIMD 폭 증가가 직접적 성능 향상
 *   → AES: 128-bit SSE → 256-bit AVX → 512-bit VAES
 *   → SHA: 파이프라인 인터리빙으로 처리량 극대화
 */

/* 커널 memcpy에서 SIMD가 유리한 구간 */
/*
 * 크기 < 64B:   레지스터 이동 (mov)     — SIMD 오버헤드만 증가
 * 64B ~ 2KB:    AVX2 vmovdqu 루프       — L1/L2 캐시 히트, SIMD 유리
 * 2KB ~ 256KB:  REP MOVSB (FSRM)       — L2/L3 최적화된 마이크로코드
 * > 256KB:      NT 스토어 (vmovntdq)    — 캐시 오염 방지, 대역폭 최대화
 *
 * 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 내부:
 *    a. process context (kcryptd 워크큐):
 *       → may_use_simd() == true
 *       → kernel_fpu_begin()
 *       → AES-NI/VAES로 직접 암호화
 *       → kernel_fpu_end()
 *
 *    b. 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는 알고리즘 내부에서 한 번만 호출
 *
 * 워커 스레드 수 조정:
 *   /sys/block/dm-0/dm/num_write_same_max_bytes
 *   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 사용 중
 */

IPsec/WireGuard SIMD 가속

/* IPsec: ESP 변환에서의 SIMD 사용 */
/*
 * IPsec ESP 패킷 처리 경로:
 *   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 연산의 첫 단계는 데이터를 메모리에서 레지스터로, 또는 레지스터 간에 이동하는 것입니다. 정렬 여부, 논템포럴 힌트, 브로드캐스트 패턴에 따라 명령어 선택이 성능에 큰 영향을 미칩니다.

/* 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 반복이 실전 패턴입니다.

/* 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 변환, 전치, 엔디안(Endianness) 변환의 핵심이며, 명령어마다 고유한 선택 패턴을 가집니다.

/* 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 패킹/언패킹/확장 명령어

데이터 폭 변환은 이미지/비디오 파이프라인(Pipeline)의 핵심입니다. 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;
}

참고 자료

• Intel Intrinsics Guide — SSE/AVX/AVX-512 인트린직 함수 레퍼런스
• 커널 공식 문서 — Kernel API (kernel_fpu_begin/end 포함)
• 커널 소스 — arch/x86/include/asm/fpu/api.h FPU API 헤더 (Bootlin Elixir)
• 커널 소스 — arch/x86/kernel/fpu/core.c FPU 상태 관리 (Bootlin Elixir)
• 커널 소스 — arch/x86/crypto SIMD 암호화 구현 (Bootlin Elixir)
• 커널 소스 — arch/arm64/crypto ARM NEON/SVE 암호화 구현 (Bootlin Elixir)
• 커널 소스 — lib/crypto/aegis128-neon-inner.c NEON 활용 예 (Bootlin Elixir)
• LWN.net — Kernel FPU state handling
• LWN.net — AMX support for the kernel
• LWN.net — A new direction for SIMD in the kernel
• ARM NEON 공식 문서 — Arm Neon Intrinsics Reference
• ARM SVE 프로그래밍 가이드 — Arm Scalable Vector Extension (SVE) Programming Guide
• RISC-V 벡터 확장 사양 — RISC-V "V" Vector Extension specification
• Intel SDM — Intel 64 and IA-32 Architectures Software Developer's Manual

관련 문서

SIMD와 관련된 다른 주제를 더 깊이 이해하고 싶다면 다음 문서를 참고하세요.

• 어셈블리 종합 — GCC 인라인 어셈블리, ABI, 메모리 배리어(Memory Barrier)
• CPUID 명령어 — 런타임 SIMD 기능 탐지
• 최적화 — SIMD 기반 커널 최적화 기법
• 커널 아키텍처 — x86_64/ARM64 아키텍처 비교