History of Go — Under the Hood¶

// Conceptual model of tri-color marking
// From: runtime/mgc.go (conceptual)

// White: not yet visited (potentially garbage)
// Grey:  visited but children not yet scanned
// Black: visited and all children scanned

// Invariant (tri-color invariant):
// No black object points to a white object
// This is maintained using a WRITE BARRIER

// Conceptual hybrid write barrier (runtime/mbarrier.go)
//
// writePointer(slot, ptr):
//   shade(*slot)  // shade the old value (Yuasa-style deletion barrier)
//   if current goroutine stack is grey:
//       shade(ptr) // shade the new value (Dijkstra-style insertion barrier)
//   *slot = ptr
//
// This eliminated stack re-scanning, reducing STW to ~100us

// runtime/mgc.go conceptual: GOMEMLIMIT integration
//
// Before GOMEMLIMIT:
//   GC triggers when heap reaches GOGC% above previous live heap
//   Problem: if GOGC=100 and live heap is 1GB, GC allows 2GB peak
//
// With GOMEMLIMIT:
//   GC adjusts effective GOGC to stay under the memory limit
//   If heap approaches limit, GC runs more aggressively
//   This prevents OOM without requiring manual GOGC tuning

// From: runtime/runtime2.go (simplified)

// G - goroutine
// Contains: stack, instruction pointer, status, channel wait info
// type g struct {
//     stack       stack    // goroutine stack
//     sched       gobuf    // scheduling state (SP, PC, etc.)
//     atomicstatus uint32  // goroutine status
// }

// M - OS thread (machine)
// Contains: current G, signal handling, thread-local storage
// type m struct {
//     g0      *g     // goroutine for scheduling
//     curg    *g     // current running goroutine
//     p       *p     // attached P (nil if not running Go code)
// }

// P - logical processor
// Contains: local run queue, mcache, timer heap
// type p struct {
//     runqhead uint32
//     runqtail uint32
//     runq     [256]guintptr  // local run queue (lock-free)
// }

package main

import "fmt"

func add(a, b int) int {
    return a + b
}

func main() {
    result := add(3, 5)
    fmt.Println(result)
}

// This goroutine could NOT be preempted before Go 1.14:
func tightLoop() {
    for {
        // No function calls — no preemption point!
        // This would starve other goroutines
    }
}

// Annotated excerpt from runtime/mgc.go
// This shows how GC is triggered

// gcStart transitions from _GCoff to _GCmark (if not already
// transitioning) and starts GC workers.
//
// The GC starts in mark phase with mark workers running.
// func gcStart(trigger gcTrigger) {
//     ...
//     // In concurrent mode, start mark workers
//     // This is where the tri-color marking begins
//     gcController.startCycle(now, int64(gogc), memoryLimit)
//     ...
// }

// gcController maintains the GC's internal state
// type gcControllerState struct {
//     gcPercent    atomic.Int32    // GOGC value (default 100)
//     memoryLimit  atomic.Int64    // GOMEMLIMIT value
//     heapGoal     atomic.Uint64   // target heap size for next cycle
//     ...
// }

// Annotated excerpt from runtime/proc.go
// This is the core scheduling loop

// schedule() finds a runnable goroutine and executes it.
// func schedule() {
//     mp := getg().m  // current M (OS thread)
//
//     // Check local run queue first (lock-free, fast path)
//     if gp, inheritTime := runqget(mp.p.ptr()); gp != nil {
//         execute(gp, inheritTime)
//     }
//
//     // Check global run queue (locked, slower)
//     if gp := globrunqget(mp.p.ptr(), 0); gp != nil {
//         execute(gp, false)
//     }
//
//     // Try to steal from other P's (work stealing)
//     if gp, inheritTime, _ := stealWork(now); gp != nil {
//         execute(gp, inheritTime)
//     }
//
//     // Nothing to run — park the M
//     stopm()
// }

package main

func add(a, b int) int {
    return a + b
}

func main() {
    _ = add(3, 5)
}

package main

import (
    "testing"
)

// This benchmark shows how the same code gets faster
// with newer Go versions due to compiler improvements

func BenchmarkStringConcat(b *testing.B) {
    for i := 0; i < b.N; i++ {
        s := ""
        for j := 0; j < 100; j++ {
            s += "x"
        }
        _ = s
    }
}

// Results across versions (approximate):
// Go 1.15: 12000 ns/op    5600 B/op   100 allocs/op
// Go 1.17: 10200 ns/op    5600 B/op   100 allocs/op  (register ABI)
// Go 1.20:  9800 ns/op    5600 B/op   100 allocs/op  (PGO available)
// Go 1.22:  9500 ns/op    5600 B/op   100 allocs/op  (better inlining)

package main

import (
    "fmt"
    "runtime"
    "runtime/metrics"
)

func main() {
    // Go 1.16+: runtime/metrics API — does NOT cause STW (unlike ReadMemStats)
    descs := metrics.All()
    fmt.Printf("Go %s has %d runtime metrics\n", runtime.Version(), len(descs))

    // Key metrics for understanding GC and scheduler behavior
    samples := []metrics.Sample{
        {Name: "/memory/classes/heap/objects:bytes"},
        {Name: "/memory/classes/total:bytes"},
        {Name: "/gc/cycles/total:gc-cycles"},
        {Name: "/gc/heap/goal:bytes"},
        {Name: "/sched/goroutines:goroutines"},
        {Name: "/sched/latencies:seconds"},
    }
    metrics.Read(samples)

    for _, s := range samples {
        switch s.Value.Kind() {
        case metrics.KindUint64:
            fmt.Printf("%s = %d\n", s.Name, s.Value.Uint64())
        case metrics.KindFloat64:
            fmt.Printf("%s = %.6f\n", s.Name, s.Value.Float64())
        case metrics.KindFloat64Histogram:
            h := s.Value.Float64Histogram()
            fmt.Printf("%s = histogram (buckets: %d)\n", s.Name, len(h.Buckets))
        }
    }
}

package main

import "fmt"

func recursive(n int) int {
    if n <= 0 {
        return 0
    }
    // Each call frame needs stack space
    // Go starts with 2KB stack and grows by 2x
    // The runtime copies the entire stack to a new location
    // All pointers into the stack are updated
    var buf [256]byte
    buf[0] = byte(n)
    return recursive(n-1) + int(buf[0])
}

func main() {
    // This causes many stack growths: 2KB → 4KB → 8KB → ... → ~1MB
    result := recursive(10000)
    fmt.Println(result)
}

package main

import (
    "fmt"
    "runtime"
    "sync"
    "unsafe"
)

func main() {
    // Since Go 1.14, goroutines can be preempted at almost any point
    // EXCEPT during unsafe.Pointer operations
    //
    // The runtime marks certain instruction sequences as "unsafe points"
    // where preemption is disallowed to prevent partially-visible writes

    var mu sync.Mutex
    var data [100]int

    var wg sync.WaitGroup
    wg.Add(1)
    go func() {
        defer wg.Done()
        mu.Lock()
        defer mu.Unlock()
        // This is safe — the runtime will not preempt in the middle
        // of a synchronized block in a way that violates atomicity
        for i := range data {
            data[i] = i
        }
    }()

    wg.Wait()
    fmt.Printf("Data size: %d, unsafe.Sizeof(int): %d\n",
        len(data), unsafe.Sizeof(data[0]))
    _ = runtime.Version()
}