sync: add semaphores (#5831)

vlib/sync/sync_nix.c.v

@@ -3,7 +3,10 @@
 // that can be found in the LICENSE file.
 module sync
 
+import time
+
 #flag -lpthread
+#include <semaphore.h>
 
 // [init_with=new_mutex] // TODO: implement support for this struct attribute, and disallow Mutex{} from outside the sync.new_mutex() function.
 [ref_only]
@@ -21,6 +24,36 @@ struct RwMutexAttr {
 	attr C.pthread_rwlockattr_t
 }
 
+/* MacOSX has no unnamed semaphores and no `timed_wait()` at all
+   so we emulate the behaviour with other devices */
+struct MacOSX_Semaphore {
+	mtx C.pthread_mutex_t
+	cond C.pthread_cond_t
+mut:
+	count int
+}
+
+[ref_only]
+struct PosixSemaphore {
+	sem C.sem_t
+}
+
+[ref_only]
+struct CondAttr {
+	attr C.pthread_condattr_t
+}
+
+pub struct Semaphore {
+	/*
+	$if macos {
+		sem &MacOSX_Semaphore
+	} $else {
+		sem &PosixSemaphore
+	}
+	*/
+	sem voidptr // since the above does not work, yet
+}
+
 pub fn new_mutex() &Mutex {
 	m := &Mutex{}
 	C.pthread_mutex_init(&m.mutex, C.NULL)
@@ -65,3 +98,91 @@ pub fn (mut m RwMutex) r_unlock() {
 pub fn (mut m RwMutex) w_unlock() {
 	C.pthread_rwlock_unlock(&m.mutex)
 }
+
+pub fn new_semaphore() Semaphore {
+	$if macos {
+		s := Semaphore{
+			sem: &MacOSX_Semaphore{count: 0}
+		}
+		C.pthread_mutex_init(&&MacOSX_Semaphore(s.sem).mtx, C.NULL)
+		a := &CondAttr{}
+		C.pthread_condattr_init(&a.attr)
+		C.pthread_condattr_setpshared(&a.attr, C.PTHREAD_PROCESS_PRIVATE)
+		C.pthread_cond_init(&&MacOSX_Semaphore(s.sem).cond, &a.attr)
+		return s
+	} $else {
+		s := Semaphore{
+			sem: &PosixSemaphore{}
+		}
+		C.sem_init(&&PosixSemaphore(s.sem).sem, 0, 0)
+		return s
+	}
+}
+
+pub fn (s Semaphore) post() {
+	$if macos {
+		C.pthread_mutex_lock(&&MacOSX_Semaphore(s.sem).mtx)
+		(&MacOSX_Semaphore(s.sem)).count++
+		C.pthread_cond_signal(&&MacOSX_Semaphore(s.sem).cond)
+		C.pthread_mutex_unlock(&&MacOSX_Semaphore(s.sem).mtx)
+	} $else {
+		C.sem_post(&&PosixSemaphore(s.sem).sem)
+	}
+}
+
+pub fn (s Semaphore) wait() {
+	$if macos {
+		C.pthread_mutex_lock(&&MacOSX_Semaphore(s.sem).mtx)
+		for &MacOSX_Semaphore(s.sem).count == 0 {
+			C.pthread_cond_wait(&&MacOSX_Semaphore(s.sem).cond, &&MacOSX_Semaphore(s.sem).mtx)
+		}
+		(&MacOSX_Semaphore(s.sem)).count--
+		C.pthread_mutex_unlock(&&MacOSX_Semaphore(s.sem).mtx)
+	} $else {
+		C.sem_wait(&&PosixSemaphore(s.sem).sem)
+	}
+}
+
+pub fn (s Semaphore) try_wait() bool {
+	$if macos {
+		t_spec := time.zero_timespec()
+		C.pthread_mutex_lock(&&MacOSX_Semaphore(s.sem).mtx)
+		for &MacOSX_Semaphore(s.sem).count == 0 {
+			res := C.pthread_cond_timedwait(&&MacOSX_Semaphore(s.sem).cond, &&MacOSX_Semaphore(s.sem).mtx, &t_spec)
+			if res == C.ETIMEDOUT {
+				break
+			}
+		}
+		mut res := false
+		if &MacOSX_Semaphore(s.sem).count > 0 { // success
+			(&MacOSX_Semaphore(s.sem)).count--
+			res = true
+		}
+		C.pthread_mutex_unlock(&&MacOSX_Semaphore(s.sem).mtx)
+		return res
+	} $else {
+		return C.sem_trywait(&&PosixSemaphore(s.sem).sem) == 0
+	}
+}
+
+pub fn (s Semaphore) timed_wait(timeout time.Duration) bool {
+	t_spec := timeout.timespec()
+	$if macos {
+		C.pthread_mutex_lock(&&MacOSX_Semaphore(s.sem).mtx)
+		for &MacOSX_Semaphore(s.sem).count == 0 {
+			res := C.pthread_cond_timedwait(&&MacOSX_Semaphore(s.sem).cond, &&MacOSX_Semaphore(s.sem).mtx, &t_spec)
+			if res == C.ETIMEDOUT {
+				break
+			}
+		}
+		mut res := false
+		if &MacOSX_Semaphore(s.sem).count > 0 { // success
+			(&MacOSX_Semaphore(s.sem)).count--
+			res = true
+		}
+		C.pthread_mutex_unlock(&&MacOSX_Semaphore(s.sem).mtx)
+		return res
+	} $else {
+		return C.sem_timedwait(&&PosixSemaphore(s.sem).sem, &t_spec) == 0
+	}
+}

vlib/sync/sync_windows.c.v

@@ -3,11 +3,15 @@
 // that can be found in the LICENSE file.
 module sync
 
+import time
+
 // TODO: The suggestion of using CriticalSection instead of mutex
 // was discussed. Needs consideration.
 
 // Mutex HANDLE
 type MHANDLE voidptr
+// Semaphore HANDLE
+type SHANDLE voidptr
 
 //[init_with=new_mutex] // TODO: implement support for this struct attribute, and disallow Mutex{} from outside the sync.new_mutex() function.
 
@@ -28,6 +32,11 @@ mut:
 	mx C.SRWLOCK    // mutex handle
 }
 
+pub struct Semaphore {
+mut:
+	sem SHANDLE
+}
+
 enum MutexState {
 	broken
 	waiting
@@ -118,3 +127,25 @@ pub fn (mut m Mutex) destroy() {
 	C.CloseHandle(m.mx)  // destroy mutex
 	m.state = .destroyed // setting up reference to invalid state
 }
+
+pub fn new_semaphore() Semaphore {
+	return Semaphore{
+		sem: SHANDLE(C.CreateSemaphore(0, 0, C.INT32_MAX, 0))
+	}
+}
+
+pub fn (s Semaphore) post() {
+	C.ReleaseSemaphore(s.sem, 1, 0)
+}
+
+pub fn (s Semaphore) wait() {
+	C.WaitForSingleObject(s.sem, C.INFINITE)
+}
+
+pub fn (s Semaphore) try_wait() bool {
+	return C.WaitForSingleObject(s.sem, 0) == 0
+}
+
+pub fn (s Semaphore) timed_wait(timeout time.Duration) bool {
+	return C.WaitForSingleObject(s.sem, timeout / time.millisecond) == 0
+}