Initial project import

tools/v/vlib/sync/sync.c.v

@@ -0,0 +1,124 @@
+module sync
+
+import time
+
+@[noreturn]
+fn cpanic(res int) {
+	panic(unsafe { tos_clone(&u8(C.strerror(res))) })
+}
+
+@[noreturn]
+fn cpanic_errno() {
+	cpanic(C.errno)
+}
+
+fn should_be_zero(res int) {
+	if res != 0 {
+		cpanic(res)
+	}
+}
+
+// SpinLock is a mutual exclusion lock that busy-waits (spins) when locked.
+// When one thread holds the lock, any other thread attempting to acquire it
+// will loop repeatedly until the lock becomes available.
+@[noinit]
+pub struct SpinLock {
+mut:
+	locked  u8     // Lock state: 0 = unlocked, 1 = locked
+	padding [63]u8 // Cache line padding (fills to 64 bytes total)
+}
+
+// new_spin_lock creates and returns a new SpinLock instance initialized to unlocked state.
+pub fn new_spin_lock() &SpinLock {
+	mut the_lock := &SpinLock{
+		locked: 0
+	}
+	// Ensure initialization visibility across threads
+	C.atomic_thread_fence(C.memory_order_release)
+	$if valgrind ? {
+		C.ANNOTATE_RWLOCK_CREATE(&the_lock.locked)
+	}
+	return the_lock
+}
+
+// lock acquires the spin lock. If the lock is currently held by another thread,
+// this function will spin (busy-wait) until the lock becomes available.
+@[inline]
+pub fn (s &SpinLock) lock() {
+	// Expected value starts as unlocked (0)
+	mut expected := u8(0)
+	mut spin_count := 0
+	max_spins := 100
+	base_delay := 100 // nanosecond
+	max_delay := 10000 // nanoseconds (10μs)
+
+	// Busy-wait until lock is acquired
+	for {
+		// Attempt atomic compare-and-swap:
+		// Succeeds if current value matches expected (0),
+		// then swaps to locked (1)
+		if C.atomic_compare_exchange_weak_byte(&s.locked, &expected, 1) {
+			$if valgrind ? {
+				C.ANNOTATE_RWLOCK_ACQUIRED(&s.locked, 1) // 1 = write lock
+			}
+			// Prevent critical section reordering
+			C.atomic_thread_fence(C.memory_order_acquire)
+			return
+		}
+
+		spin_count++
+		// Exponential backoff after max_spins
+		if spin_count > max_spins {
+			// Calculate delay with cap: 100ns to 10μs
+			exponent := int_min(spin_count / max_spins, 10)
+			delay := int_min(base_delay * (1 << exponent), max_delay)
+			time.sleep(delay * time.nanosecond)
+		} else {
+			// Reduce power/bus contention during spinning
+			C.cpu_relax()
+		}
+
+		expected = 0
+	}
+}
+
+// try_lock try to lock the spin lock instance and return immediately.
+// If the spin lock was already locked, it will return false.
+@[inline]
+pub fn (s &SpinLock) try_lock() bool {
+	// First do a relaxed load to check if lock is free in order to prevent
+	// unnecessary cache misses if someone does while(!try_lock())
+	// TODO: make a `relaxed` load
+	if C.atomic_load_byte(&s.locked) == 0 {
+		mut expected := u8(0)
+		if C.atomic_compare_exchange_weak_byte(&s.locked, &expected, 1) {
+			$if valgrind ? {
+				C.ANNOTATE_RWLOCK_ACQUIRED(&s.locked, 1)
+			}
+			C.atomic_thread_fence(C.memory_order_acquire)
+			return true
+		}
+	}
+	return false
+}
+
+// unlock releases the spin lock, making it available to other threads.
+// IMPORTANT: Must only be called by the thread that currently holds the lock.
+@[inline]
+pub fn (s &SpinLock) unlock() {
+	$if valgrind ? {
+		C.ANNOTATE_RWLOCK_RELEASED(&s.locked, 1) // 1 = write lock
+	}
+	// Ensure critical section completes before release
+	C.atomic_thread_fence(C.memory_order_release)
+
+	// Atomically reset to unlocked state
+	C.atomic_store_byte(&s.locked, 0)
+}
+
+// destroy frees the resources associated with the spin lock instance.
+pub fn (s &SpinLock) destroy() {
+	$if valgrind ? {
+		C.ANNOTATE_RWLOCK_DESTROY(&s.locked)
+	}
+}