01 · 메모리와 가상 메모리

import Foundation

// ❌ 파일 전체가 dirty 힙으로 올라온다. iOS엔 스왑이 없으니
//    이 순간 footprint가 파일 크기만큼 뛰고, 상한을 넘으면 그대로 종료다.
func loadBad(_ url: URL) throws -> Data {
    try Data(contentsOf: url)          // 500MB 파일 → dirty 500MB
}

// ✅ mmap: file-backed clean 페이지가 되어 '실제로 만진 페이지'만 올라온다.
//    압박이 오면 커널이 알아서 버리고, 다시 필요하면 파일에서 재적재한다.
func loadMapped(_ url: URL) throws -> Data {
    try Data(contentsOf: url, options: .mappedIfSafe)
}

// 사용 예 — 헤더 1KB만 읽으면 그 페이지(16KB) 하나만 물리 메모리에 올라온다
func readHeader(_ url: URL) throws -> Data {
    let mapped = try loadMapped(url)
    return mapped.prefix(1024)
}

// ⚠️ .mappedIfSafe는 '안전할 때만' 매핑한다(네트워크 볼륨 등은 통째로 읽는다).
//    그리고 매핑했더라도 전 영역을 무작위로 훑으면 결국 다 올라와 이점이 사라진다.

// 검증: 남은 예산을 직접 찍어 보면 두 방식의 차이가 바로 보인다
func logHeadroom(_ tag: String) {
    let mb = os_proc_available_memory() / 1024 / 1024
    print("[\(tag)] 남은 예산 \(mb)MB")
}

import UIKit
import ImageIO

// UIImage를 만들었다고 디코딩이 끝난 게 아니다. dirty를 잡아먹는 건
// '디코딩된 비트맵'이고, 그 크기는 표시 크기가 아니라 원본 픽셀 수로 정해진다.
//   4000×3000 원본 → 4000*3000*4B ≈ 48MB (100×100 뷰에 그려도 똑같이 48MB)

func downsample(at url: URL,
                to pointSize: CGSize,
                scale: CGFloat) -> UIImage? {
    // 디코딩 캐시를 끄고 소스만 연다 — 여기서는 아직 픽셀을 만들지 않는다
    let srcOptions = [kCGImageSourceShouldCache: false] as CFDictionary
    guard let src = CGImageSourceCreateWithURL(url as CFURL, srcOptions) else {
        return nil
    }

    // 목표는 point가 아니라 '픽셀' — Retina 배율을 곱해야 뭉개지지 않는다
    let maxPixel = max(pointSize.width, pointSize.height) * scale

    let options = [
        kCGImageSourceCreateThumbnailFromImageAlways: true,
        kCGImageSourceShouldCacheImmediately: true,        // 이 시점에 디코딩까지 완료
        kCGImageSourceCreateThumbnailWithTransform: true,  // EXIF 회전 반영
        kCGImageSourceThumbnailMaxPixelSize: maxPixel
    ] as CFDictionary

    guard let cg = CGImageSourceCreateThumbnailAtIndex(src, 0, options) else {
        return nil
    }
    return UIImage(cgImage: cg, scale: scale, orientation: .up)
}

// 셀에서 쓸 때 — 100×100 셀이면 비트맵도 300×300(3x) 수준으로 끝난다
func configure(cell: UICollectionViewCell, imageView: UIImageView, url: URL) {
    imageView.image = downsample(at: url,
                                 to: cell.bounds.size,
                                 scale: cell.traitCollection.displayScale)
}

import UIKit

final class ImageCache {
    static let shared = ImageCache()

    private let cache = NSCache<NSString, UIImage>()
    private var pressureSource: DispatchSourceMemoryPressure?

    private init() {
        cache.countLimit = 200
        cache.totalCostLimit = 64 * 1024 * 1024

        // 커널이 주는 압박 신호를 직접 구독한다.
        // UIKit의 didReceiveMemoryWarning보다 이른 단계(.warning)에서도 온다.
        let source = DispatchSource.makeMemoryPressureSource(
            eventMask: [.warning, .critical],
            queue: .main
        )
        source.setEventHandler { [weak self] in
            guard let self, let data = self.pressureSource?.data else { return }
            if data.contains(.critical) {
                self.cache.removeAllObjects()      // 전부 비운다
            } else if data.contains(.warning) {
                self.cache.countLimit = 50         // 예산을 줄여 축출을 유도
            }
        }
        source.resume()

        // ⚠️ 소스는 반드시 강한 프로퍼티로 붙들어야 한다.
        //    지역 변수로 두면 스코프를 벗어나며 취소되어 핸들러가 한 번도 안 불린다.
        pressureSource = source
    }
}

final class FeedViewController: UIViewController {
    // ❌ 여기서 아무것도 안 하면 경고는 그냥 로그 한 줄이다.
    //    다음 압박에서 죽는 건 비우지 않은 내 앱이다.
    override func didReceiveMemoryWarning() {
        super.didReceiveMemoryWarning()
        ImageCache.shared.purge()          // ✅ 실제로 비운다
    }
}

extension ImageCache {
    func purge() { cache.removeAllObjects() }
}

import Foundation

print(vm_page_size)            // 실기기(ARM64): 16384
print(sysconf(Int32(_SC_PAGESIZE)))  // 동일하게 16384
// iOS 시뮬레이터(맥의 아키텍처 따름)나 x86 macOS에선 4096이 나올 수 있음

import Foundation

// ❌ 4096을 상수로 박으면 실기기(16KB)에서 정렬·크기 가정이 전부 어긋난다
let badPageSize = 4096

// ✅ 런타임 값을 쓴다 — 시뮬레이터든 실기기든 항상 맞다
let pageSize = Int(vm_page_size)               // 실기기 ARM64: 16384
let pageSizeAlt = sysconf(Int32(_SC_PAGESIZE)) // 같은 값

