// V spawn (OS threads) benchmark – for comparison with Go goroutines.
//
// Uses V's built-in `spawn` (OS threads) and `chan` (V1 channels).
// This measures V's current threading primitives vs Go's goroutines.
//
// Run: v -prod run spawn_benchmark.v
module main

import time

// ---------------------------------------------------------------------------
// Benchmark 1 – fan-out / fan-in
// ---------------------------------------------------------------------------

fn fan_worker(c chan int) {
    c <- 1
}

fn bench_fan_out_fan_in(n int) {
    c := chan int{cap: n}

    sw := time.new_stopwatch()

    for _ in 0 .. n {
        spawn fan_worker(c)
    }

    for _ in 0 .. n {
        _ = <-c
    }

    elapsed := sw.elapsed()
    us := elapsed.microseconds()
    ns_per := elapsed.nanoseconds() / n
    println('fan-out/fan-in  ${n} threads: ${us} us  (${ns_per} ns/thread)')
}

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

fn pinger(c1 chan int, c2 chan int, n int) {
    mut val := 0
    for _ in 0 .. n {
        val = <-c1
        val++
        c2 <- val
    }
}

fn bench_ping_pong(n int) {
    c1 := chan int{cap: 1}
    c2 := chan int{cap: 1}

    spawn pinger(c1, c2, n)

    sw := time.new_stopwatch()

    mut val := 0
    for _ in 0 .. n {
        c1 <- val
        val = <-c2
    }

    elapsed := sw.elapsed()
    us := elapsed.microseconds()
    ns_per := elapsed.nanoseconds() / n
    println('ping-pong       ${n} round-trips: ${us} us  (${ns_per} ns/round-trip)')
}

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

fn producer(c chan int, count int) {
    mut val := 0
    for _ in 0 .. count {
        val++
        c <- val
    }
}

fn bench_contended_channel(num_producers int, msgs_per_producer int) {
    total := num_producers * msgs_per_producer
    c := chan int{cap: 64}

    sw := time.new_stopwatch()

    for _ in 0 .. num_producers {
        spawn producer(c, msgs_per_producer)
    }

    for _ in 0 .. total {
        _ = <-c
    }

    elapsed := sw.elapsed()
    us := elapsed.microseconds()
    ns_per := elapsed.nanoseconds() / total
    println('contended chan  ${num_producers} producers x ${msgs_per_producer} msgs: ${us} us  (${ns_per} ns/msg)')
}

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

fn main() {
    println('=== V spawn (OS threads) Benchmark ===')
    println('')

    bench_fan_out_fan_in(1000)
    bench_fan_out_fan_in(10000)
    // Skip 100k - too many OS threads

    println('')
    bench_ping_pong(10000)
    bench_ping_pong(100000)

    println('')
    bench_contended_channel(10, 1000)
    bench_contended_channel(100, 1000)

    println('')
}