• 노드 = 연산, 간선 = 데이터 흐름
• eager 실행은 파이썬이 한 줄씩 커널을 호출한다 — 다음 줄에 무엇이 올지 모른다
• 그래프로 잡아 두면 전체를 보고 결정할 수 있다: 무엇을 합칠지, 어떤 순서로 돌릴지, 메모리를 언제 놓을지
• 이 단계에서 컴파일러는 그래프로 표현된 연산과 의존 관계를 분석한다

x ──▶ floor ──▶ y ──▶ add(1) ──▶ z

# 노드: floor, add
# 간선: x→floor, floor→add(y), add→z

• torch.fx.Graph — 노드 리스트를 가진 평범한 파이썬 객체
• 순회·수정이 쉽다: 노드를 돌면서 바꾸고, 다시 파이썬 코드로 찍어낼 수 있다
• Dynamo·AOTAutograd·Inductor의 경계에서 FX 그래프를 주고받는다. Inductor 내부에서는 루프 수준 IR도 사용한다
• 출력이 코드처럼 읽히는 이유: FX 는 그래프를 forward() 함수 형태로 되찍어 준다

# FX 그래프를 코드로 되찍은 형태 (graph_code 로그의 모양)
def forward(self, L_x_ : torch.Tensor):
    l_x_ = L_x_
    floor = torch.floor(l_x_);  l_x_ = None
    add = floor + 1;  floor = None
    return (add,)

• 백엔드는 FX GraphModule과 예시 입력을 받고, 실행 가능한 함수를 반환한다.
• 기본 Inductor 경로는 AOTAutograd를 활용한다. 사용자 백엔드도 필요하면 AOTAutograd를 연결할 수 있다.
• 아래 예제는 그래프를 출력하고 eager 방식으로 실행하는 관찰용 백엔드다. 새 하드웨어 지원을 구현한 코드는 아니다.

def inspect_backend(gm, example_inputs):
    print(gm.code)
    return gm.forward

compiled = torch.compile(f, backend=inspect_backend)
compiled(x)

• 파이썬 바이트코드를 해석하며 실행 흐름을 따라간다
• 텐서 연산을 만나면 계산하지 않고 그래프에 기록한다 — 심볼릭 추적
• 출력 세 가지: FX 그래프 · guard · 잔여 바이트코드
• guard = 이 그래프가 유효한 전제 (입력 shape · dtype · 파이썬 값 등). 재사용 가능한 캐시 항목이 없으면 재컴파일할 수 있다
• 그래프로 못 넣는 파이썬 동작은 잔여 바이트코드로 남겨 인터프리터가 그대로 실행

• 원인 ① 텐서 값에 의존하는 제어흐름 — if x.sum() > 0 은 값을 알아야 분기하는데, Dynamo 는 계산을 안 한다
• 원인 ② 그래프화 불가능한 파이썬 동작 — print, I/O, 외부 라이브러리 호출
• 결과 함수가 여러 그래프로 쪼개지고, 컴파일된 코드 ↔ 파이썬 인터프리터 사이 문맥 전환이 생긴다
• 부작용 그래프 경계를 넘는 최적화 기회 소실 — 경계 양쪽 연산은 절대 합쳐지지 않는다

def a_dynamo_break(x):
    y = x * 2
    if y.sum() > 0:      # ← 여기서 graph break
        return y + 1     #   그래프 1: x*2, sum   /  그래프 2: y+1 또는 y-1
    return y - 1

torch._dynamo.explain(a_dynamo_break)(x)
# Graph Count / Graph Break Count / Break Reasons 를 알려 준다

CPU 실측: Graph Count = 2, Graph Break Count = 1. 입력은 torch.ones(4). 실제 사유·그래프는 부록 A에 수록.

• Dynamo 의 FX 그래프는 사람이 쓴 그대로다 — in-place, view, 고수준 연산이 섞여 있다
• 컴파일러는 단순하고 예측 가능한 표현을 원한다
• AOTAutograd 가 하는 일 두 가지: Functionalization + Decomposition
• 이름대로 backward 그래프도 Ahead-Of-Time 으로 미리 만든다 (원문 1편은 forward 정규화에 집중)

# 사용자 코드
y = x.clone()
y.add_(1)          # 기존 y의 값을 변경
y = y.view(-1)     # 같은 저장 공간을 볼 수 있음

# 개념 예시: mutation 제거
clone = aten.clone(x)
add   = aten.add(clone, 1)
view  = aten.view(add, [-1])
# view가 남았다고 독립 메모리가 된 것은 아님

• SiLU(x)는 x × sigmoid(x)로 표현할 수 있다.
• 이번 실행에서는 neg → exp → add → div로 표현됐다. 식은 x / (1 + exp(−x))와 같다.
• 남기는 연산 집합은 버전·백엔드·설정에 따라 달라진다.
• 구현할 연산 종류는 줄어들지만, 모든 모델 지원이 자동으로 보장되지는 않는다.

