<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml" lang xml:lang>
<head>
  <meta charset="utf-8" />
  <meta name="generator" content="mpark/wg21" />
  <meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=yes" />
  <meta name="dcterms.date" content="2024-04-29" />
  <title>Atomic Refs Bound to Memory Orderings &amp; Atomic Accessors</title>
  <style>
code{white-space: pre-wrap;}
span.smallcaps{font-variant: small-caps;}
span.underline{text-decoration: underline;}
div.column{display: inline-block; vertical-align: top; width: 50%;}
</style>
  <style>
pre > code.sourceCode { white-space: pre; position: relative; }
pre > code.sourceCode > span { display: inline-block; line-height: 1.25; }
pre > code.sourceCode > span:empty { height: 1.2em; }
.sourceCode { overflow: visible; }
code.sourceCode > span { color: inherit; text-decoration: inherit; }
div.sourceCode { margin: 1em 0; }
pre.sourceCode { margin: 0; }
@media screen {
div.sourceCode { overflow: auto; }
}
@media print {
pre > code.sourceCode { white-space: pre-wrap; }
pre > code.sourceCode > span { text-indent: -5em; padding-left: 5em; }
}
pre.numberSource code
{ counter-reset: source-line 0; }
pre.numberSource code > span
{ position: relative; left: -4em; counter-increment: source-line; }
pre.numberSource code > span > a:first-child::before
{ content: counter(source-line);
position: relative; left: -1em; text-align: right; vertical-align: baseline;
border: none; display: inline-block;
-webkit-touch-callout: none; -webkit-user-select: none;
-khtml-user-select: none; -moz-user-select: none;
-ms-user-select: none; user-select: none;
padding: 0 4px; width: 4em;
color: #aaaaaa;
}
pre.numberSource { margin-left: 3em; border-left: 1px solid #aaaaaa; padding-left: 4px; }
div.sourceCode
{ background-color: #f6f8fa; }
@media screen {
pre > code.sourceCode > span > a:first-child::before { text-decoration: underline; }
}
code span { } 
code span.al { color: #ff0000; } 
code span.an { } 
code span.at { } 
code span.bn { color: #9f6807; } 
code span.bu { color: #9f6807; } 
code span.cf { color: #00607c; } 
code span.ch { color: #9f6807; } 
code span.cn { } 
code span.co { color: #008000; font-style: italic; } 
code span.cv { color: #008000; font-style: italic; } 
code span.do { color: #008000; } 
code span.dt { color: #00607c; } 
code span.dv { color: #9f6807; } 
code span.er { color: #ff0000; font-weight: bold; } 
code span.ex { } 
code span.fl { color: #9f6807; } 
code span.fu { } 
code span.im { } 
code span.in { color: #008000; } 
code span.kw { color: #00607c; } 
code span.op { color: #af1915; } 
code span.ot { } 
code span.pp { color: #6f4e37; } 
code span.re { } 
code span.sc { color: #9f6807; } 
code span.ss { color: #9f6807; } 
code span.st { color: #9f6807; } 
code span.va { } 
code span.vs { color: #9f6807; } 
code span.wa { color: #008000; font-weight: bold; } 
code.diff {color: #898887}
code.diff span.va {color: #00AA00}
code.diff span.st {color: #bf0303}
</style>
  <style type="text/css">
body {
margin: 5em;
font-family: serif;

hyphens: auto;
line-height: 1.35;
}
div.wrapper {
max-width: 60em;
margin: auto;
}
ul {
list-style-type: none;
padding-left: 2em;
margin-top: -0.2em;
margin-bottom: -0.2em;
}
a {
text-decoration: none;
color: #4183C4;
}
a.hidden_link {
text-decoration: none;
color: inherit;
}
li {
margin-top: 0.6em;
margin-bottom: 0.6em;
}
h1, h2, h3, h4 {
position: relative;
line-height: 1;
}
a.self-link {
position: absolute;
top: 0;
left: calc(-1 * (3.5rem - 26px));
width: calc(3.5rem - 26px);
height: 2em;
text-align: center;
border: none;
transition: opacity .2s;
opacity: .5;
font-family: sans-serif;
font-weight: normal;
font-size: 83%;
}
a.self-link:hover { opacity: 1; }
a.self-link::before { content: "§"; }
ul > li:before {
content: "\2014";
position: absolute;
margin-left: -1.5em;
}
:target { background-color: #C9FBC9; }
:target .codeblock { background-color: #C9FBC9; }
:target ul { background-color: #C9FBC9; }
.abbr_ref { float: right; }
.folded_abbr_ref { float: right; }
:target .folded_abbr_ref { display: none; }
:target .unfolded_abbr_ref { float: right; display: inherit; }
.unfolded_abbr_ref { display: none; }
.secnum { display: inline-block; min-width: 35pt; }
.header-section-number { display: inline-block; min-width: 35pt; }
.annexnum { display: block; }
div.sourceLinkParent {
float: right;
}
a.sourceLink {
position: absolute;
opacity: 0;
margin-left: 10pt;
}
a.sourceLink:hover {
opacity: 1;
}
a.itemDeclLink {
position: absolute;
font-size: 75%;
text-align: right;
width: 5em;
opacity: 0;
}
a.itemDeclLink:hover { opacity: 1; }
span.marginalizedparent {
position: relative;
left: -5em;
}
li span.marginalizedparent { left: -7em; }
li ul > li span.marginalizedparent { left: -9em; }
li ul > li ul > li span.marginalizedparent { left: -11em; }
li ul > li ul > li ul > li span.marginalizedparent { left: -13em; }
div.footnoteNumberParent {
position: relative;
left: -4.7em;
}
a.marginalized {
position: absolute;
font-size: 75%;
text-align: right;
width: 5em;
}
a.enumerated_item_num {
position: relative;
left: -3.5em;
display: inline-block;
margin-right: -3em;
text-align: right;
width: 3em;
}
div.para { margin-bottom: 0.6em; margin-top: 0.6em; text-align: justify; }
div.section { text-align: justify; }
div.sentence { display: inline; }
span.indexparent {
display: inline;
position: relative;
float: right;
right: -1em;
}
a.index {
position: absolute;
display: none;
}
a.index:before { content: "⟵"; }

a.index:target {
display: inline;
}
.indexitems {
margin-left: 2em;
text-indent: -2em;
}
div.itemdescr {
margin-left: 3em;
}
.bnf {
font-family: serif;
margin-left: 40pt;
margin-top: 0.5em;
margin-bottom: 0.5em;
}
.ncbnf {
font-family: serif;
margin-top: 0.5em;
margin-bottom: 0.5em;
margin-left: 40pt;
}
.ncsimplebnf {
font-family: serif;
font-style: italic;
margin-top: 0.5em;
margin-bottom: 0.5em;
margin-left: 40pt;
background: inherit; 
}
span.textnormal {
font-style: normal;
font-family: serif;
white-space: normal;
display: inline-block;
}
span.rlap {
display: inline-block;
width: 0px;
}
span.descr { font-style: normal; font-family: serif; }
span.grammarterm { font-style: italic; }
span.term { font-style: italic; }
span.terminal { font-family: monospace; font-style: normal; }
span.nonterminal { font-style: italic; }
span.tcode { font-family: monospace; font-style: normal; }
span.textbf { font-weight: bold; }
span.textsc { font-variant: small-caps; }
a.nontermdef { font-style: italic; font-family: serif; }
span.emph { font-style: italic; }
span.techterm { font-style: italic; }
span.mathit { font-style: italic; }
span.mathsf { font-family: sans-serif; }
span.mathrm { font-family: serif; font-style: normal; }
span.textrm { font-family: serif; }
span.textsl { font-style: italic; }
span.mathtt { font-family: monospace; font-style: normal; }
span.mbox { font-family: serif; font-style: normal; }
span.ungap { display: inline-block; width: 2pt; }
span.textit { font-style: italic; }
span.texttt { font-family: monospace; }
span.tcode_in_codeblock { font-family: monospace; font-style: normal; }
span.phantom { color: white; }

span.math { font-style: normal; }
span.mathblock {
display: block;
margin-left: auto;
margin-right: auto;
margin-top: 1.2em;
margin-bottom: 1.2em;
text-align: center;
}
span.mathalpha {
font-style: italic;
}
span.synopsis {
font-weight: bold;
margin-top: 0.5em;
display: block;
}
span.definition {
font-weight: bold;
display: block;
}
.codeblock {
margin-left: 1.2em;
line-height: 127%;
}
.outputblock {
margin-left: 1.2em;
line-height: 127%;
}
div.itemdecl {
margin-top: 2ex;
}
code.itemdeclcode {
white-space: pre;
display: block;
}
span.textsuperscript {
vertical-align: super;
font-size: smaller;
line-height: 0;
}
.footnotenum { vertical-align: super; font-size: smaller; line-height: 0; }
.footnote {
font-size: small;
margin-left: 2em;
margin-right: 2em;
margin-top: 0.6em;
margin-bottom: 0.6em;
}
div.minipage {
display: inline-block;
margin-right: 3em;
}
div.numberedTable {
text-align: center;
margin: 2em;
}
div.figure {
text-align: center;
margin: 2em;
}
table {
border: 1px solid black;
border-collapse: collapse;
margin-left: auto;
margin-right: auto;
margin-top: 0.8em;
text-align: left;
hyphens: none; 
}
td, th {
padding-left: 1em;
padding-right: 1em;
vertical-align: top;
}
td.empty {
padding: 0px;
padding-left: 1px;
}
td.left {
text-align: left;
}
td.right {
text-align: right;
}
td.center {
text-align: center;
}
td.justify {
text-align: justify;
}
td.border {
border-left: 1px solid black;
}
tr.rowsep, td.cline {
border-top: 1px solid black;
}
tr.even, tr.odd {
border-bottom: 1px solid black;
}
tr.capsep {
border-top: 3px solid black;
border-top-style: double;
}
tr.header {
border-bottom: 3px solid black;
border-bottom-style: double;
}
th {
border-bottom: 1px solid black;
}
span.centry {
font-weight: bold;
}
div.table {
display: block;
margin-left: auto;
margin-right: auto;
text-align: center;
width: 90%;
}
span.indented {
display: block;
margin-left: 2em;
margin-bottom: 1em;
margin-top: 1em;
}
ol.enumeratea { list-style-type: none; background: inherit; }
ol.enumerate { list-style-type: none; background: inherit; }

code.sourceCode > span { display: inline; }

div#refs p { padding-left: 32px; text-indent: -32px; }
</style>
  <link href="data:text/html; charset=utf-8;charset=utf-8,%3Chtml%3E%0A%3Chead%3E%0A%3Ctitle%3EBIG%2DIP%20Per%20Request%20Policy%20Resource%20blocked%20page%3C%2Ftitle%3E%0A%3Cstyle%3E%0Abody%2C%20html%20%7B%0A%20%20%20%20padding%3A%200%3B%0A%20%20%20%20margin%3A%200%3B%0A%20%20%20%20height%3A%20100%25%3B%0A%7D%0Atable%2C%20td%2C%20th%2C%20div%20%7B%0A%20%20%20%20border%3A%200%3B%0A%20%20%20%20padding%3A%200%3B%0A%20%20%20%20margin%3A%200%3B%0A%7D%0Abody%2C%20table%2C%20td%2C%20th%2C%20div%2C%20input%2C%20h1%2C%20h2%2C%20h3%2C%20h4%2C%20h5%2C%20h6%20%7B%0A%20%20%20%20font%2Dfamily%20%3A%20Calibri%2C%20Tahoma%2C%20Verdana%2C%20Arial%2C%20Helvetica%2C%20Sans%2DSerif%3B%0A%20%20%20%20color%3A%20%23000000%3B%0A%20%20%20%20text%2Dalign%3A%20center%3B%0A%7D%0Abody%2C%20table%2C%20td%2C%20th%2C%20div%2C%20input%20%7B%0A%20%20%20%20font%2Dsize%20%3A%2014px%3B%0A%7D%0Ah1%2C%20h2%2C%20h3%2C%20h4%2C%20h5%2C%20h6%20%7B%0A%20%20%20%20font%2Dsize%20%3A%2018px%3B%0A%20%20%20%20text%2Ddecoration%3A%20none%3B%0A%20%20%20%20margin%2Dbottom%3A%200px%3B%0A%7D%0Abody%0A%7B%0A%20%20%20%20background%2Dcolor%3A%20%23FFFFFF%3B%0A%7D%0Atable%23page%5Fheader%0A%7B%0A%20%20%20%20width%3A%20100%25%3B%0A%20%20%20%20height%3A%2080px%3B%0A%20%20%20%20background%2Dcolor%3A%20%23FFFFFF%3B%0A%20%20%20%20background%2Drepeat%3A%20repeat%2Dx%3B%0A%7D%0Atable%23main%5Ftable%0A%7B%0A%20%20%20%20width%3A100%25%3B%0A%7D%0A%3C%2Fstyle%3E%0A%3C%2Fhead%3E%0A%0A%3Cscript%20language%3D%22javascript%22%3E%0Afunction%20OnLoad%28%29%20%7B%0A%20%20%20%20var%20category%20%3D%20%22Information%20Technology%22%3B%0A%20%20%20%20var%20categoryDiv%20%3D%20document%2EgetElementById%28%27display%5Fcategory%27%29%3B%0A%20%20%20%20if%20%28category%20%3D%3D%3D%20%22%22%29%20%7B%0A%20%20%20%20%20%20%20%20categoryDiv%2Estyle%2Evisibility%20%3D%20%27hidden%27%3B%0A%20%20%20%20%7D%20else%20%7B%0A%20%20%20%20%20%20%20%20categoryDiv%2Estyle%2Evisibility%20%3D%20%27visible%27%3B%0A%20%20%20%20%20%20%20%20categoryDiv%2EinnerHTML%20%2B%3D%20%27%3Ctd%3E%27%20%2B%20%22The%20category%20reference%20is%3A%22%20%2B%20%27%20%27%20%2B%20category%20%2B%20%27%3C%2Ftd%3E%27%3B%0A%20%20%20%20%7D%0A%7D%0A%3C%2Fscript%3E%0A%3Cbody%20onload%3D%22OnLoad%28%29%3B%22%3E%0A%20%20%20%20%3Ctable%20id%3D%22page%5Fheader%22%3E%0A%20%20%20%20%20%20%20%20%3Ctr%3E%3Ctd%20style%3D%22padding%2Dleft%3A10px%3B%22%3E%0A%20%20%20%20%20%20%20%20%20%20%20%20%3Ch1%3ETransparent%20proxy%20access%20blocked%2E%20%3Cbr%3E%20Please%20verify%20your%20proxy%20setting%20are%20correct%2E%20%3Cbr%3E%20Contact%20CCHD%20if%20you%20need%20assistance%2E%3C%2Fh1%3E%20%20%20%20%20%20%20%20%3C%2Ftd%3E%3C%2Ftr%3E%0A%20%20%20%20%3C%2Ftable%3E%0A%20%20%20%20%3Ctable%20id%3D%27main%5Ftable%27%3E%0A%20%20%20%20%20%20%20%20%3Ctr%20id%3D%27display%5Fcategory%27%3E%3C%2Ftr%3E%0A%20%20%20%20%3C%2Ftable%3E%0A%3C%2Fbody%3E%0A%3C%2Fhtml%3E%0A" rel="icon" />
  <!--[if lt IE 9]>
    <script src="//cdnjs.cloudflare.com/ajax/libs/html5shiv/3.7.3/html5shiv-printshiv.min.js"></script>
  <![endif]-->
  
</head>
<body>
<div class="wrapper">
<header id="title-block-header">
<h1 class="title" style="text-align:center">Atomic Refs Bound to Memory
Orderings &amp; Atomic Accessors</h1>

<table style="border:none;float:right">
  <tr>
    <td>Document #: </td>
    <td>D2689R3</td>
  </tr>
  <tr>
    <td>Date: </td>
    <td>2024-04-29</td>
  </tr>
  <tr>
    <td style="vertical-align:top">Project: </td>
    <td>Programming Language C++<br>
      SG1 &amp; LEWG<br>
    </td>
  </tr>
  <tr>
    <td style="vertical-align:top">Reply-to: </td>
    <td>
      Christian Trott<br>&lt;<a href="mailto:crtrott@sandia.gov" class="email">crtrott@sandia.gov</a>&gt;<br>
      Damien Lebrun-Grandie<br>&lt;<a href="mailto:lebrungrandt@ornl.gov" class="email">lebrungrandt@ornl.gov</a>&gt;<br>
      Mark Hoemmen<br>&lt;<a href="mailto:mhoemmen@nvidia.com" class="email">mhoemmen@nvidia.com</a>&gt;<br>
      Daniel Sunderland<br>&lt;<a href="mailto:dansunderland@gmail.com" class="email">dansunderland@gmail.com</a>&gt;<br>
      Nic Morales<br>&lt;<a href="mailto:nmmoral@sandia.gov" class="email">nmmoral@sandia.gov</a>&gt;<br>
      Nevin Liber<br>&lt;<a href="mailto:nliber@anl.gov" class="email">nliber@anl.gov</a>&gt;<br>
    </td>
  </tr>
</table>

</header>
<div style="clear:both">
<div id="TOC" role="doc-toc">
<h1 id="toctitle">Contents</h1>
<ul>
<li><a href="#revision-history" id="toc-revision-history"><span class="toc-section-number">1</span> Revision History</a>
<ul>
<li><a href="#p2689r3-lewg-feedback" id="toc-p2689r3-lewg-feedback"><span class="toc-section-number">1.1</span> P2689R3 (LEWG Feedback)</a></li>
<li><a href="#p2689r2-sg1-issaquah-2023-discussion" id="toc-p2689r2-sg1-issaquah-2023-discussion"><span class="toc-section-number">1.2</span> P2689R2 (SG1 Issaquah 2023
discussion)</a>
<ul>
<li><a href="#issaquah-2023-sg1-polls" id="toc-issaquah-2023-sg1-polls"><span class="toc-section-number">1.2.1</span> Issaquah 2023 SG1 Polls</a></li>
</ul></li>
<li><a href="#p2689r1-2023-01-pre-issaquah-2023-mailing" id="toc-p2689r1-2023-01-pre-issaquah-2023-mailing"><span class="toc-section-number">1.3</span> P2689R1 2023-01 (pre-Issaquah
2023) mailing</a></li>
<li><a href="#initial-version-2022-10-mailing" id="toc-initial-version-2022-10-mailing"><span class="toc-section-number">1.4</span> Initial Version 2022-10
Mailing</a>
<ul>
<li><a href="#kona-2022-sg1-polls" id="toc-kona-2022-sg1-polls"><span class="toc-section-number">1.4.1</span> Kona 2022 SG1 polls</a></li>
</ul></li>
</ul></li>
<li><a href="#rational" id="toc-rational"><span class="toc-section-number">2</span> Rational</a></li>
<li><a href="#design-decisions" id="toc-design-decisions"><span class="toc-section-number">3</span> Design decisions</a>
<ul>
<li><a href="#exposition-only-or-not" id="toc-exposition-only-or-not"><span class="toc-section-number">3.1</span> Exposition Only Or Not</a></li>
<li><a href="#memory-order-conversions" id="toc-memory-order-conversions"><span class="toc-section-number">3.2</span> Memory Order Conversions</a></li>
</ul></li>
<li><a href="#open-questions" id="toc-open-questions"><span class="toc-section-number">4</span> Open questions</a></li>
<li><a href="#wording" id="toc-wording"><span class="toc-section-number">5</span> Wording</a>
<ul>
<li><a href="#bound-atomic-ref" id="toc-bound-atomic-ref"><span class="toc-section-number">5.1</span> Bound atomic ref</a>
<ul>
<li><a href="#change-the-header-synopsis-for-atomic-in-atomics.syn" id="toc-change-the-header-synopsis-for-atomic-in-atomics.syn"><span class="toc-section-number">5.1.1</span> Change the header synopsis for
atomic in [atomics.syn]:</a></li>
<li><a href="#add-the-following-just-before-atomics.types.generic" id="toc-add-the-following-just-before-atomics.types.generic"><span class="toc-section-number">5.1.2</span> Add the following just before
[atomics.types.generic]:</a></li>
<li><a href="#in-version.syn" id="toc-in-version.syn"><span class="toc-section-number">5.1.3</span> In [version.syn]:</a></li>
</ul></li>
<li><a href="#atomic-accessors" id="toc-atomic-accessors"><span class="toc-section-number">5.2</span> Atomic Accessors</a>
<ul>
<li><a href="#add-to-the-mdspan-header-synopsis-in-mdspan.syn" id="toc-add-to-the-mdspan-header-synopsis-in-mdspan.syn"><span class="toc-section-number">5.2.1</span> Add to the mdspan header
synopsis in [mdspan.syn]</a></li>
<li><a href="#put-the-following-before-mdspan.mdspan" id="toc-put-the-following-before-mdspan.mdspan"><span class="toc-section-number">5.2.2</span> Put the following before
[mdspan.mdspan]:</a></li>
</ul></li>
<li><a href="#in-version.syn-1" id="toc-in-version.syn-1"><span class="toc-section-number">5.3</span> In [version.syn]</a></li>
</ul></li>
<li><a href="#acknowledgments" id="toc-acknowledgments"><span class="toc-section-number">6</span> Acknowledgments</a></li>
</ul>
</div>
<h1 data-number="1" id="revision-history"><span class="header-section-number">1</span> Revision History<a href="#revision-history" class="self-link"></a></h1>
<h2 data-number="1.1" id="p2689r3-lewg-feedback"><span class="header-section-number">1.1</span> P2689R3 (LEWG Feedback)<a href="#p2689r3-lewg-feedback" class="self-link"></a></h2>
<ul>
<li>Split definition of <em><code>atomic-ref-bound</code></em> into one
for arithmetic and pointer, and one for other types
<ul>
<li>needed because the typedef <code>difference_type</code> should only
appear for arithmetic and pointer types</li>
</ul></li>
<li>Added discussion for making <em><code>atomic-ref-bound</code></em>
exposition only or not</li>
<li>Added discussion arguing for not having converting constructors with
respect to memory order</li>
<li>Added missing <code>fetch_min</code> and <code>fetch_max</code>
functions</li>
<li>Use “west const”</li>
<li>Added header synopsis changes</li>
</ul>
<h2 data-number="1.2" id="p2689r2-sg1-issaquah-2023-discussion"><span class="header-section-number">1.2</span> P2689R2 (SG1 Issaquah 2023
discussion)<a href="#p2689r2-sg1-issaquah-2023-discussion" class="self-link"></a></h2>
<ul>
<li>Renamed <code>atomic-ref-bounded</code> to
<code>atomic-ref-bound</code></li>
<li>Renamed <code>atomic-ref-unbounded</code> to
<code>atomic-ref-unbound</code></li>
<li>Fixed the wording for
<code>basic-atomic-accessor::offset</code></li>
<li>Fixed the wording for
<code>basic-atomic-accessor::access</code></li>
<li>If P2616R3 (Making std::atomic notification/wait operations usable
in more situations) is also approved, similar changes should be applied
to <code>atomic-ref-bound</code> as well</li>
</ul>
<h3 data-number="1.2.1" id="issaquah-2023-sg1-polls"><span class="header-section-number">1.2.1</span> Issaquah 2023 SG1 Polls<a href="#issaquah-2023-sg1-polls" class="self-link"></a></h3>
<h4 data-number="1.2.1.1" id="p2689-poll"><span class="header-section-number">1.2.1.1</span> P2689 poll<a href="#p2689-poll" class="self-link"></a></h4>
Forward P2689R1 to LEWG, targeting C++26 Incl. wording changes: <br> -
Atomic ref [un]bounded to [un]bound <br> - Basic atomic accessors
<code>access()</code> effects should be
<code>return reference(p[i]);</code> <br> - Basic atomic accessors
<code>offset()</code> effects should be <code>return p+i;</code>
<table>
<thead>
<tr>
<th>
SF
</th>
<th>
F
</th>
<th>
N
</th>
<th>
A
</th>
<th>
SA
</th>
</tr>
</thead>
<tbody>
<tr>
<td>
5
</td>
<td>
9
</td>
<td>
0
</td>
<td>
0
</td>
<td>
0
</td>
</tr>
</tbody>
</table>
<p>Unanimous consent</p>
<h4 data-number="1.2.1.2" id="p2616-poll"><span class="header-section-number">1.2.1.2</span> P2616 poll<a href="#p2616-poll" class="self-link"></a></h4>
Apply changes in P2616R3 to the additions of P2689R1
<table>
<thead>
<tr>
<th>
SF
</th>
<th>
F
</th>
<th>
N
</th>
<th>
A
</th>
<th>
SA
</th>
</tr>
</table>
<p>No objection to unanimous consent</p>
<h2 data-number="1.3" id="p2689r1-2023-01-pre-issaquah-2023-mailing"><span class="header-section-number">1.3</span> P2689R1 2023-01 (pre-Issaquah
2023) mailing<a href="#p2689r1-2023-01-pre-issaquah-2023-mailing" class="self-link"></a></h2>
<ul>
<li>Added <code>atomic-ref-bounded</code> exposition-only template for
an <code>atomic_ref</code> like type bounded to a particular
<code>memory_order</code></li>
<li>Added <code>atomic_ref_relaxed</code>,
<code>atomic_ref_acq_rel</code> and <code>atomic_ref_seq_cst</code>
alias templates</li>
<li>Added <code>basic-atomic-accessor</code> exposition-only
template</li>
<li>Added <code>atomic_accessor_relaxed</code>,
<code>atomic_accessor_acq_rel</code> and
<code>atomic_accessor_seq_cst</code> templates</li>
</ul>
<h2 data-number="1.4" id="initial-version-2022-10-mailing"><span class="header-section-number">1.4</span> Initial Version 2022-10
Mailing<a href="#initial-version-2022-10-mailing" class="self-link"></a></h2>
<h3 data-number="1.4.1" id="kona-2022-sg1-polls"><span class="header-section-number">1.4.1</span> Kona 2022 SG1 polls<a href="#kona-2022-sg1-polls" class="self-link"></a></h3>
<h4 data-number="1.4.1.1" id="sg1-poll-1"><span class="header-section-number">1.4.1.1</span> SG1 Poll #1<a href="#sg1-poll-1" class="self-link"></a></h4>
We like the bound <code>memory_order</code> versions of
<code>atomic_ref</code> (This says nothing about whether these are
aliases of general a template that takes a <code>memory_order</code>
argument.) <br> <br> <code>atomic_ref_relaxed</code> <br>
<code>atomic_ref_acq_rel</code> (acquire for load, release for store)
<br> <code>atomic_ref_seq_cst</code>
<table>
<thead>
<tr>
<th>
SF
</th>
<th>
F
</th>
<th>
N
</th>
<th>
A
</th>
<th>
SA
</th>
</tr>
</thead>
<tbody>
<tr>
<td>
1
</td>
<td>
11
</td>
<td>
0
</td>
<td>
1
</td>
<td>
0
</td>
</tr>
</tbody>
</table>
<p>Consensus</p>
<h4 data-number="1.4.1.2" id="sg1-poll-2"><span class="header-section-number">1.4.1.2</span> SG1 Poll #2<a href="#sg1-poll-2" class="self-link"></a></h4>
X) The meaning of the bound <code>memory_order</code> is that is the
default order <br> Y) The meaning of the bound <code>memory_order</code>
is that is the only order
<table>
<thead>
<tr>
<th>
SX
</th>
<th>
X
</th>
<th>
N
</th>
<th>
Y
</th>
<th>
SY
</th>
</tr>
</thead>
<tbody>
<tr>
<td>
1
</td>
<td>
1
</td>
<td>
3
</td>
<td>
4
</td>
<td>
2
</td>
</tr>
</tbody>
</table>
<p>Consensus for Y <br> <br> SX : we have a variant of this type in
Folly and it has been useful to be able to override this <br> SY : it’s
weird for <code>atomic_ref_relaxed</code> to have a <code>seq_cst</code>
atomic done to it; since you can re-form the <code>_ref</code> you can
still do it</p>
<h4 data-number="1.4.1.3" id="sg1-poll-3"><span class="header-section-number">1.4.1.3</span> SG1 Poll #3<a href="#sg1-poll-3" class="self-link"></a></h4>
the next version of this proposal, with these changes, should target SG1
&amp; LEWG <br> <br> <code>atomic_accessor</code> -&gt;
<code>atomic_ref</code> <br> <code>atomic_accessor_relaxed</code> -&gt;
<code>atomic_ref_relaxed</code> <br>
<code>atomic_accessor_acq_rel</code> -&gt;
<code>atomic_ref_acq_rel</code> <br>
<code>atomic_accessor_seq_cst</code> -&gt;
<code>atomic_ref_seq_cst</code> <br> <br> (Return to SG1 for final
wording when this is in LWG.)
<table>
<thead>
<tr>
<th>
SF
</th>
<th>
F
</th>
<th>
N
</th>
<th>
A
</th>
<th>
SA
</th>
</tr>
</thead>
<tbody>
<tr>
<td>
6
</td>
<td>
6
</td>
<td>
2
</td>
<td>
0
</td>
<td>
0
</td>
</tr>
</tbody>
</table>
<h1 data-number="2" id="rational"><span class="header-section-number">2</span> Rational<a href="#rational" class="self-link"></a></h1>
<p>This proposal adds three <code>atomic_ref</code> like types each
bound to a particular <code>memory_order</code>. The API differs from
<code>atomic_ref</code> in that the <code>memory_order</code> cannot be
specified at run time; i.e., none of its member functions take a
<code>memory_order</code> parameter. In the specific case of
<code>atomic_ref_acq_rel</code>, loads are done via
<code>memory_order_acquire</code> and stores are done via
<code>memory_order_release</code>.</p>
<table>
<thead>
<tr>
<th>
Atomic Ref
</th>
<th>
<code>memory_order</code>
</th>
<th>
Loads
</th>
<th>
Stores
</th>
</tr>
</thead>
<tbody>
<tr>
<td>
<code>atomic_ref_relaxed</code>
</td>
<td>
<code>memory_order_relaxed</code>
</td>
<td>
<code>memory_order_relaxed</code>
</td>
<td>
<code>memory_order_relaxed</code>
</td>
</tr>
<tr>
<td>
<code>atomic_ref_acq_rel</code>
</td>
<td>
<code>memory_order_acq_rel</code>
</td>
<td>
<code>memory_order_acquire</code>
</td>
<td>
<code>memory_order_release</code>
</td>
</tr>
<tr>
<td>
<code>atomic_ref_seq_cst</code>
</td>
<td>
<code>memory_order_seq_cst</code>
</td>
<td>
<code>memory_order_seq_cst</code>
</td>
<td>
<code>memory_order_seq_cst</code>
</td>
</tr>
</tbody>
</table>
<p>This proposal also adds four atomic accessors to be used with
<code>mdspan</code>. They only differ with their <code>reference</code>
types and all operations are performed atomically by using that
corresponding reference type.</p>
<table>
<thead>
<tr>
<th>
Accessor
</th>
<th>
<code>reference</code>
</th>
</tr>
</thead>
<tbody>
<tr>
<td>
<code>atomic_accessor</code>
</td>
<td>
<code>atomic_ref</code>
</td>
</tr>
<tr>
<td>
<code>atomic_accessor_relaxed</code>
</td>
<td>
<code>atomic_ref_relaxed</code>
</td>
</tr>
<tr>
<td>
<code>atomic_accessor_acq_rel</code>
</td>
<td>
<code>atomic_ref_acq_rel</code>
</td>
</tr>
<tr>
<td>
<code>atomic_accessor_seq_cst</code>
</td>
<td>
<code>atomic_ref_seq_cst</code>
</td>
</tr>
</tbody>
</table>
<p><code>atomic_accessor</code> was part of the rational provided in
P0009 for <code>mdspan</code>s <em>accessor policy</em> template
parameter.</p>
<p>One of the primary use cases for these accessors is the ability to
write algorithms with somewhat generic <code>mdspan</code> outputs,
which can be called in sequential and parallel contexts. When called in
parallel contexts users would simply pass an <code>mdspan</code> with an
atomic accessor - the algorithm implementation itself could be agnostic
to the calling context.</p>
<p>A variation on this use case is an implementation of an algorithm
taking an execution policy, which adds the atomic accessor to its output
argument if called with a parallel policy, while using the
<code>default_accessor</code> when called with a sequential policy. The
following demonstrates this with a function computing a histogram:</p>
<div class="sourceCode" id="cb1"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb1-1"><a href="#cb1-1" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> T, <span class="kw">class</span> Extents, <span class="kw">class</span> LayoutPolicy<span class="op">&gt;</span></span>
<span id="cb1-2"><a href="#cb1-2" aria-hidden="true" tabindex="-1"></a><span class="kw">auto</span> add_atomic_accessor_if_needed<span class="op">(</span></span>
<span id="cb1-3"><a href="#cb1-3" aria-hidden="true" tabindex="-1"></a>    std<span class="op">::</span>execution<span class="op">::</span>sequenced_policy,</span>
<span id="cb1-4"><a href="#cb1-4" aria-hidden="true" tabindex="-1"></a>    mdspan<span class="op">&lt;</span>T, Extents, LayoutPolicy<span class="op">&gt;</span> m<span class="op">)</span> <span class="op">{</span></span>
<span id="cb1-5"><a href="#cb1-5" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> m;</span>
<span id="cb1-6"><a href="#cb1-6" aria-hidden="true" tabindex="-1"></a>    <span class="op">}</span></span>
<span id="cb1-7"><a href="#cb1-7" aria-hidden="true" tabindex="-1"></a></span>
<span id="cb1-8"><a href="#cb1-8" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> ExecutionPolicy, <span class="kw">class</span> T, <span class="kw">class</span> Extents, <span class="kw">class</span> LayoutPolicy<span class="op">&gt;</span></span>
<span id="cb1-9"><a href="#cb1-9" aria-hidden="true" tabindex="-1"></a><span class="kw">auto</span> add_atomic_accessor_if_needed<span class="op">(</span></span>
<span id="cb1-10"><a href="#cb1-10" aria-hidden="true" tabindex="-1"></a>    ExecutionPolicy,</span>
<span id="cb1-11"><a href="#cb1-11" aria-hidden="true" tabindex="-1"></a>    mdspan<span class="op">&lt;</span>T, Extents, LayoutPolicy<span class="op">&gt;</span> m<span class="op">)</span> <span class="op">{</span></span>
<span id="cb1-12"><a href="#cb1-12" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> mdspan<span class="op">(</span>m<span class="op">.</span>data_handle<span class="op">()</span>, m<span class="op">.</span>mapping<span class="op">()</span>, atomic_accessor<span class="op">&lt;</span>T<span class="op">&gt;())</span>;</span>
<span id="cb1-13"><a href="#cb1-13" aria-hidden="true" tabindex="-1"></a>    <span class="op">}</span></span>
<span id="cb1-14"><a href="#cb1-14" aria-hidden="true" tabindex="-1"></a></span>
<span id="cb1-15"><a href="#cb1-15" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> ExecT<span class="op">&gt;</span></span>
<span id="cb1-16"><a href="#cb1-16" aria-hidden="true" tabindex="-1"></a><span class="dt">void</span> compute_histogram<span class="op">(</span>ExecT exec, <span class="dt">float</span> bin_size,</span>
<span id="cb1-17"><a href="#cb1-17" aria-hidden="true" tabindex="-1"></a>               mdspan<span class="op">&lt;</span><span class="dt">int</span>, stdex<span class="op">::</span>dextents<span class="op">&lt;</span><span class="dt">int</span>,<span class="dv">1</span><span class="op">&gt;&gt;</span> output,</span>
<span id="cb1-18"><a href="#cb1-18" aria-hidden="true" tabindex="-1"></a>               mdspan<span class="op">&lt;</span><span class="dt">float</span>, stdex<span class="op">::</span>dextents<span class="op">&lt;</span><span class="dt">int</span>,<span class="dv">1</span><span class="op">&gt;&gt;</span> data<span class="op">)</span> <span class="op">{</span></span>
<span id="cb1-19"><a href="#cb1-19" aria-hidden="true" tabindex="-1"></a></span>
<span id="cb1-20"><a href="#cb1-20" aria-hidden="true" tabindex="-1"></a>  <span class="kw">static_assert</span><span class="op">(</span>is_execution_policy_v<span class="op">&lt;</span>ExecT<span class="op">&gt;)</span>;</span>
<span id="cb1-21"><a href="#cb1-21" aria-hidden="true" tabindex="-1"></a></span>
<span id="cb1-22"><a href="#cb1-22" aria-hidden="true" tabindex="-1"></a>  <span class="kw">auto</span> accumulator <span class="op">=</span> add_atomic_accessor_if_needed<span class="op">(</span>exec, output<span class="op">)</span>;</span>
<span id="cb1-23"><a href="#cb1-23" aria-hidden="true" tabindex="-1"></a></span>
<span id="cb1-24"><a href="#cb1-24" aria-hidden="true" tabindex="-1"></a>  for_each<span class="op">(</span>exec, data<span class="op">.</span>data_handle<span class="op">()</span>, data<span class="op">.</span>data_handle<span class="op">()+</span>data<span class="op">.</span>extent<span class="op">(</span><span class="dv">0</span><span class="op">)</span>, <span class="op">[=](</span><span class="dt">float</span> val<span class="op">)</span> <span class="op">{</span></span>
<span id="cb1-25"><a href="#cb1-25" aria-hidden="true" tabindex="-1"></a>    <span class="dt">int</span> bin <span class="op">=</span> std<span class="op">::</span>abs<span class="op">(</span>val<span class="op">)/</span>bin_size;</span>
<span id="cb1-26"><a href="#cb1-26" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span><span class="op">(</span>bin <span class="op">&gt;</span> output<span class="op">.</span>extent<span class="op">(</span><span class="dv">0</span><span class="op">))</span> bin <span class="op">=</span> output<span class="op">.</span>extent<span class="op">(</span><span class="dv">0</span><span class="op">)-</span><span class="dv">1</span>;</span>
<span id="cb1-27"><a href="#cb1-27" aria-hidden="true" tabindex="-1"></a>    accumulator<span class="op">[</span>bin<span class="op">]++</span>;</span>
<span id="cb1-28"><a href="#cb1-28" aria-hidden="true" tabindex="-1"></a>  <span class="op">})</span>;</span>
<span id="cb1-29"><a href="#cb1-29" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span></code></pre></div>
<p>The above example is available on godbolt: <a href="https://godbolt.org/z/cWa6MG5dj">https://godbolt.org/z/cWa6MG5dj</a></p>
<h1 data-number="3" id="design-decisions"><span class="header-section-number">3</span> Design decisions<a href="#design-decisions" class="self-link"></a></h1>
<p>Three options for atomic refs were discussed in SG1 in Kona 2022: add
new types for <code>memory_order</code> bound atomic refs, add a new
<code>memory_order</code> template parameter to the existing
<code>atomic_ref</code>, or add a constructor to the existing
<code>atomic_ref</code> that takes a <code>memory_order</code> and
stores it. Given that the last two are ABI breaks, the first option was
polled and chosen. It was also decided that the new bound atomic refs
would not support overriding the specified <code>memory_order</code> at
run time.</p>
<p>This proposal has chosen to make a general exposition-only template
<code>atomic-ref-bound</code> that takes a <code>memory_order</code> as
a template argument and alias templates for the three specific bound
atomic refs. Also, the various member functions are constrained by
integral types not including <code>bool</code>, floating point types and
pointer types, as opposed to the different template specializations
specified for <code>atomic_ref</code>. Other than not being able to
specifiy the <code>memory_order</code> at run time, the intention is
that the bound atomic ref types have the same functionality and API as
<code>atomic_ref</code>.</p>
<p>Similarly for the atomic accessors, it was decided in SG1 in Kona
2022 to add four new types. This proposal has chosen to make a general
exposition-only template <code>basic-atomic-accessor</code> which takes
the <code>reference</code> type as a template parameter, and four alias
templates for the specific atomic accessors.</p>
<p>Assuming both papers are approved, SG1 voted that similar changes to
<code>atomic_ref</code> in P2616R3 (Making std::atomic notification/wait
operations usable in more situations) should also be applied to
<code>atomic-ref-bound</code>. They are not yet in the wording of either
paper, as we do not know what order LWG will apply them to the working
draft.</p>
<h2 data-number="3.1" id="exposition-only-or-not"><span class="header-section-number">3.1</span> Exposition Only Or Not<a href="#exposition-only-or-not" class="self-link"></a></h2>
<p>As mentioned above, during SG1 review we introduced explicitly named
symbols instead of making <code>basic-atomic-accessor</code> and
<code>atomic-ref-bound</code> public.</p>
<p>The primary reason for not making the generic versions public is that
the memory order is generally dictated by algorithmic
considerations.</p>
<p>The only generic thing one may want to decide is whether to use
atomics at all (e.g. as the function of the execution policy).</p>
<p>Consequently, we could not find a use-case where the generic types
are useful. That said we also don’t have a strong reason to not make
them public - other than that it constrains implementers.</p>
<h2 data-number="3.2" id="memory-order-conversions"><span class="header-section-number">3.2</span> Memory Order Conversions<a href="#memory-order-conversions" class="self-link"></a></h2>
<p>A question was raised whether to make the various bounded
<code>atomic_ref</code> and <code>atomic_accessor</code> variants
constructible/convertible from each other. We don’t see many good
reasons to enable that:</p>
<ul>
<li><code>atomic_ref</code> is meant to be almost used
<code>in-place</code> for individual operations
e.g. <code>atomic_ref(a[i])++</code> and not much of an interface
type</li>
<li>atomic accessors are something you are supposed to add in a fairly
local scope too
<ul>
<li>we don’t expect folks to pass <code>mdspan</code> with atomic
accessors around</li>
</ul></li>
</ul>
<p>However we identified a possible reason not to permit it:</p>
<p>Writing functions which take <code>atomic_ref_MEM_ORDER</code> imply
ordering behavior: allowing conversions would make it very easy to
violate that expectation.</p>
<p>Consider the following:</p>
<div class="sourceCode" id="cb2"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb2-1"><a href="#cb2-1" aria-hidden="true" tabindex="-1"></a><span class="dt">void</span> foo<span class="op">(</span>atomic_ref_relaxed<span class="op">&lt;</span><span class="dt">int</span><span class="op">&gt;</span> counter<span class="op">)</span>;</span>
<span id="cb2-2"><a href="#cb2-2" aria-hidden="true" tabindex="-1"></a></span>
<span id="cb2-3"><a href="#cb2-3" aria-hidden="true" tabindex="-1"></a><span class="dt">void</span> bar<span class="op">(</span><span class="dt">int</span><span class="op">&amp;</span> counter<span class="op">)</span> <span class="op">{</span></span>
<span id="cb2-4"><a href="#cb2-4" aria-hidden="true" tabindex="-1"></a>  atomic_ref_relaxed atomic_counter<span class="op">(</span>counter<span class="op">)</span>;</span>
<span id="cb2-5"><a href="#cb2-5" aria-hidden="true" tabindex="-1"></a>  atomic_counter<span class="op">++</span>;</span>
<span id="cb2-6"><a href="#cb2-6" aria-hidden="true" tabindex="-1"></a>  <span class="op">...</span></span>
<span id="cb2-7"><a href="#cb2-7" aria-hidden="true" tabindex="-1"></a>  foo<span class="op">(</span>atomic_counter<span class="op">)</span>;</span>
<span id="cb2-8"><a href="#cb2-8" aria-hidden="true" tabindex="-1"></a>  <span class="op">...</span></span>
<span id="cb2-9"><a href="#cb2-9" aria-hidden="true" tabindex="-1"></a>  atomic_counter<span class="op">++</span>;</span>
<span id="cb2-10"><a href="#cb2-10" aria-hidden="true" tabindex="-1"></a>  atomic_thread_fence<span class="op">(</span>memory_order<span class="op">::</span>acq_rel<span class="op">)</span>;</span>
<span id="cb2-11"><a href="#cb2-11" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span></code></pre></div>
<p>We believe it would be potentially unexpected for <code>foo</code> to
do any operations other than <code>relaxed</code> atomics on
<code>counter</code>. Likewise if <code>foo</code> were to take
<code>atomic_ref_seq_cst</code> it would be surprising if it did
<code>relaxed</code> atomic accesses.</p>
<h1 data-number="4" id="open-questions"><span class="header-section-number">4</span> Open questions<a href="#open-questions" class="self-link"></a></h1>
<p>This proposal uses alias templates to exposition-only types for
<code>atomic_ref_relaxed</code>, <code>atomic_accessor</code>, etc.
However, we do not want to prescribe a particular implementation. For
instance, if an implementer wished to derive from an
<code>atomic-ref-bound</code>-like type (to get a more user friendly
name mangling, which is something not normally covered by the Standard),
would they be allowed to do so? We believe an alias template to an
exposition-only type is not observable from the point of view of the
Standard and such an implementation would be allowed, but we request
clarification on this. Potentially this is something we can leave to LWG
review to suggest wording that would achieve that goal.</p>
<!--

 /$$      /$$                           /$$ /$$
| $$  /$ | $$                          | $$|__/
| $$ /$$$| $$  /$$$$$$   /$$$$$$   /$$$$$$$ /$$ /$$$$$$$   /$$$$$$
| $$/$$ $$ $$ /$$__  $$ /$$__  $$ /$$__  $$| $$| $$__  $$ /$$__  $$
| $$$$_  $$$$| $$  \ $$| $$  \__/| $$  | $$| $$| $$  \ $$| $$  \ $$
| $$$/ \  $$$| $$  | $$| $$      | $$  | $$| $$| $$  | $$| $$  | $$
| $$/   \  $$|  $$$$$$/| $$      |  $$$$$$$| $$| $$  | $$|  $$$$$$$
|__/     \__/ \______/ |__/       \_______/|__/|__/  |__/ \____  $$
                                                          /$$  \ $$
                                                         |  $$$$$$/
                                                          \______/
-->
<h1 data-number="5" id="wording"><span class="header-section-number">5</span> Wording<a href="#wording" class="self-link"></a></h1>
<p>The proposed changes are relative to <a href="https://wg21.link/n4917">N4917</a>:</p>
<h2 data-number="5.1" id="bound-atomic-ref"><span class="header-section-number">5.1</span> Bound atomic ref<a href="#bound-atomic-ref" class="self-link"></a></h2>
<h3 data-number="5.1.1" id="change-the-header-synopsis-for-atomic-in-atomics.syn"><span class="header-section-number">5.1.1</span> Change the header synopsis
for atomic in [atomics.syn]:<a href="#change-the-header-synopsis-for-atomic-in-atomics.syn" class="self-link"></a></h3>
<p><code>// [atomics.ref.pointer], partial specialization for pointers</code><br />
<code>template&lt;class T&gt; struct atomic_ref&lt;T*&gt;;                                          // freestanding</code><br />
<span class="add" style="color: #00AA00"><ins><span><code>// [atomics.ref.bounded], class tempalte atomic-ref-bound</code></span></ins></span><br />
<span class="add" style="color: #00AA00"><ins><span><code>template&lt;class T, class MemoryOrder&gt;</code></span>
<em><span><code>atomic-ref-bound</code></span></em><span><code>; // exposition only</code></span></ins></span><br />
<span class="add" style="color: #00AA00"><ins><span><code>template&lt;class T&gt; using atomic_ref_relaxed =</code></span><em><span><code>atomic-ref-bound</code></span></em><span><code>&lt;T, memory_order_relaxed&gt;; // freestanding</code></span></ins></span><br />
<span class="add" style="color: #00AA00"><ins><span><code>template&lt;class T&gt; using atomic_ref_acq_rel =</code></span><em><span><code>atomic-ref-bound</code></span></em><span><code>&lt;T, memory_order_acq_rel&gt;; // freestanding</code></span></ins></span><br />
<span class="add" style="color: #00AA00"><ins><span><code>template&lt;class T&gt; using atomic_ref_seq_cst =</code></span><em><span><code>atomic-ref-bound</code></span></em><span><code>&lt;T, memory_order_seq_cst&gt;; // freestanding</code></span></ins></span><br />
<code></code><br />
<code>// [atomics.types.generic], class template atomic</code><br />
<code>template&lt;class T&gt; struct atomic&lt;T&gt;;                                          // freestanding</code></p>
<h3 data-number="5.1.2" id="add-the-following-just-before-atomics.types.generic"><span class="header-section-number">5.1.2</span> Add the following just before
[atomics.types.generic]:<a href="#add-the-following-just-before-atomics.types.generic" class="self-link"></a></h3>
<p><b>Class template <code>atomic-ref-bound</code>
[atomics.ref.bound]</b></p>
<p><b>Exposition only helper</b></p>
<div class="sourceCode" id="cb3"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb3-1"><a href="#cb3-1" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> T<span class="op">&gt;</span></span>
<span id="cb3-2"><a href="#cb3-2" aria-hidden="true" tabindex="-1"></a><span class="kw">constexpr</span> <span class="dt">bool</span> <em>atomic-ref-non-generic-type()</em>;</span></code></pre></div>
<p>Returns: <code>true</code> if the class
<code>atomic_ref&lt;T&gt;</code> has a member type definition
<code>difference_type</code>, otherwise <code>false</code>.</p>
<p>[Note: This is true for a set of defined integral types, floating
point types, and pointers.]</p>
<p><b>General [atomics.ref.bound.general]</b></p>
<div class="sourceCode" id="cb4"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb4-1"><a href="#cb4-1" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span> <span class="op">&lt;</span><span class="kw">class</span> T, memory_order MemoryOrder<span class="op">&gt;</span></span>
<span id="cb4-2"><a href="#cb4-2" aria-hidden="true" tabindex="-1"></a><span class="kw">struct</span> atomic<span class="op">-</span>ref<span class="op">-</span>bound <span class="op">{</span>  <span class="co">// exposition only</span></span>
<span id="cb4-3"><a href="#cb4-3" aria-hidden="true" tabindex="-1"></a>   <span class="kw">private</span><span class="op">:</span></span>
<span id="cb4-4"><a href="#cb4-4" aria-hidden="true" tabindex="-1"></a>    <span class="kw">using</span> atomic_ref_unbound <span class="op">=</span> atomic_ref<span class="op">&lt;</span>T<span class="op">&gt;</span>;  <span class="co">// exposition only</span></span>
<span id="cb4-5"><a href="#cb4-5" aria-hidden="true" tabindex="-1"></a>    atomic_ref_unbound ref;                    <span class="co">// exposition only</span></span>
<span id="cb4-6"><a href="#cb4-6" aria-hidden="true" tabindex="-1"></a></span>
<span id="cb4-7"><a href="#cb4-7" aria-hidden="true" tabindex="-1"></a>    <span class="kw">static</span> <span class="kw">constexpr</span> memory_order store_ordering <span class="op">=</span></span>
<span id="cb4-8"><a href="#cb4-8" aria-hidden="true" tabindex="-1"></a>        MemoryOrder <span class="op">==</span> memory_order_acq_rel <span class="op">?</span> memory_order_release</span>
<span id="cb4-9"><a href="#cb4-9" aria-hidden="true" tabindex="-1"></a>                                            <span class="op">:</span> MemoryOrder;  <span class="co">// exposition only</span></span>
<span id="cb4-10"><a href="#cb4-10" aria-hidden="true" tabindex="-1"></a></span>
<span id="cb4-11"><a href="#cb4-11" aria-hidden="true" tabindex="-1"></a>    <span class="kw">static</span> <span class="kw">constexpr</span> memory_order load_ordering <span class="op">=</span></span>
<span id="cb4-12"><a href="#cb4-12" aria-hidden="true" tabindex="-1"></a>        MemoryOrder <span class="op">==</span> memory_order_acq_rel <span class="op">?</span> memory_order_acquire</span>
<span id="cb4-13"><a href="#cb4-13" aria-hidden="true" tabindex="-1"></a>                                            <span class="op">:</span> MemoryOrder;  <span class="co">// exposition only</span></span>
<span id="cb4-14"><a href="#cb4-14" aria-hidden="true" tabindex="-1"></a></span>
<span id="cb4-15"><a href="#cb4-15" aria-hidden="true" tabindex="-1"></a>    <span class="kw">static</span> <span class="kw">constexpr</span> <span class="dt">bool</span> is_integral_value <span class="op">=</span></span>
<span id="cb4-16"><a href="#cb4-16" aria-hidden="true" tabindex="-1"></a>        is_integral_v<span class="op">&lt;</span>T<span class="op">&gt;</span> <span class="op">&amp;&amp;</span> <span class="op">!</span>is_same_v<span class="op">&lt;</span>T, <span class="dt">bool</span><span class="op">&gt;</span>;  <span class="co">// exposition only</span></span>
<span id="cb4-17"><a href="#cb4-17" aria-hidden="true" tabindex="-1"></a>    <span class="kw">static</span> <span class="kw">constexpr</span> <span class="dt">bool</span> is_floating_point_value <span class="op">=</span></span>
<span id="cb4-18"><a href="#cb4-18" aria-hidden="true" tabindex="-1"></a>        is_floating_point_v<span class="op">&lt;</span>T<span class="op">&gt;</span>;  <span class="co">// exposition only</span></span>
<span id="cb4-19"><a href="#cb4-19" aria-hidden="true" tabindex="-1"></a>    <span class="kw">static</span> <span class="kw">constexpr</span> <span class="dt">bool</span> is_pointer_value <span class="op">=</span></span>
<span id="cb4-20"><a href="#cb4-20" aria-hidden="true" tabindex="-1"></a>        is_pointer_v<span class="op">&lt;</span>T<span class="op">&gt;</span>;  <span class="co">// exposition only</span></span>
<span id="cb4-21"><a href="#cb4-21" aria-hidden="true" tabindex="-1"></a></span>
<span id="cb4-22"><a href="#cb4-22" aria-hidden="true" tabindex="-1"></a>   <span class="kw">public</span><span class="op">:</span></span>
<span id="cb4-23"><a href="#cb4-23" aria-hidden="true" tabindex="-1"></a>    <span class="kw">using</span> value_type <span class="op">=</span> T;</span>
<span id="cb4-24"><a href="#cb4-24" aria-hidden="true" tabindex="-1"></a>    <span class="kw">static</span> <span class="kw">constexpr</span> memory_order memory_ordering <span class="op">=</span> MemoryOrder;</span>
<span id="cb4-25"><a href="#cb4-25" aria-hidden="true" tabindex="-1"></a>    <span class="kw">static</span> <span class="kw">constexpr</span> <span class="dt">size_t</span> required_alignment <span class="op">=</span> atomic_ref_unbound<span class="op">::</span>required_alignment;</span>
<span id="cb4-26"><a href="#cb4-26" aria-hidden="true" tabindex="-1"></a></span>
<span id="cb4-27"><a href="#cb4-27" aria-hidden="true" tabindex="-1"></a>    <span class="kw">static</span> <span class="kw">constexpr</span> <span class="dt">bool</span> is_always_lock_free <span class="op">=</span> atomic_ref_unbound<span class="op">::</span>is_always_lock_free;</span>
<span id="cb4-28"><a href="#cb4-28" aria-hidden="true" tabindex="-1"></a>    <span class="dt">bool</span> is_lock_free<span class="op">()</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span>
<span id="cb4-29"><a href="#cb4-29" aria-hidden="true" tabindex="-1"></a></span>
<span id="cb4-30"><a href="#cb4-30" aria-hidden="true" tabindex="-1"></a>    <span class="kw">explicit</span> atomic<span class="op">-</span>ref<span class="op">-</span>bound<span class="op">(</span>T<span class="op">&amp;)</span>;</span>
<span id="cb4-31"><a href="#cb4-31" aria-hidden="true" tabindex="-1"></a>    atomic<span class="op">-</span>ref<span class="op">-</span>bound<span class="op">(</span><span class="kw">const</span> atomic<span class="op">-</span>ref<span class="op">-</span>bound<span class="op">&amp;)</span> <span class="kw">noexcept</span>;</span>
<span id="cb4-32"><a href="#cb4-32" aria-hidden="true" tabindex="-1"></a>    atomic<span class="op">-</span>ref<span class="op">-</span>bound<span class="op">&amp;</span> <span class="kw">operator</span><span class="op">=(</span><span class="kw">const</span> atomic<span class="op">-</span>ref<span class="op">-</span>bound<span class="op">&amp;)</span> <span class="op">=</span> <span class="kw">delete</span>;</span>
<span id="cb4-33"><a href="#cb4-33" aria-hidden="true" tabindex="-1"></a></span>
<span id="cb4-34"><a href="#cb4-34" aria-hidden="true" tabindex="-1"></a>    <span class="dt">void</span> store<span class="op">(</span>T desired<span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span>
<span id="cb4-35"><a href="#cb4-35" aria-hidden="true" tabindex="-1"></a>    T <span class="kw">operator</span><span class="op">=(</span>T desired<span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span>
<span id="cb4-36"><a href="#cb4-36" aria-hidden="true" tabindex="-1"></a>    T load<span class="op">()</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span>
<span id="cb4-37"><a href="#cb4-37" aria-hidden="true" tabindex="-1"></a>    <span class="kw">operator</span> T<span class="op">()</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span>
<span id="cb4-38"><a href="#cb4-38" aria-hidden="true" tabindex="-1"></a></span>
<span id="cb4-39"><a href="#cb4-39" aria-hidden="true" tabindex="-1"></a>    T exchange<span class="op">(</span>T desired<span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span>
<span id="cb4-40"><a href="#cb4-40" aria-hidden="true" tabindex="-1"></a>    <span class="dt">bool</span> compare_exchange_weak<span class="op">(</span>T<span class="op">&amp;</span> expected, T desired<span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span>
<span id="cb4-41"><a href="#cb4-41" aria-hidden="true" tabindex="-1"></a>    <span class="dt">bool</span> compare_exchange_strong<span class="op">(</span>T<span class="op">&amp;</span> expected, T desired<span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span>
<span id="cb4-42"><a href="#cb4-42" aria-hidden="true" tabindex="-1"></a></span>
<span id="cb4-43"><a href="#cb4-43" aria-hidden="true" tabindex="-1"></a>    <span class="dt">void</span> wait<span class="op">(</span>T old<span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span>
<span id="cb4-44"><a href="#cb4-44" aria-hidden="true" tabindex="-1"></a>    <span class="dt">void</span> notify_one<span class="op">()</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span>
<span id="cb4-45"><a href="#cb4-45" aria-hidden="true" tabindex="-1"></a>    <span class="dt">void</span> notify_all<span class="op">()</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span>
<span id="cb4-46"><a href="#cb4-46" aria-hidden="true" tabindex="-1"></a><span class="op">}</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">1</a></span>
Class <code>atomic-ref-bound</code> is for exposition only.</p>
<p><span class="marginalizedparent"><a class="marginalized">2</a></span>
<em>Mandates:</em></p>
<ul>
<li><p><span class="marginalizedparent"><a class="marginalized">(2.1)</a></span>
<code>is_trivially_copyable_v&lt;T&gt;</code> is
<code>true</code>.</p></li>
<li><p><span class="marginalizedparent"><a class="marginalized">(2.2)</a></span>
<code>is_same_v&lt;T, remove_cv_t&lt;T&gt;&gt;</code> is
<code>true</code>.</p></li>
</ul>
<p><strong>Operations [atomics.ref.bound.ops]</strong></p>
<div class="sourceCode" id="cb5"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb5-1"><a href="#cb5-1" aria-hidden="true" tabindex="-1"></a><span class="dt">bool</span> is_lock_free<span class="op">()</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">1</a></span>
<em>Effects:</em> Equivalent to:
<code>return ref.is_lock_free();</code></p>
<div class="sourceCode" id="cb6"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb6-1"><a href="#cb6-1" aria-hidden="true" tabindex="-1"></a><span class="kw">explicit</span> atomic<span class="op">-</span>ref<span class="op">-</span>bound<span class="op">(</span>T<span class="op">&amp;</span> t<span class="op">)</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">2</a></span>
<em>Preconditions:</em> The referenced object is aligned to
<code>required_alignment</code>.</p>
<p><span class="marginalizedparent"><a class="marginalized">3</a></span>
<em>Postconditions:</em> <code>ref</code> references the object
referenced by <code>t</code>.</p>
<p><span class="marginalizedparent"><a class="marginalized">4</a></span>
<em>Throws:</em> Nothing.</p>
<div class="sourceCode" id="cb7"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb7-1"><a href="#cb7-1" aria-hidden="true" tabindex="-1"></a>atomic<span class="op">-</span>ref<span class="op">-</span>bound<span class="op">(</span><span class="kw">const</span> atomic<span class="op">-</span>ref<span class="op">-</span>bound<span class="op">&amp;</span> a<span class="op">)</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">5</a></span>
<em>Postconditions:</em> <code>*this</code> references the object
referenced by <code>a</code>.</p>
<div class="sourceCode" id="cb8"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb8-1"><a href="#cb8-1" aria-hidden="true" tabindex="-1"></a><span class="dt">void</span> store<span class="op">(</span>T desired<span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">6</a></span>
<em>Effects:</em> Equivalent to:
<code>ref.store(desired, store_ordering);</code></p>
<div class="sourceCode" id="cb9"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb9-1"><a href="#cb9-1" aria-hidden="true" tabindex="-1"></a>T <span class="kw">operator</span><span class="op">=(</span>T desired<span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">7</a></span>
<em>Effects:</em> Equivalent to:
<code>store(desired); return desired;</code></p>
<div class="sourceCode" id="cb10"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb10-1"><a href="#cb10-1" aria-hidden="true" tabindex="-1"></a>T load<span class="op">()</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">8</a></span>
<em>Effects:</em> Equivalent to:
<code>ref.load(load_ordering);</code></p>
<div class="sourceCode" id="cb11"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb11-1"><a href="#cb11-1" aria-hidden="true" tabindex="-1"></a><span class="kw">operator</span> T<span class="op">()</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">9</a></span>
<em>Effects:</em> Equivalent to: <code>return load();</code></p>
<div class="sourceCode" id="cb12"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb12-1"><a href="#cb12-1" aria-hidden="true" tabindex="-1"></a>T exchange<span class="op">(</span>T desired<span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">10</a></span>
<em>Effects:</em> Equivalent to:
<code>return ref.exchange(desired, memory_ordering);</code></p>
<div class="sourceCode" id="cb13"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb13-1"><a href="#cb13-1" aria-hidden="true" tabindex="-1"></a><span class="dt">bool</span> compare_exchange_weak<span class="op">(</span>T<span class="op">&amp;</span> expected, T desired<span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">11</a></span>
<em>Effects:</em> Equivalent to:
<code>return ref.compare_exchange_weak(expected, desired, memory_ordering, load_ordering);</code></p>
<div class="sourceCode" id="cb14"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb14-1"><a href="#cb14-1" aria-hidden="true" tabindex="-1"></a><span class="dt">bool</span> compare_exchange_strong<span class="op">(</span>T<span class="op">&amp;</span> expected, T desired<span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">12</a></span>
<em>Effects:</em> Equivalent to:
<code>return ref.compare_exchange_strong(expected, desired, memory_ordering, load_ordering);</code></p>
<div class="sourceCode" id="cb15"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb15-1"><a href="#cb15-1" aria-hidden="true" tabindex="-1"></a><span class="dt">void</span> wait<span class="op">(</span>T old<span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">13</a></span>
<em>Effects:</em> Equivalent to:
<code>ref.wait(old, load_ordering);</code></p>
<div class="sourceCode" id="cb16"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb16-1"><a href="#cb16-1" aria-hidden="true" tabindex="-1"></a><span class="dt">void</span> notify_one<span class="op">()</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">14</a></span>
<em>Effects:</em> Equivalent to: <code>ref.notify_one(); }</code></p>
<div class="sourceCode" id="cb17"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb17-1"><a href="#cb17-1" aria-hidden="true" tabindex="-1"></a><span class="dt">void</span> notify_all<span class="op">()</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">15</a></span>
<em>Effects:</em> Equivalent to: <code>ref.notify_all(); }</code></p>
<p><b>General [atomics.ref.bound.arithmetic]</b></p>
<div class="sourceCode" id="cb18"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb18-1"><a href="#cb18-1" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span> <span class="op">&lt;</span>arithmetic<span class="op">-</span><span class="kw">or</span><span class="op">-</span>pointer T, memory_order MemoryOrder<span class="op">&gt;</span></span>
<span id="cb18-2"><a href="#cb18-2" aria-hidden="true" tabindex="-1"></a><span class="kw">requires</span><span class="op">(</span><em>atomic-ref-non-generic-type</em><span class="op">&lt;</span>T<span class="op">&gt;())</span></span>
<span id="cb18-3"><a href="#cb18-3" aria-hidden="true" tabindex="-1"></a><span class="kw">struct</span> atomic<span class="op">-</span>ref<span class="op">-</span>bound<span class="op">&lt;</span>T, MemoryOrder<span class="op">&gt;</span> <span class="op">{</span>  <span class="co">// exposition only</span></span>
<span id="cb18-4"><a href="#cb18-4" aria-hidden="true" tabindex="-1"></a>   <span class="kw">private</span><span class="op">:</span></span>
<span id="cb18-5"><a href="#cb18-5" aria-hidden="true" tabindex="-1"></a>    <span class="kw">using</span> atomic_ref_unbound <span class="op">=</span> atomic_ref<span class="op">&lt;</span>T<span class="op">&gt;</span>;  <span class="co">// exposition only</span></span>
<span id="cb18-6"><a href="#cb18-6" aria-hidden="true" tabindex="-1"></a>    atomic_ref_unbound ref;                    <span class="co">// exposition only</span></span>
<span id="cb18-7"><a href="#cb18-7" aria-hidden="true" tabindex="-1"></a></span>
<span id="cb18-8"><a href="#cb18-8" aria-hidden="true" tabindex="-1"></a>    <span class="kw">static</span> <span class="kw">constexpr</span> memory_order store_ordering <span class="op">=</span></span>
<span id="cb18-9"><a href="#cb18-9" aria-hidden="true" tabindex="-1"></a>        MemoryOrder <span class="op">==</span> memory_order_acq_rel <span class="op">?</span> memory_order_release</span>
<span id="cb18-10"><a href="#cb18-10" aria-hidden="true" tabindex="-1"></a>                                            <span class="op">:</span> MemoryOrder;  <span class="co">// exposition only</span></span>
<span id="cb18-11"><a href="#cb18-11" aria-hidden="true" tabindex="-1"></a></span>
<span id="cb18-12"><a href="#cb18-12" aria-hidden="true" tabindex="-1"></a>    <span class="kw">static</span> <span class="kw">constexpr</span> memory_order load_ordering <span class="op">=</span></span>
<span id="cb18-13"><a href="#cb18-13" aria-hidden="true" tabindex="-1"></a>        MemoryOrder <span class="op">==</span> memory_order_acq_rel <span class="op">?</span> memory_order_acquire</span>
<span id="cb18-14"><a href="#cb18-14" aria-hidden="true" tabindex="-1"></a>                                            <span class="op">:</span> MemoryOrder;  <span class="co">// exposition only</span></span>
<span id="cb18-15"><a href="#cb18-15" aria-hidden="true" tabindex="-1"></a></span>
<span id="cb18-16"><a href="#cb18-16" aria-hidden="true" tabindex="-1"></a>    <span class="kw">static</span> <span class="kw">constexpr</span> <span class="dt">bool</span> is_integral_value <span class="op">=</span></span>
<span id="cb18-17"><a href="#cb18-17" aria-hidden="true" tabindex="-1"></a>        is_integral_v<span class="op">&lt;</span>T<span class="op">&gt;</span> <span class="op">&amp;&amp;</span> <span class="op">!</span>is_same_v<span class="op">&lt;</span>T, <span class="dt">bool</span><span class="op">&gt;</span>;  <span class="co">// exposition only</span></span>
<span id="cb18-18"><a href="#cb18-18" aria-hidden="true" tabindex="-1"></a>    <span class="kw">static</span> <span class="kw">constexpr</span> <span class="dt">bool</span> is_floating_point_value <span class="op">=</span></span>
<span id="cb18-19"><a href="#cb18-19" aria-hidden="true" tabindex="-1"></a>        is_floating_point_v<span class="op">&lt;</span>T<span class="op">&gt;</span>;  <span class="co">// exposition only</span></span>
<span id="cb18-20"><a href="#cb18-20" aria-hidden="true" tabindex="-1"></a>    <span class="kw">static</span> <span class="kw">constexpr</span> <span class="dt">bool</span> is_pointer_value <span class="op">=</span></span>
<span id="cb18-21"><a href="#cb18-21" aria-hidden="true" tabindex="-1"></a>        is_pointer_v<span class="op">&lt;</span>T<span class="op">&gt;</span>;  <span class="co">// exposition only</span></span>
<span id="cb18-22"><a href="#cb18-22" aria-hidden="true" tabindex="-1"></a></span>
<span id="cb18-23"><a href="#cb18-23" aria-hidden="true" tabindex="-1"></a>   <span class="kw">public</span><span class="op">:</span></span>
<span id="cb18-24"><a href="#cb18-24" aria-hidden="true" tabindex="-1"></a>    <span class="kw">using</span> value_type <span class="op">=</span> T;</span>
<span id="cb18-25"><a href="#cb18-25" aria-hidden="true" tabindex="-1"></a>    <span class="kw">using</span> difference_type <span class="op">=</span> atomic_ref_bound<span class="op">::</span>difference_type;</span>
<span id="cb18-26"><a href="#cb18-26" aria-hidden="true" tabindex="-1"></a>    <span class="kw">static</span> <span class="kw">constexpr</span> memory_order memory_ordering <span class="op">=</span> MemoryOrder;</span>
<span id="cb18-27"><a href="#cb18-27" aria-hidden="true" tabindex="-1"></a>    <span class="kw">static</span> <span class="kw">constexpr</span> <span class="dt">size_t</span> required_alignment <span class="op">=</span> atomic_ref_unbound<span class="op">::</span>required_alignment;</span>
<span id="cb18-28"><a href="#cb18-28" aria-hidden="true" tabindex="-1"></a></span>
<span id="cb18-29"><a href="#cb18-29" aria-hidden="true" tabindex="-1"></a>    <span class="kw">static</span> <span class="kw">constexpr</span> <span class="dt">bool</span> is_always_lock_free <span class="op">=</span> atomic_ref_unbound<span class="op">::</span>is_always_lock_free;</span>
<span id="cb18-30"><a href="#cb18-30" aria-hidden="true" tabindex="-1"></a>    <span class="dt">bool</span> is_lock_free<span class="op">()</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span>
<span id="cb18-31"><a href="#cb18-31" aria-hidden="true" tabindex="-1"></a></span>
<span id="cb18-32"><a href="#cb18-32" aria-hidden="true" tabindex="-1"></a>    <span class="kw">explicit</span> atomic<span class="op">-</span>ref<span class="op">-</span>bound<span class="op">(</span>T<span class="op">&amp;</span> t<span class="op">)</span>;</span>
<span id="cb18-33"><a href="#cb18-33" aria-hidden="true" tabindex="-1"></a>    atomic<span class="op">-</span>ref<span class="op">-</span>bound<span class="op">(</span><span class="kw">const</span> atomic<span class="op">-</span>ref<span class="op">-</span>bound<span class="op">&amp;)</span> <span class="kw">noexcept</span>;</span>
<span id="cb18-34"><a href="#cb18-34" aria-hidden="true" tabindex="-1"></a>    atomic<span class="op">-</span>ref<span class="op">-</span>bound<span class="op">&amp;</span> <span class="kw">operator</span><span class="op">=(</span><span class="kw">const</span> atomic<span class="op">-</span>ref<span class="op">-</span>bound<span class="op">&amp;)</span> <span class="op">=</span> <span class="kw">delete</span>;</span>
<span id="cb18-35"><a href="#cb18-35" aria-hidden="true" tabindex="-1"></a></span>
<span id="cb18-36"><a href="#cb18-36" aria-hidden="true" tabindex="-1"></a>    <span class="dt">void</span> store<span class="op">(</span>T desired<span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span>
<span id="cb18-37"><a href="#cb18-37" aria-hidden="true" tabindex="-1"></a>    T <span class="kw">operator</span><span class="op">=(</span>T desired<span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span>
<span id="cb18-38"><a href="#cb18-38" aria-hidden="true" tabindex="-1"></a>    T load<span class="op">()</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span>
<span id="cb18-39"><a href="#cb18-39" aria-hidden="true" tabindex="-1"></a>    <span class="kw">operator</span> T<span class="op">()</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span>
<span id="cb18-40"><a href="#cb18-40" aria-hidden="true" tabindex="-1"></a></span>
<span id="cb18-41"><a href="#cb18-41" aria-hidden="true" tabindex="-1"></a>    T exchange<span class="op">(</span>T desired<span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span>
<span id="cb18-42"><a href="#cb18-42" aria-hidden="true" tabindex="-1"></a>    <span class="dt">bool</span> compare_exchange_weak<span class="op">(</span>T<span class="op">&amp;</span> expected, T desired<span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span>
<span id="cb18-43"><a href="#cb18-43" aria-hidden="true" tabindex="-1"></a>    <span class="dt">bool</span> compare_exchange_strong<span class="op">(</span>T<span class="op">&amp;</span> expected, T desired<span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span>
<span id="cb18-44"><a href="#cb18-44" aria-hidden="true" tabindex="-1"></a></span>
<span id="cb18-45"><a href="#cb18-45" aria-hidden="true" tabindex="-1"></a>    T fetch_add<span class="op">(</span>T operand<span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span>
<span id="cb18-46"><a href="#cb18-46" aria-hidden="true" tabindex="-1"></a>    T fetch_add<span class="op">(</span>difference_type operand<span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span>
<span id="cb18-47"><a href="#cb18-47" aria-hidden="true" tabindex="-1"></a>    T fetch_sub<span class="op">(</span>T operand<span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span>
<span id="cb18-48"><a href="#cb18-48" aria-hidden="true" tabindex="-1"></a>    T fetch_sub<span class="op">(</span>difference_type operand<span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span>
<span id="cb18-49"><a href="#cb18-49" aria-hidden="true" tabindex="-1"></a></span>
<span id="cb18-50"><a href="#cb18-50" aria-hidden="true" tabindex="-1"></a>    T fetch_and<span class="op">(</span>T operand<span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span>
<span id="cb18-51"><a href="#cb18-51" aria-hidden="true" tabindex="-1"></a>    T fetch_or<span class="op">(</span>T operand<span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span>
<span id="cb18-52"><a href="#cb18-52" aria-hidden="true" tabindex="-1"></a>    T fetch_xor<span class="op">(</span>T operand<span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span>
<span id="cb18-53"><a href="#cb18-53" aria-hidden="true" tabindex="-1"></a>    T fetch_max<span class="op">(</span>T operand<span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span>
<span id="cb18-54"><a href="#cb18-54" aria-hidden="true" tabindex="-1"></a>    T fetch_min<span class="op">(</span>T operand<span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span>
<span id="cb18-55"><a href="#cb18-55" aria-hidden="true" tabindex="-1"></a>    </span>
<span id="cb18-56"><a href="#cb18-56" aria-hidden="true" tabindex="-1"></a></span>
<span id="cb18-57"><a href="#cb18-57" aria-hidden="true" tabindex="-1"></a>    T <span class="kw">operator</span><span class="op">++(</span><span class="dt">int</span><span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span>
<span id="cb18-58"><a href="#cb18-58" aria-hidden="true" tabindex="-1"></a>    T <span class="kw">operator</span><span class="op">++()</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span>
<span id="cb18-59"><a href="#cb18-59" aria-hidden="true" tabindex="-1"></a>    T <span class="kw">operator</span><span class="op">--(</span><span class="dt">int</span><span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span>
<span id="cb18-60"><a href="#cb18-60" aria-hidden="true" tabindex="-1"></a>    T <span class="kw">operator</span><span class="op">--()</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span>
<span id="cb18-61"><a href="#cb18-61" aria-hidden="true" tabindex="-1"></a></span>
<span id="cb18-62"><a href="#cb18-62" aria-hidden="true" tabindex="-1"></a>    T <span class="kw">operator</span><span class="op">+=(</span>T operand<span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span>
<span id="cb18-63"><a href="#cb18-63" aria-hidden="true" tabindex="-1"></a>    T <span class="kw">operator</span><span class="op">+=(</span>difference_type operand<span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span>
<span id="cb18-64"><a href="#cb18-64" aria-hidden="true" tabindex="-1"></a>    T <span class="kw">operator</span><span class="op">-=(</span>T operand<span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span>
<span id="cb18-65"><a href="#cb18-65" aria-hidden="true" tabindex="-1"></a>    T <span class="kw">operator</span><span class="op">-=(</span>difference_type operand<span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span>
<span id="cb18-66"><a href="#cb18-66" aria-hidden="true" tabindex="-1"></a></span>
<span id="cb18-67"><a href="#cb18-67" aria-hidden="true" tabindex="-1"></a>    T <span class="kw">operator</span><span class="op">&amp;=(</span>T operand<span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span>
<span id="cb18-68"><a href="#cb18-68" aria-hidden="true" tabindex="-1"></a>    T <span class="kw">operator</span><span class="op">|=(</span>T operand<span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span>
<span id="cb18-69"><a href="#cb18-69" aria-hidden="true" tabindex="-1"></a>    T <span class="kw">operator</span><span class="op">^=(</span>T operand<span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span>
<span id="cb18-70"><a href="#cb18-70" aria-hidden="true" tabindex="-1"></a></span>
<span id="cb18-71"><a href="#cb18-71" aria-hidden="true" tabindex="-1"></a>    <span class="dt">void</span> wait<span class="op">(</span>T old<span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span>
<span id="cb18-72"><a href="#cb18-72" aria-hidden="true" tabindex="-1"></a>    <span class="dt">void</span> notify_one<span class="op">()</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span>
<span id="cb18-73"><a href="#cb18-73" aria-hidden="true" tabindex="-1"></a>    <span class="dt">void</span> notify_all<span class="op">()</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span>
<span id="cb18-74"><a href="#cb18-74" aria-hidden="true" tabindex="-1"></a><span class="op">}</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">1</a></span>
Class <code>atomic-ref-bound</code> is for exposition only.</p>
<p><span class="marginalizedparent"><a class="marginalized">2</a></span>
<em>Mandates:</em></p>
<ul>
<li><p><span class="marginalizedparent"><a class="marginalized">(2.1)</a></span>
<code>is_trivially_copyable_v&lt;T&gt;</code> is
<code>true</code>.</p></li>
<li><p><span class="marginalizedparent"><a class="marginalized">(2.2)</a></span>
<code>is_same_v&lt;T, remove_cv_t&lt;T&gt;&gt;</code> is
<code>true</code>.</p></li>
</ul>
<p><i>[Note:</i> Unlike <code>atomic_ref</code>, the memory ordering for
the arithmetic operators is <code>MemoryOrder</code>, which is not
necessarily <code>memory_order_seq_cst</code>. <i>– end note]</i></p>
<p><strong>Operations [atomics.ref.bound.ops]</strong></p>
<div class="sourceCode" id="cb19"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb19-1"><a href="#cb19-1" aria-hidden="true" tabindex="-1"></a><span class="dt">bool</span> is_lock_free<span class="op">()</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">1</a></span>
<em>Effects:</em> Equivalent to:
<code>return ref.is_lock_free();</code></p>
<div class="sourceCode" id="cb20"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb20-1"><a href="#cb20-1" aria-hidden="true" tabindex="-1"></a><span class="kw">explicit</span> atomic<span class="op">-</span>ref<span class="op">-</span>bound<span class="op">(</span>T<span class="op">&amp;</span> t<span class="op">)</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">2</a></span>
<em>Preconditions:</em> The referenced object is aligned to
<code>required_alignment</code>.</p>
<p><span class="marginalizedparent"><a class="marginalized">3</a></span>
<em>Postconditions:</em> <code>ref</code> references the object
referenced by <code>t</code>.</p>
<p><span class="marginalizedparent"><a class="marginalized">4</a></span>
<em>Throws:</em> Nothing.</p>
<div class="sourceCode" id="cb21"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb21-1"><a href="#cb21-1" aria-hidden="true" tabindex="-1"></a>atomic<span class="op">-</span>ref<span class="op">-</span>bound<span class="op">(</span><span class="kw">const</span> atomic<span class="op">-</span>ref<span class="op">-</span>bound<span class="op">&amp;</span> a<span class="op">)</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">5</a></span>
<em>Postconditions:</em> <code>*this</code> references the object
referenced by <code>a</code>.</p>
<div class="sourceCode" id="cb22"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb22-1"><a href="#cb22-1" aria-hidden="true" tabindex="-1"></a><span class="dt">void</span> store<span class="op">(</span>T desired<span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">6</a></span>
<em>Effects:</em> Equivalent to:
<code>ref.store(desired, store_ordering);</code></p>
<div class="sourceCode" id="cb23"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb23-1"><a href="#cb23-1" aria-hidden="true" tabindex="-1"></a>T <span class="kw">operator</span><span class="op">=(</span>T desired<span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">7</a></span>
<em>Effects:</em> Equivalent to:
<code>store(desired); return desired;</code></p>
<div class="sourceCode" id="cb24"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb24-1"><a href="#cb24-1" aria-hidden="true" tabindex="-1"></a>T load<span class="op">()</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">8</a></span>
<em>Effects:</em> Equivalent to:
<code>ref.load(load_ordering);</code></p>
<div class="sourceCode" id="cb25"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb25-1"><a href="#cb25-1" aria-hidden="true" tabindex="-1"></a><span class="kw">operator</span> T<span class="op">()</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">9</a></span>
<em>Effects:</em> Equivalent to: <code>return load();</code></p>
<div class="sourceCode" id="cb26"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb26-1"><a href="#cb26-1" aria-hidden="true" tabindex="-1"></a>T exchange<span class="op">(</span>T desired<span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">10</a></span>
<em>Effects:</em> Equivalent to:
<code>return ref.exchange(desired, memory_ordering);</code></p>
<div class="sourceCode" id="cb27"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb27-1"><a href="#cb27-1" aria-hidden="true" tabindex="-1"></a><span class="dt">bool</span> compare_exchange_weak<span class="op">(</span>T<span class="op">&amp;</span> expected, T desired<span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">11</a></span>
<em>Effects:</em> Equivalent to:
<code>return ref.compare_exchange_weak(expected, desired, memory_ordering, load_ordering);</code></p>
<div class="sourceCode" id="cb28"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb28-1"><a href="#cb28-1" aria-hidden="true" tabindex="-1"></a><span class="dt">bool</span> compare_exchange_strong<span class="op">(</span>T<span class="op">&amp;</span> expected, T desired<span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">12</a></span>
<em>Effects:</em> Equivalent to:
<code>return ref.compare_exchange_strong(expected, desired, memory_ordering, load_ordering);</code></p>
<div class="sourceCode" id="cb29"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb29-1"><a href="#cb29-1" aria-hidden="true" tabindex="-1"></a>T fetch_add<span class="op">(</span>T operand<span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">13</a></span>
<em>Constraints:</em>
<code>is_integral_value || is_floating_point_value</code> is
<code>true</code>.</p>
<p><span class="marginalizedparent"><a class="marginalized">14</a></span>
<em>Effects:</em> Equivalent to:
<code>return ref.fetch_add(operand, memory_ordering);</code></p>
<div class="sourceCode" id="cb30"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb30-1"><a href="#cb30-1" aria-hidden="true" tabindex="-1"></a>T fetch_add<span class="op">(</span>difference_type operand<span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">15</a></span>
<em>Constraints:</em> <code>is_pointer_value</code> is
<code>true</code>.</p>
<p><span class="marginalizedparent"><a class="marginalized">16</a></span>
<em>Effects:</em> Equivalent to:
<code>return ref.fetch_add(operand, memory_ordering);</code></p>
<div class="sourceCode" id="cb31"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb31-1"><a href="#cb31-1" aria-hidden="true" tabindex="-1"></a>T fetch_sub<span class="op">(</span>T operand<span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">17</a></span>
<em>Constraints:</em>
<code>is_integral_value || is_floating_point_value</code> is
<code>true</code>.</p>
<p><span class="marginalizedparent"><a class="marginalized">18</a></span>
<em>Effects:</em> Equivalent to:
<code>return ref.fetch_sub(operand, memory_ordering);</code></p>
<div class="sourceCode" id="cb32"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb32-1"><a href="#cb32-1" aria-hidden="true" tabindex="-1"></a>T fetch_sub<span class="op">(</span>difference_type operand<span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">19</a></span>
<em>Constraints:</em> <code>is_pointer_value</code> is
<code>true</code>.</p>
<p><span class="marginalizedparent"><a class="marginalized">20</a></span>
<em>Effects:</em> Equivalent to:
<code>return ref.fetch_sub(operand, memory_ordering);</code></p>
<div class="sourceCode" id="cb33"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb33-1"><a href="#cb33-1" aria-hidden="true" tabindex="-1"></a>T fetch_and<span class="op">(</span>difference_type operand<span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">21</a></span>
<em>Constraints:</em> <code>is_integral_value</code> is
<code>true</code>.</p>
<p><span class="marginalizedparent"><a class="marginalized">22</a></span>
<em>Effects:</em> Equivalent to:
<code>return ref.fetch_and(operand, memory_ordering);</code></p>
<div class="sourceCode" id="cb34"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb34-1"><a href="#cb34-1" aria-hidden="true" tabindex="-1"></a>T fetch_or<span class="op">(</span>difference_type operand<span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">23</a></span>
<em>Constraints:</em> <code>is_integral_value</code> is
<code>true</code>.</p>
<p><span class="marginalizedparent"><a class="marginalized">24</a></span>
<em>Effects:</em> Equivalent to:
<code>return ref.fetch_or(operand, memory_ordering);</code></p>
<div class="sourceCode" id="cb35"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb35-1"><a href="#cb35-1" aria-hidden="true" tabindex="-1"></a>T fetch_xor<span class="op">(</span>difference_type operand<span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">25</a></span>
<em>Constraints:</em> <code>is_integral_value</code> is
<code>true</code>.</p>
<p><span class="marginalizedparent"><a class="marginalized">26</a></span>
<em>Effects:</em> Equivalent to:
<code>return ref.fetch_xor(operand, memory_ordering);</code></p>
<div class="sourceCode" id="cb36"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb36-1"><a href="#cb36-1" aria-hidden="true" tabindex="-1"></a>T fetch_max<span class="op">(</span>difference_type operand<span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">25</a></span>
<em>Constraints:</em> <code>is_integral_value</code> is
<code>true</code>.</p>
<p><span class="marginalizedparent"><a class="marginalized">26</a></span>
<em>Effects:</em> Equivalent to:
<code>return ref.fetch_max(operand, memory_ordering);</code></p>
<div class="sourceCode" id="cb37"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb37-1"><a href="#cb37-1" aria-hidden="true" tabindex="-1"></a>T fetch_min<span class="op">(</span>difference_type operand<span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">25</a></span>
<em>Constraints:</em> <code>is_integral_value</code> is
<code>true</code>.</p>
<p><span class="marginalizedparent"><a class="marginalized">26</a></span>
<em>Effects:</em> Equivalent to:
<code>return ref.fetch_min(operand, memory_ordering);</code></p>
<div class="sourceCode" id="cb38"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb38-1"><a href="#cb38-1" aria-hidden="true" tabindex="-1"></a>T <span class="kw">operator</span><span class="op">++(</span><span class="dt">int</span><span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">27</a></span>
<em>Constraints:</em> <code>is_integral_value || is_pointer_value</code>
is <code>true</code>.</p>
<p><span class="marginalizedparent"><a class="marginalized">28</a></span>
<em>Effects:</em> Equivalent to: <code>return fetch_add(1);</code></p>
<div class="sourceCode" id="cb39"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb39-1"><a href="#cb39-1" aria-hidden="true" tabindex="-1"></a>T <span class="kw">operator</span><span class="op">++()</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">29</a></span>
<em>Constraints:</em> <code>is_integral_value || is_pointer_value</code>
is <code>true</code>.</p>
<p><span class="marginalizedparent"><a class="marginalized">30</a></span>
<em>Effects:</em> Equivalent to:
<code>return fetch_add(1) + 1;</code></p>
<div class="sourceCode" id="cb40"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb40-1"><a href="#cb40-1" aria-hidden="true" tabindex="-1"></a>T <span class="kw">operator</span><span class="op">--(</span><span class="dt">int</span><span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">31</a></span>
<em>Constraints:</em> <code>is_integral_value || is_pointer_value</code>
is <code>true</code>.</p>
<p><span class="marginalizedparent"><a class="marginalized">32</a></span>
<em>Effects:</em> Equivalent to: <code>return fetch_sub(1);</code></p>
<div class="sourceCode" id="cb41"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb41-1"><a href="#cb41-1" aria-hidden="true" tabindex="-1"></a>T <span class="kw">operator</span><span class="op">--()</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">33</a></span>
<em>Constraints:</em> <code>is_integral_value || is_pointer_value</code>
is <code>true</code>.</p>
<p><span class="marginalizedparent"><a class="marginalized">34</a></span>
<em>Effects:</em> Equivalent to:
<code>return fetch_sub(1) - 1;</code></p>
<div class="sourceCode" id="cb42"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb42-1"><a href="#cb42-1" aria-hidden="true" tabindex="-1"></a>T <span class="kw">operator</span><span class="op">+=(</span>T operand<span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">35</a></span>
<em>Constraints:</em>
<code>is_integral_value || is_floating_point_value</code> is
<code>true</code>.</p>
<p><span class="marginalizedparent"><a class="marginalized">36</a></span>
<em>Effects:</em> Equivalent to:
<code>return fetch_add(operand) + operand;</code></p>
<div class="sourceCode" id="cb43"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb43-1"><a href="#cb43-1" aria-hidden="true" tabindex="-1"></a>T <span class="kw">operator</span><span class="op">+=(</span>difference_type operand<span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">37</a></span>
<em>Constraints:</em> <code>is_pointer_value</code> is
<code>true</code>.</p>
<p><span class="marginalizedparent"><a class="marginalized">38</a></span>
<em>Effects:</em> Equivalent to:
<code>return fetch_add(operand) + operand;</code></p>
<div class="sourceCode" id="cb44"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb44-1"><a href="#cb44-1" aria-hidden="true" tabindex="-1"></a>T <span class="kw">operator</span><span class="op">-=(</span>T operand<span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">39</a></span>
<em>Constraints:</em>
<code>is_integral_value || is_floating_point_value</code> is
<code>true</code>.</p>
<p><span class="marginalizedparent"><a class="marginalized">40</a></span>
<em>Effects:</em> Equivalent to:
<code>return fetch_sub(operand) - operand;</code></p>
<div class="sourceCode" id="cb45"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb45-1"><a href="#cb45-1" aria-hidden="true" tabindex="-1"></a>T <span class="kw">operator</span><span class="op">-=(</span>difference_type operand<span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">41</a></span>
<em>Constraints:</em> <code>is_pointer_value</code> is
<code>true</code>.</p>
<p><span class="marginalizedparent"><a class="marginalized">42</a></span>
<em>Effects:</em> Equivalent to:
<code>return fetch_sub(operand) - operand;</code></p>
<div class="sourceCode" id="cb46"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb46-1"><a href="#cb46-1" aria-hidden="true" tabindex="-1"></a>T <span class="kw">operator</span><span class="op">&amp;=(</span>T operand<span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">43</a></span>
<em>Constraints:</em> <code>is_integral_value</code> is
<code>true</code>.</p>
<p><span class="marginalizedparent"><a class="marginalized">44</a></span>
<em>Effects:</em> Equivalent to:
<code>return fetch_and(operand) &amp; operand;</code></p>
<div class="sourceCode" id="cb47"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb47-1"><a href="#cb47-1" aria-hidden="true" tabindex="-1"></a>T <span class="kw">operator</span><span class="op">|=(</span>T operand<span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">45</a></span>
<em>Constraints:</em> <code>is_integral_value</code> is
<code>true</code>.</p>
<p><span class="marginalizedparent"><a class="marginalized">46</a></span>
<em>Effects:</em> Equivalent to:
<code>return fetch_or(operand) | operand;</code></p>
<div class="sourceCode" id="cb48"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb48-1"><a href="#cb48-1" aria-hidden="true" tabindex="-1"></a>T <span class="kw">operator</span><span class="op">^=(</span>T operand<span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">47</a></span>
<em>Constraints:</em> <code>is_integral_value</code> is
<code>true</code>.</p>
<p><span class="marginalizedparent"><a class="marginalized">48</a></span>
<em>Effects:</em> Equivalent to:
<code>return fetch_xor(operand) ^ operand;</code></p>
<div class="sourceCode" id="cb49"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb49-1"><a href="#cb49-1" aria-hidden="true" tabindex="-1"></a><span class="dt">void</span> wait<span class="op">(</span>T old<span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">49</a></span>
<em>Effects:</em> Equivalent to:
<code>ref.wait(old, load_ordering);</code></p>
<div class="sourceCode" id="cb50"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb50-1"><a href="#cb50-1" aria-hidden="true" tabindex="-1"></a><span class="dt">void</span> notify_one<span class="op">()</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">50</a></span>
<em>Effects:</em> Equivalent to: <code>ref.notify_one(); }</code></p>
<div class="sourceCode" id="cb51"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb51-1"><a href="#cb51-1" aria-hidden="true" tabindex="-1"></a><span class="dt">void</span> notify_all<span class="op">()</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">51</a></span>
<em>Effects:</em> Equivalent to: <code>ref.notify_all(); }</code></p>
<p><b>Memory Order Specific Atomic Refs
[atomics.refs.bound.order]</b></p>
<div class="sourceCode" id="cb52"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb52-1"><a href="#cb52-1" aria-hidden="true" tabindex="-1"></a><span class="co">// all freestanding</span></span>
<span id="cb52-2"><a href="#cb52-2" aria-hidden="true" tabindex="-1"></a><span class="kw">namespace</span> std <span class="op">{</span></span>
<span id="cb52-3"><a href="#cb52-3" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> T<span class="op">&gt;</span></span>
<span id="cb52-4"><a href="#cb52-4" aria-hidden="true" tabindex="-1"></a><span class="kw">using</span> atomic_ref_relaxed <span class="op">=</span> atomic<span class="op">-</span>ref<span class="op">-</span>bound<span class="op">&lt;</span>T, memory_order_relaxed<span class="op">&gt;</span>;</span>
<span id="cb52-5"><a href="#cb52-5" aria-hidden="true" tabindex="-1"></a></span>
<span id="cb52-6"><a href="#cb52-6" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> T<span class="op">&gt;</span></span>
<span id="cb52-7"><a href="#cb52-7" aria-hidden="true" tabindex="-1"></a><span class="kw">using</span> atomic_ref_acq_rel <span class="op">=</span> atomic<span class="op">-</span>ref<span class="op">-</span>bound<span class="op">&lt;</span>T, memory_order_acq_rel<span class="op">&gt;</span>;</span>
<span id="cb52-8"><a href="#cb52-8" aria-hidden="true" tabindex="-1"></a></span>
<span id="cb52-9"><a href="#cb52-9" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span><span class="op">&lt;</span><span class="kw">class</span> T<span class="op">&gt;</span></span>
<span id="cb52-10"><a href="#cb52-10" aria-hidden="true" tabindex="-1"></a><span class="kw">using</span> atomic_ref_seq_cst <span class="op">=</span> atomic<span class="op">-</span>ref<span class="op">-</span>bound<span class="op">&lt;</span>T, memory_order_seq_cst<span class="op">&gt;</span>;</span>
<span id="cb52-11"><a href="#cb52-11" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span></code></pre></div>
<h3 data-number="5.1.3" id="in-version.syn"><span class="header-section-number">5.1.3</span> In [version.syn]:<a href="#in-version.syn" class="self-link"></a></h3>
<p>Update the feature test macro <code>__cpp_lib_atomic_ref</code>.</p>
<h2 data-number="5.2" id="atomic-accessors"><span class="header-section-number">5.2</span> Atomic Accessors<a href="#atomic-accessors" class="self-link"></a></h2>
<h3 data-number="5.2.1" id="add-to-the-mdspan-header-synopsis-in-mdspan.syn"><span class="header-section-number">5.2.1</span> Add to the mdspan header
synopsis in [mdspan.syn]<a href="#add-to-the-mdspan-header-synopsis-in-mdspan.syn" class="self-link"></a></h3>
<p><code>// [mdspan.accessor.default], class template default_accessor</code><br />
<code>template&lt;class ElementType&gt;</code><br />
<code>class default_accessor;</code><br />
<code></code><br />
<span class="add" style="color: #00AA00"><ins><span><code>// [atomics.accessor.atomic], class template basic-atomic-accessor</code></span></ins></span><br />
<span class="add" style="color: #00AA00"><ins><span><code>template&lt;class T, class ReferenceType&gt;</code></span>
class
<em><span><code>basic-atomic-accessor</code></span></em><span><code>; // exposition only</code></span></ins></span><br />
<span class="add" style="color: #00AA00"><ins><span><code>template&lt;class T&gt; using atomic_accessor =</code></span><em><span><code>basic-atomic-accessor</code></span></em><span><code>&lt;T, atomic_ref&lt;T&gt;&gt;;</code></span></ins></span><br />
<span class="add" style="color: #00AA00"><ins><span><code>template&lt;class T&gt; using atomic_accessor_relaxed =</code></span><em><span><code>basic-atomic-accessor</code></span></em><span><code>&lt;T, atomic_ref_relaxed&lt;T&gt;&gt;;</code></span></ins></span><br />
<span class="add" style="color: #00AA00"><ins><span><code>template&lt;class T&gt; using atomic_accessor_acq_rel =</code></span><em><span><code>basic-atomic-accessor</code></span></em><span><code>&lt;T, atomic_ref_acq_rel&lt;T&gt;&gt;;</code></span></ins></span><br />
<span class="add" style="color: #00AA00"><ins><span><code>template&lt;class T&gt; using atomic_accessor_seq_cst =</code></span><em><span><code>basic-atomic-accessor</code></span></em><span><code>&lt;T, atomic_ref_seq_cst&lt;T&gt;&gt;;</code></span></ins></span><br />
<code></code><br />
<code>// [mdspan.mdspan], class template mdspan</code><br />
<code>template&lt;class ElementType, class Extents, class LayoutPolicy = layout_right,</code><br />
<code>class AccessorPolicy = default_accessor&lt;ElementType&gt;&gt;</code><br />
<code>class mdspan;</code></p>
<h3 data-number="5.2.2" id="put-the-following-before-mdspan.mdspan"><span class="header-section-number">5.2.2</span> Put the following before
[mdspan.mdspan]:<a href="#put-the-following-before-mdspan.mdspan" class="self-link"></a></h3>
<p><b>Class template <code>basic-atomic-accessor</code>
[mdspan.accessor.atomic.basic]</b></p>
<p><b>General [mdspan.accessor.atomic.basic.overview]</b></p>
<div class="sourceCode" id="cb53"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb53-1"><a href="#cb53-1" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span> <span class="op">&lt;</span><span class="kw">class</span> ElementType, <span class="kw">class</span> ReferenceType<span class="op">&gt;</span></span>
<span id="cb53-2"><a href="#cb53-2" aria-hidden="true" tabindex="-1"></a><span class="kw">struct</span> <em>basic-atomic-accessor</em> <span class="op">{</span>  <span class="co">// exposition only</span></span>
<span id="cb53-3"><a href="#cb53-3" aria-hidden="true" tabindex="-1"></a>    <span class="kw">using</span> offset_policy <span class="op">=</span> basic<span class="op">-</span>atomic<span class="op">-</span>accessor;</span>
<span id="cb53-4"><a href="#cb53-4" aria-hidden="true" tabindex="-1"></a>    <span class="kw">using</span> element_type <span class="op">=</span> ElementType;</span>
<span id="cb53-5"><a href="#cb53-5" aria-hidden="true" tabindex="-1"></a>    <span class="kw">using</span> reference <span class="op">=</span> ReferenceType;</span>
<span id="cb53-6"><a href="#cb53-6" aria-hidden="true" tabindex="-1"></a>    <span class="kw">using</span> data_handle_type <span class="op">=</span> ElementType<span class="op">*</span>;</span>
<span id="cb53-7"><a href="#cb53-7" aria-hidden="true" tabindex="-1"></a></span>
<span id="cb53-8"><a href="#cb53-8" aria-hidden="true" tabindex="-1"></a>    <span class="kw">constexpr</span> basic<span class="op">-</span>atomic<span class="op">-</span>accessor<span class="op">()</span> <span class="kw">noexcept</span> <span class="op">=</span> <span class="cf">default</span>;</span>
<span id="cb53-9"><a href="#cb53-9" aria-hidden="true" tabindex="-1"></a></span>
<span id="cb53-10"><a href="#cb53-10" aria-hidden="true" tabindex="-1"></a>    <span class="kw">template</span> <span class="op">&lt;</span><span class="kw">class</span> OtherElementType<span class="op">&gt;</span></span>
<span id="cb53-11"><a href="#cb53-11" aria-hidden="true" tabindex="-1"></a>    <span class="kw">constexpr</span> basic<span class="op">-</span>atomic<span class="op">-</span>accessor<span class="op">(</span>default_accessor<span class="op">&lt;</span>OtherElementType<span class="op">&gt;)</span> <span class="kw">noexcept</span>;</span>
<span id="cb53-12"><a href="#cb53-12" aria-hidden="true" tabindex="-1"></a></span>
<span id="cb53-13"><a href="#cb53-13" aria-hidden="true" tabindex="-1"></a>    <span class="kw">template</span> <span class="op">&lt;</span><span class="kw">class</span> OtherElementType<span class="op">&gt;</span></span>
<span id="cb53-14"><a href="#cb53-14" aria-hidden="true" tabindex="-1"></a>    <span class="kw">constexpr</span> basic<span class="op">-</span>atomic<span class="op">-</span>accessor<span class="op">(</span>basic<span class="op">-</span>atomic<span class="op">-</span>accessor<span class="op">&lt;</span>OtherElementType, ReferenceType<span class="op">&gt;)</span> <span class="kw">noexcept</span>;</span>
<span id="cb53-15"><a href="#cb53-15" aria-hidden="true" tabindex="-1"></a></span>
<span id="cb53-16"><a href="#cb53-16" aria-hidden="true" tabindex="-1"></a>    <span class="kw">constexpr</span> reference access<span class="op">(</span>data_handle_type p, <span class="dt">size_t</span> i<span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span>
<span id="cb53-17"><a href="#cb53-17" aria-hidden="true" tabindex="-1"></a>    <span class="kw">constexpr</span> data_handle_type offset<span class="op">(</span>data_handle_type p, <span class="dt">size_t</span> i<span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span>
<span id="cb53-18"><a href="#cb53-18" aria-hidden="true" tabindex="-1"></a><span class="op">}</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">1</a></span>
Class <code>basic-atomic-accessor</code> is for exposition only.</p>
<p><span class="marginalizedparent"><a class="marginalized">2</a></span>
<code>basic-atomic-accessor</code> meets the accessor policy
requirements.</p>
<p><span class="marginalizedparent"><a class="marginalized">3</a></span>
<code>ElementType</code> is required to be a complete object type that
is neither an abstract class type nor an array type.</p>
<p><span class="marginalizedparent"><a class="marginalized">4</a></span>
Each specialization of <code>basic-atomic-accessor</code> is a trivially
copyable type that models <code>semiregular</code>.</p>
<p><span class="marginalizedparent"><a class="marginalized">5</a></span>
<code>[0,n)</code> is an accessible range for an object <code>p</code>
of type <code>data_handle_type</code> and an object of type
<code>basic-atomic-accessor</code> if and only if <code>[p,p+n)</code>
is a valid range.</p>
<p><b>Members [mdspan.accessor.atomic.basic.members]</b></p>
<div class="sourceCode" id="cb54"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb54-1"><a href="#cb54-1" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span> <span class="op">&lt;</span><span class="kw">class</span> OtherElementType<span class="op">&gt;</span></span>
<span id="cb54-2"><a href="#cb54-2" aria-hidden="true" tabindex="-1"></a><span class="kw">constexpr</span> <em>basic-atomic-accessor</em><span class="op">(</span>default_accessor<span class="op">&lt;</span>OtherElementType<span class="op">&gt;)</span> <span class="kw">noexcept</span> <span class="op">{}</span></span>
<span id="cb54-3"><a href="#cb54-3" aria-hidden="true" tabindex="-1"></a></span>
<span id="cb54-4"><a href="#cb54-4" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span> <span class="op">&lt;</span><span class="kw">class</span> OtherElementType<span class="op">&gt;</span></span>
<span id="cb54-5"><a href="#cb54-5" aria-hidden="true" tabindex="-1"></a><span class="kw">constexpr</span> <em>basic-atomic-accessor</em><span class="op">(</span><em>basic-atomic-accessor</em><span class="op">&lt;</span>OtherElementType, ReferenceType<span class="op">&gt;)</span> <span class="kw">noexcept</span> <span class="op">{}</span></span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">1</a></span>
<em>Constraints:</em>
<code>is_convertible_v&lt;OtherElementType (*)[], element_type (*)[]&gt;</code>
is <code>true</code>.</p>
<div class="sourceCode" id="cb55"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb55-1"><a href="#cb55-1" aria-hidden="true" tabindex="-1"></a><span class="kw">constexpr</span> reference access<span class="op">(</span>data_handle_type p, <span class="dt">size_t</span> i<span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">2</a></span>
<em>Effects:</em> Equivalent to <code>return reference(p[i]);</code></p>
<div class="sourceCode" id="cb56"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb56-1"><a href="#cb56-1" aria-hidden="true" tabindex="-1"></a><span class="kw">constexpr</span> data_handle_type offset<span class="op">(</span>data_handle_type p, <span class="dt">size_t</span> i<span class="op">)</span> <span class="kw">const</span> <span class="kw">noexcept</span>;</span></code></pre></div>
<p><span class="marginalizedparent"><a class="marginalized">3</a></span>
<em>Effects:</em> Equivalent to <code>return p + i;</code></p>
<p><b>Atomic accessors [mdspan.accessor.atomic.bounded]</b></p>
<div class="sourceCode" id="cb57"><pre class="sourceCode cpp"><code class="sourceCode cpp"><span id="cb57-1"><a href="#cb57-1" aria-hidden="true" tabindex="-1"></a><span class="kw">namespace</span> std <span class="op">{</span></span>
<span id="cb57-2"><a href="#cb57-2" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span> <span class="op">&lt;</span><span class="kw">class</span> ElementType<span class="op">&gt;</span></span>
<span id="cb57-3"><a href="#cb57-3" aria-hidden="true" tabindex="-1"></a><span class="kw">using</span> atomic_accessor <span class="op">=</span> <em>basic-atomic-accessor</em><span class="op">&lt;</span>ElementType, atomic_ref<span class="op">&lt;</span>ElementType<span class="op">&gt;&gt;</span>;</span>
<span id="cb57-4"><a href="#cb57-4" aria-hidden="true" tabindex="-1"></a></span>
<span id="cb57-5"><a href="#cb57-5" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span> <span class="op">&lt;</span><span class="kw">class</span> ElementType<span class="op">&gt;</span></span>
<span id="cb57-6"><a href="#cb57-6" aria-hidden="true" tabindex="-1"></a><span class="kw">using</span> atomic_accessor_relaxed <span class="op">=</span> <em>basic-atomic-accessor</em><span class="op">&lt;</span>ElementType, atomic_ref_relaxed<span class="op">&lt;</span>ElementType<span class="op">&gt;&gt;</span>;</span>
<span id="cb57-7"><a href="#cb57-7" aria-hidden="true" tabindex="-1"></a></span>
<span id="cb57-8"><a href="#cb57-8" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span> <span class="op">&lt;</span><span class="kw">class</span> ElementType<span class="op">&gt;</span></span>
<span id="cb57-9"><a href="#cb57-9" aria-hidden="true" tabindex="-1"></a><span class="kw">using</span> atomic_accessor_acq_rel <span class="op">=</span> <em>basic-atomic-accessor</em><span class="op">&lt;</span>ElementType, atomic_ref_acq_rel<span class="op">&lt;</span>ElementType<span class="op">&gt;&gt;</span>;</span>
<span id="cb57-10"><a href="#cb57-10" aria-hidden="true" tabindex="-1"></a></span>
<span id="cb57-11"><a href="#cb57-11" aria-hidden="true" tabindex="-1"></a><span class="kw">template</span> <span class="op">&lt;</span><span class="kw">class</span> ElementType<span class="op">&gt;</span></span>
<span id="cb57-12"><a href="#cb57-12" aria-hidden="true" tabindex="-1"></a><span class="kw">using</span> atomic_accessor_seq_cst <span class="op">=</span> <em>basic-atomic-accessor</em><span class="op">&lt;</span>ElementType, atomic_ref_seq_cst<span class="op">&lt;</span>ElementType<span class="op">&gt;&gt;</span>;</span>
<span id="cb57-13"><a href="#cb57-13" aria-hidden="true" tabindex="-1"></a><span class="op">}</span></span></code></pre></div>
<h2 data-number="5.3" id="in-version.syn-1"><span class="header-section-number">5.3</span> In [version.syn]<a href="#in-version.syn-1" class="self-link"></a></h2>
<p>Add the following feature test macro:</p>
<p><code>#define __cpp_lib_atomic_accessors YYYYMML // also in &lt;mdspan&gt;</code></p>
<h1 data-number="6" id="acknowledgments"><span class="header-section-number">6</span> Acknowledgments<a href="#acknowledgments" class="self-link"></a></h1>
<p>Sandia National Laboratories is a multimission laboratory managed and
operated by National Technology and Engineering Solutions of Sandia,
LLC., a wholly owned subsidiary of Honeywell International, Inc., for
the U.S. Department of Energy’s National Nuclear Security Administration
under Grant DE-NA-0003525.</p>
<p>This manuscript has been authored by UTBattelle, LLC, under Grant
DE-AC05-00OR22725 with the U.S. Department of Energy (DOE).</p>
<p>This work was supported by Exascale Computing Project 17-SC-20-SC, a
joint project of the U.S. Department of Energy’s Office of Science and
National Nuclear Security Administration, responsible for delivering a
capable exascale ecosystem, including software, applications, and
hardware technology, to support the nation’s exascale computing
imperative.</p>
<p>This research used resources of the Argonne Leadership Computing
Facility, which is a DOE Office of Science User Facility supported under
Contract DE-AC02-06CH11357.</p>
</div>
</div>
</body>
</html>