// 페이지 경계로 올림 — 매핑·정렬 계산의 기본
func pageAligned(_ bytes: Int) -> Int {
    (bytes + pageSize - 1) / pageSize * pageSize
}

// 예: 1MB를 요청해도 실제 매핑 단위는 페이지 배수로 맞춰진다
let chunk = pageAligned(1_000_000)             // 16KB 배수로 반올림

// footprint 회계도 16KB 단위로 잡힌다는 점이 실무에서 체감된다:
// 16KB 회계는 페이지 단위 매핑(vm_allocate·mmap)에서 체감된다. 1KB를 vm_allocate로
// 1000번 따로 잡으면 실제 점유가 1MB가 아니라 16MB에 가까워진다. 반면 보통의
// malloc/Swift 힙 할당은 작은 요청을 큰 리전에서 잘라 쓰므로 1MB 남짓에 수렴하고,
// 내부 단편화는 리전 꼬리에서만 생긴다.
func demonstrateRounding() {
    let logical = 1_000 * 1_024                // 약 1MB
    let worstCase = 1_000 * pageSize           // 페이지마다 하나씩 흩어졌을 때
    print("논리 \(logical / 1024)KB vs 최악 \(worstCase / 1024)KB")
}

import Foundation
import MachO

// 같은 코드도 실행할 때마다 다른 가상 주소에 올라온다(ASLR slide).
// 그래서 "지난번 로그의 0x104a2c000과 이번 0x10b31c000이 같은 함수인가?"는
// 주소를 그대로 비교해서는 답할 수 없다.

// ✅ 메인 실행 이미지의 slide를 빼서 '정규화된 오프셋'으로 바꾼다
func slideOfMainImage() -> Int {
    for i in 0..<_dyld_image_count() {
        guard let raw = _dyld_get_image_name(i) else { continue }
        let exe = Bundle.main.executableURL?.lastPathComponent ?? ""
        if String(cString: raw).hasSuffix("/" + exe) {
            return _dyld_get_image_vmaddr_slide(i)
        }
    }
    return 0
}

func normalized(_ runtimeAddress: UInt) -> UInt {
    UInt(Int(runtimeAddress) - slideOfMainImage())
}

// 이 정규화된 값이라야 빌드가 같은 두 실행 사이에서 비교가 성립한다
func logSymbolAddress(_ address: UInt) {
    print("runtime 0x\(String(address, radix: 16)) "
        + "→ 정규화 0x\(String(normalized(address), radix: 16))")
}

/*  LLDB에서 같은 일을 할 때:
      (lldb) image list -o -f        # 각 이미지의 slide와 경로
      (lldb) image lookup -a 0x104a2c1f4
    크래시 리포트는 "Binary Images" 섹션에 로드 주소가 찍혀 있으니
    그 값을 빼면 정규화 오프셋이 된다.                                     */

import Foundation

// ❌ 두 컴포넌트가 각자 읽으면 같은 내용이 물리 메모리에 두 벌 올라온다
final class BadLoader {
    let dictionary: Data
    let index: Data
    init(url: URL) throws {
        dictionary = try Data(contentsOf: url)   // 40MB dirty
        index      = try Data(contentsOf: url)   // 또 40MB dirty  → 합계 80MB
    }
}

// ✅ mmap하면 서로 다른 가상 주소가 '같은 물리 프레임'을 가리킨다.
//    N개가 매핑해도 물리 사용량은 대략 한 벌에 수렴한다.
final class SharedResource {
    static let shared = try? SharedResource(url: Bundle.main.url(
        forResource: "dictionary", withExtension: "bin")!)

    let data: Data
    init(url: URL) throws {
        data = try Data(contentsOf: url, options: .mappedIfSafe)
    }
}

// 프로세스 경계를 넘어도 마찬가지다 — 앱과 확장이 App Group의 같은 파일을
// 매핑하면 커널이 페이지를 공유시킨다.
func sharedFileURL() -> URL? {
    FileManager.default
        .containerURL(forSecurityApplicationGroupIdentifier: "group.com.app")?
        .appendingPathComponent("dictionary.bin")
}

// ⚠️ 단, 그 페이지에 쓰기를 하면 COW가 발동해 쓴 쪽만 사본을 갖는다 —
//    그 순간부터 공유가 아니다. 공유 이점은 '읽기 전용'일 때 유지된다.

// 시스템도 같은 원리를 쓴다: dyld 공유 캐시가 프레임워크 코드를
// 앱들 사이에 한 벌만 RAM에 두는 것이 정확히 이 메커니즘이다.

struct Point { var x, y: Double }   // 값 타입
class Node  { var value = 0 }        // 참조 타입

func demo() {
    let p = Point(x: 1, y: 2)  // 스택 프레임에 인라인 저장
    let n = Node()             // 인스턴스는 힙, n(포인터)만 스택

    // 값 타입이라도 힙으로 가는 경우:
    let closure = { print(p, n.value) }  // p, n 캡처. 이 클로저가 이스케이프하면 캡처는 힙 박스로
    // 큰 프로토콜 타입(existential)도 박싱되어 힙에 갈 수 있음
    _ = closure
}

import Foundation

struct Point { var x, y: Double }

// struct라고 항상 스택이 아니다. 아래 세 경우엔 힙으로 간다.
final class Holder { var origin = Point(x: 0, y: 0) }   // ① 클래스 프로퍼티 → 힙

func captureCases() -> () -> Void {
    let p = Point(x: 1, y: 2)
    // ② 이스케이핑 클로저 캡처 → 힙 캡처 박스로 이동
    let escaping: () -> Void = { print(p) }
    return escaping
}

protocol Shape {}
struct BigShape: Shape {                                 // 3워드(24B) 초과 페이로드
    var a, b, c, d: Double
}
// ③ 큰 existential로 담기면 별도 힙 버퍼에 박싱된다
let boxed: any Shape = BigShape(a: 0, b: 0, c: 0, d: 0)

