컴파일러와 인터프리터: 코드가 실행되기까지

사람이 쓴 코드가 기계에서 실행되기까지의 단계를 따라가요. 어휘 분석, 구문 분석, 의미 분석, 최적화, 코드 생성으로 이어지는 컴파일러의 흐름을 살펴보고, 파이썬이 실제로 만드는 바이트코드를 dis로 열어 봐요. days * 60 * 60 * 24는 미리 계산되지 않는데 60 * 60 * 24 * days는 되는 이유를 확인하고, 식을 스택 기계 명령으로 바꾸는 작은 컴파일러와 가상 기계를 직접 만들어 상수 접기로 명령을 11개에서 5개로 줄여요. 인터프리터가 느린 이유와 JIT, 미리 컴파일하기의 장단점까지 다뤄요.

고급강의 3 / 6약 12분

이론 트랙의 파싱 강의에서 식을 문법 나무로 만들고 바로 계산했어요. 실제 언어는 여기서 몇 단계를 더 거쳐요. 문법 나무를 검사하고, 다듬고, 기계가 빠르게 실행할 수 있는 명령으로 바꿔요. 이 일을 하는 프로그램이 컴파일러예요. 이번 강의에서는 파이썬이 실제로 만드는 명령을 들여다보고, 작은 컴파일러와 그 명령을 실행할 가상 기계를 직접 만들어요.

코드가 실행되기까지의 단계

  1. 어휘 분석: 글자를 토큰으로 잘라요. 오토마타 강의의 정규 표현식이 하는 일이에요.
  2. 구문 분석: 토큰을 문법 나무로 만들어요. 문법과 파싱 강의에서 직접 해 봤어요.
  3. 의미 분석: 이름이 정의돼 있는지, 타입이 맞는지처럼 문법만으로는 알 수 없는 것을 검사해요.
  4. 최적화: 뜻은 같고 더 빠른 코드로 바꿔요.
  5. 코드 생성: CPU가 직접 실행하는 기계어나, 가상 기계가 실행하는 바이트코드를 만들어요.

좁은 뜻의 컴파일러는 이 과정을 실행 전에 한 번에 마치고 결과물(실행 파일)을 남겨요. C, C++, Rust, Go가 그래요. 인터프리터는 코드를 읽으면서 바로 실행해요. 실제로는 둘을 섞은 방식이 많아요. 파이썬은 코드를 바이트코드로 컴파일한 뒤 가상 기계가 그 바이트코드를 하나씩 해석하며 실행하고, 자바는 바이트코드를 실행하다가 자주 쓰는 부분을 기계어로 다시 컴파일해요.

파이썬의 바이트코드 들여다보기

파이썬은 함수를 정의하는 순간 그 몸통을 바이트코드로 컴파일해 둬요. 표준 라이브러리의 dis 모듈로 열어 볼 수 있어요.

import dis

def show(func):                                      # 함수의 바이트코드를 한 줄에 명령 하나씩 보여 줘요
    for ins in dis.get_instructions(func):
        arg = ins.argrepr or (ins.argval if ins.arg is not None and ins.opname != "RESUME" else "")
        print(f"    {ins.opname:<34} {arg}".rstrip())

def area(width, height):
    return width * height / 2

def seconds_a(days):
    return days * 60 * 60 * 24

def seconds_b(days):
    return 60 * 60 * 24 * days

print("area의 바이트코드:")
show(area)
print("days * 60 * 60 * 24에 86400이 미리 계산돼 있나요?", 86400 in seconds_a.__code__.co_consts)
print("60 * 60 * 24 * days는요?", 86400 in seconds_b.__code__.co_consts)
print("days가 0.7이면:", seconds_a(0.7), "와", seconds_b(0.7))
area의 바이트코드:
    RESUME
    LOAD_FAST_BORROW_LOAD_FAST_BORROW  width, height
    BINARY_OP                          *
    LOAD_SMALL_INT                     2
    BINARY_OP                          /
    RETURN_VALUE
