1
// Create a new g running fn.
2
// Put it on the queue of g's waiting to run.
3
// The compiler turns a go statement into a call to this.
4
func newproc(fn *funcval) {
5
    gp := getg()
6
    // 获取当前的程序计数器（返回地址），用于调试和分析栈踪迹时追踪调用来源
7
    pc := sys.GetCallerPC()
8
    // 切换到当前 M 的系统栈
9
    systemstack(func() {
10
        newg := newproc1(fn, gp, pc, false, waitReasonZero)
11

12
        // 获取当前线程的 P 并将新创建的 newg 加入到本地队列
13
        pp := getg().m.p.ptr()
14
        runqput(pp, newg, true)
15

16
        if mainStarted {
17
            wakep()
18
        }
19
    })
20
}

1
// Create a new g in state _Grunnable (or _Gwaiting if parked is true), starting at fn.
2
// callerpc is the address of the go statement that created this. The caller is responsible
3
// for adding the new g to the scheduler. If parked is true, waitreason must be non-zero.
4
func newproc1(fn *funcval, callergp *g, callerpc uintptr, parked bool, waitreason waitReason) *g {
5
    if fn == nil {
6
        fatal("go of nil func value")
7
    }
8

9
    mp := acquirem() // disable preemption because we hold M and P in local vars.
10
    pp := mp.p.ptr()
11
    newg := gfget(pp)
12
    if newg == nil {
13
        newg = malg(stackMin)
14
        casgstatus(newg, _Gidle, _Gdead)
15
        allgadd(newg) // publishes with a g->status of Gdead so GC scanner doesn't look at uninitialized stack.
16
    }
17

18
    ......
19

20
    totalSize := uintptr(4*goarch.PtrSize + sys.MinFrameSize) // extra space in case of reads slightly beyond frame
21
    totalSize = alignUp(totalSize, sys.StackAlign)
22
    sp := newg.stack.hi - totalSize
23

24
    ......
25

26
    memclrNoHeapPointers(unsafe.Pointer(&newg.sched), unsafe.Sizeof(newg.sched))
27
    newg.sched.sp = sp
28
    newg.stktopsp = sp
29
    newg.sched.pc = abi.FuncPCABI0(goexit) + sys.PCQuantum // +PCQuantum so that previous instruction is in same function
30
    newg.sched.g = guintptr(unsafe.Pointer(newg))
31
    gostartcallfn(&newg.sched, fn)
32
    newg.parentGoid = callergp.goid
33
    newg.gopc = callerpc
34
    newg.ancestors = saveAncestors(callergp)
35
    newg.startpc = fn.fn
36

37
    ...... // 判断是否系统 G，进行标记
38

39
    // Track initial transition?
40
    newg.trackingSeq = uint8(cheaprand())
41
    if newg.trackingSeq%gTrackingPeriod == 0 {
42
        newg.tracking = true
43
    }
44
    gcController.addScannableStack(pp, int64(newg.stack.hi-newg.stack.lo))
45

46
    .......// trace 跟踪
47

48
    // Set up race context.
49
    if raceenabled {
50
        newg.racectx = racegostart(callerpc)
51
        newg.raceignore = 0
52
        if newg.labels != nil {
53
            // See note in proflabel.go on labelSync's role in synchronizing
54
            // with the reads in the signal handler.
55
            racereleasemergeg(newg, unsafe.Pointer(&labelSync))
56
        }
57
    }
58
    releasem(mp) // 释放锁
59

60
    return newg
61
}

