// Goroutine benchmark in Go – equivalent to goroutine_benchmark.v.
//
// Tests:
// 1. Goroutine creation + completion (fan-out/fan-in via unbuffered channel)
// 2. Channel ping-pong between two goroutines
// 3. Many goroutines contending on a single channel
//
// Run: go run goroutine_benchmark.go
package main

import (
    "fmt"
    "time"
)

// ---------------------------------------------------------------------------
// Benchmark 1 – fan-out / fan-in (unbuffered channel)
// ---------------------------------------------------------------------------

func benchFanOutFanIn(n int) {
    c := make(chan int) // unbuffered, matching V benchmark

    start := time.Now()

    for i := 0; i < n; i++ {
        go func() {
            c <- 1
        }()
    }

    for i := 0; i < n; i++ {
        <-c
    }

    elapsed := time.Since(start)
    fmt.Printf("fan-out/fan-in  %d goroutines: %d us  (%d ns/goroutine)\n",
        n, elapsed.Microseconds(), elapsed.Nanoseconds()/int64(n))
}

// ---------------------------------------------------------------------------
// Benchmark 2 – channel ping-pong
// ---------------------------------------------------------------------------

func benchPingPong(n int) {
    c1 := make(chan int, 1)
    c2 := make(chan int, 1)

    go func() {
        for i := 0; i < n; i++ {
            val := <-c1
            c2 <- val + 1
        }
    }()

    start := time.Now()

    val := 0
    for i := 0; i < n; i++ {
        c1 <- val
        val = <-c2
    }

    elapsed := time.Since(start)
    fmt.Printf("ping-pong       %d round-trips: %d us  (%d ns/round-trip)\n",
        n, elapsed.Microseconds(), elapsed.Nanoseconds()/int64(n))
}

// ---------------------------------------------------------------------------
// Benchmark 3 – contended channel (many producers, one consumer)
// ---------------------------------------------------------------------------

func benchContendedChannel(numProducers int, msgsPerProducer int) {
    total := numProducers * msgsPerProducer
    c := make(chan int, 64)

    start := time.Now()

    for p := 0; p < numProducers; p++ {
        go func() {
            for i := 0; i < msgsPerProducer; i++ {
                c <- i
            }
        }()
    }

    for i := 0; i < total; i++ {
        <-c
    }

    elapsed := time.Since(start)
    fmt.Printf("contended chan  %d producers x %d msgs: %d us  (%d ns/msg)\n",
        numProducers, msgsPerProducer,
        elapsed.Microseconds(), elapsed.Nanoseconds()/int64(total))
}

// ---------------------------------------------------------------------------
// Main
// ---------------------------------------------------------------------------

func main() {
    fmt.Println("=== Go Goroutine Benchmark ===")
    fmt.Println()

    benchFanOutFanIn(10)
    benchFanOutFanIn(50)
    benchFanOutFanIn(100)
    benchFanOutFanIn(500)

    fmt.Println()
    benchPingPong(1000)
    benchPingPong(10000)
    benchPingPong(100000)

    fmt.Println()
    benchContendedChannel(4, 1000)
    benchContendedChannel(10, 1000)

    fmt.Println()
}