Go 런타임 스케줄러 Deep Dive — GMP 모델, Work-Stealing, 비동기 Preemption, netpoller 완전 정복 (2025)

유저 공간:     G1  G2  G3  G4  G5  G6  G7  G8  G9  ...  (수십만)
                |   |   |   |   |   |   |   |   |
                +---+---+   +---+---+   +---+---+---+
                    |           |                |
Go 런타임:          P0          P1              P2     (GOMAXPROCS=3)
                    |           |                |
OS:                 M0          M1              M2     (OS 스레드)
                    |           |                |
커널:              CPU0        CPU1             CPU2

type g struct {
    stack       stack   // 스택 [lo, hi)
    stackguard0 uintptr // 스택 오버플로우 체크용

    m         *m       // 현재 실행 중인 M (없으면 nil)
    sched     gobuf    // 저장된 PC, SP, BP 등
    atomicstatus atomic.Uint32 // _Grunnable, _Grunning, _Gwaiting, ...

    goid       uint64 // 고유 ID
    waitreason waitReason // "chan receive", "select", "GC assist wait" 등

    // 스케줄러 힌트
    preempt       bool // true면 다음 preemption check에서 양보
    preemptStop   bool // 비동기 preemption 표식
    preemptShrink bool // 스택 축소 허용

    // 트레이싱
    traceseq uint64
    tracelastp puintptr
}

type m struct {
    g0      *g     // 스케줄링/GC용 특수 고루틴 (각 M마다 1개)
    curg    *g     // 현재 실행 중인 유저 고루틴

    p       puintptr  // 현재 붙어 있는 P (없으면 0)
    nextp   puintptr  // 다음에 붙을 P
    oldp    puintptr  // syscall 전의 P

    id          int64
    mallocing   int32
    throwing    throwType
    preemptoff  string // "gc", "locks" 등 preempt 금지 이유

    locks       int32
    dying       int32
    profilehz   int32

    // park/unpark
    park        note
    alllink     *m
    schedlink   muintptr

    // cgo / signal
    mOS // OS별 정보 (스레드 ID, TLS 등)
}

type p struct {
    id          int32
    status      uint32 // _Pidle, _Prunning, _Psyscall, _Pgcstop, _Pdead

    m           muintptr // 붙어 있는 M

    // 로컬 런큐 (락 없이 접근 가능, 크기 256)
    runqhead    uint32
    runqtail    uint32
    runq        [256]guintptr

    // 다음에 실행할 G (우선권)
    runnext     guintptr

    // GC 관련
    gcAssistTime        int64
    gcFractionalMarkTime int64
    gcMarkWorkerMode    gcMarkWorkerMode

    // sudog 캐시 (채널 대기용)
    sudogcache  []*sudog
    sudogbuf    [128]*sudog

    // mcache (malloc 로컬 캐시)
    mcache      *mcache

    // 타이머 힙
    timers      []*timer
    timerModifiedEarliest atomic.Int64
}

┌─────────────────────────────────────────────┐
│ Global Run Queue (락 필요)                   │
└─────────────────────────────────────────────┘
             ↑ (overflow/steal)
┌──────┐   ┌──────┐   ┌──────┐   ┌──────┐
│  P0  │   │  P1  │   │  P2  │   │  P3  │     GOMAXPROCS=4
│ runq │   │ runq │   │ runq │   │ runq │     local run queues (256)
└──────┘   └──────┘   └──────┘   └──────┘
    │         │          │          │
    M0        M1         M2         M3         OS 스레드
    │         │          │          │
  CPU0      CPU1       CPU2        CPU3

