CPU 아키텍처 기초

let arr: [u8; 128] = [0; 128];

// arr[0] 접근 → 캐시 미스 → arr[0..64] 전부 L1로 로드
let _ = arr[0];

// arr[1]~arr[63] 접근 → 이미 L1에 있음 → 캐시 히트 (4 사이클)
let _ = arr[32];

// arr[64] 접근 → 새 캐시 라인 → 또 미스
let _ = arr[64];

같은 v0 레지스터를 다른 시각으로 해석:

  v0.16b  →  u8  × 16  (16개 바이트)
  v0.8h   →  u16 × 8   (8개 반정수)
  v0.4s   →  f32 × 4   (4개 단정밀도)
  v0.2d   →  f64 × 2   (2개 배정밀도)

실제 비트는 똑같고, 명령어가 어떻게 해석하느냐의 차이

ARM64 어셈블리로 보면:

; x0 = &arr[0] 주소라고 가정

; 스칼라 로드 (1바이트)
LDRB w1, [x0]        ; arr[0] → w1 (8비트)

; SIMD 로드 (16바이트 한 번에)
LDR q0, [x0]         ; arr[0..16] → v0 (128비트)

; 이게 from_slice(&arr[0..16])의 실제 기계어

// Rust 코드
let v = u8x16::from_slice(&arr[0..16]);

// → 컴파일하면 (release):
//   LDR q0, [x0]   ← 딱 한 줄
//   (루프도, 복사도 없음)

use std::alloc::{Layout, alloc};

// 16바이트 정렬 보장 할당
let layout = Layout::from_size_align(64, 16).unwrap();
let ptr = unsafe { alloc(layout) };

// Vec은 정렬 보장 없음 → 실제론 보통 align 8
// 정렬이 중요한 경우 aligned_vec 등 crate 사용

// std::simd의 from_slice는 미정렬도 처리하지만
// 정렬된 경우 컴파일러가 더 빠른 명령어 선택 가능

// 의존성이 있는 루프 — 파이프라인 활용 불가
let mut sum = 0u32;
for x in data {
    sum += x as u32;  // 이전 sum에 의존 → 순차 실행
}

// SIMD 병렬 누산 — 4개 독립 누산기
let mut acc = [u32x4::splat(0); 4];  // 독립 레인 4세트
for chunk in data.chunks_exact(16) {
    let v = u8x16::from_slice(chunk);
    // ... 각 acc에 분산하여 누산
    // → 파이프라인이 4개 동시 실행
}
let total = acc[0] + acc[1] + acc[2] + acc[3];

use std::arch::aarch64::__prefetch;

fn process_large(data: &[u8]) {
    let chunks = data.chunks_exact(64);
    for (i, chunk) in chunks.enumerate() {
        // 8 청크(512바이트) 앞의 데이터 미리 로드 요청
        if i + 8 < data.len() / 64 {
            unsafe {
                __prefetch::<0, 0>(data.as_ptr().add((i + 8) * 64));
                //          ↑ locality=0 (곧 한 번만 쓸 것)
            }
        }
        // 현재 청크 처리...
    }
}

// 타입의 크기와 정렬 확인
println!("{}", std::mem::size_of::());   // 16
println!("{}", std::mem::align_of::());  // 16

// 캐시 라인 크기 (상수로 정의해 쓰기)
const CACHE_LINE: usize = 64;

// 캐시 라인 정렬 구조체
#[repr(align(64))]
struct CacheAligned(T);

// 메모리 주소가 정렬됐는지 확인
fn is_aligned(ptr: *const u8, align: usize) -> bool {
    ptr as usize % align == 0
}