days * 60 * 60 * 24에 86400이 미리 계산돼 있나요? False
60 * 60 * 24 * days는요? True
days가 0.7이면: 60480.0 와 60479.99999999999
  • 지역 변수 두 개를 스택에 올리고, BINARY_OP가 스택 위의 두 값을 꺼내 곱한 결과를 다시 올려요. 2를 올리고 또 나누고, 맨 위의 값을 돌려줘요. CPython은 레지스터 대신 스택에 값을 쌓아 가며 계산하는 스택 기계예요. 명령 이름은 파이썬 버전마다 조금씩 달라요. 위는 3.14에서 본 결과예요.
  • 60 * 60 * 24 * days는 컴파일러가 앞의 곱셈을 미리 계산해서 86400을 넣어 뒀어요. 이걸 상수 접기라고 해요. 그런데 days * 60 * 60 * 24는 왼쪽부터 ((days × 60) × 60) × 24로 묶이니 상수끼리 바로 붙어 있는 곳이 없어요.
  • 순서를 바꿔서 접으면 되지 않냐고요? 마지막 줄처럼 실수 곱셈은 순서에 따라 반올림 결과가 달라지고, days가 직접 만든 객체라면 *의 뜻 자체가 다를 수 있어요. 그래서 컴파일러는 뜻이 바뀔 수 있는 변환을 함부로 하지 못해요. 타입을 미리 모르는 동적 언어의 최적화가 어려운 이유를 보여 주는 작은 예예요.

가져온 모듈의 바이트코드는 __pycache__ 폴더의 .pyc 파일에 저장해 두었다가, 소스가 바뀌지 않았으면 다음 실행 때 컴파일을 건너뛰고 그대로 써요.

작은 컴파일러 만들기

이제 사칙연산 식을 위한 컴파일러를 직접 만들어요. 파싱은 이론 트랙에서 직접 만든 파서와 같은 나무를 주는 파이썬의 ast에 맡기고, 그 뒤의 의미 분석, 최적화, 코드 생성을 짜요. 결과물은 파이썬처럼 스택 기계의 명령이고, 그걸 실행하는 가상 기계도 만들어요.

import ast
import operator

OPS = {ast.Add: "ADD", ast.Sub: "SUB", ast.Mult: "MUL", ast.Div: "DIV"}
CALC = {"ADD": operator.add, "SUB": operator.sub, "MUL": operator.mul, "DIV": operator.truediv}

def fold(node):                                      # 최적화: 변수가 없는 부분은 미리 계산해 둬요(상수 접기)
    if isinstance(node, ast.BinOp):
        node.left, node.right = fold(node.left), fold(node.right)
        if isinstance(node.left, ast.Constant) and isinstance(node.right, ast.Constant):
            return ast.Constant(CALC[OPS[type(node.op)]](node.left.value, node.right.value))
    return node

def compile_expr(text, known, optimize=False):
    tree = ast.parse(text, mode="eval").body         # 1. 파싱: 글자를 문법 나무로
    if optimize:
        tree = fold(tree)                            # 2. 최적화
    code = []
    def emit(node):                                  # 3. 코드 생성: 후위 순회로 스택 기계 명령을 만들어요
        if isinstance(node, ast.Constant):
            code.append(("PUSH", node.value))
        elif isinstance(node, ast.Name):
            if node.id not in known:                 # 의미 분석: 모르는 이름은 실행하기 전에 잡아요
                raise NameError(f"정의되지 않은 이름 {node.id!r}")
            code.append(("LOAD", node.id))
        elif isinstance(node, ast.BinOp) and type(node.op) in OPS:
            emit(node.left)
            emit(node.right)
            code.append((OPS[type(node.op)], None))
        else:
            raise SyntaxError(f"지원하지 않는 문법: {type(node).__name__}")
    emit(tree)
    return code

def run_vm(code, env):                               # 스택 하나로 명령을 차례로 실행하는 가상 기계
    stack = []
    for op, arg in code:
        if op == "PUSH":
            stack.append(arg)
        elif op == "LOAD":
            stack.append(env[arg])
        else:
            b, a = stack.pop(), stack.pop()
            stack.append(CALC[op](a, b))
    return stack.pop()