/*  실제 배치를 눈으로 확인하는 법 — SIL을 찍어 할당 명령을 본다:
      swiftc -emit-sil -O MyFile.swift | grep -E 'alloc_stack|alloc_box|alloc_ref'

      alloc_stack : 스택에 잡힘        (원하는 결과)
      alloc_box   : var를 캡처한 이스케이핑 클로저의 힙 박스 (let 캡처는 여기 안 잡힌다)
      alloc_ref   : 클래스 인스턴스 힙 할당

      ⚠️ let 캡처 이스케이핑 클로저의 컨텍스트와 큰 existential 박싱은 SIL에
         alloc_box/alloc_ref로 나타나지 않는다(각각 partial_apply,
         init_existential_addr로 보이고 실제 할당은 IRGen 단계다). 이 둘은
         swiftc -emit-ir -O MyFile.swift | grep swift_allocObject 로 확인해야 한다.

    Debug(-Onone)와 Release(-O)의 결과가 다르다는 점이 중요하다.
    최적화가 켜지면 escape analysis로 힙 할당이 스택으로 승격되거나
    아예 사라지기도 하므로, 판단은 반드시 -O로 해야 한다.                    */

// 3워드 규칙 확인
func layoutCheck() {
    print(MemoryLayout<BigShape>.size)   // 32 — 3워드(24) 초과 → 박싱
    print(MemoryLayout<Point>.size)      // 16 — 인라인 가능
}

import Foundation

// 스택은 작고 고정이다: 메인 스레드 1MB, 보조 스레드 기본 512KB.
// 넘기면 가드 페이지에 닿아 EXC_BAD_ACCESS로 즉사하고, 이건 catch할 수 없다.

// ❌ 고정 크기 튜플·거대한 struct는 진짜로 스택 프레임에 얹힌다
func bad() {
    // 128KB짜리 값을 지역 변수로 — 몇 겹만 중첩해도 1MB를 넘는다
    var buffer = (0, 0, 0, 0 /* … 수천 개 … */)
    _ = buffer
}

// ✅ Array는 요소를 힙 버퍼에 담는다 — 크기가 커도 스택엔 참조만 남는다
func good() {
    var samples = [Float](repeating: 0, count: 200_000)   // 800KB, 힙
    samples.withUnsafeMutableBufferPointer { buf in
        for i in buf.indices { buf[i] *= 0.5 }
    }
}

// ✅ 수명이 짧고 크기를 아는 임시 버퍼는 이 API가 가장 명확하다
func processTemporary(count: Int) {
    withUnsafeTemporaryAllocation(of: Float.self, capacity: count) { buf in
        for i in buf.indices { buf[i] = Float(i) }
        // 작은 크기는 스택, 큰 크기는 힙 — 런타임이 알아서 고른다
    }
}

// 보조 스레드 스택을 명시적으로 키워야 한다면(최후의 수단)
func makeDeepThread() {
    let thread = Thread { /* 깊은 작업 */ }
    thread.stackSize = 4 * 1024 * 1024        // 4MB · 4KB 배수여야 한다
    thread.start()
}

import Foundation

final class Node {
    var children: [Node] = []
}

// ❌ 서버 JSON이나 사용자 데이터가 깊이를 정하면, 깊이 하나로 앱이 죽는다.
//    스택 오버플로는 do/catch로 잡을 수 없다 — 즉시 EXC_BAD_ACCESS다.
func walkRecursive(_ node: Node, visit: (Node) -> Void) {
    visit(node)
    for child in node.children {
        walkRecursive(child, visit: visit)     // 깊이 = 신뢰할 수 없는 입력
    }
}

// ✅ ① 명시적 스택으로 바꾸면 깊이가 힙에서 자란다 — 스택 한계와 무관해진다
func walkIterative(_ root: Node, visit: (Node) -> Void) {
    var stack = [root]
    while let node = stack.popLast() {
        visit(node)
        stack.append(contentsOf: node.children)
    }
}

// ✅ ② 재귀를 유지해야 한다면 깊이 상한을 계약으로 못 박는다
enum ParseError: Error { case tooDeep(Int) }

func walkBounded(_ node: Node,
                 depth: Int = 0,
                 maxDepth: Int = 64,
                 visit: (Node) -> Void) throws {
    guard depth <= maxDepth else { throw ParseError.tooDeep(depth) }
    visit(node)
    for child in node.children {
        try walkBounded(child, depth: depth + 1, maxDepth: maxDepth, visit: visit)
    }
}

// ⚠️ JSONDecoder처럼 내부적으로 재귀하는 파서도 같은 위험이 있다.
//    신뢰할 수 없는 소스의 중첩 깊이는 파싱 전에 크기·깊이로 먼저 거른다.

// 원본
let a = Node()
use(a)

// ARC가 개념적으로 삽입 (실제론 swift_retain/swift_release)
let a = Node()      // refCount = 1 (생성 시)
swift_retain(a)     // 필요 시 +1
use(a)
swift_release(a)    // -1, 0이면 deinit 후 free — 즉시·결정적

import Foundation

// ARC는 마지막 참조가 풀리는 '그 지점'에서 즉시 deinit한다.
// 트레이싱 GC와 달리 시점이 예측 가능하므로, 자원 반납을 여기에 걸 수 있다.

final class LogFile {
    private let handle: FileHandle

    init(url: URL) throws {
        if !FileManager.default.fileExists(atPath: url.path) {
            FileManager.default.createFile(atPath: url.path, contents: nil)
        }
        handle = try FileHandle(forWritingTo: url)
    }

    func write(_ line: String) throws {
        try handle.write(contentsOf: Data((line + "\n").utf8))
    }

    // ✅ 스코프를 벗어나는 즉시 fd가 반납된다 — 파일 디스크립터 누수가 구조적으로 불가능
    deinit {
        try? handle.close()
    }
}

