| /freebsd/contrib/llvm-project/libcxx/include/ |
| H A D | atomic | 14 atomic synopsis
62 struct atomic
70 atomic() noexcept = default; // until C++20
71 constexpr atomic() noexcept(is_nothrow_default_constructible_v<T>); // since C++20
72 constexpr atomic(T desr) noexcept;
73 atomic(const atomic&) = delete;
74 atomic& operator=(const atomic&) = delete;
75 atomic& operator=(const atomic&) volatile = delete;
113 struct atomic<integral>
122 atomic() noexcept = default;
[all …]
|
| /freebsd/contrib/llvm-project/libcxx/include/__atomic/ |
| H A D | aliases.h | 12 #include <__atomic/atomic.h>
28 using atomic_bool = atomic<bool>;
29 using atomic_char = atomic<char>;
30 using atomic_schar = atomic<signed char>;
31 using atomic_uchar = atomic<unsigned char>;
32 using atomic_short = atomic<short>;
33 using atomic_ushort = atomic<unsigned short>;
34 using atomic_int = atomic<int>;
35 using atomic_uint = atomic<unsigned int>;
36 using atomic_long = atomic<long>;
[all …]
|
| H A D | atomic.h | 36 struct atomic : public __atomic_base<_Tp> { struct
42 _LIBCPP_HIDE_FROM_ABI atomic() = default; argument
44 _LIBCPP_HIDE_FROM_ABI atomic() _NOEXCEPT = default;
47 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR atomic(_Tp __d) _NOEXCEPT : __base(__d) {} in atomic() function
58 atomic& operator=(const atomic&) = delete; argument
59 atomic& operator=(const atomic&) volatile = delete; argument
62 // atomic<T*>
65 struct atomic<_Tp*> : public __atomic_base<_Tp*> {
70 _LIBCPP_HIDE_FROM_ABI atomic() _NOEXCEPT = default;
72 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR atomic(_Tp* __d) _NOEXCEPT : __base(__d) {}
[all …]
|
| /freebsd/share/man/man3/ |
| H A D | ATOMIC_VAR_INIT.3 | 42 .Nd type-generic atomic operations
96 provides type-generic macros for atomic operations.
97 Atomic operations can be used by multithreaded programs to provide
101 Atomic variables are declared using the
104 These variables are not type-compatible with their non-atomic
106 Depending on the compiler used, atomic variables may be opaque and can
111 macro initializes the atomic variable
115 Atomic variables can be initialized while being declared using
120 macro returns the value of atomic variable
124 macro sets the atomic variable
[all …]
|
| /freebsd/contrib/llvm-project/llvm/lib/Target/WebAssembly/ |
| H A D | WebAssemblyInstrAtomics.td | 1 // WebAssemblyInstrAtomics.td-WebAssembly Atomic codegen support-*- tablegen -*-
10 /// WebAssembly Atomic operand code-gen constructs.
32 // Atomic wait / notify
40 "memory.atomic.notify \t$dst, ${off}(${addr})${p2align}, $count",
41 "memory.atomic.notify \t${off}${p2align}", 0x00, false>;
46 "memory.atomic.notify \t$dst, ${off}(${addr})${p2align}, $count",
47 "memory.atomic.notify \t${off}${p2align}", 0x00, true>;
54 "memory.atomic.wait32 \t$dst, ${off}(${addr})${p2align}, $exp, $timeout",
55 "memory.atomic.wait32 \t${off}${p2align}", 0x01, false>;
61 "memory.atomic.wait32 \t$dst, ${off}(${addr})${p2align}, $exp, $timeout",
[all …]
|
| /freebsd/share/man/man9/ |
| H A D | atomic.9 | 39 .Nd atomic operations
81 Atomic operations are commonly used to implement reference counts and as
93 inherently atomic if the integer is naturally aligned and its size does not
96 the compiler, whereas atomic operations are always performed.
98 When atomic operations are performed on cache-coherent memory, all
101 When an atomic load is performed on a location in cache-coherent memory,
102 it reads the entire value that was defined by the last atomic store to
104 An atomic load will never return a value out of thin air.
105 When an atomic store is performed on a location, no other thread or
111 identical to the semantics of similarly named C11 atomic operations.
[all …]
|
| H A D | cpuset.9 | 144 macro is identical, but the bit representing the CPU is cleared with atomic
158 with atomic store with release semantics.
163 performs multiple individually atomic operations.)
174 macro is identical, but the bit representing the CPU is set with atomic
178 macro sets the bit representing the CPU with atomic acquire semantics.
293 with atomic machine instructions.
298 performs multiple individually atomic operations.)
326 is similar, with the same atomic semantics as
|
| /freebsd/contrib/ofed/opensm/include/complib/ |
| H A D | cl_atomic.h | 38 * Declaration of atomic manipulation functions.
55 /****h* Component Library/Atomic Operations
57 * Atomic Operations
60 * The Atomic Operations functions allow callers to operate on
61 * 32-bit signed integers in an atomic fashion.
63 /****f* Component Library: Atomic Operations/cl_atomic_inc
83 * The provided value is incremented and its value returned in one atomic
90 * Atomic Operations, cl_atomic_dec, cl_atomic_add, cl_atomic_sub
93 /****f* Component Library: Atomic Operations/cl_atomic_dec
113 * The provided value is decremented and its value returned in one atomic
[all …]
|
| /freebsd/sys/dev/qat/qat_api/common/utils/ |
| H A D | lac_lock_free_stack.h | 12 uint64_t atomic; member
41 old_top.atomic = stack->top.atomic; in pop()
48 } while (!__sync_bool_compare_and_swap(&stack->top.atomic, in pop()
49 old_top.atomic, in pop()
50 new_top.atomic)); in pop()
62 old_top.atomic = stack->top.atomic; in push()
66 } while (!__sync_bool_compare_and_swap(&stack->top.atomic, in push()
67 old_top.atomic, in push()
68 new_top.atomic)); in push()
|
| /freebsd/sys/dev/qat/qat_api/common/include/ |
| H A D | lac_sal_types_crypto.h | 56 /**< pointer to an array of atomic stats for symmetric */
59 /**< pointer to an array of atomic stats for key */
62 /**< pointer to an array of atomic stats for DH */
65 /**< pointer to an array of atomic stats for Dsa */
68 /**< pointer to an array of atomic stats for Rsa */
71 /**< pointer to an array of atomic stats for Ecc */
74 /**< pointer to an array of atomic stats for Ecc DH */
77 /**< pointer to an array of atomic stats for Ecc DSA */
80 /**< pointer to an array of atomic stats for prime */
83 /**< pointer to an array of atomic stats for large number */
[all …]
|
| /freebsd/contrib/llvm-project/llvm/include/llvm/CodeGen/ |
| H A D | MachineMemOperand.h | 160 /// Atomic information for this memory operation.
164 /// Atomic ordering requirements for this memory operation. For cmpxchg
165 /// atomic operations, atomic ordering requirements when store occurs.
167 /// For cmpxchg atomic operations, atomic ordering requirements when store
186 /// size, and base alignment. For atomic operations the synchronization scope
187 /// and atomic ordering requirements must also be specified. For cmpxchg
188 /// atomic operations the atomic ordering requirements when store does not
275 /// Return the atomic ordering requirements for this memory operation. For
276 /// cmpxchg atomic operations, return the atomic ordering requirements when
282 /// For cmpxchg atomic operations, return the atomic ordering requirements
[all …]
|
| /freebsd/contrib/llvm-project/compiler-rt/lib/builtins/ |
| H A D | atomic.c | 1 //===-- atomic.c - Implement support functions for atomic operations.------===//
9 // atomic.c defines a set of functions for performing atomic accesses on
16 // 2) Atomic operations, rather than explicit mutexes, are most commonly used
21 // For operations that must be atomic on two locations, the lower lock is
66 /// locks for atomic operations
73 #include <machine/atomic.h>
92 /// locks for atomic operations
120 /// locks for atomic operations
134 // get collisions from atomic fields in a single object in lock_for_pointer()
178 /// Whether atomic operations for the given size (and alignment) are lock-free.
[all …]
|
| /freebsd/contrib/llvm-project/llvm/lib/Target/AMDGPU/ |
| H A D | AMDGPUAtomicOptimizer.cpp | 10 /// This pass optimizes atomic operations by using a single lane of a wavefront
11 /// to perform the atomic operation, thus reducing contention on that memory
13 /// Atomic optimizer uses following strategies to compute scan and reduced
36 #define DEBUG_TYPE "amdgpu-atomic-optimizer"
196 // Early exit for unhandled address space atomic instructions. in visitAtomicRMWInst()
226 // Only 32 and 64 bit floating point atomic ops are supported. in visitAtomicRMWInst()
235 // If the pointer operand is divergent, then each lane is doing an atomic in visitAtomicRMWInst()
244 // value to the atomic calculation. We can only optimize divergent values if in visitAtomicRMWInst()
245 // we have DPP available on our subtarget (for DPP strategy), and the atomic in visitAtomicRMWInst()
255 // If we get here, we can optimize the atomic using a single wavefront-wide in visitAtomicRMWInst()
[all …]
|
| /freebsd/contrib/jemalloc/include/jemalloc/internal/ |
| H A D | prng.h | 4 #include "jemalloc/internal/atomic.h"
62 * 2**lg_range). If atomic is true, they do so safely from multiple threads.
67 prng_lg_range_u32(atomic_u32_t *state, unsigned lg_range, bool atomic) { in prng_lg_range_u32() argument
75 if (atomic) { in prng_lg_range_u32()
104 prng_lg_range_zu(atomic_zu_t *state, unsigned lg_range, bool atomic) { in prng_lg_range_zu() argument
112 if (atomic) { in prng_lg_range_zu()
132 prng_range_u32(atomic_u32_t *state, uint32_t range, bool atomic) { in prng_range_u32() argument
143 ret = prng_lg_range_u32(state, lg_range, atomic); in prng_range_u32()
168 prng_range_zu(atomic_zu_t *state, size_t range, bool atomic) { in prng_range_zu() argument
179 ret = prng_lg_range_zu(state, lg_range, atomic); in prng_range_zu()
|
| H A D | arena_structs_b.h | 5 #include "jemalloc/internal/atomic.h"
18 /* Synchronizes all non-atomic fields. */
89 * Synchronization: atomic.
93 /* Next bin shard for binding new threads. Synchronization: atomic. */
124 * Synchronization: atomic.
131 * Synchronization: atomic.
138 * Synchronization: atomic.
145 * Synchronization: atomic.
|
| /freebsd/contrib/llvm-project/llvm/lib/Transforms/Utils/ |
| H A D | MemoryOpRemark.cpp | 84 // * volatile / atomic in visit()
129 bool Atomic, in inlineVolatileOrAtomicWithExtraArgs() argument
135 if (Atomic) in inlineVolatileOrAtomicWithExtraArgs()
136 R << " Atomic: " << NV("StoreAtomic", true) << "."; in inlineVolatileOrAtomicWithExtraArgs()
139 if ((Inline && !*Inline) || !Volatile || !Atomic) in inlineVolatileOrAtomicWithExtraArgs()
145 if (!Atomic) in inlineVolatileOrAtomicWithExtraArgs()
146 R << " Atomic: " << NV("StoreAtomic", false) << "."; in inlineVolatileOrAtomicWithExtraArgs()
171 bool Atomic = SI.isAtomic(); in visitStore() local
178 inlineVolatileOrAtomicWithExtraArgs(nullptr, Volatile, Atomic, *R); in visitStore()
190 bool Atomic = false; in visitIntrinsicCall() local
[all …]
|
| /freebsd/contrib/llvm-project/clang/lib/CodeGen/ |
| H A D | CGAtomic.cpp | 1 //===--- CGAtomic.cpp - Emit LLVM IR for atomic operations ----------------===//
9 // This file contains the code for emitting atomic operations.
167 /// Is the atomic size larger than the underlying value type?
169 /// Note that the absence of padding does not mean that atomic
170 /// objects are completely interchangeable with non-atomic
184 /// Cast the given pointer to an integer pointer suitable for atomic
188 /// If Addr is compatible with the iN that will be used for an atomic
193 /// Turn an atomic-layout object into an r-value.
206 /// Copy an atomic r-value into atomic-layout memory.
220 /// Emits atomic load.
[all …]
|
| /freebsd/contrib/llvm-project/lldb/include/lldb/Utility/ |
| H A D | Timer.h | 14 #include <atomic>
33 std::atomic<uint64_t> m_nanos;
34 std::atomic<uint64_t> m_nanos_total;
35 std::atomic<uint64_t> m_count;
36 std::atomic<Category *> m_next;
71 static std::atomic<bool> g_quiet;
72 static std::atomic<unsigned> g_display_depth;
|
| /freebsd/contrib/llvm-project/compiler-rt/lib/xray/ |
| H A D | xray_x86_64.cpp | 16 #include <atomic>
143 // 4. Do an atomic write over the jmp instruction for the "mov r10d" in patchFunctionEntry()
161 reinterpret_cast<std::atomic<uint16_t> *>(Address), MovR10Seq, in patchFunctionEntry()
165 reinterpret_cast<std::atomic<uint16_t> *>(Address), Jmp9Seq, in patchFunctionEntry()
189 // 4. Do an atomic write over the jmp instruction for the "mov r10d" in patchFunctionExit()
208 reinterpret_cast<std::atomic<uint16_t> *>(Address), MovR10Seq, in patchFunctionExit()
212 reinterpret_cast<std::atomic<uint8_t> *>(Address), RetOpCode, in patchFunctionExit()
238 reinterpret_cast<std::atomic<uint16_t> *>(Address), MovR10Seq, in patchFunctionTailExit()
242 reinterpret_cast<std::atomic<uint16_t> *>(Address), Jmp9Seq, in patchFunctionTailExit()
267 reinterpret_cast<std::atomic<uint16_t> *>(Address), NopwSeq, in patchCustomEvent()
[all …]
|
| /freebsd/contrib/llvm-project/clang/include/clang/Sema/ |
| H A D | SemaConcept.h | 61 // - an atomic constraint A subsumes another atomic constraint B in subsumes()
64 // C++ [temp.constr.atomic] p2 in subsumes()
65 // Two atomic constraints are identical if they are formed from the in subsumes()
89 // clauses where each clause is a disjunction of atomic constraints. For atomic
95 // clauses where each clause is a conjunction of atomic constraints. For atomic
103 /// either an atomic constraint, a conjunction of normalized constraints or a
153 "getAtomicConstraint called on non-atomic constraint."); in getAtomicConstraint()
206 // and only if there exists an atomic constraint Pia in Pi for which in subsumes()
207 // there exists an atomic constraint, Qjb, in Qj such that Pia in subsumes()
|
| /freebsd/contrib/ofed/libibverbs/man/ |
| H A D | ibv_query_device.3 | 42 int max_qp_rd_atom; /* Maximum number of RDMA Read & Atomic operations …
43 int max_ee_rd_atom; /* Maximum number of RDMA Read & Atomic operations …
44 …_res_rd_atom; /* Maximum number of resources used for RDMA Read & Atomic operations by this…
45 …max_qp_init_rd_atom; /* Maximum depth per QP for initiation of RDMA Read & Atomic operations */
46 …max_ee_init_rd_atom; /* Maximum depth per EEC for initiation of RDMA Read & Atomic operations */
47 enum ibv_atomic_cap atomic_cap; /* Atomic operations support level */
|
| /freebsd/contrib/llvm-project/libcxx/include/__stop_token/ |
| H A D | atomic_unique_lock.h | 15 #include <atomic>
26 // It uses std::atomic<State>,
34 std::atomic<_State>& __state_;
38 _LIBCPP_HIDE_FROM_ABI explicit __atomic_unique_lock(std::atomic<_State>& __state) noexcept in __atomic_unique_lock()
44 _LIBCPP_HIDE_FROM_ABI __atomic_unique_lock(std::atomic<_State>& __state, _Pred&& __give_up_locking) noexcept in __atomic_unique_lock()
51 std::atomic<_State>& __state, in __atomic_unique_lock()
95 // At this stage, until we exit the inner while loop, other than the atomic state, we are not reading any order in __lock_impl()
123 // Some use cases need to set other bits at the same time as an atomic in __lock_impl()
|
| /freebsd/contrib/llvm-project/llvm/include/llvm/Transforms/Scalar/ |
| H A D | LowerAtomicPass.h | 1 //===- LowerAtomicPass.h - Lower atomic intrinsics --------------*- C++ -*-===//
9 // This pass lowers atomic intrinsics to non-atomic form for use in a known
21 /// A pass that lowers atomic intrinsic into non-atomic intrinsics.
|
| /freebsd/contrib/libcxxrt/ |
| H A D | atomic.h | 45 * Atomic, implements a subset of `std::atomic`.
48 class atomic
51 * The underlying value. Use C11 atomic qualification if available.
59 constexpr atomic(T init) : val(init) {} in atomic() function
|
| H A D | guard.cc | 38 * platform that can do 32-bit atomic test and set operations can use this
44 #include "atomic.h"
104 * Class encapsulating a single atomic word being used to represent the
128 atomic<GuardWord> val;
182 * Class encapsulating using two 32-bit atomic values to represent a 64-bit
205 atomic<uint32_t> init_word;
210 atomic<uint32_t> lock_word;
226 // this version, we don't have atomic manipulation of both the in try_lock()
245 * implementation, this is ordered, not atomic: the initialise bit is
283 * atomic with the lock in the high bit and the initialised flag in the low
[all …]
|