class <lambda>(torch.nn.Module):
    def forward(self, arg0_1: "f32[4]"):
        add: "f32[4]" = torch.ops.aten.add.Tensor(arg0_1, 1);  arg0_1 = None

        neg: "f32[4]" = torch.ops.aten.neg.default(add)
        exp: "f32[4]" = torch.ops.aten.exp.default(neg);  neg = None
        add_1: "f32[4]" = torch.ops.aten.add.Tensor(exp, 1);  exp = None
        div: "f32[4]" = torch.ops.aten.div.Tensor(add, add_1);  add = add_1 = None
        return (div,)

# FX / ATen 그래프 — 텐서 단위
y = floor(x)
z = y + 1

# Inductor 루프 수준 IR — 원소 단위
for i in range(N):
    y[i] = floor(x[i])
    z[i] = y[i] + 1

• FLOPs: 부동소수점 연산 횟수. FLOP/s는 초당 연산 처리량이다.
• 길이 P 내적은 곱 P번 + 덧셈 P−1번. 관례적으로 약 2P FLOPs로 센다.
• 행렬곱 [N,P] × [P,M]은 출력 NM개마다 길이 P 내적 → 약 2NPM FLOPs.
• bytes: 원소 수 × 원소당 바이트 수. FP32는 원소당 4 bytes.

A: [N, P]    B: [P, M]    C: [N, M]

계산량 ≈ 2 × N × P × M FLOPs

이상적인 최소 데이터 이동량
≈ (NP + PM + NM) × s bytes
s = 원소당 바이트 수
# 캐시·재사용·추가 버퍼에 따라 실측량은 달라짐

계산 시간 하한 ≈ FLOPs / 연산 처리량
이동 시간 하한 ≈ bytes / 메모리 대역폭

연산 집약도 = FLOPs / bytes

단순 Roofline 관점:
시간 ≳ max(계산 시간, 이동 시간)

• 단순 원소 연산: 큰 배열에서는 메모리 대역폭이 중요해지기 쉽다.
• 작은 연산: Python·커널 호출 오버헤드가 더 중요할 수 있다.
• 행렬곱: shape·dtype·재사용·커널 구현에 따라 병목이 달라진다.
• Fusion은 메모리 접근과 호출을 줄일 수 있다. 최종 효과는 측정해야 한다.

• 이번 환경은 CPU다. GPU용 Triton 출력으로 표시하지 않는다.
• 아래는 Inductor의 output_code.py 안 C++ 소스다. 원문 전체는 마지막 부록에서 내려받을 수 있다.
• floor와 add가 같은 루프에서 수행되는지, 중간 y 배열이 필요한지 확인하자.
• 다른 하드웨어를 지원하려면 코드 생성 외에도 실행·메모리·지원 연산을 연결해야 한다.

auto tmp0 = at::vec::Vectorized<float>::loadu(in_ptr0 + static_cast<int64_t>(x0), static_cast<int64_t>(16));
auto tmp1 = tmp0.floor();
auto tmp2 = static_cast<float>(1.0);
auto tmp3 = at::vec::Vectorized<float>(tmp2);
auto tmp4 = tmp1 + tmp3;
tmp4.store(out_ptr0 + static_cast<int64_t>(x0));

Graph Count: 2
Graph Break Count: 1




def forward(self, L_x_ : torch.Tensor):
    l_x_ = L_x_
    y = l_x_ * 2;  l_x_ = None
    sum_1 = y.sum()
    gt = sum_1 > 0;  sum_1 = None
    return (gt, y)

def forward(self, L_y_ : torch.Tensor):
    l_y_ = L_y_
    add = l_y_ + 1;  l_y_ = None
    return (add,)

# remove="mutations"



def forward(self, x_1):
    clone = torch.ops.aten.clone.default(x_1);  x_1 = None
    add = torch.ops.aten.add.Tensor(clone, 1);  clone = None
    view = torch.ops.aten.view.default(add, [-1]);  view = None
    view_1 = torch.ops.aten.view.default(add, [-1]);  add = None
    silu = torch.ops.aten.silu.default(view_1);  view_1 = None
    return silu

# remove="mutations_and_views"



def forward(self, x_1):
    clone = torch.ops.aten.clone.default(x_1);  x_1 = None
    add = torch.ops.aten.add.Tensor(clone, 1);  clone = None
    view_copy = torch.ops.aten.view_copy.default(add, [-1]);  view_copy = None
    view_copy_1 = torch.ops.aten.view_copy.default(add, [-1]);  add = None
    silu = torch.ops.aten.silu.default(view_copy_1);  view_copy_1 = None
    return silu

# 실제 ATen (파일 경로 주석 생략)
class <lambda>(torch.nn.Module):
    def forward(self, arg0_1: "f32[1024, 1024]"):
        floor: "f32[1024, 1024]" = torch.ops.aten.floor.default(arg0_1);  arg0_1 = None

        add: "f32[1024, 1024]" = torch.ops.aten.add.Tensor(floor, 1);  floor = None
        return (add,)

class op0_loop_body:
    var_ranges = {p0: 1048576}
    index0 = p0
    def body(self, ops):
        get_index = self.get_index('index0')
        load = ops.load('arg0_1', get_index)
        floor = ops.floor(load)
        constant = ops.constant(1.0, torch.float32)
        add = ops.add(floor, constant)
        get_index_1 = self.get_index('index0')
        store = ops.store('buf0', get_index_1, add, None)
        return store