05 · Static vs Dynamic Dispatch

import Foundation

// ────────── ① 정적 디스패치 (직접 호출) ──────────
struct Circle {
    func draw() { print("circle") }        // struct는 상속이 없다 → 항상 정적
}
final class Square {
    func draw() { print("square") }        // final → 오버라이드 불가 → 정적
}

// ────────── ② vtable (클래스 상속) ──────────
class Shape {
    func draw() { print("shape") }         // 오버라이드 가능 → vtable 슬롯
}
class Triangle: Shape {
    override func draw() { print("triangle") }
}

// ────────── ③ witness table (프로토콜) ──────────
protocol Drawable { func draw() }
extension Circle: Drawable {}
extension Square: Drawable {}

func render(_ d: any Drawable) { d.draw() }      // existential → witness table
func render<T: Drawable>(_ d: T) { d.draw() }    // 특수화되면 → 정적!

// ────────── ④ objc_msgSend ──────────
class Legacy: NSObject {
    @objc dynamic func draw() { print("legacy") }  // 셀렉터 기반 런타임 조회
}

// ────────── 호출부 ──────────
Circle().draw()                     // ① 직접 호출 (인라인될 수도 있다)
let s: Shape = Triangle(); s.draw() // ② vtable 조회 후 호출
render(Circle() as any Drawable)    // ③ witness table 경유
Legacy().draw()                     // ④ objc_msgSend(obj, sel_draw)

// ① final — "더 이상 오버라이드되지 않는다"를 선언
final class Renderer {
    func draw() {}                 // 클래스가 final이면 메서드도 전부 정적
}
class Partial {
    final func draw() {}           // 메서드 단위로도 가능
}

// ② private / fileprivate — 가시성이 좁으면 컴파일러가 증명할 수 있다
class Internal {
    private func helper() {}       // 이 파일 밖에서 오버라이드 불가 → 정적
}

// ③ WMO(Whole Module Optimization) — 모듈 전체를 한 번에 본다
//    internal 메서드도 "이 모듈에 오버라이드가 없음"을 확인하면 정적으로 바뀐다
//    빌드 설정: SWIFT_COMPILATION_MODE = wholemodule (Release 기본값)

// ④ 제네릭 특수화 — 구체 타입별 사본을 만들어 witness table을 없앤다
func draw<T: Drawable>(_ x: T) { x.draw() }
draw(Circle())     // → draw_specialized_Circle(...) 로 복제되고 직접 호출

// ⑤ some P (opaque type) — 구체 타입이 하나로 고정되므로 특수화 가능
func make() -> some Drawable { Circle() }   // 항상 Circle → 정적
func makeAny() -> any Drawable { Circle() } // 상자에 담김 → 동적

// ① @objc dynamic — 일부러 objc_msgSend 경로로 보낸다
class Model: NSObject {
    @objc dynamic var count = 0    // KVO를 쓰려면 필수 (성능이 아니라 기능 선택)
}

// ② 라이브러리 진화(library evolution) 모드
//    -enable-library-evolution 으로 빌드된 프레임워크는
//    "나중에 필드가 추가되어도 클라이언트를 다시 컴파일하지 않아도" 되어야 한다.
//    → struct 레이아웃조차 고정할 수 없으므로 접근이 간접적으로 바뀐다.
@frozen public struct Point {      // "이 레이아웃은 절대 안 바꾼다"고 약속하면
    public var x: Double           // 클라이언트가 직접 접근할 수 있다
    public var y: Double
}

// ③ 모듈 경계 — @inlinable 없이 public 함수는 다른 모듈에서 인라인 불가
@inlinable public func fastPath() { /* ... */ }   // 본문을 클라이언트에게 노출

# SIL 덤프 (최적화 전)
swiftc -emit-sil Dispatch.swift | swift demangle

# 최적화 후 (특수화·devirtualization이 반영된 상태)
swiftc -O -emit-sil Dispatch.swift | swift demangle

# 디스패치 명령어만 골라 보기
swiftc -O -emit-sil Dispatch.swift \
  | grep -E "function_ref|class_method|witness_method|objc_method"

# 어셈블리까지
swiftc -O -S Dispatch.swift

// Swift                          →  SIL 명령어
Circle().draw()                   →  function_ref @...Circle4drawyyF   // ① 정적
                                     apply

let s: Shape = Triangle()         →  class_method %0 : $Shape, #Shape.draw   // ② vtable
s.draw()                             apply

