refactor(topics): 멀티 에이전트용 지식 재편 — _Common(공통 기본기) + Domain_* 구조

에이전트 8종(대화형/프로그래머 C·S/디자이너/설계자/기획자/QA/PD/PM)에게 [공통 기본 능력 + 롤별 Specialty] 2층으로 지식을 주입하기 위한 재분류. 문서 내용·포맷은 무수정, 폴더 이동만 (6,372개 문서 수 보존 확인). - Topic_Programming → Domain_Programming (내부 구조 보존) - Topic_Graphic → Domain_Design - Topic_Business → Domain_Product - Topic_General → Domain_General - _Common 신설: Math(구 Topic_Math_Specialty), Reasoning(구 General/From_Thinking & Reasoning), Reasoning_Creativity(구 General/From_창의성), Communication(Poetic_Blog_Writing + From_writing) - 타 도메인의 From_* 폴더는 유지 (출처 표기일 뿐, 이미 도메인에 맞게 분류된 문서) - 빈 폴더 정리 (memory/procedures) - 에이전트→폴더 매핑은 workspace의 .astra/agent-knowledge-map.json (9개 에이전트) Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-07-11 11:05:56 +09:00
parent 6549ead309
commit c24165b8bc
6193 changed files with 1717 additions and 31 deletions
@@ -0,0 +1,189 @@
+---
+id: wiki-2026-0508-garbage-collection
+title: Garbage Collection
+category: 10_Wiki/Topics
+status: verified
+canonical_id: self
+aliases: [GC, Garbage Collector, Memory Management]
+duplicate_of: none
+source_trust_level: A
+confidence_score: 0.9
+verification_status: applied
+tags: [runtime, memory, performance, vm]
+raw_sources: []
+last_reinforced: 2026-05-10
+github_commit: pending
+tech_stack:
+  language: java
+  framework: jvm
+---
+
+# Garbage Collection
+
+## 매 한 줄
+> **"매 unreachable memory를 자동으로 reclaim한다"**. 매 GC는 manual malloc/free의 cognitive burden을 제거 — McCarthy의 Lisp(1959)에서 시작, modern V8/HotSpot/Go의 generational + concurrent collector로 evolution. 2026 trade-off는 매 throughput vs latency vs memory overhead.
+
+## 매 핵심
+
+### 매 Algorithm 분류
+- **Mark-and-sweep**: 매 reachable mark → unreachable sweep (fragmentation)
+- **Copying (semi-space)**: 매 live obj 새 space로 copy (50% memory waste)
+- **Mark-compact**: 매 mark 후 live obj 한쪽 끝으로 compact
+- **Reference counting**: 매 ref count 0 즉시 free (cycle 문제)
+
+### 매 Generational Hypothesis
+- **매 most objects die young**: 매 short-lived 95%+
+- **Young gen** (eden + survivor): 매 frequent, fast minor GC
+- **Old gen** (tenured): 매 infrequent, expensive major GC
+- **매 write barrier**: old → young reference tracking
+
+### 매 응용
+1. JVM (G1, ZGC, Shenandoah) — sub-ms pause.
+2. V8 (Orinoco) — concurrent + parallel + incremental.
+3. Go (tricolor concurrent) — sub-ms STW pause.
+4. .NET (Server GC, regions) — generational + LOH.
+
+## 💻 패턴
+
+### JVM ZGC 설정 (sub-ms pause)
+```bash
+java -XX:+UseZGC \
+     -XX:+ZGenerational \
+     -Xmx16g \
+     -XX:SoftMaxHeapSize=14g \
+     -jar app.jar
+```
+
+### Go GC tuning
+```go
+import "runtime/debug"
+
+func init() {
+    // 매 GOGC=100 default — 100% growth 시 trigger
+    debug.SetGCPercent(50) // 매 lower = more frequent, less memory
+    
+    // 매 hard memory limit (Go 1.19+)
+    debug.SetMemoryLimit(8 << 30) // 매 8GB
+}
+
+// 매 manual hint after large alloc
+runtime.GC()
+```
+
+### V8 Heap snapshot (Node.js)
+```javascript
+const v8 = require('v8');
+const fs = require('fs');
+
+// 매 heap snapshot for leak analysis
+const snapshot = v8.writeHeapSnapshot();
+console.log(`Heap snapshot: ${snapshot}`);
+
+// 매 heap statistics
+console.log(v8.getHeapStatistics());
+// { total_heap_size, used_heap_size, heap_size_limit, ... }
+```
+
+### Reference cycle break (Python)
+```python
+import weakref
+
+class Parent:
+    def __init__(self):
+        self.children = []
+
+class Child:
+    def __init__(self, parent):
+        # 매 strong cycle: parent ↔ child → leak
+        # self.parent = parent
+        # 매 fix: weakref
+        self.parent = weakref.ref(parent)
+    
+    def get_parent(self):
+        return self.parent()  # 매 None if collected
+```
+
+### Object pooling (avoid GC pressure)
+```csharp
+public class BulletPool
+{
+    private readonly Stack<Bullet> pool = new();
+    
+    public Bullet Rent()
+    {
+        if (pool.Count > 0) return pool.Pop();
+        return new Bullet();
+    }
+    
+    public void Return(Bullet b)
+    {
+        b.Reset();
+        pool.Push(b);
+    }
+}
+// 매 hot path에서 alloc 회피 → minor GC 감소
+```
+
+### Tricolor marking (concept, Go-style)
+```go
+// 매 white = unscanned, gray = in queue, black = scanned
+// invariant: 매 black은 white를 직접 reference 안 함
+// write barrier로 enforce:
+func writeBarrier(slot **Object, ptr *Object) {
+    if isBlack(slot) && isWhite(ptr) {
+        markGray(ptr)  // 매 promote to gray
+    }
+    *slot = ptr
+}
+```
+
+### .NET Span<T> (stack alloc, no GC)
+```csharp
+public int SumDigits(int n)
+{
+    Span<int> digits = stackalloc int[16];
+    int i = 0;
+    while (n > 0) { digits[i++] = n % 10; n /= 10; }
+    int sum = 0;
+    for (int j = 0; j < i; j++) sum += digits[j];
+    return sum; // 매 zero heap allocation
+}
+```
+
+## 매 결정 기준
+| 상황 | GC choice |
+|---|---|
+| Low-latency trading (JVM) | ZGC / Shenandoah (sub-ms pause) |
+| Throughput batch (JVM) | Parallel GC |
+| Game engine (managed) | Object pooling + GC.Collect at safe points |
+| Real-time embedded | Manual memory or Rust (no GC) |
+| Server-side Go | Default tricolor + GOGC tuning |
+
+**기본값**: 매 modern runtime의 default GC. 매 measure first (allocation profiler), tune later.
+
+## 🔗 Graph
+- 부모: [[Memory Management]]
+- 변형: [[Reference Counting]]
+- 응용: [[JVM]] · [[V8]]
+- Adjacent: [[ARC]]
+
+## 🤖 LLM 활용
+**언제**: 매 GC pause 분석, allocation hotspot 식별, runtime flag tuning 추천.
+**언제 X**: 매 Rust/C/C++ — GC 없음. 매 hard real-time — non-deterministic pause unacceptable.
+
+## ❌ 안티패턴
+- **Calling GC.Collect() 빈번**: 매 fragmentation + throughput 손실.
+- **Finalizer 의존**: 매 non-deterministic, GC overhead 증가 → IDisposable 사용.
+- **Large object heap thrash**: 매 LOH (.NET) 매번 alloc → fragmentation.
+- **String concat in loop**: 매 immutable string × N alloc → StringBuilder 사용.
+
+## 🧪 검증 / 중복
+- Verified (Jones, Hosking, Moss, "The Garbage Collection Handbook", 2nd ed., 2023).
+- Verified (Oracle ZGC docs, OpenJDK).
+- 신뢰도 A.
+
+## 🕓 Changelog
+| 날짜 | 변경 |
+|---|---|
+| 2026-05-08 | Phase 1 |
+| 2026-05-10 | Manual cleanup — generational GC + V8/Go/JVM modern collectors |