1
type p struct {
2
    id          int32
3
    status      uint32 // one of pidle/prunning/...
4
    link        puintptr
5
    schedtick   uint32     // incremented on every scheduler call
6
    syscalltick uint32     // incremented on every system call
7
    sysmontick  sysmontick // last tick observed by sysmon
8
    m           muintptr   // back-link to associated m (nil if idle)
9
    mcache      *mcache
10
    pcache      pageCache
11
    raceprocctx uintptr
12

13
    deferpool    []*_defer // pool of available defer structs (see panic.go)
14
    deferpoolbuf [32]*_defer
15

16
    // Cache of goroutine ids, amortizes accesses to runtime·sched.goidgen.
17
    goidcache    uint64
18
    goidcacheend uint64
19

20
    // Queue of runnable goroutines. Accessed without lock.
21
    runqhead uint32
22
    runqtail uint32
23
    runq     [256]guintptr
24
    // runnext, if non-nil, is a runnable G that was ready'd by
25
    // the current G and should be run next instead of what's in
26
    // runq if there's time remaining in the running G's time
27
    // slice. It will inherit the time left in the current time
28
    // slice. If a set of goroutines is locked in a
29
    // communicate-and-wait pattern, this schedules that set as a
30
    // unit and eliminates the (potentially large) scheduling
31
    // latency that otherwise arises from adding the ready'd
32
    // goroutines to the end of the run queue.
33
    //
34
    // Note that while other P's may atomically CAS this to zero,
35
    // only the owner P can CAS it to a valid G.
36
    runnext guintptr
37

38
    // Available G's (status == Gdead)
39
    gFree struct {
40
        gList
41
        n int32
42
    }
43

44
    sudogcache []*sudog
45
    sudogbuf   [128]*sudog
46

47
    // Cache of mspan objects from the heap.
48
    mspancache struct {
49
        // We need an explicit length here because this field is used
50
        // in allocation codepaths where write barriers are not allowed,
51
        // and eliminating the write barrier/keeping it eliminated from
52
        // slice updates is tricky, more so than just managing the length
53
        // ourselves.
54
        len int
55
        buf [128]*mspan
56
    }
57

58
    // Cache of a single pinner object to reduce allocations from repeated
59
    // pinner creation.
60
    pinnerCache *pinner
61

62
    trace pTraceState
63

64
    palloc persistentAlloc // per-P to avoid mutex
65

66
    // Per-P GC state
67
    gcAssistTime         int64 // Nanoseconds in assistAlloc
68
    gcFractionalMarkTime int64 // Nanoseconds in fractional mark worker (atomic)
69

70
    // limiterEvent tracks events for the GC CPU limiter.
71
    limiterEvent limiterEvent
72

73
    // gcMarkWorkerMode is the mode for the next mark worker to run in.
74
    // That is, this is used to communicate with the worker goroutine
75
    // selected for immediate execution by
76
    // gcController.findRunnableGCWorker. When scheduling other goroutines,
77
    // this field must be set to gcMarkWorkerNotWorker.
78
    gcMarkWorkerMode gcMarkWorkerMode
79
    // gcMarkWorkerStartTime is the nanotime() at which the most recent
80
    // mark worker started.
81
    gcMarkWorkerStartTime int64
82

83
    // gcw is this P's GC work buffer cache. The work buffer is
84
    // filled by write barriers, drained by mutator assists, and
85
    // disposed on certain GC state transitions.
86
    gcw gcWork
87

88
    // wbBuf is this P's GC write barrier buffer.
89
    //
90
    // TODO: Consider caching this in the running G.
91
    wbBuf wbBuf
92

93
    runSafePointFn uint32 // if 1, run sched.safePointFn at next safe point
94

95
    // statsSeq is a counter indicating whether this P is currently
96
    // writing any stats. Its value is even when not, odd when it is.
97
    statsSeq atomic.Uint32
98

99
    // Timer heap.
100
    timers timers
101

102
    // maxStackScanDelta accumulates the amount of stack space held by
103
    // live goroutines (i.e. those eligible for stack scanning).
104
    // Flushed to gcController.maxStackScan once maxStackScanSlack
105
    // or -maxStackScanSlack is reached.
106
    maxStackScanDelta int64
107

108
    // gc-time statistics about current goroutines
109
    // Note that this differs from maxStackScan in that this
110
    // accumulates the actual stack observed to be used at GC time (hi - sp),
111
    // not an instantaneous measure of the total stack size that might need
112
    // to be scanned (hi - lo).
113
    scannedStackSize uint64 // stack size of goroutines scanned by this P
114
    scannedStacks    uint64 // number of goroutines scanned by this P
115

116
    // preempt is set to indicate that this P should be enter the
117
    // scheduler ASAP (regardless of what G is running on it).
118
    preempt bool
119

120
    // gcStopTime is the nanotime timestamp that this P last entered _Pgcstop.
121
    gcStopTime int64
122

123
    // Padding is no longer needed. False sharing is now not a worry because p is large enough
124
    // that its size class is an integer multiple of the cache line size (for any of our architectures).
125
}
126

