ed/Odin
1
0
Fork 0
mirror of https://github.com/Ed94/Odin.git synced 2026-07-28 18:30:06 +00:00
Code Issues Packages Projects Releases Wiki Activity

Move atomic intrinsics to the new built-in package intrinsics

Browse Source
This commit is contained in:
gingerBill
2018-10-20 10:44:02 +01:00
parent 4ac1218bf8
commit 3742d9e7e9
8 changed files with 209 additions and 174 deletions
Download Patch File Download Diff File Expand all files Collapse all files
core/sync/atomic.odin
+63 -61
View File
@@ -1,5 +1,7 @@
package sync
import "intrinsics"
Ordering :: enum {
Relaxed, // Monotonic
Release,
@@ -11,10 +13,10 @@ Ordering :: enum {
strongest_failure_ordering :: inline proc "contextless" (order: Ordering) -> Ordering {
using Ordering;
#complete switch order {
case Relaxed: return Relaxed;
case Release: return Relaxed;
case Acquire: return Acquire;
case Acquire_Release: return Acquire;
case Relaxed: return Relaxed;
case Release: return Relaxed;
case Acquire: return Acquire;
case Acquire_Release: return Acquire;
case Sequentially_Consistent: return Sequentially_Consistent;
}
return Relaxed;
@@ -23,11 +25,11 @@ strongest_failure_ordering :: inline proc "contextless" (order: Ordering) -> Ord
fence :: proc "contextless" (order: Ordering) {
using Ordering;
#complete switch order {
case Relaxed: panic("there is no such thing as a relaxed fence");
case Release: __atomic_fence_rel();
case Acquire: __atomic_fence_acq();
case Acquire_Release: __atomic_fence_acqrel();
case Sequentially_Consistent: __atomic_fence();
case Relaxed: panic("there is no such thing as a relaxed fence");
case Release: intrinsics.atomic_fence_rel();
case Acquire: intrinsics.atomic_fence_acq();
case Acquire_Release: intrinsics.atomic_fence_acqrel();
case Sequentially_Consistent: intrinsics.atomic_fence();
case: panic("unknown order");
}
}
@@ -36,10 +38,10 @@ fence :: proc "contextless" (order: Ordering) {
atomic_store :: proc "contextless" (dst: ^$T, val: T, order: Ordering) {
using Ordering;
#complete switch order {
case Relaxed: __atomic_store_relaxed(dst, val);
case Release: __atomic_store_rel(dst, val);
case Sequentially_Consistent: __atomic_store(dst, val);
case Acquire: panic("there is not such thing as an acquire store");
case Relaxed: intrinsics.atomic_store_relaxed(dst, val);
case Release: intrinsics.atomic_store_rel(dst, val);
case Sequentially_Consistent: intrinsics.atomic_store(dst, val);
case Acquire: panic("there is not such thing as an acquire store");
case Acquire_Release: panic("there is not such thing as an acquire/release store");
case: panic("unknown order");
}
@@ -48,10 +50,10 @@ atomic_store :: proc "contextless" (dst: ^$T, val: T, order: Ordering) {
atomic_load :: proc "contextless" (dst: ^$T, order: Ordering) -> T {
using Ordering;
#complete switch order {
case Relaxed: return __atomic_load_relaxed(dst);
case Acquire: return __atomic_load_acq(dst);
case Sequentially_Consistent: return __atomic_load(dst);
case Release: panic("there is no such thing as a release load");
case Relaxed: return intrinsics.atomic_load_relaxed(dst);
case Acquire: return intrinsics.atomic_load_acq(dst);
case Sequentially_Consistent: return intrinsics.atomic_load(dst);
case Release: panic("there is no such thing as a release load");
case Acquire_Release: panic("there is no such thing as an acquire/release load");
}
panic("unknown order");
@@ -61,11 +63,11 @@ atomic_load :: proc "contextless" (dst: ^$T, order: Ordering) -> T {
atomic_swap :: proc "contextless" (dst: ^$T, val: T, order: Ordering) -> T {
using Ordering;
#complete switch order {
case Relaxed: return __atomic_xchg_relaxed(dst, val);
case Release: return __atomic_xchg_rel(dst, val);
case Acquire: return __atomic_xchg_acq(dst, val);
case Acquire_Release: return __atomic_xchg_acqrel(dst, val);
case Sequentially_Consistent: return __atomic_xchg(dst, val);
case Relaxed: return intrinsics.atomic_xchg_relaxed(dst, val);
case Release: return intrinsics.atomic_xchg_rel(dst, val);
case Acquire: return intrinsics.atomic_xchg_acq(dst, val);
case Acquire_Release: return intrinsics.atomic_xchg_acqrel(dst, val);
case Sequentially_Consistent: return intrinsics.atomic_xchg(dst, val);
}
panic("unknown order");
return T{};
@@ -76,23 +78,23 @@ atomic_compare_exchange :: proc "contextless" (dst: ^$T, old, new: T, success, f
switch failure {
case Relaxed:
switch success {
case Release: return __atomic_cxchg_rel_failrelaxed(dst, old, new);
case Relaxed: return __atomic_cxchg_relaxed(dst, old, new);
case Acquire: return __atomic_cxchg_acq_failrelaxed(dst, old, new);
case Acquire_Release: return __atomic_cxchg_acqrel_failrelaxed(dst, old, new);
case Sequentially_Consistent: return __atomic_cxchg_failrelaxed(dst, old, new);
case Release: return intrinsics.atomic_cxchg_rel_failrelaxed(dst, old, new);
case Relaxed: return intrinsics.atomic_cxchg_relaxed(dst, old, new);
case Acquire: return intrinsics.atomic_cxchg_acq_failrelaxed(dst, old, new);
case Acquire_Release: return intrinsics.atomic_cxchg_acqrel_failrelaxed(dst, old, new);
case Sequentially_Consistent: return intrinsics.atomic_cxchg_failrelaxed(dst, old, new);
case: panic("an unknown ordering combination");
}
case Acquire:
switch success {
case Acquire: return __atomic_cxchg_acq(dst, old, new);
case Acquire_Release: return __atomic_cxchg_acqrel_failacq(dst, old, new);
case Sequentially_Consistent: return __atomic_acqrel_failacq(dst, old, new);
case Acquire: return intrinsics.atomic_cxchg_acq(dst, old, new);
case Acquire_Release: return intrinsics.atomic_cxchg_acqrel_failacq(dst, old, new);
case Sequentially_Consistent: return intrinsics.atomic_acqrel_failacq(dst, old, new);
case: panic("an unknown ordering combination");
}
case Sequentially_Consistent:
switch success {
case Sequentially_Consistent: return __atomic_cxchg(dst, old, new);
case Sequentially_Consistent: return intrinsics.atomic_cxchg(dst, old, new);
case: panic("an unknown ordering combination");
}
case Acquire_Release:
@@ -108,11 +110,11 @@ atomic_compare_exchange :: proc "contextless" (dst: ^$T, old, new: T, success, f
atomic_add :: proc "contextless" (dst: ^$T, val: T, order: Ordering) -> T {
using Ordering;
#complete switch order {
case Relaxed: return __atomic_add_relaxed(dst, val);
case Release: return __atomic_add_rel(dst, val);
case Acquire: return __atomic_add_acq(dst, val);
case Acquire_Release: return __atomic_add_acqrel(dst, val);
case Sequentially_Consistent: return __atomic_add(dst, val);
case Relaxed: return intrinsics.atomic_add_relaxed(dst, val);
case Release: return intrinsics.atomic_add_rel(dst, val);
case Acquire: return intrinsics.atomic_add_acq(dst, val);
case Acquire_Release: return intrinsics.atomic_add_acqrel(dst, val);
case Sequentially_Consistent: return intrinsics.atomic_add(dst, val);
}
panic("unknown order");
return T{};
@@ -121,11 +123,11 @@ atomic_add :: proc "contextless" (dst: ^$T, val: T, order: Ordering) -> T {
atomic_sub :: proc "contextless" (dst: ^$T, val: T, order: Ordering) -> T {
using Ordering;
#complete switch order {
case Relaxed: return __atomic_sub_relaxed(dst, val);
case Release: return __atomic_sub_rel(dst, val);
case Acquire: return __atomic_sub_acq(dst, val);
case Acquire_Release: return __atomic_sub_acqrel(dst, val);
case Sequentially_Consistent: return __atomic_sub(dst, val);
case Relaxed: return intrinsics.atomic_sub_relaxed(dst, val);
case Release: return intrinsics.atomic_sub_rel(dst, val);
case Acquire: return intrinsics.atomic_sub_acq(dst, val);
case Acquire_Release: return intrinsics.atomic_sub_acqrel(dst, val);
case Sequentially_Consistent: return intrinsics.atomic_sub(dst, val);
}
panic("unknown order");
return T{};
@@ -134,11 +136,11 @@ atomic_sub :: proc "contextless" (dst: ^$T, val: T, order: Ordering) -> T {
atomic_and :: proc "contextless" (dst: ^$T, val: T, order: Ordering) -> T {
using Ordering;
#complete switch order {
case Relaxed: return __atomic_and_relaxed(dst, val);
case Release: return __atomic_and_rel(dst, val);
case Acquire: return __atomic_and_acq(dst, val);
case Acquire_Release: return __atomic_and_acqrel(dst, val);
case Sequentially_Consistent: return __atomic_and(dst, val);
case Relaxed: return intrinsics.atomic_and_relaxed(dst, val);
case Release: return intrinsics.atomic_and_rel(dst, val);
case Acquire: return intrinsics.atomic_and_acq(dst, val);
case Acquire_Release: return intrinsics.atomic_and_acqrel(dst, val);
case Sequentially_Consistent: return intrinsics.atomic_and(dst, val);
}
panic("unknown order");
return T{};
@@ -147,11 +149,11 @@ atomic_and :: proc "contextless" (dst: ^$T, val: T, order: Ordering) -> T {
atomic_nand :: proc "contextless" (dst: ^$T, val: T, order: Ordering) -> T {
using Ordering;
#complete switch order {
case Relaxed: return __atomic_nand_relaxed(dst, val);
case Release: return __atomic_nand_rel(dst, val);
case Acquire: return __atomic_nand_acq(dst, val);
case Acquire_Release: return __atomic_nand_acqrel(dst, val);
case Sequentially_Consistent: return __atomic_nand(dst, val);
case Relaxed: return intrinsics.atomic_nand_relaxed(dst, val);
case Release: return intrinsics.atomic_nand_rel(dst, val);
case Acquire: return intrinsics.atomic_nand_acq(dst, val);
case Acquire_Release: return intrinsics.atomic_nand_acqrel(dst, val);
case Sequentially_Consistent: return intrinsics.atomic_nand(dst, val);
}
panic("unknown order");
return T{};
@@ -160,11 +162,11 @@ atomic_nand :: proc "contextless" (dst: ^$T, val: T, order: Ordering) -> T {
atomic_or :: proc "contextless" (dst: ^$T, val: T, order: Ordering) -> T {
using Ordering;
#complete switch order {
case Relaxed: return __atomic_or_relaxed(dst, val);
case Release: return __atomic_or_rel(dst, val);
case Acquire: return __atomic_or_acq(dst, val);
case Acquire_Release: return __atomic_or_acqrel(dst, val);
case Sequentially_Consistent: return __atomic_or(dst, val);
case Relaxed: return intrinsics.atomic_or_relaxed(dst, val);
case Release: return intrinsics.atomic_or_rel(dst, val);
case Acquire: return intrinsics.atomic_or_acq(dst, val);
case Acquire_Release: return intrinsics.atomic_or_acqrel(dst, val);
case Sequentially_Consistent: return intrinsics.atomic_or(dst, val);
}
panic("unknown order");
return T{};
@@ -173,11 +175,11 @@ atomic_or :: proc "contextless" (dst: ^$T, val: T, order: Ordering) -> T {
atomic_xor :: proc "contextless" (dst: ^$T, val: T, order: Ordering) -> T {
using Ordering;
#complete switch order {
case Relaxed: return __atomic_xor_relaxed(dst, val);
case Release: return __atomic_xor_rel(dst, val);
case Acquire: return __atomic_xor_acq(dst, val);
case Acquire_Release: return __atomic_xor_acqrel(dst, val);
case Sequentially_Consistent: return __atomic_xor(dst, val);
case Relaxed: return intrinsics.atomic_xor_relaxed(dst, val);
case Release: return intrinsics.atomic_xor_rel(dst, val);
case Acquire: return intrinsics.atomic_xor_acq(dst, val);
case Acquire_Release: return intrinsics.atomic_xor_acqrel(dst, val);
case Sequentially_Consistent: return intrinsics.atomic_xor(dst, val);
}
panic("unknown order");
return T{};