Home
last modified time | relevance | path

Searched full:atomic (Results 1 – 25 of 1514) sorted by relevance

12345678910>>...61

/freebsd/contrib/llvm-project/libcxx/include/
H A Datomic14 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 Daliases.h12 #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 Datomic.h36 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() argument
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 DATOMIC_VAR_INIT.342 .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 DWebAssemblyInstrAtomics.td1 // 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 Datomic.939 .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 Dcpuset.9148 macro is identical, but the bit representing the CPU is cleared with atomic
166 with atomic store with release semantics.
171 performs multiple individually atomic operations.)
182 macro is identical, but the bit representing the CPU is set with atomic
186 macro sets the bit representing the CPU with atomic acquire semantics.
305 with atomic machine instructions.
310 performs multiple individually atomic operations.)
338 is similar, with the same atomic semantics as
/freebsd/contrib/ofed/opensm/include/complib/
H A Dcl_atomic.h38 * 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 Dlac_lock_free_stack.h12 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/contrib/llvm-project/llvm/include/llvm/CodeGen/
H A DMachineMemOperand.h160 /// 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 Datomic.c1 //===-- 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/secure/lib/libcrypto/man/man3/
H A DCRYPTO_THREAD_run_once.3137 result of the operation in \fI*ret\fR. \fIlock\fR will be locked, unless atomic
140 be the only way that the variable is modified. If atomic operations are not
144 result of the operation in \fI*ret\fR. \fIlock\fR will be locked, unless atomic
147 be the only way that the variable is modified. If atomic operations are not
150 \&\fBCRYPTO_atomic_and()\fR performs an atomic bitwise and of \fIop\fR and \fI*val\fR and stores
152 \&\fI*ret\fR. \fIlock\fR will be locked, unless atomic operations are supported on the
155 be the only way that the variable is modified. If atomic operations are not
158 \&\fBCRYPTO_atomic_or()\fR performs an atomic bitwise or of \fIop\fR and \fI*val\fR and stores
160 \&\fI*ret\fR. \fIlock\fR will be locked, unless atomic operations are supported on the
163 be the only way that the variable is modified. If atomic operations are not
[all …]
/freebsd/contrib/llvm-project/llvm/lib/Target/AMDGPU/
H A DAMDGPUAtomicOptimizer.cpp10 /// 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/crypto/openssl/doc/man3/
H A DCRYPTO_THREAD_run_once.pod94 result of the operation in I<*ret>. I<lock> will be locked, unless atomic
97 be the only way that the variable is modified. If atomic operations are not
103 result of the operation in I<*ret>. I<lock> will be locked, unless atomic
106 be the only way that the variable is modified. If atomic operations are not
111 CRYPTO_atomic_and() performs an atomic bitwise and of I<op> and I<*val> and stores
113 I<*ret>. I<lock> will be locked, unless atomic operations are supported on the
116 be the only way that the variable is modified. If atomic operations are not
121 CRYPTO_atomic_or() performs an atomic bitwise or of I<op> and I<*val> and stores
123 I<*ret>. I<lock> will be locked, unless atomic operations are supported on the
126 be the only way that the variable is modified. If atomic operations are not
[all …]
/freebsd/contrib/jemalloc/include/jemalloc/internal/
H A Dprng.h67 prng_lg_range_u32(atomic_u32_t * state,unsigned lg_range,bool atomic) prng_lg_range_u32() argument
104 prng_lg_range_zu(atomic_zu_t * state,unsigned lg_range,bool atomic) prng_lg_range_zu() argument
132 prng_range_u32(atomic_u32_t * state,uint32_t range,bool atomic) prng_range_u32() argument
168 prng_range_zu(atomic_zu_t * state,size_t range,bool atomic) prng_range_zu() argument
H A Darena_structs_b.h
/freebsd/contrib/llvm-project/llvm/lib/Transforms/Utils/
H A DMemoryOpRemark.cpp84 // * 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/lldb/include/lldb/Utility/
H A DTimer.h14 #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/clang/lib/CodeGen/
H A DCGAtomic.cpp1 //===--- 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/sys/dev/qat/qat_api/common/include/
H A Dlac_sal_types_crypto.h56 /**< 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/compiler-rt/lib/xray/
H A Dxray_x86_64.cpp16 #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 DSemaConcept.h61 // - 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 Dibv_query_device.342 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 Datomic_unique_lock.h15 #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 DLowerAtomicPass.h1 //===- 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.

12345678910>>...61