The G-M-P model

Learn the goroutine, machine and processor trio.

The G-M-P model

The Go scheduler works with three structures: G (goroutine: its stack and state), M (machine: an operating system thread) and P (processor: the right to run plus a local queue). For a G to run, an M must hold a P.

number of P = GOMAXPROCS (default: number of CPU cores)
number of M = as many as needed (grows for blocking syscalls)
number of G = can be hundreds of thousands

This multiplexes millions of goroutines onto a few OS threads (M:N scheduling).

Why goroutines are cheap

A goroutine starts with a stack of about 2 KB that grows as needed, while an OS thread usually reserves 1–8 MB. Switching goroutines happens in user space without entering the kernel, so context switches are very fast.

Exercise P and CPU

Compare runtime.GOMAXPROCS(0) with runtime.NumCPU() and print whether the P count is not greater than the CPU count (<=).

Show example solution

package main

import (
    "fmt"
    "runtime"
)

func main() {
    fmt.Println(runtime.GOMAXPROCS(0) <= runtime.NumCPU())
}

Test yourself

At most how many goroutines can run Go code at the same time?
- Always 1
- As many as GOMAXPROCS (the number of Ps)
- Unlimited
- As many as the number of Ms
Show answer

As many as GOMAXPROCS (the number of Ps) — Running Go code needs a P, and the number of Ps is GOMAXPROCS. Ms waiting in syscalls don't hold a P.

Read the P count

fmt.Println(runtime.____(0))

Show answer

fmt.Println(runtime.GOMAXPROCS(0))

G, M, P

G

Goroutine
M

OS thread
P

Run right + queue
GOMAXPROCS

Number of Ps

Next lesson: Goroutine lifecycle

We Are Enhancing Your Experience

Cookie Preferences

Strictly Necessary Cookies

Analytical Cookies