127
type g struct {
128
    // Stack parameters.
129
    // stack describes the actual stack memory: [stack.lo, stack.hi).
130
    // stackguard0 is the stack pointer compared in the Go stack growth prologue.
131
    // It is stack.lo+StackGuard normally, but can be StackPreempt to trigger a preemption.
132
    // stackguard1 is the stack pointer compared in the //go:systemstack stack growth prologue.
133
    // It is stack.lo+StackGuard on g0 and gsignal stacks.
134
    // It is ~0 on other goroutine stacks, to trigger a call to morestackc (and crash).
135
    stack       stack   // offset known to runtime/cgo
136
    stackguard0 uintptr // offset known to liblink
137
    stackguard1 uintptr // offset known to liblink
138

139
    _panic    *_panic // innermost panic - offset known to liblink
140
    _defer    *_defer // innermost defer
141
    m         *m      // current m; offset known to arm liblink
142
    sched     gobuf
143
    syscallsp uintptr // if status==Gsyscall, syscallsp = sched.sp to use during gc
144
    syscallpc uintptr // if status==Gsyscall, syscallpc = sched.pc to use during gc
145
    syscallbp uintptr // if status==Gsyscall, syscallbp = sched.bp to use in fpTraceback
146
    stktopsp  uintptr // expected sp at top of stack, to check in traceback
147
    // param is a generic pointer parameter field used to pass
148
    // values in particular contexts where other storage for the
149
    // parameter would be difficult to find. It is currently used
150
    // in four ways:
151
    // 1. When a channel operation wakes up a blocked goroutine, it sets param to
152
    //    point to the sudog of the completed blocking operation.
153
    // 2. By gcAssistAlloc1 to signal back to its caller that the goroutine completed
154
    //    the GC cycle. It is unsafe to do so in any other way, because the goroutine's
155
    //    stack may have moved in the meantime.
156
    // 3. By debugCallWrap to pass parameters to a new goroutine because allocating a
157
    //    closure in the runtime is forbidden.
158
    // 4. When a panic is recovered and control returns to the respective frame,
159
    //    param may point to a savedOpenDeferState.
160
    param        unsafe.Pointer
161
    atomicstatus atomic.Uint32
162
    stackLock    uint32 // sigprof/scang lock; TODO: fold in to atomicstatus
163
    goid         uint64
164
    schedlink    guintptr
165
    waitsince    int64      // approx time when the g become blocked
166
    waitreason   waitReason // if status==Gwaiting
167

168
    preempt       bool // preemption signal, duplicates stackguard0 = stackpreempt
169
    preemptStop   bool // transition to _Gpreempted on preemption; otherwise, just deschedule
170
    preemptShrink bool // shrink stack at synchronous safe point
171

172
    // asyncSafePoint is set if g is stopped at an asynchronous
173
    // safe point. This means there are frames on the stack
174
    // without precise pointer information.
175
    asyncSafePoint bool
176

177
    paniconfault bool // panic (instead of crash) on unexpected fault address
178
    gcscandone   bool // g has scanned stack; protected by _Gscan bit in status
179
    throwsplit   bool // must not split stack
180
    // activeStackChans indicates that there are unlocked channels
181
    // pointing into this goroutine's stack. If true, stack
182
    // copying needs to acquire channel locks to protect these
183
    // areas of the stack.
184
    activeStackChans bool
185
    // parkingOnChan indicates that the goroutine is about to
186
    // park on a chansend or chanrecv. Used to signal an unsafe point
187
    // for stack shrinking.
188
    parkingOnChan atomic.Bool
189
    // inMarkAssist indicates whether the goroutine is in mark assist.
190
    // Used by the execution tracer.
191
    inMarkAssist bool
192
    coroexit     bool // argument to coroswitch_m
193

194
    raceignore    int8  // ignore race detection events
195
    nocgocallback bool  // whether disable callback from C
196
    tracking      bool  // whether we're tracking this G for sched latency statistics
197
    trackingSeq   uint8 // used to decide whether to track this G
198
    trackingStamp int64 // timestamp of when the G last started being tracked
199
    runnableTime  int64 // the amount of time spent runnable, cleared when running, only used when tracking
200
    lockedm       muintptr
201
    fipsIndicator uint8
202
    sig           uint32
203
    writebuf      []byte
204
    sigcode0      uintptr
205
    sigcode1      uintptr
206
    sigpc         uintptr
207
    parentGoid    uint64          // goid of goroutine that created this goroutine
208
    gopc          uintptr         // pc of go statement that created this goroutine
209
    ancestors     *[]ancestorInfo // ancestor information goroutine(s) that created this goroutine (only used if debug.tracebackancestors)
210
    startpc       uintptr         // pc of goroutine function
211
    racectx       uintptr
212
    waiting       *sudog         // sudog structures this g is waiting on (that have a valid elem ptr); in lock order
213
    cgoCtxt       []uintptr      // cgo traceback context
214
    labels        unsafe.Pointer // profiler labels
215
    timer         *timer         // cached timer for time.Sleep
216
    sleepWhen     int64          // when to sleep until
217
    selectDone    atomic.Uint32  // are we participating in a select and did someone win the race?
218

219
    // goroutineProfiled indicates the status of this goroutine's stack for the
220
    // current in-progress goroutine profile
221
    goroutineProfiled goroutineProfileStateHolder
222

223
    coroarg   *coro // argument during coroutine transfers
224
    syncGroup *synctestGroup
225

226
    // Per-G tracer state.
227
    trace gTraceState
228

229
    // Per-G GC state
230

231
    // gcAssistBytes is this G's GC assist credit in terms of
232
    // bytes allocated. If this is positive, then the G has credit
233
    // to allocate gcAssistBytes bytes without assisting. If this
234
    // is negative, then the G must correct this by performing
235
    // scan work. We track this in bytes to make it fast to update
236
    // and check for debt in the malloc hot path. The assist ratio
237
    // determines how this corresponds to scan work debt.
238
    gcAssistBytes int64
239
}