10강 / 20강

파이프라인 — 세탁기와 건조기를 동시에

명령을 겹쳐 흘리기, 그리고 분기 예측

5강에서 CPU는 인출 → 해독 → 실행 한 바퀴를 돈다고 했습니다. 그런데 인출을 하는 동안 ALU는 놀고, 실행하는 동안 인출 회로는 놉니다. 아깝죠?

그래서 겹쳐서 돌립니다. 빨래방에서 세탁기가 돌아가는 동안 먼저 끝난 빨래를 건조기에 넣는 것과 똑같아요.

고등학생세탁기와 건조기를 동시에

5강에서 CPU 는 인출 → 해독 → 실행 한 바퀴를 돈다고 했죠. 그런데 그렇게 하면 낭비가 생깁니다.

인출할 때 실행 회로는 논다

비유 — 빨래

빨래가 세 단계입니다. 세탁 30분, 건조 30분, 개기 30분.

방식	3벌 처리
한 벌씩 끝까지	90 × 3 = 270분
겹쳐서	150분

1번을 건조하는 동안 2번을 세탁한다

겹치면 이렇게 됩니다

시간	세탁기	건조기	개기
0–30	1번	—	—
30–60	2번	1번	—
60–90	3번	2번	1번

기계가 전부 동시에 돈다 — 그게 파이프라인

CPU 도 똑같습니다

명령 1을 실행하는 동안 명령 2를 해독하고 명령 3을 인출합니다.

한 명령의 시간은 그대로 — 처리량이 3배

이게 핵심입니다. 빨라진 게 아니라 겹친 거예요. 요즘 CPU 는 15~20단계 로 나눕니다.

겹치면 얼마나 빨라지나

겹치지 않으면 (한 번에 하나씩)
  명령1: [인출][해독][실행]
  명령2:                   [인출][해독][실행]
  명령3:                                     [인출][해독][실행]
  → 3개에 9클럭

파이프라인 (겹쳐서)
  명령1: [인출][해독][실행]
  명령2:       [인출][해독][실행]
  명령3:             [인출][해독][실행]
  → 3개에 5클럭.  100개면 102클럭!

명령 하나가 걸리는 시간(지연시간)은 그대로 3클럭입니다. 하지만 초당 몇 개를 뽑아내느냐(처리량)가 3배가 돼요. 현대 CPU는 이걸 14~20단계로 쪼갭니다.

고등학생겹치면 생기는 문제

좋아 보이는데 — 왜 20단계에서 멈췄을까요?

겹치려면 다음 일이 무엇인지 알아야 한다

문제 ① 앞 결과가 필요할 때

a = b + c
d = a + e   ← a 를 기다려야 한다

두 번째 명령은 첫 번째가 끝나야 할 수 있습니다. 겹칠 수가 없어요.

빨래로 치면 — 같은 옷을 다시 세탁하는 격

문제 ② 어디로 갈지 모를 때 — 분기

if 재고 > 0:
    주문처리()
else:
    품절안내()

조건을 계산해 봐야 어디로 갈지 압니다. 그런데 파이프라인은 미리 다음 명령을 가져와야 해요.

"다음이 뭐냐" 를 알 수 없는 순간이 온다

비유 — 갈림길 앞의 배달원

배달원 여럿이 줄지어 갑니다. 갈림길에서 어느 쪽인지 모르면?

선택	결과
기다린다	줄이 전부 멈춘다
찍고 간다	맞으면 이득, 틀리면 되돌아온다

CPU 는 찍고 갑니다 — 그게 분기 예측

그리고 이게 단계 수의 한계입니다

단계가 많을수록 틀렸을 때 버리는 게 많아집니다. 20단계면 20개 명령을 버려야 해요.

깊게 겹칠수록 실패의 대가가 커진다

파이프라인은 처리량을 늘리지 지연시간을 줄이지 않습니다.

Python 브라우저에서 실행

def 파이프라인_클럭(명령수, 단계수):
    return 단계수 + (명령수 - 1)       # 첫 명령을 채우고 나면 한 클럭에 하나씩

print(f"{'명령 수':>10}{'안 겹칠 때':>12}{'3단계':>10}{'14단계':>10}{'빨라진 배수':>14}")
print("-" * 58)
for n in [1, 3, 10, 100, 1_000_000]:
    안겹침 = n * 3
    p3  = 파이프라인_클럭(n, 3)
    p14 = 파이프라인_클럭(n, 14)
    print(f"{n:>10,}{안겹침:>12,}{p3:>10,}{p14:>10,}{안겹침/p14:>13.1f}배")

print()
print("→ 명령이 많을수록 단계를 잘게 쪼갠 쪽이 이깁니다.")
print("  단, '줄이 끊기지 않는다'는 전제가 있을 때만요.")

줄이 끊기는 세 가지 — 해저드

🔗

데이터 해저드

앞 명령의 결과를
바로 다음이 써야 할 때

🔀

제어 해저드

점프할지 말지
아직 모를 때

🚧

구조 해저드

한 부품을
둘이 동시에 원할 때

제일 아픈 건 제어 해저드입니다. 6강에서 본 JLE loop 를 떠올려 보세요. 이 명령이 뛸지 말지는 실행 단계에 가야 압니다. 그런데 파이프라인은 그 사이에 이미 다음 명령들을 인출해 놨어요.

만약 뛰는 게 맞았다면? 이미 넣은 명령들을 전부 버려야 합니다. 14단계 파이프라인이면 14클럭이 통째로 날아가요.

