FangSoftSoft
/
libcxx


			
				
					
						
						
							123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249
							<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"
          "http://www.w3.org/TR/html4/strict.dtd">
<!-- Material used from: HTML 4.01 specs: http://www.w3.org/TR/html401/ -->
<html>
<head>
  <META http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
  <title>&lt;atomic&gt; design</title>
  <link type="text/css" rel="stylesheet" href="menu.css">
  <link type="text/css" rel="stylesheet" href="content.css">
</head>

<body>
<div id="menu">
  <div>
    <a href="https://llvm.org/">LLVM Home</a>
  </div>

  <div class="submenu">
    <label>libc++ Info</label>
    <a href="/index.html">About</a>
  </div>

  <div class="submenu">
    <label>Quick Links</label>
    <a href="https://lists.llvm.org/mailman/listinfo/cfe-dev">cfe-dev</a>
    <a href="https://lists.llvm.org/mailman/listinfo/cfe-commits">cfe-commits</a>
    <a href="https://bugs.llvm.org/">Bug Reports</a>
    <a href="https://github.com/llvm/llvm-project/tree/master/libcxx/">Browse Sources</a>
  </div>
</div>

<div id="content">
  <!--*********************************************************************-->
  <h1>&lt;atomic&gt; design</h1>
  <!--*********************************************************************-->

<p>
This is a variation of design A which puts the burden on the library to arrange
for the correct manipulation of the run time memory ordering arguments, and only
calls the compiler for well-defined memory orderings.  I think of this design as
the worst of A and C, instead of the best of A and C.  But I offer it as an
option in the spirit of completeness.
</p>

<blockquote><pre>
<font color="#C80000">// type must be trivially copyable</font>
bool __atomic_is_lock_free(const type* atomic_obj);

<font color="#C80000">// type must be trivially copyable</font>
type __atomic_load_relaxed(const volatile type* atomic_obj);
type __atomic_load_consume(const volatile type* atomic_obj);
type __atomic_load_acquire(const volatile type* atomic_obj);
type __atomic_load_seq_cst(const volatile type* atomic_obj);

<font color="#C80000">// type must be trivially copyable</font>
type __atomic_store_relaxed(volatile type* atomic_obj, type desired);
type __atomic_store_release(volatile type* atomic_obj, type desired);
type __atomic_store_seq_cst(volatile type* atomic_obj, type desired);

<font color="#C80000">// type must be trivially copyable</font>
type __atomic_exchange_relaxed(volatile type* atomic_obj, type desired);
type __atomic_exchange_consume(volatile type* atomic_obj, type desired);
type __atomic_exchange_acquire(volatile type* atomic_obj, type desired);
type __atomic_exchange_release(volatile type* atomic_obj, type desired);
type __atomic_exchange_acq_rel(volatile type* atomic_obj, type desired);
type __atomic_exchange_seq_cst(volatile type* atomic_obj, type desired);

<font color="#C80000">// type must be trivially copyable</font>
bool __atomic_compare_exchange_strong_relaxed_relaxed(volatile type* atomic_obj,
                                                      type* expected,
                                                      type desired);
bool __atomic_compare_exchange_strong_consume_relaxed(volatile type* atomic_obj,
                                                      type* expected,
                                                      type desired);
bool __atomic_compare_exchange_strong_consume_consume(volatile type* atomic_obj,
                                                      type* expected,
                                                      type desired);
bool __atomic_compare_exchange_strong_acquire_relaxed(volatile type* atomic_obj,
                                                      type* expected,
                                                      type desired);
bool __atomic_compare_exchange_strong_acquire_consume(volatile type* atomic_obj,
                                                      type* expected,
                                                      type desired);
bool __atomic_compare_exchange_strong_acquire_acquire(volatile type* atomic_obj,
                                                      type* expected,
                                                      type desired);
bool __atomic_compare_exchange_strong_release_relaxed(volatile type* atomic_obj,
                                                      type* expected,
                                                      type desired);
bool __atomic_compare_exchange_strong_release_consume(volatile type* atomic_obj,
                                                      type* expected,
                                                      type desired);
bool __atomic_compare_exchange_strong_release_acquire(volatile type* atomic_obj,
                                                      type* expected,
                                                      type desired);
bool __atomic_compare_exchange_strong_acq_rel_relaxed(volatile type* atomic_obj,
                                                      type* expected,
                                                      type desired);
bool __atomic_compare_exchange_strong_acq_rel_consume(volatile type* atomic_obj,
                                                      type* expected,
                                                      type desired);
