Scheduler Source — Find the Bug¶

// GOMAXPROCS=1, runtime built with go1.13.
package main

import (
    "fmt"
    "runtime"
)

func main() {
    runtime.GOMAXPROCS(1)
    done := make(chan struct{})
    go func() {
        fmt.Println("worker started")
        close(done)
    }()
    for i := 0; ; i++ {
        if i == -1 {       // BUG: no function call inside the loop body
            break
        }
    }
    <-done
}

func worker(jobs <-chan int, results chan<- int) {
    for j := range jobs {
        runtime.Gosched()               // BUG: yields before doing anything
        result := heavyCompute(j)
        runtime.Gosched()               // BUG: yields after every job
        results <- result
        runtime.Gosched()               // BUG: yields after the send
    }
}

func runOnOpenGLThread() {
    runtime.LockOSThread()            // BUG: no matching UnlockOSThread
    initOpenGL()
    for ev := range events {
        renderFrame(ev)
    }
    // function returns here when events closes
}

func main() {
    go runOnOpenGLThread()
    // ... rest of program continues using normal goroutines
}

func main() {
    runtime.GOMAXPROCS(1)
    var counter int
    var wg sync.WaitGroup
    for i := 0; i < 1000; i++ {
        wg.Add(1)
        go func() {
            counter++          // BUG: still a race, race detector flags it
            wg.Done()
        }()
    }
    wg.Wait()
    fmt.Println(counter)        // also not always 1000
}

func main() {
    done := make(chan struct{})

    // "Watchdog" — wake periodically to print stats.
    go func() {
        for {
            // BUG: busy spin, no sleep, no select, no channel op
            if statsReady() {
                printStats()
            }
        }
    }()

    runApp(done)
    <-done
}

func main() {
    runtime.GOMAXPROCS(runtime.NumCPU())   // BUG: ignores cgroup CPU quota
    // ... heavy concurrent work
}

// Container started with: docker run --cpus=2 myapp
// Host has 32 cores, NumCPU() returns 32.

var mu sync.Mutex

func transfer(from, to *Account, amt int) {
    from.mu.Lock()
    to.mu.Lock()                       // BUG: lock-order inversion possible
    from.balance -= amt
    to.balance += amt
    to.mu.Unlock()
    from.mu.Unlock()
}

// Symptom: occasional deadlock. "Fix" applied:
func transfer2(from, to *Account, amt int) {
    for !from.mu.TryLock() { runtime.Gosched() }   // BUG: masks lock order
    for !to.mu.TryLock()   { runtime.Gosched() }
    // ... etc
}

/*
#include <math.h>
*/
import "C"

func hotLoop(xs []float64) []float64 {
    out := make([]float64, len(xs))
    for i, x := range xs {
        out[i] = float64(C.sqrt(C.double(x)))   // BUG: cgo per iteration
    }
    return out
}

func processFiles(paths []string) {
    sem := make(chan struct{}, runtime.GOMAXPROCS(0))
    var wg sync.WaitGroup
    for _, p := range paths {
        wg.Add(1)
        sem <- struct{}{}
        go func(p string) {
            defer wg.Done()
            defer func() { <-sem }()
            data, _ := os.ReadFile(p)            // BUG: blocking file I/O
            process(data)
        }(p)
    }
    wg.Wait()
}

func ingest(stream <-chan Event) {
    for ev := range stream {
        go func(ev Event) {                  // BUG: no bound
            heavy(ev)                         // takes ~50ms
        }(ev)
    }
}
// stream produces 100k events per second; heavy() takes 50ms.
// goroutines accumulate at ~95k/sec until OOM.

func consumer(ch <-chan Job) {
    for {
        select {
        case j := <-ch:
            process(j)
        case <-time.After(time.Second):    // BUG: new timer every iteration
            log.Println("idle")
        }
    }
}

type Producer struct{ out chan<- Item }

func (p *Producer) Send(items []Item) {
    for _, it := range items {
        go func(it Item) {                  // BUG: one G per item just to send
            p.out <- it
        }(it)
    }
}

// caller pushes 1M items. 1M goroutines spawn; channel buffer is 100.
// 999,900 goroutines park on chansend.

func worker(ctx context.Context, ch <-chan Job) {
    for {
        select {
        case <-ctx.Done():
            return
        case j := <-ch:
            process(j)
        default:                              // BUG: makes select non-blocking
            // nothing
        }
    }
}

func process(items []Item) error {
    var wg sync.WaitGroup
    errs := make(chan error, len(items))
    for _, it := range items {
        wg.Add(1)
        go func(it Item) {
            if err := step1(it); err != nil {
                errs <- err
                return                       // BUG: forgot wg.Done() on this path
            }
            if err := step2(it); err != nil {
                errs <- err
                wg.Done()
                return
            }
            wg.Done()
        }(it)
    }
    wg.Wait()                                // hangs forever if any step1 fails
    close(errs)
    // ...
}

// Wrapping a thread-local-state C library.
func renderFrame(ev Event) error {
    runtime.LockOSThread()
    if err := C.bindContext(); err != 0 {
        runtime.UnlockOSThread()             // BUG: unlocked while still on the thread
        return fmt.Errorf("bind: %d", err)
    }
    runtime.UnlockOSThread()                 // BUG: unlocked, but cgo state is still on this thread
    return drawFrame(ev)                     // may now run on a different M
}

func worker(id int) {
    defer fmt.Printf("worker %d done\n", id)
    if id < 0 {
        runtime.Goexit()                     // BUG: doesn't terminate main
    }
    process(id)
}

func main() {
    worker(-1)                               // calls Goexit from the main goroutine
    fmt.Println("after worker")              // never runs
    // program hangs in "no goroutines" state.
}

var ready = make(chan struct{})

func init() {
    go func() {
        <-ready                              // BUG: nothing sends to ready
        fmt.Println("background ready")
    }()
}

func main() {
    // ... main does normal work, never closes ready.
    fmt.Println("main done")
}

func main() {
    sigs := make(chan os.Signal, 1)
    signal.Notify(sigs, syscall.SIGUSR1)
    go func() {
        for range sigs {
            // BUG: blocking DB call from inside what is morally a signal handler
            db.Exec("INSERT INTO audit VALUES (...)")
        }
    }()
    runApp()
}