golang中的GPM到底是什么？

G、P、M 三者是golang实现高并发能的最为重要的概念， runtime 通过 调度器 来实现三者的相互调度执行，通过p将用户态的 g 与内核态资源 m 的动态绑定来执行，以减少以前通过频繁创建内核态线程而产生的一系列的性能问题，从而发挥服务器最大有限资源的能力。

本节主要通过阅读runtime源码来认识这三个组件到底长的是什么样子，以此加深到 GPM 的理解。go version go1.15.6

G

G是英文字母 goroutine 的缩写，一般称为“ 协程 ”，注意它与线程和进程的区别，这个应该很容易理解，每个goper应该都知道。

每个 Goroutine 对应一个 G 结构体，G 存储 Goroutine 的运行堆栈、状态以及任务函数，可重用。

Goroutine数据结构位于 src/runtime/runtime2.go 文件，注意此文件里有太多重要的底层数据结构，对于我们理解底层runtime非常的重要，建议大量多看看。不需要记住每一个数据结构，但需要的时候要能第一时间想到在哪里查找。

Goroutine 字段非常的多，我们这里分段来理解

type g struct {
// Stack parameters.
// stack describes the actual stack memory: [stack.lo, stack.hi).
// stackguard0 is the stack pointer compared in the Go stack growth prologue.
// It is stack.lo+StackGuard normally, but can be StackPreempt to trigger a preemption.
// stackguard1 is the stack pointer compared in the C stack growth prologue.
// It is stack.lo+StackGuard on g0 and gsignal stacks.
// It is ~0 on other goroutine stacks, to trigger a call to morestackc (and crash).
stack stack // offset known to runtime/cgo
stackguard0 uintptr // offset known to liblink
stackguard1 uintptr // offset known to liblink
}

stack 描述了当前 Goroutine 的栈内存范围 [stack.lo, stack.hi) ，其中stack 的数据结构为

// Stack describes a Go execution stack.
// The bounds of the stack are exactly [lo, hi),
// with no implicit data structures on either side.
// 描述go执行栈
// 栈边界为[lo, hi)，左包含可不包含，即 lo≤stack// 两边都没有隐含的数据结构。
type stack struct {
lo uintptr
hi uintptr
}

stackguard0 和 stackguard1 均是一个栈指针，用于扩容场景，前者用于 Go stack ，后者用于C stack。这两个字段主要用于调度器抢占式调度。另外还有三个字段与抢占有关

type g struct {
preempt bool // preemption signal, duplicates stackguard0 = stackpreempt
preemptStop bool // transition to _Gpreempted on preemption; otherwise, just deschedule
preemptShrink bool // shrink stack at synchronous safe point
}

preempt 抢占标记，其值为true 执行 stackguard0 = stackpreempt

preemptStop 将抢占标记修改为 _Gpreedmpted，如果修改失败则取消

preemptShrink 在同步安全点收缩栈

type g struct {
_panic *_panic // innermost panic - offset known to liblink
_defer *_defer // innermost defer
}

_panic 当前Goroutine 中的panic

_defer 当前Goroutine 中的defer

type g struct {
m *m // current m; offset known to arm liblink
sched gobuf
goid int64
}

m 当前 Goroutine 绑定的M,有可能为nil

sched 存储当前 Goroutine 调度相关的数据

goid 当前 Goroutine 的唯一标识，对开发者不可见，一般不使用此字段。可参考相关文章了解为什么Go开发团队为什么不向外开放访问此字段。

gobuf 结构体

type gobuf struct {
// The offsets of sp, pc, and g are known to (hard-coded in) libmach.
// 寄存器 sp,pc和g的偏移量，硬编码在libmach
//
// ctxt is unusual with respect to GC: it may be a
// heap-allocated funcval, so GC needs to track it, but it
// needs to be set and cleared from assembly, where it's
// difficult to have write barriers. However, ctxt is really a
// saved, live register, and we only ever exchange it between
// the real register and the gobuf. Hence, we treat it as a
// root during stack scanning, which means assembly that saves
// and restores it doesn't need write barriers. It's still
// typed as a pointer so that any other writes from Go get
// write barriers.
sp uintptr
pc uintptr
g guintptr
ctxt unsafe.Pointer
ret sys.Uintreg
lr uintptr
bp uintptr // for GOEXPERIMENT=framepointer
}

调度器在将 G 由一种状态变更为另一种状态时，需要将上下文信息保存到这个 gobuf 结构体，当再次运行 G 的时候，再从这个结构体中读取出来，主要用来暂时上下文信息。其中的栈指针和程序计数器会用来存储或者恢复寄存器中的值，改变程序即将执行的代码。

Goroutine 的状态有以下几种（ 源码 ）

需要注意的是对于 _Gmoribund_unused 状态并未使用，但在 gdb 脚本中存在；而对于 _Genqueue_unused 状态目前也未使用，不需要关心。

_Gscan 与上面除了 _Grunning 状态以外的其它状态相组合，表示 GC 正在扫描栈。Goroutine 不会执行用户代码，且栈由设置了 _Gscan 位的 Goroutine 所有。

可以看到除了上面提到的两个未使用的状态外一共有14种状态值。许多状态之间是可以进行改变的。如下图所示

type g strcut {
syscallsp uintptr // if status==Gsyscall, syscallsp = sched.sp to use during gc
syscallpc uintptr // if status==Gsyscall, syscallpc = sched.pc to use during gc
stktopsp uintptr // expected sp at top of stack, to check in traceback
param unsafe.Pointer // passed parameter on wakeup
atomicstatus uint32
stackLock uint32 // sigprof/scang lock; TODO: fold in to atomicstatus
}

