What is the GMP model?

Question

Accepted Answer

**GMP** — Goroutine (G), Machine (M), Processor (P). Go's scheduler architecture that efficiently maps lightweight goroutines onto OS threads.

**Component roles:**
- **G (Goroutine):** Unit of execution with its own stack, program counter, and state. States: runnable, running, waiting, syscall.
- **M (Machine):** OS thread that executes goroutine code. Created by runtime, max ~10,000. Binds to a P to run goroutines.
- **P (Processor):** Logical processor with local run queue (256 capacity). Count set by `GOMAXPROCS`. Mediates between G and M.

**Scheduling flow:**
```go
// Check GOMAXPROCS setting
fmt.Println("CPUs:", runtime.NumCPU())
fmt.Println("GOMAXPROCS:", runtime.GOMAXPROCS(0))

// Runtime scheduler control
runtime.Gosched()          // Yield to scheduler
runtime.LockOSThread()     // Pin to current OS thread
runtime.NumGoroutine()     // Count active goroutines
```

**Work stealing algorithm:**
1. When P's local queue is empty, try to steal from random P.
2. Steal half of victim P's queue.
3. If stealing fails, check global run queue.
4. If global queue is empty, check network poller.
5. If nothing to do, M may sleep.

**Handoff mechanism:** When M enters a blocking syscall:
1. M is detached from its P.
2. P is given to another M (or new M created).
3. Goroutines in P's queue continue running.

**When GMP knowledge helps:**
- Tuning GOMAXPROCS for workload type.
- Debugging scheduling-related performance issues.
- Understanding goroutine behavior in containers.
- Optimizing for latency vs throughput.

**Common mistakes:**
- Not adjusting GOMAXPROCS in containers (uses host CPU count).
- Confusing `runtime.GOMAXPROCS(0)` (returns current) with setting a value.
- Assuming goroutines always run in parallel.
- Using `runtime.LockOSThread()` without need (reduces flexibility).
- Not understanding that work stealing is random (not perfectly balanced).

Go: What is the GMP model?