v2: translate Go's goroutine scheduler (GMP model) to V (#26740)

Add a full goroutine runtime module (vlib/goroutines/) translated from
Go's runtime scheduler, implementing the GMP (Goroutine-Machine-Processor)
model with work-stealing, lock-free local run queues, and cooperative
scheduling.

Runtime module:
- goroutines.v: Core data structures (Goroutine, Machine, Processor, Sched)
- scheduler.v: GMP scheduler with work stealing, goroutine_create()
- park.v: gopark/goready for goroutine blocking/unblocking
- chan.v: Channel implementation (send, recv, close, select)
- init.v: Module init creating P's (one per CPU core) and M0
- context_nix.c.v: ucontext-based context switching (Linux/macOS)
- context_windows.c.v: Windows Fiber-based context switching
- atomic_ops.c.v: C atomic operation wrappers

V2 compiler changes:
- ssa/instr.v: Add go_call and spawn_call opcodes
- ssa/builder.v: Handle .key_go and .key_spawn in build_keyword_operator,
  add build_go_or_spawn() helper to extract CallExpr operands
- gen/c/c.v: Emit goroutines__goroutine_create() for go_call,
  pthread_create() for spawn_call, with argument packing structs

The transformer now:
- Detects `KeywordOperator{ op: .key_go }` expressions
- Synthesizes per-function: args struct, trampoline function, and
  dispatch wrapper that calls goroutines__goroutine_create
- Replaces `go foo(a, b)` with a plain call to the dispatch wrapper
- Registers wrapper info in needed_go_wrappers map (thread-safe for
  parallel transform)

Backends see only regular CallExpr nodes after transformation.
SSA builder and cleanc gen_spawn_expr retain fallback .key_go handling.

Benchmark results (V goroutines vs Go goroutines vs V spawn):

  fan-out/fan-in 500g:  V=3017us  Go=657us   spawn=70465us
  ping-pong 100K rt:    V=117ms   Go=41ms    spawn=953ms
  contended 10x1K:      V=549us   Go=824us   spawn=14920us