// 의사 코드 (실제 구현은 더 복잡)
func findRunnable() *g {
    top:
    // 1. 로컬 런큐 체크
    if gp, inheritTime := runqget(_p_); gp != nil {
        return gp, inheritTime
    }

    // 2. 글로벌 런큐 체크
    if sched.runqsize != 0 {
        lock(&sched.lock)
        gp := globrunqget(_p_, 0)
        unlock(&sched.lock)
        if gp != nil { return gp, false }
    }

    // 3. Netpoller 체크 (non-blocking)
    if list := netpoll(0); !list.empty() {
        gp := list.pop()
        return gp, false
    }

    // 4. 다른 P에서 훔치기 (steal from other P)
    procs := gomaxprocs
    if sched.nmspinning.Add(1) < procs/2 {
        // 최대 4번 시도
        for i := 0; i < 4; i++ {
            for _, p2 := range randomOrder.randomProcs(procs) {
                if gp := runqsteal(_p_, p2, stealTimersOrRunNextG); gp != nil {
                    return gp, false
                }
            }
        }
    }

    // 5. 아무것도 없으면 M을 park (잠재움)
    stopm()
    goto top
}

func runqget(_p_ *p) (gp *g, inheritTime bool) {
    // runnext 우선
    next := _p_.runnext
    if next != 0 && _p_.runnext.cas(next, 0) {
        return next.ptr(), true
    }

    for {
        h := atomic.LoadAcq(&_p_.runqhead)
        t := _p_.runqtail
        if t == h {
            return nil, false // 비었음
        }
        gp := _p_.runq[h%uint32(len(_p_.runq))].ptr()
        if atomic.CasRel(&_p_.runqhead, h, h+1) {
            return gp, false
        }
    }
}

func runqsteal(_p_, p2 *p, stealRunNextG bool) *g {
    t := _p_.runqtail
    // p2의 런큐에서 절반을 훔쳐온다
    n := runqgrab(p2, &_p_.runq, t, stealRunNextG)
    if n == 0 { return nil }
    n--
    gp := _p_.runq[(t+n)%uint32(len(_p_.runq))].ptr()
    if n == 0 { return gp }
    _ = atomic.LoadAcq(&_p_.runqhead)
    atomic.StoreRel(&_p_.runqtail, t+n)
    return gp
}

; 함수 프롤로그
CMPQ    SP, runtime.stackguard0(R14)  ; SP가 guard보다 작으면?
JLS     morestack                      ; 스택 모자람 → morestack 호출

// 원래 스택 [0x1000, 0x1800), 새 스택 [0x2000, 0x2800)
// delta = 0x1000
for _, ptr := range stackMap {
    if ptr >= oldLo && ptr < oldHi {
        *ptr += delta // 새 위치로 조정
    }
}

func shrinkstack(gp *g) {
    oldsize := gp.stack.hi - gp.stack.lo
    newsize := oldsize / 2
    if newsize < _StackMin {
        return
    }
    // 사용량이 1/4 미만이면 절반으로 축소
    avail := gp.stack.hi - gp.sched.sp
    if avail*4 > oldsize {
        return
    }
    copystack(gp, newsize)
}

; 함수 프롤로그
CMPQ    SP, runtime.stackguard0(R14)
JLS     morestack_or_preempt  ; stackguard를 MAX_UINT로 설정해서 강제 진입

// Go 1.13에서 이 코드는 치명적
go func() {
    for i := 0; i < 1e18; i++ {
        // 함수 호출 없음 → preempt 불가
    }
}()

runtime.GC() // 영원히 멈춤! GC 시작을 위해 모든 G가 stop해야 하는데...

// runtime/preempt.go
func preemptone(_p_ *p) bool {
    mp := _p_.m.ptr()
    gp := mp.curg

    gp.preempt = true
    gp.stackguard0 = stackPreempt // 기존 협력적 방식도 유지

    // 비동기 preemption
    if preemptMSupported && debug.asyncpreemptoff == 0 {
        _p_.preempt = true
        preemptM(mp)  // SIGURG 발송
    }
    return true
}

// 이 상태에서 멈추면 위험
x := &someStruct{}  // 1. x 할당 중 (writeBarrier 이전)
x.field = ptr       // 2. GC가 x.field를 못 보고 ptr 해제 가능

// runtime/proc.go
func sysmon() {
    for {
        // 1. netpoll 체크 (blocking된 I/O 깨우기)
        list := netpoll(10 * time.Microsecond)
        injectglist(&list)

        // 2. syscall blocked P 회수
        retake(now)

        // 3. GC 강제 트리거 (2분마다)
        if gcTrigger.test() {
            injectglist(startGCM)
        }

        // 4. 스캐벤저 (메모리 반환)
        scavenger.wake()
    }
}

