Home
last modified time | relevance | path

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

12345678910>>...67

/freebsd/contrib/llvm-project/libcxx/include/__cxx03/
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/
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/__cxx03/__atomic/
H A Daliases.h12 #include <__cxx03/__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
41 _LIBCPP_HIDE_FROM_ABI atomic() _NOEXCEPT = default; argument
43 _LIBCPP_HIDE_FROM_ABI atomic(_Tp __d) _NOEXCEPT : __base(__d) {} in atomic() function
54 atomic& operator=(const atomic&) = delete; argument
55 atomic& operator=(const atomic&) volatile = delete; argument
58 // atomic<T*>
61 struct atomic<_Tp*> : public __atomic_base<_Tp*> {
66 _LIBCPP_HIDE_FROM_ABI atomic() _NOEXCEPT = default;
68 _LIBCPP_HIDE_FROM_ABI atomic(_Tp* __d) _NOEXCEPT : __base(__d) {}
116 atomic& operator=(const atomic&) = delete;
[all …]
/freebsd/contrib/llvm-project/libcxx/include/__atomic/
H A Daliases.h12 #include <__atomic/atomic.h>
29 using atomic_bool = atomic<bool>;
30 using atomic_char = atomic<char>;
31 using atomic_schar = atomic<signed char>;
32 using atomic_uchar = atomic<unsigned char>;
33 using atomic_short = atomic<short>;
34 using atomic_ushort = atomic<unsigned short>;
35 using atomic_int = atomic<int>;
36 using atomic_uint = atomic<unsigned int>;
37 using atomic_long = atomic<long>;
[all …]
H A Datomic.h145 // atomic<Integral>
237 …static_assert(is_trivially_copyable<_Tp>::value, "std::atomic<T> requires that 'T' be a trivially …
241 struct atomic : public __atomic_base<typename __check_atomic_mandates<_Tp>::type> {
245 _LIBCPP_HIDE_FROM_ABI atomic() = default;
247 _LIBCPP_HIDE_FROM_ABI atomic() _NOEXCEPT = default;
250 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR atomic(_Tp __d) _NOEXCEPT : __base(__d) {}
261 atomic& operator=(const atomic&) = delete;
262 atomic& operator=(const atomic&) volatile = delete;
265 // atomic<T*>
268 struct atomic<_Tp*> : public __atomic_base<_Tp*> {
[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/contrib/llvm-project/clang/lib/Tooling/Inclusions/Stdlib/
H A DStdSpecialSymbolMap.inc282 // Only add headers for the generic atomic template.
284 SYMBOL(atomic, std::, <atomic>)
286 SYMBOL(atomic_bool, std::, <atomic>)
287 SYMBOL(atomic_bool, None, <atomic>)
289 SYMBOL(atomic_char, std::, <atomic>)
290 SYMBOL(atomic_char, None, <atomic>)
292 SYMBOL(atomic_char16_t, std::, <atomic>)
293 SYMBOL(atomic_char16_t, None, <atomic>)
295 SYMBOL(atomic_char32_t, std::, <atomic>)
296 SYMBOL(atomic_char32_t, None, <atomic>)
[all …]
/freebsd/share/man/man9/
H A Datomic.942 .Nd atomic operations
84 Atomic operations are commonly used to implement reference counts and as
96 inherently atomic if the integer is naturally aligned and its size does not
99 the compiler, whereas atomic operations are always performed.
101 When atomic operations are performed on cache-coherent memory, all
104 When an atomic load is performed on a location in cache-coherent memory,
105 it reads the entire value that was defined by the last atomic store to
107 An atomic load will never return a value out of thin air.
108 When an atomic store is performed on a location, no other thread or
114 identical to the semantics of similarly named C11 atomic operations.
[all …]
/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/contrib/llvm-project/libc/src/__support/CPP/
H A Datomic.h1 //===-- A simple equivalent of std::atomic ----------------------*- C++ -*-===//
33 // https://clang.llvm.org/docs/LanguageExtensions.html#scoped-atomic-builtins.
66 template <typename T> struct Atomic { struct
70 "atomic<T> requires T to be trivially copyable, copy "
75 "atomic<T> in libc only support types whose values has unique "
95 // we need pointers to the memory of the atomic values. Load and store
96 // operations should be performed using the atomic methods however.
99 LIBC_INLINE constexpr Atomic() = default; argument
101 // Initializes the value without using atomic operations.
102 LIBC_INLINE constexpr Atomic(value_type v) : val(v) {} in Atomic() function
[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"
183 // Early exit for unhandled address space atomic instructions. in visitAtomicRMWInst()
213 // Only 32 and 64 bit floating point atomic ops are supported. in visitAtomicRMWInst()
222 // If the pointer operand is divergent, then each lane is doing an atomic in visitAtomicRMWInst()
231 // value to the atomic calculation. We can only optimize divergent values if in visitAtomicRMWInst()
232 // we have DPP available on our subtarget (for DPP strategy), and the atomic in visitAtomicRMWInst()
242 // If we get here, we can optimize the atomic using a single wavefront-wide in visitAtomicRMWInst()
[all …]
/freebsd/contrib/llvm-project/llvm/include/llvm/CodeGen/
H A DMachineMemOperand.h162 /// Atomic information for this memory operation.
166 /// Atomic ordering requirements for this memory operation. For cmpxchg
167 /// atomic operations, atomic ordering requirements when store occurs.
169 /// For cmpxchg atomic operations, atomic ordering requirements when store
188 /// size, and base alignment. For atomic operations the synchronization scope
189 /// and atomic ordering requirements must also be specified. For cmpxchg
190 /// atomic operations the atomic ordering requirements when store does not
279 /// Return the atomic ordering requirements for this memory operation. For
280 /// cmpxchg atomic operations, return the atomic ordering requirements when
286 /// 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.3140 result of the operation in \fI*ret\fR. \fIlock\fR will be locked, unless atomic
143 be the only way that the variable is modified. If atomic operations are not
147 result of the operation in \fI*ret\fR. \fIlock\fR will be locked, unless atomic
150 be the only way that the variable is modified. If atomic operations are not
153 \&\fBCRYPTO_atomic_and()\fR performs an atomic bitwise and of \fIop\fR and \fI*val\fR and stores
155 \&\fI*ret\fR. \fIlock\fR will be locked, unless atomic operations are supported on the
158 be the only way that the variable is modified. If atomic operations are not
161 \&\fBCRYPTO_atomic_or()\fR performs an atomic bitwise or of \fIop\fR and \fI*val\fR and stores
163 \&\fI*ret\fR. \fIlock\fR will be locked, unless atomic operations are supported on the
166 be the only way that the variable is modified. If atomic operations are not
[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/sys/compat/linuxkpi/common/include/linux/
H A Datomic.h30 #include <asm/atomic.h>
32 #include <linux/atomic/atomic-arch-fallback.h>
33 #include <asm/atomic-long.h>
34 #include <linux/atomic/atomic-instrumented.h>
/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
/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.
166 /// Is the atomic size larger than the underlying value type?
168 /// Note that the absence of padding does not mean that atomic
169 /// objects are completely interchangeable with non-atomic
183 /// Cast the given pointer to an integer pointer suitable for atomic
187 /// If Addr is compatible with the iN that will be used for an atomic
192 /// Turn an atomic-layout object into an r-value.
205 /// Copy an atomic r-value into atomic-layout memory.
219 /// Emits atomic load.
[all …]
/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/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/sys/dev/qat/qat_api/common/utils/
H A Dlac_lock_free_stack.h18 atomic_int atomic; member
53 old_top.atomic = stack->top.atomic; in pop()
72 old_top.atomic = stack->top.atomic; in push()
82 lock_free_stack_t stack = { .top.atomic = 0 }; in _init_stack()
/freebsd/contrib/llvm-project/compiler-rt/lib/xray/
H A Dxray_x86_64.cpp16 #include <atomic>
144 // 4. Do an atomic write over the jmp instruction for the "mov r10d" in patchFunctionEntry()
164 reinterpret_cast<std::atomic<uint16_t> *>(Address), MovR10Seq, in patchFunctionEntry()
168 reinterpret_cast<std::atomic<uint16_t> *>(Address), Jmp9Seq, in patchFunctionEntry()
193 // 4. Do an atomic write over the jmp instruction for the "mov r10d" in patchFunctionExit()
213 reinterpret_cast<std::atomic<uint16_t> *>(Address), MovR10Seq, in patchFunctionExit()
217 reinterpret_cast<std::atomic<uint8_t> *>(Address), RetOpCode, in patchFunctionExit()
244 reinterpret_cast<std::atomic<uint16_t> *>(Address), MovR10Seq, in patchFunctionTailExit()
248 reinterpret_cast<std::atomic<uint16_t> *>(Address), Jmp9Seq, in patchFunctionTailExit()
273 reinterpret_cast<std::atomic<uint16_t> *>(Address), NopwSeq, in patchCustomEvent()
[all …]

12345678910>>...67