New redesign of core:sync (stored under core:sync/sync2 for the time being)

core/sync/sync2/primitives.odin

@@ -0,0 +1,185 @@
+package sync2
+
+import "core:time"
+import "core:runtime"
+
+// A Mutex is a mutual exclusion lock
+// The zero value for a Mutex is an unlocked mutex
+//
+// A Mutex must not be copied after first use
+Mutex :: struct {
+	impl: _Mutex,
+}
+
+// mutex_lock locks m
+mutex_lock :: proc(m: ^Mutex) {
+	_mutex_lock(m);
+}
+
+// mutex_lock unlocks m
+mutex_unlock :: proc(m: ^Mutex) {
+	_mutex_unlock(m);
+}
+
+// mutex_lock tries to lock m, will return true on success, and false on failure
+mutex_try_lock :: proc(m: ^Mutex) -> bool {
+	return _mutex_try_lock(m);
+}
+
+// A RW_Mutex is a reader/writer mutual exclusion lock
+// The lock can be held by any arbitrary number of readers or a single writer
+// The zero value for a RW_Mutex is an unlocked mutex
+//
+// A RW_Mutex must not be copied after first use
+RW_Mutex :: struct {
+	impl: _RW_Mutex,
+}
+
+// rw_mutex_lock locks rw for writing (with a single writer)
+// If the mutex is already locked for reading or writing, the mutex blocks until the mutex is available.
+rw_mutex_lock :: proc(rw: ^RW_Mutex) {
+	_rw_mutex_lock(rw);
+}
+
+// rw_mutex_unlock unlocks rw for writing (with a single writer)
+rw_mutex_unlock :: proc(rw: ^RW_Mutex) {
+	_rw_mutex_unlock(rw);
+}
+
+// rw_mutex_try_lock tries to lock rw for writing (with a single writer)
+rw_mutex_try_lock :: proc(rw: ^RW_Mutex) -> bool {
+	return _rw_mutex_try_lock(rw);
+}
+
+// rw_mutex_shared_lock locks rw for reading (with arbitrary number of readers)
+rw_mutex_shared_lock :: proc(rw: ^RW_Mutex) {
+	_rw_mutex_shared_lock(rw);
+}
+
+// rw_mutex_shared_unlock unlocks rw for reading (with arbitrary number of readers)
+rw_mutex_shared_unlock :: proc(rw: ^RW_Mutex) {
+	_rw_mutex_shared_unlock(rw);
+}
+
+// rw_mutex_try_shared_lock tries to lock rw for reading (with arbitrary number of readers)
+rw_mutex_try_shared_lock :: proc(rw: ^RW_Mutex) -> bool {
+	return _rw_mutex_try_shared_lock(rw);
+}
+
+
+// A Recusrive_Mutex is a recursive mutual exclusion lock
+// The zero value for a Recursive_Mutex is an unlocked mutex
+//
+// A Recursive_Mutex must not be copied after first use
+Recursive_Mutex :: struct {
+	// TODO(bill): Is this implementation too lazy?
+	// Can this be made to work on all OSes without construction and destruction, i.e. Zero is Initialized
+	// CRITICAL_SECTION would be a perfect candidate for this on Windows but that cannot be "dumb"
+
+	owner:     int,
+	recursion: int,
+	mutex: Mutex,
+}
+
+recursive_mutex_lock :: proc(m: ^Recursive_Mutex) {
+	tid := runtime.current_thread_id();
+	if tid != m.owner {
+		mutex_lock(&m.mutex);
+	}
+	// inside the lock
+	m.owner = tid;
+	m.recursion += 1;
+}
+
+recursive_mutex_unlock :: proc(m: ^Recursive_Mutex) {
+	tid := runtime.current_thread_id();
+	assert(tid == m.owner);
+	m.recursion -= 1;
+	recursion := m.recursion;
+	if recursion == 0 {
+		m.owner = 0;
+	}
+	if recursion == 0 {
+		mutex_unlock(&m.mutex);
+	}
+	// outside the lock
+
+}
+
+recursive_mutex_try_lock :: proc(m: ^Recursive_Mutex) -> bool {
+	tid := runtime.current_thread_id();
+	if m.owner == tid {
+		return mutex_try_lock(&m.mutex);
+	}
+	if !mutex_try_lock(&m.mutex) {
+		return false;
+	}
+	// inside the lock
+	m.owner = tid;
+	m.recursion += 1;
+	return true;
+}
+
+
+
+// Cond implements a condition variable, a rendezvous point for threads
+// waiting for signalling the occurence of an event
+//
+// A Cond must not be copied after first use
+Cond :: struct {
+	impl: _Cond,
+}
+
+cond_wait :: proc(c: ^Cond, m: ^Mutex) {
+	_cond_wait(c, m);
+}
+
+cond_wait_with_timeout :: proc(c: ^Cond, m: ^Mutex, timeout: time.Duration) -> bool {
+	return _cond_wait_with_timeout(c, m, timeout);
+}
+
+cond_signal :: proc(c: ^Cond) {
+	_cond_signal(c);
+}
+
+cond_broadcast :: proc(c: ^Cond) {
+	_cond_broadcast(c);
+}
+
+
+
+// When waited upon, blocks until the internal count is greater than zero, then subtracts one.
+// Posting to the semaphore increases the count by one, or the provided amount.
+//
+// A Sema must not be copied after first use
+Sema :: struct {
+	// TODO(bill): Is this implementation too lazy?
+	// Can this be made to work on all OSes without construction and destruction, i.e. Zero is Initialized
+
+	mutex: Mutex,
+	cond:  Cond,
+	count: int,
+}
+
+
+sema_wait :: proc(s: ^Sema) {
+	mutex_lock(&s.mutex);
+	defer mutex_unlock(&s.mutex);
+
+	for s.count == 0 {
+		cond_wait(&s.cond, &s.mutex);
+	}
+
+	s.count -= 1;
+	if s.count > 0 {
+		cond_signal(&s.cond);
+	}
+}
+
+sema_post :: proc(s: ^Sema, count := 1) {
+	mutex_lock(&s.mutex);
+	defer mutex_unlock(&s.mutex);
+
+	s.count += count;
+	cond_signal(&s.cond);
+}