func retake(now int64) uint32 {
    n := 0
    for i := 0; i < len(allp); i++ {
        _p_ := allp[i]
        pd := &_p_.sysmontick

        // Case 1: syscall에서 너무 오래 있는 P
        if _p_.status == _Psyscall && pd.syscalltick == now {
            handoffp(_p_) // P를 다른 M에 넘기기
            n++
        }

        // Case 2: 같은 G가 10ms 이상 실행 중
        if _p_.status == _Prunning && pd.schedtick == now {
            preemptone(_p_) // preempt 요청
        }
    }
    return uint32(n)
}

// syscall.Syscall에서 호출
func entersyscall() {
    _g_ := getg()
    _g_.m.mcache = nil
    _g_.m.p.ptr().status = _Psyscall
    _g_.m.p.ptr().m = 0 // P에서 M 떼어내기
    _g_.m.locks++
    save(pc, sp)
    _g_.atomicstatus.Store(_Gsyscall)
}

func handoffp(_p_ *p) {
    // P에 새 M 붙이기 (idle M 깨우거나 새로 생성)
    if atomic.Load(&sched.nmspinning) == 0 && atomic.Cas(&sched.nmspinning, 0, 1) {
        startm(_p_, true)
        return
    }
    // ...
}

func exitsyscall() {
    _g_ := getg()

    if exitsyscallfast(oldp) {
        // 빠른 경로: 원래 P가 아직 비어 있으면 재획득
        ...
        return
    }

    // 느린 경로: P를 찾지 못하면 G를 글로벌 큐에 넣고 M park
    mcall(exitsyscall0)
}

// net 패키지 내부
func (fd *netFD) Read(p []byte) (n int, err error) {
    n, err = fd.pfd.Read(p)
    // ...
}

// internal/poll
func (fd *FD) Read(p []byte) (int, error) {
    for {
        n, err := syscall.Read(fd.Sysfd, p)
        if err != nil {
            if err == syscall.EAGAIN && fd.pd.pollable() {
                if err = fd.pd.waitRead(fd.isFile); err == nil {
                    continue // 재시도
                }
            }
        }
        return n, err
    }
}

go f()

func newproc(fn *funcval) {
    gp := getg()
    pc := getcallerpc()
    systemstack(func() {
        newg := newproc1(fn, gp, pc)
        _p_ := getg().m.p.ptr()

        // runnext에 우선 배치 (LIFO)
        runqput(_p_, newg, true)

        if mainStarted {
            wakep()
        }
    })
}

func schedule() {
    _g_ := getg()

    top:
    // GC 담당 중이면 잠시 대기
    if sched.gcwaiting.Load() {
        gcstopm()
        goto top
    }

    // 타이머 체크
    checkTimers(pp, 0)

    // 61번에 한 번은 글로벌 큐에서 (기아 방지)
    var gp *g
    if _p_.schedtick%61 == 0 && sched.runqsize > 0 {
        lock(&sched.lock)
        gp = globrunqget(_p_, 1)
        unlock(&sched.lock)
    }

    // 로컬 큐에서
    if gp == nil {
        gp, _ = runqget(_p_)
    }

    // 로컬도 비면 work-stealing
    if gp == nil {
        gp, _, _ = findRunnable()
    }

    execute(gp, false)
}

// M은 네 가지 상태
// 1. Executing G
// 2. Executing runtime code (GC, sysmon)
// 3. Idle (parked, waiting for work)
// 4. Spinning (adtively searching for work)

ch := make(chan int)
go func() { ch <- 42 }()
x := <-ch

ch := make(chan int, 10)

type hchan struct {
    qcount   uint         // 현재 개수
    dataqsiz uint         // 버퍼 크기
    buf      unsafe.Pointer // 순환 버퍼
    elemsize uint16
    closed   uint32
    elemtype *_type
    sendx    uint // 다음 쓸 위치
    recvx    uint // 다음 읽을 위치
    recvq    waitq // 대기 중인 리시버
    sendq    waitq // 대기 중인 센더
    lock     mutex
}

