Go 01 - Goroutine

type g struct {
    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
    param          unsafe.Pointer   // passed parameter on wakeup
    atomicstatus   uint32
    goid           int64
    schedlink      guintptr
    waitsince      int64            // approx time when the g become blocked
    waitreason     waitReason       // if status==Gwaiting
    preempt        bool             // preemption signal, duplicates stackguard0 = stackpreempt
    lockedm        muintptr
    writebuf       []byte
    sigcode0       uintptr
    sigcode1       uintptr
    sigpc          uintptr
    gopc           uintptr          // pc of go statement that created this goroutine
    startpc        uintptr          // pc of goroutine function
    waiting        *sudog           // sudog structures this g is waiting on (that have a valid elem ptr); in lock order
}

type m struct {
    g0      *g     // goroutine with scheduling stack
    curg    *g     // current running goroutine

    ...
}

type p struct {
    id          int32
    status      uint32     // one of pidle/prunning/...
    link        puintptr
    schedtick   uint32     // incremented on every scheduler call
    syscalltick uint32     // incremented on every system call
    sysmontick  sysmontick // last tick observed by sysmon
    m           muintptr   // back-link to associated m (nil if idle)
    mcache      *mcache

    runqhead uint32
    runqtail uint32
    runq     [256]guintptr
    runnext guintptr

    sudogcache []*sudog
    sudogbuf   [128]*sudog

    ...v
}

// memory usage
package main

import (
    "flag"
    "fmt"
    "os"
    "runtime"
    "time"
)

var n = flag.Int("n", 1e5, "Number of goroutines to create")

var ch = make(chan byte)
var counter = 0

func f() {
    counter++
    <-ch // Block this goroutine
}

func main() {
    flag.Parse()
    if *n <= 0 {
        fmt.Fprintf(os.Stderr, "invalid number of goroutines")
        os.Exit(1)
    }

    // Limit the number of spare OS threads to just 1
    runtime.GOMAXPROCS(1)

    // Make a copy of 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()

    // Make a copy of 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)
}

// time consume
package main

import (
    "fmt"
    "time"
)

func runCallback(in, out chan int64) {
    for n, ok := <-in; ok; n, ok = <-in {
        out <- n
    }
}

func runTest(round int, coroutineNum, switchTimes int64) {
    fmt.Printf("##### Round: %v\n", round)

    start := time.Now()
    channelsIn, channelsOut := make([]chan int64, coroutineNum), make([]chan int64, coroutineNum)
    for i := int64(0); i < coroutineNum; i++ {
        channelsIn[i] = make(chan int64, 1)
        channelsOut[i] = make(chan int64, 1)
    }
    end := time.Now()
    fmt.Printf("Create %v goroutines and channels cost %v ns, avg %v ns\n", coroutineNum, end.Sub(start).Nanoseconds(), end.Sub(start).Nanoseconds()/coroutineNum)

    start = time.Now()
    for i := int64(0); i < coroutineNum; i++ {
        go runCallback(channelsIn[i], channelsOut[i])
    }
    end = time.Now()
    fmt.Printf("Start %v goroutines and channels cost %v ns, avg %v ns\n", coroutineNum, end.Sub(start).Nanoseconds(), end.Sub(start).Nanoseconds()/coroutineNum)

    var sum int64 = 0
    start = time.Now()
    for i := int64(0); i < switchTimes; i++ {
        for j := int64(0); j < coroutineNum; j++ {
            channelsIn[j] <- 1
            sum += <-channelsOut[j]
        }
    }
    end = time.Now()
    fmt.Printf("Switch %v goroutines for %v times cost %v ns, avg %v ns\n", coroutineNum, sum, end.Sub(start).Nanoseconds(), end.Sub(start).Nanoseconds()/sum)

    start = time.Now()
    for i := int64(0); i < coroutineNum; i++ {
        close(channelsIn[i])
        close(channelsOut[i])
    }
    end = time.Now()
    fmt.Printf("Close %v goroutines cost %v ns, avg %v ns\n", coroutineNum, end.Sub(start).Nanoseconds(), end.Sub(start).Nanoseconds()/coroutineNum)
}

func main() {
    // runTest(1, 1000, 1000)
    // runTest(2, 5000, 200)
    // runTest(3, 10000, 100)
    // runTest(4, 50000, 50)
    // runTest(5, 100000, 10)
    runTest(6, 500000, 5)
}