package runtime
// 源码位置：src/runtime/runtime2.go
// 仅仅列出此次需要的字段以及代码，其他省略

var (
    sched  schedt // 用于存储go运行时调度器的全局信息
)

type schedt struct {
    // accessed atomically. keep at top to ensure alignment on 32-bit systems. 
    // 存储全局的已经分配出去的用于标识goroutine id的数值 
    // 思考：下面字段为什么是 uint64 
    goidgen  uint64
}

// GMP模型中的G
type g struct {
    goid int64   // 每个goroutine的id标识，这里的类型是 int64
}

// GMP模型中的M
type m struct {
    g0  *g     // goroutine with scheduling stack
}

// GMP模型中的P
// 在某个goroutine中调用`go`关键字生成新的goroutine时，都会优先选择把新生成的goroutine存放到当前P的本地队列中
// 当前P不仅
type p struct { 
    // Cache of goroutine ids, amortizes accesses to runtime·sched.goidgen. 
    // 思考：下面2个字段为什么是 uint64
    goidcache    uint64 // 已经使用的数值
    goidcacheend uint64 // 当前批量申请的id的最大值。与goidcache相等时，则表示耗尽了，需要重新申请 
	
	
    // Queue of runnable goroutines. Accessed without lock.
    runqhead uint32
    runqtail uint32
    runq     [256]guintptr 
    // runnext, if non-nil, is a runnable G that was ready'd by
    // the current G and should be run next instead of what's in
    // runq if there's time remaining in the running G's time
    // slice. It will inherit the time left in the current time
    // slice. If a set of goroutines is locked in a
    // communicate-and-wait pattern, this schedules that set as a
    // unit and eliminates the (potentially large) scheduling
    // latency that otherwise arises from adding the ready'd
    // goroutines to the end of the run queue.
    runnext guintptr 
	
    // Available G's (status == Gdead)
    gFree struct {
        gList
        n int32
    }
}

package main

import "time"

func main() {
	go func() {}()

	time.Sleep(1 * time.Second)
}

main.main.func1 STEXT nosplit size=1 args=0x0 locals=0x0 funcid=0x0 align=0x0
        0x0000 00000 (/Users/ivanli/code/demo/main.go:6)        TEXT    main.main.func1(SB), NOSPLIT|ABIInternal, $0-0
        0x0000 00000 (/Users/ivanli/code/demo/main.go:6)        FUNCDATA        $0, gclocals·g2BeySu+wFnoycgXfElmcg==(SB)
        0x0000 00000 (/Users/ivanli/code/demo/main.go:6)        FUNCDATA        $1, gclocals·g2BeySu+wFnoycgXfElmcg==(SB)
        0x0000 00000 (/Users/ivanli/code/demo/main.go:6)        RET
        0x0000 c3 
        
main.main STEXT size=66 args=0x0 locals=0x10 funcid=0x0 align=0x0
        ...
        0x0014 00020 (/Users/ivanli/code/demo/main.go:6)        LEAQ    main.main.func1·f(SB), AX
        0x0020 00032 (/Users/ivanli/code/demo/main.go:6)        CALL    runtime.newproc(SB)
        ...

package runtime

// 源码位置：src/runtime/proc.go
// 仅仅列出此次需要的字段以及代码，其他省略

const (
    // Number of goroutine ids to grab from sched.goidgen to local per-P cache at once.
    // 16 seems to provide enough amortization, but other than that it's mostly arbitrary number.
    _GoidCacheBatch = 16
)

func newproc(siz int32, fn *funcval) {
    argp := add(unsafe.Pointer(&fn), sys.PtrSize)
    gp := getg()
    pc := getcallerpc()

    // systemstack 的声明代码位置：src/runtime/stubs.go
    //
    // systemstack runs fn on a system stack.
    // If systemstack is called from the per-OS-thread (g0) stack, or
    // if systemstack is called from the signal handling (gsignal) stack,
    // systemstack calls fn directly and returns.
    // Otherwise, systemstack is being called from the limited stack
    // of an ordinary goroutine. In this case, systemstack switches
    // to the per-OS-thread stack, calls fn, and switches back.
    // It is common to use a func literal as the argument, in order
    // to share inputs and outputs with the code around the call
    // to system stack:
    //
    //	... set up y ...
    //	systemstack(func() {
    //		x = bigcall(y)
    //	})
    //	... use x ...
    //
    //go:noescape
    //func systemstack(fn func())
  
    // systemstack() 在系统栈执行 newproc1() 
    systemstack(func() {
        newproc1(fn, (*uint8)(argp), siz, gp, pc)
    })
}

// 具体的生成逻辑在这里
func newproc1(fn *funcval, argp *uint8, narg int32, callergp *g, callerpc uintptr) {
  _g_ := getg() 
  // 获取当前G所绑定的P
  _p_ := _g_.m.p.ptr()
  // 通过P生成一个新的G
  newg := gfget(_p_)

  // ...... omit other code
  
  // P 中存储着一段在 sched.goidgen 申请的用于分配给goroutine的id数值域
  // 每次批量申请 _GoidCacheBatch 个id
  // 如果已经耗尽，则重新申请一批
  if _p_.goidcache == _p_.goidcacheend {
        // Sched.goidgen is the last allocated id,
        // this batch must be [sched.goidgen+1, sched.goidgen+GoidCacheBatch].
        // At startup sched.goidgen=0, so main goroutine receives goid=1.
        //
        // 通过原子操作，在 sched.goidgen 中批量获取一段新的数值域，赋值给当前P 
        _p_.goidcache = atomic.Xadd64(&sched.goidgen, _GoidCacheBatch)
        // _p_.goidcache = _p_.goidcache - (_GoidCacheBatch - 1)
        _p_.goidcache -= _GoidCacheBatch - 1
        _p_.goidcacheend = _p_.goidcache + _GoidCacheBatch
		
        // 这一行为添加的用于调试的代码，非官方源码
        print("\n", "_p_.id:", _p_.id," goidcache:",_p_.goidcache, " goidcacheend:", _p_.goidcacheend, "\n")
    }

    // 新生成的goroutine的goid值，这里发生了类型转换
    newg.goid = int64(_p_.goidcache)

    // 这一行为添加的用于调试的代码，非官方源码
    print("_p_.id:", _p_.id, " newg.goid:", newg.goid, "\n")
    _p_.goidcache++
	
    // ...... omit other code
}

package main

import "fmt"

func main() {
	fmt.Println("\nuser go code main")
}