text = "(2 + 3) * 4 - x / (60 * 60)"
for optimize in (False, True):
    code = compile_expr(text, known={"x"}, optimize=optimize)
    listing = " ".join(op if arg is None else f"{op} {arg}" for op, arg in code)
    print(f"최적화 {'켬' if optimize else '끔'}: 명령 {len(code)}개 | {listing}")
    print(f"    x = 7200일 때 결과: {run_vm(code, {'x': 7200})}")

try:
    compile_expr("y * 2 + 1", known={"x"})
except NameError as e:
    print("실행하기 전에 잡은 오류:", e)
최적화 끔: 명령 11개 | PUSH 2 PUSH 3 ADD PUSH 4 MUL LOAD x PUSH 60 PUSH 60 MUL DIV SUB
    x = 7200일 때 결과: 18.0
최적화 켬: 명령 5개 | PUSH 20 LOAD x PUSH 3600 DIV SUB
    x = 7200일 때 결과: 18.0
실행하기 전에 잡은 오류: 정의되지 않은 이름 'y'
  • 코드 생성은 문법 나무의 후위 순회예요. 양쪽 자식의 명령을 먼저 내보내고 연산 명령을 붙이면, 가상 기계가 스택에서 두 값을 꺼내 계산하게 돼요.
  • 상수 접기를 켜니 (2 + 3) × 4가 20으로, 60 × 60이 3600으로 미리 계산돼서 명령이 11개에서 5개로 줄었어요. 실행할 때마다 하던 계산을 컴파일할 때 한 번만 하는 셈이에요. 실제 컴파일러는 이런 최적화를 수십 가지 해요. 쓰이지 않는 코드 지우기, 반복문 안에서 늘 같은 계산을 밖으로 빼내기, 작은 함수를 부르는 자리에 몸통을 그대로 펼치기(인라이닝) 같은 것들이에요.
  • 모르는 이름 y는 실행하기 전에 잡았어요. 이게 컴파일 단계의 장점이에요. 정적 타입 언어는 같은 방식으로 타입이 맞지 않는 코드도 실행 전에 거부해요. 파이썬은 이 검사를 실행할 때 해서 그 줄에 도달해야 오류가 나는데, mypy 같은 타입 검사기를 쓰면 실행 전에 상당 부분을 잡을 수 있어요.

기계어까지 내려가면

C 같은 언어는 가상 기계 대신 CPU가 직접 실행하는 기계어를 만들어요. 두 정수를 더해 돌려주는 C 함수를 x86-64용으로 최적화해 컴파일하면 명령 두 줄이 돼요.

add:
    lea eax, [rdi+rsi]
    ret

rdi와 rsi 레지스터로 들어온 두 인자를 더해 결과를 eax 레지스터에 담고 돌아가요. 원래 주소를 계산하는 명령인 lea를 덧셈에 빌려 쓰는 게 컴파일러의 요령이에요. 파이썬의 width * height는 바이트코드 몇 개가 되고, 인터프리터는 그 바이트코드 하나하나를 다시 C 코드 여러 줄로 처리해요. 이걸 비교하면 왜 컴파일된 코드가 빠른지 감이 와요. 여러 파일로 나뉘어 컴파일된 기계어를 실행 파일 하나로 묶는 마지막 단계는 링킹이라고 해요.

인터프리터는 왜 느릴까

import time

def python_sum(n):                                   # 인터프리터가 명령을 하나씩 해석하며 도는 반복문
    total = 0
    for i in range(n):
        total += i
    return total

n = 10_000_000
start = time.perf_counter()
a = python_sum(n)
mid = time.perf_counter()
b = sum(range(n))                                    # C로 컴파일된 내장 함수
end = time.perf_counter()
print("답이 같나요?", a == b)
print("C로 짠 sum이 두 배 넘게 빠른가요?", (mid - start) / (end - mid) > 2)
답이 같나요? True
C로 짠 sum이 두 배 넘게 빠른가요? True