func writeReport() throws {
    let log = try LogFile(url: URL(fileURLWithPath: "/tmp/report.log"))
    try log.write("시작")
    // 함수가 끝나는 순간 log의 참조 수가 0 → deinit → close()
}   // ← 여기서 확정적으로 닫힌다. GC 언어라면 "언젠가"였을 지점.

// 같은 패턴이 옵저버·구독 해제에도 쓰인다
final class PriceWatcher {
    private var token: NSObjectProtocol?

    init() {
        token = NotificationCenter.default.addObserver(
            forName: .init("PriceChanged"), object: nil, queue: .main
        ) { _ in /* 갱신 */ }
    }

    deinit {
        if let token { NotificationCenter.default.removeObserver(token) }
    }
}

import UIKit

final class Tile { var pixels = [UInt8](repeating: 0, count: 64 * 64 * 4) }
final class Layer { var tiles: [Tile] = [] }
final class Document { var layers: [Layer] = [] }

final class EditorViewController: UIViewController {
    private var document: Document?

    // ❌ 마지막 참조를 메인에서 놓으면, 그 자리에서 수만 개의 deinit이
    //    동기로 연쇄 실행된다. 해제도 비용이라 프레임을 놓친다.
    func closeBad() {
        document = nil          // 여기서 앱이 멈칫한다
    }

    // ✅ 소유권을 백그라운드로 넘기고 거기서 놓는다
    func close() {
        guard let doc = document else { return }
        document = nil                       // 메인에서는 참조만 끊고
        Task.detached(priority: .utility) {
            _ = doc                          // 실제 연쇄 해제는 여기서 일어난다
        }
    }
}

// 측정: 해제 비용이 실제로 메인에 있는지 보려면 signpost를 건다
import os.signpost

let releaseLog = OSLog(subsystem: "com.app.memory", category: "release")

func measuredClose(_ doc: inout Document?) {
    let id = OSSignpostID(log: releaseLog)
    os_signpost(.begin, log: releaseLog, name: "document release", signpostID: id)
    doc = nil
    os_signpost(.end, log: releaseLog, name: "document release", signpostID: id)
}
// Instruments의 os_signpost 트랙에서 이 구간이 프레임 예산을 먹는지 바로 보인다

import Foundation

// retain/release는 멀티스레드 안전을 위해 '원자적 연산'이라 공짜가 아니다.
// 초당 수만 번 도는 경로에서는 이 비용이 실제로 보인다.

// ❌ 참조 타입 배열 — 순회·복사마다 retain/release가 붙는다
final class ParticleRef {
    var x: Float = 0, y: Float = 0
}
func stepRef(_ ps: [ParticleRef]) {
    for p in ps { p.x += 1 }        // 요소 접근마다 참조 카운팅 트래픽
}

// ✅ 참조를 하나도 담지 않는 값 타입 — 셀 숫자 자체가 없다
struct Particle {
    var x: Float = 0, y: Float = 0
}
func step(_ ps: inout [Particle]) {
    for i in ps.indices { ps[i].x += 1 }   // ARC 연산 0회
}

// ✅ 소유권 파라미터는 '참조를 담은' 값에서 의미가 있다 — 일반 파라미터는 이미 기본이
//    borrowing이라, Particle처럼 참조가 없는 타입엔 생략할 카운팅 자체가 없다.
//    String·클래스를 품은 타입에서라야 retain/release 쌍이 실제로 줄어든다.
func inspect(_ item: borrowing Particle) -> Float {
    item.x                                  // "잠깐 빌려 볼 뿐" — 카운팅 없음
}

func consumeOnce(_ item: consuming Particle) {
    // 소유권을 넘겨받았으므로 호출자 쪽 release가 생략된다
    _ = item
}

// ✅ 복사 자체를 금지해 카운팅이 성립할 여지를 없앤다
struct FileToken: ~Copyable {
    let fd: Int32
    deinit { close(fd) }
}

// ⚠️ 단, 값 타입이라도 내부에 클래스 참조나 COW 버퍼(Array·String)를 담으면
//    복사 시 그 필드에는 여전히 retain/release가 발생한다.
struct HasReference {
    var name: String                        // String은 내부 버퍼가 참조 카운팅된다
}

import Foundation

// ARC는 카운트만 본다. 서로를 가리키는 섬은 외부에서 도달 불가여도
// 카운트가 0이 되지 않아 영영 해제되지 않는다 — 이게 누수다.

final class Parent {
    var child: Child?
    deinit { print("Parent 해제") }
}
final class Child {
    var parent: Parent?          // ❌ 양방향 strong → 순환
    deinit { print("Child 해제") }
}

func leaks() {
    let p = Parent()
    let c = Child()
    p.child = c
    c.parent = p
}   // ← 아무 deinit도 찍히지 않는다. 두 객체는 영구히 남는다.

// ✅ 한 변을 비소유로 끊는다 — 소유 방향을 명시적으로 정한다
final class SafeChild {
    weak var parent: Parent?     // 또는 unowned (수명이 구조적으로 보장될 때)
    deinit { print("SafeChild 해제") }
}

// 검증 습관: 화면·모델 단위로 해제 테스트를 둔다
import XCTest

final class LeakTests: XCTestCase {
    func test_문서가_해제된다() {
        weak var weakDoc: Parent?
        autoreleasepool {
            let doc = Parent()
            doc.child = Child()
            weakDoc = doc
        }
        XCTAssertNil(weakDoc, "순환 참조로 해제되지 않았다")
    }
}

// 도구: Xcode Memory Graph Debugger(디버그 바의 그래프 아이콘)에서
// 보라색 ⚠️ 배지가 붙은 노드가 순환 후보다.

class ViewController {
    var onDone: (() -> Void)?