func f(_ d: any Drawable)         →  witness_method $@opened(...), #Drawable.draw  // ③ PWT
{ d.draw() }                         apply

Legacy().draw()                   →  objc_method %0 : $Legacy, #Legacy.draw!foreign // ④ msgSend
                                     apply

// ─── -O 를 켜고 다시 뽑으면 이런 변화가 보인다 ───
// class_method   → function_ref   (final/WMO로 devirtualize 됨)
// witness_method → function_ref   (제네릭이 특수화됨)
// 아예 apply 자체가 사라짐        (인라인됨)

protocol P {}
struct S3: P { var a, b, c: Int }        // 24바이트 = 3 words
struct S4: P { var a, b, c, d: Int }     // 32바이트 = 4 words

MemoryLayout<any P>.size        // 40 — 버퍼 3 + metadata 1 + witness 1

// 박싱 여부는 크기로 갈린다
func check() {
    let x: any P = S3(a:1,b:2,c:3)   // 인라인 버퍼에 들어감 (힙 할당 없음)
    let y: any P = S4(a:1,b:2,c:3,d:4) // 힙 박싱 발생
    _ = (x, y)
}

// ✅ 실무 회피법 — 애초에 existential을 안 만든다
func drawAll<T: P>(_ xs: [T]) { }      // 동종 배열이면 제네릭이 낫다
let shapes: [any P] = [Circle(), Square()]            // 이종이 진짜 필요할 때만

; ─── 정적 디스패치 ───
bl      _draw_Circle          ; 목적지 주소가 명령어에 박혀 있다
                              ; → 페치 단계에서 이미 다음 명령을 안다
                              ; → 애초에 인라인되어 이 줄이 사라질 수도 있다

; ─── 동적 디스패치 (vtable) ───
ldr     x8, [x0]              ; (1) 객체에서 metadata 포인터 로드   ← 메모리 접근
ldr     x9, [x8, #0x50]       ; (2) 테이블에서 함수 포인터 로드     ← 또 메모리 접근
blr     x9                    ; (3) 레지스터가 가리키는 곳으로 점프 ← 간접 분기

; 비용의 정체:
;   (1)(2) 두 번의 의존적 로드 — 캐시에 없으면 각각 수십~수백 사이클
;   (3)    간접 분기 — 주소를 "예측"해야 한다

// ───────── 정적: 인라인 → 상수 접기 → 죽은 코드 제거 ─────────
struct Config {
    let debugMode = false
    func scale(_ v: Int) -> Int { debugMode ? v * 2 : v }
}
func compute() -> Int {
    Config().scale(21)
}
// 컴파일러가 하는 일:
//   1. scale() 인라인          → (false ? 21*2 : 21)
//   2. 상수 접기               → 21
//   3. Config() 할당도 불필요  → 죽은 코드 제거
//   최종 기계어: mov w0, #21   ← 함수 호출이 통째로 사라졌다

// ───────── 동적: 아무것도 못 한다 ─────────
protocol Scaler { func scale(_ v: Int) -> Int }
func computeDynamic(_ s: any Scaler) -> Int {
    s.scale(21)
}
// 컴파일러가 아는 것: "어떤 함수가 불릴지 모른다"
//   → 인라인 불가
//   → debugMode가 false인지 알 수 없으니 상수 접기 불가
//   → 부수효과가 있을지 모르니 죽은 코드 제거 불가
//   → 레지스터 할당도 보수적으로 (호출 규약을 지켜야 하니까)

// 개념적 동작
objc_msgSend(receiver, @selector(draw))
  ↓
  1. receiver 에서 isa (클래스 포인터) 로드
  2. 클래스의 "메서드 캐시"(셀렉터 → IMP 해시 테이블)에서 조회  ← 대부분 여기서 끝
  3. 미스면 클래스 계층을 따라 올라가며 메서드 목록 탐색
  4. 찾으면 캐시에 넣고 호출 (다음부터는 2에서 히트)

// 이 "한 번 찾은 결과를 캐시" 아이디어가 인라인 캐싱이고,
// Smalltalk/Self 연구에서 나와 지금은 JavaScript 엔진까지 다 쓴다.
// → 그래서 objc_msgSend 는 "느리지만 감당 가능한" 수준에 머문다.

// 다만 Swift 정적 호출과 비교하면 여전히 큰 차이:
//   · 인라인 불가 (런타임에 swizzling으로 바뀔 수 있으므로 원리적으로 불가능)
//   · 인자를 레지스터 규약에 맞춰 세팅하는 고정 비용