bool __atomic_compare_exchange_strong_acq_rel_acquire(volatile type* atomic_obj,
                                                      type* expected,
                                                      type desired);
bool __atomic_compare_exchange_strong_seq_cst_relaxed(volatile type* atomic_obj,
                                                      type* expected,
                                                      type desired);
bool __atomic_compare_exchange_strong_seq_cst_consume(volatile type* atomic_obj,
                                                      type* expected,
                                                      type desired);
bool __atomic_compare_exchange_strong_seq_cst_acquire(volatile type* atomic_obj,
                                                      type* expected,
                                                      type desired);
bool __atomic_compare_exchange_strong_seq_cst_seq_cst(volatile type* atomic_obj,
                                                      type* expected,
                                                      type desired);

<font color="#C80000">// type must be trivially copyable</font>
bool __atomic_compare_exchange_weak_relaxed_relaxed(volatile type* atomic_obj,
                                                    type* expected,
                                                    type desired);
bool __atomic_compare_exchange_weak_consume_relaxed(volatile type* atomic_obj,
                                                    type* expected,
                                                    type desired);
bool __atomic_compare_exchange_weak_consume_consume(volatile type* atomic_obj,
                                                    type* expected,
                                                    type desired);
bool __atomic_compare_exchange_weak_acquire_relaxed(volatile type* atomic_obj,
                                                    type* expected,
                                                    type desired);
bool __atomic_compare_exchange_weak_acquire_consume(volatile type* atomic_obj,
                                                    type* expected,
                                                    type desired);
bool __atomic_compare_exchange_weak_acquire_acquire(volatile type* atomic_obj,
                                                    type* expected,
                                                    type desired);
bool __atomic_compare_exchange_weak_release_relaxed(volatile type* atomic_obj,
                                                    type* expected,
                                                    type desired);
bool __atomic_compare_exchange_weak_release_consume(volatile type* atomic_obj,
                                                    type* expected,
                                                    type desired);
bool __atomic_compare_exchange_weak_release_acquire(volatile type* atomic_obj,
                                                    type* expected,
                                                    type desired);
bool __atomic_compare_exchange_weak_acq_rel_relaxed(volatile type* atomic_obj,
                                                    type* expected,
                                                    type desired);
bool __atomic_compare_exchange_weak_acq_rel_consume(volatile type* atomic_obj,
                                                    type* expected,
                                                    type desired);
bool __atomic_compare_exchange_weak_acq_rel_acquire(volatile type* atomic_obj,
                                                    type* expected,
                                                    type desired);
bool __atomic_compare_exchange_weak_seq_cst_relaxed(volatile type* atomic_obj,
                                                    type* expected,
                                                    type desired);
bool __atomic_compare_exchange_weak_seq_cst_consume(volatile type* atomic_obj,
                                                    type* expected,
                                                    type desired);
bool __atomic_compare_exchange_weak_seq_cst_acquire(volatile type* atomic_obj,
                                                    type* expected,
                                                    type desired);
bool __atomic_compare_exchange_weak_seq_cst_seq_cst(volatile type* atomic_obj,
                                                    type* expected,
                                                    type desired);

<font color="#C80000">// type is one of: char, signed char, unsigned char, short, unsigned short, int,</font>
<font color="#C80000">//      unsigned int, long, unsigned long, long long, unsigned long long,</font>
<font color="#C80000">//      char16_t, char32_t, wchar_t</font>
type __atomic_fetch_add_relaxed(volatile type* atomic_obj, type operand);
type __atomic_fetch_add_consume(volatile type* atomic_obj, type operand);
type __atomic_fetch_add_acquire(volatile type* atomic_obj, type operand);
type __atomic_fetch_add_release(volatile type* atomic_obj, type operand);
type __atomic_fetch_add_acq_rel(volatile type* atomic_obj, type operand);
type __atomic_fetch_add_seq_cst(volatile type* atomic_obj, type operand);

<font color="#C80000">// type is one of: char, signed char, unsigned char, short, unsigned short, int,</font>
<font color="#C80000">//      unsigned int, long, unsigned long, long long, unsigned long long,</font>
<font color="#C80000">//      char16_t, char32_t, wchar_t</font>
type __atomic_fetch_sub_relaxed(volatile type* atomic_obj, type operand);
type __atomic_fetch_sub_consume(volatile type* atomic_obj, type operand);
type __atomic_fetch_sub_acquire(volatile type* atomic_obj, type operand);
type __atomic_fetch_sub_release(volatile type* atomic_obj, type operand);
type __atomic_fetch_sub_acq_rel(volatile type* atomic_obj, type operand);
type __atomic_fetch_sub_seq_cst(volatile type* atomic_obj, type operand);

