Perform the operation return the new value, all memory models are validPerform the operation return the old value, all memory models are valid
Types
AtomMemModel = distinct cint
- Source Edit
Vars
ATOMIC_ACQ_REL {.importc: "__ATOMIC_ACQ_REL", nodecl.}: AtomMemModel
- Full barrier in both directions and synchronizes with acquire loads and release stores in another thread. Source Edit
ATOMIC_ACQUIRE {.importc: "__ATOMIC_ACQUIRE", nodecl.}: AtomMemModel
- Barrier to hoisting of code and synchronizes with release (or stronger) semantic stores from another thread. Source Edit
ATOMIC_CONSUME {.importc: "__ATOMIC_CONSUME", nodecl.}: AtomMemModel
- Data dependency only for both barrier and synchronization with another thread. Source Edit
ATOMIC_RELAXED {.importc: "__ATOMIC_RELAXED", nodecl.}: AtomMemModel
- No barriers or synchronization. Source Edit
ATOMIC_RELEASE {.importc: "__ATOMIC_RELEASE", nodecl.}: AtomMemModel
- Barrier to sinking of code and synchronizes with acquire (or stronger) semantic loads from another thread. Source Edit
ATOMIC_SEQ_CST {.importc: "__ATOMIC_SEQ_CST", nodecl.}: AtomMemModel
- Full barrier in both directions and synchronizes with acquire loads and release stores in all threads. Source Edit
Procs
proc atomicAddFetch[T: AtomType](p: ptr T; val: T; mem: AtomMemModel): T {. importc: "__atomic_add_fetch", nodecl, ...raises: [], tags: [], forbids: [].}
- Source Edit
proc atomicAlwaysLockFree(size: int; p: pointer): bool {. importc: "__atomic_always_lock_free", nodecl, ...raises: [], tags: [], forbids: [].}
- This built-in function returns true if objects of size bytes always generate lock free atomic instructions for the target architecture. size must resolve to a compile-time constant and the result also resolves to a compile-time constant. ptr is an optional pointer to the object that may be used to determine alignment. A value of 0 indicates typical alignment should be used. The compiler may also ignore this parameter. Source Edit
proc atomicAndFetch[T: AtomType](p: ptr T; val: T; mem: AtomMemModel): T {. importc: "__atomic_and_fetch", nodecl, ...raises: [], tags: [], forbids: [].}
- Source Edit
proc atomicClear(p: pointer; mem: AtomMemModel) {.importc: "__atomic_clear", nodecl, ...raises: [], tags: [], forbids: [].}
- This built-in function performs an atomic clear operation at p. After the operation, at p contains 0. ATOMIC_RELAXED, ATOMIC_SEQ_CST, ATOMIC_RELEASE Source Edit
proc atomicCompareExchange[T: AtomType](p, expected, desired: ptr T; weak: bool; success_memmodel: AtomMemModel; failure_memmodel: AtomMemModel): bool {. importc: "__atomic_compare_exchange", nodecl, ...raises: [], tags: [], forbids: [].}
- This proc implements the generic version of atomic_compare_exchange. The proc is virtually identical to atomic_compare_exchange_n, except the desired value is also a pointer. Source Edit
proc atomicCompareExchangeN[T: AtomType](p, expected: ptr T; desired: T; weak: bool; success_memmodel: AtomMemModel; failure_memmodel: AtomMemModel): bool {. importc: "__atomic_compare_exchange_n", nodecl, ...raises: [], tags: [], forbids: [].}
- This proc implements an atomic compare and exchange operation. This compares the contents at p with the contents at expected and if equal, writes desired at p. If they are not equal, the current contents at p is written into expected. Weak is true for weak compare_exchange, and false for the strong variation. Many targets only offer the strong variation and ignore the parameter. When in doubt, use the strong variation. True is returned if desired is written at p and the execution is considered to conform to the memory model specified by success_memmodel. There are no restrictions on what memory model can be used here. False is returned otherwise, and the execution is considered to conform to failure_memmodel. This memory model cannot be __ATOMIC_RELEASE nor __ATOMIC_ACQ_REL. It also cannot be a stronger model than that specified by success_memmodel. Source Edit
proc atomicExchange[T: AtomType](p, val, ret: ptr T; mem: AtomMemModel) {. importc: "__atomic_exchange", nodecl, ...raises: [], tags: [], forbids: [].}
- This is the generic version of an atomic exchange. It stores the contents at val at p. The original value at p is copied into ret. Source Edit
proc atomicExchangeN[T: AtomType](p: ptr T; val: T; mem: AtomMemModel): T {. importc: "__atomic_exchange_n", nodecl, ...raises: [], tags: [], forbids: [].}
- This proc implements an atomic exchange operation. It writes val at p, and returns the previous contents at p. ATOMIC_RELAXED, ATOMIC_SEQ_CST, ATOMIC_ACQUIRE, ATOMIC_RELEASE, ATOMIC_ACQ_REL Source Edit
proc atomicFetchAdd[T: AtomType](p: ptr T; val: T; mem: AtomMemModel): T {. importc: "__atomic_fetch_add", nodecl, ...raises: [], tags: [], forbids: [].}
- Source Edit
proc atomicFetchAnd[T: AtomType](p: ptr T; val: T; mem: AtomMemModel): T {. importc: "__atomic_fetch_and", nodecl, ...raises: [], tags: [], forbids: [].}
- Source Edit
proc atomicFetchNand[T: AtomType](p: ptr T; val: T; mem: AtomMemModel): T {. importc: "__atomic_fetch_nand", nodecl, ...raises: [], tags: [], forbids: [].}
- Source Edit
proc atomicFetchOr[T: AtomType](p: ptr T; val: T; mem: AtomMemModel): T {. importc: "__atomic_fetch_or", nodecl, ...raises: [], tags: [], forbids: [].}
- Source Edit
proc atomicFetchSub[T: AtomType](p: ptr T; val: T; mem: AtomMemModel): T {. importc: "__atomic_fetch_sub", nodecl, ...raises: [], tags: [], forbids: [].}
- Source Edit
proc atomicFetchXor[T: AtomType](p: ptr T; val: T; mem: AtomMemModel): T {. importc: "__atomic_fetch_xor", nodecl, ...raises: [], tags: [], forbids: [].}
- Source Edit
proc atomicIsLockFree(size: int; p: pointer): bool {. importc: "__atomic_is_lock_free", nodecl, ...raises: [], tags: [], forbids: [].}
- This built-in function returns true if objects of size bytes always generate lock free atomic instructions for the target architecture. If it is not known to be lock free a call is made to a runtime routine named __atomic_is_lock_free. ptr is an optional pointer to the object that may be used to determine alignment. A value of 0 indicates typical alignment should be used. The compiler may also ignore this parameter. Source Edit
proc atomicLoad[T: AtomType](p, ret: ptr T; mem: AtomMemModel) {. importc: "__atomic_load", nodecl, ...raises: [], tags: [], forbids: [].}
- This is the generic version of an atomic load. It returns the contents at p in ret. Source Edit
proc atomicLoadN[T: AtomType](p: ptr T; mem: AtomMemModel): T {. importc: "__atomic_load_n", nodecl, ...raises: [], tags: [], forbids: [].}
- This proc implements an atomic load operation. It returns the contents at p. ATOMIC_RELAXED, ATOMIC_SEQ_CST, ATOMIC_ACQUIRE, ATOMIC_CONSUME. Source Edit
proc atomicNandFetch[T: AtomType](p: ptr T; val: T; mem: AtomMemModel): T {. importc: "__atomic_nand_fetch", nodecl, ...raises: [], tags: [], forbids: [].}
- Source Edit
proc atomicOrFetch[T: AtomType](p: ptr T; val: T; mem: AtomMemModel): T {. importc: "__atomic_or_fetch", nodecl, ...raises: [], tags: [], forbids: [].}
- Source Edit
proc atomicSignalFence(mem: AtomMemModel) {.importc: "__atomic_signal_fence", nodecl, ...raises: [], tags: [], forbids: [].}
- This built-in function acts as a synchronization fence between a thread and signal handlers based in the same thread. All memory orders are valid. Source Edit
proc atomicStore[T: AtomType](p, val: ptr T; mem: AtomMemModel) {. importc: "__atomic_store", nodecl, ...raises: [], tags: [], forbids: [].}
- This is the generic version of an atomic store. It stores the value of val at p Source Edit
proc atomicStoreN[T: AtomType](p: ptr T; val: T; mem: AtomMemModel) {. importc: "__atomic_store_n", nodecl, ...raises: [], tags: [], forbids: [].}
- This proc implements an atomic store operation. It writes val at p. ATOMIC_RELAXED, ATOMIC_SEQ_CST, and ATOMIC_RELEASE. Source Edit
proc atomicSubFetch[T: AtomType](p: ptr T; val: T; mem: AtomMemModel): T {. importc: "__atomic_sub_fetch", nodecl, ...raises: [], tags: [], forbids: [].}
- Source Edit
proc atomicTestAndSet(p: pointer; mem: AtomMemModel): bool {. importc: "__atomic_test_and_set", nodecl, ...raises: [], tags: [], forbids: [].}
- This built-in function performs an atomic test-and-set operation on the byte at p. The byte is set to some implementation defined nonzero "set" value and the return value is true if and only if the previous contents were "set". All memory models are valid. Source Edit
proc atomicThreadFence(mem: AtomMemModel) {.importc: "__atomic_thread_fence", nodecl, ...raises: [], tags: [], forbids: [].}
- This built-in function acts as a synchronization fence between threads based on the specified memory model. All memory orders are valid. Source Edit
proc atomicXorFetch[T: AtomType](p: ptr T; val: T; mem: AtomMemModel): T {. importc: "__atomic_xor_fetch", nodecl, ...raises: [], tags: [], forbids: [].}
- Source Edit