    func setup() {
        // self가 클로저를 소유하고, 클로저가 self를 strong 캡처하면 순환
        onDone = { [weak self] in
            guard let self else { return }  // 이미 죽었으면 조용히 종료
            self.refresh()
        }
    }
}

// 수명이 확실히 더 긴 부모를 가리킬 때만 unowned
class Child {
    unowned let parent: Parent   // parent는 child보다 항상 오래 산다는 계약
    init(parent: Parent) { self.parent = parent }
}

import UIKit

final class ProfileViewController: UIViewController {
    private let api = ProfileAPI()
    private var items: [Item] = []

    func load() {
        // ① 네트워크 콜백 — 응답이 오기 전에 사용자가 뒤로가기를 누를 수 있다
        //    → self가 먼저 죽을 수 있다 → weak
        api.fetch { [weak self] profile in
            guard let self else { return }        // 죽었으면 조용히 종료
            self.render(profile)
        }

        // ② 지연 실행 — 마찬가지로 그 사이 화면이 닫힐 수 있다 → weak
        DispatchQueue.main.asyncAfter(deadline: .now() + 3) { [weak self] in
            self?.showTooltip()
        }

        // ③ 즉시 동기 실행 — self가 죽을 방법이 없다 → 캡처 리스트 불필요
        items.sort { self.rank($0) < self.rank($1) }
    }

    // ④ self가 소유하고, self보다 오래 살 수 없는 하위 객체가 되짚어 볼 때
    //    → unowned (언랩 비용 없이 계약을 코드로 드러낸다)
    private lazy var layout: GridLayout = {
        GridLayout(dataSource: self)
    }()

    private func render(_ p: Profile) {}
    private func showTooltip() {}
    private func rank(_ i: Item) -> Int { 0 }
}

struct Profile {}
struct Item {}
final class ProfileAPI { func fetch(_ done: @escaping (Profile) -> Void) {} }
final class GridLayout {
    unowned let dataSource: ProfileViewController   // 계약: 소유자가 나보다 오래 산다
    init(dataSource: ProfileViewController) { self.dataSource = dataSource }
}

import UIKit

// delegate는 보통 '소유자'다. 그걸 strong으로 되짚으면 그 자체로 순환이 된다.

protocol ImagePickerDelegate: AnyObject {          // ✅ AnyObject 제약이 있어야
    func picker(_ picker: ImagePicker,             //    weak를 붙일 수 있다
                didPick image: UIImage)
}

final class ImagePicker {
    // ✅ weak — picker를 소유한 쪽을 붙들지 않는다
    weak var delegate: ImagePickerDelegate?

    func finish(with image: UIImage) {
        delegate?.picker(self, didPick: image)
    }
}

final class ComposeViewController: UIViewController, ImagePickerDelegate {
    private let picker = ImagePicker()              // VC가 picker를 소유

    override func viewDidLoad() {
        super.viewDidLoad()
        picker.delegate = self                      // picker → VC 는 weak라 순환 없음
    }

    func picker(_ picker: ImagePicker, didPick image: UIImage) {}

    deinit { print("ComposeViewController 해제") }   // 순환이면 안 찍힌다
}

// ⚠️ 예외: 클로저 기반 콜백 프로퍼티는 delegate와 성격이 다르다.
//    아래는 'picker가 클로저를 소유'하므로, 클로저 쪽에서 self를 weak로 잡아야 한다.
final class ClosurePicker {
    var onPick: ((UIImage) -> Void)?
}
func wire(_ vc: ComposeViewController, _ p: ClosurePicker) {
    p.onPick = { [weak vc] image in vc?.picker(ImagePicker(), didPick: image) }
}

import Foundation

final class Report {
    private var rows: [Int] = []
    private var total = 0

    func compute() {
        // ❌ 동기·비저장 클로저에 weak를 붙일 이유가 없다.
        //    옵셔널 체이닝만 늘고, 최악의 경우 '필요한 순간 nil'이 된다.
        rows.forEach { [weak self] row in
            self?.total += row
        }

        // ✅ map/filter/forEach 같은 non-escaping 클로저는 함수가 끝나기 전에
        //    반드시 실행·폐기되므로 self를 잡아도 사이클이 생기지 않는다
        rows.forEach { row in
            self.total += row
        }
    }

    // ❌ 더 나쁜 경우: 반드시 실행돼야 하는 정리 작업에 weak를 걸면
    //    self가 마지막 참조일 때 정리가 통째로 건너뛰어진다
    func flushBad(queue: DispatchQueue) {
        queue.async { [weak self] in
            self?.writeToDisk()          // self가 이미 nil이면 저장이 사라진다
        }
    }

    // ✅ 이 작업이 끝날 때까지는 살아 있어야 한다면 strong 캡처가 '옳다'
    func flush(queue: DispatchQueue) {
        queue.async {
            self.writeToDisk()           // 의도적으로 수명을 연장한다
        }
    }

    private func writeToDisk() {}
}

// 판단은 "순환이 생기는가"이지 "weak가 안전해 보이는가"가 아니다.
// 순환은 self가 그 클로저를 '보유'할 때만 생긴다.

import Foundation

final class Session {
    var onExpire: (() -> Void)?
}

final class Dashboard {
    private let session = Session()

    func setupCrashy() {
        // ❌ Dashboard가 session보다 먼저 죽을 수 있는데 unowned를 걸었다.
        //    죽은 뒤 onExpire가 불리면 그 자리에서 trap → 크래시.
        session.onExpire = { [unowned self] in
            self.reload()
        }
    }

    func setupSafe() {
        // ✅ 수명이 불확실하면 weak가 정답이다
        session.onExpire = { [weak self] in
            self?.reload()
        }
    }

    private func reload() {}
}