select {
case v := <-ch1:
case ch2 <- v:
case <-time.After(1 * time.Second):
default:
}

type Mutex struct {
    state int32
    sema  uint32
}

// state bits:
// 0: locked
// 1: woken (깨워진 상태)
// 2: starving (기아 모드)
// 3-: waiter count

[앱 실행] → [STW 1: Mark 시작] → [동시 Mark] → [STW 2: Mark 종료] → [동시 Sweep] → [앱 실행]
              ~수 ms               수십 ms          ~수 ms              (비차단)

// runtime/mgcmark.go
func gcAssistAlloc(gp *g) {
    assistWorkPerByte := float64(gcController.assistWorkPerByte.Load())
    debtBytes := gp.gcAssistBytes * int64(assistWorkPerByte)
    if debtBytes > 0 {
        gcDrainN(gcw, debtBytes) // 마크 작업 수행
    }
}

type gcControllerState struct {
    dedicatedMarkWorkersNeeded atomic.Int64
    fractionalUtilizationGoal  float64 // 보통 0.25
}

호스트: 32 CPU
컨테이너 limit: 2 CPU (cgroup)
→ GOMAXPROCS = 32 (잘못됨!)
→ 32개 P가 2개 CPU 위에서 요리 경쟁 → throttling + 컨텍스트 스위칭 폭증

import _ "go.uber.org/automaxprocs"

GODEBUG=schedtrace=1000 ./myapp

SCHED 1000ms: gomaxprocs=4 idleprocs=0 threads=8 spinningthreads=0 idlethreads=1 runqueue=3 [12 8 6 10]

gc 12 @2.345s 3%: 0.021+1.2+0.015 ms clock, 0.084+0.52/2.1/1.8+0.060 ms cpu

import "runtime/trace"

f, _ := os.Create("trace.out")
trace.Start(f)
defer trace.Stop()

// ... 애플리케이션 코드 ...

go tool trace trace.out

import _ "net/http/pprof"

go func() {
    http.ListenAndServe("localhost:6060", nil)
}()

# CPU 프로파일 (30초)
go tool pprof http://localhost:6060/debug/pprof/profile?seconds=30

# 메모리
go tool pprof http://localhost:6060/debug/pprof/heap

# 고루틴 스택
curl http://localhost:6060/debug/pprof/goroutine?debug=2

# 블록/뮤텍스
go tool pprof http://localhost:6060/debug/pprof/block
go tool pprof http://localhost:6060/debug/pprof/mutex

// 나쁜 예
func fetchAll(urls []string) []string {
    ch := make(chan string)
    for _, u := range urls {
        go func(u string) {
            ch <- fetch(u)
        }(u)
    }
    var results []string
    for i := 0; i < 2; i++ { // 버그: 2개만 받음
        results = append(results, <-ch)
    }
    return results
    // 나머지 N-2개 고루틴은 영원히 ch에 블록됨 → 리크
}

// 센더가 더 빠르면 매번 park/unpark → 2x 이상 오버헤드
ch := make(chan int)
go producer(ch)
consumer(ch)

// 버퍼 추가로 batching
ch := make(chan int, 1024)

// 100만 개 고루틴 → 메모리 2GB + 스케줄링 오버헤드
for i := 0; i < 1_000_000; i++ {
    go process(i)
}

// Worker pool 패턴
pool := make(chan struct{}, 100) // 세마포어
for i := 0; i < 1_000_000; i++ {
    pool <- struct{}{}
    go func(i int) {
        defer func() { <-pool }()
        process(i)
    }(i)
}

func main() {
    runtime.LockOSThread()
    defer runtime.UnlockOSThread()

    // 이제 이 G는 특정 OS 스레드에 묶임
    // cgo callback, OpenGL (OpenGL은 thread-local state 사용), 시그널 처리 등에 필요
}

// #include <stdio.h>
import "C"

func foo() {
    C.printf(...) // cgo 호출
}

# taskset으로 CPU 고정
taskset -c 0-15 ./myapp

# GOMAXPROCS도 맞추기
GOMAXPROCS=16 ./myapp

