What is the GMP model?

Question

Accepted Answer

**GMP** — Goroutine (G), Machine (M), Processor (P). Go's three-tier scheduler that enables efficient concurrency by multiplexing goroutines onto OS threads.

**G (Goroutine):** Represents a unit of work. Contains stack, instruction pointer, and scheduling state. Goroutines transition between states: `_Grunnable` (ready to run), `_Grunning` (actively executing), `_Gwaiting` (blocked on I/O/channel/syscall), `_Gsyscall` (in system call).

**M (Machine):** An OS thread managed by the runtime. M threads execute goroutine code. Limited to 10,000 by default. When an M blocks, its P is handed off to another M.

**P (Processor):** A logical processor with a local run queue (capacity 256). Number controlled by `GOMAXPROCS` (defaults to `runtime.NumCPU()`). P is the scheduling entity — it binds goroutines to machines.

**Scheduling algorithm:**
```go
// Check current GOMAXPROCS
fmt.Println("Processors:", runtime.GOMAXPROCS(0))

// Runtime scheduler hints
runtime.Gosched()    // Yield to scheduler
runtime.LockOSThread() // Pin to current OS thread
runtime.UnlockOSThread() // Unpin from OS thread
```

**Work stealing:** When a P's local queue is empty, it tries to steal half of another P's queue. This prevents load imbalance without a global lock.

**Handoff:** When an M makes a blocking syscall, its P is detached and given to another M so goroutines keep running.

**When to tune GMP:**
- CPU-bound workloads: set GOMAXPROCS to number of CPU cores.
- I/O-bound workloads: consider higher GOMAXPROCS.
- Container environments: GOMAXPROCS may not detect cgroup limits automatically.

**Common mistakes:**
- Not adjusting GOMAXPROCS in containers (Go defaults to host CPU count).
- Assuming `runtime.GOMAXPROCS(0)` returns the max value (it returns current setting).
- Using `runtime.LockOSThread()` unnecessarily (pins goroutine, reduces scheduling flexibility).
- Not understanding that work stealing is random (not guaranteed to balance perfectly).
- Forgetting that goroutines sharing a P can run concurrently but not in parallel.

Go: What is the GMP model?