같은 덧셈을 1,000만 번 하는데, C로 컴파일된 내장 sum이 몇 배 빨라요(이 컴퓨터에서는 3배쯤). 파이썬 반복문은 한 바퀴마다 바이트코드 명령 여러 개를 하나씩 꺼내 무슨 명령인지 보고 해당하는 C 코드로 뛰어가요. 게다가 total += i의 두 값이 작은 정수인지, 큰 정수인지, 전혀 다른 객체인지를 매번 확인해야 해요. 컴파일된 코드는 이런 확인 없이 기계어 몇 개로 끝내요. 넘파이가 이보다도 훨씬 빠른 이유는 컴퓨터 구조 강의에서 봤어요.

파이썬도 가만있지는 않아요. 3.11부터는 같은 자리에서 늘 정수끼리 더해지면 그 명령을 "정수 전용 더하기"로 바꿔 끼우는 특수화로 빨라졌어요. 위의 LOAD_FAST_BORROW_LOAD_FAST_BORROW처럼 자주 붙어 나오는 명령을 하나로 합치기도 하고, 3.13부터는 실험적인 JIT 컴파일러도 들어 있어요.

JIT: 실행하면서 컴파일하기

JIT(Just-In-Time) 컴파일러는 프로그램을 실행하면서 자주 도는 부분을 찾아 그때 기계어로 컴파일해요. 자바의 HotSpot, 자바스크립트의 V8, 파이썬의 다른 구현인 PyPy가 대표적이에요.

방식장점단점예
미리 컴파일실행이 빠르고 시작도 빨라요빌드 시간이 들고, 실행 중에야 알 수 있는 정보는 못 써요C, C++, Rust, Go
인터프리터바로 실행되고 유연해요명령마다 해석 비용이 들어요셸 스크립트, CPython의 기본 실행
JIT실행 중 실제 타입과 경로를 보고 최적화해요처음엔 느리고(데우는 시간) 메모리를 더 써요자바, 자바스크립트, PyPy

JIT은 실행 중에만 알 수 있는 정보를 써요. 예를 들어 어떤 함수가 실제로는 늘 정수만 받는다는 걸 보고 정수 전용 기계어를 만들고, 혹시 다른 타입이 오면 그때 원래 방식으로 되돌아가요. 그래서 오래 도는 서버 프로그램에서는 미리 컴파일한 코드에 버금가는 속도가 나기도 해요. 웹 브라우저가 자바스크립트를 빠르게 돌리는 것도, C나 Rust로 짠 코드를 브라우저에서 돌리는 WebAssembly도 이런 컴파일 기술 위에 서 있어요.

실습

  1. show로 x + 1을 돌려주는 함수와 1 + x를 돌려주는 함수의 바이트코드를 비교해 보세요. 리스트 컴프리헨션을 쓰는 함수의 바이트코드는 어떻게 생겼나요?
  2. fold를 고쳐서 x * 1은 x로, x + 0은 x로 바꾸는 최적화를 더해 보세요. x가 실수일 때도 둘 다 늘 안전할까요? 힌트: x가 -0.0이면 x + 0은 무엇이 될까요?
  3. 컴파일러에 거듭제곱(**)을 더하고, 가상 기계에 POW 명령을 추가해 보세요.
  4. 가상 기계가 실행한 명령 수를 세게 만들고, 최적화 전후로 같은 식을 100만 번 실행하는 시간을 비교해 보세요.
  5. python -m py_compile 파일이름.py로 컴파일하고, __pycache__ 폴더에 무엇이 생기는지 확인해 보세요.