// unowned(unsafe)는 그 trap 검사조차 없다 — 해제된 메모리를 그냥 읽는다.
final class Danger {
    // ❌ 실패해도 크래시가 안 나고 엉뚱한 값이 읽히거나, 한참 뒤 전혀 다른 곳에서 터진다
    unowned(unsafe) var target: AnyObject?
}

/*  오용을 잡는 도구:
      Scheme → Diagnostics → Zombie Objects   (해제된 객체 접근 시 즉시 정지)
      Address Sanitizer                        (use-after-free 검출)

    unowned가 정당한 유일한 경우는 "소유 관계가 구조적으로 한 방향이고,
    그 계약이 코드로 강제되는" 때다. 예: 부모가 자식을 소유하고
    자식은 부모보다 절대 오래 살 수 없는 경우.                              */

final class Downloader {
    var completion: (() -> Void)?
    func start() {
        // ❌ self ↔ completion 순환: self가 completion 보유, completion이 self 캡처
        completion = { self.finish() }

        // ✅ 캡처 리스트로 지분을 끊는다
        completion = { [weak self] in self?.finish() }
    }
    func finish() {}
}

import Foundation

final class Downloader {
    var completion: (() -> Void)?              // self가 클로저를 '보유'한다
    private var retries = 0

    func startLeaky() {
        // ❌ self → completion → self 순환. 외부 참조가 사라져도 둘 다 안 죽는다.
        completion = {
            self.finish()
        }
    }

    func start() {
        // ✅ 한 변을 끊는다
        completion = { [weak self] in
            guard let self else { return }
            self.finish()
        }
    }

    // ✅ 필요한 값만 캡처하면 self를 아예 안 잡아도 된다 — 가장 깔끔한 해법
    func startCapturingValues() {
        let currentRetries = retries           // 값만 복사
        completion = {
            print("재시도 \(currentRetries)회 후 완료")
        }
    }

    private func finish() {
        // ⚠️ 여기서 completion?()을 부르면 start()가 심은 클로저가 다시 finish()를
        //    불러 무한 재귀가 된다. 발화는 호출자가 하고, 여기서는 참조만 끊는다.
        completion = nil                       // ✅ 발화 후 비워 참조를 끊는다
    }
}

// ⚠️ 반대로 과잉도 문제다. 아래는 self를 '보유하지 않는' 클로저라 순환이 없다.
func noCycle(queue: DispatchQueue, worker: Downloader) {
    queue.async {
        worker.start()      // 클로저는 실행 후 사라진다 — weak 불필요
    }
}

import UIKit

// ① delegate
protocol RouterDelegate: AnyObject { func didFinish() }
final class Router {
    weak var delegate: RouterDelegate?          // ✅ weak
}

// ② 클로저 프로퍼티 (self가 보유하는 콜백)
final class SearchBar: UIView {
    var onQueryChanged: ((String) -> Void)?
}
final class SearchScreen: UIViewController {
    private let bar = SearchBar()
    override func viewDidLoad() {
        super.viewDidLoad()
        bar.onQueryChanged = { [weak self] q in  // ✅ 캡처 리스트로 끊기
            self?.search(q)
        }
    }
    private func search(_ q: String) {}
}

// ③ 양방향 링크 (부모 ↔ 자식)
final class Folder {
    var files: [File] = []                      // 부모가 자식을 strong으로 소유
}
final class File {
    unowned let folder: Folder                  // ✅ 자식은 비소유로 되짚는다
    init(folder: Folder) { self.folder = folder }
}

// 소유 방향을 한 줄로 정리해 두면 리뷰에서 바로 판별된다:
//   "누가 누구를 소유하는가?" → 소유자만 strong, 반대 방향은 전부 weak/unowned
//
// Combine·Notification 구독도 같은 범주다
import Combine
final class Widget {
    private var bag = Set<AnyCancellable>()
    func bind(_ publisher: AnyPublisher<Int, Never>) {
        publisher
            .sink { [weak self] v in self?.apply(v) }   // ✅ sink 클로저도 self를 잡는다
            .store(in: &bag)
    }
    private func apply(_ v: Int) {}
}

import UIKit
import XCTest

// ① 개발 중엔 화면 단위로 deinit 로그를 남긴다 — 닫았는데 안 찍히면 즉시 의심
final class FeedViewController: UIViewController {
#if DEBUG
    deinit { print("✅ deinit: \(type(of: self))") }
#endif
}

// ② 공통 베이스에 한 번만 넣어 두면 전 화면에 적용된다
class TrackedViewController: UIViewController {
#if DEBUG
    deinit { print("✅ deinit: \(type(of: self))") }
#endif
}

// ③ 로그는 사람이 놓친다 — 테스트로 고정한다
final class LeakTests: XCTestCase {

    func test_피드화면이_해제된다() {
        weak var weak: FeedViewController?
        autoreleasepool {
            let vc = FeedViewController()
            vc.loadViewIfNeeded()                 // 뷰 계층까지 만들어 실제와 가깝게
            weak = vc
        }
        XCTAssertNil(weak, "FeedViewController가 해제되지 않았다 — 순환 참조 의심")
    }

    // 재사용 가능한 헬퍼로 만들어 두면 화면마다 한 줄로 검증된다
    func assertDeallocated<T: AnyObject>(_ make: () -> T,
                                         file: StaticString = #filePath,
                                         line: UInt = #line) {
        weak var weak: T?
        autoreleasepool {
            let object = make()
            weak = object
        }
        XCTAssertNil(weak, "\(T.self)가 해제되지 않았다", file: file, line: line)
    }

    func test_여러_화면() {
        assertDeallocated { FeedViewController() }
    }
}

# 특정 프로세스의 VM 리전별 크기·dirty/swapped 스냅샷 (폴트 카운트는 나오지 않는다)
$ vmmap --summary <pid>
# 시스템 전역 폴트/페이지인 카운터
$ vm_stat 1
#  ... faults, pageins, "swapins" 등 컬럼을 시간에 따라 관찰
#  Instruments의 VM Tracker/System Trace로도 폴트를 타임라인에서 볼 수 있다