type g struct {
waitsince int64 // approx time when the g become blocked
waitreason waitReason // if status==Gwaiting
}

waitsince G 阻塞时长

waitreason 阻塞原因

type g struct {
// asyncSafePoint is set if g is stopped at an asynchronous
// safe point. This means there are frames on the stack
// without precise pointer information.
asyncSafePoint bool
paniconfault bool // panic (instead of crash) on unexpected fault address
gcscandone bool // g has scanned stack; protected by _Gscan bit in status
throwsplit bool // must not split stack
}

asyncSafePoint 异步安全点；如果 g 在 异步安全点 停止则设置为 true ，表示在栈上没有精确的指针信息

paniconfault 地址异常引起的panic（代替了崩溃）

gcscandone g 扫描完了栈，受状态 _Gscan 位保护

throwsplit 不允许拆分stack 什么意思？

type g struct {
// activeStackChans indicates that there are unlocked channels
// pointing into this goroutine's stack. If true, stack
// copying needs to acquire channel locks to protect these
// areas of the stack.
activeStackChans bool
// parkingOnChan indicates that the goroutine is about to
// park on a chansend or chanrecv. Used to signal an unsafe point
// for stack shrinking. It's a boolean value, but is updated atomically.
parkingOnChan uint8
}

activeStackChans 表示是否有未加锁定的channel指向到了g 栈，如果为true,那么对栈的复制需要channal锁来保护这些区域

parkingOnChan 表示g 是放在chansend 还是 chanrecv。用于栈的收缩，是一个布尔值，但是原子性更新

type g struct {
raceignore int8 // ignore race detection events
sysblocktraced bool // StartTrace has emitted EvGoInSyscall about this goroutine
sysexitticks int64 // cputicks when syscall has returned (for tracing)
traceseq uint64 // trace event sequencer
tracelastp puintptr // last P emitted an event for this goroutine
lockedm muintptr
sig uint32
writebuf []byte
sigcode0 uintptr
sigcode1 uintptr
sigpc uintptr
gopc uintptr // pc of go statement that created this goroutine
ancestors *[]ancestorInfo // ancestor information goroutine(s) that created this goroutine (only used if debug.tracebackancestors)
startpc uintptr // pc of goroutine function
racectx uintptr
waiting *sudog // sudog structures this g is waiting on (that have a valid elem ptr); in lock order
cgoCtxt []uintptr // cgo traceback context
labels unsafe.Pointer // profiler labels
timer *timer // cached timer for time.Sleep
selectDone uint32 // are we participating in a select and did someone win the race?
}

gopc 创建当前G的pc

startpc go func 的pc

waiting 如何理解？

timer 通过time.Sleep 缓存 timer

从字段命名来看，许多字段都与trace 有关，不清楚什么意思

type g struct {
// Per-G GC state
// gcAssistBytes is this G's GC assist credit in terms of
// bytes allocated. If this is positive, then the G has credit
// to allocate gcAssistBytes bytes without assisting. If this
// is negative, then the G must correct this by performing
// scan work. We track this in bytes to make it fast to update
// and check for debt in the malloc hot path. The assist ratio
// determines how this corresponds to scan work debt.
gcAssistBytes int64
}

gcAssistBytes 与GC相关，未理解要表达的意思？

总结

• 每个G 都有自己的状态，状态保存在 atomicstatus 字段，共有十几种状态值。


• 每个 G 在状态发生变化时，即 atomicstatus 字段值被改变时，都需要保存当前G的上下文的信息，这个信息存储在 sched 字段，其数据类型为 gobuf ，想理解存储的信息可以看一下这个结构体的各个字段


• 每个G 都有三个与抢占有关的字段，分别为 preempt 、 preemptStop 和 premptShrink


• 每个 G 都有自己的唯一id, 字段为 goid ，但此字段官方不推荐开发使用


• 每个 G 都可以最多绑定一个m，如果可能未绑定，则值为 nil


• 每个 G 都有自己内部的 defer 和 panic 。


• G 可以被阻塞，并存储有阻塞原因，字段 waitsince 和 waitreason


• G 可以被进行 GC 扫描，相关字段为 gcscandone 、 atomicstatus （ _Gscan 与上面除了 _Grunning 状态以外的其它状态组合）

P

P表示逻辑处理器，对 G 来说，P 相当于 CPU 核，G 只有绑定到 P 才能被调度。对 M 来说，P 提供了相关的执行环境(Context)，如内存分配状态(mcache)，任务队列(G)等。

P 的数量决定了系统内最大可并行的 G 的数量（前提：物理 CPU 核数  >= P 的数量）。

P 的数量由用户设置的 GoMAXPROCS 决定，但是不论 GoMAXPROCS 设置为多大，P 的数量最大为 256。

P的数据结构也有几十个字段，我们还是分开来理解

type p struct {
id int32
status uint32 // one of pidle/prunning/...
link puintptr
schedtick uint32 // incremented on every scheduler call
syscalltick uint32 // incremented on every system call
sysmontick sysmontick // last tick observed by sysmon
}

id : P的唯一标识

status P当前状态，状态值有_Pidle、_Prunning、_Psyscall、_Pgcstop 和 _Pdead

link 未知

schedtick 每次程序被调用时递增

syscalltick 每次系统调用时时递增

sysmontick sysmon 最后tick的时间，是一个 sysmontick 数据类型。sysmon介绍： https://www.jianshu.com/p/469d0c7a7936

对于P的状态有五种：

M

// TODO