자주 하는 오해

  • 파이썬은 컴파일을 하지 않는다. 바이트코드로 컴파일한 뒤 가상 기계가 실행해요. 다만 CPU의 기계어까지는 만들지 않아요.
  • 컴파일 언어와 인터프리터 언어가 따로 있다. 언어가 아니라 구현의 성질이에요. 같은 파이썬도 CPython은 바이트코드를 해석하고, PyPy는 JIT으로 기계어를 만들어요.
  • 최적화는 컴파일러가 알아서 다 해 준다. 뜻이 바뀔 수 있는 최적화는 하지 못해요. days * 60 * 60 * 24처럼 쓰는 방식이 결과를 바꿔요.
  • JIT은 늘 빠르다. 데우는 시간이 있어서, 짧게 끝나는 프로그램에서는 오히려 손해일 수 있어요.
  • 컴파일되면 버그가 없다. 컴파일러는 문법과 타입처럼 미리 알 수 있는 것만 잡아요. 계산 가능성 강의에서 본 것처럼 모든 버그를 미리 잡는 건 원리적으로 불가능해요.

점검 문제

  1. 컴파일러가 거치는 다섯 단계는?
  2. 컴파일러와 인터프리터의 차이는 무엇이고, 파이썬은 어느 쪽인가요?
  3. CPython이 스택 기계라는 건 무슨 뜻인가요?
  4. 60 * 60 * 24 * days는 상수 접기가 되는데 days * 60 * 60 * 24는 안 되는 이유는?
  5. 작은 컴파일러에서 코드 생성이 후위 순회인 이유는?
  6. 모르는 이름을 실행 전에 잡는 건 어느 단계이고, 어떤 장점이 있나요?
  7. 파이썬 반복문이 C로 컴파일된 코드보다 느린 이유 두 가지는?
  8. JIT이 미리 컴파일하기보다 유리할 수 있는 점과 불리한 점은?

정답

  1. 글자를 토큰으로 자르는 어휘 분석, 토큰을 문법 나무로 만드는 구문 분석, 이름과 타입을 검사하는 의미 분석, 같은 뜻의 더 빠른 코드로 바꾸는 최적화, 기계어나 바이트코드를 만드는 코드 생성이에요.
  2. 컴파일러는 실행 전에 코드를 다른 형태로 바꿔 두고, 인터프리터는 코드를 읽으면서 바로 실행해요. CPython은 바이트코드로 컴파일한 뒤 그 바이트코드를 가상 기계가 해석하며 실행하는 섞인 방식이에요.
  3. 레지스터 대신 스택에 값을 올리고, 명령이 스택 위의 값을 꺼내 계산한 결과를 다시 올리는 방식으로 실행한다는 뜻이에요.
  4. 식이 왼쪽부터 묶여서 ((days × 60) × 60) × 24가 되니 상수끼리 바로 붙은 곳이 없어요. 순서를 바꾸면 실수의 반올림 결과나 객체에 따른 *의 뜻이 달라질 수 있어서 컴파일러가 함부로 바꾸지 못해요.
  5. 스택 기계는 두 값을 먼저 스택에 올려 둬야 계산할 수 있으니, 양쪽 자식의 명령을 먼저 내보내고 연산 명령을 나중에 붙여야 하기 때문이에요.
  6. 의미 분석 단계예요. 그 줄까지 실행하지 않아도 오류를 알 수 있어서, 드물게 실행되는 코드의 실수도 미리 잡아요.
  7. 명령마다 무슨 명령인지 해석하고 해당 코드로 뛰어가는 비용이 들고, 값의 타입을 매번 확인해야 하기 때문이에요.
  8. 실행 중에 실제로 쓰이는 타입과 경로를 보고 그에 맞게 최적화할 수 있다는 점이 유리해요. 처음에는 데우는 시간 동안 느리고 메모리를 더 쓴다는 점이 불리해요.

다음 강의

지금까지는 프로그램 하나가 한 번에 한 가지 일을 했어요. 하지만 컴퓨터에는 코어가 여러 개 있고, 서버는 수많은 요청을 동시에 받아요. 다음 강의에서는 여러 일을 번갈아 진행하는 동시성과 정말로 동시에 실행하는 병렬성을 구별하고, 스레드와 락, 경쟁 상태, 파이썬의 asyncio까지 직접 실험해 봐요.