V goroutines are ~3-5x slower than Go on creation/scheduling (expected
given Go's mature runtime) but dramatically faster than OS threads
(spawn), and competitive on channel throughput.

Author: medvednikov

vlib/goroutines/README.md

@@ -0,0 +1,50 @@
+# goroutines
+
+Go-style goroutine runtime for V, implementing the GMP (Goroutine-Machine-Processor) scheduling model translated from the Go runtime (`src/runtime/proc.go`, `runtime2.go`, `chan.go`).
+
+## Overview
+
+This module provides lightweight goroutines for V's `go` keyword, as opposed to `spawn` which creates OS threads.
+
+### GMP Model
+
+- **G (Goroutine)**: Lightweight unit of execution with its own stack (~8KB default)
+- **M (Machine)**: OS thread that executes goroutines
+- **P (Processor)**: Logical processor with a local run queue (one per CPU core)
+
+### Key Features
+
+- **Work stealing**: Idle processors steal work from busy ones
+- **Local run queues**: Lock-free per-P queues minimize contention
+- **Global run queue**: Overflow and fairness mechanism
+- **Goroutine parking**: Efficient blocking/unblocking for channels
+- **G reuse**: Dead goroutines are recycled to reduce allocation
+
+## Usage
+
+```v
+// `go` launches a goroutine (lightweight, scheduled by GMP)
+go expensive_computation()
+
+// `spawn` launches an OS thread (traditional V behavior)
+spawn blocking_io_task()
+```
+
+## Architecture
+
+Translated from Go's runtime source:
+
+| Go Source | V Module File | Purpose |
+|-----------|---------------|---------|
+| `runtime2.go` | `goroutines.v` | Core data structures (G, M, P, Sched) |
+| `proc.go` | `scheduler.v` | Scheduler loop, work stealing, run queues |
+| `proc.go` | `park.v` | gopark/goready, Sudog, WaitQ |
+| `proc.go` | `init.v` | Initialization (schedinit, procresize) |
+| `chan.go` | `chan.v` | Channel implementation |
+| asm (gogo/gosave) | `context_nix.c.v` | Context switching (ucontext) |
+| asm (gogo/gosave) | `context_windows.c.v` | Context switching (Windows fibers) |
+
+## References
+
+- [Go Scheduler Design Doc](https://golang.org/s/go11sched)
+- [Go Runtime Source](https://github.com/golang/go/tree/master/src/runtime)

vlib/goroutines/atomic_ops.c.v

@@ -0,0 +1,47 @@
+// Copyright (c) 2019-2024 Alexander Medvednikov. All rights reserved.
+// Use of this source code is governed by an MIT license
+// that can be found in the LICENSE file.
+//
+// Atomic operations and C interop for the goroutine scheduler.
+module goroutines
+
+#include <stdlib.h>
+#include <string.h>
+#include "@VMODROOT/vlib/goroutines/goroutines_tls.h"
+
+#flag @VMODROOT/vlib/goroutines/tls.c
+
+// Thread-local storage
+fn C.goroutines_get_current_m() voidptr
+fn C.goroutines_set_current_m(mp voidptr)
+
+// Typed atomic operations (implemented in tls.c)
+fn C.goroutines_atomic_load_u32(ptr &u32) u32
+fn C.goroutines_atomic_store_u32(ptr &u32, val u32)
+fn C.goroutines_atomic_fetch_add_u32(ptr &u32, val u32) u32
+fn C.goroutines_atomic_fetch_add_i32(ptr &i32, val i32) i32
+fn C.goroutines_atomic_fetch_sub_i32(ptr &i32, val i32) i32
+fn C.goroutines_atomic_fetch_add_u64(ptr &u64, val u64) u64
+fn C.goroutines_atomic_cas_u32(ptr &u32, expected &u32, desired u32) bool
+fn C.goroutines_atomic_cas_ptr(ptr voidptr, expected voidptr, desired voidptr) bool
+
+fn C.grt_spinlock_lock(lk &i32)
+fn C.grt_spinlock_unlock(lk &i32)
+
+fn C.memcpy(dest voidptr, src voidptr, n usize) voidptr
+fn C.memset(dest voidptr, ch int, n usize) voidptr
+fn C.rand() int
+
+// SpinLock - ucontext-safe lock (pthreads mutex breaks with swapcontext).
+pub struct SpinLock {
+mut:
+	state i32
+}
+
+pub fn (mut s SpinLock) acquire() {
+	C.grt_spinlock_lock(&s.state)
+}
+
+pub fn (mut s SpinLock) release() {
+	C.grt_spinlock_unlock(&s.state)
+}

vlib/goroutines/chan.v

@@ -0,0 +1,285 @@
+// Copyright (c) 2019-2024 Alexander Medvednikov. All rights reserved.
+// Use of this source code is governed by an MIT license
+// that can be found in the LICENSE file.
+//
+// Channel implementation for goroutines.
+// Translated from Go's runtime/chan.go.
+//
+// Channels provide goroutine-safe communication between goroutines.
+// They support both buffered and unbuffered modes.
+//
+// Key operations translated from Go:
+//   - makechan()  -> chan_make()
+//   - chansend()  -> chan_send()
+//   - chanrecv()  -> chan_recv()
+//   - closechan() -> chan_close()
+module goroutines
+
+// Chan is a goroutine-safe channel for communication between goroutines.
+// Translated from Go's hchan struct in chan.go.
+pub struct Chan {
+pub mut:
+	mu       SpinLock // protects all fields (spinlock is ucontext-safe)
+	qcount   u32        // total data in the queue
+	dataqsiz u32        // size of the circular buffer
+	buf      voidptr    // circular buffer for buffered channels
+	elemsize u16        // size of each element
+	closed   bool       // true if channel is closed
+
+	sendx u32 // send index into circular buffer
+	recvx u32 // receive index into circular buffer
+
+	recvq WaitQ // list of recv waiters
+	sendq WaitQ // list of send waiters
+}
+
+// chan_make creates a new channel.
+// If buf_size > 0, creates a buffered channel.
+// Translated from Go's makechan() in chan.go.
+pub fn chan_make(elem_size int, buf_size int) &Chan {
+	mut c := &Chan{
+		elemsize: u16(elem_size)
+		dataqsiz: u32(buf_size)
+	}
+	if buf_size > 0 {
+		c.buf = unsafe { malloc(elem_size * buf_size) }
+	}
+	return c
+}
+
+// chan_send sends a value on the channel.
+// If block is true, blocks until the send can proceed.
+// Returns true if the value was sent.
+// Translated from Go's chansend() in chan.go.
+pub fn chan_send(c &Chan, ep voidptr, block bool) bool {
+	if c == unsafe { nil } {
+		if !block {
+			return false
+		}
+		// Block forever on nil channel (Go behavior)
+		gopark('chan send (nil chan)')
+		return false // unreachable
+	}
+
+	mut ch := unsafe { c }
+	ch.mu.acquire()
+
+	if ch.closed {
+		ch.mu.release()
+		panic('send on closed channel')
+	}
+
+	// Fast path: try to find a waiting receiver
+	sg := ch.recvq.dequeue()
+	if sg != unsafe { nil } {
+		// Found a waiting receiver - send directly
+		ch.mu.release()
+		send_direct(sg, ep, ch.elemsize)
+		return true
+	}
+
+	// Buffered channel with space available
+	if ch.qcount < ch.dataqsiz {
+		// Put data in buffer
+		dst := chan_buf(ch, ch.sendx)
+		unsafe { C.memcpy(dst, ep, ch.elemsize) }
+		ch.sendx++
+		if ch.sendx == ch.dataqsiz {
+			ch.sendx = 0
+		}
+		ch.qcount++
+		ch.mu.release()
+		return true
+	}
+
+	if !block {
+		ch.mu.release()
+		return false
+	}
+
+	// Block: enqueue ourselves on the send wait queue
+	gp := get_current_g()
+	mut mysg := &Sudog{
+		g:    unsafe { gp }
+		elem: ep
+		c:    voidptr(ch)
+	}
+	ch.sendq.enqueue(mysg)
+	ch.mu.release()
+
+	// Park the goroutine until a receiver wakes us
+	gopark('chan send')
+
+	return true
+}
+
+// chan_recv receives a value from the channel.
+// If block is true, blocks until a value is available.
+// Returns (received, ok). ok is false if channel is closed and empty.
+// Translated from Go's chanrecv() in chan.go.
+pub fn chan_recv(c &Chan, ep voidptr, block bool) (bool, bool) {
+	if c == unsafe { nil } {
+		if !block {
+			return false, false
+		}
+		gopark('chan receive (nil chan)')
+		return false, false // unreachable
+	}
+
+	mut ch := unsafe { c }
+	ch.mu.acquire()
+
+	// Fast path: try to find a waiting sender
+	sg := ch.sendq.dequeue()
+	if sg != unsafe { nil } {
+		ch.mu.release()
+		recv_direct(ch, sg, ep)
+		return true, true
+	}
+
+	// Buffered channel with data available
+	if ch.qcount > 0 {
+		src := chan_buf(ch, ch.recvx)
+		if ep != unsafe { nil } {
+			unsafe { C.memcpy(ep, src, ch.elemsize) }
+		}
+		ch.recvx++
+		if ch.recvx == ch.dataqsiz {
+			ch.recvx = 0
+		}
+		ch.qcount--
+		ch.mu.release()
+		return true, true
+	}
+
+	if ch.closed {
+		ch.mu.release()
+		if ep != unsafe { nil } {
+			unsafe { C.memset(ep, 0, ch.elemsize) }
+		}
+		return true, false
+	}
+
+	if !block {
+		ch.mu.release()
+		return false, false
+	}
+
+	// Block: enqueue ourselves on the recv wait queue
+	gp := get_current_g()
+	mut mysg := &Sudog{
+		g:    unsafe { gp }
+		elem: ep
+		c:    voidptr(ch)
+	}
+	ch.recvq.enqueue(mysg)
+	ch.mu.release()
+
+	// Park until a sender wakes us
+	gopark('chan receive')
+
+	return true, true
+}
+
+// chan_close closes the channel.
+// Translated from Go's closechan() in chan.go.
+pub fn chan_close(c &Chan) {
+	if c == unsafe { nil } {
+		panic('close of nil channel')
+	}
+
+	mut ch := unsafe { c }
+	ch.mu.acquire()
+
+	if ch.closed {
+		ch.mu.release()
+		panic('close of closed channel')
+	}
+
+	ch.closed = true
+
+	// Wake all waiting receivers
+	for {
+		mut sg := ch.recvq.dequeue()
+		if sg == unsafe { nil } {
+			break
+		}
+		if sg.elem != unsafe { nil } {
+			unsafe { C.memset(sg.elem, 0, ch.elemsize) }
+		}
+		sg.success = false
+		goready(sg.g)
+	}
+
+	// Wake all waiting senders (they will panic)
+	for {
+		mut sg := ch.sendq.dequeue()
+		if sg == unsafe { nil } {
+			break
+		}
+		sg.success = false
+		goready(sg.g)
+	}
+
+	ch.mu.release()
+}
+
+// send_direct sends data directly from sender to a waiting receiver.
+// Translated from Go's send() in chan.go.
+fn send_direct(sg &Sudog, ep voidptr, elem_size u16) {
+	if sg.elem != unsafe { nil } {
+		unsafe { C.memcpy(sg.elem, ep, elem_size) }
+	}
+	mut s := unsafe { sg }
+	s.success = true
+	goready(sg.g)
+}
+
+// recv_direct receives data directly from a waiting sender.
+fn recv_direct(ch &Chan, sg &Sudog, ep voidptr) {
+	if ch.dataqsiz == 0 {
+		// Unbuffered: copy directly from sender
+		if ep != unsafe { nil } {
+			unsafe { C.memcpy(ep, sg.elem, ch.elemsize) }
+		}
+	} else {
+		// Buffered: take from buffer, then copy sender's data into buffer
+		buf_elem := chan_buf(ch, unsafe { ch }.recvx)
+		if ep != unsafe { nil } {
+			unsafe { C.memcpy(ep, buf_elem, ch.elemsize) }
+		}
+		unsafe { C.memcpy(buf_elem, sg.elem, ch.elemsize) }
+		unsafe {
+			ch.recvx++
+			if ch.recvx == ch.dataqsiz {
+				ch.recvx = 0
+			}
+			ch.sendx = ch.recvx
+		}
+	}
+	mut s := unsafe { sg }
+	s.success = true
+	goready(sg.g)
+}
+
+// chan_buf returns a pointer to the i-th slot in the buffer.
+// Translated from Go's chanbuf() in chan.go.
+fn chan_buf(c &Chan, i u32) voidptr {
+	return unsafe { voidptr(usize(c.buf) + usize(i) * usize(c.elemsize)) }
+}
+
+// chan_len returns the number of elements in the channel buffer.
+pub fn chan_len(c &Chan) int {
+	if c == unsafe { nil } {
+		return 0
+	}
+	return int(c.qcount)
+}
+
+// chan_cap returns the capacity of the channel buffer.
+pub fn chan_cap(c &Chan) int {
+	if c == unsafe { nil } {
+		return 0
+	}
+	return int(c.dataqsiz)
+}