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,186 @@
+---
+id: wiki-2026-0508-just-in-time-jit
+title: Just-In-Time (JIT)
+category: 10_Wiki/Topics
+status: verified
+canonical_id: self
+aliases: [JIT Compilation, Dynamic Compilation, Tracing JIT]
+duplicate_of: none
+source_trust_level: A
+confidence_score: 0.95
+verification_status: applied
+tags: [compiler, optimization, runtime, performance, llvm]
+raw_sources: []
+last_reinforced: 2026-05-10
+github_commit: pending
+tech_stack:
+  language: python
+  framework: jax
+---
+
+# Just-In-Time (JIT)
+
+## 매 한 줄
+> **"매 compile 매 first call, 매 reuse 매 hot path"**. JIT compilation 매 source / bytecode / IR 의 native code 의 runtime translation — 매 profile-guided 의 hot region 의 optimize. 2026 ML 시대 매 JAX `jit`, PyTorch 2.x `torch.compile`, Mojo, JuliaLang 매 mainstream.
+
+## 매 핵심
+
+### 매 JIT 의 mechanics
+- **Trace**: 매 input shape / dtype 의 capture 매 computational graph.
+- **Specialize**: 매 fixed shapes 의 specialized kernel 의 generate.
+- **Cache**: 매 (function, signature) → compiled artifact.
+- **Recompile**: 매 shape change → cache miss → recompile (avoid in hot loop).
+
+### 매 vs AOT
+- **AOT (ahead-of-time)**: rustc, gcc — startup 빠름, 매 dynamic dispatch 부족.
+- **JIT**: 매 runtime info 의 use → better inlining, 매 startup 의 cost.
+- **Hybrid**: PyPy, V8, .NET — interpret first, JIT after N invocations.
+
+### 매 ML JIT 의 specifics
+- **Static shape**: JAX `jit` 매 traced shape 의 specialize — dynamic shape 매 retrace.
+- **XLA / Triton backend**: 매 fused kernels — memory bandwidth dominant.
+- **Compilation cache**: persistent disk cache 매 cold-start 의 mitigate.
+
+### 매 응용
+1. ML training loop (JAX, torch.compile).
+2. Numerical Python (Numba `@njit`).
+3. JavaScript engines (V8, JSC).
+4. Database query plans (Snowflake, DuckDB).
+
+## 💻 패턴
+
+### Pattern 1: JAX jit (2026 standard)
+```python
+import jax
+import jax.numpy as jnp
+
+@jax.jit
+def attention(q, k, v):
+    scores = jnp.einsum("bhqd,bhkd->bhqk", q, k) / jnp.sqrt(q.shape[-1])
+    weights = jax.nn.softmax(scores, axis=-1)
+    return jnp.einsum("bhqk,bhkd->bhqd", weights, v)
+
+# First call: trace + compile (slow)
+# Subsequent: cached (fast)
+out = attention(q, k, v)
+```
+
+### Pattern 2: torch.compile (PyTorch 2.x)
+```python
+import torch
+
+model = MyTransformer().cuda()
+compiled = torch.compile(model, mode="reduce-overhead", fullgraph=True)
+
+for batch in dataloader:
+    out = compiled(batch)  # 매 first batch 매 slow, subsequent 매 fast
+    out.backward()
+```
+
+### Pattern 3: Static argnums (avoid retrace)
+```python
+from functools import partial
+
+@partial(jax.jit, static_argnums=(1,))
+def topk(logits, k):
+    return jax.lax.top_k(logits, k)
+
+# 매 k=10 매 specialized — 매 k=20 매 separate compilation
+topk(logits, 10)
+topk(logits, 20)  # new compile
+```
+
+### Pattern 4: Numba JIT (Python → LLVM)
+```python
+from numba import njit
+import numpy as np
+
+@njit(cache=True, fastmath=True)
+def mandelbrot(c, max_iter=100):
+    z = 0.0 + 0.0j
+    for i in range(max_iter):
+        z = z * z + c
+        if z.real * z.real + z.imag * z.imag > 4.0:
+            return i
+    return max_iter
+```
+
+### Pattern 5: AOT cache 의 prewarm
+```python
+import os
+os.environ["JAX_COMPILATION_CACHE_DIR"] = "/var/cache/jax"
+
+import jax
+jax.config.update("jax_persistent_cache_min_entry_size_bytes", 0)
+jax.config.update("jax_persistent_cache_min_compile_time_secs", 1.0)
+
+# 매 first deployment 매 prewarm script 의 run — 매 next pods cold-start fast.
+```
+
+### Pattern 6: Recompilation detection
+```python
+import jax
+from collections import Counter
+
+class CompileCounter:
+    def __init__(self):
+        self.count = Counter()
+
+    def trace(self, fn_name: str, sig: tuple):
+        self.count[(fn_name, sig)] += 1
+        if self.count[(fn_name, sig)] > 3:
+            print(f"매 thrash: {fn_name} recompiled {self.count[(fn_name, sig)]} times")
+
+# Usage: hook into jax.config or torch dynamo logger
+```
+
+### Pattern 7: Mojo JIT (2026)
+```mojo
+fn matmul[M: Int, N: Int, K: Int](a: Tensor, b: Tensor) -> Tensor:
+    # 매 compile-time specialization 매 shapes — 매 SIMD auto-vectorize.
+    var c = Tensor[DType.float32](M, N)
+    for i in range(M):
+        for j in range(N):
+            var s: Float32 = 0
+            for k in range(K):
+                s += a[i, k] * b[k, j]
+            c[i, j] = s
+    return c
+```
+
+## 매 결정 기준
+| 상황 | Approach |
+|---|---|
+| Numerical Python tight loop | Numba `@njit`. |
+| ML training | JAX `jit` 또는 `torch.compile`. |
+| Variable shapes | Avoid JIT 또는 `dynamic=True`. |
+| One-shot script | 매 JIT overhead 매 not worth. |
+| Long-running server | JIT + persistent cache. |
+
+**기본값**: ML 매 `torch.compile(mode="reduce-overhead")` 또는 `jax.jit`. Tight numerical loop 매 Numba.
+
+## 🔗 Graph
+- 부모: [[Performance-Optimization]]
+- 변형: [[Tracing-JIT]]
+- 응용: [[JAX]] · [[torch.compile]] · [[V8 Engine]]
+- Adjacent: [[XLA]] · [[Triton]]
+
+## 🤖 LLM 활용
+**언제**: ML training/serving where compile cost amortizes (>100 calls), tight numerical loops, long-running services.
+**언제 X**: One-shot scripts, code with constantly-changing shapes, debugging (use eager mode).
+
+## ❌ 안티패턴
+- **JIT in hot Python loop with varying shapes**: 매 retrace 매 every call — slower than eager.
+- **No persistent cache**: 매 cold start 매 30s+ compile every deploy.
+- **JIT debugging**: 매 stacktrace 매 useless — eager 의 disable JIT first.
+- **Premature JIT**: profile first — 매 80% code 매 not bottleneck.
+
+## 🧪 검증 / 중복
+- Verified: JAX docs (2026), PyTorch 2.x docs, "Engineering a Compiler" (Cooper & Torczon), V8 design docs.
+- 신뢰도 A.
+
+## 🕓 Changelog
+| 날짜 | 변경 |
+|---|---|
+| 2026-05-08 | Phase 1 |
+| 2026-05-10 | Manual cleanup — full content with JAX/torch.compile/Numba/Mojo 2026 patterns |