고등학생그래서 CPU 는 찍습니다 — 분기 예측

note 의 이 대목이 현대 CPU 의 비밀입니다.

CPU 는 if 문의 결과를 미리 짐작한다

어떻게 짐작하나 — 과거를 본다

과거	예측
지난 10번 다 참	참일 것
번갈아 참/거짓	패턴을 학습한다

요즘 CPU 의 예측 정확도는 95~99%

이게 왜 놀라운가

CPU 안에 작은 학습 기계가 들어 있는 겁니다. 과거 패턴으로 미래를 맞히는 — 기계학습의 원시적 형태죠.

틀리면 어떻게 되나

	비용
맞힘	0
틀림	15~20 사이클 낭비

99% 맞혀도 1%가 큰 비용이 된다

코드에 실제로 영향을 줍니다

유명한 실험이 있어요 — 정렬된 배열이 정렬 안 된 배열보다 6배 빨리 처리됩니다.

배열	if 결과	예측
정렬됨	앞은 다 거짓, 뒤는 다 참	거의 다 맞힌다
무작위	들쭉날쭉	절반은 틀린다

같은 코드 · 같은 자료 개수 — 순서만 다른데 6배

8강의 캐시 이야기와 같은 성격입니다. "코드만 봐서는 안 보이는 비용" 이죠.

분기 예측 실패는 파이프라인 길이만큼 손해입니다.

Python 브라우저에서 실행

# 예측이 빗나가면 얼마나 손해인가
단계 = 14
분기비율 = 0.19          # 명령 5개 중 1개꼴로 분기

print(f"{'예측 정확도':>12}{'명령당 평균 낭비 클럭':>24}{'실효 IPC':>12}")
print("-" * 52)
for 정확도 in [0.99, 0.95, 0.90, 0.75, 0.50]:
    낭비 = 분기비율 * (1 - 정확도) * 단계
    ipc = 1 / (1 + 낭비)
    print(f"{정확도*100:>11.0f}%{낭비:>22.3f}{ipc:>12.2f}")

print()
print("→ 정확도가 99%에서 90%로 떨어지면 IPC가 20% 넘게 깎입니다.")
print("  그래서 '예측하기 쉬운 코드'가 빠릅니다.")

예측하기 쉬운 코드 vs 어려운 코드

정렬된 데이터를 훑으면 if (x > 100) 의 답이 한동안 계속 같습니다. 예측기가 신나죠. 무작위 데이터면 매번 찍기라 절반은 틀립니다.

데이터를 정렬해 두는 것만으로 빨라지는 유명한 현상.

Python 브라우저에서 실행

import time, random

N = 400_000
정렬됨  = list(range(N))
무작위  = 정렬됨.copy()
random.shuffle(무작위)

def 세기(데이터):
    t = time.perf_counter()
    c = 0
    for x in 데이터:
        if x > N // 2:      # 이 분기가 예측하기 쉬운가?
            c += 1
    return (time.perf_counter() - t) * 1000, c

a, _ = 세기(정렬됨)
b, _ = 세기(무작위)
print(f"정렬된 데이터: {a:8.1f} ms   ← 분기 답이 한동안 같다")
print(f"무작위 데이터: {b:8.1f} ms   ← 매번 찍어야 한다")
print(f"→ {b/a:.2f}배")
print()
print("(파이썬 인터프리터가 두꺼워서 차이가 줄어 보입니다.")
print(" C로 같은 걸 하면 3~6배까지 벌어집니다.)")

branch-misses 가 2% 넘으면 예측하기 어려운 코드입니다.

bash 브라우저에서 실행

# 진짜 CPU 의 분기 예측 실패율
perf stat true

고등학생스펙터와 멜트다운 — 예측의 대가

note 의 이 이야기가 2018년 세상을 놀라게 했습니다.

CPU 가 찍어서 미리 실행한 흔적이 남는다

무슨 일이 벌어지나

CPU 가 "이쪽일 거야" 하고 미리 실행한다
실행 중에 남의 메모리를 읽는다
"아, 틀렸네" 하고 결과를 취소한다
그런데 캐시에 흔적이 남는다

결과는 지웠는데 부작용은 안 지워졌다

그 흔적을 어떻게 읽나

어떤 자료를 읽어 보고 얼마나 빨리 오는지 잽니다.

속도	뜻
빠르다	캐시에 있었다 → 아까 건드렸다
느리다	없었다

시간을 재서 비밀을 알아낸다 — 부채널 공격

비유 — 발자국

도둑이 방에 들어왔다 나가면서 물건을 다 제자리에 돌려놨습니다.

그런데 카펫에 발자국이 남았어요. 어디를 밟았는지 보입니다.

되돌린다고 흔적까지 되돌아가지는 않는다

왜 이게 심각했나

이유	설명
거의 모든 CPU	20년치 칩이 전부 해당
설계 문제	버그가 아니라 원리다
고치면 느려진다	패치로 5~30% 성능 손실

성능을 위한 20년간의 최적화가 구멍이었다

6강의 스택 오버플로와 같은 구조예요 — 속도를 위한 선택이 보안 대가로 돌아옵니다.

이 CPU가 안고 있는 알려진 취약점들입니다.

bash 브라우저에서 실행

grep -m1 bugs /proc/cpuinfo | tr ' ' '\n' | tail -8

🤔 확인 문제

파이프라인이 14단계인 CPU에서 분기 예측이 빗나가면 대략 얼마를 손해 볼까요?

🤔 확인 문제

파이프라인이 늘려 주는 것은?