//Выделяет новую g со стеком, достаточно большим для stacksize байтов.
func malg(stacksize int32) *g {
  newg := new(g)      // <--- все начинается здесь
  if stacksize >= 0 {
    stacksize = round2(_StackSystem + stacksize)
    systemstack(func() {
      newg.stack = stackalloc(uint32(stacksize))
    })
    newg.stackguard0 = newg.stack.lo + _StackGuard
        newg.stackguard1 = ^uintptr(0)
        ...
        ...
    }
    return newg
}

// Создаем новую g, выполняющую fn с narg байтами аргументов, начинающихся с argp. callerpc - это адрес оператора go, который ее создал. Новая g помещается в очередь g, ожидающих запуска.
func newproc1(fn *funcval, argp unsafe.Pointer, narg int32, callergp *g, callerpc uintptr) {
  ...
    acquirem() // отключаем вытеснение менее приоритетных задач, потому что оно может удерживать p в локальном var
  siz := narg
    siz = (siz + 7) &^ 7
  ...
  _p_ := _g_.m.p.ptr()
  newg := gfget(_p_)
  if newg == nil {
    newg = malg(_StackMin) // !!! <- здесь происходит магия
    casgstatus(newg, _Gidle, _Gdead)
    allgadd(newg)
  }
  ...
}

type g struct {
    stack            stack
    stackguard0      uintptr
    stackguard1      uintptr
    _panic           *_panic
    _defer           *_defer
    m                *m
    sched            gobuf
    syscallsp        uintptr
    syscallpc        uintptr
    stktopsp         uintptr
    param            unsafe.Pointer
    atomicstatus     uint32
    stackLock        uint32
    goid             int64
    schedlink        guintptr
    waitsince        int64
    waitreason       waitReason
    preempt          bool
    preemptStop      bool
    preemptShrink    bool
    asyncSafePoint   bool
    paniconfault     bool
    gcscandone       bool
    throwsplit       bool
    activeStackChans bool
    raceignore       int8
    sysblocktraced   bool
    sysexitticks     int64
    traceseq         uint64
    tracelastp       puintptr
    lockedm          muintptr
    sig              uint32
    writebuf         []byte
    sigcode0         uintptr
    sigcode1         uintptr
    sigpc            uintptr
    gopc             uintptr
    ancestors        *[]ancestorInfo
    startpc          uintptr
    racectx          uintptr
    waiting          *sudog
    cgoCtxt          []uintptr
    labels           unsafe.Pointer
    timer            *timer
    selectDone       uint32
    gcAssistBytes    int64
}

type g struct {
  // Параметры стека.
  // stack описывает фактическую память стека: [stack.lo, stack.hi).
  // stackguard0 - указатель стека, сравниваемый по мере роста стека Go.
  // stackguard1 - указатель стека, сравниваемый по мере роста стека C.
...
  stack       stack  // смещение, известное runtime/cgo
  stackguard0 uintptr // смещение, известное liblink
  stackguard1 uintptr // смещение, известное liblink

type stack struct {
  lo uintptr
  hi uintptr
}

package main
func foo(i int) int {
  if i < 1e8 {
    return foo(i + 1)
  }
  return -1
}
func main() {
  foo(0)
}

$ go run exceed-stack.go
runtime: goroutine stack exceeds 1000000000-byte limit
fatal error: stack overflow
runtime stack:
runtime.throw(0x1071ce1, 0xe)
  /usr/local/go/src/runtime/panic.go:774 +0x72
runtime.newstack()
  /usr/local/go/src/runtime/stack.go:1046 +0x6e9
runtime.morestack()
  /usr/local/go/src/runtime/asm_amd64.s:449 +0x8f
goroutine 1 [running]:
main.foo(0xffffdf, 0x0)
...
...

$ ~ go run poc-goroutines-sizing.go
# 10 Тысячь горутин
Number of goroutines: 100000
Per goroutine:
  Memory: 2115.71 bytes
  Time:   1.404500 µs
# 1 Миллион горутин
Number of goroutines: 1000000
Per goroutine:
  Memory: 2655.21 bytes
  Time:   1.518857 µs
# 3 Миллиона горутин
Number of goroutines: 3000000
Per goroutine:
  Memory: 2700.37 bytes
  Time:   1.637003 µs
# 6 Миллионов горутин
Number of goroutines: 6000000
Per goroutine:
  Memory: 2700.29 bytes
  Time:   2.541744 µs
# 9 Миллионов горутин
Number of goroutines: 9000000
Per goroutine:
  Memory: 2700.27 bytes
  Time:   2.857699 µs
# 12 Миллионов горутин
Number of goroutines: 12000000
Per goroutine:
  Memory: 2694.09 bytes
  Time:   3.232870 µs
# 50 Миллионов горутин
Number of goroutines: 50000000
Per goroutine:
  Memory: 2695.37 bytes
  Time:   5.098005 µs

package main
import (
  "flag"
  "fmt"
  "os"
  "runtime"
  "time"
)
var n = flag.Int("n", 3*1e6, "Number of goroutines to create")
var ch = make(chan byte)
var counter = 0
func f() {
  counter++
  <-ch// Блокируем эту горутину
}
func main() {
  flag.Parse()
  if *n <= 0 {
    fmt.Fprintf(os.Stderr, "invalid number of goroutines")
    os.Exit(1)
  }
  // Ограничиваем количество свободных потоков ОС до 1
  runtime.GOMAXPROCS(1)
  // Делаем копию MemStats
  var m0 runtime.MemStats
  runtime.ReadMemStats(&m0)
  t0 := time.Now().UnixNano()
  for i := 0; i < *n; i++ {
    go f()
  }
  runtime.Gosched()
  t1 := time.Now().UnixNano()
  runtime.GC()
  // Делаем копию MemStats
  var m1 runtime.MemStats
  runtime.ReadMemStats(&m1)
  if counter != *n {
    fmt.Fprintf(os.Stderr, "failed to begin execution of all goroutines")
    os.Exit(1)
  }
  fmt.Printf("Number of goroutines: %d\n", *n)
  fmt.Printf("Per goroutine:\n")
  fmt.Printf("  Memory: %.2f bytes\n", float64(m1.Sys-m0.Sys)/float64(*n))
  fmt.Printf("  Time:   %f µs\n", float64(t1-t0)/float64(*n)/1e3)
}