2nd/10_Wiki/Topics/Domain_Programming/Programming & Language/마크-스윕(Mark-Sweep).md

id, title, category, status, canonical_id, aliases, duplicate_of, source_trust_level, confidence_score, verification_status, tags, raw_sources, last_reinforced, github_commit, tech_stack

id	title	category	status	canonical_id	aliases	duplicate_of	source_trust_level	confidence_score	verification_status	tags	raw_sources	last_reinforced	github_commit	tech_stack
wiki-2026-0508-마크-스윕-mark-sweep	마크 스윕(Mark Sweep)	10_Wiki/Topics	verified	self	Mark-Sweep Mark and Sweep Tracing GC	none	A	0.9	applied	gc memory runtime algorithm jvm v8		2026-05-10	pending	language framework C/C++/Java JVM/V8/Go runtime

마크 스윕(Mark Sweep)

매 한 줄

"매 root 에서 reachable 한 것만 매 mark, 매 unmarked 는 매 sweep". 매 1960 McCarthy 의 LISP 가 매 origin, 매 60+ 년 동안 매 tracing GC 의 backbone. 매 modern 변형 (G1, ZGC, Shenandoah, V8 Orinoco) 매 모두 매 mark-sweep 의 evolution.

매 핵심

매 두 phase

1. 매 Mark: 매 root (stack, register, global) 에서 매 reachable graph 매 traverse, 매 mark bit 설정.
2. 매 Sweep: 매 heap 전체를 매 scan, 매 unmarked block 을 매 free list 로.

매 vs 친척들

• 매 vs Reference Counting: 매 cycle 처리 가능, 매 thoughput ↑, 매 latency spike ↑.
• 매 vs Copying (Cheney): 매 fragmentation 발생, 매 메모리 효율 ↑ (매 copy 가 1/2 reserve X).
• 매 vs Mark-Compact: 매 sweep 후 compact 추가 — 매 fragmentation 해결.

매 Tri-color abstraction

• 매 White: 매 unvisited (sweep 대상).
• 매 Grey: 매 reachable, 매 children 미 traverse.
• 매 Black: 매 reachable + 매 children traversed.
• 매 invariant: 매 black → white edge 의 X (매 보장 시 concurrent OK).

매 Modern 변형

• 매 Generational: 매 young/old, 매 minor/major GC.
• 매 Concurrent: 매 mark 를 매 mutator 와 병행.
• 매 Incremental: 매 small chunk 씩 매 stop.
• 매 Region-based (G1): 매 heap 을 region 으로 split.

패턴

Naive mark

typedef struct Obj {
    uint8_t marked;
    size_t n_refs;
    struct Obj** refs;
} Obj;

void mark(Obj* o) {
    if (!o || o->marked) return;
    o->marked = 1;
    for (size_t i = 0; i < o->n_refs; i++) mark(o->refs[i]);
}

Sweep over heap

typedef struct Heap { Obj* objects[MAX]; size_t n; Obj* free_list; } Heap;

void sweep(Heap* h) {
    Obj* fl = NULL;
    for (size_t i = 0; i < h->n; i++) {
        Obj* o = h->objects[i];
        if (!o) continue;
        if (o->marked) {
            o->marked = 0;            // 매 reset for next cycle
        } else {
            // 매 free
            o->refs[0] = (Obj*)fl;     // 매 link to free list
            fl = o;
            h->objects[i] = NULL;
        }
    }
    h->free_list = fl;
}

Tri-color (worklist)

void mark_tricolor(Obj* roots[], size_t n) {
    Queue grey;
    for (size_t i = 0; i < n; i++) { roots[i]->color = GREY; enqueue(&grey, roots[i]); }
    while (!empty(&grey)) {
        Obj* o = dequeue(&grey);
        for (size_t i = 0; i < o->n_refs; i++) {
            Obj* c = o->refs[i];
            if (c && c->color == WHITE) { c->color = GREY; enqueue(&grey, c); }
        }
        o->color = BLACK;
    }
}

Write barrier (concurrent invariant)

// 매 Dijkstra-style: 매 black 이 white 를 가리키지 않도록
void write_barrier(Obj* parent, size_t i, Obj* child) {
    if (parent->color == BLACK && child && child->color == WHITE) {
        child->color = GREY;
        enqueue(&grey, child);
    }
    parent->refs[i] = child;
}

Generational hook (write barrier on old → young)

// 매 remembered set 에 매 old object 추가
void gen_write_barrier(Obj* parent, size_t i, Obj* child) {
    parent->refs[i] = child;
    if (parent->gen == OLD && child && child->gen == YOUNG)
        remembered_set_add(parent);
}

JVM tuning (G1)

java -XX:+UseG1GC \
     -XX:MaxGCPauseMillis=100 \
     -XX:G1HeapRegionSize=16m \
     -Xms4g -Xmx4g \
     -Xlog:gc*:file=gc.log \
     -jar app.jar

V8 incremental marking trace

node --trace-gc --trace-gc-verbose --max-old-space-size=4096 app.js

매 결정 기준

상황	GC
매 simple, 매 single-thread	Mark-Sweep
매 fragmentation 의 우려	Mark-Compact
매 short-lived dominant	Generational + copying young
매 latency-critical (<10ms)	ZGC / Shenandoah
매 throughput-critical	Parallel/Throughput GC
매 ref-cycle 매 잦음	Tracing GC (RC X)

기본값: 매 JVM 8GB 초과 = 매 G1 (default), 매 latency 절실 = 매 ZGC.

Graph

• 부모: Garbage Collection · Memory Management
• 응용: JVM · V8
• Adjacent: Tri-color Marking · Write Barrier · Reference Counting

LLM 활용

언제: 매 GC 알고리즘 설명, 매 JVM/V8 tuning, 매 GC log 분석, 매 toy GC 작성. 언제 X: 매 production 의 직접 GC patch (매 risk ↑) — 매 review 만.

안티패턴

• 매 Frequent full GC trigger: 매 -Xmx 부족 / 매 leak.
• 매 No write barrier in concurrent: 매 missed object 의 free.
• 매 Recursive mark on deep graph: 매 stack overflow — 매 worklist 사용.
• 매 Tuning without log: 매 -Xlog:gc* / -verbose:gc 매 필수.
• 매 Force System.gc(): 매 hint, 매 흔히 매 worse latency.

검증 / 중복

• Verified: Jones/Hosking/Moss "The Garbage Collection Handbook", JVM HotSpot docs, V8 blog (Orinoco), Go runtime docs.
• 신뢰도 A.

Changelog

날짜	변경
2026-05-08	Phase 1
2026-05-10	Manual cleanup — mark-sweep tri-color/write barrier/tuning 작성