// src/runtime/runtime2.go
// 以下结构体精简了很多字段
type g struct {
	stack       stack   // offset known to runtime/cgo

	m              *m      // current m; offset known to arm liblink
	sched          gobuf
	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
}

go func(){
}

// src/runtime/runtime2.go
type m struct {
	g0      *g     // goroutine with scheduling stack
	
	// Fields not known to debuggers.
	goSigStack    gsignalStack // Go-allocated signal handling stack
	curg          *g       // current running goroutine
	p             puintptr // attached p for executing go code (nil if not executing go code)
	spinning      bool // m is out of work and is actively looking for work
	blocked       bool // m is blocked on a note
	freeWait      uint32 // if == 0, safe to free g0 and delete m (atomic)
	alllink       *m // on allm
	schedlink     muintptr
	createstack   [32]uintptr    // stack that created this thread.
	thread        uintptr // thread handle
	freelink      *m      // on sched.freem
}

// src/runtime/runtime2.go
type p struct {
	lock mutex

	id          int32
	m           muintptr   // back-link to associated m (nil if idle)
	mcache      *mcache

	// 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    *g
}

package main
import "fmt"
import "time"
import "runtime"

func main() {
    var result int
    processors := runtime.GOMAXPROCS(0)  
    for i := 0; i < processors; i++ {
        go func() {
            for { result++ }
        }()
    }
    time.Sleep(time.Second)       //wait for go function to increment the value.
    fmt.Println("result =", result)
}