mirror of
https://github.com/boostorg/documentation-fixes.git
synced 2026-01-19 04:12:08 +00:00
1691 lines
90 KiB
HTML
1691 lines
90 KiB
HTML
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
|
|
<html>
|
|
<head>
|
|
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
|
|
<title>Programming interfaces</title>
|
|
<link rel="stylesheet" href="../../../doc/src/boostbook.css" type="text/css">
|
|
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
|
|
<link rel="home" href="../index.html" title="The Boost C++ Libraries BoostBook Documentation Subset">
|
|
<link rel="up" href="../atomic.html" title="Chapter 6. Boost.Atomic">
|
|
<link rel="prev" href="thread_coordination.html" title="Thread coordination using Boost.Atomic">
|
|
<link rel="next" href="usage_examples.html" title="Usage examples">
|
|
</head>
|
|
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
|
|
<table cellpadding="2" width="100%"><tr>
|
|
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../boost.png"></td>
|
|
<td align="center"><a href="../../../index.html">Home</a></td>
|
|
<td align="center"><a href="../../../libs/libraries.htm">Libraries</a></td>
|
|
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
|
|
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
|
|
<td align="center"><a href="../../../more/index.htm">More</a></td>
|
|
</tr></table>
|
|
<hr>
|
|
<div class="spirit-nav">
|
|
<a accesskey="p" href="thread_coordination.html"><img src="../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../atomic.html"><img src="../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="usage_examples.html"><img src="../../../doc/src/images/next.png" alt="Next"></a>
|
|
</div>
|
|
<div class="section">
|
|
<div class="titlepage"><div><div><h2 class="title" style="clear: both">
|
|
<a name="atomic.interface"></a><a class="link" href="interface.html" title="Programming interfaces">Programming interfaces</a>
|
|
</h2></div></div></div>
|
|
<div class="toc"><dl class="toc">
|
|
<dt><span class="section"><a href="interface.html#atomic.interface.configuration">Configuration and building</a></span></dt>
|
|
<dt><span class="section"><a href="interface.html#atomic.interface.interface_memory_order">Memory order</a></span></dt>
|
|
<dt><span class="section"><a href="interface.html#atomic.interface.interface_atomic_flag">Atomic flags</a></span></dt>
|
|
<dt><span class="section"><a href="interface.html#atomic.interface.interface_atomic_object">Atomic objects</a></span></dt>
|
|
<dt><span class="section"><a href="interface.html#atomic.interface.interface_fences">Fences</a></span></dt>
|
|
<dt><span class="section"><a href="interface.html#atomic.interface.feature_macros">Feature testing macros</a></span></dt>
|
|
</dl></div>
|
|
<div class="section">
|
|
<div class="titlepage"><div><div><h3 class="title">
|
|
<a name="atomic.interface.configuration"></a><a class="link" href="interface.html#atomic.interface.configuration" title="Configuration and building">Configuration and building</a>
|
|
</h3></div></div></div>
|
|
<p>
|
|
The library contains header-only and compiled parts. The library is header-only
|
|
for lock-free cases but requires a separate binary to implement the lock-based
|
|
emulation. Users are able to detect whether linking to the compiled part
|
|
is required by checking the <a class="link" href="interface.html#atomic.interface.feature_macros" title="Feature testing macros">feature
|
|
macros</a>.
|
|
</p>
|
|
<p>
|
|
The following macros affect library behavior:
|
|
</p>
|
|
<div class="informaltable"><table class="table">
|
|
<colgroup>
|
|
<col>
|
|
<col>
|
|
</colgroup>
|
|
<thead><tr>
|
|
<th>
|
|
<p>
|
|
Macro
|
|
</p>
|
|
</th>
|
|
<th>
|
|
<p>
|
|
Description
|
|
</p>
|
|
</th>
|
|
</tr></thead>
|
|
<tbody>
|
|
<tr>
|
|
<td>
|
|
<p>
|
|
<code class="computeroutput"><span class="identifier">BOOST_ATOMIC_NO_CMPXCHG8B</span></code>
|
|
</p>
|
|
</td>
|
|
<td>
|
|
<p>
|
|
Affects 32-bit x86 Oracle Studio builds. When defined, the library
|
|
assumes the target CPU does not support <code class="computeroutput"><span class="identifier">cmpxchg8b</span></code>
|
|
instruction used to support 64-bit atomic operations. This is the
|
|
case with very old CPUs (pre-Pentium). The library does not perform
|
|
runtime detection of this instruction, so running the code that
|
|
uses 64-bit atomics on such CPUs will result in crashes, unless
|
|
this macro is defined. Note that the macro does not affect MSVC,
|
|
GCC and compatible compilers because the library infers this information
|
|
from the compiler-defined macros.
|
|
</p>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td>
|
|
<p>
|
|
<code class="computeroutput"><span class="identifier">BOOST_ATOMIC_NO_CMPXCHG16B</span></code>
|
|
</p>
|
|
</td>
|
|
<td>
|
|
<p>
|
|
Affects 64-bit x86 MSVC and Oracle Studio builds. When defined,
|
|
the library assumes the target CPU does not support <code class="computeroutput"><span class="identifier">cmpxchg16b</span></code> instruction used to
|
|
support 128-bit atomic operations. This is the case with some early
|
|
64-bit AMD CPUs, all Intel CPUs and current AMD CPUs support this
|
|
instruction. The library does not perform runtime detection of
|
|
this instruction, so running the code that uses 128-bit atomics
|
|
on such CPUs will result in crashes, unless this macro is defined.
|
|
Note that the macro does not affect GCC and compatible compilers
|
|
because the library infers this information from the compiler-defined
|
|
macros.
|
|
</p>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td>
|
|
<p>
|
|
<code class="computeroutput"><span class="identifier">BOOST_ATOMIC_NO_MFENCE</span></code>
|
|
</p>
|
|
</td>
|
|
<td>
|
|
<p>
|
|
Affects 32-bit x86 Oracle Studio builds. When defined, the library
|
|
assumes the target CPU does not support <code class="computeroutput"><span class="identifier">mfence</span></code>
|
|
instruction used to implement thread fences. This instruction was
|
|
added with SSE2 instruction set extension, which was available
|
|
in CPUs since Intel Pentium 4. The library does not perform runtime
|
|
detection of this instruction, so running the library code on older
|
|
CPUs will result in crashes, unless this macro is defined. Note
|
|
that the macro does not affect MSVC, GCC and compatible compilers
|
|
because the library infers this information from the compiler-defined
|
|
macros.
|
|
</p>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td>
|
|
<p>
|
|
<code class="computeroutput"><span class="identifier">BOOST_ATOMIC_FORCE_FALLBACK</span></code>
|
|
</p>
|
|
</td>
|
|
<td>
|
|
<p>
|
|
When defined, all operations are implemented with locks. This is
|
|
mostly used for testing and should not be used in real world projects.
|
|
</p>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td>
|
|
<p>
|
|
<code class="computeroutput"><span class="identifier">BOOST_ATOMIC_DYN_LINK</span></code>
|
|
and <code class="computeroutput"><span class="identifier">BOOST_ALL_DYN_LINK</span></code>
|
|
</p>
|
|
</td>
|
|
<td>
|
|
<p>
|
|
Control library linking. If defined, the library assumes dynamic
|
|
linking, otherwise static. The latter macro affects all Boost libraries,
|
|
not just <span class="bold"><strong>Boost.Atomic</strong></span>.
|
|
</p>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td>
|
|
<p>
|
|
<code class="computeroutput"><span class="identifier">BOOST_ATOMIC_NO_LIB</span></code>
|
|
and <code class="computeroutput"><span class="identifier">BOOST_ALL_NO_LIB</span></code>
|
|
</p>
|
|
</td>
|
|
<td>
|
|
<p>
|
|
Control library auto-linking on Windows. When defined, disables
|
|
auto-linking. The latter macro affects all Boost libraries, not
|
|
just <span class="bold"><strong>Boost.Atomic</strong></span>.
|
|
</p>
|
|
</td>
|
|
</tr>
|
|
</tbody>
|
|
</table></div>
|
|
<p>
|
|
Besides macros, it is important to specify the correct compiler options for
|
|
the target CPU. With GCC and compatible compilers this affects whether particular
|
|
atomic operations are lock-free or not.
|
|
</p>
|
|
<p>
|
|
Boost building process is described in the <a href="http://www.boost.org/doc/libs/release/more/getting_started/" target="_top">Getting
|
|
Started guide</a>. For example, you can build <span class="bold"><strong>Boost.Atomic</strong></span>
|
|
with the following command line:
|
|
</p>
|
|
<pre class="programlisting">bjam --with-atomic variant=release instruction-set=core2 stage
|
|
</pre>
|
|
</div>
|
|
<div class="section">
|
|
<div class="titlepage"><div><div><h3 class="title">
|
|
<a name="atomic.interface.interface_memory_order"></a><a class="link" href="interface.html#atomic.interface.interface_memory_order" title="Memory order">Memory order</a>
|
|
</h3></div></div></div>
|
|
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">memory_order</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span>
|
|
</pre>
|
|
<p>
|
|
The enumeration <code class="literal">boost::memory_order</code> defines the following
|
|
values to represent memory ordering constraints:
|
|
</p>
|
|
<div class="informaltable"><table class="table">
|
|
<colgroup>
|
|
<col>
|
|
<col>
|
|
</colgroup>
|
|
<thead><tr>
|
|
<th>
|
|
<p>
|
|
Constant
|
|
</p>
|
|
</th>
|
|
<th>
|
|
<p>
|
|
Description
|
|
</p>
|
|
</th>
|
|
</tr></thead>
|
|
<tbody>
|
|
<tr>
|
|
<td>
|
|
<p>
|
|
<code class="computeroutput"><span class="identifier">memory_order_relaxed</span></code>
|
|
</p>
|
|
</td>
|
|
<td>
|
|
<p>
|
|
No ordering constraint. Informally speaking, following operations
|
|
may be reordered before, preceding operations may be reordered
|
|
after the atomic operation. This constraint is suitable only when
|
|
either a) further operations do not depend on the outcome of the
|
|
atomic operation or b) ordering is enforced through stand-alone
|
|
<code class="computeroutput"><span class="identifier">atomic_thread_fence</span></code>
|
|
operations. The operation on the atomic value itself is still atomic
|
|
though.
|
|
</p>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td>
|
|
<p>
|
|
<code class="computeroutput"><span class="identifier">memory_order_release</span></code>
|
|
</p>
|
|
</td>
|
|
<td>
|
|
<p>
|
|
Perform <code class="computeroutput"><span class="identifier">release</span></code>
|
|
operation. Informally speaking, prevents all preceding memory operations
|
|
to be reordered past this point.
|
|
</p>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td>
|
|
<p>
|
|
<code class="computeroutput"><span class="identifier">memory_order_acquire</span></code>
|
|
</p>
|
|
</td>
|
|
<td>
|
|
<p>
|
|
Perform <code class="computeroutput"><span class="identifier">acquire</span></code>
|
|
operation. Informally speaking, prevents succeeding memory operations
|
|
to be reordered before this point.
|
|
</p>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td>
|
|
<p>
|
|
<code class="computeroutput"><span class="identifier">memory_order_consume</span></code>
|
|
</p>
|
|
</td>
|
|
<td>
|
|
<p>
|
|
Perform <code class="computeroutput"><span class="identifier">consume</span></code>
|
|
operation. More relaxed (and on some architectures more efficient)
|
|
than <code class="computeroutput"><span class="identifier">memory_order_acquire</span></code>
|
|
as it only affects succeeding operations that are computationally-dependent
|
|
on the value retrieved from an atomic variable.
|
|
</p>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td>
|
|
<p>
|
|
<code class="computeroutput"><span class="identifier">memory_order_acq_rel</span></code>
|
|
</p>
|
|
</td>
|
|
<td>
|
|
<p>
|
|
Perform both <code class="computeroutput"><span class="identifier">release</span></code>
|
|
and <code class="computeroutput"><span class="identifier">acquire</span></code> operation
|
|
</p>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td>
|
|
<p>
|
|
<code class="computeroutput"><span class="identifier">memory_order_seq_cst</span></code>
|
|
</p>
|
|
</td>
|
|
<td>
|
|
<p>
|
|
Enforce sequential consistency. Implies <code class="computeroutput"><span class="identifier">memory_order_acq_rel</span></code>,
|
|
but additionally enforces total order for all operations such qualified.
|
|
</p>
|
|
</td>
|
|
</tr>
|
|
</tbody>
|
|
</table></div>
|
|
<p>
|
|
See section <a class="link" href="thread_coordination.html" title="Thread coordination using Boost.Atomic"><span class="emphasis"><em>happens-before</em></span></a>
|
|
for explanation of the various ordering constraints.
|
|
</p>
|
|
</div>
|
|
<div class="section">
|
|
<div class="titlepage"><div><div><h3 class="title">
|
|
<a name="atomic.interface.interface_atomic_flag"></a><a class="link" href="interface.html#atomic.interface.interface_atomic_flag" title="Atomic flags">Atomic flags</a>
|
|
</h3></div></div></div>
|
|
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">atomic</span><span class="special">/</span><span class="identifier">atomic_flag</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span>
|
|
</pre>
|
|
<p>
|
|
The <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">atomic_flag</span></code> type provides the most basic
|
|
set of atomic operations suitable for implementing mutually exclusive access
|
|
to thread-shared data. The flag can have one of the two possible states:
|
|
set and clear. The class implements the following operations:
|
|
</p>
|
|
<div class="informaltable"><table class="table">
|
|
<colgroup>
|
|
<col>
|
|
<col>
|
|
</colgroup>
|
|
<thead><tr>
|
|
<th>
|
|
<p>
|
|
Syntax
|
|
</p>
|
|
</th>
|
|
<th>
|
|
<p>
|
|
Description
|
|
</p>
|
|
</th>
|
|
</tr></thead>
|
|
<tbody>
|
|
<tr>
|
|
<td>
|
|
<p>
|
|
<code class="computeroutput"><span class="identifier">atomic_flag</span><span class="special">()</span></code>
|
|
</p>
|
|
</td>
|
|
<td>
|
|
<p>
|
|
Initialize to the clear state. See the discussion below.
|
|
</p>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td>
|
|
<p>
|
|
<code class="computeroutput"><span class="keyword">bool</span> <span class="identifier">test_and_set</span><span class="special">(</span><span class="identifier">memory_order</span>
|
|
<span class="identifier">order</span><span class="special">)</span></code>
|
|
</p>
|
|
</td>
|
|
<td>
|
|
<p>
|
|
Sets the atomic flag to the set state; returns <code class="computeroutput"><span class="keyword">true</span></code>
|
|
if the flag had been set prior to the operation
|
|
</p>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td>
|
|
<p>
|
|
<code class="computeroutput"><span class="keyword">void</span> <span class="identifier">clear</span><span class="special">(</span><span class="identifier">memory_order</span>
|
|
<span class="identifier">order</span><span class="special">)</span></code>
|
|
</p>
|
|
</td>
|
|
<td>
|
|
<p>
|
|
Sets the atomic flag to the clear state
|
|
</p>
|
|
</td>
|
|
</tr>
|
|
</tbody>
|
|
</table></div>
|
|
<p>
|
|
<code class="computeroutput"><span class="identifier">order</span></code> always has <code class="computeroutput"><span class="identifier">memory_order_seq_cst</span></code> as default parameter.
|
|
</p>
|
|
<p>
|
|
Note that the default constructor <code class="computeroutput"><span class="identifier">atomic_flag</span><span class="special">()</span></code> is unlike <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">atomic_flag</span></code>,
|
|
which leaves the default-constructed object uninitialized. This potentially
|
|
requires dynamic initialization during the program startup to perform the
|
|
object initialization, which makes it unsafe to create global <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">atomic_flag</span></code> objects that can be used before
|
|
entring <code class="computeroutput"><span class="identifier">main</span><span class="special">()</span></code>.
|
|
Some compilers though (especially those supporting C++11 <code class="computeroutput"><span class="keyword">constexpr</span></code>)
|
|
may be smart enough to perform flag initialization statically (which is,
|
|
in C++11 terms, a constant initialization).
|
|
</p>
|
|
<p>
|
|
This difference is deliberate and is done to support C++03 compilers. C++11
|
|
defines the <code class="computeroutput"><span class="identifier">ATOMIC_FLAG_INIT</span></code>
|
|
macro which can be used to statically initialize <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">atomic_flag</span></code>
|
|
to a clear state like this:
|
|
</p>
|
|
<pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">atomic_flag</span> <span class="identifier">flag</span> <span class="special">=</span> <span class="identifier">ATOMIC_FLAG_INIT</span><span class="special">;</span> <span class="comment">// constant initialization</span>
|
|
</pre>
|
|
<p>
|
|
This macro cannot be implemented in C++03 because for that <code class="computeroutput"><span class="identifier">atomic_flag</span></code> would have to be an aggregate
|
|
type, which it cannot be because it has to prohibit copying and consequently
|
|
define the default constructor. Thus the closest equivalent C++03 code using
|
|
<span class="bold"><strong>Boost.Atomic</strong></span> would be:
|
|
</p>
|
|
<pre class="programlisting"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">atomic_flag</span> <span class="identifier">flag</span><span class="special">;</span> <span class="comment">// possibly, dynamic initialization in C++03;</span>
|
|
<span class="comment">// constant initialization in C++11</span>
|
|
</pre>
|
|
<p>
|
|
The same code is also valid in C++11, so this code can be used universally.
|
|
However, for interface parity with <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">atomic_flag</span></code>,
|
|
if possible, the library also defines the <code class="computeroutput"><span class="identifier">BOOST_ATOMIC_FLAG_INIT</span></code>
|
|
macro, which is equivalent to <code class="computeroutput"><span class="identifier">ATOMIC_FLAG_INIT</span></code>:
|
|
</p>
|
|
<pre class="programlisting"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">atomic_flag</span> <span class="identifier">flag</span> <span class="special">=</span> <span class="identifier">BOOST_ATOMIC_FLAG_INIT</span><span class="special">;</span> <span class="comment">// constant initialization</span>
|
|
</pre>
|
|
<p>
|
|
This macro will only be implemented on a C++11 compiler. When this macro
|
|
is not available, the library defines <code class="computeroutput"><span class="identifier">BOOST_ATOMIC_NO_ATOMIC_FLAG_INIT</span></code>.
|
|
</p>
|
|
</div>
|
|
<div class="section">
|
|
<div class="titlepage"><div><div><h3 class="title">
|
|
<a name="atomic.interface.interface_atomic_object"></a><a class="link" href="interface.html#atomic.interface.interface_atomic_object" title="Atomic objects">Atomic objects</a>
|
|
</h3></div></div></div>
|
|
<div class="toc"><dl class="toc">
|
|
<dt><span class="section"><a href="interface.html#atomic.interface.interface_atomic_object.interface_atomic_generic"><code class="literal">boost::atomic<<span class="emphasis"><em>T</em></span>></code>
|
|
template class</a></span></dt>
|
|
<dt><span class="section"><a href="interface.html#atomic.interface.interface_atomic_object.interface_atomic_integral"><code class="literal">boost::atomic<<span class="emphasis"><em>integral</em></span>></code>
|
|
template class</a></span></dt>
|
|
<dt><span class="section"><a href="interface.html#atomic.interface.interface_atomic_object.interface_atomic_pointer"><code class="literal">boost::atomic<<span class="emphasis"><em>pointer</em></span>></code>
|
|
template class</a></span></dt>
|
|
<dt><span class="section"><a href="interface.html#atomic.interface.interface_atomic_object.interface_atomic_convenience_typedefs"><code class="literal">boost::atomic<<span class="emphasis"><em>T</em></span>></code>
|
|
convenience typedefs</a></span></dt>
|
|
</dl></div>
|
|
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">atomic</span><span class="special">/</span><span class="identifier">atomic</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span>
|
|
</pre>
|
|
<p>
|
|
<code class="literal">boost::atomic<<span class="emphasis"><em>T</em></span>></code> provides methods
|
|
for atomically accessing variables of a suitable type <code class="literal"><span class="emphasis"><em>T</em></span></code>.
|
|
The type is suitable if it is <span class="emphasis"><em>trivially copyable</em></span> (3.9/9
|
|
[basic.types]). Following are examples of the types compatible with this
|
|
requirement:
|
|
</p>
|
|
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
|
|
<li class="listitem">
|
|
a scalar type (e.g. integer, boolean, enum or pointer type)
|
|
</li>
|
|
<li class="listitem">
|
|
a <code class="literal">class</code> or <code class="literal">struct</code> that has no non-trivial
|
|
copy or move constructors or assignment operators, has a trivial destructor,
|
|
and that is comparable via <code class="literal">memcmp</code>.
|
|
</li>
|
|
</ul></div>
|
|
<p>
|
|
Note that classes with virtual functions or virtual base classes do not satisfy
|
|
the requirements. Also be warned that structures with "padding"
|
|
between data members may compare non-equal via <code class="literal">memcmp</code>
|
|
even though all members are equal.
|
|
</p>
|
|
<div class="section">
|
|
<div class="titlepage"><div><div><h4 class="title">
|
|
<a name="atomic.interface.interface_atomic_object.interface_atomic_generic"></a><a class="link" href="interface.html#atomic.interface.interface_atomic_object.interface_atomic_generic" title="boost::atomic<T> template class"><code class="literal">boost::atomic<<span class="emphasis"><em>T</em></span>></code>
|
|
template class</a>
|
|
</h4></div></div></div>
|
|
<p>
|
|
All atomic objects support the following operations and properties:
|
|
</p>
|
|
<div class="informaltable"><table class="table">
|
|
<colgroup>
|
|
<col>
|
|
<col>
|
|
</colgroup>
|
|
<thead><tr>
|
|
<th>
|
|
<p>
|
|
Syntax
|
|
</p>
|
|
</th>
|
|
<th>
|
|
<p>
|
|
Description
|
|
</p>
|
|
</th>
|
|
</tr></thead>
|
|
<tbody>
|
|
<tr>
|
|
<td>
|
|
<p>
|
|
<code class="computeroutput"><span class="identifier">atomic</span><span class="special">()</span></code>
|
|
</p>
|
|
</td>
|
|
<td>
|
|
<p>
|
|
Initialize to an unspecified value
|
|
</p>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td>
|
|
<p>
|
|
<code class="computeroutput"><span class="identifier">atomic</span><span class="special">(</span><span class="identifier">T</span> <span class="identifier">initial_value</span><span class="special">)</span></code>
|
|
</p>
|
|
</td>
|
|
<td>
|
|
<p>
|
|
Initialize to <code class="literal">initial_value</code>
|
|
</p>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td>
|
|
<p>
|
|
<code class="computeroutput"><span class="keyword">bool</span> <span class="identifier">is_lock_free</span><span class="special">()</span></code>
|
|
</p>
|
|
</td>
|
|
<td>
|
|
<p>
|
|
Checks if the atomic object is lock-free; the returned value
|
|
is consistent with the <code class="computeroutput"><span class="identifier">is_always_lock_free</span></code>
|
|
static constant, see below
|
|
</p>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td>
|
|
<p>
|
|
<code class="computeroutput"><span class="identifier">T</span> <span class="identifier">load</span><span class="special">(</span><span class="identifier">memory_order</span>
|
|
<span class="identifier">order</span><span class="special">)</span></code>
|
|
</p>
|
|
</td>
|
|
<td>
|
|
<p>
|
|
Return current value
|
|
</p>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td>
|
|
<p>
|
|
<code class="computeroutput"><span class="keyword">void</span> <span class="identifier">store</span><span class="special">(</span><span class="identifier">T</span>
|
|
<span class="identifier">value</span><span class="special">,</span>
|
|
<span class="identifier">memory_order</span> <span class="identifier">order</span><span class="special">)</span></code>
|
|
</p>
|
|
</td>
|
|
<td>
|
|
<p>
|
|
Write new value to atomic variable
|
|
</p>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td>
|
|
<p>
|
|
<code class="computeroutput"><span class="identifier">T</span> <span class="identifier">exchange</span><span class="special">(</span><span class="identifier">T</span>
|
|
<span class="identifier">new_value</span><span class="special">,</span>
|
|
<span class="identifier">memory_order</span> <span class="identifier">order</span><span class="special">)</span></code>
|
|
</p>
|
|
</td>
|
|
<td>
|
|
<p>
|
|
Exchange current value with <code class="computeroutput"><span class="identifier">new_value</span></code>,
|
|
returning current value
|
|
</p>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td>
|
|
<p>
|
|
<code class="computeroutput"><span class="keyword">bool</span> <span class="identifier">compare_exchange_weak</span><span class="special">(</span><span class="identifier">T</span>
|
|
<span class="special">&</span> <span class="identifier">expected</span><span class="special">,</span> <span class="identifier">T</span>
|
|
<span class="identifier">desired</span><span class="special">,</span>
|
|
<span class="identifier">memory_order</span> <span class="identifier">order</span><span class="special">)</span></code>
|
|
</p>
|
|
</td>
|
|
<td>
|
|
<p>
|
|
Compare current value with <code class="computeroutput"><span class="identifier">expected</span></code>,
|
|
change it to <code class="computeroutput"><span class="identifier">desired</span></code>
|
|
if matches. Returns <code class="computeroutput"><span class="keyword">true</span></code>
|
|
if an exchange has been performed, and always writes the previous
|
|
value back in <code class="computeroutput"><span class="identifier">expected</span></code>.
|
|
May fail spuriously, so must generally be retried in a loop.
|
|
</p>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td>
|
|
<p>
|
|
<code class="computeroutput"><span class="keyword">bool</span> <span class="identifier">compare_exchange_weak</span><span class="special">(</span><span class="identifier">T</span>
|
|
<span class="special">&</span> <span class="identifier">expected</span><span class="special">,</span> <span class="identifier">T</span>
|
|
<span class="identifier">desired</span><span class="special">,</span>
|
|
<span class="identifier">memory_order</span> <span class="identifier">success_order</span><span class="special">,</span> <span class="identifier">memory_order</span>
|
|
<span class="identifier">failure_order</span><span class="special">)</span></code>
|
|
</p>
|
|
</td>
|
|
<td>
|
|
<p>
|
|
Compare current value with <code class="computeroutput"><span class="identifier">expected</span></code>,
|
|
change it to <code class="computeroutput"><span class="identifier">desired</span></code>
|
|
if matches. Returns <code class="computeroutput"><span class="keyword">true</span></code>
|
|
if an exchange has been performed, and always writes the previous
|
|
value back in <code class="computeroutput"><span class="identifier">expected</span></code>.
|
|
May fail spuriously, so must generally be retried in a loop.
|
|
</p>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td>
|
|
<p>
|
|
<code class="computeroutput"><span class="keyword">bool</span> <span class="identifier">compare_exchange_strong</span><span class="special">(</span><span class="identifier">T</span>
|
|
<span class="special">&</span> <span class="identifier">expected</span><span class="special">,</span> <span class="identifier">T</span>
|
|
<span class="identifier">desired</span><span class="special">,</span>
|
|
<span class="identifier">memory_order</span> <span class="identifier">order</span><span class="special">)</span></code>
|
|
</p>
|
|
</td>
|
|
<td>
|
|
<p>
|
|
Compare current value with <code class="computeroutput"><span class="identifier">expected</span></code>,
|
|
change it to <code class="computeroutput"><span class="identifier">desired</span></code>
|
|
if matches. Returns <code class="computeroutput"><span class="keyword">true</span></code>
|
|
if an exchange has been performed, and always writes the previous
|
|
value back in <code class="computeroutput"><span class="identifier">expected</span></code>.
|
|
</p>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td>
|
|
<p>
|
|
<code class="computeroutput"><span class="keyword">bool</span> <span class="identifier">compare_exchange_strong</span><span class="special">(</span><span class="identifier">T</span>
|
|
<span class="special">&</span> <span class="identifier">expected</span><span class="special">,</span> <span class="identifier">T</span>
|
|
<span class="identifier">desired</span><span class="special">,</span>
|
|
<span class="identifier">memory_order</span> <span class="identifier">success_order</span><span class="special">,</span> <span class="identifier">memory_order</span>
|
|
<span class="identifier">failure_order</span><span class="special">))</span></code>
|
|
</p>
|
|
</td>
|
|
<td>
|
|
<p>
|
|
Compare current value with <code class="computeroutput"><span class="identifier">expected</span></code>,
|
|
change it to <code class="computeroutput"><span class="identifier">desired</span></code>
|
|
if matches. Returns <code class="computeroutput"><span class="keyword">true</span></code>
|
|
if an exchange has been performed, and always writes the previous
|
|
value back in <code class="computeroutput"><span class="identifier">expected</span></code>.
|
|
</p>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td>
|
|
<p>
|
|
<code class="computeroutput"><span class="keyword">static</span> <span class="keyword">bool</span>
|
|
<span class="identifier">is_always_lock_free</span></code>
|
|
</p>
|
|
</td>
|
|
<td>
|
|
<p>
|
|
This static boolean constant indicates if any atomic object of
|
|
this type is lock-free
|
|
</p>
|
|
</td>
|
|
</tr>
|
|
</tbody>
|
|
</table></div>
|
|
<p>
|
|
<code class="computeroutput"><span class="identifier">order</span></code> always has <code class="computeroutput"><span class="identifier">memory_order_seq_cst</span></code> as default parameter.
|
|
</p>
|
|
<p>
|
|
The <code class="computeroutput"><span class="identifier">compare_exchange_weak</span></code>/<code class="computeroutput"><span class="identifier">compare_exchange_strong</span></code> variants taking
|
|
four parameters differ from the three parameter variants in that they allow
|
|
a different memory ordering constraint to be specified in case the operation
|
|
fails.
|
|
</p>
|
|
<p>
|
|
In addition to these explicit operations, each <code class="literal">atomic<<span class="emphasis"><em>T</em></span>></code>
|
|
object also supports implicit <code class="literal">store</code> and <code class="literal">load</code>
|
|
through the use of "assignment" and "conversion to <code class="literal">T</code>"
|
|
operators. Avoid using these operators, as they do not allow explicit specification
|
|
of a memory ordering constraint.
|
|
</p>
|
|
</div>
|
|
<div class="section">
|
|
<div class="titlepage"><div><div><h4 class="title">
|
|
<a name="atomic.interface.interface_atomic_object.interface_atomic_integral"></a><a class="link" href="interface.html#atomic.interface.interface_atomic_object.interface_atomic_integral" title="boost::atomic<integral> template class"><code class="literal">boost::atomic<<span class="emphasis"><em>integral</em></span>></code>
|
|
template class</a>
|
|
</h4></div></div></div>
|
|
<p>
|
|
In addition to the operations listed in the previous section, <code class="literal">boost::atomic<<span class="emphasis"><em>I</em></span>></code>
|
|
for integral types <code class="literal"><span class="emphasis"><em>I</em></span></code>, except <code class="computeroutput"><span class="keyword">bool</span></code>, supports the following operations,
|
|
which correspond to <code class="literal">std::atomic<<span class="emphasis"><em>I</em></span>></code>:
|
|
</p>
|
|
<div class="informaltable"><table class="table">
|
|
<colgroup>
|
|
<col>
|
|
<col>
|
|
</colgroup>
|
|
<thead><tr>
|
|
<th>
|
|
<p>
|
|
Syntax
|
|
</p>
|
|
</th>
|
|
<th>
|
|
<p>
|
|
Description
|
|
</p>
|
|
</th>
|
|
</tr></thead>
|
|
<tbody>
|
|
<tr>
|
|
<td>
|
|
<p>
|
|
<code class="computeroutput"><span class="identifier">I</span> <span class="identifier">fetch_add</span><span class="special">(</span><span class="identifier">I</span>
|
|
<span class="identifier">v</span><span class="special">,</span>
|
|
<span class="identifier">memory_order</span> <span class="identifier">order</span><span class="special">)</span></code>
|
|
</p>
|
|
</td>
|
|
<td>
|
|
<p>
|
|
Add <code class="computeroutput"><span class="identifier">v</span></code> to variable,
|
|
returning previous value
|
|
</p>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td>
|
|
<p>
|
|
<code class="computeroutput"><span class="identifier">I</span> <span class="identifier">fetch_sub</span><span class="special">(</span><span class="identifier">I</span>
|
|
<span class="identifier">v</span><span class="special">,</span>
|
|
<span class="identifier">memory_order</span> <span class="identifier">order</span><span class="special">)</span></code>
|
|
</p>
|
|
</td>
|
|
<td>
|
|
<p>
|
|
Subtract <code class="computeroutput"><span class="identifier">v</span></code> from
|
|
variable, returning previous value
|
|
</p>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td>
|
|
<p>
|
|
<code class="computeroutput"><span class="identifier">I</span> <span class="identifier">fetch_and</span><span class="special">(</span><span class="identifier">I</span>
|
|
<span class="identifier">v</span><span class="special">,</span>
|
|
<span class="identifier">memory_order</span> <span class="identifier">order</span><span class="special">)</span></code>
|
|
</p>
|
|
</td>
|
|
<td>
|
|
<p>
|
|
Apply bit-wise "and" with <code class="computeroutput"><span class="identifier">v</span></code>
|
|
to variable, returning previous value
|
|
</p>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td>
|
|
<p>
|
|
<code class="computeroutput"><span class="identifier">I</span> <span class="identifier">fetch_or</span><span class="special">(</span><span class="identifier">I</span>
|
|
<span class="identifier">v</span><span class="special">,</span>
|
|
<span class="identifier">memory_order</span> <span class="identifier">order</span><span class="special">)</span></code>
|
|
</p>
|
|
</td>
|
|
<td>
|
|
<p>
|
|
Apply bit-wise "or" with <code class="computeroutput"><span class="identifier">v</span></code>
|
|
to variable, returning previous value
|
|
</p>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td>
|
|
<p>
|
|
<code class="computeroutput"><span class="identifier">I</span> <span class="identifier">fetch_xor</span><span class="special">(</span><span class="identifier">I</span>
|
|
<span class="identifier">v</span><span class="special">,</span>
|
|
<span class="identifier">memory_order</span> <span class="identifier">order</span><span class="special">)</span></code>
|
|
</p>
|
|
</td>
|
|
<td>
|
|
<p>
|
|
Apply bit-wise "xor" with <code class="computeroutput"><span class="identifier">v</span></code>
|
|
to variable, returning previous value
|
|
</p>
|
|
</td>
|
|
</tr>
|
|
</tbody>
|
|
</table></div>
|
|
<p>
|
|
Additionally, as a <span class="bold"><strong>Boost.Atomic</strong></span> extension,
|
|
the following operations are also provided:
|
|
</p>
|
|
<div class="informaltable"><table class="table">
|
|
<colgroup>
|
|
<col>
|
|
<col>
|
|
</colgroup>
|
|
<thead><tr>
|
|
<th>
|
|
<p>
|
|
Syntax
|
|
</p>
|
|
</th>
|
|
<th>
|
|
<p>
|
|
Description
|
|
</p>
|
|
</th>
|
|
</tr></thead>
|
|
<tbody>
|
|
<tr>
|
|
<td>
|
|
<p>
|
|
<code class="computeroutput"><span class="identifier">I</span> <span class="identifier">fetch_negate</span><span class="special">(</span><span class="identifier">memory_order</span>
|
|
<span class="identifier">order</span><span class="special">)</span></code>
|
|
</p>
|
|
</td>
|
|
<td>
|
|
<p>
|
|
Change the sign of the value stored in the variable, returning
|
|
previous value
|
|
</p>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td>
|
|
<p>
|
|
<code class="computeroutput"><span class="identifier">I</span> <span class="identifier">fetch_complement</span><span class="special">(</span><span class="identifier">memory_order</span>
|
|
<span class="identifier">order</span><span class="special">)</span></code>
|
|
</p>
|
|
</td>
|
|
<td>
|
|
<p>
|
|
Set the variable to the one's complement of the current value,
|
|
returning previous value
|
|
</p>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td>
|
|
<p>
|
|
<code class="computeroutput"><span class="keyword">void</span> <span class="identifier">opaque_negate</span><span class="special">(</span><span class="identifier">memory_order</span>
|
|
<span class="identifier">order</span><span class="special">)</span></code>
|
|
</p>
|
|
</td>
|
|
<td>
|
|
<p>
|
|
Change the sign of the value stored in the variable, returning
|
|
nothing
|
|
</p>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td>
|
|
<p>
|
|
<code class="computeroutput"><span class="keyword">void</span> <span class="identifier">opaque_complement</span><span class="special">(</span><span class="identifier">memory_order</span>
|
|
<span class="identifier">order</span><span class="special">)</span></code>
|
|
</p>
|
|
</td>
|
|
<td>
|
|
<p>
|
|
Set the variable to the one's complement of the current value,
|
|
returning nothing
|
|
</p>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td>
|
|
<p>
|
|
<code class="computeroutput"><span class="keyword">void</span> <span class="identifier">opaque_add</span><span class="special">(</span><span class="identifier">I</span>
|
|
<span class="identifier">v</span><span class="special">,</span>
|
|
<span class="identifier">memory_order</span> <span class="identifier">order</span><span class="special">)</span></code>
|
|
</p>
|
|
</td>
|
|
<td>
|
|
<p>
|
|
Add <code class="computeroutput"><span class="identifier">v</span></code> to variable,
|
|
returning nothing
|
|
</p>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td>
|
|
<p>
|
|
<code class="computeroutput"><span class="keyword">void</span> <span class="identifier">opaque_sub</span><span class="special">(</span><span class="identifier">I</span>
|
|
<span class="identifier">v</span><span class="special">,</span>
|
|
<span class="identifier">memory_order</span> <span class="identifier">order</span><span class="special">)</span></code>
|
|
</p>
|
|
</td>
|
|
<td>
|
|
<p>
|
|
Subtract <code class="computeroutput"><span class="identifier">v</span></code> from
|
|
variable, returning nothing
|
|
</p>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td>
|
|
<p>
|
|
<code class="computeroutput"><span class="keyword">void</span> <span class="identifier">opaque_and</span><span class="special">(</span><span class="identifier">I</span>
|
|
<span class="identifier">v</span><span class="special">,</span>
|
|
<span class="identifier">memory_order</span> <span class="identifier">order</span><span class="special">)</span></code>
|
|
</p>
|
|
</td>
|
|
<td>
|
|
<p>
|
|
Apply bit-wise "and" with <code class="computeroutput"><span class="identifier">v</span></code>
|
|
to variable, returning nothing
|
|
</p>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td>
|
|
<p>
|
|
<code class="computeroutput"><span class="keyword">void</span> <span class="identifier">opaque_or</span><span class="special">(</span><span class="identifier">I</span>
|
|
<span class="identifier">v</span><span class="special">,</span>
|
|
<span class="identifier">memory_order</span> <span class="identifier">order</span><span class="special">)</span></code>
|
|
</p>
|
|
</td>
|
|
<td>
|
|
<p>
|
|
Apply bit-wise "or" with <code class="computeroutput"><span class="identifier">v</span></code>
|
|
to variable, returning nothing
|
|
</p>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td>
|
|
<p>
|
|
<code class="computeroutput"><span class="keyword">void</span> <span class="identifier">opaque_xor</span><span class="special">(</span><span class="identifier">I</span>
|
|
<span class="identifier">v</span><span class="special">,</span>
|
|
<span class="identifier">memory_order</span> <span class="identifier">order</span><span class="special">)</span></code>
|
|
</p>
|
|
</td>
|
|
<td>
|
|
<p>
|
|
Apply bit-wise "xor" with <code class="computeroutput"><span class="identifier">v</span></code>
|
|
to variable, returning nothing
|
|
</p>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td>
|
|
<p>
|
|
<code class="computeroutput"><span class="keyword">bool</span> <span class="identifier">add_and_test</span><span class="special">(</span><span class="identifier">I</span>
|
|
<span class="identifier">v</span><span class="special">,</span>
|
|
<span class="identifier">memory_order</span> <span class="identifier">order</span><span class="special">)</span></code>
|
|
</p>
|
|
</td>
|
|
<td>
|
|
<p>
|
|
Add <code class="computeroutput"><span class="identifier">v</span></code> to variable,
|
|
returning <code class="computeroutput"><span class="keyword">true</span></code> if
|
|
the result is zero and <code class="computeroutput"><span class="keyword">false</span></code>
|
|
otherwise
|
|
</p>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td>
|
|
<p>
|
|
<code class="computeroutput"><span class="keyword">bool</span> <span class="identifier">sub_and_test</span><span class="special">(</span><span class="identifier">I</span>
|
|
<span class="identifier">v</span><span class="special">,</span>
|
|
<span class="identifier">memory_order</span> <span class="identifier">order</span><span class="special">)</span></code>
|
|
</p>
|
|
</td>
|
|
<td>
|
|
<p>
|
|
Subtract <code class="computeroutput"><span class="identifier">v</span></code> from
|
|
variable, returning <code class="computeroutput"><span class="keyword">true</span></code>
|
|
if the result is zero and <code class="computeroutput"><span class="keyword">false</span></code>
|
|
otherwise
|
|
</p>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td>
|
|
<p>
|
|
<code class="computeroutput"><span class="keyword">bool</span> <span class="identifier">and_and_test</span><span class="special">(</span><span class="identifier">I</span>
|
|
<span class="identifier">v</span><span class="special">,</span>
|
|
<span class="identifier">memory_order</span> <span class="identifier">order</span><span class="special">)</span></code>
|
|
</p>
|
|
</td>
|
|
<td>
|
|
<p>
|
|
Apply bit-wise "and" with <code class="computeroutput"><span class="identifier">v</span></code>
|
|
to variable, returning <code class="computeroutput"><span class="keyword">true</span></code>
|
|
if the result is zero and <code class="computeroutput"><span class="keyword">false</span></code>
|
|
otherwise
|
|
</p>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td>
|
|
<p>
|
|
<code class="computeroutput"><span class="keyword">bool</span> <span class="identifier">or_and_test</span><span class="special">(</span><span class="identifier">I</span>
|
|
<span class="identifier">v</span><span class="special">,</span>
|
|
<span class="identifier">memory_order</span> <span class="identifier">order</span><span class="special">)</span></code>
|
|
</p>
|
|
</td>
|
|
<td>
|
|
<p>
|
|
Apply bit-wise "or" with <code class="computeroutput"><span class="identifier">v</span></code>
|
|
to variable, returning <code class="computeroutput"><span class="keyword">true</span></code>
|
|
if the result is zero and <code class="computeroutput"><span class="keyword">false</span></code>
|
|
otherwise
|
|
</p>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td>
|
|
<p>
|
|
<code class="computeroutput"><span class="keyword">bool</span> <span class="identifier">xor_and_test</span><span class="special">(</span><span class="identifier">I</span>
|
|
<span class="identifier">v</span><span class="special">,</span>
|
|
<span class="identifier">memory_order</span> <span class="identifier">order</span><span class="special">)</span></code>
|
|
</p>
|
|
</td>
|
|
<td>
|
|
<p>
|
|
Apply bit-wise "xor" with <code class="computeroutput"><span class="identifier">v</span></code>
|
|
to variable, returning <code class="computeroutput"><span class="keyword">true</span></code>
|
|
if the result is zero and <code class="computeroutput"><span class="keyword">false</span></code>
|
|
otherwise
|
|
</p>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td>
|
|
<p>
|
|
<code class="computeroutput"><span class="keyword">bool</span> <span class="identifier">bit_test_and_set</span><span class="special">(</span><span class="keyword">unsigned</span>
|
|
<span class="keyword">int</span> <span class="identifier">n</span><span class="special">,</span> <span class="identifier">memory_order</span>
|
|
<span class="identifier">order</span><span class="special">)</span></code>
|
|
</p>
|
|
</td>
|
|
<td>
|
|
<p>
|
|
Set bit number <code class="computeroutput"><span class="identifier">n</span></code>
|
|
in the variable to 1, returning <code class="computeroutput"><span class="keyword">true</span></code>
|
|
if the bit was previously set to 1 and <code class="computeroutput"><span class="keyword">false</span></code>
|
|
otherwise
|
|
</p>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td>
|
|
<p>
|
|
<code class="computeroutput"><span class="keyword">bool</span> <span class="identifier">bit_test_and_reset</span><span class="special">(</span><span class="keyword">unsigned</span>
|
|
<span class="keyword">int</span> <span class="identifier">n</span><span class="special">,</span> <span class="identifier">memory_order</span>
|
|
<span class="identifier">order</span><span class="special">)</span></code>
|
|
</p>
|
|
</td>
|
|
<td>
|
|
<p>
|
|
Set bit number <code class="computeroutput"><span class="identifier">n</span></code>
|
|
in the variable to 0, returning <code class="computeroutput"><span class="keyword">true</span></code>
|
|
if the bit was previously set to 1 and <code class="computeroutput"><span class="keyword">false</span></code>
|
|
otherwise
|
|
</p>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td>
|
|
<p>
|
|
<code class="computeroutput"><span class="keyword">bool</span> <span class="identifier">bit_test_and_complement</span><span class="special">(</span><span class="keyword">unsigned</span>
|
|
<span class="keyword">int</span> <span class="identifier">n</span><span class="special">,</span> <span class="identifier">memory_order</span>
|
|
<span class="identifier">order</span><span class="special">)</span></code>
|
|
</p>
|
|
</td>
|
|
<td>
|
|
<p>
|
|
Change bit number <code class="computeroutput"><span class="identifier">n</span></code>
|
|
in the variable to the opposite value, returning <code class="computeroutput"><span class="keyword">true</span></code> if the bit was previously
|
|
set to 1 and <code class="computeroutput"><span class="keyword">false</span></code>
|
|
otherwise
|
|
</p>
|
|
</td>
|
|
</tr>
|
|
</tbody>
|
|
</table></div>
|
|
<div class="note"><table border="0" summary="Note">
|
|
<tr>
|
|
<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../doc/src/images/note.png"></td>
|
|
<th align="left">Note</th>
|
|
</tr>
|
|
<tr><td align="left" valign="top"><p>
|
|
In Boost.Atomic 1.67 and later the <code class="literal"><span class="emphasis"><em>op</em></span>_and_test</code>
|
|
operations will return the opposite value (i.e. <code class="computeroutput"><span class="keyword">true</span></code>
|
|
if the result is non-zero). This was changed for consistency with other
|
|
operations in Boost.Atomic, as well as with conventions taken in the
|
|
C++ standard library. Users may prefer to postpone using these operations
|
|
until Boost 1.67 to avoid the need to update the code after the upgrade.
|
|
</p></td></tr>
|
|
</table></div>
|
|
<p>
|
|
<code class="computeroutput"><span class="identifier">order</span></code> always has <code class="computeroutput"><span class="identifier">memory_order_seq_cst</span></code> as default parameter.
|
|
</p>
|
|
<p>
|
|
The <code class="literal">opaque_<span class="emphasis"><em>op</em></span></code> and <code class="literal"><span class="emphasis"><em>op</em></span>_and_test</code>
|
|
variants of the operations may result in a more efficient code on some
|
|
architectures because the original value of the atomic variable is not
|
|
preserved. In the <code class="literal">bit_test_and_<span class="emphasis"><em>op</em></span></code>
|
|
operations, the bit number <code class="computeroutput"><span class="identifier">n</span></code>
|
|
starts from 0, which means the least significand bit, and must not exceed
|
|
<code class="literal">std::numeric_limits<<span class="emphasis"><em>I</em></span>>::digits - 1</code>.
|
|
</p>
|
|
<p>
|
|
In addition to these explicit operations, each <code class="literal">boost::atomic<<span class="emphasis"><em>I</em></span>></code>
|
|
object also supports implicit pre-/post- increment/decrement, as well as
|
|
the operators <code class="computeroutput"><span class="special">+=</span></code>, <code class="computeroutput"><span class="special">-=</span></code>, <code class="computeroutput"><span class="special">&=</span></code>,
|
|
<code class="computeroutput"><span class="special">|=</span></code> and <code class="computeroutput"><span class="special">^=</span></code>.
|
|
Avoid using these operators, as they do not allow explicit specification
|
|
of a memory ordering constraint which always defaults to <code class="computeroutput"><span class="identifier">memory_order_seq_cst</span></code>.
|
|
</p>
|
|
</div>
|
|
<div class="section">
|
|
<div class="titlepage"><div><div><h4 class="title">
|
|
<a name="atomic.interface.interface_atomic_object.interface_atomic_pointer"></a><a class="link" href="interface.html#atomic.interface.interface_atomic_object.interface_atomic_pointer" title="boost::atomic<pointer> template class"><code class="literal">boost::atomic<<span class="emphasis"><em>pointer</em></span>></code>
|
|
template class</a>
|
|
</h4></div></div></div>
|
|
<p>
|
|
In addition to the operations applicable to all atomic object, <code class="literal">boost::atomic<<span class="emphasis"><em>P</em></span>></code>
|
|
for pointer types <code class="literal"><span class="emphasis"><em>P</em></span></code> (other than
|
|
pointers to <code class="literal">void</code>, function or member pointers) support
|
|
the following operations, which correspond to <code class="literal">std::atomic<<span class="emphasis"><em>P</em></span>></code>:
|
|
</p>
|
|
<div class="informaltable"><table class="table">
|
|
<colgroup>
|
|
<col>
|
|
<col>
|
|
</colgroup>
|
|
<thead><tr>
|
|
<th>
|
|
<p>
|
|
Syntax
|
|
</p>
|
|
</th>
|
|
<th>
|
|
<p>
|
|
Description
|
|
</p>
|
|
</th>
|
|
</tr></thead>
|
|
<tbody>
|
|
<tr>
|
|
<td>
|
|
<p>
|
|
<code class="computeroutput"><span class="identifier">T</span> <span class="identifier">fetch_add</span><span class="special">(</span><span class="identifier">ptrdiff_t</span>
|
|
<span class="identifier">v</span><span class="special">,</span>
|
|
<span class="identifier">memory_order</span> <span class="identifier">order</span><span class="special">)</span></code>
|
|
</p>
|
|
</td>
|
|
<td>
|
|
<p>
|
|
Add <code class="computeroutput"><span class="identifier">v</span></code> to variable,
|
|
returning previous value
|
|
</p>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td>
|
|
<p>
|
|
<code class="computeroutput"><span class="identifier">T</span> <span class="identifier">fetch_sub</span><span class="special">(</span><span class="identifier">ptrdiff_t</span>
|
|
<span class="identifier">v</span><span class="special">,</span>
|
|
<span class="identifier">memory_order</span> <span class="identifier">order</span><span class="special">)</span></code>
|
|
</p>
|
|
</td>
|
|
<td>
|
|
<p>
|
|
Subtract <code class="computeroutput"><span class="identifier">v</span></code> from
|
|
variable, returning previous value
|
|
</p>
|
|
</td>
|
|
</tr>
|
|
</tbody>
|
|
</table></div>
|
|
<p>
|
|
Similarly to integers, the following <span class="bold"><strong>Boost.Atomic</strong></span>
|
|
extensions are also provided:
|
|
</p>
|
|
<div class="informaltable"><table class="table">
|
|
<colgroup>
|
|
<col>
|
|
<col>
|
|
</colgroup>
|
|
<thead><tr>
|
|
<th>
|
|
<p>
|
|
Syntax
|
|
</p>
|
|
</th>
|
|
<th>
|
|
<p>
|
|
Description
|
|
</p>
|
|
</th>
|
|
</tr></thead>
|
|
<tbody>
|
|
<tr>
|
|
<td>
|
|
<p>
|
|
<code class="computeroutput"><span class="keyword">void</span> <span class="identifier">opaque_add</span><span class="special">(</span><span class="identifier">ptrdiff_t</span>
|
|
<span class="identifier">v</span><span class="special">,</span>
|
|
<span class="identifier">memory_order</span> <span class="identifier">order</span><span class="special">)</span></code>
|
|
</p>
|
|
</td>
|
|
<td>
|
|
<p>
|
|
Add <code class="computeroutput"><span class="identifier">v</span></code> to variable,
|
|
returning nothing
|
|
</p>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td>
|
|
<p>
|
|
<code class="computeroutput"><span class="keyword">void</span> <span class="identifier">opaque_sub</span><span class="special">(</span><span class="identifier">ptrdiff_t</span>
|
|
<span class="identifier">v</span><span class="special">,</span>
|
|
<span class="identifier">memory_order</span> <span class="identifier">order</span><span class="special">)</span></code>
|
|
</p>
|
|
</td>
|
|
<td>
|
|
<p>
|
|
Subtract <code class="computeroutput"><span class="identifier">v</span></code> from
|
|
variable, returning nothing
|
|
</p>
|
|
</td>
|
|
</tr>
|
|
</tbody>
|
|
</table></div>
|
|
<p>
|
|
<code class="computeroutput"><span class="identifier">order</span></code> always has <code class="computeroutput"><span class="identifier">memory_order_seq_cst</span></code> as default parameter.
|
|
</p>
|
|
<p>
|
|
In addition to these explicit operations, each <code class="literal">boost::atomic<<span class="emphasis"><em>P</em></span>></code>
|
|
object also supports implicit pre-/post- increment/decrement, as well as
|
|
the operators <code class="computeroutput"><span class="special">+=</span></code>, <code class="computeroutput"><span class="special">-=</span></code>. Avoid using these operators, as they
|
|
do not allow explicit specification of a memory ordering constraint which
|
|
always defaults to <code class="computeroutput"><span class="identifier">memory_order_seq_cst</span></code>.
|
|
</p>
|
|
</div>
|
|
<div class="section">
|
|
<div class="titlepage"><div><div><h4 class="title">
|
|
<a name="atomic.interface.interface_atomic_object.interface_atomic_convenience_typedefs"></a><a class="link" href="interface.html#atomic.interface.interface_atomic_object.interface_atomic_convenience_typedefs" title="boost::atomic<T> convenience typedefs"><code class="literal">boost::atomic<<span class="emphasis"><em>T</em></span>></code>
|
|
convenience typedefs</a>
|
|
</h4></div></div></div>
|
|
<p>
|
|
For convenience, several shorthand typedefs of <code class="literal">boost::atomic<<span class="emphasis"><em>T</em></span>></code>
|
|
are provided:
|
|
</p>
|
|
<pre class="programlisting"><span class="keyword">typedef</span> <span class="identifier">atomic</span><span class="special"><</span> <span class="keyword">char</span> <span class="special">></span> <span class="identifier">atomic_char</span><span class="special">;</span>
|
|
<span class="keyword">typedef</span> <span class="identifier">atomic</span><span class="special"><</span> <span class="keyword">unsigned</span> <span class="keyword">char</span> <span class="special">></span> <span class="identifier">atomic_uchar</span><span class="special">;</span>
|
|
<span class="keyword">typedef</span> <span class="identifier">atomic</span><span class="special"><</span> <span class="keyword">signed</span> <span class="keyword">char</span> <span class="special">></span> <span class="identifier">atomic_schar</span><span class="special">;</span>
|
|
<span class="keyword">typedef</span> <span class="identifier">atomic</span><span class="special"><</span> <span class="keyword">unsigned</span> <span class="keyword">short</span> <span class="special">></span> <span class="identifier">atomic_ushort</span><span class="special">;</span>
|
|
<span class="keyword">typedef</span> <span class="identifier">atomic</span><span class="special"><</span> <span class="keyword">short</span> <span class="special">></span> <span class="identifier">atomic_short</span><span class="special">;</span>
|
|
<span class="keyword">typedef</span> <span class="identifier">atomic</span><span class="special"><</span> <span class="keyword">unsigned</span> <span class="keyword">int</span> <span class="special">></span> <span class="identifier">atomic_uint</span><span class="special">;</span>
|
|
<span class="keyword">typedef</span> <span class="identifier">atomic</span><span class="special"><</span> <span class="keyword">int</span> <span class="special">></span> <span class="identifier">atomic_int</span><span class="special">;</span>
|
|
<span class="keyword">typedef</span> <span class="identifier">atomic</span><span class="special"><</span> <span class="keyword">unsigned</span> <span class="keyword">long</span> <span class="special">></span> <span class="identifier">atomic_ulong</span><span class="special">;</span>
|
|
<span class="keyword">typedef</span> <span class="identifier">atomic</span><span class="special"><</span> <span class="keyword">long</span> <span class="special">></span> <span class="identifier">atomic_long</span><span class="special">;</span>
|
|
<span class="keyword">typedef</span> <span class="identifier">atomic</span><span class="special"><</span> <span class="keyword">unsigned</span> <span class="keyword">long</span> <span class="keyword">long</span> <span class="special">></span> <span class="identifier">atomic_ullong</span><span class="special">;</span>
|
|
<span class="keyword">typedef</span> <span class="identifier">atomic</span><span class="special"><</span> <span class="keyword">long</span> <span class="keyword">long</span> <span class="special">></span> <span class="identifier">atomic_llong</span><span class="special">;</span>
|
|
|
|
<span class="keyword">typedef</span> <span class="identifier">atomic</span><span class="special"><</span> <span class="keyword">void</span><span class="special">*</span> <span class="special">></span> <span class="identifier">atomic_address</span><span class="special">;</span>
|
|
<span class="keyword">typedef</span> <span class="identifier">atomic</span><span class="special"><</span> <span class="keyword">bool</span> <span class="special">></span> <span class="identifier">atomic_bool</span><span class="special">;</span>
|
|
<span class="keyword">typedef</span> <span class="identifier">atomic</span><span class="special"><</span> <span class="keyword">wchar_t</span> <span class="special">></span> <span class="identifier">atomic_wchar_t</span><span class="special">;</span>
|
|
<span class="keyword">typedef</span> <span class="identifier">atomic</span><span class="special"><</span> <span class="keyword">char16_t</span> <span class="special">></span> <span class="identifier">atomic_char16_t</span><span class="special">;</span>
|
|
<span class="keyword">typedef</span> <span class="identifier">atomic</span><span class="special"><</span> <span class="keyword">char32_t</span> <span class="special">></span> <span class="identifier">atomic_char32_t</span><span class="special">;</span>
|
|
|
|
<span class="keyword">typedef</span> <span class="identifier">atomic</span><span class="special"><</span> <span class="identifier">uint8_t</span> <span class="special">></span> <span class="identifier">atomic_uint8_t</span><span class="special">;</span>
|
|
<span class="keyword">typedef</span> <span class="identifier">atomic</span><span class="special"><</span> <span class="identifier">int8_t</span> <span class="special">></span> <span class="identifier">atomic_int8_t</span><span class="special">;</span>
|
|
<span class="keyword">typedef</span> <span class="identifier">atomic</span><span class="special"><</span> <span class="identifier">uint16_t</span> <span class="special">></span> <span class="identifier">atomic_uint16_t</span><span class="special">;</span>
|
|
<span class="keyword">typedef</span> <span class="identifier">atomic</span><span class="special"><</span> <span class="identifier">int16_t</span> <span class="special">></span> <span class="identifier">atomic_int16_t</span><span class="special">;</span>
|
|
<span class="keyword">typedef</span> <span class="identifier">atomic</span><span class="special"><</span> <span class="identifier">uint32_t</span> <span class="special">></span> <span class="identifier">atomic_uint32_t</span><span class="special">;</span>
|
|
<span class="keyword">typedef</span> <span class="identifier">atomic</span><span class="special"><</span> <span class="identifier">int32_t</span> <span class="special">></span> <span class="identifier">atomic_int32_t</span><span class="special">;</span>
|
|
<span class="keyword">typedef</span> <span class="identifier">atomic</span><span class="special"><</span> <span class="identifier">uint64_t</span> <span class="special">></span> <span class="identifier">atomic_uint64_t</span><span class="special">;</span>
|
|
<span class="keyword">typedef</span> <span class="identifier">atomic</span><span class="special"><</span> <span class="identifier">int64_t</span> <span class="special">></span> <span class="identifier">atomic_int64_t</span><span class="special">;</span>
|
|
|
|
<span class="keyword">typedef</span> <span class="identifier">atomic</span><span class="special"><</span> <span class="identifier">int_least8_t</span> <span class="special">></span> <span class="identifier">atomic_int_least8_t</span><span class="special">;</span>
|
|
<span class="keyword">typedef</span> <span class="identifier">atomic</span><span class="special"><</span> <span class="identifier">uint_least8_t</span> <span class="special">></span> <span class="identifier">atomic_uint_least8_t</span><span class="special">;</span>
|
|
<span class="keyword">typedef</span> <span class="identifier">atomic</span><span class="special"><</span> <span class="identifier">int_least16_t</span> <span class="special">></span> <span class="identifier">atomic_int_least16_t</span><span class="special">;</span>
|
|
<span class="keyword">typedef</span> <span class="identifier">atomic</span><span class="special"><</span> <span class="identifier">uint_least16_t</span> <span class="special">></span> <span class="identifier">atomic_uint_least16_t</span><span class="special">;</span>
|
|
<span class="keyword">typedef</span> <span class="identifier">atomic</span><span class="special"><</span> <span class="identifier">int_least32_t</span> <span class="special">></span> <span class="identifier">atomic_int_least32_t</span><span class="special">;</span>
|
|
<span class="keyword">typedef</span> <span class="identifier">atomic</span><span class="special"><</span> <span class="identifier">uint_least32_t</span> <span class="special">></span> <span class="identifier">atomic_uint_least32_t</span><span class="special">;</span>
|
|
<span class="keyword">typedef</span> <span class="identifier">atomic</span><span class="special"><</span> <span class="identifier">int_least64_t</span> <span class="special">></span> <span class="identifier">atomic_int_least64_t</span><span class="special">;</span>
|
|
<span class="keyword">typedef</span> <span class="identifier">atomic</span><span class="special"><</span> <span class="identifier">uint_least64_t</span> <span class="special">></span> <span class="identifier">atomic_uint_least64_t</span><span class="special">;</span>
|
|
<span class="keyword">typedef</span> <span class="identifier">atomic</span><span class="special"><</span> <span class="identifier">int_fast8_t</span> <span class="special">></span> <span class="identifier">atomic_int_fast8_t</span><span class="special">;</span>
|
|
<span class="keyword">typedef</span> <span class="identifier">atomic</span><span class="special"><</span> <span class="identifier">uint_fast8_t</span> <span class="special">></span> <span class="identifier">atomic_uint_fast8_t</span><span class="special">;</span>
|
|
<span class="keyword">typedef</span> <span class="identifier">atomic</span><span class="special"><</span> <span class="identifier">int_fast16_t</span> <span class="special">></span> <span class="identifier">atomic_int_fast16_t</span><span class="special">;</span>
|
|
<span class="keyword">typedef</span> <span class="identifier">atomic</span><span class="special"><</span> <span class="identifier">uint_fast16_t</span> <span class="special">></span> <span class="identifier">atomic_uint_fast16_t</span><span class="special">;</span>
|
|
<span class="keyword">typedef</span> <span class="identifier">atomic</span><span class="special"><</span> <span class="identifier">int_fast32_t</span> <span class="special">></span> <span class="identifier">atomic_int_fast32_t</span><span class="special">;</span>
|
|
<span class="keyword">typedef</span> <span class="identifier">atomic</span><span class="special"><</span> <span class="identifier">uint_fast32_t</span> <span class="special">></span> <span class="identifier">atomic_uint_fast32_t</span><span class="special">;</span>
|
|
<span class="keyword">typedef</span> <span class="identifier">atomic</span><span class="special"><</span> <span class="identifier">int_fast64_t</span> <span class="special">></span> <span class="identifier">atomic_int_fast64_t</span><span class="special">;</span>
|
|
<span class="keyword">typedef</span> <span class="identifier">atomic</span><span class="special"><</span> <span class="identifier">uint_fast64_t</span> <span class="special">></span> <span class="identifier">atomic_uint_fast64_t</span><span class="special">;</span>
|
|
<span class="keyword">typedef</span> <span class="identifier">atomic</span><span class="special"><</span> <span class="identifier">intmax_t</span> <span class="special">></span> <span class="identifier">atomic_intmax_t</span><span class="special">;</span>
|
|
<span class="keyword">typedef</span> <span class="identifier">atomic</span><span class="special"><</span> <span class="identifier">uintmax_t</span> <span class="special">></span> <span class="identifier">atomic_uintmax_t</span><span class="special">;</span>
|
|
|
|
<span class="keyword">typedef</span> <span class="identifier">atomic</span><span class="special"><</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="special">></span> <span class="identifier">atomic_size_t</span><span class="special">;</span>
|
|
<span class="keyword">typedef</span> <span class="identifier">atomic</span><span class="special"><</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">ptrdiff_t</span> <span class="special">></span> <span class="identifier">atomic_ptrdiff_t</span><span class="special">;</span>
|
|
|
|
<span class="keyword">typedef</span> <span class="identifier">atomic</span><span class="special"><</span> <span class="identifier">intptr_t</span> <span class="special">></span> <span class="identifier">atomic_intptr_t</span><span class="special">;</span>
|
|
<span class="keyword">typedef</span> <span class="identifier">atomic</span><span class="special"><</span> <span class="identifier">uintptr_t</span> <span class="special">></span> <span class="identifier">atomic_uintptr_t</span><span class="special">;</span>
|
|
</pre>
|
|
<p>
|
|
The typedefs are provided only if the corresponding type is available.
|
|
</p>
|
|
</div>
|
|
</div>
|
|
<div class="section">
|
|
<div class="titlepage"><div><div><h3 class="title">
|
|
<a name="atomic.interface.interface_fences"></a><a class="link" href="interface.html#atomic.interface.interface_fences" title="Fences">Fences</a>
|
|
</h3></div></div></div>
|
|
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">atomic</span><span class="special">/</span><span class="identifier">fences</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span>
|
|
</pre>
|
|
<div class="informaltable"><table class="table">
|
|
<colgroup>
|
|
<col>
|
|
<col>
|
|
</colgroup>
|
|
<thead><tr>
|
|
<th>
|
|
<p>
|
|
Syntax
|
|
</p>
|
|
</th>
|
|
<th>
|
|
<p>
|
|
Description
|
|
</p>
|
|
</th>
|
|
</tr></thead>
|
|
<tbody>
|
|
<tr>
|
|
<td>
|
|
<p>
|
|
<code class="computeroutput"><span class="keyword">void</span> <span class="identifier">atomic_thread_fence</span><span class="special">(</span><span class="identifier">memory_order</span>
|
|
<span class="identifier">order</span><span class="special">)</span></code>
|
|
</p>
|
|
</td>
|
|
<td>
|
|
<p>
|
|
Issue fence for coordination with other threads.
|
|
</p>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td>
|
|
<p>
|
|
<code class="computeroutput"><span class="keyword">void</span> <span class="identifier">atomic_signal_fence</span><span class="special">(</span><span class="identifier">memory_order</span>
|
|
<span class="identifier">order</span><span class="special">)</span></code>
|
|
</p>
|
|
</td>
|
|
<td>
|
|
<p>
|
|
Issue fence for coordination with signal handler (only in same
|
|
thread).
|
|
</p>
|
|
</td>
|
|
</tr>
|
|
</tbody>
|
|
</table></div>
|
|
</div>
|
|
<div class="section">
|
|
<div class="titlepage"><div><div><h3 class="title">
|
|
<a name="atomic.interface.feature_macros"></a><a class="link" href="interface.html#atomic.interface.feature_macros" title="Feature testing macros">Feature testing macros</a>
|
|
</h3></div></div></div>
|
|
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special"><</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">atomic</span><span class="special">/</span><span class="identifier">capabilities</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">></span>
|
|
</pre>
|
|
<p>
|
|
<span class="bold"><strong>Boost.Atomic</strong></span> defines a number of macros
|
|
to allow compile-time detection whether an atomic data type is implemented
|
|
using "true" atomic operations, or whether an internal "lock"
|
|
is used to provide atomicity. The following macros will be defined to <code class="computeroutput"><span class="number">0</span></code> if operations on the data type always require
|
|
a lock, to <code class="computeroutput"><span class="number">1</span></code> if operations on
|
|
the data type may sometimes require a lock, and to <code class="computeroutput"><span class="number">2</span></code>
|
|
if they are always lock-free:
|
|
</p>
|
|
<div class="informaltable"><table class="table">
|
|
<colgroup>
|
|
<col>
|
|
<col>
|
|
</colgroup>
|
|
<thead><tr>
|
|
<th>
|
|
<p>
|
|
Macro
|
|
</p>
|
|
</th>
|
|
<th>
|
|
<p>
|
|
Description
|
|
</p>
|
|
</th>
|
|
</tr></thead>
|
|
<tbody>
|
|
<tr>
|
|
<td>
|
|
<p>
|
|
<code class="computeroutput"><span class="identifier">BOOST_ATOMIC_FLAG_LOCK_FREE</span></code>
|
|
</p>
|
|
</td>
|
|
<td>
|
|
<p>
|
|
Indicate whether <code class="computeroutput"><span class="identifier">atomic_flag</span></code>
|
|
is lock-free
|
|
</p>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td>
|
|
<p>
|
|
<code class="computeroutput"><span class="identifier">BOOST_ATOMIC_BOOL_LOCK_FREE</span></code>
|
|
</p>
|
|
</td>
|
|
<td>
|
|
<p>
|
|
Indicate whether <code class="computeroutput"><span class="identifier">atomic</span><span class="special"><</span><span class="keyword">bool</span><span class="special">></span></code> is lock-free
|
|
</p>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td>
|
|
<p>
|
|
<code class="computeroutput"><span class="identifier">BOOST_ATOMIC_CHAR_LOCK_FREE</span></code>
|
|
</p>
|
|
</td>
|
|
<td>
|
|
<p>
|
|
Indicate whether <code class="computeroutput"><span class="identifier">atomic</span><span class="special"><</span><span class="keyword">char</span><span class="special">></span></code> (including signed/unsigned
|
|
variants) is lock-free
|
|
</p>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td>
|
|
<p>
|
|
<code class="computeroutput"><span class="identifier">BOOST_ATOMIC_CHAR16_T_LOCK_FREE</span></code>
|
|
</p>
|
|
</td>
|
|
<td>
|
|
<p>
|
|
Indicate whether <code class="computeroutput"><span class="identifier">atomic</span><span class="special"><</span><span class="keyword">char16_t</span><span class="special">></span></code> (including signed/unsigned
|
|
variants) is lock-free
|
|
</p>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td>
|
|
<p>
|
|
<code class="computeroutput"><span class="identifier">BOOST_ATOMIC_CHAR32_T_LOCK_FREE</span></code>
|
|
</p>
|
|
</td>
|
|
<td>
|
|
<p>
|
|
Indicate whether <code class="computeroutput"><span class="identifier">atomic</span><span class="special"><</span><span class="keyword">char32_t</span><span class="special">></span></code> (including signed/unsigned
|
|
variants) is lock-free
|
|
</p>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td>
|
|
<p>
|
|
<code class="computeroutput"><span class="identifier">BOOST_ATOMIC_WCHAR_T_LOCK_FREE</span></code>
|
|
</p>
|
|
</td>
|
|
<td>
|
|
<p>
|
|
Indicate whether <code class="computeroutput"><span class="identifier">atomic</span><span class="special"><</span><span class="keyword">wchar_t</span><span class="special">></span></code> (including signed/unsigned
|
|
variants) is lock-free
|
|
</p>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td>
|
|
<p>
|
|
<code class="computeroutput"><span class="identifier">BOOST_ATOMIC_SHORT_LOCK_FREE</span></code>
|
|
</p>
|
|
</td>
|
|
<td>
|
|
<p>
|
|
Indicate whether <code class="computeroutput"><span class="identifier">atomic</span><span class="special"><</span><span class="keyword">short</span><span class="special">></span></code> (including signed/unsigned
|
|
variants) is lock-free
|
|
</p>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td>
|
|
<p>
|
|
<code class="computeroutput"><span class="identifier">BOOST_ATOMIC_INT_LOCK_FREE</span></code>
|
|
</p>
|
|
</td>
|
|
<td>
|
|
<p>
|
|
Indicate whether <code class="computeroutput"><span class="identifier">atomic</span><span class="special"><</span><span class="keyword">int</span><span class="special">></span></code> (including signed/unsigned
|
|
variants) is lock-free
|
|
</p>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td>
|
|
<p>
|
|
<code class="computeroutput"><span class="identifier">BOOST_ATOMIC_LONG_LOCK_FREE</span></code>
|
|
</p>
|
|
</td>
|
|
<td>
|
|
<p>
|
|
Indicate whether <code class="computeroutput"><span class="identifier">atomic</span><span class="special"><</span><span class="keyword">long</span><span class="special">></span></code> (including signed/unsigned
|
|
variants) is lock-free
|
|
</p>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td>
|
|
<p>
|
|
<code class="computeroutput"><span class="identifier">BOOST_ATOMIC_LLONG_LOCK_FREE</span></code>
|
|
</p>
|
|
</td>
|
|
<td>
|
|
<p>
|
|
Indicate whether <code class="computeroutput"><span class="identifier">atomic</span><span class="special"><</span><span class="keyword">long</span>
|
|
<span class="keyword">long</span><span class="special">></span></code>
|
|
(including signed/unsigned variants) is lock-free
|
|
</p>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td>
|
|
<p>
|
|
<code class="computeroutput"><span class="identifier">BOOST_ATOMIC_ADDRESS_LOCK_FREE</span></code>
|
|
or <code class="computeroutput"><span class="identifier">BOOST_ATOMIC_POINTER_LOCK_FREE</span></code>
|
|
</p>
|
|
</td>
|
|
<td>
|
|
<p>
|
|
Indicate whether <code class="computeroutput"><span class="identifier">atomic</span><span class="special"><</span><span class="identifier">T</span>
|
|
<span class="special">*></span></code> is lock-free
|
|
</p>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td>
|
|
<p>
|
|
<code class="computeroutput"><span class="identifier">BOOST_ATOMIC_THREAD_FENCE</span></code>
|
|
</p>
|
|
</td>
|
|
<td>
|
|
<p>
|
|
Indicate whether <code class="computeroutput"><span class="identifier">atomic_thread_fence</span></code>
|
|
function is lock-free
|
|
</p>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td>
|
|
<p>
|
|
<code class="computeroutput"><span class="identifier">BOOST_ATOMIC_SIGNAL_FENCE</span></code>
|
|
</p>
|
|
</td>
|
|
<td>
|
|
<p>
|
|
Indicate whether <code class="computeroutput"><span class="identifier">atomic_signal_fence</span></code>
|
|
function is lock-free
|
|
</p>
|
|
</td>
|
|
</tr>
|
|
</tbody>
|
|
</table></div>
|
|
<p>
|
|
In addition to these standard macros, <span class="bold"><strong>Boost.Atomic</strong></span>
|
|
also defines a number of extension macros, which can also be useful. Like
|
|
the standard ones, these macros are defined to values <code class="computeroutput"><span class="number">0</span></code>,
|
|
<code class="computeroutput"><span class="number">1</span></code> and <code class="computeroutput"><span class="number">2</span></code>
|
|
to indicate whether the corresponding operations are lock-free or not.
|
|
</p>
|
|
<div class="informaltable"><table class="table">
|
|
<colgroup>
|
|
<col>
|
|
<col>
|
|
</colgroup>
|
|
<thead><tr>
|
|
<th>
|
|
<p>
|
|
Macro
|
|
</p>
|
|
</th>
|
|
<th>
|
|
<p>
|
|
Description
|
|
</p>
|
|
</th>
|
|
</tr></thead>
|
|
<tbody>
|
|
<tr>
|
|
<td>
|
|
<p>
|
|
<code class="computeroutput"><span class="identifier">BOOST_ATOMIC_INT8_LOCK_FREE</span></code>
|
|
</p>
|
|
</td>
|
|
<td>
|
|
<p>
|
|
Indicate whether <code class="computeroutput"><span class="identifier">atomic</span><span class="special"><</span><span class="identifier">int8_type</span><span class="special">></span></code> is lock-free.
|
|
</p>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td>
|
|
<p>
|
|
<code class="computeroutput"><span class="identifier">BOOST_ATOMIC_INT16_LOCK_FREE</span></code>
|
|
</p>
|
|
</td>
|
|
<td>
|
|
<p>
|
|
Indicate whether <code class="computeroutput"><span class="identifier">atomic</span><span class="special"><</span><span class="identifier">int16_type</span><span class="special">></span></code> is lock-free.
|
|
</p>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td>
|
|
<p>
|
|
<code class="computeroutput"><span class="identifier">BOOST_ATOMIC_INT32_LOCK_FREE</span></code>
|
|
</p>
|
|
</td>
|
|
<td>
|
|
<p>
|
|
Indicate whether <code class="computeroutput"><span class="identifier">atomic</span><span class="special"><</span><span class="identifier">int32_type</span><span class="special">></span></code> is lock-free.
|
|
</p>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td>
|
|
<p>
|
|
<code class="computeroutput"><span class="identifier">BOOST_ATOMIC_INT64_LOCK_FREE</span></code>
|
|
</p>
|
|
</td>
|
|
<td>
|
|
<p>
|
|
Indicate whether <code class="computeroutput"><span class="identifier">atomic</span><span class="special"><</span><span class="identifier">int64_type</span><span class="special">></span></code> is lock-free.
|
|
</p>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td>
|
|
<p>
|
|
<code class="computeroutput"><span class="identifier">BOOST_ATOMIC_INT128_LOCK_FREE</span></code>
|
|
</p>
|
|
</td>
|
|
<td>
|
|
<p>
|
|
Indicate whether <code class="computeroutput"><span class="identifier">atomic</span><span class="special"><</span><span class="identifier">int128_type</span><span class="special">></span></code> is lock-free.
|
|
</p>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td>
|
|
<p>
|
|
<code class="computeroutput"><span class="identifier">BOOST_ATOMIC_NO_ATOMIC_FLAG_INIT</span></code>
|
|
</p>
|
|
</td>
|
|
<td>
|
|
<p>
|
|
Defined after including <code class="computeroutput"><span class="identifier">atomic_flag</span><span class="special">.</span><span class="identifier">hpp</span></code>,
|
|
if the implementation does not support the <code class="computeroutput"><span class="identifier">BOOST_ATOMIC_FLAG_INIT</span></code>
|
|
macro for static initialization of <code class="computeroutput"><span class="identifier">atomic_flag</span></code>.
|
|
This macro is typically defined for pre-C++11 compilers.
|
|
</p>
|
|
</td>
|
|
</tr>
|
|
</tbody>
|
|
</table></div>
|
|
<p>
|
|
In the table above, <code class="computeroutput"><span class="identifier">intN_type</span></code>
|
|
is a type that fits storage of contiguous <code class="computeroutput"><span class="identifier">N</span></code>
|
|
bits, suitably aligned for atomic operations.
|
|
</p>
|
|
</div>
|
|
</div>
|
|
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
|
|
<td align="left"></td>
|
|
<td align="right"><div class="copyright-footer">Copyright © 2011 Helge Bahmann<br>Copyright © 2012 Tim Blechmann<br>Copyright © 2013, 2017 Andrey Semashev<p>
|
|
Distributed under the Boost Software License, Version 1.0. (See accompanying
|
|
file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
|
|
</p>
|
|
</div></td>
|
|
</tr></table>
|
|
<hr>
|
|
<div class="spirit-nav">
|
|
<a accesskey="p" href="thread_coordination.html"><img src="../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../atomic.html"><img src="../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="usage_examples.html"><img src="../../../doc/src/images/next.png" alt="Next"></a>
|
|
</div>
|
|
</body>
|
|
</html>
|