<font color="#C80000">// type is one of: char, signed char, unsigned char, short, unsigned short, int,</font>
<font color="#C80000">//      unsigned int, long, unsigned long, long long, unsigned long long,</font>
<font color="#C80000">//      char16_t, char32_t, wchar_t</font>
type __atomic_fetch_and_relaxed(volatile type* atomic_obj, type operand);
type __atomic_fetch_and_consume(volatile type* atomic_obj, type operand);
type __atomic_fetch_and_acquire(volatile type* atomic_obj, type operand);
type __atomic_fetch_and_release(volatile type* atomic_obj, type operand);
type __atomic_fetch_and_acq_rel(volatile type* atomic_obj, type operand);
type __atomic_fetch_and_seq_cst(volatile type* atomic_obj, type operand);

<font color="#C80000">// type is one of: char, signed char, unsigned char, short, unsigned short, int,</font>
<font color="#C80000">//      unsigned int, long, unsigned long, long long, unsigned long long,</font>
<font color="#C80000">//      char16_t, char32_t, wchar_t</font>
type __atomic_fetch_or_relaxed(volatile type* atomic_obj, type operand);
type __atomic_fetch_or_consume(volatile type* atomic_obj, type operand);
type __atomic_fetch_or_acquire(volatile type* atomic_obj, type operand);
type __atomic_fetch_or_release(volatile type* atomic_obj, type operand);
type __atomic_fetch_or_acq_rel(volatile type* atomic_obj, type operand);
type __atomic_fetch_or_seq_cst(volatile type* atomic_obj, type operand);

<font color="#C80000">// type is one of: char, signed char, unsigned char, short, unsigned short, int,</font>
<font color="#C80000">//      unsigned int, long, unsigned long, long long, unsigned long long,</font>
<font color="#C80000">//      char16_t, char32_t, wchar_t</font>
type __atomic_fetch_xor_relaxed(volatile type* atomic_obj, type operand);
type __atomic_fetch_xor_consume(volatile type* atomic_obj, type operand);
type __atomic_fetch_xor_acquire(volatile type* atomic_obj, type operand);
type __atomic_fetch_xor_release(volatile type* atomic_obj, type operand);
type __atomic_fetch_xor_acq_rel(volatile type* atomic_obj, type operand);
type __atomic_fetch_xor_seq_cst(volatile type* atomic_obj, type operand);

void* __atomic_fetch_add_relaxed(void* volatile* atomic_obj, ptrdiff_t operand);
void* __atomic_fetch_add_consume(void* volatile* atomic_obj, ptrdiff_t operand);
void* __atomic_fetch_add_acquire(void* volatile* atomic_obj, ptrdiff_t operand);
void* __atomic_fetch_add_release(void* volatile* atomic_obj, ptrdiff_t operand);
void* __atomic_fetch_add_acq_rel(void* volatile* atomic_obj, ptrdiff_t operand);
void* __atomic_fetch_add_seq_cst(void* volatile* atomic_obj, ptrdiff_t operand);

void* __atomic_fetch_sub_relaxed(void* volatile* atomic_obj, ptrdiff_t operand);
void* __atomic_fetch_sub_consume(void* volatile* atomic_obj, ptrdiff_t operand);
void* __atomic_fetch_sub_acquire(void* volatile* atomic_obj, ptrdiff_t operand);
void* __atomic_fetch_sub_release(void* volatile* atomic_obj, ptrdiff_t operand);
void* __atomic_fetch_sub_acq_rel(void* volatile* atomic_obj, ptrdiff_t operand);
void* __atomic_fetch_sub_seq_cst(void* volatile* atomic_obj, ptrdiff_t operand);

void __atomic_thread_fence_relaxed();
void __atomic_thread_fence_consume();
void __atomic_thread_fence_acquire();
void __atomic_thread_fence_release();
void __atomic_thread_fence_acq_rel();
void __atomic_thread_fence_seq_cst();

void __atomic_signal_fence_relaxed();
void __atomic_signal_fence_consume();
void __atomic_signal_fence_acquire();
void __atomic_signal_fence_release();
void __atomic_signal_fence_acq_rel();
void __atomic_signal_fence_seq_cst();
</pre></blockquote>

</div>
</body>
</html>