# 앱 시작이 느릴 때, 원인이 '코드 페이지를 디스크에서 끌어오는 비용'인지 먼저 잰다.
# 실행 파일의 __TEXT는 file-backed clean 페이지라 처음 만질 때마다 hard fault가 난다.

# ① 런치 단계별 시간을 먼저 본다
#    Xcode → Scheme → Run → Arguments → Environment Variables
DYLD_PRINT_STATISTICS = 1
#   total time: 512.30 ms
#     dylib loading time:  240.11 ms    ← 동적 프레임워크가 많다
#     rebase/binding time:  96.40 ms    ← 심볼·포인터가 많다
#     ObjC setup time:      41.02 ms

# ② 실기기 앱의 VM 구성을 본다 — vmmap·vm_stat은 맥 로컬 프로세스용 CLI라
#    실기기 앱은 Xcode의 Debug Memory Graph로 .memgraph를 뜬 뒤 맥에서 연다
vmmap --summary MyApp.memgraph | grep -E '__TEXT|Physical footprint'
#    폴트 수 자체는 실기기에 붙인 Instruments(System Trace / VM Tracker)의 타임라인에서 본다

# ③ 처방
#   - 동적 프레임워크를 정적 링크로 합치면 dylib loading·binding이 함께 준다
#   - 사용하지 않는 코드를 지워 __TEXT 자체를 줄인다 (폴트 수는 코드 크기에 비례)
#   - 런치 경로에서 실제로 쓰는 함수를 앞쪽 페이지에 모으면 폴트가 줄어든다
#     (order file — 링커에 심볼 순서를 지정)
#     Build Settings → Order File → $(SRCROOT)/launch.order

# ④ Instruments의 App Launch 템플릿이 위 항목을 한 화면에서 보여준다.
#    감으로 고치지 말고, 어느 구간이 큰지 먼저 확인할 것.

import Foundation

// 같은 파일이라도 '어떻게 읽느냐'에 따라 메모리 성격이 완전히 달라진다.
//   Data(contentsOf:)  → 익명 dirty. 스왑이 없으니 회수 불가. 상한 넘으면 종료.
//   .mappedIfSafe      → file-backed clean. 압박 시 커널이 버리고 다시 읽는다.

final class TileStore {
    private let mapped: Data

    init(url: URL) throws {
        mapped = try Data(contentsOf: url, options: .mappedIfSafe)
    }

    // 필요한 범위만 만지면 그 페이지만 폴트로 올라온다
    func tile(at index: Int, tileSize: Int) -> Data {
        let start = index * tileSize
        return mapped[start ..< min(start + tileSize, mapped.count)]
    }
}

// ✅ 스트리밍이 더 나은 경우도 있다 — 앞에서 뒤로 한 번만 훑는다면
func parseSequentially(_ url: URL) throws {
    let handle = try FileHandle(forReadingFrom: url)
    defer { try? handle.close() }
    while let chunk = try handle.read(upToCount: 1 << 20), !chunk.isEmpty {
        process(chunk)                 // 상수 메모리로 끝난다
    }
}

func process(_ chunk: Data) {}

// 선택 기준
//   임의 접근 · 일부만 읽음      → mmap
//   앞에서 뒤로 한 번만 읽음     → 스트리밍
//   파일이 작다(수 MB 이하)      → 그냥 Data(contentsOf:)
//
// ⚠️ mmap한 파일을 다른 주체가 truncate하면 접근 순간 SIGBUS로 죽는다.
//    앱 컨테이너 밖의 신뢰할 수 없는 위치는 매핑하지 않는다.

import Foundation

// 페이지 폴트와 TLB miss는 '얼마나 많이 읽었나'가 아니라
// '얼마나 흩어져 읽었나'에 비례한다.

struct Particle { var x, y, vx, vy: Float }

// ✅ 순차 접근 — 한 페이지를 다 쓰고 다음 페이지로 넘어간다
func stepSequential(_ ps: inout [Particle]) {
    for i in ps.indices {
        ps[i].x += ps[i].vx
        ps[i].y += ps[i].vy
    }
}

// ❌ 무작위 접근 — 매 반복이 다른 페이지를 건드려 폴트·TLB miss가 폭증한다
func stepRandom(_ ps: inout [Particle], order: [Int]) {
    for i in order {
        ps[i].x += ps[i].vx
    }
}

// ✅ 일부 필드만 훑는다면 SoA로 재배치해 워킹셋 자체를 줄인다
struct ParticlesSoA {
    var x: [Float] = []
    var y: [Float] = []
    var vx: [Float] = []
    var vy: [Float] = []
}

func drawPositions(_ p: ParticlesSoA) {
    // vx·vy는 아예 읽지 않으므로 그 페이지들이 올라올 일이 없다
    for i in p.x.indices { plot(p.x[i], p.y[i]) }
}

func plot(_ x: Float, _ y: Float) {}

// 16KB 페이지 기준으로 감을 잡으면 판단이 쉬워진다:
//   Particle 16B × 1024개 = 16KB = 정확히 한 페이지
//   → 이 1024개는 순서를 어떻게 섞어도 페이지가 하나뿐이라 폴트는 최대 1회다.
//     차이는 데이터가 여러 페이지에 걸칠 때 생긴다: 100만 개(16MB = 1024페이지)를
//     순차로 훑으면 페이지당 1회씩 1024회로 끝나지만, 무작위로 훑으면 같은 페이지를
//     오가며 TLB miss가 폭증한다(이미 상주 중이면 폴트 자체는 안 난다).
//     압박으로 회수된 페이지를 다시 건드릴 때에야 폴트가 추가된다.

