ed/Odin
1
0
Fork 0
mirror of https://github.com/Ed94/Odin.git synced 2026-08-06 15:48:51 +00:00
Code Issues Packages Projects Releases Wiki Activity

Change intrinsics.Atomic_Memory_Order fields to use Ada_Case rather than snake_case

Browse Source
This commit is contained in:
gingerBill
2022-03-31 12:57:24 +01:00
parent 22b961ea53
commit 9f2d710c35
9 changed files with 126 additions and 126 deletions
Download Patch File Download Diff File Expand all files Collapse all files
core/c/libc/stdatomic.odin
+75 -75
View File
@@ -50,10 +50,10 @@ atomic_thread_fence :: #force_inline proc(order: memory_order) {
assert(order != .relaxed) assert(order != .relaxed)
assert(order != .consume) assert(order != .consume)
#partial switch order { #partial switch order {
case .acquire: intrinsics.atomic_thread_fence(.acquire) case .acquire: intrinsics.atomic_thread_fence(.Acquire)
case .release: intrinsics.atomic_thread_fence(.release) case .release: intrinsics.atomic_thread_fence(.Release)
case .acq_rel: intrinsics.atomic_thread_fence(.acq_rel) case .acq_rel: intrinsics.atomic_thread_fence(.Acq_Rel)
case .seq_cst: intrinsics.atomic_thread_fence(.seq_cst) case .seq_cst: intrinsics.atomic_thread_fence(.Seq_Cst)
} }
} }
@@ -61,10 +61,10 @@ atomic_signal_fence :: #force_inline proc(order: memory_order) {
assert(order != .relaxed) assert(order != .relaxed)
assert(order != .consume) assert(order != .consume)
#partial switch order { #partial switch order {
case .acquire: intrinsics.atomic_signal_fence(.acquire) case .acquire: intrinsics.atomic_signal_fence(.Acquire)
case .release: intrinsics.atomic_signal_fence(.release) case .release: intrinsics.atomic_signal_fence(.Release)
case .acq_rel: intrinsics.atomic_signal_fence(.acq_rel) case .acq_rel: intrinsics.atomic_signal_fence(.Acq_Rel)
case .seq_cst: intrinsics.atomic_signal_fence(.seq_cst) case .seq_cst: intrinsics.atomic_signal_fence(.Seq_Cst)
} }
} }
@@ -123,9 +123,9 @@ atomic_store_explicit :: #force_inline proc(object: ^$T, desired: T, order: memo
assert(order != .acq_rel) assert(order != .acq_rel)
#partial switch order { #partial switch order {
case .relaxed: intrinsics.atomic_store_explicit(object, desired, .relaxed) case .relaxed: intrinsics.atomic_store_explicit(object, desired, .Relaxed)
case .release: intrinsics.atomic_store_explicit(object, desired, .release) case .release: intrinsics.atomic_store_explicit(object, desired, .Release)
case .seq_cst: intrinsics.atomic_store_explicit(object, desired, .seq_cst) case .seq_cst: intrinsics.atomic_store_explicit(object, desired, .Seq_Cst)
} }
} }
@@ -138,10 +138,10 @@ atomic_load_explicit :: #force_inline proc(object: ^$T, order: memory_order) {
assert(order != .acq_rel) assert(order != .acq_rel)
#partial switch order { #partial switch order {
case .relaxed: return intrinsics.atomic_load_explicit(object, .relaxed) case .relaxed: return intrinsics.atomic_load_explicit(object, .Relaxed)
case .consume: return intrinsics.atomic_load_explicit(object, .consume) case .consume: return intrinsics.atomic_load_explicit(object, .Consume)
case .acquire: return intrinsics.atomic_load_explicit(object, .acquire) case .acquire: return intrinsics.atomic_load_explicit(object, .Acquire)
case .seq_cst: return intrinsics.atomic_load_explicit(object, .seq_cst) case .seq_cst: return intrinsics.atomic_load_explicit(object, .Seq_Cst)
} }
} }
@@ -151,12 +151,12 @@ atomic_exchange :: #force_inline proc(object: ^$T, desired: T) -> T {
atomic_exchange_explicit :: #force_inline proc(object: ^$T, desired: T, order: memory_order) -> T { atomic_exchange_explicit :: #force_inline proc(object: ^$T, desired: T, order: memory_order) -> T {
switch order { switch order {
case .relaxed: return intrinsics.atomic_exchange_explicit(object, desired, .relaxed) case .relaxed: return intrinsics.atomic_exchange_explicit(object, desired, .Relaxed)
case .consume: return intrinsics.atomic_exchange_explicit(object, desired, .consume) case .consume: return intrinsics.atomic_exchange_explicit(object, desired, .Consume)
case .acquire: return intrinsics.atomic_exchange_explicit(object, desired, .acquire) case .acquire: return intrinsics.atomic_exchange_explicit(object, desired, .Acquire)
case .release: return intrinsics.atomic_exchange_explicit(object, desired, .release) case .release: return intrinsics.atomic_exchange_explicit(object, desired, .Release)
case .acq_rel: return intrinsics.atomic_exchange_explicit(object, desired, .acq_rel) case .acq_rel: return intrinsics.atomic_exchange_explicit(object, desired, .Acq_Rel)
case .seq_cst: return intrinsics.atomic_exchange_explicit(object, desired, .seq_cst) case .seq_cst: return intrinsics.atomic_exchange_explicit(object, desired, .Seq_Cst)
} }
return false return false
} }
@@ -193,36 +193,36 @@ atomic_compare_exchange_strong_explicit :: #force_inline proc(object, expected:
assert(success != .relaxed) assert(success != .relaxed)
#partial switch success { #partial switch success {
case .seq_cst: case .seq_cst:
value, ok = intrinsics.atomic_compare_exchange_strong_explicit(object, expected^, desired, .seq_cst, .seq_cst) value, ok = intrinsics.atomic_compare_exchange_strong_explicit(object, expected^, desired, .Seq_Cst, .Seq_Cst)
case .acquire: case .acquire:
value, ok = intrinsics.atomic_compare_exchange_strong_explicit(object, expected^, desired, .acquire, .seq_cst) value, ok = intrinsics.atomic_compare_exchange_strong_explicit(object, expected^, desired, .Acquire, .Seq_Cst)
case .consume: case .consume:
value, ok = intrinsics.atomic_compare_exchange_strong_explicit(object, expected^, desired, .consume, .seq_cst) value, ok = intrinsics.atomic_compare_exchange_strong_explicit(object, expected^, desired, .Consume, .Seq_Cst)
case .release: case .release:
value, ok = intrinsics.atomic_compare_exchange_strong_explicit(object, expected^, desired, .release, .seq_cst) value, ok = intrinsics.atomic_compare_exchange_strong_explicit(object, expected^, desired, .Release, .Seq_Cst)
case .acq_rel: case .acq_rel:
value, ok = intrinsics.atomic_compare_exchange_strong_explicit(object, expected^, desired, .acq_rel, .seq_cst) value, ok = intrinsics.atomic_compare_exchange_strong_explicit(object, expected^, desired, .Acq_Rel, .Seq_Cst)
} }
case .relaxed: case .relaxed:
assert(success != .release) assert(success != .release)
#partial switch success { #partial switch success {
case .relaxed: case .relaxed:
value, ok = intrinsics.atomic_compare_exchange_strong_explicit(object, expected^, desired, .relaxed, .relaxed) value, ok = intrinsics.atomic_compare_exchange_strong_explicit(object, expected^, desired, .Relaxed, .Relaxed)
case .seq_cst: case .seq_cst:
value, ok = intrinsics.atomic_compare_exchange_strong_explicit(object, expected^, desired, .seq_cst, .relaxed) value, ok = intrinsics.atomic_compare_exchange_strong_explicit(object, expected^, desired, .Seq_Cst, .Relaxed)
case .acquire: case .acquire:
value, ok = intrinsics.atomic_compare_exchange_strong_explicit(object, expected^, desired, .acquire, .relaxed) value, ok = intrinsics.atomic_compare_exchange_strong_explicit(object, expected^, desired, .Acquire, .Relaxed)
case .consume: case .consume:
value, ok = intrinsics.atomic_compare_exchange_strong_explicit(object, expected^, desired, .consume, .relaxed) value, ok = intrinsics.atomic_compare_exchange_strong_explicit(object, expected^, desired, .Consume, .Relaxed)
case .acq_rel: case .acq_rel:
value, ok = intrinsics.atomic_compare_exchange_strong_explicit(object, expected^, desired, .acq_rel, .relaxed) value, ok = intrinsics.atomic_compare_exchange_strong_explicit(object, expected^, desired, .Acq_Rel, .Relaxed)
} }
case .consume: case .consume:
assert(success == .seq_cst) assert(success == .seq_cst)
value, ok = intrinsics.atomic_compare_exchange_strong_explicit(object, expected^, desired, .seq_cst, .consume) value, ok = intrinsics.atomic_compare_exchange_strong_explicit(object, expected^, desired, .Seq_Cst, .Consume)
case .acquire: case .acquire:
assert(success == .seq_cst) assert(success == .seq_cst)
value, ok = intrinsics.atomic_compare_exchange_strong_explicit(object, expected^, desired, .seq_cst, .acquire) value, ok = intrinsics.atomic_compare_exchange_strong_explicit(object, expected^, desired, .Seq_Cst, .Acquire)
} }
if !ok { expected^ = value } if !ok { expected^ = value }
@@ -245,36 +245,36 @@ atomic_compare_exchange_weak_explicit :: #force_inline proc(object, expected: ^$
assert(success != .relaxed) assert(success != .relaxed)
#partial switch success { #partial switch success {
case .seq_cst: case .seq_cst:
value, ok = intrinsics.atomic_compare_exchange_weak_explicit(object, expected^, desired, .seq_cst, .seq_cst) value, ok = intrinsics.atomic_compare_exchange_weak_explicit(object, expected^, desired, .Seq_Cst, .Seq_Cst)
case .acquire: case .acquire:
value, ok = intrinsics.atomic_compare_exchange_weak_explicit(object, expected^, desired, .acquire, .seq_cst) value, ok = intrinsics.atomic_compare_exchange_weak_explicit(object, expected^, desired, .Acquire, .Seq_Cst)
case .consume: case .consume:
value, ok = intrinsics.atomic_compare_exchange_weak_explicit(object, expected^, desired, .consume, .seq_cst) value, ok = intrinsics.atomic_compare_exchange_weak_explicit(object, expected^, desired, .Consume, .Seq_Cst)
case .release: case .release:
value, ok = intrinsics.atomic_compare_exchange_weak_explicit(object, expected^, desired, .release, .seq_cst) value, ok = intrinsics.atomic_compare_exchange_weak_explicit(object, expected^, desired, .Release, .Seq_Cst)
case .acq_rel: case .acq_rel:
value, ok = intrinsics.atomic_compare_exchange_weak_explicit(object, expected^, desired, .acq_rel, .seq_cst) value, ok = intrinsics.atomic_compare_exchange_weak_explicit(object, expected^, desired, .Acq_Rel, .Seq_Cst)
} }
case .relaxed: case .relaxed:
assert(success != .release) assert(success != .release)
#partial switch success { #partial switch success {
case .relaxed: case .relaxed:
value, ok = intrinsics.atomic_compare_exchange_weak_explicit(object, expected^, desired, .relaxed, .relaxed) value, ok = intrinsics.atomic_compare_exchange_weak_explicit(object, expected^, desired, .Relaxed, .Relaxed)
case .seq_cst: case .seq_cst:
value, ok = intrinsics.atomic_compare_exchange_weak_explicit(object, expected^, desired, .seq_cst, .relaxed) value, ok = intrinsics.atomic_compare_exchange_weak_explicit(object, expected^, desired, .Seq_Cst, .Relaxed)
case .acquire: case .acquire:
value, ok = intrinsics.atomic_compare_exchange_weak_explicit(object, expected^, desired, .acquire, .relaxed) value, ok = intrinsics.atomic_compare_exchange_weak_explicit(object, expected^, desired, .Acquire, .Relaxed)
case .consume: case .consume:
value, ok = intrinsics.atomic_compare_exchange_weak_explicit(object, expected^, desired, .consume, .relaxed) value, ok = intrinsics.atomic_compare_exchange_weak_explicit(object, expected^, desired, .Consume, .Relaxed)
case .acq_rel: case .acq_rel:
value, ok = intrinsics.atomic_compare_exchange_weak_explicit(object, expected^, desired, .acq_rel, .relaxed) value, ok = intrinsics.atomic_compare_exchange_weak_explicit(object, expected^, desired, .Acq_Rel, .Relaxed)
} }
case .consume: case .consume:
assert(success == .seq_cst) assert(success == .seq_cst)
value, ok = intrinsics.atomic_compare_exchange_weak_explicit(object, expected^, desired, .seq_cst, .consume) value, ok = intrinsics.atomic_compare_exchange_weak_explicit(object, expected^, desired, .Seq_Cst, .Consume)
case .acquire: case .acquire:
assert(success == .seq_cst) assert(success == .seq_cst)
value, ok = intrinsics.atomic_compare_exchange_weak_explicit(object, expected^, desired, .seq_cst, .acquire) value, ok = intrinsics.atomic_compare_exchange_weak_explicit(object, expected^, desired, .Seq_Cst, .Acquire)
} }
if !ok { expected^ = value } if !ok { expected^ = value }
@@ -288,13 +288,13 @@ atomic_fetch_add :: #force_inline proc(object: ^$T, operand: T) -> T {
atomic_fetch_add_explicit :: #force_inline proc(object: ^$T, operand: T, order: memory_order) -> T { atomic_fetch_add_explicit :: #force_inline proc(object: ^$T, operand: T, order: memory_order) -> T {
switch order { switch order {
case .relaxed: return intrinsics.atomic_add_explicit(object, operand, .relaxed) case .relaxed: return intrinsics.atomic_add_explicit(object, operand, .Relaxed)
case .consume: return intrinsics.atomic_add_explicit(object, operand, .consume) case .consume: return intrinsics.atomic_add_explicit(object, operand, .Consume)
case .acquire: return intrinsics.atomic_add_explicit(object, operand, .acquire) case .acquire: return intrinsics.atomic_add_explicit(object, operand, .Acquire)
case .release: return intrinsics.atomic_add_explicit(object, operand, .release) case .release: return intrinsics.atomic_add_explicit(object, operand, .Release)
case .acq_rel: return intrinsics.atomic_add_explicit(object, operand, .acq_rel) case .acq_rel: return intrinsics.atomic_add_explicit(object, operand, .Acq_Rel)
case: fallthrough case: fallthrough
case .seq_cst: return intrinsics.atomic_add_explicit(object, operand, .seq_cst) case .seq_cst: return intrinsics.atomic_add_explicit(object, operand, .Seq_Cst)
} }
} }
@@ -304,13 +304,13 @@ atomic_fetch_sub :: #force_inline proc(object: ^$T, operand: T) -> T {
atomic_fetch_sub_explicit :: #force_inline proc(object: ^$T, operand: T, order: memory_order) -> T { atomic_fetch_sub_explicit :: #force_inline proc(object: ^$T, operand: T, order: memory_order) -> T {
switch order { switch order {
case .relaxed: return intrinsics.atomic_sub_explicit(object, operand, .relaxed) case .relaxed: return intrinsics.atomic_sub_explicit(object, operand, .Relaxed)
case .consume: return intrinsics.atomic_sub_explicit(object, operand, .consume) case .consume: return intrinsics.atomic_sub_explicit(object, operand, .Consume)
case .acquire: return intrinsics.atomic_sub_explicit(object, operand, .acquire) case .acquire: return intrinsics.atomic_sub_explicit(object, operand, .Acquire)
case .release: return intrinsics.atomic_sub_explicit(object, operand, .release) case .release: return intrinsics.atomic_sub_explicit(object, operand, .Release)
case .acq_rel: return intrinsics.atomic_sub_explicit(object, operand, .acq_rel) case .acq_rel: return intrinsics.atomic_sub_explicit(object, operand, .Acq_Rel)
case: fallthrough case: fallthrough
case .seq_cst: return intrinsics.atomic_sub_explicit(object, operand, .seq_cst) case .seq_cst: return intrinsics.atomic_sub_explicit(object, operand, .Seq_Cst)
} }
} }
@@ -320,13 +320,13 @@ atomic_fetch_or :: #force_inline proc(object: ^$T, operand: T) -> T {
atomic_fetch_or_explicit :: #force_inline proc(object: ^$T, operand: T, order: memory_order) -> T { atomic_fetch_or_explicit :: #force_inline proc(object: ^$T, operand: T, order: memory_order) -> T {
switch order { switch order {
case .relaxed: return intrinsics.atomic_or_explicit(object, operand, .relaxed) case .relaxed: return intrinsics.atomic_or_explicit(object, operand, .Relaxed)
case .consume: return intrinsics.atomic_or_explicit(object, operand, .consume) case .consume: return intrinsics.atomic_or_explicit(object, operand, .Consume)
case .acquire: return intrinsics.atomic_or_explicit(object, operand, .acquire) case .acquire: return intrinsics.atomic_or_explicit(object, operand, .Acquire)
case .release: return intrinsics.atomic_or_explicit(object, operand, .release) case .release: return intrinsics.atomic_or_explicit(object, operand, .Release)
case .acq_rel: return intrinsics.atomic_or_explicit(object, operand, .acq_rel) case .acq_rel: return intrinsics.atomic_or_explicit(object, operand, .Acq_Rel)
case: fallthrough case: fallthrough
case .seq_cst: return intrinsics.atomic_or_explicit(object, operand, .seq_cst) case .seq_cst: return intrinsics.atomic_or_explicit(object, operand, .Seq_Cst)
} }
} }
@@ -336,13 +336,13 @@ atomic_fetch_xor :: #force_inline proc(object: ^$T, operand: T) -> T {
atomic_fetch_xor_explicit :: #force_inline proc(object: ^$T, operand: T, order: memory_order) -> T { atomic_fetch_xor_explicit :: #force_inline proc(object: ^$T, operand: T, order: memory_order) -> T {
switch order { switch order {
case .relaxed: return intrinsics.atomic_xor_explicit(object, operand, .relaxed) case .relaxed: return intrinsics.atomic_xor_explicit(object, operand, .Relaxed)
case .consume: return intrinsics.atomic_xor_explicit(object, operand, .consume) case .consume: return intrinsics.atomic_xor_explicit(object, operand, .Consume)
case .acquire: return intrinsics.atomic_xor_explicit(object, operand, .acquire) case .acquire: return intrinsics.atomic_xor_explicit(object, operand, .Acquire)
case .release: return intrinsics.atomic_xor_explicit(object, operand, .release) case .release: return intrinsics.atomic_xor_explicit(object, operand, .Release)
case .acq_rel: return intrinsics.atomic_xor_explicit(object, operand, .acq_rel) case .acq_rel: return intrinsics.atomic_xor_explicit(object, operand, .Acq_Rel)
case: fallthrough case: fallthrough
case .seq_cst: return intrinsics.atomic_xor_explicit(object, operand, .seq_cst) case .seq_cst: return intrinsics.atomic_xor_explicit(object, operand, .Seq_Cst)
} }
} }
@@ -351,13 +351,13 @@ atomic_fetch_and :: #force_inline proc(object: ^$T, operand: T) -> T {
} }
atomic_fetch_and_explicit :: #force_inline proc(object: ^$T, operand: T, order: memory_order) -> T { atomic_fetch_and_explicit :: #force_inline proc(object: ^$T, operand: T, order: memory_order) -> T {
switch order { switch order {
case .relaxed: return intrinsics.atomic_and_explicit(object, operand, .relaxed) case .relaxed: return intrinsics.atomic_and_explicit(object, operand, .Relaxed)
case .consume: return intrinsics.atomic_and_explicit(object, operand, .consume) case .consume: return intrinsics.atomic_and_explicit(object, operand, .Consume)
case .acquire: return intrinsics.atomic_and_explicit(object, operand, .acquire) case .acquire: return intrinsics.atomic_and_explicit(object, operand, .Acquire)
case .release: return intrinsics.atomic_and_explicit(object, operand, .release) case .release: return intrinsics.atomic_and_explicit(object, operand, .Release)
case .acq_rel: return intrinsics.atomic_and_explicit(object, operand, .acq_rel) case .acq_rel: return intrinsics.atomic_and_explicit(object, operand, .Acq_Rel)
case: fallthrough case: fallthrough
case .seq_cst: return intrinsics.atomic_and_explicit(object, operand, .seq_cst) case .seq_cst: return intrinsics.atomic_and_explicit(object, operand, .Seq_Cst)
} }
} }
core/intrinsics/intrinsics.odin
+6 -6
View File
@@ -63,12 +63,12 @@ syscall :: proc(id: uintptr, args: ..uintptr) -> uintptr ---
// Atomics // Atomics
Atomic_Memory_Order :: enum { Atomic_Memory_Order :: enum {
relaxed = 0, // unordered Relaxed = 0, // Unordered
consume = 1, // monotonic Consume = 1, // Monotonic
acquire = 2, Acquire = 2,
release = 3, Release = 3,
acq_rel = 4, Acq_Rel = 4,
seq_cst = 5, Seq_Cst = 5,
} }
atomic_thread_fence :: proc(order: Atomic_Memory_Order) --- atomic_thread_fence :: proc(order: Atomic_Memory_Order) ---
core/mem/mem.odin
+1 -1
View File
@@ -16,7 +16,7 @@ zero_explicit :: proc "contextless" (data: rawptr, len: int) -> rawptr {
// equivalent semantics to those provided by the C11 Annex K 3.7.4.1 // equivalent semantics to those provided by the C11 Annex K 3.7.4.1
// memset_s call. // memset_s call.
intrinsics.mem_zero_volatile(data, len) // Use the volatile mem_zero intrinsics.mem_zero_volatile(data, len) // Use the volatile mem_zero
intrinsics.atomic_thread_fence(.seq_cst) // Prevent reordering intrinsics.atomic_thread_fence(.Seq_Cst) // Prevent reordering
return data return data
} }
zero_item :: proc "contextless" (item: $P/^$T) { zero_item :: proc "contextless" (item: $P/^$T) {
core/sync/atomic.odin
+6 -6
View File
@@ -6,12 +6,12 @@ cpu_relax :: intrinsics.cpu_relax
/* /*
Atomic_Memory_Order :: enum { Atomic_Memory_Order :: enum {
relaxed = 0, Relaxed = 0,
consume = 1, Consume = 1,
acquire = 2, Acquire = 2,
release = 3, Release = 3,
acq_rel = 4, Acq_Rel = 4,
seq_cst = 5, Seq_Cst = 5,
} }
*/ */
Atomic_Memory_Order :: intrinsics.Atomic_Memory_Order Atomic_Memory_Order :: intrinsics.Atomic_Memory_Order
core/sync/extended.odin
+15 -15
View File
@@ -146,10 +146,10 @@ Auto_Reset_Event :: struct {
} }
auto_reset_event_signal :: proc(e: ^Auto_Reset_Event) { auto_reset_event_signal :: proc(e: ^Auto_Reset_Event) {
old_status := atomic_load_explicit(&e.status, .relaxed) old_status := atomic_load_explicit(&e.status, .Relaxed)
for { for {
new_status := old_status + 1 if old_status < 1 else 1 new_status := old_status + 1 if old_status < 1 else 1
if _, ok := atomic_compare_exchange_weak_explicit(&e.status, old_status, new_status, .release, .relaxed); ok { if _, ok := atomic_compare_exchange_weak_explicit(&e.status, old_status, new_status, .Release, .Relaxed); ok {
break break
} }
@@ -160,7 +160,7 @@ auto_reset_event_signal :: proc(e: ^Auto_Reset_Event) {
} }
auto_reset_event_wait :: proc(e: ^Auto_Reset_Event) { auto_reset_event_wait :: proc(e: ^Auto_Reset_Event) {
old_status := atomic_sub_explicit(&e.status, 1, .acquire) old_status := atomic_sub_explicit(&e.status, 1, .Acquire)
if old_status < 1 { if old_status < 1 {
sema_wait(&e.sema) sema_wait(&e.sema)
} }
@@ -174,14 +174,14 @@ Ticket_Mutex :: struct {
} }
ticket_mutex_lock :: #force_inline proc(m: ^Ticket_Mutex) { ticket_mutex_lock :: #force_inline proc(m: ^Ticket_Mutex) {
ticket := atomic_add_explicit(&m.ticket, 1, .relaxed) ticket := atomic_add_explicit(&m.ticket, 1, .Relaxed)
for ticket != atomic_load_explicit(&m.serving, .acquire) { for ticket != atomic_load_explicit(&m.serving, .Acquire) {
cpu_relax() cpu_relax()
} }
} }
ticket_mutex_unlock :: #force_inline proc(m: ^Ticket_Mutex) { ticket_mutex_unlock :: #force_inline proc(m: ^Ticket_Mutex) {
atomic_add_explicit(&m.serving, 1, .relaxed) atomic_add_explicit(&m.serving, 1, .Relaxed)
} }
@(deferred_in=ticket_mutex_unlock) @(deferred_in=ticket_mutex_unlock)
ticket_mutex_guard :: proc(m: ^Ticket_Mutex) -> bool { ticket_mutex_guard :: proc(m: ^Ticket_Mutex) -> bool {
@@ -196,18 +196,18 @@ Benaphore :: struct {
} }
benaphore_lock :: proc(b: ^Benaphore) { benaphore_lock :: proc(b: ^Benaphore) {
if atomic_add_explicit(&b.counter, 1, .acquire) > 1 { if atomic_add_explicit(&b.counter, 1, .Acquire) > 1 {
sema_wait(&b.sema) sema_wait(&b.sema)
} }
} }
benaphore_try_lock :: proc(b: ^Benaphore) -> bool { benaphore_try_lock :: proc(b: ^Benaphore) -> bool {
v, _ := atomic_compare_exchange_strong_explicit(&b.counter, 1, 0, .acquire, .acquire) v, _ := atomic_compare_exchange_strong_explicit(&b.counter, 1, 0, .Acquire, .Acquire)
return v == 0 return v == 0
} }
benaphore_unlock :: proc(b: ^Benaphore) { benaphore_unlock :: proc(b: ^Benaphore) {
if atomic_sub_explicit(&b.counter, 1, .release) > 0 { if atomic_sub_explicit(&b.counter, 1, .Release) > 0 {
sema_post(&b.sema) sema_post(&b.sema)
} }
} }
@@ -227,7 +227,7 @@ Recursive_Benaphore :: struct {
recursive_benaphore_lock :: proc(b: ^Recursive_Benaphore) { recursive_benaphore_lock :: proc(b: ^Recursive_Benaphore) {
tid := current_thread_id() tid := current_thread_id()
if atomic_add_explicit(&b.counter, 1, .acquire) > 1 { if atomic_add_explicit(&b.counter, 1, .Acquire) > 1 {
if tid != b.owner { if tid != b.owner {
sema_wait(&b.sema) sema_wait(&b.sema)
} }
@@ -240,10 +240,10 @@ recursive_benaphore_lock :: proc(b: ^Recursive_Benaphore) {
recursive_benaphore_try_lock :: proc(b: ^Recursive_Benaphore) -> bool { recursive_benaphore_try_lock :: proc(b: ^Recursive_Benaphore) -> bool {
tid := current_thread_id() tid := current_thread_id()
if b.owner == tid { if b.owner == tid {
atomic_add_explicit(&b.counter, 1, .acquire) atomic_add_explicit(&b.counter, 1, .Acquire)
} }
if v, _ := atomic_compare_exchange_strong_explicit(&b.counter, 1, 0, .acquire, .acquire); v != 0 { if v, _ := atomic_compare_exchange_strong_explicit(&b.counter, 1, 0, .Acquire, .Acquire); v != 0 {
return false return false
} }
// inside the lock // inside the lock
@@ -260,7 +260,7 @@ recursive_benaphore_unlock :: proc(b: ^Recursive_Benaphore) {
if recursion == 0 { if recursion == 0 {
b.owner = 0 b.owner = 0
} }
if atomic_sub_explicit(&b.counter, 1, .release) > 0 { if atomic_sub_explicit(&b.counter, 1, .Release) > 0 {
if recursion == 0 { if recursion == 0 {
sema_post(&b.sema) sema_post(&b.sema)
} }
@@ -293,12 +293,12 @@ once_do :: proc(o: ^Once, fn: proc()) {
defer mutex_unlock(&o.m) defer mutex_unlock(&o.m)
if !o.done { if !o.done {
fn() fn()
atomic_store_explicit(&o.done, true, .release) atomic_store_explicit(&o.done, true, .Release)
} }
} }
if atomic_load_explicit(&o.done, .acquire) == false { if atomic_load_explicit(&o.done, .Acquire) == false {
do_slow(o, fn) do_slow(o, fn)
} }
} }
core/sync/primitives_atomic.odin
+8 -8
View File
@@ -24,7 +24,7 @@ atomic_mutex_lock :: proc(m: ^Atomic_Mutex) {
new_state := curr_state // Make a copy of it new_state := curr_state // Make a copy of it
spin_lock: for spin in 0..<i32(100) { spin_lock: for spin in 0..<i32(100) {
state, ok := atomic_compare_exchange_weak_explicit(&m.state, .Unlocked, new_state, .acquire, .consume) state, ok := atomic_compare_exchange_weak_explicit(&m.state, .Unlocked, new_state, .Acquire, .Consume)
if ok { if ok {
return return
} }
@@ -42,7 +42,7 @@ atomic_mutex_lock :: proc(m: ^Atomic_Mutex) {
new_state = .Waiting new_state = .Waiting
for { for {
if atomic_exchange_explicit(&m.state, .Waiting, .acquire) == .Unlocked { if atomic_exchange_explicit(&m.state, .Waiting, .Acquire) == .Unlocked {
return return
} }
@@ -52,7 +52,7 @@ atomic_mutex_lock :: proc(m: ^Atomic_Mutex) {
} }
if v := atomic_exchange_explicit(&m.state, .Locked, .acquire); v != .Unlocked { if v := atomic_exchange_explicit(&m.state, .Locked, .Acquire); v != .Unlocked {
lock_slow(m, v) lock_slow(m, v)
} }
} }
@@ -65,7 +65,7 @@ atomic_mutex_unlock :: proc(m: ^Atomic_Mutex) {
} }
switch atomic_exchange_explicit(&m.state, .Unlocked, .release) { switch atomic_exchange_explicit(&m.state, .Unlocked, .Release) {
case .Unlocked: case .Unlocked:
unreachable() unreachable()
case .Locked: case .Locked:
@@ -77,7 +77,7 @@ atomic_mutex_unlock :: proc(m: ^Atomic_Mutex) {
// atomic_mutex_try_lock tries to lock m, will return true on success, and false on failure // atomic_mutex_try_lock tries to lock m, will return true on success, and false on failure
atomic_mutex_try_lock :: proc(m: ^Atomic_Mutex) -> bool { atomic_mutex_try_lock :: proc(m: ^Atomic_Mutex) -> bool {
_, ok := atomic_compare_exchange_strong_explicit(&m.state, .Unlocked, .Locked, .acquire, .consume) _, ok := atomic_compare_exchange_strong_explicit(&m.state, .Unlocked, .Locked, .Acquire, .Consume)
return ok return ok
} }
@@ -290,7 +290,7 @@ Queue_Item :: struct {
@(private="file") @(private="file")
queue_item_wait :: proc(item: ^Queue_Item) { queue_item_wait :: proc(item: ^Queue_Item) {
for atomic_load_explicit(&item.futex, .acquire) == 0 { for atomic_load_explicit(&item.futex, .Acquire) == 0 {
futex_wait(&item.futex, 0) futex_wait(&item.futex, 0)
cpu_relax() cpu_relax()
} }
@@ -298,7 +298,7 @@ queue_item_wait :: proc(item: ^Queue_Item) {
@(private="file") @(private="file")
queue_item_wait_with_timeout :: proc(item: ^Queue_Item, duration: time.Duration) -> bool { queue_item_wait_with_timeout :: proc(item: ^Queue_Item, duration: time.Duration) -> bool {
start := time.tick_now() start := time.tick_now()
for atomic_load_explicit(&item.futex, .acquire) == 0 { for atomic_load_explicit(&item.futex, .Acquire) == 0 {
remaining := duration - time.tick_since(start) remaining := duration - time.tick_since(start)
if remaining < 0 { if remaining < 0 {
return false return false
@@ -312,7 +312,7 @@ queue_item_wait_with_timeout :: proc(item: ^Queue_Item, duration: time.Duration)
} }
@(private="file") @(private="file")
queue_item_signal :: proc(item: ^Queue_Item) { queue_item_signal :: proc(item: ^Queue_Item) {
atomic_store_explicit(&item.futex, 1, .release) atomic_store_explicit(&item.futex, 1, .Release)
futex_signal(&item.futex) futex_signal(&item.futex)
} }
core/sync/primitives_internal.odin
+3 -3
View File
@@ -10,7 +10,7 @@ when #config(ODIN_SYNC_RECURSIVE_MUTEX_USE_FUTEX, true) {
_recursive_mutex_lock :: proc(m: ^Recursive_Mutex) { _recursive_mutex_lock :: proc(m: ^Recursive_Mutex) {
tid := Futex(current_thread_id()) tid := Futex(current_thread_id())
for { for {
prev_owner := atomic_compare_exchange_strong_explicit(&m.impl.owner, tid, 0, .acquire, .acquire) prev_owner := atomic_compare_exchange_strong_explicit(&m.impl.owner, tid, 0, .Acquire, .Acquire)
switch prev_owner { switch prev_owner {
case 0, tid: case 0, tid:
m.impl.recursion += 1 m.impl.recursion += 1
@@ -27,7 +27,7 @@ when #config(ODIN_SYNC_RECURSIVE_MUTEX_USE_FUTEX, true) {
if m.impl.recursion != 0 { if m.impl.recursion != 0 {
return return
} }
atomic_exchange_explicit(&m.impl.owner, 0, .release) atomic_exchange_explicit(&m.impl.owner, 0, .Release)
futex_signal(&m.impl.owner) futex_signal(&m.impl.owner)
// outside the lock // outside the lock
@@ -36,7 +36,7 @@ when #config(ODIN_SYNC_RECURSIVE_MUTEX_USE_FUTEX, true) {
_recursive_mutex_try_lock :: proc(m: ^Recursive_Mutex) -> bool { _recursive_mutex_try_lock :: proc(m: ^Recursive_Mutex) -> bool {
tid := Futex(current_thread_id()) tid := Futex(current_thread_id())
prev_owner := atomic_compare_exchange_strong_explicit(&m.impl.owner, tid, 0, .acquire, .acquire) prev_owner := atomic_compare_exchange_strong_explicit(&m.impl.owner, tid, 0, .Acquire, .Acquire)
switch prev_owner { switch prev_owner {
case 0, tid: case 0, tid:
m.impl.recursion += 1 m.impl.recursion += 1
src/checker.cpp
+6 -6
View File
@@ -992,12 +992,12 @@ void init_universal(void) {
{ {
GlobalEnumValue values[OdinAtomicMemoryOrder_COUNT] = { GlobalEnumValue values[OdinAtomicMemoryOrder_COUNT] = {
{"relaxed", OdinAtomicMemoryOrder_relaxed}, {OdinAtomicMemoryOrder_strings[OdinAtomicMemoryOrder_relaxed], OdinAtomicMemoryOrder_relaxed},
{"consume", OdinAtomicMemoryOrder_consume}, {OdinAtomicMemoryOrder_strings[OdinAtomicMemoryOrder_consume], OdinAtomicMemoryOrder_consume},
{"acquire", OdinAtomicMemoryOrder_acquire}, {OdinAtomicMemoryOrder_strings[OdinAtomicMemoryOrder_acquire], OdinAtomicMemoryOrder_acquire},
{"release", OdinAtomicMemoryOrder_release}, {OdinAtomicMemoryOrder_strings[OdinAtomicMemoryOrder_release], OdinAtomicMemoryOrder_release},
{"acq_rel", OdinAtomicMemoryOrder_acq_rel}, {OdinAtomicMemoryOrder_strings[OdinAtomicMemoryOrder_acq_rel], OdinAtomicMemoryOrder_acq_rel},
{"seq_cst", OdinAtomicMemoryOrder_seq_cst}, {OdinAtomicMemoryOrder_strings[OdinAtomicMemoryOrder_seq_cst], OdinAtomicMemoryOrder_seq_cst},
}; };
add_global_enum_type(str_lit("Atomic_Memory_Order"), values, gb_count_of(values), &t_atomic_memory_order); add_global_enum_type(str_lit("Atomic_Memory_Order"), values, gb_count_of(values), &t_atomic_memory_order);
src/types.cpp
+6 -6
View File
@@ -703,12 +703,12 @@ enum OdinAtomicMemoryOrder : i32 {
}; };
char const *OdinAtomicMemoryOrder_strings[OdinAtomicMemoryOrder_COUNT] = { char const *OdinAtomicMemoryOrder_strings[OdinAtomicMemoryOrder_COUNT] = {
"relaxed", "Relaxed",
"consume", "Consume",
"acquire", "Acquire",
"release", "Release",
"acq_rel", "Acq_Rel",
"seq_cst", "Seq_Cst",
}; };
gb_global Type *t_atomic_memory_order = nullptr; gb_global Type *t_atomic_memory_order = nullptr;