// Goroutine benchmark: measures scheduling and channel throughput
// of V's goroutine runtime (translated from Go's GMP scheduler).
//
// Compile: v -enable-globals -cc gcc -gc none -prod run goroutine_benchmark.v
// For comparison, see goroutine_benchmark.go.
//
// Note: Under the v1 compiler, the goroutines module uses pthreads-based
// sync.Mutex which has limitations with ucontext-based context switching.
// The v2 compiler will use a native spinlock, enabling higher scale.
module main

import goroutines
import sync
import time

__global bench_sem = sync.Semaphore{}
__global bench_n = int(0)
__global bench_chan1 = &goroutines.Chan(unsafe { nil })
__global bench_chan2 = &goroutines.Chan(unsafe { nil })
__global bench_msgs_per = int(0)

// --- fan-out/fan-in ---

fn fan_worker(arg voidptr) {
	c := unsafe { &goroutines.Chan(arg) }
	mut val := 1
	goroutines.chan_send(c, voidptr(&val), true)
}

fn fan_collector(arg voidptr) {
	c := unsafe { &goroutines.Chan(arg) }
	mut recv_val := 0
	for _ in 0 .. bench_n {
		goroutines.chan_recv(c, voidptr(&recv_val), true)
	}
	bench_sem.post()
}

fn bench_fan_out_fan_in(n int) {
	bench_n = n
	c := goroutines.chan_make(int(sizeof(int)), 0)

	sw := time.new_stopwatch()

	goroutines.goroutine_create(voidptr(&fan_collector), voidptr(c), 0)
	for _ in 0 .. n {
		goroutines.goroutine_create(voidptr(&fan_worker), voidptr(c), 0)
	}

	bench_sem.wait()

	elapsed := sw.elapsed()
	us := elapsed.microseconds()
	ns_per := elapsed.nanoseconds() / n
	C.printf(c'fan-out/fan-in  %d goroutines: %lld us  (%lld ns/goroutine)\n', n, us, ns_per)
}

// --- ping-pong ---

fn ping_side(arg voidptr) {
	mut val := 0
	for _ in 0 .. bench_n {
		goroutines.chan_send(bench_chan1, voidptr(&val), true)
		goroutines.chan_recv(bench_chan2, voidptr(&val), true)
	}
	bench_sem.post()
}

fn pong_side(arg voidptr) {
	mut val := 0
	for _ in 0 .. bench_n {
		goroutines.chan_recv(bench_chan1, voidptr(&val), true)
		val++
		goroutines.chan_send(bench_chan2, voidptr(&val), true)
	}
}

fn bench_ping_pong(n int) {
	bench_n = n
	bench_chan1 = goroutines.chan_make(int(sizeof(int)), 1)
	bench_chan2 = goroutines.chan_make(int(sizeof(int)), 1)

	sw := time.new_stopwatch()

	goroutines.goroutine_create(voidptr(&pong_side), unsafe { nil }, 0)
	goroutines.goroutine_create(voidptr(&ping_side), unsafe { nil }, 0)

	bench_sem.wait()

	elapsed := sw.elapsed()
	us := elapsed.microseconds()
	ns_per := elapsed.nanoseconds() / n
	C.printf(c'ping-pong       %d round-trips: %lld us  (%lld ns/round-trip)\n', n, us, ns_per)
}

// --- contended channel ---

fn producer(arg voidptr) {
	c := unsafe { &goroutines.Chan(arg) }
	mut val := 0
	for _ in 0 .. bench_msgs_per {
		val++
		goroutines.chan_send(c, voidptr(&val), true)
	}
}

fn consumer_fn(arg voidptr) {
	c := unsafe { &goroutines.Chan(arg) }
	mut recv_val := 0
	for _ in 0 .. bench_n {
		goroutines.chan_recv(c, voidptr(&recv_val), true)
	}
	bench_sem.post()
}

fn bench_contended_channel(num_producers int, msgs_per_producer int) {
	total := num_producers * msgs_per_producer
	bench_n = total
	bench_msgs_per = msgs_per_producer
	c := goroutines.chan_make(int(sizeof(int)), 64)

	sw := time.new_stopwatch()

	goroutines.goroutine_create(voidptr(&consumer_fn), voidptr(c), 0)
	for _ in 0 .. num_producers {
		goroutines.goroutine_create(voidptr(&producer), voidptr(c), 0)
	}

	bench_sem.wait()

	elapsed := sw.elapsed()
	us := elapsed.microseconds()
	ns_per := elapsed.nanoseconds() / total
	C.printf(c'contended chan  %d producers x %d msgs: %lld us  (%lld ns/msg)\n', num_producers,
		msgs_per_producer, us, ns_per)
}

fn main() {
	C.printf(c'=== V Goroutine Benchmark ===\n\n')

	bench_fan_out_fan_in(10)
	bench_fan_out_fan_in(50)
	bench_fan_out_fan_in(100)
	bench_fan_out_fan_in(500)

	C.printf(c'\n')
	bench_ping_pong(1000)
	bench_ping_pong(10000)
	bench_ping_pong(100000)

	C.printf(c'\n')
	bench_contended_channel(4, 1000)
	bench_contended_channel(10, 1000)

	C.printf(c'\n')
	goroutines.shutdown()
}