GODEBUG=gctrace=1 ./myapp 2>&1 | grep "gc "

GODEBUG=schedtrace=100 ./myapp

curl http://localhost:6060/debug/pprof/goroutine?debug=1 | head -100

10000 @ 0x7a3e00 0x7a3cd0 0x6b2a20
#       0x7a3dff        runtime.gopark+0xff    runtime/proc.go:363
#       0x7a3ccf        runtime.chanrecv+0x37f runtime/chan.go:584
#       0x6b2a1f        main.worker+0x2f       main.go:24

go tool pprof -top cpu.prof

// Go 1.21까지: 고전적 함정
for i := 0; i < 10; i++ {
    go func() {
        fmt.Println(i) // 전부 10 출력!
    }()
}

go test -cpuprofile cpu.prof
cp cpu.prof default.pgo
go build -pgo=auto

1. 현상 확인
   - p50/p99 레이턴시
   - 처리량 (rps)
   - 에러 비율
   - CPU/메모리 사용률

2. 빠른 스냅샷
   GODEBUG=schedtrace=1000,gctrace=1 ./myapp

3. Goroutine 개수 확인
   curl http://.../debug/pprof/goroutine?debug=1

4. CPU 프로파일
   go tool pprof http://.../debug/pprof/profile?seconds=30
   - top 명령: hot path 확인
   - runtime.* 함수가 상위? → 런타임 오버헤드 의심

5. 블록 프로파일
   go tool pprof http://.../debug/pprof/block
   - 채널 recv/send? → 설계 점검
   - Mutex? → 경합 축소 (락 세분화, sync.Pool, sync.Map)

6. Trace (정밀 분석)
   trace.Start(f); ...; trace.Stop()
   go tool trace trace.out
   - Goroutine Analysis → 특정 G의 실행/블록 패턴
   - Scheduler Latency → starvation 여부

7. 메모리 프로파일
   go tool pprof http://.../debug/pprof/heap
   - top -cum → 누적 할당 많은 지점
   - 할당 줄이기: sync.Pool, 슬라이스 재사용

8. 힙 오브젝트 (gc 분석)
   GOGC=off ./myapp → 수동으로 GC 제어
   GOMEMLIMIT=8GiB → 메모리 상한 설정

┌─────────────────────────────────────────────────────┐
│            Go GMP Scheduler Cheat Sheet              │
├─────────────────────────────────────────────────────┤
│ G = Goroutine: 2KB stack, grows on demand            │
│ M = Machine: OS thread                               │
│ P = Processor: local runq (256), mcache              │
│                                                      │
│ GOMAXPROCS = len(P) = logical CPUs                   │
│                                                      │
│ Schedule Loop (on g0):                               │
│   1. runqget(P.local)       [lock-free]              │
│   2. globrunqget (61-tick)  [lock]                   │
│   3. netpoll(0)             [epoll/kqueue]           │
│   4. runqsteal(random P)    [work-stealing]          │
│   5. stopm() → park                                  │
│                                                      │
│ Preemption:                                          │
│   - sysmon: 10ms 단위 체크                            │
│   - Async: SIGURG → asyncPreempt                     │
│   - Cooperative: stackguard0 flag                    │
│                                                      │
│ Syscall:                                             │
│   - entersyscall: P 분리                              │
│   - sysmon retake: 10μs+ → handoffp                  │
│   - exitsyscall: P 재획득 or global queue + park     │
│                                                      │
│ Netpoller:                                           │
│   - 모든 socket non-blocking                          │
│   - gopark → epoll_wait → goready                    │
│                                                      │
│ GC:                                                  │
│   - Concurrent mark + STW boundaries (~1ms)          │
│   - Async preempt가 STW 짧게 유지                     │
│   - GC assist: 할당한 G가 mark 도움                   │
│                                                      │
│ 튜닝:                                                 │
│   - GOMAXPROCS (+ automaxprocs for k8s)              │
│   - GODEBUG=schedtrace=1000,gctrace=1                │
│   - go tool trace, pprof (cpu/heap/block/mutex)      │
└─────────────────────────────────────────────────────┘