final class MemoryPressureWatcher {
    // 이 source는 반드시 강한 프로퍼티에 보관해야 핸들러가 유지된다.
    // 지역 let에만 두면 스코프를 벗어나며 즉시 해제·취소돼(resume은 retain이 아님)
    // 핸들러가 한 번도 안 불린다.
    private var pressureSource: DispatchSourceMemoryPressure?

    func start() {
        let source = DispatchSource.makeMemoryPressureSource(
            eventMask: [.warning, .critical], queue: .main)
        pressureSource = source   // 강참조로 보관 (유일 소유자)

        source.setEventHandler { [weak self] in
            guard let event = self?.pressureSource?.data else { return }
            if event.contains(.critical) {
                ImageCache.shared.removeAll()   // 지금 비우지 않으면 다음 차례는 종료
            } else if event.contains(.warning) {
                ImageCache.shared.trimToLimit()
            }
        }
        source.resume()
    }
}

// UIKit 레벨: NSCache는 압박 시 자동으로 비워지도록 설계됨

import UIKit

// 경고에 반응하지 않으면 확보가 저절로 생기는 게 아니라,
// 응답하지 못한 그 앱이 다음 종료 후보가 된다.

final class MemoryResponder {
    static let shared = MemoryResponder()
    private var handlers: [() -> Void] = []

    private init() {
        NotificationCenter.default.addObserver(
            forName: UIApplication.didReceiveMemoryWarningNotification,
            object: nil, queue: .main
        ) { [weak self] _ in
            self?.purgeAll()
        }
    }

    func register(_ purge: @escaping () -> Void) {
        handlers.append(purge)
    }

    private func purgeAll() {
        let before = os_proc_available_memory()
        handlers.forEach { $0() }                 // ✅ 실제로 비운다
        let after = os_proc_available_memory()
        print("경고 대응: \((after - before) / 1024 / 1024)MB 회수")
    }
}

// 각 캐시가 스스로 등록한다
final class ThumbnailCache {
    init() {
        MemoryResponder.shared.register { [weak self] in self?.removeAll() }
    }
    func removeAll() {}
}

// ⚠️ 비우는 대상은 '재생성 가능한 것'만.
//    저장 안 된 사용자 입력은 캐시가 아니라 데이터다 — 먼저 draft로 저장할 것.

import UIKit

// ❌ 무한히 자라는 딕셔너리 캐시 — 축출도 없고 압박에 반응하지도 않는다
final class BadCache {
    private var storage: [String: UIImage] = [:]      // 스레드 안전 ✗
    func set(_ i: UIImage, _ k: String) { storage[k] = i }
}

// ✅ NSCache — 스레드 안전 + 압박 시 시스템이 자동으로 비운다
final class ThumbCache {
    private let cache = NSCache<NSString, UIImage>()

    init() {
        cache.countLimit = 300
        // cost는 '바이트 수'로 넣어야 totalCostLimit이 의미를 갖는다
        cache.totalCostLimit = 48 * 1024 * 1024
    }

    func image(for key: String) -> UIImage? {
        cache.object(forKey: key as NSString)
    }

    func store(_ image: UIImage, for key: String) {
        let bytes = Int(image.size.width * image.size.height
                        * image.scale * image.scale * 4)
        cache.setObject(image, forKey: key as NSString, cost: bytes)
    }
}

// ⚠️ countLimit·totalCostLimit은 soft limit이다. 정확히 지켜지지 않으므로
//    NSCache에 든 값은 항상 "있으면 이득, 없어도 정상"으로 다룬다.
func thumbnail(_ key: String, cache: ThumbCache, make: () -> UIImage) -> UIImage {
    if let hit = cache.image(for: key) { return hit }
    let fresh = make()                     // ✅ 없으면 다시 만드는 경로가 반드시 있어야 한다
    cache.store(fresh, for: key)
    return fresh
}

// ✅ Swift 값 타입을 담아야 하면 클래스로 감싼다 (NSCache는 참조 타입만 받는다)
final class Box<T>: NSObject {
    let value: T
    init(_ value: T) { self.value = value }
}

import Foundation
import UIKit

// "기기에 램이 8GB인데 왜 죽지?" — 전역 여유와 무관하게 앱별 상한이 따로 있다.
// 상한은 기기·OS·앱 종류(앱 / 확장 / 위젯)에 따라 다르고 문서화되어 있지 않다.

func currentBudget() -> (usedMB: Int, remainingMB: Int) {
    // 지금 이 프로세스가 더 쓸 수 있는 대략적 바이트
    let remaining = os_proc_available_memory()

    // 현재 footprint (dirty + compressed)
    var info = task_vm_info_data_t()
    var count = mach_msg_type_number_t(MemoryLayout<task_vm_info_data_t>.size
                                       / MemoryLayout<integer_t>.size)
    let kr = withUnsafeMutablePointer(to: &info) {
        $0.withMemoryRebound(to: integer_t.self, capacity: Int(count)) {
            task_info(mach_task_self_, task_flavor_t(TASK_VM_INFO), $0, &count)
        }
    }
    let used = kr == KERN_SUCCESS ? Int(info.phys_footprint) : 0
    return (used / 1024 / 1024, remaining / 1024 / 1024)
}

// 큰 작업 전에 예산을 확인하고, 부족하면 규모를 줄인다
func batchSize(for itemBytes: Int) -> Int {
    let budget = currentBudget().remainingMB * 1024 * 1024
    let safe = Int(Double(budget) * 0.5)      // 절반만 쓴다 (여유 확보)
    return max(1, safe / max(1, itemBytes))
}

// ⚠️ 앱 확장(공유 시트·위젯)은 상한이 앱 본체보다 훨씬 낮다.
//    본체에서 되던 이미지 처리가 확장에서 죽는 이유가 대개 이것이다.

// 특별히 큰 메모리가 필요한 앱은 entitlement로 상한을 올릴 수 있다(무제한은 아니다):
//   com.apple.developer.kernel.increased-memory-limit