Go g struct


### Goroutines Itself
```typetype 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	_panic         *_panic // innermost panic - offset known to liblink	_defer         *_defer // innermost defer	m              *m      // current m; offset known to arm liblink	sched          gobuf	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	goid           int64	waitsince      int64  // approx time when the g become blocked	waitreason     string // if status==Gwaiting	schedlink      guintptr	preempt        bool     // preemption signal, duplicates stackguard0 = stackpreempt	paniconfault   bool     // panic (instead of crash) on unexpected fault address	preemptscan    bool     // preempted g does scan for gc	gcscandone     bool     // g has scanned stack; protected by _Gscan bit in status	gcscanvalid    bool     // false at start of gc cycle, true if G has not run since last scan; TODO: remove?	throwsplit     bool     // must not split stack	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        *m	sig            uint32	writebuf       []byte	sigcode0       uintptr	sigcode1       uintptr	sigpc          uintptr	gopc           uintptr // pc of go statement that created this goroutine	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?	// 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}```