docs(10_Wiki): Topic_Business/General/Graphic/Programming을 Topics/ 하위로 이동

최상위 10_Wiki/Topic_*였던 4개 카테고리 폴더를 10_Wiki/Topics/Topic_* 로 재배치.
콘텐츠 변경 없음(순수 폴더 이동) — Topics/ 하위 나머지 폴더는 이미 지난 커밋에서
전부 정리된 상태(잔존 항목은 에이전트 운영 상태 및 사용자가 보존을 요청한
업데이트0615/무제 3.canvas 뿐).
This commit is contained in:
Antigravity Agent
2026-07-05 00:44:01 +09:00
parent e9cbf23ab5
commit 9a135bd19d
6127 changed files with 0 additions and 0 deletions
@@ -0,0 +1,274 @@
---
id: wiki-2026-0508-bottlenecks
title: Bottlenecks (Performance & Process)
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [병목, bottleneck, theory of constraints, TOC, critical path, profiling]
duplicate_of: none
source_trust_level: A
confidence_score: 0.93
verification_status: applied
tags: [performance, bottleneck, profiling, theory-of-constraints, optimization, scalability, latency]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
language: any
framework: profiling tools
---
# Bottlenecks
## 📌 한 줄 통찰
> **"매 system 의 throat"**. 매 weakest link 의 throughput 의 결정. 매 non-bottleneck 의 improve = 매 시간 낭비. 매 Goldratt's TOC: 매 5 step. 매 modern AI: 매 HBM bandwidth + 매 network 의 bottleneck.
## 📖 핵심
### 매 type
1. **Hardware**: CPU / GPU / RAM / disk / network.
2. **Software**: algorithm / blocking / lock contention.
3. **Process**: approval / single point of expertise.
4. **Data**: schema / indexing / partitioning.
5. **Cognitive** (team): meeting / context-switch.
### Theory of Constraints (Goldratt)
1. **Identify** the bottleneck.
2. **Exploit** it (use 100%).
3. **Subordinate** non-bottleneck (don't over-feed).
4. **Elevate** it (invest to widen).
5. **Repeat** (new bottleneck emerges).
### Amdahl's Law (related)
- 매 90% 의 100× → 매 전체 의 매 10× cap.
- 매 bottleneck 의 X 의 의미.
### 매 hardware bottleneck 의 modern (LLM)
- **HBM bandwidth**: 매 H100 = 매 3 TB/s. 매 LLM inference 의 dominant.
- **NVLink**: 매 GPU-GPU.
- **Network** (RDMA, InfiniBand): 매 distributed train.
- **PCIe**: 매 GPU-CPU.
- **Storage**: 매 NVMe vs spinning.
- **Power / cooling**: 매 datacenter limit.
### 매 software bottleneck
- **CPU-bound**: 매 compute heavy.
- **I/O-bound**: 매 disk / network wait.
- **Memory-bound**: 매 swap / cache miss.
- **Lock contention**: 매 mutex.
- **GIL** (Python): 매 single-thread CPU.
- **N+1 query**: 매 ORM 의 typical.
### 매 detection
- **Profiler**: cProfile, perf, async-profiler.
- **Trace**: distributed tracing (Jaeger).
- **Metric**: CPU/mem/disk/network util.
- **APM**: Datadog, NewRelic.
- **Flame graph**.
- **Critical path**.
### 매 process bottleneck
- 매 approval chain.
- 매 single expert.
- 매 environment provisioning.
- 매 review SLA.
- 매 meeting cadence.
→ 매 DORA Lead Time 의 component.
### 매 data bottleneck
- 매 single hot row.
- 매 missing index.
- 매 cross-shard transaction.
- 매 schema migration block.
### 매 distributed bottleneck (modern)
- 매 leader 의 single (Raft, Paxos).
- 매 cross-region call.
- 매 sync replication.
- 매 connection pool limit.
## 💻 패턴
### Profile (Python cProfile)
```python
import cProfile, pstats
def main():
expensive_call()
cheap_call()
cProfile.run('main()', 'out.prof')
stats = pstats.Stats('out.prof').sort_stats('cumulative')
stats.print_stats(20)
```
### Linux perf (system-level)
```bash
# 매 CPU profile
perf record -F 99 -p $PID -- sleep 10
perf report
# 매 flame graph
perf script | ./stackcollapse-perf.pl | ./flamegraph.pl > flame.svg
```
### Async profiler (JVM)
```bash
# 매 sample lock contention
java -jar async-profiler.jar -e lock -d 30 -f lock.html $PID
# 매 wall clock (I/O bound 도)
java -jar async-profiler.jar -e wall -d 30 -f wall.html $PID
```
### N+1 detect (Django)
```python
from django.test.utils import CaptureQueriesContext
from django.db import connection
with CaptureQueriesContext(connection) as ctx:
posts = Post.objects.all()
for post in posts:
print(post.author.name) # 매 N+1
if len(ctx.captured_queries) > 5:
log(f'N+1 detected: {len(ctx.captured_queries)} queries')
# 매 fix
posts = Post.objects.select_related('author') # 매 1 query
```
### GPU bottleneck profile (PyTorch)
```python
import torch.profiler as prof
with prof.profile(
activities=[prof.ProfilerActivity.CPU, prof.ProfilerActivity.CUDA],
record_shapes=True,
profile_memory=True,
) as p:
model(input)
print(p.key_averages().table(sort_by='cuda_time_total', row_limit=20))
# 매 HBM bandwidth bottleneck 의 reveal
```
### Lock contention detection
```python
import threading
class LockMonitor:
def __init__(self, lock):
self.lock = lock
self.wait_times = []
def __enter__(self):
start = time.time()
self.lock.acquire()
self.wait_times.append(time.time() - start)
def __exit__(self, *args):
self.lock.release()
def report(self):
if not self.wait_times: return
avg = sum(self.wait_times) / len(self.wait_times)
if avg > 0.1: log(f'Lock contention: avg wait {avg*1000}ms')
```
### Distributed trace (Jaeger)
```python
from opentelemetry import trace
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.exporter.jaeger.thrift import JaegerExporter
trace.set_tracer_provider(TracerProvider())
tracer = trace.get_tracer(__name__)
@tracer.start_as_current_span('handle_request')
def handle(req):
with tracer.start_as_current_span('db_query') as span:
span.set_attribute('db.statement', 'SELECT ...')
result = db.query(...)
return result
```
→ 매 시각적 bottleneck identify.
### Process bottleneck (workflow analysis)
```python
def analyze_workflow(stage_durations):
"""매 stage 별 의 throughput 의 비교."""
rates = {stage: 1 / dur for stage, dur in stage_durations.items()}
bottleneck = min(rates, key=rates.get)
overall_rate = rates[bottleneck]
waste = sum(r - overall_rate for r in rates.values() if r > overall_rate)
return {
'bottleneck': bottleneck,
'overall_rate_per_min': overall_rate * 60,
'capacity_wasted': waste,
}
```
### Critical path (DAG)
```python
import networkx as nx
def critical_path(tasks):
"""매 longest path through DAG."""
G = nx.DiGraph()
for task in tasks:
G.add_node(task.id, duration=task.duration)
for dep in task.deps:
G.add_edge(dep, task.id)
# 매 longest path
return nx.dag_longest_path(G, weight='duration')
```
## 🤔 결정 기준
| 증상 | Tool |
|---|---|
| Slow request | APM + distributed trace |
| CPU pegged | Flame graph (perf) |
| GPU underutilized | Memory bandwidth (PyTorch profiler) |
| Slow query | EXPLAIN + slow query log |
| Lock contention | async-profiler -e lock |
| Long lead time | Process / DORA analysis |
| Thundering herd | Coordination check |
**기본값**: 매 measure first. 매 hypothesis-based optimize.
## 🔗 Graph
- 부모: [[System-Design]]
- 변형: [[CPU-Bound]]
- 응용: [[Theory-of-Constraints]] · [[Amdahl's Law]] · [[Critical-Path]]
- Tool: [[Profiling]] · [[Flame-Graph]] · [[Distributed Tracing]]
- Adjacent: [[Optimization]] · [[Scalability]] · [[DORA-Metrics]]
## 🤖 LLM 활용
**언제**: 매 performance optimization. 매 capacity planning. 매 incident root cause. 매 process improvement.
**언제 X**: 매 hypothesis 없 의 optimize.
## ❌ 안티패턴
- **Optimize without measure**: 매 wrong place.
- **Non-bottleneck improve**: 매 시간 waste (TOC).
- **모든 part 의 평등 invest**: 매 ROI low.
- **Single profile 의 trust**: 매 representative X.
- **Process 의 "사람 의 fault"**: 매 system issue 가 대부분.
- **Premature optimization**: 매 simplicity lose.
## 🧪 검증 / 중복
- Verified (Goldratt TOC, Knuth premature optimization, Brendan Gregg Systems Performance).
- 신뢰도 A.
- Related: [[Amdahl's Law]] · [[Theory-of-Constraints]] · [[Profiling]] · [[Critical-Path]].
## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — type + TOC + 매 profile / N+1 / GPU / trace code |