<!doctype html><html lang="en">
 <head>
  <meta content="text/html; charset=utf-8" http-equiv="Content-Type">
  <meta content="width=device-width, initial-scale=1, shrink-to-fit=no" name="viewport">
  <title>P1135R6: The C++20 Synchronization Library</title>
<style data-fill-with="stylesheet">/******************************************************************************
 *                   Style sheet for the W3C specifications                   *
 *
 * Special classes handled by this style sheet include:
 *
 * Indices
 *   - .toc for the Table of Contents (<ol class="toc">)
 *     + <span class="secno"> for the section numbers
 *   - #toc for the Table of Contents (<nav id="toc">)
 *   - ul.index for Indices (<a href="#ref">term</a><span>, in §N.M</span>)
 *   - table.index for Index Tables (e.g. for properties or elements)
 *
 * Structural Markup
 *   - table.data for general data tables
 *     -> use 'scope' attribute, <colgroup>, <thead>, and <tbody> for best results !
 *     -> use <table class='complex data'> for extra-complex tables
 *     -> use <td class='long'> for paragraph-length cell content
 *     -> use <td class='pre'> when manual line breaks/indentation would help readability
 *   - dl.switch for switch statements
 *   - ol.algorithm for algorithms (helps to visualize nesting)
 *   - .figure and .caption (HTML4) and figure and figcaption (HTML5)
 *     -> .sidefigure for right-floated figures
 *   - ins/del
 *
 * Code
 *   - pre and code
 *
 * Special Sections
 *   - .note       for informative notes             (div, p, span, aside, details)
 *   - .example    for informative examples          (div, p, pre, span)
 *   - .issue      for issues                        (div, p, span)
 *   - .assertion  for assertions                    (div, p, span)
 *   - .advisement for loud normative statements     (div, p, strong)
 *   - .annoying-warning for spec obsoletion notices (div, aside, details)
 *
 * Definition Boxes
 *   - pre.def   for WebIDL definitions
 *   - table.def for tables that define other entities (e.g. CSS properties)
 *   - dl.def    for definition lists that define other entitles (e.g. HTML elements)
 *
 * Numbering
 *   - .secno for section numbers in .toc and headings (<span class='secno'>3.2</span>)
 *   - .marker for source-inserted example/figure/issue numbers (<span class='marker'>Issue 4</span>)
 *   - ::before styled for CSS-generated issue/example/figure numbers:
 *     -> Documents wishing to use this only need to add
 *        figcaption::before,
 *        .caption::before { content: "Figure "  counter(figure) " ";  }
 *        .example::before { content: "Example " counter(example) " "; }
 *        .issue::before   { content: "Issue "   counter(issue) " ";   }
 *
 * Header Stuff (ignore, just don't conflict with these classes)
 *   - .head for the header
 *   - .copyright for the copyright
 *
 * Miscellaneous
 *   - .overlarge for things that should be as wide as possible, even if
 *     that overflows the body text area. This can be used on an item or
 *     on its container, depending on the effect desired.
 *     Note that this styling basically doesn't help at all when printing,
 *     since A4 paper isn't much wider than the max-width here.
 *     It's better to design things to fit into a narrower measure if possible.
 *   - js-added ToC jump links (see fixup.js)
 *
 ******************************************************************************/

/******************************************************************************/
/*                                   Body                                     */
/******************************************************************************/

	body {
		counter-reset: example figure issue;

		/* Layout */
		max-width: 50em;               /* limit line length to 50em for readability   */
		margin: 0 auto;                /* center text within page                     */
		padding: 1.6em 1.5em 2em 50px; /* assume 16px font size for downlevel clients */
		padding: 1.6em 1.5em 2em calc(26px + 1.5em); /* leave space for status flag     */

		/* Typography */
		line-height: 1.5;
		font-family: sans-serif;
		widows: 2;
		orphans: 2;
		word-wrap: break-word;
		overflow-wrap: break-word;
		hyphens: auto;

		/* Colors */
		color: black;
		background: white top left fixed no-repeat;
		background-size: 25px auto;
	}


/******************************************************************************/
/*                         Front Matter & Navigation                          */
/******************************************************************************/

/** Header ********************************************************************/

	div.head { margin-bottom: 1em }
	div.head hr { border-style: solid; }

	div.head h1 {
		font-weight: bold;
		margin: 0 0 .1em;
		font-size: 220%;
	}

	div.head h2 { margin-bottom: 1.5em;}

/** W3C Logo ******************************************************************/

	.head .logo {
		float: right;
		margin: 0.4rem 0 0.2rem .4rem;
	}

	.head img[src*="logos/W3C"] {
		display: block;
		border: solid #1a5e9a;
		border-width: .65rem .7rem .6rem;
		border-radius: .4rem;
		background: #1a5e9a;
		color: white;
		font-weight: bold;
	}

	.head a:hover > img[src*="logos/W3C"],
	.head a:focus > img[src*="logos/W3C"] {
		opacity: .8;
	}

	.head a:active > img[src*="logos/W3C"] {
		background: #c00;
		border-color: #c00;
	}

	/* see also additional rules in Link Styling section */

/** Copyright *****************************************************************/

	p.copyright,
	p.copyright small { font-size: small }

/** Back to Top / ToC Toggle **************************************************/

	@media print {
		#toc-nav {
			display: none;
		}
	}
	@media not print {
		#toc-nav {
			position: fixed;
			z-index: 2;
			bottom: 0; left: 0;
			margin: 0;
			min-width: 1.33em;
			border-top-right-radius: 2rem;
			box-shadow: 0 0 2px;
			font-size: 1.5em;
			color: black;
		}
		#toc-nav > a {
			display: block;
			white-space: nowrap;

			height: 1.33em;
			padding: .1em 0.3em;
			margin: 0;

			background: white;
			box-shadow: 0 0 2px;
			border: none;
			border-top-right-radius: 1.33em;
			background: white;
		}
		#toc-nav > #toc-jump {
			padding-bottom: 2em;
			margin-bottom: -1.9em;
		}

		#toc-nav > a:hover,
		#toc-nav > a:focus {
			background: #f8f8f8;
		}
		#toc-nav > a:not(:hover):not(:focus) {
			color: #707070;
		}

		/* statusbar gets in the way on keyboard focus; remove once browsers fix */
		#toc-nav > a[href="#toc"]:not(:hover):focus:last-child {
			padding-bottom: 1.5rem;
		}

		#toc-nav:not(:hover) > a:not(:focus) > span + span {
			/* Ideally this uses :focus-within on #toc-nav */
			display: none;
		}
		#toc-nav > a > span + span {
			padding-right: 0.2em;
		}

		#toc-toggle-inline {
			vertical-align: 0.05em;
			font-size: 80%;
			color: gray;
			color: hsla(203,20%,40%,.7);
			border-style: none;
			background: transparent;
			position: relative;
		}
		#toc-toggle-inline:hover:not(:active),
		#toc-toggle-inline:focus:not(:active) {
			text-shadow: 1px 1px silver;
			top: -1px;
			left: -1px;
		}

		#toc-nav :active {
			color: #C00;
		}
	}

/** ToC Sidebar ***************************************************************/

	/* Floating sidebar */
	@media screen {
		body.toc-sidebar #toc {
			position: fixed;
			top: 0; bottom: 0;
			left: 0;
			width: 23.5em;
			max-width: 80%;
			max-width: calc(100% - 2em - 26px);
			overflow: auto;
			padding: 0 1em;
			padding-left: 42px;
			padding-left: calc(1em + 26px);
			background: inherit;
			background-color: #f7f8f9;
			z-index: 1;
			box-shadow: -.1em 0 .25em rgba(0,0,0,.1) inset;
		}
		body.toc-sidebar #toc h2 {
			margin-top: .8rem;
			font-variant: small-caps;
			font-variant: all-small-caps;
			text-transform: lowercase;
			font-weight: bold;
			color: gray;
			color: hsla(203,20%,40%,.7);
		}
		body.toc-sidebar #toc-jump:not(:focus) {
			width: 0;
			height: 0;
			padding: 0;
			position: absolute;
			overflow: hidden;
		}
	}
	/* Hide main scroller when only the ToC is visible anyway */
	@media screen and (max-width: 28em) {
		body.toc-sidebar {
			overflow: hidden;
		}
	}

	/* Sidebar with its own space */
	@media screen and (min-width: 78em) {
		body:not(.toc-inline) #toc {
			position: fixed;
			top: 0; bottom: 0;
			left: 0;
			width: 23.5em;
			overflow: auto;
			padding: 0 1em;
			padding-left: 42px;
			padding-left: calc(1em + 26px);
			background: inherit;
			background-color: #f7f8f9;
			z-index: 1;
			box-shadow: -.1em 0 .25em rgba(0,0,0,.1) inset;
		}
		body:not(.toc-inline) #toc h2 {
			margin-top: .8rem;
			font-variant: small-caps;
			font-variant: all-small-caps;
			text-transform: lowercase;
			font-weight: bold;
			color: gray;
			color: hsla(203,20%,40%,.7);
		}

		body:not(.toc-inline) {
			padding-left: 29em;
		}
		/* See also Overflow section at the bottom */

		body:not(.toc-inline) #toc-jump:not(:focus) {
			width: 0;
			height: 0;
			padding: 0;
			position: absolute;
			overflow: hidden;
		}
	}
	@media screen and (min-width: 90em) {
		body:not(.toc-inline) {
			margin: 0 4em;
		}
	}

/******************************************************************************/
/*                                Sectioning                                  */
/******************************************************************************/

/** Headings ******************************************************************/

	h1, h2, h3, h4, h5, h6, dt {
		page-break-after: avoid;
		page-break-inside: avoid;
		font: 100% sans-serif;   /* Reset all font styling to clear out UA styles */
		font-family: inherit;    /* Inherit the font family. */
		line-height: 1.2;        /* Keep wrapped headings compact */
		hyphens: manual;         /* Hyphenated headings look weird */
	}

	h2, h3, h4, h5, h6 {
		margin-top: 3rem;
	}

	h1, h2, h3 {
		color: #005A9C;
		background: transparent;
	}

	h1 { font-size: 170%; }
	h2 { font-size: 140%; }
	h3 { font-size: 120%; }
	h4 { font-weight: bold; }
	h5 { font-style: italic; }
	h6 { font-variant: small-caps; }
	dt { font-weight: bold; }

/** Subheadings ***************************************************************/

	h1 + h2,
	#subtitle {
		/* #subtitle is a subtitle in an H2 under the H1 */
		margin-top: 0;
	}
	h2 + h3,
	h3 + h4,
	h4 + h5,
	h5 + h6 {
		margin-top: 1.2em; /* = 1 x line-height */
	}

/** Section divider ***********************************************************/

	:not(.head) > hr {
		font-size: 1.5em;
		text-align: center;
		margin: 1em auto;
		height: auto;
		border: transparent solid 0;
		background: transparent;
	}
	:not(.head) > hr::before {
		content: "\2727\2003\2003\2727\2003\2003\2727";
	}

/******************************************************************************/
/*                            Paragraphs and Lists                            */
/******************************************************************************/

	p {
		margin: 1em 0;
	}

	dd > p:first-child,
	li > p:first-child {
		margin-top: 0;
	}

	ul, ol {
		margin-left: 0;
		padding-left: 2em;
	}

	li {
		margin: 0.25em 0 0.5em;
		padding: 0;
	}

	dl dd {
		margin: 0 0 .5em 2em;
	}

	.head dd + dd { /* compact for header */
		margin-top: -.5em;
	}

	/* Style for algorithms */
	ol.algorithm ol:not(.algorithm),
	.algorithm > ol ol:not(.algorithm) {
	 border-left: 0.5em solid #DEF;
	}

	/* Put nice boxes around each algorithm. */
	[data-algorithm]:not(.heading) {
	  padding: .5em;
	  border: thin solid #ddd; border-radius: .5em;
	  margin: .5em calc(-0.5em - 1px);
	}
	[data-algorithm]:not(.heading) > :first-child {
	  margin-top: 0;
	}
	[data-algorithm]:not(.heading) > :last-child {
	  margin-bottom: 0;
	}

	/* Style for switch/case <dl>s */
	dl.switch > dd > ol.only,
	dl.switch > dd > .only > ol {
	 margin-left: 0;
	}
	dl.switch > dd > ol.algorithm,
	dl.switch > dd > .algorithm > ol {
	 margin-left: -2em;
	}
	dl.switch {
	 padding-left: 2em;
	}
	dl.switch > dt {
	 text-indent: -1.5em;
	 margin-top: 1em;
	}
	dl.switch > dt + dt {
	 margin-top: 0;
	}
	dl.switch > dt::before {
	 content: '\21AA';
	 padding: 0 0.5em 0 0;
	 display: inline-block;
	 width: 1em;
	 text-align: right;
	 line-height: 0.5em;
	}

/** Terminology Markup ********************************************************/


/******************************************************************************/
/*                                 Inline Markup                              */
/******************************************************************************/

/** Terminology Markup ********************************************************/
	dfn   { /* Defining instance */
		font-weight: bolder;
	}
	a > i { /* Instance of term */
		font-style: normal;
	}
	dt dfn code, code.idl {
		font-size: medium;
	}
	dfn var {
		font-style: normal;
	}

/** Change Marking ************************************************************/

	del { color: red;  text-decoration: line-through; }
	ins { color: #080; text-decoration: underline;    }

/** Miscellaneous improvements to inline formatting ***************************/

	sup {
		vertical-align: super;
		font-size: 80%
	}

/******************************************************************************/
/*                                    Code                                    */
/******************************************************************************/

/** General monospace/pre rules ***********************************************/

	pre, code, samp {
		font-family: Menlo, Consolas, "DejaVu Sans Mono", Monaco, monospace;
		font-size: .9em;
		page-break-inside: avoid;
		hyphens: none;
		text-transform: none;
	}
	pre code,
	code code {
		font-size: 100%;
	}

	pre {
		margin-top: 1em;
		margin-bottom: 1em;
		overflow: auto;
	}

/** Inline Code fragments *****************************************************/

  /* Do something nice. */

/******************************************************************************/
/*                                    Links                                   */
/******************************************************************************/

/** General Hyperlinks ********************************************************/

	/* We hyperlink a lot, so make it less intrusive */
	a[href] {
		color: #034575;
		text-decoration: none;
		border-bottom: 1px solid #707070;
		/* Need a bit of extending for it to look okay */
		padding: 0 1px 0;
		margin: 0 -1px 0;
	}
	a:visited {
		border-bottom-color: #BBB;
	}

	/* Use distinguishing colors when user is interacting with the link */
	a[href]:focus,
	a[href]:hover {
		background: #f8f8f8;
		background: rgba(75%, 75%, 75%, .25);
		border-bottom-width: 3px;
		margin-bottom: -2px;
	}
	a[href]:active {
		color: #C00;
		border-color: #C00;
	}

	/* Backout above styling for W3C logo */
	.head .logo,
	.head .logo a {
		border: none;
		text-decoration: none;
		background: transparent;
	}

/******************************************************************************/
/*                                    Images                                  */
/******************************************************************************/

	img {
		border-style: none;
	}

	/* For autogen numbers, add
	   .caption::before, figcaption::before { content: "Figure " counter(figure) ". "; }
	*/

	figure, .figure, .sidefigure {
		page-break-inside: avoid;
		text-align: center;
		margin: 2.5em 0;
	}
	.figure img,    .sidefigure img,    figure img,
	.figure object, .sidefigure object, figure object {
		max-width: 100%;
		margin: auto;
	}
	.figure pre, .sidefigure pre, figure pre {
		text-align: left;
		display: table;
		margin: 1em auto;
	}
	.figure table, figure table {
		margin: auto;
	}
	@media screen and (min-width: 20em) {
		.sidefigure {
			float: right;
			width: 50%;
			margin: 0 0 0.5em 0.5em
		}
	}
	.caption, figcaption, caption {
		font-style: italic;
		font-size: 90%;
	}
	.caption::before, figcaption::before, figcaption > .marker {
		font-weight: bold;
	}
	.caption, figcaption {
		counter-increment: figure;
	}

	/* DL list is indented 2em, but figure inside it is not */
	dd > .figure, dd > figure { margin-left: -2em }

/******************************************************************************/
/*                             Colored Boxes                                  */
/******************************************************************************/

	.issue, .note, .example, .assertion, .advisement, blockquote {
		padding: .5em;
		border: .5em;
		border-left-style: solid;
		page-break-inside: avoid;
	}
	span.issue, span.note {
		padding: .1em .5em .15em;
		border-right-style: solid;
	}

	.issue,
	.note,
	.example,
	.advisement,
	.assertion,
	blockquote {
		margin: 1em auto;
	}
	.note  > p:first-child,
	.issue > p:first-child,
	blockquote > :first-child {
		margin-top: 0;
	}
	blockquote > :last-child {
		margin-bottom: 0;
	}

/** Blockquotes ***************************************************************/

	blockquote {
		border-color: silver;
	}

/** Open issue ****************************************************************/

	.issue {
		border-color: #E05252;
		background: #FBE9E9;
		counter-increment: issue;
		overflow: auto;
	}
	.issue::before, .issue > .marker {
		text-transform: uppercase;
		color: #AE1E1E;
		padding-right: 1em;
		text-transform: uppercase;
	}
	/* Add .issue::before { content: "Issue " counter(issue) " "; } for autogen numbers,
	   or use class="marker" to mark up the issue number in source. */

/** Example *******************************************************************/

	.example {
		border-color: #E0CB52;
		background: #FCFAEE;
		counter-increment: example;
		overflow: auto;
		clear: both;
	}
	.example::before, .example > .marker {
		text-transform: uppercase;
		color: #827017;
		min-width: 7.5em;
		display: block;
	}
	/* Add .example::before { content: "Example " counter(example) " "; } for autogen numbers,
	   or use class="marker" to mark up the example number in source. */

/** Non-normative Note ********************************************************/

	.note {
		border-color: #52E052;
		background: #E9FBE9;
		overflow: auto;
	}

	.note::before, .note > .marker,
	details.note > summary::before,
	details.note > summary > .marker {
		text-transform: uppercase;
		display: block;
		color: hsl(120, 70%, 30%);
	}
	/* Add .note::before { content: "Note"; } for autogen label,
	   or use class="marker" to mark up the label in source. */

	details.note > summary {
		display: block;
		color: hsl(120, 70%, 30%);
	}
	details.note[open] > summary {
		border-bottom: 1px silver solid;
	}

/** Assertion Box *************************************************************/
	/*  for assertions in algorithms */

	.assertion {
		border-color: #AAA;
		background: #EEE;
	}

/** Advisement Box ************************************************************/
	/*  for attention-grabbing normative statements */

	.advisement {
		border-color: orange;
		border-style: none solid;
		background: #FFEECC;
	}
	strong.advisement {
		display: block;
		text-align: center;
	}
	.advisement > .marker {
		color: #B35F00;
	}

/** Spec Obsoletion Notice ****************************************************/
	/* obnoxious obsoletion notice for older/abandoned specs. */

	details {
		display: block;
	}
	summary {
		font-weight: bolder;
	}

	.annoying-warning:not(details),
	details.annoying-warning:not([open]) > summary,
	details.annoying-warning[open] {
		background: #fdd;
		color: red;
		font-weight: bold;
		padding: .75em 1em;
		border: thick red;
		border-style: solid;
		border-radius: 1em;
	}
	.annoying-warning :last-child {
		margin-bottom: 0;
	}

@media not print {
	details.annoying-warning[open] {
		position: fixed;
		left: 1em;
		right: 1em;
		bottom: 1em;
		z-index: 1000;
	}
}

	details.annoying-warning:not([open]) > summary {
		text-align: center;
	}

/** Entity Definition Boxes ***************************************************/

	.def {
		padding: .5em 1em;
		background: #DEF;
		margin: 1.2em 0;
		border-left: 0.5em solid #8CCBF2;
	}

/******************************************************************************/
/*                                    Tables                                  */
/******************************************************************************/

	th, td {
		text-align: left;
		text-align: start;
	}

/** Property/Descriptor Definition Tables *************************************/

	table.def {
		/* inherits .def box styling, see above */
		width: 100%;
		border-spacing: 0;
	}

	table.def td,
	table.def th {
		padding: 0.5em;
		vertical-align: baseline;
		border-bottom: 1px solid #bbd7e9;
	}

	table.def > tbody > tr:last-child th,
	table.def > tbody > tr:last-child td {
		border-bottom: 0;
	}

	table.def th {
		font-style: italic;
		font-weight: normal;
		padding-left: 1em;
		width: 3em;
	}

	/* For when values are extra-complex and need formatting for readability */
	table td.pre {
		white-space: pre-wrap;
	}

	/* A footnote at the bottom of a def table */
	table.def           td.footnote {
		padding-top: 0.6em;
	}
	table.def           td.footnote::before {
		content: " ";
		display: block;
		height: 0.6em;
		width: 4em;
		border-top: thin solid;
	}

/** Data tables (and properly marked-up index tables) *************************/
	/*
		 <table class="data"> highlights structural relationships in a table
		 when correct markup is used (e.g. thead/tbody, th vs. td, scope attribute)

		 Use class="complex data" for particularly complicated tables --
		 (This will draw more lines: busier, but clearer.)

		 Use class="long" on table cells with paragraph-like contents
		 (This will adjust text alignment accordingly.)
		 Alternately use class="longlastcol" on tables, to have the last column assume "long".
	*/

	table {
		word-wrap: normal;
		overflow-wrap: normal;
		hyphens: manual;
	}

	table.data,
	table.index {
		margin: 1em auto;
		border-collapse: collapse;
		border: hidden;
		width: 100%;
	}
	table.data caption,
	table.index caption {
		max-width: 50em;
		margin: 0 auto 1em;
	}

	table.data td,  table.data th,
	table.index td, table.index th {
		padding: 0.5em 1em;
		border-width: 1px;
		border-color: silver;
		border-top-style: solid;
	}

	table.data thead td:empty {
		padding: 0;
		border: 0;
	}

	table.data  thead,
	table.index thead,
	table.data  tbody,
	table.index tbody {
		border-bottom: 2px solid;
	}

	table.data colgroup,
	table.index colgroup {
		border-left: 2px solid;
	}

	table.data  tbody th:first-child,
	table.index tbody th:first-child  {
		border-right: 2px solid;
		border-top: 1px solid silver;
		padding-right: 1em;
	}

	table.data th[colspan],
	table.data td[colspan] {
		text-align: center;
	}

	table.complex.data th,
	table.complex.data td {
		border: 1px solid silver;
		text-align: center;
	}

	table.data.longlastcol td:last-child,
	table.data td.long {
	 vertical-align: baseline;
	 text-align: left;
	}

	table.data img {
		vertical-align: middle;
	}


/*
Alternate table alignment rules

	table.data,
	table.index {
		text-align: center;
	}

	table.data  thead th[scope="row"],
	table.index thead th[scope="row"] {
		text-align: right;
	}

	table.data  tbody th:first-child,
	table.index tbody th:first-child  {
		text-align: right;
	}

Possible extra rowspan handling

	table.data  tbody th[rowspan]:not([rowspan='1']),
	table.index tbody th[rowspan]:not([rowspan='1']),
	table.data  tbody td[rowspan]:not([rowspan='1']),
	table.index tbody td[rowspan]:not([rowspan='1']) {
		border-left: 1px solid silver;
	}

	table.data  tbody th[rowspan]:first-child,
	table.index tbody th[rowspan]:first-child,
	table.data  tbody td[rowspan]:first-child,
	table.index tbody td[rowspan]:first-child{
		border-left: 0;
		border-right: 1px solid silver;
	}
*/

/******************************************************************************/
/*                                  Indices                                   */
/******************************************************************************/


/** Table of Contents *********************************************************/

	.toc a {
		/* More spacing; use padding to make it part of the click target. */
		padding-top: 0.1rem;
		/* Larger, more consistently-sized click target */
		display: block;
		/* Reverse color scheme */
		color: black;
		border-color: #3980B5;
		border-bottom-width: 3px !important;
		margin-bottom: 0px !important;
	}
	.toc a:visited {
		border-color: #054572;
	}
	.toc a:not(:focus):not(:hover) {
		/* Allow colors to cascade through from link styling */
		border-bottom-color: transparent;
	}

	.toc, .toc ol, .toc ul, .toc li {
		list-style: none; /* Numbers must be inlined into source */
		/* because generated content isn't search/selectable and markers can't do multilevel yet */
		margin:  0;
		padding: 0;
		line-height: 1.1rem; /* consistent spacing */
	}

	/* ToC not indented until third level, but font style & margins show hierarchy */
	.toc > li             { font-weight: bold;   }
	.toc > li li          { font-weight: normal; }
	.toc > li li li       { font-size:   95%;    }
	.toc > li li li li    { font-size:   90%;    }
	.toc > li li li li .secno { font-size: 85%; }
	.toc > li li li li li { font-size:   85%;    }
	.toc > li li li li li .secno { font-size: 100%; }

	/* @supports not (display:grid) { */
		.toc > li             { margin: 1.5rem 0;    }
		.toc > li li          { margin: 0.3rem 0;    }
		.toc > li li li       { margin-left: 2rem;   }

		/* Section numbers in a column of their own */
		.toc .secno {
			float: left;
			width: 4rem;
			white-space: nowrap;
		}

		.toc li {
			clear: both;
		}

		:not(li) > .toc              { margin-left:  5rem; }
		.toc .secno                  { margin-left: -5rem; }
		.toc > li li li .secno       { margin-left: -7rem; }
		.toc > li li li li .secno    { margin-left: -9rem; }
		.toc > li li li li li .secno { margin-left: -11rem; }

		/* Tighten up indentation in narrow ToCs */
		@media (max-width: 30em) {
			:not(li) > .toc              { margin-left:  4rem; }
			.toc .secno                  { margin-left: -4rem; }
			.toc > li li li              { margin-left:  1rem; }
			.toc > li li li .secno       { margin-left: -5rem; }
			.toc > li li li li .secno    { margin-left: -6rem; }
			.toc > li li li li li .secno { margin-left: -7rem; }
		}
	/* } */

	@supports (display:grid) and (display:contents) {
		/* Use #toc over .toc to override non-@supports rules. */
		#toc {
			display: grid;
			align-content: start;
			grid-template-columns: auto 1fr;
			grid-column-gap: 1rem;
			column-gap: 1rem;
			grid-row-gap: .6rem;
			row-gap: .6rem;
		}
		#toc h2 {
			grid-column: 1 / -1;
			margin-bottom: 0;
		}
		#toc ol,
		#toc li,
		#toc a {
			display: contents;
			/* Switch <a> to subgrid when supported */
		}
		#toc span {
			margin: 0;
		}
		#toc > .toc > li > a > span {
			/* The spans of the top-level list,
			   comprising the first items of each top-level section. */
			margin-top: 1.1rem;
		}
		#toc#toc .secno { /* Ugh, need more specificity to override base.css */
			grid-column: 1;
			width: auto;
			margin-left: 0;
		}
		#toc .content {
			grid-column: 2;
			width: auto;
			margin-right: 1rem;
		}
		#toc .content:hover {
			background: rgba(75%, 75%, 75%, .25);
			border-bottom: 3px solid #054572;
			margin-bottom: -3px;
		}
		#toc li li li .content {
			margin-left: 1rem;
		}
		#toc li li li li .content {
			margin-left: 2rem;
		}
	}


/** Index *********************************************************************/

	/* Index Lists: Layout */
	ul.index       { margin-left: 0; columns: 15em; text-indent: 1em hanging; }
	ul.index li    { margin-left: 0; list-style: none; break-inside: avoid; }
	ul.index li li { margin-left: 1em }
	ul.index dl    { margin-top: 0; }
	ul.index dt    { margin: .2em 0 .2em 20px;}
	ul.index dd    { margin: .2em 0 .2em 40px;}
	/* Index Lists: Typography */
	ul.index ul,
	ul.index dl { font-size: smaller; }
	@media not print {
		ul.index li span {
			white-space: nowrap;
			color: transparent; }
		ul.index li a:hover + span,
		ul.index li a:focus + span {
			color: #707070;
		}
	}

/** Index Tables *****************************************************/
	/* See also the data table styling section, which this effectively subclasses */

	table.index {
		font-size: small;
		border-collapse: collapse;
		border-spacing: 0;
		text-align: left;
		margin: 1em 0;
	}

	table.index td,
	table.index th {
		padding: 0.4em;
	}

	table.index tr:hover td:not([rowspan]),
	table.index tr:hover th:not([rowspan]) {
		background: #f7f8f9;
	}

	/* The link in the first column in the property table (formerly a TD) */
	table.index th:first-child a {
		font-weight: bold;
	}

/******************************************************************************/
/*                                    Print                                   */
/******************************************************************************/

	@media print {
		/* Pages have their own margins. */
		html {
			margin: 0;
		}
		/* Serif for print. */
		body {
			font-family: serif;
		}
	}
	@page {
		margin: 1.5cm 1.1cm;
	}

/******************************************************************************/
/*                                    Legacy                                  */
/******************************************************************************/

	/* This rule is inherited from past style sheets. No idea what it's for. */
	.hide { display: none }



/******************************************************************************/
/*                             Overflow Control                               */
/******************************************************************************/

	.figure .caption, .sidefigure .caption, figcaption {
		/* in case figure is overlarge, limit caption to 50em */
		max-width: 50rem;
		margin-left: auto;
		margin-right: auto;
	}
	.overlarge > table {
		/* limit preferred width of table */
		max-width: 50em;
		margin-left: auto;
		margin-right: auto;
	}

	@media (min-width: 55em) {
		.overlarge {
			margin-left: calc(13px + 26.5rem - 50vw);
			margin-right: calc(13px + 26.5rem - 50vw);
			max-width: none;
		}
	}
	@media screen and (min-width: 78em) {
		body:not(.toc-inline) .overlarge {
			/* 30.5em body padding 50em content area */
			margin-left: calc(40em - 50vw) !important;
			margin-right: calc(40em - 50vw) !important;
		}
	}
	@media screen and (min-width: 90em) {
		body:not(.toc-inline) .overlarge {
			/* 4em html margin 30.5em body padding 50em content area */
			margin-left: 0 !important;
			margin-right: calc(84.5em - 100vw) !important;
		}
	}

	@media not print {
		.overlarge {
			overflow-x: auto;
			/* See Lea Verou's explanation background-attachment:
			 * http://lea.verou.me/2012/04/background-attachment-local/
			 *
			background: top left  / 4em 100% linear-gradient(to right,  #ffffff, rgba(255, 255, 255, 0)) local,
			            top right / 4em 100% linear-gradient(to left, #ffffff, rgba(255, 255, 255, 0)) local,
			            top left  / 1em 100% linear-gradient(to right,  #c3c3c5, rgba(195, 195, 197, 0)) scroll,
			            top right / 1em 100% linear-gradient(to left, #c3c3c5, rgba(195, 195, 197, 0)) scroll,
			            white;
			background-repeat: no-repeat;
			*/
		}
	}
</style>
<style type="text/css">
    table, th, td {
      border: 1px solid black;
      border-collapse: collapse;
      vertical-align: top;
    }
    th, td {
      border-left: none;
      border-right: none;
      padding: 0px 10px;
    }
    th {
      text-align: center;
    }

    del { background: #fcc; color: #000; text-decoration: line-through; }
    ins { background: #cfc; color: #000; }
    blockquote .highlight:not(.idl) { background: initial; margin: initial; padding: 0.5em }
    blockquote ul { background: inherit; }
    blockquote code.highlight:not(.idl) { padding: initial; }
    blockquote c-[a] { color: inherit; } /* Keyword.Declaration */
    blockquote c-[b] { color: inherit; } /* Keyword.Type */
    blockquote c-[c] { color: inherit; } /* Comment */
    blockquote c-[d] { color: inherit; } /* Comment.Multiline */
    blockquote c-[e] { color: inherit; } /* Name.Attribute */
    blockquote c-[f] { color: inherit; } /* Name.Tag */
    blockquote c-[g] { color: inherit; } /* Name.Variable */
    blockquote c-[k] { color: inherit; } /* Keyword */
    blockquote c-[l] { color: inherit; } /* Literal */
    blockquote c-[m] { color: inherit; } /* Literal.Number */
    blockquote c-[n] { color: inherit; } /* Name */
    blockquote c-[o] { color: inherit; } /* Operator */
    blockquote c-[p] { color: inherit; } /* Punctuation */
    blockquote c-[s] { color: inherit; } /* Literal.String */
    blockquote c-[t] { color: inherit; } /* Literal.String.Single */
    blockquote c-[u] { color: inherit; } /* Literal.String.Double */
    blockquote c-[cp] { color: inherit; } /* Comment.Preproc */
    blockquote c-[c1] { color: inherit; } /* Comment.Single */
    blockquote c-[cs] { color: inherit; } /* Comment.Special */
    blockquote c-[kc] { color: inherit; } /* Keyword.Constant */
    blockquote c-[kn] { color: inherit; } /* Keyword.Namespace */
    blockquote c-[kp] { color: inherit; } /* Keyword.Pseudo */
    blockquote c-[kr] { color: inherit; } /* Keyword.Reserved */
    blockquote c-[ld] { color: inherit; } /* Literal.Date */
    blockquote c-[nc] { color: inherit; } /* Name.Class */
    blockquote c-[no] { color: inherit; } /* Name.Constant */
    blockquote c-[nd] { color: inherit; } /* Name.Decorator */
    blockquote c-[ni] { color: inherit; } /* Name.Entity */
    blockquote c-[ne] { color: inherit; } /* Name.Exception */
    blockquote c-[nf] { color: inherit; } /* Name.Function */
    blockquote c-[nl] { color: inherit; } /* Name.Label */
    blockquote c-[nn] { color: inherit; } /* Name.Namespace */
    blockquote c-[py] { color: inherit; } /* Name.Property */
    blockquote c-[ow] { color: inherit; } /* Operator.Word */
    blockquote c-[mb] { color: inherit; } /* Literal.Number.Bin */
    blockquote c-[mf] { color: inherit; } /* Literal.Number.Float */
    blockquote c-[mh] { color: inherit; } /* Literal.Number.Hex */
    blockquote c-[mi] { color: inherit; } /* Literal.Number.Integer */
    blockquote c-[mo] { color: inherit; } /* Literal.Number.Oct */
    blockquote c-[sb] { color: inherit; } /* Literal.String.Backtick */
    blockquote c-[sc] { color: inherit; } /* Literal.String.Char */
    blockquote c-[sd] { color: inherit; } /* Literal.String.Doc */
    blockquote c-[se] { color: inherit; } /* Literal.String.Escape */
    blockquote c-[sh] { color: inherit; } /* Literal.String.Heredoc */
    blockquote c-[si] { color: inherit; } /* Literal.String.Interpol */
    blockquote c-[sx] { color: inherit; } /* Literal.String.Other */
    blockquote c-[sr] { color: inherit; } /* Literal.String.Regex */
    blockquote c-[ss] { color: inherit; } /* Literal.String.Symbol */
    blockquote c-[vc] { color: inherit; } /* Name.Variable.Class */
    blockquote c-[vg] { color: inherit; } /* Name.Variable.Global */
    blockquote c-[vi] { color: inherit; } /* Name.Variable.Instance */
    blockquote c-[il] { color: inherit; } /* Literal.Number.Integer.Long */
  </style>
  <meta content="Bikeshed version 9c51ae462b4b8b2f14dbddcd7d4b5224375eccc0" name="generator">
  <link href="https://wg21.link/P1135R5" rel="canonical">
  <link href="https://isocpp.org/favicon.ico" rel="icon">
<style>
pre {
  margin-top: 0px;
  margin-bottom: 0px;
}
.ins, ins, ins *, span.ins, span.ins * {
  background-color: rgb(200, 250, 200);
  color: rgb(0, 136, 0);
  text-decoration: none;
}
.del, del, del *, span.del, span.del * {
  background-color: rgb(250, 200, 200);
  color: rgb(255, 0, 0);
  text-decoration: line-through;
  text-decoration-color: rgb(255, 0, 0);
}
math, span.math {
  font-family: serif;
  font-style: italic;
}
ul {
  list-style-type: "— ";
}
blockquote {
  counter-reset: paragraph;
}
div.numbered, div.newnumbered {
  margin-left: 2em;
  margin-top: 1em;
  margin-bottom: 1em;
}
div.numbered:before, div.newnumbered:before {
  position: absolute;
  margin-left: -2em;
  display-style: block;
}
div.numbered:before {
  content: counter(paragraph);
  counter-increment: paragraph;
}
div.newnumbered:before {
  content: "�";
}
div.numbered ul, div.newnumbered ul {
  counter-reset: list_item;
}
div.numbered li, div.newnumbered li {
  margin-left: 3em;
}
div.numbered li:before, div.newnumbered li:before {
  position: absolute;
  margin-left: -4.8em;
  display-style: block;
}
div.numbered li:before {
  content: "(" counter(paragraph) "." counter(list_item) ")";
  counter-increment: list_item;
}
div.newnumbered li:before {
  content: "(�." counter(list_item) ")";
  counter-increment: list_item;
}
</style>
<style>/* style-md-lists */

/* This is a weird hack for me not yet following the commonmark spec
   regarding paragraph and lists. */
[data-md] > :first-child {
    margin-top: 0;
}
[data-md] > :last-child {
    margin-bottom: 0;
}</style>
<style>/* style-counters */

body {
    counter-reset: example figure issue;
}
.issue {
    counter-increment: issue;
}
.issue:not(.no-marker)::before {
    content: "Issue " counter(issue);
}

.example {
    counter-increment: example;
}
.example:not(.no-marker)::before {
    content: "Example " counter(example);
}
.invalid.example:not(.no-marker)::before,
.illegal.example:not(.no-marker)::before {
    content: "Invalid Example" counter(example);
}

figcaption {
    counter-increment: figure;
}
figcaption:not(.no-marker)::before {
    content: "Figure " counter(figure) " ";
}</style>
<style>/* style-selflinks */

.heading, .issue, .note, .example, li, dt {
    position: relative;
}
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;
}
a.self-link:hover {
    opacity: 1;
}
.heading > a.self-link {
    font-size: 83%;
}
li > a.self-link {
    left: calc(-1 * (3.5rem - 26px) - 2em);
}
dfn > a.self-link {
    top: auto;
    left: auto;
    opacity: 0;
    width: 1.5em;
    height: 1.5em;
    background: gray;
    color: white;
    font-style: normal;
    transition: opacity .2s, background-color .2s, color .2s;
}
dfn:hover > a.self-link {
    opacity: 1;
}
dfn > a.self-link:hover {
    color: black;
}

a.self-link::before            { content: "¶"; }
.heading > a.self-link::before { content: "§"; }
dfn > a.self-link::before      { content: "#"; }</style>
<style>/* style-autolinks */

.css.css, .property.property, .descriptor.descriptor {
    color: #005a9c;
    font-size: inherit;
    font-family: inherit;
}
.css::before, .property::before, .descriptor::before {
    content: "‘";
}
.css::after, .property::after, .descriptor::after {
    content: "’";
}
.property, .descriptor {
    /* Don't wrap property and descriptor names */
    white-space: nowrap;
}
.type { /* CSS value <type> */
    font-style: italic;
}
pre .property::before, pre .property::after {
    content: "";
}
[data-link-type="property"]::before,
[data-link-type="propdesc"]::before,
[data-link-type="descriptor"]::before,
[data-link-type="value"]::before,
[data-link-type="function"]::before,
[data-link-type="at-rule"]::before,
[data-link-type="selector"]::before,
[data-link-type="maybe"]::before {
    content: "‘";
}
[data-link-type="property"]::after,
[data-link-type="propdesc"]::after,
[data-link-type="descriptor"]::after,
[data-link-type="value"]::after,
[data-link-type="function"]::after,
[data-link-type="at-rule"]::after,
[data-link-type="selector"]::after,
[data-link-type="maybe"]::after {
    content: "’";
}

[data-link-type].production::before,
[data-link-type].production::after,
.prod [data-link-type]::before,
.prod [data-link-type]::after {
    content: "";
}

[data-link-type=element],
[data-link-type=element-attr] {
    font-family: Menlo, Consolas, "DejaVu Sans Mono", monospace;
    font-size: .9em;
}
[data-link-type=element]::before { content: "<" }
[data-link-type=element]::after  { content: ">" }

[data-link-type=biblio] {
    white-space: pre;
}</style>
 <body class="h-entry">
  <div class="head">
   <p data-fill-with="logo"></p>
   <h1 class="p-name no-ref" id="title">P1135R6<br>The C++20 Synchronization Library</h1>
   <h2 class="no-num no-toc no-ref heading settled" id="subtitle"><span class="content">Published Proposal, <time class="dt-updated" datetime="2019-07-19">2019-07-19</time></span></h2>
   <div data-fill-with="spec-metadata">
    <dl>
     <dt>Authors:
     <dd>
      <dd class="editor p-author h-card vcard"><a class="p-name fn u-email email" href="mailto:brycelelbach@gmail.com">Bryce Adelstein Lelbach</a> (<span class="p-org org">NVIDIA</span>)
     <dd>
      <dd class="editor p-author h-card vcard"><a class="p-name fn u-email email" href="mailto:ogiroux@nvidia.com">Olivier Giroux</a> (<span class="p-org org">NVIDIA</span>)
     <dd>
      <dd class="editor p-author h-card vcard"><a class="p-name fn u-email email" href="mailto:jfbastien@apple.com">JF Bastien</a> (<span class="p-org org">Apple</span>)
     <dd>
      <dd class="editor p-author h-card vcard"><a class="p-name fn u-email email" href="mailto:dv@vollmann.ch">Detlef Vollmann</a>
     <dd>
      <dd class="editor p-author h-card vcard"><a class="p-name fn u-email email" href="mailto:dolsen@nvidia.com">David Olsen</a> (<span class="p-org org">NVIDIA</span>)
     <dt>Source:
     <dd><a href="https://github.com/brycelelbach/wg21_p1135_cpp20_synchronization_library/blob/master/cpp20_synchronization_library.bs">GitHub</a>
     <dt>Issue Tracking:
     <dd><a href="https://github.com/brycelelbach/wg21_p1135_cpp20_synchronization_library/issues">GitHub</a>
     <dt>Project:
     <dd>ISO/IEC JTC1/SC22/WG21 14882: Programming Language — C++
     <dt>Audience:
     <dd>LWG
    </dl>
   </div>
   <div data-fill-with="warning"></div>
   <hr title="Separator for header">
  </div>
  <nav data-fill-with="table-of-contents" id="toc">
   <h2 class="no-num no-toc no-ref" id="contents">Table of Contents</h2>
   <ol class="toc" role="directory">
    <li><a href="#intro"><span class="secno">1</span> <span class="content">Introduction</span></a>
    <li><a href="#changelog"><span class="secno">2</span> <span class="content">Changelog</span></a>
    <li><a href="#wording"><span class="secno">3</span> <span class="content">Wording</span></a>
    <li>
     <a href="#index"><span class="secno"></span> <span class="content">Index</span></a>
     <ol class="toc">
      <li><a href="#index-defined-here"><span class="secno"></span> <span class="content">Terms defined by this specification</span></a>
     </ol>
    <li>
     <a href="#references"><span class="secno"></span> <span class="content">References</span></a>
     <ol class="toc">
      <li><a href="#informative"><span class="secno"></span> <span class="content">Informative References</span></a>
     </ol>
   </ol>
  </nav>
  <main>
   <h2 class="heading settled" data-level="1" id="intro"><span class="secno">1. </span><span class="content">Introduction</span><a class="self-link" href="#intro"></a></h2>
   <p>This paper is the unification of a series of related C++20 proposals for
introducing new synchronization and thread coordination facilities and
enhancing existing ones:</p>
   <ul>
    <li data-md>
     <p><a data-link-type="biblio" href="#biblio-p0514r4">[P0514R4]</a>: Efficient <code class="highlight"><c- n>atomic</c-></code> waiting and semaphores.</p>
    <li data-md>
     <p><a data-link-type="biblio" href="#biblio-p0666r2">[P0666R2]</a>: Latches and barriers.</p>
    <li data-md>
     <p><a data-link-type="biblio" href="#biblio-p0995r1">[P0995R1]</a>: <code class="highlight"><c- n>atomic_flag</c-><c- o>::</c-><c- n>test</c-></code> and lockfree integral types.</p>
    <li data-md>
     <p><a data-link-type="biblio" href="#biblio-p1258r0">[P1258R0]</a>: Don’t make C++ unimplementable for small CPUs.</p>
   </ul>
   <p>The first part of this paper adds member functions <code class="highlight"><c- n>wait</c-></code>, <code class="highlight"><c- n>notify_one</c-></code>,
and <code class="highlight"><c- n>notify_all</c-></code> to <code class="highlight"><c- n>atomic</c-><c- o>&lt;</c-><c- n>T</c-><c- o>></c-></code>.  It does not add those same member
functions to <code class="highlight"><c- n>atomic_ref</c-><c- o>&lt;</c-><c- n>T</c-><c- o>></c-></code>, <code class="highlight"><c- n>atomic</c-><c- o>&lt;</c-><c- n>shared_ptr</c-><c- o>&lt;</c-><c- n>T</c-><c- o>>></c-></code>, or <code class="highlight"><c- n>atomic</c-><c- o>&lt;</c-><c- n>weak_ptr</c-><c- o>&lt;</c-><c- n>T</c-><c- o>>></c-></code>.  Those omissions were partly an oversight, because
the papers for those types were in flight at the same time as this paper.
Adding <code class="highlight"><c- n>wait</c-></code>, <code class="highlight"><c- n>notify_one</c-></code>, and <code class="highlight"><c- n>notify_all</c-></code> to the other types are not
being added to this paper, but will be done separately in <a href="https://wg21.link/P1643">[P1643R0]</a> and <a href="https://wg21.link/P1644">[P1644R0]</a>.</p>
   <h2 class="heading settled" data-level="2" id="changelog"><span class="secno">2. </span><span class="content">Changelog</span><a class="self-link" href="#changelog"></a></h2>
   <p><strong>Revision 0:</strong> Post Rapperswil 2018 changes from <a data-link-type="biblio" href="#biblio-p0514r4">[P0514R4]</a>, <a data-link-type="biblio" href="#biblio-p0666r2">[P0666R2]</a>, and <a data-link-type="biblio" href="#biblio-p0995r1">[P0995R1]</a> based on <a href="http://wiki.edg.com/bin/view/Wg21rapperswil2018/P0666">Rapperswil 2018 LEWG feedback</a>.</p>
   <ul>
    <li data-md>
     <p>Refactored <code class="highlight"><c- n>basic_barrier</c-></code> and <code class="highlight"><c- n>barrier</c-></code> into one class with a default template parameter as suggested by LEWG at Rapperswil 2018.</p>
    <li data-md>
     <p>Refactored <code class="highlight"><c- n>basic_semaphore</c-></code> and <code class="highlight"><c- n>counting_semaphore</c-></code> into one class with a default template parameter as suggested by LEWG at Rapperswil 2018.</p>
    <li data-md>
     <p>Fixed <code class="highlight"><c- n>update</c-></code> parameters in semaphore, latch, and barrier member functions to consistently default to 1 to resolve mistakes identified by LEWG at Rapperswil 2018.</p>
   </ul>
   <p><strong>Revision 1:</strong> Pre San Diego 2018 changes based on <a href="http://wiki.edg.com/bin/view/Wg21rapperswil2018/P0666">Rapperswil 2018 LEWG feedback</a> and <a href="http://lists.isocpp.org/lib-ext/2018/06/7755.php">a June discussion on the LEWG and SG1 mailing lists</a>.</p>
   <ul>
    <li data-md>
     <p>Added member function versions of <code class="highlight"><c- n>atomic_wait_</c-><c- o>*</c-></code> and <code class="highlight"><c- n>atomic_notify_</c-><c- o>*</c-></code>, for consistency. Refactored wording to accommodate this.</p>
    <li data-md>
     <p>Renamed the <code class="highlight"><c- n>atomic_flag</c-></code> overloads of <code class="highlight"><c- n>atomic_wait</c-></code> and <code class="highlight"><c- n>atomic_wait_explicit</c-></code> to <code class="highlight"><c- n>atomic_flag_wait</c-></code> and <code class="highlight"><c- n>atomic_flag_wait_explicit</c-></code> for consistency and to leave the door open for future compatibility with C.</p>
    <li data-md>
     <p>Renamed <code class="highlight"><c- n>latch</c-><c- o>::</c-><c- n>arrive_and_wait</c-></code> and <code class="highlight"><c- n>barrier</c-><c- o>::</c-><c- n>arrive_and_wait</c-></code> to <code class="highlight"><c- n>latch</c-><c- o>::</c-><c- n>sync</c-></code> and <code class="highlight"><c- n>barrier</c-><c- o>::</c-><c- n>sync</c-></code>, because LEWG at Rapperswil 2018 expected these methods to be the common use case and prefers they have a short name.</p>
    <li data-md>
     <p>Renamed <code class="highlight"><c- n>latch</c-><c- o>::</c-><c- n>arrive</c-></code> to <code class="highlight"><c- n>latch</c-><c- o>::</c-><c- n>count_down</c-></code> to further separate and distinguish the <code class="highlight"><c- n>latch</c-></code> and <code class="highlight"><c- n>barrier</c-></code> interfaces.</p>
    <li data-md>
     <p>Removed <code class="highlight"><c- n>barrier</c-><c- o>::</c-><c- n>try_wait</c-></code> to resolve concerns raised during LEWG discussion at Rapperswil 2018 regarding its "maybe consuming" nature.</p>
    <li data-md>
     <p>Required that <code class="highlight"><c- n>barrier</c-><c- o>::</c-><c- n>arrival_token</c-></code>'s move constructor and move assignment operators are <code class="highlight"><c- k>noexcept</c-></code> to resolve discussions in LEWG at Rapperswil 2018 regarding exceptions being thrown when using the split arrive and wait barrier interface.</p>
    <li data-md>
     <p>Made <code class="highlight"><c- n>counting_semaphore</c-><c- o>::</c-><c- n>acquire</c-></code>, <code class="highlight"><c- n>counting_semaphore</c-><c- o>::</c-><c- n>try_acquire</c-></code>, and <code class="highlight"><c- n>latch</c-><c- o>::</c-><c- n>wait</c-></code> <code class="highlight"><c- k>noexcept</c-></code>, because participants in the mailing list discussion preferred that synchronization operations not throw and that any resource acquisition failures be reported by throwing during construction of synchronization objects.</p>
    <li data-md>
     <p>Made <code class="highlight"><c- n>counting_semaphore</c-></code>, <code class="highlight"><c- n>latch</c-></code>, and <code class="highlight"><c- n>barrier</c-></code>'s constructors non <code class="highlight"><c- k>constexpr</c-></code> and allowed them to throw <code class="highlight"><c- n>system_error</c-></code> if the object cannot be created, because participants in the mailing list discussion preferred that synchronization operations not throw and that any resource acquisition failures be reported by throwing during construction of synchronization objects.</p>
    <li data-md>
     <p>Clarified that <code class="highlight"><c- n>counting_semaphore</c-><c- o>::</c-><c- n>release</c-></code>, <code class="highlight"><c- n>latch</c-><c- o>::</c-><c- n>count_down</c-></code>, <code class="highlight"><c- n>latch</c-><c- o>::</c-><c- n>sync</c-></code>, <code class="highlight"><c- n>barrier</c-><c- o>::</c-><c- n>wait</c-></code>, <code class="highlight"><c- n>barrier</c-><c- o>::</c-><c- n>sync</c-></code>, and <code class="highlight"><c- n>barrier</c-><c- o>::</c-><c- n>arrive_and_drop</c-></code> throw nothing (but cannot be <code class="highlight"><c- k>noexcept</c-></code>, because they have preconditions) to resolve discussions in LEWG at Rapperswil 2018 and on the mailing list.</p>
   </ul>
   <p><strong>Revision 2:</strong> San Diego 2018 changes to incorporate <a data-link-type="biblio" href="#biblio-p1258r0">[P1258R0]</a> and pre-meeting feedback.</p>
   <ul>
    <li data-md>
     <p>Made <code class="highlight"><c- n>barrier</c-><c- o>::</c-><c- n>wait</c-></code> take its <code class="highlight"><c- n>arrival_token</c-></code> parameter by rvalue reference.</p>
    <li data-md>
     <p>Made the <code class="highlight"><c- n>atomic_signed_lock_free</c-></code> and <code class="highlight"><c- n>atomic_unsigned_lock_free</c-></code> types optional for freestanding implementations, as per <a data-link-type="biblio" href="#biblio-p1258r0">[P1258R0]</a>.</p>
   </ul>
   <p><strong>Revision 3:</strong> Pre Kona 2019 changes based on <a href="http://wiki.edg.com/bin/view/Wg21sandiego2018/P1135">San Diego 2018 LEWG feedback</a>.</p>
   <ul>
    <li data-md>
     <p>Renamed <code class="highlight"><c- n>latch</c-><c- o>::</c-><c- n>sync</c-></code> and <code class="highlight"><c- n>barrier</c-><c- o>::</c-><c- n>sync</c-></code> back to <code class="highlight"><c- n>latch</c-><c- o>::</c-><c- n>arrive_and_wait</c-></code> and <code class="highlight"><c- n>barrier</c-><c- o>::</c-><c- n>arrive_and_wait</c-></code>, because this name had the strongest consensus in LEWG at San Diego 2018.</p>
    <li data-md>
     <p>Removed <code class="highlight"><c- n>atomic_int_fast_wait_t</c-></code> and <code class="highlight"><c- n>atomic_uint_fast_wait_t</c-></code>, because LEWG at San Diego 2018 felt that the use case was uncommon and the types had high potential for misuse.</p>
    <li data-md>
     <p>Made <code class="highlight"><c- n>counting_semaphore</c-><c- o>::</c-><c- n>acquire</c-></code> and <code class="highlight"><c- n>latch</c-><c- o>::</c-><c- n>wait</c-></code> non <code class="highlight"><c- k>noexcept</c-></code> again, because LEWG at San Diego 2018 desired <code class="highlight"><c- k>constexpr</c-></code> constructors for new synchronization objects to allow synchronization during program initialization and to maintain consistency with existing synchronization objects like <code class="highlight"><c- n>mutex</c-></code>.</p>
    <li data-md>
     <p>Made <code class="highlight"><c- n>counting_semaphore</c-></code>, <code class="highlight"><c- n>latch</c-></code>, and <code class="highlight"><c- n>barrier</c-></code>'s constructors <code class="highlight"><c- k>constexpr</c-></code> again, because LEWG at San Diego 2018 desired <code class="highlight"><c- k>constexpr</c-></code> constructors for new synchronization objects to allow synchronization during program initialization and to maintain consistency with existing synchronization objects like <code class="highlight"><c- n>mutex</c-></code>.</p>
    <li data-md>
     <p>Clarified that <code class="highlight"><c- n>counting_semaphore</c-><c- o>::</c-><c- n>release</c-></code>, <code class="highlight"><c- n>latch</c-><c- o>::</c-><c- n>count_down</c-></code>, <code class="highlight"><c- n>latch</c-><c- o>::</c-><c- n>arrive_and_wait</c-></code>, <code class="highlight"><c- n>barrier</c-><c- o>::</c-><c- n>wait</c-></code>, <code class="highlight"><c- n>barrier</c-><c- o>::</c-><c- n>arrive_and_wait</c-></code>, and <code class="highlight"><c- n>barrier</c-><c- o>::</c-><c- n>arrive_and_drop</c-></code> may throw <code class="highlight"><c- n>system_error</c-></code> exceptions, which is an implication of the constructors of said objects being <code class="highlight"><c- k>constexpr</c-></code> because any underlying system errors must be reported on operations not during construction.</p>
    <li data-md>
     <p>Added missing <code class="highlight"><c- n>atomic</c-><c- o>&lt;</c-><c- n>T</c-><c- o>>::</c-><c- n>wait</c-></code> and <code class="highlight"><c- n>atomic</c-><c- o>&lt;</c-><c- n>T</c-><c- o>>::</c-><c- n>notify_</c-><c- o>*</c-></code> member functions to the class synopses for the <code class="highlight"><c- n>atomic</c-><c- o>&lt;</c-><c- n>T</c-><c- o>></c-></code> integral, floating-point, and pointer specializations.</p>
    <li data-md>
     <p>Fixed <code class="highlight"><c- n>atomic</c-><c- o>&lt;</c-><c- n>T</c-><c- o>>::</c-><c- n>notify_</c-><c- o>*</c-></code> member functions to be non <code class="highlight"><c- k>const</c-></code>.</p>
   </ul>
   <p><strong>Revision 4:</strong> Lots of wording changes based on <a href="http://wiki.edg.com/bin/view/Wg21kona2019/LWG1135Notes">Kona 2019 LWG feedback</a>.  Three design changes to fix bugs that were discovered during LWG review or afterwards while revising the paper.  These will be presented to SG1 in a separate paper, <a data-link-type="biblio" href="#biblio-p1633r0">[P1633R0]</a>, in Cologne.</p>
   <ul>
    <li data-md>
     <p>Changed <code class="highlight"><c- n>atomic_flag</c-><c- o>::</c-><c- n>test</c-></code> to be a <code class="highlight"><c- k>const</c-></code> function.  Changed the <code class="highlight"><c- n>atomic_flag</c-><c- o>*</c-></code> parameter of <code class="highlight"><c- n>atomic_flag_test</c-></code> and <code class="highlight"><c- n>atomic_flag_test_explicit</c-></code> to be <code class="highlight"><c- k>const</c-> <c- n>atomic_flag</c-><c- o>*</c-></code>.</p>
    <li data-md>
     <p>Added the requirement that the <code class="highlight"><c- n>least_max_value</c-></code> template parameter to <code class="highlight"><c- n>counting_semaphore</c-></code> be greater than zero.</p>
    <li data-md>
     <p>Changed the requirement on the <code class="highlight"><c- n>update</c-></code> parameter to <code class="highlight"><c- n>barrier</c-><c- o>::</c-><c- n>arrive</c-></code> from <code class="highlight"><c- n>update</c-> <c- o>>=</c-> <c- mi>0</c-></code> to <code class="highlight"><c- n>update</c-> <c- o>></c-> <c- mi>0</c-></code>.</p>
   </ul>
   <p><strong>Revision 5:</strong> Some wording improvements after the post-Kona mailing
and before the pre-Cologne mailing.
Incorporated feedback from LWG teleconferences on <a href="http://wiki.edg.com/bin/view/Wg21cologne2019/LWGTelecom7June">7 June</a> and <a href="http://wiki.edg.com/bin/view/Wg21cologne2019/LWGTelecom14June">14 June</a>.
Rebased the wording to be relative to the post-Kona draft, <a data-link-type="biblio" href="#biblio-n4810">[N4810]</a>.
There is one design change, which will be included in <a href="https://wg21.link/P1633R0">[P1633R0]</a> along with the three changes in R4:</p>
   <ul>
    <li data-md>
     <p>Allow <code class="highlight"><c- n>latch</c-><c- o>::</c-><c- n>try_wait</c-></code> to spuriously return <code class="highlight">false</code>.</p>
   </ul>
   <p><strong>Revision 6:</strong> Removed the wording for the destructors of <code class="highlight"><c- n>counting_semaphore</c-></code>, <code class="highlight"><c- n>latch</c-></code>, and <code class="highlight"><c- n>barrier</c-></code> that allowed the destructor to be called when some member functions in other threads had not yet returned.  This design change has been added to <span>[P1633R1]</span>.  Based on SG1’s discussion of <span>[P1633R1]</span>, the restriction on the template parameter of <code class="highlight"><c- n>counting_semaphore</c-></code> was changed from <code class="highlight"><c- o>></c-> <c- mi>0</c-></code> to <code class="highlight"><c- o>>=</c-> <c- mi>0</c-></code>.  Several small wording improvements based on <a href="http://wiki.edg.com/bin/view/Wg21cologne2019/LWG1135Notes">LWG feedback</a> in Cologne.</p>
   <h2 class="heading settled" data-level="3" id="wording"><span class="secno">3. </span><span class="content">Wording</span><a class="self-link" href="#wording"></a></h2>
   <p class="note" role="note"><span>Note:</span> The following changes are relative to the post Kona 2019 working draft of ISO/IEC 14882, (<a data-link-type="biblio" href="#biblio-n4810">[N4810]</a>).</p>
   <p class="note" role="note"><span>Note:</span> The � character is used to denote a placeholder number which shall be selected by the editor.</p>
   <p>Add <code class="highlight"><c- o>&lt;</c-><c- n>semaphore</c-><c- o>></c-></code>, <code class="highlight"><c- o>&lt;</c-><c- n>latch</c-><c- o>></c-></code>, and <code class="highlight"><c- o>&lt;</c-><c- n>barrier</c-><c- o>></c-></code> to <a href="http://eel.is/c++draft/headers#tab:headers.cpp">Table 19</a> "C++ library headers" in <a href="http://eel.is/c++draft/headers">[<strong>headers</strong>]</a>.</p>
   <p>Modify paragraph 3 in <a href="http://eel.is/c++draft/compliance">16.5.1.3
[<strong>compliance</strong>]</a> as follows:</p>
   <blockquote>
    <div>
      The supplied version of the header <code class="highlight"><c- o>&lt;</c-><c- n>cstdlib</c-><c- o>></c-></code> shall declare at least the functions <code class="highlight"><c- n>abort</c-></code>, <code class="highlight"><c- n>atexit</c-></code>, <code class="highlight"><c- n>at_quick_exit</c-></code>, <code class="highlight"><c- n>exit</c-></code>, and <code class="highlight"><c- n>quick_exit</c-></code> (<a href="http://eel.is/c++draft/support.start.term">17.5</a>). 
     <ins>The supplied version of the header <code class="highlight"><c- o>&lt;</c-><c- n>atomic</c-><c- o>></c-></code> shall meet the same requirements as for a hosted implementation except that support for always lock-free integral atomic types (<a href="http://eel.is/c++draft/atomics.lockfree">[<strong>atomics.lockfree</strong>]</a>) is implementation-defined, and whether or not the type aliases <code class="highlight"><c- n>atomic_signed_lock_free</c-></code> and <code class="highlight"><c- n>atomic_unsigned_lock_free</c-></code> are defined (<a href="http://eel.is/c++draft/atomics.alias">[<strong>atomics.alias</strong>]</a>) is implementation-defined.</ins>
      The other headers listed in this table shall meet the same requirements as for a hosted implementation. 
    </div>
   </blockquote>
   <p>Modify the header synopsis for <code class="highlight"><c- o>&lt;</c-><c- n>atomic</c-><c- o>></c-></code> in <a href="http://eel.is/c++draft/atomics.syn">[<strong>atomics.syn</strong>]</a> as follows:</p>
   <blockquote>
     <b>31.2 Header <code class="highlight"><c- o>&lt;</c-><c- n>atomic</c-><c- o>></c-></code> synopsis <span style="float: right;">[atomics.syn]</span></b> 
<pre class="highlight"><code class="highlight"><c- k><c- k>namespace</c-></c-> <c- n><c- n>std</c-></c-> <c- p><c- p>{</c-></c->
  <i><c- c1><c- c1>// ...</c-></c-></i>
  
  <i><c- c1><c- c1>// 31.8, non-member functions</c-></c-></i>
  <i><c- c1><c- c1>// ...</c-></c-></i>

<div class="ins">  <c- k><c- k>template</c-></c-><c- o><c- o>&lt;</c-></c-><c- k><c- k>class</c-></c-> <c- nc><c- nc>T</c-></c-><c- o><c- o>></c-></c->
    <c- b><c- b>void</c-></c-> <c- n><c- n>atomic_wait</c-></c-><c- p><c- p>(</c-></c-><c- k><c- k>const</c-></c-> <c- k><c- k>volatile</c-></c-> <c- n><c- n>atomic</c-></c-><c- o><c- o>&lt;</c-></c-><c- n><c- n>T</c-></c-><c- o><c- o>>*</c-></c-><c- p><c- p>,</c-></c->
                     <c- k><c- k>typename</c-></c-> <c- n><c- n>atomic</c-></c-><c- o><c- o>&lt;</c-></c-><c- n><c- n>T</c-></c-><c- o><c- o>>::</c-></c-><c- n><c- n>value_type</c-></c-><c- p><c- p>);</c-></c->
  <c- k><c- k>template</c-></c-><c- o><c- o>&lt;</c-></c-><c- k><c- k>class</c-></c-> <c- nc><c- nc>T</c-></c-><c- o><c- o>></c-></c->
    <c- b><c- b>void</c-></c-> <c- n><c- n>atomic_wait</c-></c-><c- p><c- p>(</c-></c-><c- k><c- k>const</c-></c-> <c- n><c- n>atomic</c-></c-><c- o><c- o>&lt;</c-></c-><c- n><c- n>T</c-></c-><c- o><c- o>>*</c-></c-><c- p><c- p>,</c-></c->
                     <c- k><c- k>typename</c-></c-> <c- n><c- n>atomic</c-></c-><c- o><c- o>&lt;</c-></c-><c- n><c- n>T</c-></c-><c- o><c- o>>::</c-></c-><c- n><c- n>value_type</c-></c-><c- p><c- p>);</c-></c->
  <c- k><c- k>template</c-></c-><c- o><c- o>&lt;</c-></c-><c- k><c- k>class</c-></c-> <c- nc><c- nc>T</c-></c-><c- o><c- o>></c-></c->
    <c- b><c- b>void</c-></c-> <c- n><c- n>atomic_wait_explicit</c-></c-><c- p><c- p>(</c-></c-><c- k><c- k>const</c-></c-> <c- k><c- k>volatile</c-></c-> <c- n><c- n>atomic</c-></c-><c- o><c- o>&lt;</c-></c-><c- n><c- n>T</c-></c-><c- o><c- o>>*</c-></c-><c- p><c- p>,</c-></c->
                              <c- k><c- k>typename</c-></c-> <c- n><c- n>atomic</c-></c-><c- o><c- o>&lt;</c-></c-><c- n><c- n>T</c-></c-><c- o><c- o>>::</c-></c-><c- n><c- n>value_type</c-></c-><c- p><c- p>,</c-></c->
                              <c- n><c- n>memory_order</c-></c-><c- p><c- p>);</c-></c->
  <c- k><c- k>template</c-></c-><c- o><c- o>&lt;</c-></c-><c- k><c- k>class</c-></c-> <c- nc><c- nc>T</c-></c-><c- o><c- o>></c-></c->
    <c- b><c- b>void</c-></c-> <c- n><c- n>atomic_wait_explicit</c-></c-><c- p><c- p>(</c-></c-><c- k><c- k>const</c-></c-> <c- n><c- n>atomic</c-></c-><c- o><c- o>&lt;</c-></c-><c- n><c- n>T</c-></c-><c- o><c- o>>*</c-></c-><c- p><c- p>,</c-></c->
                              <c- k><c- k>typename</c-></c-> <c- n><c- n>atomic</c-></c-><c- o><c- o>&lt;</c-></c-><c- n><c- n>T</c-></c-><c- o><c- o>>::</c-></c-><c- n><c- n>value_type</c-></c-><c- p><c- p>,</c-></c->
                              <c- n><c- n>memory_order</c-></c-><c- p><c- p>);</c-></c->
  <c- k><c- k>template</c-></c-><c- o><c- o>&lt;</c-></c-><c- k><c- k>class</c-></c-> <c- nc><c- nc>T</c-></c-><c- o><c- o>></c-></c->
    <c- b><c- b>void</c-></c-> <c- n><c- n>atomic_notify_one</c-></c-><c- p><c- p>(</c-></c-><c- k><c- k>volatile</c-></c-> <c- n><c- n>atomic</c-></c-><c- o><c- o>&lt;</c-></c-><c- n><c- n>T</c-></c-><c- o><c- o>>*</c-></c-><c- p><c- p>);</c-></c->
  <c- k><c- k>template</c-></c-><c- o><c- o>&lt;</c-></c-><c- k><c- k>class</c-></c-> <c- nc><c- nc>T</c-></c-><c- o><c- o>></c-></c->
    <c- b><c- b>void</c-></c-> <c- n><c- n>atomic_notify_one</c-></c-><c- p><c- p>(</c-></c-><c- n><c- n>atomic</c-></c-><c- o><c- o>&lt;</c-></c-><c- n><c- n>T</c-></c-><c- o><c- o>>*</c-></c-><c- p><c- p>);</c-></c->
  <c- k><c- k>template</c-></c-><c- o><c- o>&lt;</c-></c-><c- k><c- k>class</c-></c-> <c- nc><c- nc>T</c-></c-><c- o><c- o>></c-></c->
    <c- b><c- b>void</c-></c-> <c- n><c- n>atomic_notify_all</c-></c-><c- p><c- p>(</c-></c-><c- k><c- k>volatile</c-></c-> <c- n><c- n>atomic</c-></c-><c- o><c- o>&lt;</c-></c-><c- n><c- n>T</c-></c-><c- o><c- o>>*</c-></c-><c- p><c- p>);</c-></c->
  <c- k><c- k>template</c-></c-><c- o><c- o>&lt;</c-></c-><c- k><c- k>class</c-></c-> <c- nc><c- nc>T</c-></c-><c- o><c- o>></c-></c->
    <c- b><c- b>void</c-></c-> <c- n><c- n>atomic_notify_all</c-></c-><c- p><c- p>(</c-></c-><c- n><c- n>atomic</c-></c-><c- o><c- o>&lt;</c-></c-><c- n><c- n>T</c-></c-><c- o><c- o>>*</c-></c-><c- p><c- p>);</c-></c-></div>
  <i><c- c1><c- c1>// 31.3, type aliases</c-></c-></i>
  <i><c- c1><c- c1>// ...</c-></c-></i>
   
  <c- k><c- k>using</c-></c-> <c- n><c- n>atomic_intptr_t</c-></c->       <c- o><c- o>=</c-></c-> <c- n><c- n>atomic</c-></c-><c- o><c- o>&lt;</c-></c-><c- b><c- b>intptr_t</c-></c-><c- o><c- o>></c-></c-><c- p><c- p>;</c-></c->
  <c- k><c- k>using</c-></c-> <c- n><c- n>atomic_uintptr_t</c-></c->      <c- o><c- o>=</c-></c-> <c- n><c- n>atomic</c-></c-><c- o><c- o>&lt;</c-></c-><c- b><c- b>uintptr_t</c-></c-><c- o><c- o>></c-></c-><c- p><c- p>;</c-></c->
  <c- k><c- k>using</c-></c-> <c- n><c- n>atomic_size_t</c-></c->         <c- o><c- o>=</c-></c-> <c- n><c- n>atomic</c-></c-><c- o><c- o>&lt;</c-></c-><c- b><c- b>size_t</c-></c-><c- o><c- o>></c-></c-><c- p><c- p>;</c-></c->
  <c- k><c- k>using</c-></c-> <c- n><c- n>atomic_ptrdiff_t</c-></c->      <c- o><c- o>=</c-></c-> <c- n><c- n>atomic</c-></c-><c- o><c- o>&lt;</c-></c-><c- b><c- b>ptrdiff_t</c-></c-><c- o><c- o>></c-></c-><c- p><c- p>;</c-></c->
  <c- k><c- k>using</c-></c-> <c- n><c- n>atomic_intmax_t</c-></c->       <c- o><c- o>=</c-></c-> <c- n><c- n>atomic</c-></c-><c- o><c- o>&lt;</c-></c-><c- b><c- b>intmax_t</c-></c-><c- o><c- o>></c-></c-><c- p><c- p>;</c-></c->
  <c- k><c- k>using</c-></c-> <c- n><c- n>atomic_uintmax_t</c-></c->      <c- o><c- o>=</c-></c-> <c- n><c- n>atomic</c-></c-><c- o><c- o>&lt;</c-></c-><c- b><c- b>uintmax_t</c-></c-><c- o><c- o>></c-></c-><c- p><c- p>;</c-></c->
 
<div class="ins">  <c- k><c- k>using</c-></c-> <c- n><c- n>atomic_signed_lock_free</c-></c->   <c- o><c- o>=</c-></c-> <i><c- n><c- n>see</c-></c-> <c- n><c- n>below</c-></c-></i><c- p><c- p>;</c-></c->
  <c- k><c- k>using</c-></c-> <c- n><c- n>atomic_unsigned_lock_free</c-></c-> <c- o><c- o>=</c-></c-> <i><c- n><c- n>see</c-></c-> <c- n><c- n>below</c-></c-></i><c- p><c- p>;</c-></c-></div>
  <i><c- c1><c- c1>// 31.9, flag type and operations</c-></c-></i>
  <c- k><c- k>struct</c-></c-> <c- n><c- n>atomic_flag</c-></c-><c- p><c- p>;</c-></c->

<div class="ins">  <c- b><c- b>bool</c-></c-> <c- nf><c- nf>atomic_flag_test</c-></c-><c- p><c- p>(</c-></c-><c- k><c- k>const</c-></c-> <c- k><c- k>volatile</c-></c-> <c- n><c- n>atomic_flag</c-></c-><c- o><c- o>*</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
  <c- b><c- b>bool</c-></c-> <c- nf><c- nf>atomic_flag_test</c-></c-><c- p><c- p>(</c-></c-><c- k><c- k>const</c-></c-> <c- n><c- n>atomic_flag</c-></c-><c- o><c- o>*</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
  <c- b><c- b>bool</c-></c-> <c- nf><c- nf>atomic_flag_test_explicit</c-></c-><c- p><c- p>(</c-></c-><c- k><c- k>const</c-></c-> <c- k><c- k>volatile</c-></c-> <c- n><c- n>atomic_flag</c-></c-><c- o><c- o>*</c-></c-><c- p><c- p>,</c-></c-> <c- n><c- n>memory_order</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
  <c- b><c- b>bool</c-></c-> <c- nf><c- nf>atomic_flag_test_explicit</c-></c-><c- p><c- p>(</c-></c-><c- k><c- k>const</c-></c-> <c- n><c- n>atomic_flag</c-></c-><c- o><c- o>*</c-></c-><c- p><c- p>,</c-></c-> <c- n><c- n>memory_order</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c-></div>  <c- b><c- b>bool</c-></c-> <c- nf><c- nf>atomic_flag_test_and_set</c-></c-><c- p><c- p>(</c-></c-><c- k><c- k>volatile</c-></c-> <c- n><c- n>atomic_flag</c-></c-><c- o><c- o>*</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
  <c- b><c- b>bool</c-></c-> <c- nf><c- nf>atomic_flag_test_and_set</c-></c-><c- p><c- p>(</c-></c-><c- n><c- n>atomic_flag</c-></c-><c- o><c- o>*</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
  <c- b><c- b>bool</c-></c-> <c- nf><c- nf>atomic_flag_test_and_set_explicit</c-></c-><c- p><c- p>(</c-></c-><c- k><c- k>volatile</c-></c-> <c- n><c- n>atomic_flag</c-></c-><c- o><c- o>*</c-></c-><c- p><c- p>,</c-></c-> <c- n><c- n>memory_order</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
  <c- b><c- b>bool</c-></c-> <c- nf><c- nf>atomic_flag_test_and_set_explicit</c-></c-><c- p><c- p>(</c-></c-><c- n><c- n>atomic_flag</c-></c-><c- o><c- o>*</c-></c-><c- p><c- p>,</c-></c-> <c- n><c- n>memory_order</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
  <c- b><c- b>void</c-></c-> <c- nf><c- nf>atomic_flag_clear</c-></c-><c- p><c- p>(</c-></c-><c- k><c- k>volatile</c-></c-> <c- n><c- n>atomic_flag</c-></c-><c- o><c- o>*</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
  <c- b><c- b>void</c-></c-> <c- nf><c- nf>atomic_flag_clear</c-></c-><c- p><c- p>(</c-></c-><c- n><c- n>atomic_flag</c-></c-><c- o><c- o>*</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
  <c- b><c- b>void</c-></c-> <c- nf><c- nf>atomic_flag_clear_explicit</c-></c-><c- p><c- p>(</c-></c-><c- k><c- k>volatile</c-></c-> <c- n><c- n>atomic_flag</c-></c-><c- o><c- o>*</c-></c-><c- p><c- p>,</c-></c-> <c- n><c- n>memory_order</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
  <c- b><c- b>void</c-></c-> <c- nf><c- nf>atomic_flag_clear_explicit</c-></c-><c- p><c- p>(</c-></c-><c- n><c- n>atomic_flag</c-></c-><c- o><c- o>*</c-></c-><c- p><c- p>,</c-></c-> <c- n><c- n>memory_order</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
<div class="ins">  <c- b><c- b>void</c-></c-> <c- nf><c- nf>atomic_flag_wait</c-></c-><c- p><c- p>(</c-></c-><c- k><c- k>const</c-></c-> <c- k><c- k>volatile</c-></c-> <c- n><c- n>atomic_flag</c-></c-><c- o><c- o>*</c-></c-><c- p><c- p>,</c-></c-> <c- b><c- b>bool</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
  <c- b><c- b>void</c-></c-> <c- nf><c- nf>atomic_flag_wait</c-></c-><c- p><c- p>(</c-></c-><c- k><c- k>const</c-></c-> <c- n><c- n>atomic_flag</c-></c-><c- o><c- o>*</c-></c-><c- p><c- p>,</c-></c-> <c- b><c- b>bool</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
  <c- b><c- b>void</c-></c-> <c- nf><c- nf>atomic_flag_wait_explicit</c-></c-><c- p><c- p>(</c-></c-><c- k><c- k>const</c-></c-> <c- k><c- k>volatile</c-></c-> <c- n><c- n>atomic_flag</c-></c-><c- o><c- o>*</c-></c-><c- p><c- p>,</c-></c->
                                 <c- b><c- b>bool</c-></c-><c- p><c- p>,</c-></c-> <c- n><c- n>memory_order</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
  <c- b><c- b>void</c-></c-> <c- nf><c- nf>atomic_flag_wait_explicit</c-></c-><c- p><c- p>(</c-></c-><c- k><c- k>const</c-></c-> <c- n><c- n>atomic_flag</c-></c-><c- o><c- o>*</c-></c-><c- p><c- p>,</c-></c->
                                 <c- b><c- b>bool</c-></c-><c- p><c- p>,</c-></c-> <c- n><c- n>memory_order</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
  <c- b><c- b>void</c-></c-> <c- nf><c- nf>atomic_flag_notify_one</c-></c-><c- p><c- p>(</c-></c-><c- k><c- k>volatile</c-></c-> <c- n><c- n>atomic_flag</c-></c-><c- o><c- o>*</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
  <c- b><c- b>void</c-></c-> <c- nf><c- nf>atomic_flag_notify_one</c-></c-><c- p><c- p>(</c-></c-><c- n><c- n>atomic_flag</c-></c-><c- o><c- o>*</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
  <c- b><c- b>void</c-></c-> <c- nf><c- nf>atomic_flag_notify_all</c-></c-><c- p><c- p>(</c-></c-><c- k><c- k>volatile</c-></c-> <c- n><c- n>atomic_flag</c-></c-><c- o><c- o>*</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>const</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
  <c- b><c- b>void</c-></c-> <c- nf><c- nf>atomic_flag_notify_all</c-></c-><c- p><c- p>(</c-></c-><c- n><c- n>atomic_flag</c-></c-><c- o><c- o>*</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>const</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c-></div>
  <c- cp><c- cp>#define ATOMIC_FLAG_INIT </c-></c-><i><c- cp><c- cp>see below</c-></c-></i>

  <i><c- c1><c- c1>// 30.10, fences</c-></c-></i>
  <c- k><c- k>extern</c-></c-> <c- s><c- s>"C"</c-></c-> <c- b><c- b>void</c-></c-> <c- n><c- n>atomic_thread_fence</c-></c-><c- p><c- p>(</c-></c-><c- n><c- n>memory_order</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
  <c- k><c- k>extern</c-></c-> <c- s><c- s>"C"</c-></c-> <c- b><c- b>void</c-></c-> <c- n><c- n>atomic_signal_fence</c-></c-><c- p><c- p>(</c-></c-><c- n><c- n>memory_order</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
<c- p><c- p>}</c-></c->
</code></pre>
   </blockquote>
   <p>Modify <a href="http://eel.is/c++draft/atomics.alias">[<strong>atomics.alias</strong>]</a> as follows, adding a new paragraph to the end:</p>
   <blockquote>
     <b>31.3 Type aliases <span style="float: right;">[atomics.alias]</span></b> 
    <div class="numbered"> The type aliases <code class="highlight"><c- n>atomic_intN_t</c-></code>, <code class="highlight"><c- n>atomic_uintN_t</c-></code>, <code class="highlight"><c- n>atomic_intptr_t</c-></code>, and <code class="highlight"><c- n>atomic_uintptr_t</c-></code> are defined if and only if <code class="highlight"><c- n>intN_t</c-></code>, <code class="highlight"><c- n>uintN_t</c-></code>, <code class="highlight"><c- b>intptr_t</c-></code>, and <code class="highlight"><c- b>uintptr_t</c-></code> are defined, respectively. </div>
    <div class="ins">
     <div class="numbered"> The type aliases <code class="highlight"><c- n>atomic_signed_lock_free</c-></code> and <code class="highlight"><c- n>atomic_unsigned_lock_free</c-></code> name specializations of <code class="highlight"><c- n>atomic</c-></code> whose template arguments are integral types, respectively signed and unsigned, and whose <code class="highlight"><c- n>is_always_lock_free</c-></code> property is <code class="highlight">true</code>. [ <em>Note</em>: These aliases are optional in freestanding implementations (<a href="http://eel.is/c++draft/compliance">[<strong>compliance</strong>]</a>). - <em>end note</em> ] Implementations should choose for these aliases the integral specializations of atomic for which the atomic waiting and notifying operations ([<strong>atomics.wait</strong>]) are most efficient. </div>
    </div>
   </blockquote>
   <p>Insert a new paragraph after paragraph 1 in <a href="http://eel.is/c++draft/atomics.lockfree">[<strong>atomics.lockfree</strong>]</a>:</p>
   <blockquote class="ins"> At least one signed integral specialization of the <code class="highlight"><c- n>atomic</c-></code> template, along with the specialization for the corresponding unsigned type (<a href="http://eel.is/c++draft/basic.fundamental">[<strong>basic.fundamental</strong>]</a>), are always lock-free. [ <em>Note</em>: This requirement is optional in freestanding implementations (<a href="http://eel.is/c++draft/compliance">[<strong>compliance</strong>]</a>). - <em>end note</em> ] </blockquote>
   <p>Add a new subclause after <a href="http://eel.is/c++draft/atomics.lockfree">[<strong>atomics.lockfree</strong>]</a> with the stable name [<strong>atomics.wait</strong>]:</p>
   <blockquote class="ins">
     <b>31.� Waiting and notifying <span style="float: right;">[atomics.wait]</span></b> 
    <div class="numbered"> <dfn data-dfn-type="dfn" data-noexport id="atomic-waiting-operations">Atomic waiting operations<a class="self-link" href="#atomic-waiting-operations"></a></dfn> and <dfn data-dfn-type="dfn" data-noexport id="atomic-notifying-operations">atomic notifying operations<a class="self-link" href="#atomic-notifying-operations"></a></dfn> provide a mechanism to wait for the value of an atomic object to change more efficiently than can be achieved with polling.
Atomic waiting operations may block until they are unblocked by atomic notifying operations, according to each function’s effects.
[ <em>Note:</em> Programs are not guaranteed to observe transient atomic values, an issue known as the A-B-A problem, resulting in continued blocking if a condition is only temporarily met. – <em>end note</em> ] </div>
    <div class="numbered">
      [ <em>Note</em>: The following functions are atomic waiting operations: 
     <ul>
      <li data-md>
       <p><code class="highlight"><c- n>atomic</c-><c- o>&lt;</c-><c- n>T</c-><c- o>>::</c-><c- n>wait</c-></code>.</p>
      <li data-md>
       <p><code class="highlight"><c- n>atomic_flag</c-><c- o>::</c-><c- n>wait</c-></code>.</p>
      <li data-md>
       <p><code class="highlight"><c- n>atomic_wait</c-></code> and <code class="highlight"><c- n>atomic_wait_explicit</c-></code>.</p>
      <li data-md>
       <p><code class="highlight"><c- n>atomic_flag_wait</c-></code> and <code class="highlight"><c- n>atomic_flag_wait_explicit</c-></code>.</p>
     </ul>
     <p><em>- end note</em> ]</p>
    </div>
    <div class="numbered">
      [ <em>Note</em>: The following functions are atomic notifying operations: 
     <ul>
      <li data-md>
       <p><code class="highlight"><c- n>atomic</c-><c- o>&lt;</c-><c- n>T</c-><c- o>>::</c-><c- n>notify_one</c-></code> and <code class="highlight"><c- n>atomic</c-><c- o>&lt;</c-><c- n>T</c-><c- o>>::</c-><c- n>notify_all</c-></code>.</p>
      <li data-md>
       <p><code class="highlight"><c- n>atomic_flag</c-><c- o>::</c-><c- n>notify_one</c-></code> and <code class="highlight"><c- n>atomic_flag</c-><c- o>::</c-><c- n>notify_all</c-></code>.</p>
      <li data-md>
       <p><code class="highlight"><c- n>atomic_notify_one</c-></code> and <code class="highlight"><c- n>atomic_notify_all</c-></code>.</p>
      <li data-md>
       <p><code class="highlight"><c- n>atomic_flag_notify_one</c-></code> and <code class="highlight"><c- n>atomic_flag_notify_all</c-></code>.</p>
     </ul>
     <p><em>- end note</em> ]</p>
    </div>
    <div class="numbered">
      A call to an atomic waiting operation on an atomic object <code class="highlight"><c- n>M</c-></code> is <dfn data-dfn-type="dfn" data-noexport id="eligible-to-be-unblocked">eligible to be unblocked<a class="self-link" href="#eligible-to-be-unblocked"></a></dfn> by a call to an atomic notifying operation on <code class="highlight"><c- n>M</c-></code> if there exist side effects <code class="highlight"><c- n>X</c-></code> and <code class="highlight"><c- n>Y</c-></code> on <code class="highlight"><c- n>M</c-></code> such that: 
     <ul>
      <li data-md>
       <p>the atomic waiting operation has blocked after observing the result of <code class="highlight"><c- n>X</c-></code>,</p>
      <li data-md>
       <p><code class="highlight"><c- n>X</c-></code> precedes <code class="highlight"><c- n>Y</c-></code> in the modification order of <code class="highlight"><c- n>M</c-></code>, and</p>
      <li data-md>
       <p><code class="highlight"><c- n>Y</c-></code> happens before the call to the atomic notifying operation.</p>
     </ul>
    </div>
   </blockquote>
   <p>Drafting note: Adding atomic waiting and notifying operations to <code class="highlight"><c- n>atomic_ref</c-><c- o>&lt;</c-><c- n>T</c-><c- o>></c-></code> and to <code class="highlight"><c- n>atomic</c-><c- o>&lt;</c-><c- n>shared_ptr</c-><c- o>&lt;</c-><c- n>T</c-><c- o>>></c-></code> is done in separate papers, <a href="https://wg21.link/P1643">[P1643R0]</a> and <a href="https://wg21.link/P1644">[P1644R0]</a> respectively, not as part of this paper.</p>
   <p>Modify <a href="http://eel.is/c++draft/atomics.types.generic">[<strong>atomics.types.generic</strong>]</a> as follows:</p>
   <blockquote>
     <b>31.7 Class template <code class="highlight"><c- n>atomic</c-></code> <span style="float: right;">[atomics.types.generic]</span></b> 
<pre class="highlight"><code class="highlight"><c- k><c- k>namespace</c-></c-> <c- n><c- n>std</c-></c-> <c- p><c- p>{</c-></c->
  <c- k><c- k>template</c-></c-><c- o><c- o>&lt;</c-></c-><c- k><c- k>class</c-></c-> <c- nc><c- nc>T</c-></c-><c- o><c- o>></c-></c-> <c- k><c- k>struct</c-></c-> <c- n><c- n>atomic</c-></c-> <c- p><c- p>{</c-></c->
    <c- k><c- k>using</c-></c-> <c- n><c- n>value_type</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>T</c-></c-><c- p><c- p>;</c-></c->
    <c- k><c- k>static</c-></c-> <c- k><c- k>constexpr</c-></c-> <c- b><c- b>bool</c-></c-> <c- n><c- n>is_always_lock_free</c-></c-> <c- o><c- o>=</c-></c-> <i><c- n><c- n>implementation</c-></c-><c- o><c- o>-</c-></c-><c- n><c- n>defined</c-></c-></i><c- p><c- p>;</c-></c->
    <c- b><c- b>bool</c-></c-> <c- nf><c- nf>is_lock_free</c-></c-><c- p><c- p>()</c-></c-> <c- k><c- k>const</c-></c-> <c- k><c- k>volatile</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- b><c- b>bool</c-></c-> <c- nf><c- nf>is_lock_free</c-></c-><c- p><c- p>()</c-></c-> <c- k><c- k>const</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- b><c- b>void</c-></c-> <c- nf><c- nf>store</c-></c-><c- p><c- p>(</c-></c-><c- n><c- n>T</c-></c-><c- p><c- p>,</c-></c-> <c- n><c- n>memory_order</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>memory_order</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>seq_cst</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>volatile</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- b><c- b>void</c-></c-> <c- nf><c- nf>store</c-></c-><c- p><c- p>(</c-></c-><c- n><c- n>T</c-></c-><c- p><c- p>,</c-></c-> <c- n><c- n>memory_order</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>memory_order</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>seq_cst</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- n><c- n>T</c-></c-> <c- nf><c- nf>load</c-></c-><c- p><c- p>(</c-></c-><c- n><c- n>memory_order</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>memory_order</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>seq_cst</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>const</c-></c-> <c- k><c- k>volatile</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- n><c- n>T</c-></c-> <c- nf><c- nf>load</c-></c-><c- p><c- p>(</c-></c-><c- n><c- n>memory_order</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>memory_order</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>seq_cst</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>const</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- k><c- k>operator</c-></c-> <c- nf><c- nf>T</c-></c-><c- p><c- p>()</c-></c-> <c- k><c- k>const</c-></c-> <c- k><c- k>volatile</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- k><c- k>operator</c-></c-> <c- nf><c- nf>T</c-></c-><c- p><c- p>()</c-></c-> <c- k><c- k>const</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- n><c- n>T</c-></c-> <c- nf><c- nf>exchange</c-></c-><c- p><c- p>(</c-></c-><c- n><c- n>T</c-></c-><c- p><c- p>,</c-></c-> <c- n><c- n>memory_order</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>memory_order</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>seq_cst</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>volatile</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- n><c- n>T</c-></c-> <c- nf><c- nf>exchange</c-></c-><c- p><c- p>(</c-></c-><c- n><c- n>T</c-></c-><c- p><c- p>,</c-></c-> <c- n><c- n>memory_order</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>memory_order</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>seq_cst</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- b><c- b>bool</c-></c-> <c- nf><c- nf>compare_exchange_weak</c-></c-><c- p><c- p>(</c-></c-><c- n><c- n>T</c-></c-><c- o><c- o>&amp;</c-></c-><c- p><c- p>,</c-></c-> <c- n><c- n>T</c-></c-><c- p><c- p>,</c-></c-> <c- n><c- n>memory_order</c-></c-><c- p><c- p>,</c-></c-> <c- n><c- n>memory_order</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>volatile</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- b><c- b>bool</c-></c-> <c- nf><c- nf>compare_exchange_weak</c-></c-><c- p><c- p>(</c-></c-><c- n><c- n>T</c-></c-><c- o><c- o>&amp;</c-></c-><c- p><c- p>,</c-></c-> <c- n><c- n>T</c-></c-><c- p><c- p>,</c-></c-> <c- n><c- n>memory_order</c-></c-><c- p><c- p>,</c-></c-> <c- n><c- n>memory_order</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- b><c- b>bool</c-></c-> <c- nf><c- nf>compare_exchange_strong</c-></c-><c- p><c- p>(</c-></c-><c- n><c- n>T</c-></c-><c- o><c- o>&amp;</c-></c-><c- p><c- p>,</c-></c-> <c- n><c- n>T</c-></c-><c- p><c- p>,</c-></c-> <c- n><c- n>memory_order</c-></c-><c- p><c- p>,</c-></c-> <c- n><c- n>memory_order</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>volatile</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- b><c- b>bool</c-></c-> <c- nf><c- nf>compare_exchange_strong</c-></c-><c- p><c- p>(</c-></c-><c- n><c- n>T</c-></c-><c- o><c- o>&amp;</c-></c-><c- p><c- p>,</c-></c-> <c- n><c- n>T</c-></c-><c- p><c- p>,</c-></c-> <c- n><c- n>memory_order</c-></c-><c- p><c- p>,</c-></c-> <c- n><c- n>memory_order</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- b><c- b>bool</c-></c-> <c- nf><c- nf>compare_exchange_weak</c-></c-><c- p><c- p>(</c-></c-><c- n><c- n>T</c-></c-><c- o><c- o>&amp;</c-></c-><c- p><c- p>,</c-></c-> <c- n><c- n>T</c-></c-><c- p><c- p>,</c-></c->
                               <c- n><c- n>memory_order</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>memory_order</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>seq_cst</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>volatile</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- b><c- b>bool</c-></c-> <c- nf><c- nf>compare_exchange_weak</c-></c-><c- p><c- p>(</c-></c-><c- n><c- n>T</c-></c-><c- o><c- o>&amp;</c-></c-><c- p><c- p>,</c-></c-> <c- n><c- n>T</c-></c-><c- p><c- p>,</c-></c->
                               <c- n><c- n>memory_order</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>memory_order</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>seq_cst</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- b><c- b>bool</c-></c-> <c- nf><c- nf>compare_exchange_strong</c-></c-><c- p><c- p>(</c-></c-><c- n><c- n>T</c-></c-><c- o><c- o>&amp;</c-></c-><c- p><c- p>,</c-></c-> <c- n><c- n>T</c-></c-><c- p><c- p>,</c-></c->
                                 <c- n><c- n>memory_order</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>memory_order</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>seq_cst</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>volatile</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- b><c- b>bool</c-></c-> <c- nf><c- nf>compare_exchange_strong</c-></c-><c- p><c- p>(</c-></c-><c- n><c- n>T</c-></c-><c- o><c- o>&amp;</c-></c-><c- p><c- p>,</c-></c-> <c- n><c- n>T</c-></c-><c- p><c- p>,</c-></c->
                                 <c- n><c- n>memory_order</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>memory_order</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>seq_cst</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
<div class="ins">    <c- b><c- b>void</c-></c-> <c- nf><c- nf>wait</c-></c-><c- p><c- p>(</c-></c-><c- n><c- n>T</c-></c-><c- p><c- p>,</c-></c-> <c- n><c- n>memory_order</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>memory_order</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>seq_cst</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>const</c-></c-> <c- k><c- k>volatile</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- b><c- b>void</c-></c-> <c- nf><c- nf>wait</c-></c-><c- p><c- p>(</c-></c-><c- n><c- n>T</c-></c-><c- p><c- p>,</c-></c-> <c- n><c- n>memory_order</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>memory_order</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>seq_cst</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>const</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- b><c- b>void</c-></c-> <c- nf><c- nf>notify_one</c-></c-><c- p><c- p>()</c-></c-> <c- k><c- k>volatile</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- b><c- b>void</c-></c-> <c- nf><c- nf>notify_one</c-></c-><c- p><c- p>()</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- b><c- b>void</c-></c-> <c- nf><c- nf>notify_all</c-></c-><c- p><c- p>()</c-></c-> <c- k><c- k>volatile</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- b><c- b>void</c-></c-> <c- nf><c- nf>notify_all</c-></c-><c- p><c- p>()</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c-></div>
    <c- n><c- n>atomic</c-></c-><c- p><c- p>()</c-></c-> <c- k><c- k>noexcept</c-></c-> <c- o><c- o>=</c-></c-> <c- k><c- k>default</c-></c-><c- p><c- p>;</c-></c->
    <c- k><c- k>constexpr</c-></c-> <c- nf><c- nf>atomic</c-></c-><c- p><c- p>(</c-></c-><c- n><c- n>T</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- n><c- n>atomic</c-></c-><c- p><c- p>(</c-></c-><c- k><c- k>const</c-></c-> <c- n><c- n>atomic</c-></c-><c- o><c- o>&amp;</c-></c-><c- p><c- p>)</c-></c-> <c- o><c- o>=</c-></c-> <c- k><c- k>delete</c-></c-><c- p><c- p>;</c-></c->
    <c- n><c- n>atomic</c-></c-><c- o><c- o>&amp;</c-></c-> <c- k><c- k>operator</c-></c-><c- o><c- o>=</c-></c-><c- p><c- p>(</c-></c-><c- k><c- k>const</c-></c-> <c- n><c- n>atomic</c-></c-><c- o><c- o>&amp;</c-></c-><c- p><c- p>)</c-></c-> <c- o><c- o>=</c-></c-> <c- k><c- k>delete</c-></c-><c- p><c- p>;</c-></c->
    <c- n><c- n>atomic</c-></c-><c- o><c- o>&amp;</c-></c-> <c- k><c- k>operator</c-></c-><c- o><c- o>=</c-></c-><c- p><c- p>(</c-></c-><c- k><c- k>const</c-></c-> <c- n><c- n>atomic</c-></c-><c- o><c- o>&amp;</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>volatile</c-></c-> <c- o><c- o>=</c-></c-> <c- k><c- k>delete</c-></c-><c- p><c- p>;</c-></c->
    <c- n><c- n>T</c-></c-> <c- k><c- k>operator</c-></c-><c- o><c- o>=</c-></c-><c- p><c- p>(</c-></c-><c- n><c- n>T</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>volatile</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- n><c- n>T</c-></c-> <c- k><c- k>operator</c-></c-><c- o><c- o>=</c-></c-><c- p><c- p>(</c-></c-><c- n><c- n>T</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
  <c- p><c- p>};</c-></c->
<c- p><c- p>}</c-></c->
</code></pre>
   </blockquote>
   <p>Drafting note: The behavior of the non-member functions <code class="highlight"><c- n>atomic_wait</c-></code>, <code class="highlight"><c- n>atomic_wait_explicit</c-></code>, <code class="highlight"><c- n>atomic_notify_one</c-></code>, and <code class="highlight"><c- n>atomic_notify_all</c-></code> is already covered by <a href="http://eel.is/c++draft/atomics.nonmembers">[<strong>atomics.nonmembers</strong>]</a>.  Only the behavior of the member functions needs to be listed here.</p>
   <p>Add the following to the end of <a href="http://eel.is/c++draft/atomics.types.operations">[<strong>atomics.types.operations</strong>]</a>:</p>
   <blockquote class="ins">
<pre class="highlight"><c- b>void</c-> <c- nf>wait</c-><c- p>(</c-><c- n>T</c-> <c- n>old</c-><c- p>,</c-> <c- n>memory_order</c-> <c- n>order</c-> <c- o>=</c-> <c- n>memory_order</c-><c- o>::</c-><c- n>seq_cst</c-><c- p>)</c-> <c- k>const</c-> <c- k>volatile</c-> <c- k>noexcept</c-><c- p>;</c->
<c- b>void</c-> <c- nf>wait</c-><c- p>(</c-><c- n>T</c-> <c- n>old</c-><c- p>,</c-> <c- n>memory_order</c-> <c- n>order</c-> <c- o>=</c-> <c- n>memory_order</c-><c- o>::</c-><c- n>seq_cst</c-><c- p>)</c-> <c- k>const</c-> <c- k>noexcept</c-><c- p>;</c->
</pre>
    <div class="numbered"> <em>Expects:</em> <code class="highlight"><c- n>order</c-></code> is neither <code class="highlight"><c- n>memory_order</c-><c- o>::</c-><c- n>release</c-></code> nor <code class="highlight"><c- n>memory_order</c-><c- o>::</c-><c- n>acq_rel</c-></code>. </div>
    <div class="numbered">
      <em>Effects:</em> Repeatedly performs the following steps, in order: 
     <ul>
      <li data-md>
       <p>Evaluates <code class="highlight"><c- n>load</c-><c- p>(</c-><c- n>order</c-><c- p>)</c-></code> and compares its value representation for equality against that of <code class="highlight"><c- n>old</c-></code>.</p>
      <li data-md>
       <p>If they compare unequal, returns.</p>
      <li data-md>
       <p>Blocks until it is unblocked by an atomic notifying operation or is unblocked spuriously.</p>
     </ul>
    </div>
    <div class="numbered"> <em>Remarks:</em> This function is an atomic waiting operation ([<strong>atomics.wait</strong>]). </div>
<pre class="highlight"><c- b>void</c-> <c- nf>notify_one</c-><c- p>()</c-> <c- k>volatile</c-> <c- k>noexcept</c-><c- p>;</c->
<c- b>void</c-> <c- nf>notify_one</c-><c- p>()</c-> <c- k>noexcept</c-><c- p>;</c->
</pre>
    <div class="numbered"> <em>Effects:</em> Unblocks the execution of at least one atomic waiting operation that is eligible to be unblocked ([<strong>atomics.wait</strong>]) by this call, if any such atomic waiting operations exist. </div>
    <div class="numbered"> <em>Remarks:</em> This function is an atomic notifying operation ([<strong>atomics.wait</strong>]). </div>
<pre class="highlight"><c- b>void</c-> <c- nf>notify_all</c-><c- p>()</c-> <c- k>volatile</c-> <c- k>noexcept</c-><c- p>;</c->
<c- b>void</c-> <c- nf>notify_all</c-><c- p>()</c-> <c- k>noexcept</c-><c- p>;</c->
</pre>
    <div class="numbered"> <em>Effects:</em> Unblocks the execution of all atomic waiting operations that are eligible to be unblocked ([<strong>atomics.wait</strong>]) by this call. </div>
    <div class="numbered"> <em>Remarks:</em> This function is an atomic notifying operation ([<strong>atomics.wait</strong>]). </div>
   </blockquote>
   <p>Modify <a href="http://eel.is/c++draft/atomics.types.int#1">[<strong>atomics.types.int</strong>] paragraph 1</a> as follows:</p>
   <blockquote>
     <b>31.7.2 Specializations for integers <span style="float: right;">[atomics.types.int]</span></b> 
    <div class="numbered"> There are specializations of the <code class="highlight"><c- n>atomic</c-></code> class template for the integral types <code class="highlight"><c- b>char</c-></code>, <code class="highlight"><c- b>signed</c-> <c- b>char</c-></code>, <code class="highlight"><c- b>unsigned</c-> <c- b>char</c-></code>, <code class="highlight"><c- b>short</c-></code>, <code class="highlight"><c- b>unsigned</c-> <c- b>short</c-></code>, <code class="highlight"><c- b>int</c-></code>, <code class="highlight"><c- b>unsigned</c-> <c- b>int</c-></code>, <code class="highlight"><c- b>long</c-></code>, <code class="highlight"><c- b>unsigned</c-> <c- b>long</c-></code>, <code class="highlight"><c- b>long</c-> <c- b>long</c-></code>, <code class="highlight"><c- b>unsigned</c-> <c- b>long</c-> <c- b>long</c-></code>, <code class="highlight"><c- n>char8_t</c-></code>, <code class="highlight"><c- b>char16_t</c-></code>, <code class="highlight"><c- b>char32_t</c-></code>, <code class="highlight"><c- b>wchar_t</c-></code>, and any other types needed by the typedefs in the header <code class="highlight"><c- o>&lt;</c-><c- n>cstdint</c-><c- o>></c-></code>.
For each such type <code class="highlight"><i><c- n>integral</c-></i></code>, the specialization <code class="highlight"><c- n>atomic</c-><c- o>&lt;</c-><i><c- n>integral</c-></i><c- o>></c-></code> provides additional atomic operations appropriate to integral types.
[ <em>Note:</em> For the specialization <code class="highlight"><c- n>atomic</c-><c- o>&lt;</c-><c- b>bool</c-><c- o>></c-></code>, see <a href="http://eel.is/c++draft/atomics.types.generic">31.7</a>. — <em>end note</em> ] </div>
<pre class="highlight"><code class="highlight"><c- k><c- k>namespace</c-></c-> <c- n><c- n>std</c-></c-> <c- p><c- p>{</c-></c->
  <c- k><c- k>template</c-></c-><c- o><c- o>&lt;></c-></c-> <c- k><c- k>struct</c-></c-> <c- n><c- n>atomic</c-></c-><c- o><c- o>&lt;</c-></c-><i><c- n><c- n>integral</c-></c-></i><c- o><c- o>></c-></c-> <c- p><c- p>{</c-></c->
    <c- k><c- k>using</c-></c-> <c- n><c- n>value_type</c-></c-> <c- o><c- o>=</c-></c-> <i><c- n><c- n>integral</c-></c-></i><c- p><c- p>;</c-></c->
    <c- k><c- k>using</c-></c-> <c- n><c- n>difference_type</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>value_type</c-></c-><c- p><c- p>;</c-></c->
    <c- k><c- k>static</c-></c-> <c- k><c- k>constexpr</c-></c-> <c- b><c- b>bool</c-></c-> <c- n><c- n>is_always_lock_free</c-></c-> <c- o><c- o>=</c-></c-> <i><c- n><c- n>implementation</c-></c-><c- o><c- o>-</c-></c-><c- n><c- n>defined</c-></c-></i><c- p><c- p>;</c-></c->
    <c- b><c- b>bool</c-></c-> <c- nf><c- nf>is_lock_free</c-></c-><c- p><c- p>()</c-></c-> <c- k><c- k>const</c-></c-> <c- k><c- k>volatile</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- b><c- b>bool</c-></c-> <c- nf><c- nf>is_lock_free</c-></c-><c- p><c- p>()</c-></c-> <c- k><c- k>const</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- b><c- b>void</c-></c-> <c- nf><c- nf>store</c-></c-><c- p><c- p>(</c-></c-><i><c- n><c- n>integral</c-></c-></i><c- p><c- p>,</c-></c-> <c- n><c- n>memory_order</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>memory_order</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>seq_cst</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>volatile</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- b><c- b>void</c-></c-> <c- nf><c- nf>store</c-></c-><c- p><c- p>(</c-></c-><i><c- n><c- n>integral</c-></c-></i><c- p><c- p>,</c-></c-> <c- n><c- n>memory_order</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>memory_order</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>seq_cst</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <i><c- n><c- n>integral</c-></c-></i> <c- nf><c- nf>load</c-></c-><c- p><c- p>(</c-></c-><c- n><c- n>memory_order</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>memory_order</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>seq_cst</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>const</c-></c-> <c- k><c- k>volatile</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <i><c- n><c- n>integral</c-></c-></i> <c- nf><c- nf>load</c-></c-><c- p><c- p>(</c-></c-><c- n><c- n>memory_order</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>memory_order</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>seq_cst</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>const</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- k><c- k>operator</c-></c-> <i><c- nf><c- nf>integral</c-></c-></i><c- p><c- p>()</c-></c-> <c- k><c- k>const</c-></c-> <c- k><c- k>volatile</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- k><c- k>operator</c-></c-> <i><c- nf><c- nf>integral</c-></c-></i><c- p><c- p>()</c-></c-> <c- k><c- k>const</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <i><c- n><c- n>integral</c-></c-></i> <c- nf><c- nf>exchange</c-></c-><c- p><c- p>(</c-></c-><i><c- n><c- n>integral</c-></c-></i><c- p><c- p>,</c-></c-> <c- n><c- n>memory_order</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>memory_order</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>seq_cst</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>volatile</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <i><c- n><c- n>integral</c-></c-></i> <c- nf><c- nf>exchange</c-></c-><c- p><c- p>(</c-></c-><i><c- n><c- n>integral</c-></c-></i><c- p><c- p>,</c-></c-> <c- n><c- n>memory_order</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>memory_order</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>seq_cst</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- b><c- b>bool</c-></c-> <c- nf><c- nf>compare_exchange_weak</c-></c-><c- p><c- p>(</c-></c-><i><c- n><c- n>integral</c-></c-></i><c- o><c- o>&amp;</c-></c-><c- p><c- p>,</c-></c-> <i><c- n><c- n>integral</c-></c-></i><c- p><c- p>,</c-></c->
                               <c- n><c- n>memory_order</c-></c-><c- p><c- p>,</c-></c-> <c- n><c- n>memory_order</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>volatile</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- b><c- b>bool</c-></c-> <c- nf><c- nf>compare_exchange_weak</c-></c-><c- p><c- p>(</c-></c-><i><c- n><c- n>integral</c-></c-></i><c- o><c- o>&amp;</c-></c-><c- p><c- p>,</c-></c-> <i><c- n><c- n>integral</c-></c-></i><c- p><c- p>,</c-></c->
                               <c- n><c- n>memory_order</c-></c-><c- p><c- p>,</c-></c-> <c- n><c- n>memory_order</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- b><c- b>bool</c-></c-> <c- nf><c- nf>compare_exchange_strong</c-></c-><c- p><c- p>(</c-></c-><i><c- n><c- n>integral</c-></c-></i><c- o><c- o>&amp;</c-></c-><c- p><c- p>,</c-></c-> <i><c- n><c- n>integral</c-></c-></i><c- p><c- p>,</c-></c->
                                 <c- n><c- n>memory_order</c-></c-><c- p><c- p>,</c-></c-> <c- n><c- n>memory_order</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>volatile</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- b><c- b>bool</c-></c-> <c- nf><c- nf>compare_exchange_strong</c-></c-><c- p><c- p>(</c-></c-><i><c- n><c- n>integral</c-></c-></i><c- o><c- o>&amp;</c-></c-><c- p><c- p>,</c-></c-> <i><c- n><c- n>integral</c-></c-></i><c- p><c- p>,</c-></c->
                                 <c- n><c- n>memory_order</c-></c-><c- p><c- p>,</c-></c-> <c- n><c- n>memory_order</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- b><c- b>bool</c-></c-> <c- nf><c- nf>compare_exchange_weak</c-></c-><c- p><c- p>(</c-></c-><i><c- n><c- n>integral</c-></c-></i><c- o><c- o>&amp;</c-></c-><c- p><c- p>,</c-></c-> <i><c- n><c- n>integral</c-></c-></i><c- p><c- p>,</c-></c->
                               <c- n><c- n>memory_order</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>memory_order</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>seq_cst</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>volatile</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- b><c- b>bool</c-></c-> <c- nf><c- nf>compare_exchange_weak</c-></c-><c- p><c- p>(</c-></c-><i><c- n><c- n>integral</c-></c-></i><c- o><c- o>&amp;</c-></c-><c- p><c- p>,</c-></c-> <i><c- n><c- n>integral</c-></c-></i><c- p><c- p>,</c-></c->
                               <c- n><c- n>memory_order</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>memory_order</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>seq_cst</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- b><c- b>bool</c-></c-> <c- nf><c- nf>compare_exchange_strong</c-></c-><c- p><c- p>(</c-></c-><i><c- n><c- n>integral</c-></c-></i><c- o><c- o>&amp;</c-></c-><c- p><c- p>,</c-></c-> <i><c- n><c- n>integral</c-></c-></i><c- p><c- p>,</c-></c->
                                 <c- n><c- n>memory_order</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>memory_order</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>seq_cst</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>volatile</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- b><c- b>bool</c-></c-> <c- nf><c- nf>compare_exchange_strong</c-></c-><c- p><c- p>(</c-></c-><i><c- n><c- n>integral</c-></c-></i><c- o><c- o>&amp;</c-></c-><c- p><c- p>,</c-></c-> <i><c- n><c- n>integral</c-></c-></i><c- p><c- p>,</c-></c->
                                 <c- n><c- n>memory_order</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>memory_order</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>seq_cst</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
<div class="ins">    <c- b><c- b>void</c-></c-> <c- nf><c- nf>wait</c-></c-><c- p><c- p>(</c-></c-><i><c- n><c- n>integral</c-></c-></i><c- p><c- p>,</c-></c-> <c- n><c- n>memory_order</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>memory_order</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>seq_cst</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>const</c-></c-> <c- k><c- k>volatile</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- b><c- b>void</c-></c-> <c- nf><c- nf>wait</c-></c-><c- p><c- p>(</c-></c-><i><c- n><c- n>integral</c-></c-></i><c- p><c- p>,</c-></c-> <c- n><c- n>memory_order</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>memory_order</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>seq_cst</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>const</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- b><c- b>void</c-></c-> <c- nf><c- nf>notify_one</c-></c-><c- p><c- p>()</c-></c-> <c- k><c- k>volatile</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- b><c- b>void</c-></c-> <c- nf><c- nf>notify_one</c-></c-><c- p><c- p>()</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- b><c- b>void</c-></c-> <c- nf><c- nf>notify_all</c-></c-><c- p><c- p>()</c-></c-> <c- k><c- k>volatile</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- b><c- b>void</c-></c-> <c- nf><c- nf>notify_all</c-></c-><c- p><c- p>()</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c-></div>
    <i><c- n><c- n>integral</c-></c-></i> <c- nf><c- nf>fetch_add</c-></c-><c- p><c- p>(</c-></c-><i><c- n><c- n>integral</c-></c-></i><c- p><c- p>,</c-></c-> <c- n><c- n>memory_order</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>memory_order</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>seq_cst</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>volatile</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <i><c- n><c- n>integral</c-></c-></i> <c- nf><c- nf>fetch_add</c-></c-><c- p><c- p>(</c-></c-><i><c- n><c- n>integral</c-></c-></i><c- p><c- p>,</c-></c-> <c- n><c- n>memory_order</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>memory_order</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>seq_cst</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <i><c- n><c- n>integral</c-></c-></i> <c- nf><c- nf>fetch_sub</c-></c-><c- p><c- p>(</c-></c-><i><c- n><c- n>integral</c-></c-></i><c- p><c- p>,</c-></c-> <c- n><c- n>memory_order</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>memory_order</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>seq_cst</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>volatile</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <i><c- n><c- n>integral</c-></c-></i> <c- nf><c- nf>fetch_sub</c-></c-><c- p><c- p>(</c-></c-><i><c- n><c- n>integral</c-></c-></i><c- p><c- p>,</c-></c-> <c- n><c- n>memory_order</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>memory_order</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>seq_cst</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <i><c- n><c- n>integral</c-></c-></i> <c- nf><c- nf>fetch_and</c-></c-><c- p><c- p>(</c-></c-><i><c- n><c- n>integral</c-></c-></i><c- p><c- p>,</c-></c-> <c- n><c- n>memory_order</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>memory_order</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>seq_cst</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>volatile</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <i><c- n><c- n>integral</c-></c-></i> <c- nf><c- nf>fetch_and</c-></c-><c- p><c- p>(</c-></c-><i><c- n><c- n>integral</c-></c-></i><c- p><c- p>,</c-></c-> <c- n><c- n>memory_order</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>memory_order</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>seq_cst</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <i><c- n><c- n>integral</c-></c-></i> <c- nf><c- nf>fetch_or</c-></c-><c- p><c- p>(</c-></c-><i><c- n><c- n>integral</c-></c-></i><c- p><c- p>,</c-></c-> <c- n><c- n>memory_order</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>memory_order</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>seq_cst</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>volatile</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <i><c- n><c- n>integral</c-></c-></i> <c- nf><c- nf>fetch_or</c-></c-><c- p><c- p>(</c-></c-><i><c- n><c- n>integral</c-></c-></i><c- p><c- p>,</c-></c-> <c- n><c- n>memory_order</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>memory_order</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>seq_cst</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <i><c- n><c- n>integral</c-></c-></i> <c- nf><c- nf>fetch_xor</c-></c-><c- p><c- p>(</c-></c-><i><c- n><c- n>integral</c-></c-></i><c- p><c- p>,</c-></c-> <c- n><c- n>memory_order</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>memory_order</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>seq_cst</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>volatile</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <i><c- n><c- n>integral</c-></c-></i> <c- nf><c- nf>fetch_xor</c-></c-><c- p><c- p>(</c-></c-><i><c- n><c- n>integral</c-></c-></i><c- p><c- p>,</c-></c-> <c- n><c- n>memory_order</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>memory_order</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>seq_cst</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->

    <c- n><c- n>atomic</c-></c-><c- p><c- p>()</c-></c-> <c- k><c- k>noexcept</c-></c-> <c- o><c- o>=</c-></c-> <c- k><c- k>default</c-></c-><c- p><c- p>;</c-></c->
    <c- k><c- k>constexpr</c-></c-> <c- nf><c- nf>atomic</c-></c-><c- p><c- p>(</c-></c-><i><c- n><c- n>integral</c-></c-></i><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- n><c- n>atomic</c-></c-><c- p><c- p>(</c-></c-><c- k><c- k>const</c-></c-> <c- n><c- n>atomic</c-></c-><c- o><c- o>&amp;</c-></c-><c- p><c- p>)</c-></c-> <c- o><c- o>=</c-></c-> <c- k><c- k>delete</c-></c-><c- p><c- p>;</c-></c->
    <c- n><c- n>atomic</c-></c-><c- o><c- o>&amp;</c-></c-> <c- k><c- k>operator</c-></c-><c- o><c- o>=</c-></c-><c- p><c- p>(</c-></c-><c- k><c- k>const</c-></c-> <c- n><c- n>atomic</c-></c-><c- o><c- o>&amp;</c-></c-><c- p><c- p>)</c-></c-> <c- o><c- o>=</c-></c-> <c- k><c- k>delete</c-></c-><c- p><c- p>;</c-></c->
    <c- n><c- n>atomic</c-></c-><c- o><c- o>&amp;</c-></c-> <c- k><c- k>operator</c-></c-><c- o><c- o>=</c-></c-><c- p><c- p>(</c-></c-><c- k><c- k>const</c-></c-> <c- n><c- n>atomic</c-></c-><c- o><c- o>&amp;</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>volatile</c-></c-> <c- o><c- o>=</c-></c-> <c- k><c- k>delete</c-></c-><c- p><c- p>;</c-></c->
    <i><c- n><c- n>integral</c-></c-></i> <c- k><c- k>operator</c-></c-><c- o><c- o>=</c-></c-><c- p><c- p>(</c-></c-><i><c- n><c- n>integral</c-></c-></i><c- p><c- p>)</c-></c-> <c- k><c- k>volatile</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <i><c- n><c- n>integral</c-></c-></i> <c- k><c- k>operator</c-></c-><c- o><c- o>=</c-></c-><c- p><c- p>(</c-></c-><i><c- n><c- n>integral</c-></c-></i><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->

    <i><c- n><c- n>integral</c-></c-></i> <c- k><c- k>operator</c-></c-><c- o><c- o>++</c-></c-><c- p><c- p>(</c-></c-><c- b><c- b>int</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>volatile</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <i><c- n><c- n>integral</c-></c-></i> <c- k><c- k>operator</c-></c-><c- o><c- o>++</c-></c-><c- p><c- p>(</c-></c-><c- b><c- b>int</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <i><c- n><c- n>integral</c-></c-></i> <c- k><c- k>operator</c-></c-><c- o><c- o>--</c-></c-><c- p><c- p>(</c-></c-><c- b><c- b>int</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>volatile</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <i><c- n><c- n>integral</c-></c-></i> <c- k><c- k>operator</c-></c-><c- o><c- o>--</c-></c-><c- p><c- p>(</c-></c-><c- b><c- b>int</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <i><c- n><c- n>integral</c-></c-></i> <c- k><c- k>operator</c-></c-><c- o><c- o>++</c-></c-><c- p><c- p>()</c-></c-> <c- k><c- k>volatile</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <i><c- n><c- n>integral</c-></c-></i> <c- k><c- k>operator</c-></c-><c- o><c- o>++</c-></c-><c- p><c- p>()</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <i><c- n><c- n>integral</c-></c-></i> <c- k><c- k>operator</c-></c-><c- o><c- o>--</c-></c-><c- p><c- p>()</c-></c-> <c- k><c- k>volatile</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <i><c- n><c- n>integral</c-></c-></i> <c- k><c- k>operator</c-></c-><c- o><c- o>--</c-></c-><c- p><c- p>()</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <i><c- n><c- n>integral</c-></c-></i> <c- k><c- k>operator</c-></c-><c- o><c- o>+=</c-></c-><c- p><c- p>(</c-></c-><i><c- n><c- n>integral</c-></c-></i><c- p><c- p>)</c-></c-> <c- k><c- k>volatile</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <i><c- n><c- n>integral</c-></c-></i> <c- k><c- k>operator</c-></c-><c- o><c- o>+=</c-></c-><c- p><c- p>(</c-></c-><i><c- n><c- n>integral</c-></c-></i><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <i><c- n><c- n>integral</c-></c-></i> <c- k><c- k>operator</c-></c-><c- o><c- o>-=</c-></c-><c- p><c- p>(</c-></c-><i><c- n><c- n>integral</c-></c-></i><c- p><c- p>)</c-></c-> <c- k><c- k>volatile</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <i><c- n><c- n>integral</c-></c-></i> <c- k><c- k>operator</c-></c-><c- o><c- o>-=</c-></c-><c- p><c- p>(</c-></c-><i><c- n><c- n>integral</c-></c-></i><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <i><c- n><c- n>integral</c-></c-></i> <c- k><c- k>operator</c-></c-><c- o><c- o>&amp;=</c-></c-><c- p><c- p>(</c-></c-><i><c- n><c- n>integral</c-></c-></i><c- p><c- p>)</c-></c-> <c- k><c- k>volatile</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <i><c- n><c- n>integral</c-></c-></i> <c- k><c- k>operator</c-></c-><c- o><c- o>&amp;=</c-></c-><c- p><c- p>(</c-></c-><i><c- n><c- n>integral</c-></c-></i><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <i><c- n><c- n>integral</c-></c-></i> <c- k><c- k>operator</c-></c-><c- o><c- o>|=</c-></c-><c- p><c- p>(</c-></c-><i><c- n><c- n>integral</c-></c-></i><c- p><c- p>)</c-></c-> <c- k><c- k>volatile</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <i><c- n><c- n>integral</c-></c-></i> <c- k><c- k>operator</c-></c-><c- o><c- o>|=</c-></c-><c- p><c- p>(</c-></c-><i><c- n><c- n>integral</c-></c-></i><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <i><c- n><c- n>integral</c-></c-></i> <c- k><c- k>operator</c-></c-><c- o><c- o>^=</c-></c-><c- p><c- p>(</c-></c-><i><c- n><c- n>integral</c-></c-></i><c- p><c- p>)</c-></c-> <c- k><c- k>volatile</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <i><c- n><c- n>integral</c-></c-></i> <c- k><c- k>operator</c-></c-><c- o><c- o>^=</c-></c-><c- p><c- p>(</c-></c-><i><c- n><c- n>integral</c-></c-></i><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
  <c- p><c- p>};</c-></c->
<c- p><c- p>}</c-></c->
</code></pre>
   </blockquote>
   <p>Modify <a href="http://eel.is/c++draft/atomics.types.float#1">[<strong>atomics.types.float</strong>] paragraph 1</a> as follows:</p>
   <blockquote>
     <b>31.7.3 Specializations for floating-point types <span style="float: right;">[atomics.types.float]</span></b> 
    <div class="numbered"> There are specializations of the <code class="highlight"><c- n>atomic</c-></code> class template for the floating-point types <code class="highlight"><c- b>float</c-></code>, <code class="highlight"><c- b>double</c-></code>, and <code class="highlight"><c- b>long</c-> <c- b>double</c-></code>.
For each such type <code class="highlight"><i><c- n>floating</c-><c- o>-</c-><c- n>point</c-></i></code>, the specialization <code class="highlight"><c- n>atomic</c-><c- o>&lt;</c-><i><c- n>floating</c-><c- o>-</c-><c- n>point</c-></i><c- o>></c-></code> provides additional atomic operations appropriate to floating-point types. </div>
<pre class="highlight"><code class="highlight"><c- k><c- k>namespace</c-></c-> <c- n><c- n>std</c-></c-> <c- p><c- p>{</c-></c->
  <c- k><c- k>template</c-></c-><c- o><c- o>&lt;></c-></c-> <c- k><c- k>struct</c-></c-> <c- n><c- n>atomic</c-></c-><c- o><c- o>&lt;</c-></c-><i><c- n><c- n>floating</c-></c-><c- o><c- o>-</c-></c-><c- n><c- n>point</c-></c-></i><c- o><c- o>></c-></c-> <c- p><c- p>{</c-></c->
    <c- k><c- k>using</c-></c-> <c- n><c- n>value_type</c-></c-> <c- o><c- o>=</c-></c-> <i><c- n><c- n>floating</c-></c-><c- o><c- o>-</c-></c-><c- n><c- n>point</c-></c-></i><c- p><c- p>;</c-></c->
    <c- k><c- k>using</c-></c-> <c- n><c- n>difference_type</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>value_type</c-></c-><c- p><c- p>;</c-></c->
    <c- k><c- k>static</c-></c-> <c- k><c- k>constexpr</c-></c-> <c- b><c- b>bool</c-></c-> <c- n><c- n>is_always_lock_free</c-></c-> <c- o><c- o>=</c-></c-> <i><c- n><c- n>implementation</c-></c-><c- o><c- o>-</c-></c-><c- n><c- n>defined</c-></c-></i><c- p><c- p>;</c-></c->
    <c- b><c- b>bool</c-></c-> <c- nf><c- nf>is_lock_free</c-></c-><c- p><c- p>()</c-></c-> <c- k><c- k>const</c-></c-> <c- k><c- k>volatile</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- b><c- b>bool</c-></c-> <c- nf><c- nf>is_lock_free</c-></c-><c- p><c- p>()</c-></c-> <c- k><c- k>const</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- b><c- b>void</c-></c-> <c- nf><c- nf>store</c-></c-><c- p><c- p>(</c-></c-><i><c- n><c- n>floating</c-></c-><c- o><c- o>-</c-></c-><c- n><c- n>point</c-></c-></i><c- p><c- p>,</c-></c-> <c- n><c- n>memory_order</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>memory_order</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>seq_cst</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>volatile</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- b><c- b>void</c-></c-> <c- nf><c- nf>store</c-></c-><c- p><c- p>(</c-></c-><i><c- n><c- n>floating</c-></c-><c- o><c- o>-</c-></c-><c- n><c- n>point</c-></c-></i><c- p><c- p>,</c-></c-> <c- n><c- n>memory_order</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>memory_order</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>seq_cst</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <i><c- n><c- n>floating</c-></c-><c- o><c- o>-</c-></c-><c- n><c- n>point</c-></c-></i> <c- n><c- n>load</c-></c-><c- p><c- p>(</c-></c-><c- n><c- n>memory_order</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>memory_order</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>seq_cst</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>const</c-></c-> <c- k><c- k>volatile</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <i><c- n><c- n>floating</c-></c-><c- o><c- o>-</c-></c-><c- n><c- n>point</c-></c-></i> <c- n><c- n>load</c-></c-><c- p><c- p>(</c-></c-><c- n><c- n>memory_order</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>memory_order</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>seq_cst</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>const</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- k><c- k>operator</c-></c-> <i><c- n><c- n>floating</c-></c-><c- o><c- o>-</c-></c-><c- n><c- n>point</c-></c-></i><c- p><c- p>()</c-></c-> <c- k><c- k>const</c-></c-> <c- k><c- k>volatile</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- k><c- k>operator</c-></c-> <i><c- n><c- n>floating</c-></c-><c- o><c- o>-</c-></c-><c- n><c- n>point</c-></c-></i><c- p><c- p>()</c-></c-> <c- k><c- k>const</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <i><c- n><c- n>floating</c-></c-><c- o><c- o>-</c-></c-><c- n><c- n>point</c-></c-></i> <c- n><c- n>exchange</c-></c-><c- p><c- p>(</c-></c-><i><c- n><c- n>floating</c-></c-><c- o><c- o>-</c-></c-><c- n><c- n>point</c-></c-></i><c- p><c- p>,</c-></c->
                             <c- n><c- n>memory_order</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>memory_order</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>seq_cst</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>volatile</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <i><c- n><c- n>floating</c-></c-><c- o><c- o>-</c-></c-><c- n><c- n>point</c-></c-></i> <c- n><c- n>exchange</c-></c-><c- p><c- p>(</c-></c-><i><c- n><c- n>floating</c-></c-><c- o><c- o>-</c-></c-><c- n><c- n>point</c-></c-></i><c- p><c- p>,</c-></c->
                             <c- n><c- n>memory_order</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>memory_order</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>seq_cst</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- b><c- b>bool</c-></c-> <c- nf><c- nf>compare_exchange_weak</c-></c-><c- p><c- p>(</c-></c-><i><c- n><c- n>floating</c-></c-><c- o><c- o>-</c-></c-><c- n><c- n>point</c-></c-></i><c- o><c- o>&amp;</c-></c-><c- p><c- p>,</c-></c-> <i><c- n><c- n>floating</c-></c-><c- o><c- o>-</c-></c-><c- n><c- n>point</c-></c-></i><c- p><c- p>,</c-></c->
                               <c- n><c- n>memory_order</c-></c-><c- p><c- p>,</c-></c-> <c- n><c- n>memory_order</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>volatile</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- b><c- b>bool</c-></c-> <c- nf><c- nf>compare_exchange_weak</c-></c-><c- p><c- p>(</c-></c-><i><c- n><c- n>floating</c-></c-><c- o><c- o>-</c-></c-><c- n><c- n>point</c-></c-></i><c- o><c- o>&amp;</c-></c-><c- p><c- p>,</c-></c-> <i><c- n><c- n>floating</c-></c-><c- o><c- o>-</c-></c-><c- n><c- n>point</c-></c-></i><c- p><c- p>,</c-></c->
                               <c- n><c- n>memory_order</c-></c-><c- p><c- p>,</c-></c-> <c- n><c- n>memory_order</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- b><c- b>bool</c-></c-> <c- nf><c- nf>compare_exchange_strong</c-></c-><c- p><c- p>(</c-></c-><i><c- n><c- n>floating</c-></c-><c- o><c- o>-</c-></c-><c- n><c- n>point</c-></c-></i><c- o><c- o>&amp;</c-></c-><c- p><c- p>,</c-></c-> <i><c- n><c- n>floating</c-></c-><c- o><c- o>-</c-></c-><c- n><c- n>point</c-></c-></i><c- p><c- p>,</c-></c->
                                 <c- n><c- n>memory_order</c-></c-><c- p><c- p>,</c-></c-> <c- n><c- n>memory_order</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>volatile</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- b><c- b>bool</c-></c-> <c- nf><c- nf>compare_exchange_strong</c-></c-><c- p><c- p>(</c-></c-><i><c- n><c- n>floating</c-></c-><c- o><c- o>-</c-></c-><c- n><c- n>point</c-></c-></i><c- o><c- o>&amp;</c-></c-><c- p><c- p>,</c-></c-> <i><c- n><c- n>floating</c-></c-><c- o><c- o>-</c-></c-><c- n><c- n>point</c-></c-></i><c- p><c- p>,</c-></c->
                                 <c- n><c- n>memory_order</c-></c-><c- p><c- p>,</c-></c-> <c- n><c- n>memory_order</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- b><c- b>bool</c-></c-> <c- nf><c- nf>compare_exchange_weak</c-></c-><c- p><c- p>(</c-></c-><i><c- n><c- n>floating</c-></c-><c- o><c- o>-</c-></c-><c- n><c- n>point</c-></c-></i><c- o><c- o>&amp;</c-></c-><c- p><c- p>,</c-></c-> <i><c- n><c- n>floating</c-></c-><c- o><c- o>-</c-></c-><c- n><c- n>point</c-></c-></i><c- p><c- p>,</c-></c->
                               <c- n><c- n>memory_order</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>memory_order</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>seq_cst</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>volatile</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- b><c- b>bool</c-></c-> <c- nf><c- nf>compare_exchange_weak</c-></c-><c- p><c- p>(</c-></c-><i><c- n><c- n>floating</c-></c-><c- o><c- o>-</c-></c-><c- n><c- n>point</c-></c-></i><c- o><c- o>&amp;</c-></c-><c- p><c- p>,</c-></c-> <i><c- n><c- n>floating</c-></c-><c- o><c- o>-</c-></c-><c- n><c- n>point</c-></c-></i><c- p><c- p>,</c-></c->
                               <c- n><c- n>memory_order</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>memory_order</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>seq_cst</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- b><c- b>bool</c-></c-> <c- nf><c- nf>compare_exchange_strong</c-></c-><c- p><c- p>(</c-></c-><i><c- n><c- n>floating</c-></c-><c- o><c- o>-</c-></c-><c- n><c- n>point</c-></c-></i><c- o><c- o>&amp;</c-></c-><c- p><c- p>,</c-></c-> <i><c- n><c- n>floating</c-></c-><c- o><c- o>-</c-></c-><c- n><c- n>point</c-></c-></i><c- p><c- p>,</c-></c->
                                 <c- n><c- n>memory_order</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>memory_order</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>seq_cst</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>volatile</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- b><c- b>bool</c-></c-> <c- nf><c- nf>compare_exchange_strong</c-></c-><c- p><c- p>(</c-></c-><i><c- n><c- n>floating</c-></c-><c- o><c- o>-</c-></c-><c- n><c- n>point</c-></c-></i><c- o><c- o>&amp;</c-></c-><c- p><c- p>,</c-></c-> <i><c- n><c- n>floating</c-></c-><c- o><c- o>-</c-></c-><c- n><c- n>point</c-></c-></i><c- p><c- p>,</c-></c->
                                 <c- n><c- n>memory_order</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>memory_order</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>seq_cst</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
<div class="ins">    <c- b><c- b>void</c-></c-> <c- nf><c- nf>wait</c-></c-><c- p><c- p>(</c-></c-><i><c- n><c- n>floating</c-></c-><c- o><c- o>-</c-></c-><c- n><c- n>point</c-></c-></i><c- p><c- p>,</c-></c->
              <c- n><c- n>memory_order</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>memory_order</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>seq_cst</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>const</c-></c-> <c- k><c- k>volatile</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- b><c- b>void</c-></c-> <c- nf><c- nf>wait</c-></c-><c- p><c- p>(</c-></c-><i><c- n><c- n>floating</c-></c-><c- o><c- o>-</c-></c-><c- n><c- n>point</c-></c-></i><c- p><c- p>,</c-></c->
              <c- n><c- n>memory_order</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>memory_order</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>seq_cst</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>const</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- b><c- b>void</c-></c-> <c- nf><c- nf>notify_one</c-></c-><c- p><c- p>()</c-></c-> <c- k><c- k>volatile</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- b><c- b>void</c-></c-> <c- nf><c- nf>notify_one</c-></c-><c- p><c- p>()</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- b><c- b>void</c-></c-> <c- nf><c- nf>notify_all</c-></c-><c- p><c- p>()</c-></c-> <c- k><c- k>volatile</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- b><c- b>void</c-></c-> <c- nf><c- nf>notify_all</c-></c-><c- p><c- p>()</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c-></div>
    <i><c- n><c- n>floating</c-></c-><c- o><c- o>-</c-></c-><c- n><c- n>point</c-></c-></i> <c- n><c- n>fetch_add</c-></c-><c- p><c- p>(</c-></c-><i><c- n><c- n>floating</c-></c-><c- o><c- o>-</c-></c-><c- n><c- n>point</c-></c-></i><c- p><c- p>,</c-></c->
                             <c- n><c- n>memory_order</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>memory_order</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>seq_cst</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>volatile</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <i><c- n><c- n>floating</c-></c-><c- o><c- o>-</c-></c-><c- n><c- n>point</c-></c-></i> <c- n><c- n>fetch_add</c-></c-><c- p><c- p>(</c-></c-><i><c- n><c- n>floating</c-></c-><c- o><c- o>-</c-></c-><c- n><c- n>point</c-></c-></i><c- p><c- p>,</c-></c->
                             <c- n><c- n>memory_order</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>memory_order</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>seq_cst</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <i><c- n><c- n>floating</c-></c-><c- o><c- o>-</c-></c-><c- n><c- n>point</c-></c-></i> <c- n><c- n>fetch_sub</c-></c-><c- p><c- p>(</c-></c-><i><c- n><c- n>floating</c-></c-><c- o><c- o>-</c-></c-><c- n><c- n>point</c-></c-></i><c- p><c- p>,</c-></c->
                             <c- n><c- n>memory_order</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>memory_order</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>seq_cst</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>volatile</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <i><c- n><c- n>floating</c-></c-><c- o><c- o>-</c-></c-><c- n><c- n>point</c-></c-></i> <c- n><c- n>fetch_sub</c-></c-><c- p><c- p>(</c-></c-><i><c- n><c- n>floating</c-></c-><c- o><c- o>-</c-></c-><c- n><c- n>point</c-></c-></i><c- p><c- p>,</c-></c->
                             <c- n><c- n>memory_order</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>memory_order</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>seq_cst</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->

    <c- n><c- n>atomic</c-></c-><c- p><c- p>()</c-></c-> <c- k><c- k>noexcept</c-></c-> <c- o><c- o>=</c-></c-> <c- k><c- k>default</c-></c-><c- p><c- p>;</c-></c->
    <c- k><c- k>constexpr</c-></c-> <c- nf><c- nf>atomic</c-></c-><c- p><c- p>(</c-></c-><i><c- n><c- n>floating</c-></c-><c- o><c- o>-</c-></c-><c- n><c- n>point</c-></c-></i><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- n><c- n>atomic</c-></c-><c- p><c- p>(</c-></c-><c- k><c- k>const</c-></c-> <c- n><c- n>atomic</c-></c-><c- o><c- o>&amp;</c-></c-><c- p><c- p>)</c-></c-> <c- o><c- o>=</c-></c-> <c- k><c- k>delete</c-></c-><c- p><c- p>;</c-></c->
    <c- n><c- n>atomic</c-></c-><c- o><c- o>&amp;</c-></c-> <c- k><c- k>operator</c-></c-><c- o><c- o>=</c-></c-><c- p><c- p>(</c-></c-><c- k><c- k>const</c-></c-> <c- n><c- n>atomic</c-></c-><c- o><c- o>&amp;</c-></c-><c- p><c- p>)</c-></c-> <c- o><c- o>=</c-></c-> <c- k><c- k>delete</c-></c-><c- p><c- p>;</c-></c->
    <c- n><c- n>atomic</c-></c-><c- o><c- o>&amp;</c-></c-> <c- k><c- k>operator</c-></c-><c- o><c- o>=</c-></c-><c- p><c- p>(</c-></c-><c- k><c- k>const</c-></c-> <c- n><c- n>atomic</c-></c-><c- o><c- o>&amp;</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>volatile</c-></c-> <c- o><c- o>=</c-></c-> <c- k><c- k>delete</c-></c-><c- p><c- p>;</c-></c->
    <i><c- n><c- n>floating</c-></c-><c- o><c- o>-</c-></c-><c- n><c- n>point</c-></c-></i> <c- k><c- k>operator</c-></c-><c- o><c- o>=</c-></c-><c- p><c- p>(</c-></c-><i><c- n><c- n>floating</c-></c-><c- o><c- o>-</c-></c-><c- n><c- n>point</c-></c-></i><c- p><c- p>)</c-></c-> <c- k><c- k>volatile</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <i><c- n><c- n>floating</c-></c-><c- o><c- o>-</c-></c-><c- n><c- n>point</c-></c-></i> <c- k><c- k>operator</c-></c-><c- o><c- o>=</c-></c-><c- p><c- p>(</c-></c-><i><c- n><c- n>floating</c-></c-><c- o><c- o>-</c-></c-><c- n><c- n>point</c-></c-></i><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->

    <i><c- n><c- n>floating</c-></c-><c- o><c- o>-</c-></c-><c- n><c- n>point</c-></c-></i> <c- k><c- k>operator</c-></c-><c- o><c- o>+=</c-></c-><c- p><c- p>(</c-></c-><i><c- n><c- n>floating</c-></c-><c- o><c- o>-</c-></c-><c- n><c- n>point</c-></c-></i><c- p><c- p>)</c-></c-> <c- k><c- k>volatile</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <i><c- n><c- n>floating</c-></c-><c- o><c- o>-</c-></c-><c- n><c- n>point</c-></c-></i> <c- k><c- k>operator</c-></c-><c- o><c- o>+=</c-></c-><c- p><c- p>(</c-></c-><i><c- n><c- n>floating</c-></c-><c- o><c- o>-</c-></c-><c- n><c- n>point</c-></c-></i><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <i><c- n><c- n>floating</c-></c-><c- o><c- o>-</c-></c-><c- n><c- n>point</c-></c-></i> <c- k><c- k>operator</c-></c-><c- o><c- o>-=</c-></c-><c- p><c- p>(</c-></c-><i><c- n><c- n>floating</c-></c-><c- o><c- o>-</c-></c-><c- n><c- n>point</c-></c-></i><c- p><c- p>)</c-></c-> <c- k><c- k>volatile</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <i><c- n><c- n>floating</c-></c-><c- o><c- o>-</c-></c-><c- n><c- n>point</c-></c-></i> <c- k><c- k>operator</c-></c-><c- o><c- o>-=</c-></c-><c- p><c- p>(</c-></c-><i><c- n><c- n>floating</c-></c-><c- o><c- o>-</c-></c-><c- n><c- n>point</c-></c-></i><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
  <c- p><c- p>};</c-></c->
<c- p><c- p>}</c-></c->
</code></pre>
   </blockquote>
   <p>Modify <a href="http://eel.is/c++draft/atomics.types.pointer#1">[<strong>atomics.types.pointer</strong>] paragraph 1</a> as follows:</p>
   <blockquote>
     <b>31.7.4 Partial specialization for pointers <span style="float: right;">[atomics.types.pointer]</span></b> 
<pre class="highlight"><code class="highlight"><c- k><c- k>namespace</c-></c-> <c- n><c- n>std</c-></c-> <c- p><c- p>{</c-></c->
  <c- k><c- k>template</c-></c-><c- o><c- o>&lt;</c-></c-><c- k><c- k>class</c-></c-> <c- nc><c- nc>T</c-></c-><c- o><c- o>></c-></c-> <c- k><c- k>struct</c-></c-> <c- n><c- n>atomic</c-></c-><c- o><c- o>&lt;</c-></c-><c- n><c- n>T</c-></c-><c- o><c- o>*></c-></c-> <c- p><c- p>{</c-></c->
    <c- k><c- k>using</c-></c-> <c- n><c- n>value_type</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>T</c-></c-><c- o><c- o>*</c-></c-><c- p><c- p>;</c-></c->
    <c- k><c- k>using</c-></c-> <c- n><c- n>difference_type</c-></c-> <c- o><c- o>=</c-></c-> <c- b><c- b>ptrdiff_t</c-></c-><c- p><c- p>;</c-></c->
    <c- k><c- k>static</c-></c-> <c- k><c- k>constexpr</c-></c-> <c- b><c- b>bool</c-></c-> <c- n><c- n>is_always_lock_free</c-></c-> <c- o><c- o>=</c-></c-> <i><c- n><c- n>implementation</c-></c-><c- o><c- o>-</c-></c-><c- n><c- n>defined</c-></c-></i><c- p><c- p>;</c-></c->
    <c- b><c- b>bool</c-></c-> <c- nf><c- nf>is_lock_free</c-></c-><c- p><c- p>()</c-></c-> <c- k><c- k>const</c-></c-> <c- k><c- k>volatile</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- b><c- b>bool</c-></c-> <c- nf><c- nf>is_lock_free</c-></c-><c- p><c- p>()</c-></c-> <c- k><c- k>const</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- b><c- b>void</c-></c-> <c- nf><c- nf>store</c-></c-><c- p><c- p>(</c-></c-><c- n><c- n>T</c-></c-><c- o><c- o>*</c-></c-><c- p><c- p>,</c-></c-> <c- n><c- n>memory_order</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>memory_order</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>seq_cst</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>volatile</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- b><c- b>void</c-></c-> <c- nf><c- nf>store</c-></c-><c- p><c- p>(</c-></c-><c- n><c- n>T</c-></c-><c- o><c- o>*</c-></c-><c- p><c- p>,</c-></c-> <c- n><c- n>memory_order</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>memory_order</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>seq_cst</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- n><c- n>T</c-></c-><c- o><c- o>*</c-></c-> <c- nf><c- nf>load</c-></c-><c- p><c- p>(</c-></c-><c- n><c- n>memory_order</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>memory_order</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>seq_cst</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>const</c-></c-> <c- k><c- k>volatile</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- n><c- n>T</c-></c-><c- o><c- o>*</c-></c-> <c- nf><c- nf>load</c-></c-><c- p><c- p>(</c-></c-><c- n><c- n>memory_order</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>memory_order</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>seq_cst</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>const</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- k><c- k>operator</c-></c-> <c- n><c- n>T</c-></c-><c- o><c- o>*</c-></c-><c- p><c- p>()</c-></c-> <c- k><c- k>const</c-></c-> <c- k><c- k>volatile</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- k><c- k>operator</c-></c-> <c- n><c- n>T</c-></c-><c- o><c- o>*</c-></c-><c- p><c- p>()</c-></c-> <c- k><c- k>const</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- n><c- n>T</c-></c-><c- o><c- o>*</c-></c-> <c- nf><c- nf>exchange</c-></c-><c- p><c- p>(</c-></c-><c- n><c- n>T</c-></c-><c- o><c- o>*</c-></c-><c- p><c- p>,</c-></c-> <c- n><c- n>memory_order</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>memory_order</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>seq_cst</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>volatile</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- n><c- n>T</c-></c-><c- o><c- o>*</c-></c-> <c- nf><c- nf>exchange</c-></c-><c- p><c- p>(</c-></c-><c- n><c- n>T</c-></c-><c- o><c- o>*</c-></c-><c- p><c- p>,</c-></c-> <c- n><c- n>memory_order</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>memory_order</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>seq_cst</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- b><c- b>bool</c-></c-> <c- nf><c- nf>compare_exchange_weak</c-></c-><c- p><c- p>(</c-></c-><c- n><c- n>T</c-></c-><c- o><c- o>*&amp;</c-></c-><c- p><c- p>,</c-></c-> <c- n><c- n>T</c-></c-><c- o><c- o>*</c-></c-><c- p><c- p>,</c-></c-> <c- n><c- n>memory_order</c-></c-><c- p><c- p>,</c-></c-> <c- n><c- n>memory_order</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>volatile</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- b><c- b>bool</c-></c-> <c- nf><c- nf>compare_exchange_weak</c-></c-><c- p><c- p>(</c-></c-><c- n><c- n>T</c-></c-><c- o><c- o>*&amp;</c-></c-><c- p><c- p>,</c-></c-> <c- n><c- n>T</c-></c-><c- o><c- o>*</c-></c-><c- p><c- p>,</c-></c-> <c- n><c- n>memory_order</c-></c-><c- p><c- p>,</c-></c-> <c- n><c- n>memory_order</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- b><c- b>bool</c-></c-> <c- nf><c- nf>compare_exchange_strong</c-></c-><c- p><c- p>(</c-></c-><c- n><c- n>T</c-></c-><c- o><c- o>*&amp;</c-></c-><c- p><c- p>,</c-></c-> <c- n><c- n>T</c-></c-><c- o><c- o>*</c-></c-><c- p><c- p>,</c-></c-> <c- n><c- n>memory_order</c-></c-><c- p><c- p>,</c-></c-> <c- n><c- n>memory_order</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- b><c- b>bool</c-></c-> <c- nf><c- nf>compare_exchange_weak</c-></c-><c- p><c- p>(</c-></c-><c- n><c- n>T</c-></c-><c- o><c- o>*&amp;</c-></c-><c- p><c- p>,</c-></c-> <c- n><c- n>T</c-></c-><c- o><c- o>*</c-></c-><c- p><c- p>,</c-></c->
                               <c- n><c- n>memory_order</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>memory_order</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>seq_cst</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>volatile</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- b><c- b>bool</c-></c-> <c- nf><c- nf>compare_exchange_weak</c-></c-><c- p><c- p>(</c-></c-><c- n><c- n>T</c-></c-><c- o><c- o>*&amp;</c-></c-><c- p><c- p>,</c-></c-> <c- n><c- n>T</c-></c-><c- o><c- o>*</c-></c-><c- p><c- p>,</c-></c->
                               <c- n><c- n>memory_order</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>memory_order</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>seq_cst</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- b><c- b>bool</c-></c-> <c- nf><c- nf>compare_exchange_strong</c-></c-><c- p><c- p>(</c-></c-><c- n><c- n>T</c-></c-><c- o><c- o>*&amp;</c-></c-><c- p><c- p>,</c-></c-> <c- n><c- n>T</c-></c-><c- o><c- o>*</c-></c-><c- p><c- p>,</c-></c->
                                 <c- n><c- n>memory_order</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>memory_order</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>seq_cst</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>volatile</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- b><c- b>bool</c-></c-> <c- nf><c- nf>compare_exchange_strong</c-></c-><c- p><c- p>(</c-></c-><c- n><c- n>T</c-></c-><c- o><c- o>*&amp;</c-></c-><c- p><c- p>,</c-></c-> <c- n><c- n>T</c-></c-><c- o><c- o>*</c-></c-><c- p><c- p>,</c-></c->
                                 <c- n><c- n>memory_order</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>memory_order</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>seq_cst</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
<div class="ins">    <c- b><c- b>void</c-></c-> <c- nf><c- nf>wait</c-></c-><c- p><c- p>(</c-></c-><c- n><c- n>T</c-></c-><c- o><c- o>*</c-></c-><c- p><c- p>,</c-></c-> <c- n><c- n>memory_order</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>memory_order</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>seq_cst</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>const</c-></c-> <c- k><c- k>volatile</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- b><c- b>void</c-></c-> <c- nf><c- nf>wait</c-></c-><c- p><c- p>(</c-></c-><c- n><c- n>T</c-></c-><c- o><c- o>*</c-></c-><c- p><c- p>,</c-></c-> <c- n><c- n>memory_order</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>memory_order</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>seq_cst</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>const</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- b><c- b>void</c-></c-> <c- nf><c- nf>notify_one</c-></c-><c- p><c- p>()</c-></c-> <c- k><c- k>volatile</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- b><c- b>void</c-></c-> <c- nf><c- nf>notify_one</c-></c-><c- p><c- p>()</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- b><c- b>void</c-></c-> <c- nf><c- nf>notify_all</c-></c-><c- p><c- p>()</c-></c-> <c- k><c- k>volatile</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- b><c- b>void</c-></c-> <c- nf><c- nf>notify_all</c-></c-><c- p><c- p>()</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c-></div>
    <c- n><c- n>T</c-></c-><c- o><c- o>*</c-></c-> <c- nf><c- nf>fetch_add</c-></c-><c- p><c- p>(</c-></c-><c- b><c- b>ptrdiff_t</c-></c-><c- p><c- p>,</c-></c-> <c- n><c- n>memory_order</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>memory_order</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>seq_cst</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>volatile</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- n><c- n>T</c-></c-><c- o><c- o>*</c-></c-> <c- nf><c- nf>fetch_add</c-></c-><c- p><c- p>(</c-></c-><c- b><c- b>ptrdiff_t</c-></c-><c- p><c- p>,</c-></c-> <c- n><c- n>memory_order</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>memory_order</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>seq_cst</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- n><c- n>T</c-></c-><c- o><c- o>*</c-></c-> <c- nf><c- nf>fetch_sub</c-></c-><c- p><c- p>(</c-></c-><c- b><c- b>ptrdiff_t</c-></c-><c- p><c- p>,</c-></c-> <c- n><c- n>memory_order</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>memory_order</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>seq_cst</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>volatile</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- n><c- n>T</c-></c-><c- o><c- o>*</c-></c-> <c- nf><c- nf>fetch_sub</c-></c-><c- p><c- p>(</c-></c-><c- b><c- b>ptrdiff_t</c-></c-><c- p><c- p>,</c-></c-> <c- n><c- n>memory_order</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>memory_order</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>seq_cst</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->

    <c- n><c- n>atomic</c-></c-><c- p><c- p>()</c-></c-> <c- k><c- k>noexcept</c-></c-> <c- o><c- o>=</c-></c-> <c- k><c- k>default</c-></c-><c- p><c- p>;</c-></c->
    <c- k><c- k>constexpr</c-></c-> <c- nf><c- nf>atomic</c-></c-><c- p><c- p>(</c-></c-><c- n><c- n>T</c-></c-><c- o><c- o>*</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- n><c- n>atomic</c-></c-><c- p><c- p>(</c-></c-><c- k><c- k>const</c-></c-> <c- n><c- n>atomic</c-></c-><c- o><c- o>&amp;</c-></c-><c- p><c- p>)</c-></c-> <c- o><c- o>=</c-></c-> <c- k><c- k>delete</c-></c-><c- p><c- p>;</c-></c->
    <c- n><c- n>atomic</c-></c-><c- o><c- o>&amp;</c-></c-> <c- k><c- k>operator</c-></c-><c- o><c- o>=</c-></c-><c- p><c- p>(</c-></c-><c- k><c- k>const</c-></c-> <c- n><c- n>atomic</c-></c-><c- o><c- o>&amp;</c-></c-><c- p><c- p>)</c-></c-> <c- o><c- o>=</c-></c-> <c- k><c- k>delete</c-></c-><c- p><c- p>;</c-></c->
    <c- n><c- n>atomic</c-></c-><c- o><c- o>&amp;</c-></c-> <c- k><c- k>operator</c-></c-><c- o><c- o>=</c-></c-><c- p><c- p>(</c-></c-><c- k><c- k>const</c-></c-> <c- n><c- n>atomic</c-></c-><c- o><c- o>&amp;</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>volatile</c-></c-> <c- o><c- o>=</c-></c-> <c- k><c- k>delete</c-></c-><c- p><c- p>;</c-></c->
    <c- n><c- n>T</c-></c-><c- o><c- o>*</c-></c-> <c- k><c- k>operator</c-></c-><c- o><c- o>=</c-></c-><c- p><c- p>(</c-></c-><c- n><c- n>T</c-></c-><c- o><c- o>*</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>volatile</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- n><c- n>T</c-></c-><c- o><c- o>*</c-></c-> <c- k><c- k>operator</c-></c-><c- o><c- o>=</c-></c-><c- p><c- p>(</c-></c-><c- n><c- n>T</c-></c-><c- o><c- o>*</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->

    <c- n><c- n>T</c-></c-><c- o><c- o>*</c-></c-> <c- k><c- k>operator</c-></c-><c- o><c- o>++</c-></c-><c- p><c- p>(</c-></c-><c- b><c- b>int</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>volatile</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- n><c- n>T</c-></c-><c- o><c- o>*</c-></c-> <c- k><c- k>operator</c-></c-><c- o><c- o>++</c-></c-><c- p><c- p>(</c-></c-><c- b><c- b>int</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- n><c- n>T</c-></c-><c- o><c- o>*</c-></c-> <c- k><c- k>operator</c-></c-><c- o><c- o>--</c-></c-><c- p><c- p>(</c-></c-><c- b><c- b>int</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>volatile</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- n><c- n>T</c-></c-><c- o><c- o>*</c-></c-> <c- k><c- k>operator</c-></c-><c- o><c- o>--</c-></c-><c- p><c- p>(</c-></c-><c- b><c- b>int</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- n><c- n>T</c-></c-><c- o><c- o>*</c-></c-> <c- k><c- k>operator</c-></c-><c- o><c- o>++</c-></c-><c- p><c- p>()</c-></c-> <c- k><c- k>volatile</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- n><c- n>T</c-></c-><c- o><c- o>*</c-></c-> <c- k><c- k>operator</c-></c-><c- o><c- o>++</c-></c-><c- p><c- p>()</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- n><c- n>T</c-></c-><c- o><c- o>*</c-></c-> <c- k><c- k>operator</c-></c-><c- o><c- o>--</c-></c-><c- p><c- p>()</c-></c-> <c- k><c- k>volatile</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- n><c- n>T</c-></c-><c- o><c- o>*</c-></c-> <c- k><c- k>operator</c-></c-><c- o><c- o>--</c-></c-><c- p><c- p>()</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- n><c- n>T</c-></c-><c- o><c- o>*</c-></c-> <c- k><c- k>operator</c-></c-><c- o><c- o>+=</c-></c-><c- p><c- p>(</c-></c-><c- b><c- b>ptrdiff_t</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>volatile</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- n><c- n>T</c-></c-><c- o><c- o>*</c-></c-> <c- k><c- k>operator</c-></c-><c- o><c- o>+=</c-></c-><c- p><c- p>(</c-></c-><c- b><c- b>ptrdiff_t</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- n><c- n>T</c-></c-><c- o><c- o>*</c-></c-> <c- k><c- k>operator</c-></c-><c- o><c- o>-=</c-></c-><c- p><c- p>(</c-></c-><c- b><c- b>ptrdiff_t</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>volatile</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- n><c- n>T</c-></c-><c- o><c- o>*</c-></c-> <c- k><c- k>operator</c-></c-><c- o><c- o>-=</c-></c-><c- p><c- p>(</c-></c-><c- b><c- b>ptrdiff_t</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
  <c- p><c- p>};</c-></c->
<c- p><c- p>}</c-></c->
</code></pre>
    <div class="numbered"> There is a partial specialization of the <code class="highlight"><c- n>atomic</c-></code> class template for pointers.
Specializations of this partial specialization are standard-layout structs.
They each have a trivial default constructor and a trivial destructor. </div>
   </blockquote>
   <p>Modify <a href="http://eel.is/c++draft/atomics.flag">[<strong>atomics.flag</strong>]</a> as follows:</p>
   <blockquote>
     <b>31.9 Flag type and operations <span style="float: right;">[atomics.flag]</span></b> 
<pre class="highlight"><code class="highlight"><c- k><c- k>namespace</c-></c-> <c- n><c- n>std</c-></c-> <c- p><c- p>{</c-></c->
  <c- k><c- k>struct</c-></c-> <c- n><c- n>atomic_flag</c-></c-> <c- p><c- p>{</c-></c->
<div class="ins">    <c- b><c- b>bool</c-></c-> <c- n><c- n>test</c-></c-><c- p><c- p>(</c-></c-><c- n><c- n>memory_order</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>memory_order</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>seq_cst</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>const</c-></c-> <c- k><c- k>volatile</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- b><c- b>bool</c-></c-> <c- nf><c- nf>test</c-></c-><c- p><c- p>(</c-></c-><c- n><c- n>memory_order</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>memory_order</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>seq_cst</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>const</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c-></div>    <c- b><c- b>bool</c-></c-> <c- nf><c- nf>test_and_set</c-></c-><c- p><c- p>(</c-></c-><c- n><c- n>memory_order</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>memory_order</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>seq_cst</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>volatile</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- b><c- b>bool</c-></c-> <c- nf><c- nf>test_and_set</c-></c-><c- p><c- p>(</c-></c-><c- n><c- n>memory_order</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>memory_order</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>seq_cst</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- b><c- b>void</c-></c-> <c- nf><c- nf>clear</c-></c-><c- p><c- p>(</c-></c-><c- n><c- n>memory_order</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>memory_order</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>seq_cst</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>volatile</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- b><c- b>void</c-></c-> <c- nf><c- nf>clear</c-></c-><c- p><c- p>(</c-></c-><c- n><c- n>memory_order</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>memory_order</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>seq_cst</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->

<div class="ins">    <c- b><c- b>void</c-></c-> <c- nf><c- nf>wait</c-></c-><c- p><c- p>(</c-></c-><c- b><c- b>bool</c-></c-><c- p><c- p>,</c-></c-> <c- n><c- n>memory_order</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>memory_order</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>seq_cst</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>const</c-></c-> <c- k><c- k>volatile</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- b><c- b>void</c-></c-> <c- nf><c- nf>wait</c-></c-><c- p><c- p>(</c-></c-><c- b><c- b>bool</c-></c-><c- p><c- p>,</c-></c-> <c- n><c- n>memory_order</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>memory_order</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>seq_cst</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>const</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- b><c- b>void</c-></c-> <c- nf><c- nf>notify_one</c-></c-><c- p><c- p>()</c-></c-> <c- k><c- k>volatile</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- b><c- b>void</c-></c-> <c- nf><c- nf>notify_one</c-></c-><c- p><c- p>()</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- b><c- b>void</c-></c-> <c- nf><c- nf>notify_all</c-></c-><c- p><c- p>()</c-></c-> <c- k><c- k>volatile</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- b><c- b>void</c-></c-> <c- nf><c- nf>notify_all</c-></c-><c- p><c- p>()</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c-></div>
    <c- n><c- n>atomic_flag</c-></c-><c- p><c- p>()</c-></c-> <c- k><c- k>noexcept</c-></c-> <c- o><c- o>=</c-></c-> <c- k><c- k>default</c-></c-><c- p><c- p>;</c-></c->
    <c- n><c- n>atomic_flag</c-></c-><c- p><c- p>(</c-></c-><c- k><c- k>const</c-></c-> <c- n><c- n>atomic_flag</c-></c-><c- o><c- o>&amp;</c-></c-><c- p><c- p>)</c-></c-> <c- o><c- o>=</c-></c-> <c- k><c- k>delete</c-></c-><c- p><c- p>;</c-></c->
    <c- n><c- n>atomic_flag</c-></c-><c- o><c- o>&amp;</c-></c-> <c- k><c- k>operator</c-></c-><c- o><c- o>=</c-></c-><c- p><c- p>(</c-></c-><c- k><c- k>const</c-></c-> <c- n><c- n>atomic_flag</c-></c-><c- o><c- o>&amp;</c-></c-><c- p><c- p>)</c-></c-> <c- o><c- o>=</c-></c-> <c- k><c- k>delete</c-></c-><c- p><c- p>;</c-></c->
    <c- n><c- n>atomic_flag</c-></c-><c- o><c- o>&amp;</c-></c-> <c- k><c- k>operator</c-></c-><c- o><c- o>=</c-></c-><c- p><c- p>(</c-></c-><c- k><c- k>const</c-></c-> <c- n><c- n>atomic_flag</c-></c-><c- o><c- o>&amp;</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>volatile</c-></c-> <c- o><c- o>=</c-></c-> <c- k><c- k>delete</c-></c-><c- p><c- p>;</c-></c->
  <c- p><c- p>};</c-></c->
 
<div class="ins">  <c- b><c- b>bool</c-></c-> <c- nf><c- nf>atomic_flag_test</c-></c-><c- p><c- p>(</c-></c-><c- k><c- k>const</c-></c-> <c- k><c- k>volatile</c-></c-> <c- n><c- n>atomic_flag</c-></c-><c- o><c- o>*</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
  <c- b><c- b>bool</c-></c-> <c- nf><c- nf>atomic_flag_test</c-></c-><c- p><c- p>(</c-></c-><c- k><c- k>const</c-></c-> <c- n><c- n>atomic_flag</c-></c-><c- o><c- o>*</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
  <c- b><c- b>bool</c-></c-> <c- nf><c- nf>atomic_flag_test_explicit</c-></c-><c- p><c- p>(</c-></c-><c- k><c- k>const</c-></c-> <c- k><c- k>volatile</c-></c-> <c- n><c- n>atomic_flag</c-></c-><c- o><c- o>*</c-></c-><c- p><c- p>,</c-></c-> <c- n><c- n>memory_order</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
  <c- b><c- b>bool</c-></c-> <c- nf><c- nf>atomic_flag_test_explicit</c-></c-><c- p><c- p>(</c-></c-><c- k><c- k>const</c-></c-> <c- n><c- n>atomic_flag</c-></c-><c- o><c- o>*</c-></c-><c- p><c- p>,</c-></c-> <c- n><c- n>memory_order</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c-></div>  <c- b><c- b>bool</c-></c-> <c- nf><c- nf>atomic_flag_test_and_set</c-></c-><c- p><c- p>(</c-></c-><c- k><c- k>volatile</c-></c-> <c- n><c- n>atomic_flag</c-></c-><c- o><c- o>*</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
  <c- b><c- b>bool</c-></c-> <c- nf><c- nf>atomic_flag_test_and_set</c-></c-><c- p><c- p>(</c-></c-><c- n><c- n>atomic_flag</c-></c-><c- o><c- o>*</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
  <c- b><c- b>bool</c-></c-> <c- nf><c- nf>atomic_flag_test_and_set_explicit</c-></c-><c- p><c- p>(</c-></c-><c- k><c- k>volatile</c-></c-> <c- n><c- n>atomic_flag</c-></c-><c- o><c- o>*</c-></c-><c- p><c- p>,</c-></c-> <c- n><c- n>memory_order</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
  <c- b><c- b>bool</c-></c-> <c- nf><c- nf>atomic_flag_test_and_set_explicit</c-></c-><c- p><c- p>(</c-></c-><c- n><c- n>atomic_flag</c-></c-><c- o><c- o>*</c-></c-><c- p><c- p>,</c-></c-> <c- n><c- n>memory_order</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
  <c- b><c- b>void</c-></c-> <c- nf><c- nf>atomic_flag_clear</c-></c-><c- p><c- p>(</c-></c-><c- k><c- k>volatile</c-></c-> <c- n><c- n>atomic_flag</c-></c-><c- o><c- o>*</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
  <c- b><c- b>void</c-></c-> <c- nf><c- nf>atomic_flag_clear</c-></c-><c- p><c- p>(</c-></c-><c- n><c- n>atomic_flag</c-></c-><c- o><c- o>*</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
  <c- b><c- b>void</c-></c-> <c- nf><c- nf>atomic_flag_clear_explicit</c-></c-><c- p><c- p>(</c-></c-><c- k><c- k>volatile</c-></c-> <c- n><c- n>atomic_flag</c-></c-><c- o><c- o>*</c-></c-><c- p><c- p>,</c-></c-> <c- n><c- n>memory_order</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
  <c- b><c- b>void</c-></c-> <c- nf><c- nf>atomic_flag_clear_explicit</c-></c-><c- p><c- p>(</c-></c-><c- n><c- n>atomic_flag</c-></c-><c- o><c- o>*</c-></c-><c- p><c- p>,</c-></c-> <c- n><c- n>memory_order</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->

<div class="ins">  <c- b><c- b>void</c-></c-> <c- nf><c- nf>atomic_flag_wait</c-></c-><c- p><c- p>(</c-></c-><c- k><c- k>const</c-></c-> <c- k><c- k>volatile</c-></c-> <c- n><c- n>atomic_flag</c-></c-><c- o><c- o>*</c-></c-><c- p><c- p>,</c-></c-> <c- b><c- b>bool</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
  <c- b><c- b>void</c-></c-> <c- nf><c- nf>atomic_flag_wait</c-></c-><c- p><c- p>(</c-></c-><c- k><c- k>const</c-></c-> <c- n><c- n>atomic_flag</c-></c-><c- o><c- o>*</c-></c-><c- p><c- p>,</c-></c-> <c- b><c- b>bool</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
  <c- b><c- b>void</c-></c-> <c- nf><c- nf>atomic_flag_wait_explicit</c-></c-><c- p><c- p>(</c-></c-><c- k><c- k>const</c-></c-> <c- k><c- k>volatile</c-></c-> <c- n><c- n>atomic_flag</c-></c-><c- o><c- o>*</c-></c-><c- p><c- p>,</c-></c-> 
                                 <c- b><c- b>bool</c-></c-><c- p><c- p>,</c-></c-> <c- n><c- n>memory_order</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
  <c- b><c- b>void</c-></c-> <c- nf><c- nf>atomic_flag_wait_explicit</c-></c-><c- p><c- p>(</c-></c-><c- k><c- k>const</c-></c-> <c- n><c- n>atomic_flag</c-></c-><c- o><c- o>*</c-></c-><c- p><c- p>,</c-></c-> 
                                 <c- b><c- b>bool</c-></c-><c- p><c- p>,</c-></c-> <c- n><c- n>memory_order</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
  <c- b><c- b>void</c-></c-> <c- nf><c- nf>atomic_flag_notify_one</c-></c-><c- p><c- p>(</c-></c-><c- k><c- k>volatile</c-></c-> <c- n><c- n>atomic_flag</c-></c-><c- o><c- o>*</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
  <c- b><c- b>void</c-></c-> <c- nf><c- nf>atomic_flag_notify_one</c-></c-><c- p><c- p>(</c-></c-><c- n><c- n>atomic_flag</c-></c-><c- o><c- o>*</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
  <c- b><c- b>void</c-></c-> <c- nf><c- nf>atomic_flag_notify_all</c-></c-><c- p><c- p>(</c-></c-><c- k><c- k>volatile</c-></c-> <c- n><c- n>atomic_flag</c-></c-><c- o><c- o>*</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>const</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
  <c- b><c- b>void</c-></c-> <c- nf><c- nf>atomic_flag_notify_all</c-></c-><c- p><c- p>(</c-></c-><c- n><c- n>atomic_flag</c-></c-><c- o><c- o>*</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>const</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c-></div>
  <c- cp><c- cp>#define ATOMIC_FLAG_INIT </c-></c-><i><c- cp><c- cp>see below</c-></c-></i>
<c- p><c- p>}</c-></c->
</code></pre>
    <div class="numbered"> The <code class="highlight"><c- n>atomic_flag</c-></code> type provides the classic test-and-set functionality. It has two states, set and clear. </div>
    <div class="numbered"> Operations on an object of type <code class="highlight"><c- n>atomic_flag</c-></code> shall be lock-free.
[ <em>Note:</em> Hence the operations should also be address-free. — <em>end note</em> ] </div>
    <div class="numbered"> The <code class="highlight"><c- n>atomic_flag</c-></code> type is a standard-layout struct. It has a trivial default
constructor and a trivial destructor. </div>
    <div class="numbered">
      The macro <code class="highlight"><c- n>ATOMIC_FLAG_INIT</c-></code> shall be defined in such a way that it can be used to initialize an object of type <code class="highlight"><c- n>atomic_flag</c-></code> to the clear state.
The macro can be used in the form: 
<pre class="highlight"><c- n>atomic_flag</c-> <c- n>guard</c-> <c- o>=</c-> <c- n>ATOMIC_FLAG_INIT</c-><c- p>;</c-></pre>
     <p>It is unspecified whether the macro can be used in other initialization contexts.
For a complete static-duration object, that initialization shall be static.
Unless initialized with <code class="highlight"><c- n>ATOMIC_FLAG_INIT</c-></code>, it is unspecified whether an <code class="highlight"><c- n>atomic_flag</c-></code> object has an initial state of set or clear.</p>
    </div>
    <div class="ins">
<pre class="highlight"><c- b>bool</c-> <c- nf>atomic_flag_test</c-><c- p>(</c-><c- k>const</c-> <c- k>volatile</c-> <c- n>atomic_flag</c-><c- o>*</c-> <c- n>object</c-><c- p>)</c-> <c- k>noexcept</c-><c- p>;</c->
<c- b>bool</c-> <c- nf>atomic_flag_test</c-><c- p>(</c-><c- k>const</c-> <c- n>atomic_flag</c-><c- o>*</c-> <c- n>object</c-><c- p>)</c-> <c- k>noexcept</c-><c- p>;</c->
<c- b>bool</c-> <c- nf>atomic_flag_test_explicit</c-><c- p>(</c-><c- k>const</c-> <c- k>volatile</c-> <c- n>atomic_flag</c-><c- o>*</c-> <c- n>object</c-><c- p>,</c->
                               <c- n>memory_order</c-> <c- n>order</c-><c- p>)</c-> <c- k>noexcept</c-><c- p>;</c->
<c- b>bool</c-> <c- nf>atomic_flag_test_explicit</c-><c- p>(</c-><c- k>const</c-> <c- n>atomic_flag</c-><c- o>*</c-> <c- n>object</c-><c- p>,</c->
                               <c- n>memory_order</c-> <c- n>order</c-><c- p>)</c-> <c- k>noexcept</c-><c- p>;</c->
<c- b>bool</c-> <c- n>atomic_flag</c-><c- o>::</c-><c- n>test</c-><c- p>(</c-><c- n>memory_order</c-> <c- n>order</c-> <c- o>=</c->
                         <c- n>memory_order</c-><c- o>::</c-><c- n>seq_cst</c-><c- p>)</c-> <c- k>const</c-> <c- k>volatile</c-> <c- k>noexcept</c-><c- p>;</c->
<c- b>bool</c-> <c- n>atomic_flag</c-><c- o>::</c-><c- n>test</c-><c- p>(</c-><c- n>memory_order</c-> <c- n>order</c-> <c- o>=</c->
                         <c- n>memory_order</c-><c- o>::</c-><c- n>seq_cst</c-><c- p>)</c-> <c- k>const</c-> <c- k>noexcept</c-><c- p>;</c->
</pre>
     <div class="numbered"> For <code class="highlight"><c- n>atomic_flag_test</c-></code>, let <code class="highlight"><c- n>order</c-></code> be <code class="highlight"><c- n>memory_order</c-><c- o>::</c-><c- n>seq_cst</c-></code>. </div>
     <div class="numbered"> <em>Expects:</em> <code class="highlight"><c- n>order</c-></code> is neither <code class="highlight"><c- n>memory_order</c-><c- o>::</c-><c- n>release</c-></code> nor <code class="highlight"><c- n>memory_order</c-><c- o>::</c-><c- n>acq_rel</c-></code>. </div>
     <div class="numbered"> <em>Effects:</em> Memory is affected according to the value of <code class="highlight"><c- n>order</c-></code>. </div>
     <div class="numbered"> <em>Returns:</em> Atomically returns the value pointed to by <code class="highlight"><c- n>object</c-></code> or <code class="highlight"><c- k>this</c-></code>. </div>
    </div>
<pre class="highlight"><c- b>bool</c-> <c- nf>atomic_flag_test_and_set</c-><c- p>(</c-><c- k>volatile</c-> <c- n>atomic_flag</c-><c- o>*</c-> <c- n>object</c-><c- p>)</c-> <c- k>noexcept</c-><c- p>;</c->
<c- b>bool</c-> <c- nf>atomic_flag_test_and_set</c-><c- p>(</c-><c- n>atomic_flag</c-><c- o>*</c-> <c- n>object</c-><c- p>)</c-> <c- k>noexcept</c-><c- p>;</c->
<c- b>bool</c-> <c- nf>atomic_flag_test_and_set_explicit</c-><c- p>(</c-><c- k>volatile</c-> <c- n>atomic_flag</c-><c- o>*</c-> <c- n>object</c-><c- p>,</c->
                                       <c- n>memory_order</c-> <c- n>order</c-><c- p>)</c-> <c- k>noexcept</c-><c- p>;</c->
<c- b>bool</c-> <c- nf>atomic_flag_test_and_set_explicit</c-><c- p>(</c-><c- n>atomic_flag</c-><c- o>*</c-> <c- n>object</c-><c- p>,</c->
                                       <c- n>memory_order</c-> <c- n>order</c-><c- p>)</c-> <c- k>noexcept</c-><c- p>;</c->
<c- b>bool</c-> <c- n>atomic_flag</c-><c- o>::</c-><c- n>test_and_set</c-><c- p>(</c-><c- n>memory_order</c-> <c- n>order</c-> <c- o>=</c->
                                <c- n>memory_order</c-><c- o>::</c-><c- n>seq_cst</c-><c- p>)</c-> <c- k>volatile</c-> <c- k>noexcept</c-><c- p>;</c->
<c- b>bool</c-> <c- n>atomic_flag</c-><c- o>::</c-><c- n>test_and_set</c-><c- p>(</c-><c- n>memory_order</c-> <c- n>order</c-> <c- o>=</c->
                                 <c- n>memory_order</c-><c- o>::</c-><c- n>seq_cst</c-><c- p>)</c-> <c- k>noexcept</c-><c- p>;</c->
</pre>
    <div class="numbered"> <em>Effects:</em> Atomically sets the value pointed to by <code class="highlight"><c- n>object</c-></code> or by <code class="highlight"><c- k>this</c-></code> to <code class="highlight">true</code>.
Memory is affected according to the value of <code class="highlight"><c- n>order</c-></code>.
These operations are atomic read-modify-write operations (4.7). </div>
    <div class="numbered"> <em>Returns:</em> Atomically, the value of the object immediately before the effects. </div>
<pre class="highlight"><c- b>void</c-> <c- nf>atomic_flag_clear</c-><c- p>(</c-><c- k>volatile</c-> <c- n>atomic_flag</c-><c- o>*</c-> <c- n>object</c-><c- p>)</c-> <c- k>noexcept</c-><c- p>;</c->
<c- b>void</c-> <c- nf>atomic_flag_clear</c-><c- p>(</c-><c- n>atomic_flag</c-><c- o>*</c-> <c- n>object</c-><c- p>)</c-> <c- k>noexcept</c-><c- p>;</c->
<c- b>void</c-> <c- nf>atomic_flag_clear_explicit</c-><c- p>(</c-><c- k>volatile</c-> <c- n>atomic_flag</c-><c- o>*</c-> <c- n>object</c-><c- p>,</c->
                                <c- n>memory_order</c-> <c- n>order</c-><c- p>)</c-> <c- k>noexcept</c-><c- p>;</c->
<c- b>void</c-> <c- nf>atomic_flag_clear_explicit</c-><c- p>(</c-><c- n>atomic_flag</c-><c- o>*</c-> <c- n>object</c-><c- p>,</c->
                                <c- n>memory_order</c-> <c- n>order</c-><c- p>)</c-> <c- k>noexcept</c-><c- p>;</c->
<c- b>void</c-> <c- n>atomic_flag</c-><c- o>::</c-><c- n>clear</c-><c- p>(</c-><c- n>memory_order</c-> <c- n>order</c-> <c- o>=</c->
                          <c- n>memory_order</c-><c- o>::</c-><c- n>seq_cst</c-><c- p>)</c-> <c- k>volatile</c-> <c- k>noexcept</c-><c- p>;</c->
<c- b>void</c-> <c- n>atomic_flag</c-><c- o>::</c-><c- n>clear</c-><c- p>(</c-><c- n>memory_order</c-> <c- n>order</c-> <c- o>=</c-> 
                          <c- n>memory_order</c-><c- o>::</c-><c- n>seq_cst</c-><c- p>)</c-> <c- k>noexcept</c-><c- p>;</c->
</pre>
    <p><em>Expects:</em> <code class="highlight"><c- n>order</c-></code> is neither <code class="highlight"><c- n>memory_order</c-><c- o>::</c-><c- n>consume</c-></code>, <code class="highlight"><c- n>memory_order</c-><c- o>::</c-><c- n>acquire</c-></code>, nor <code class="highlight"><c- n>memory_order</c-><c- o>::</c-><c- n>acq_rel</c-></code>.</p>
    <p><em>Effects:</em> Atomically sets the value pointed to by <code class="highlight"><c- n>object</c-></code> or by <code class="highlight"><c- k>this</c-></code> to <code class="highlight">false</code>. Memory is affected according to the value of <code class="highlight"><c- n>order</c-></code>.</p>
    <div class="ins">
<pre class="highlight"><c- b>void</c-> <c- nf>atomic_flag_wait</c-><c- p>(</c-><c- k>const</c-> <c- k>volatile</c-> <c- n>atomic_flag</c-><c- o>*</c-> <c- n>object</c-><c- p>,</c-> <c- b>bool</c-> <c- n>old</c-><c- p>)</c-> <c- k>noexcept</c-><c- p>;</c->
<c- b>void</c-> <c- nf>atomic_flag_wait</c-><c- p>(</c-><c- k>const</c-> <c- n>atomic_flag</c-><c- o>*</c-> <c- n>object</c-><c- p>,</c-> <c- b>bool</c-> <c- n>old</c-><c- p>)</c-> <c- k>noexcept</c-><c- p>;</c->
<c- b>void</c-> <c- nf>atomic_flag_wait_explicit</c-><c- p>(</c-><c- k>const</c-> <c- k>volatile</c-> <c- n>atomic_flag</c-><c- o>*</c-> <c- n>object</c-><c- p>,</c->
                               <c- b>bool</c-> <c- n>old</c-><c- p>,</c-> <c- n>memory_order</c-> <c- n>order</c-><c- p>)</c-> <c- k>noexcept</c-><c- p>;</c->
<c- b>void</c-> <c- nf>atomic_flag_wait_explicit</c-><c- p>(</c-><c- k>const</c-> <c- n>atomic_flag</c-><c- o>*</c-> <c- n>object</c-><c- p>,</c->
                               <c- b>bool</c-> <c- n>old</c-><c- p>,</c-> <c- n>memory_order</c-> <c- n>order</c-><c- p>)</c-> <c- k>noexcept</c-><c- p>;</c->
<c- b>void</c-> <c- n>atomic_flag</c-><c- o>::</c-><c- n>wait</c-><c- p>(</c-><c- b>bool</c-> <c- n>old</c-><c- p>,</c-> <c- n>memory_order</c-> <c- n>order</c-> <c- o>=</c->
                         <c- n>memory_order</c-><c- o>::</c-><c- n>seq_cst</c-><c- p>)</c-> <c- k>const</c-> <c- k>volatile</c-> <c- k>noexcept</c-><c- p>;</c->
<c- b>void</c-> <c- n>atomic_flag</c-><c- o>::</c-><c- n>wait</c-><c- p>(</c-><c- b>bool</c-> <c- n>old</c-><c- p>,</c-> <c- n>memory_order</c-> <c- n>order</c-> <c- o>=</c->
                         <c- n>memory_order</c-><c- o>::</c-><c- n>seq_cst</c-><c- p>)</c-> <c- k>const</c-> <c- k>noexcept</c-><c- p>;</c->
</pre>
     <div class="numbered"> For <code class="highlight"><c- n>atomic_flag_wait</c-></code>, let <code class="highlight"><c- n>order</c-></code> be <code class="highlight"><c- n>memory_order</c-><c- o>::</c-><c- n>seq_cst</c-></code>.  Let <code class="highlight"><c- n>flag</c-></code> be <code class="highlight"><c- n>object</c-></code> for the non-member functions and <code class="highlight"><c- k>this</c-></code> for the member functions. </div>
     <div class="numbered"> <em>Expects:</em> <code class="highlight"><c- n>order</c-></code> is neither <code class="highlight"><c- n>memory_order</c-><c- o>::</c-><c- n>release</c-></code> nor <code class="highlight"><c- n>memory_order</c-><c- o>::</c-><c- n>acq_rel</c-></code>. </div>
     <div class="numbered">
       <em>Effects:</em> Repeatedly performs the following steps, in order: 
      <ul>
       <li data-md>
        <p>Evaluates <code class="highlight"><c- n>flag</c-><c- o>-></c-><c- n>test</c-><c- p>(</c-><c- n>order</c-><c- p>)</c-> <c- o>!=</c-> <c- n>old</c-></code>.</p>
       <li data-md>
        <p>If the result of that evaluation is <code class="highlight">true</code>, returns.</p>
       <li data-md>
        <p>Blocks until it is unblocked by an atomic notifying operation or is unblocked spuriously.</p>
      </ul>
     </div>
     <div class="numbered"> <em>Remarks:</em> This function is an atomic waiting operation ([<strong>atomics.wait</strong>]). </div>
<pre class="highlight"><c- b>void</c-> <c- nf>atomic_flag_notify_one</c-><c- p>(</c-><c- k>volatile</c-> <c- n>atomic_flag</c-><c- o>*</c-> <c- n>object</c-><c- p>)</c-> <c- k>noexcept</c-><c- p>;</c->
<c- b>void</c-> <c- nf>atomic_flag_notify_one</c-><c- p>(</c-><c- n>atomic_flag</c-><c- o>*</c-> <c- n>object</c-><c- p>)</c-> <c- k>noexcept</c-><c- p>;</c->
<c- b>void</c-> <c- n>atomic_flag</c-><c- o>::</c-><c- n>notify_one</c-><c- p>()</c-> <c- k>volatile</c-> <c- k>noexcept</c-><c- p>;</c->
<c- b>void</c-> <c- n>atomic_flag</c-><c- o>::</c-><c- n>notify_one</c-><c- p>()</c-> <c- k>noexcept</c-><c- p>;</c->
</pre>
     <div class="numbered"> <em>Effects:</em> Unblocks the execution of at least one atomic waiting operation that is eligible to be unblocked ([<strong>atomics.wait</strong>]) by this call, if any such atomic waiting operations exist. </div>
     <div class="numbered"> <em>Remarks:</em> This function is an atomic notifying operation ([<strong>atomics.wait</strong>]). </div>
<pre class="highlight"><c- b>void</c-> <c- nf>atomic_flag_notify_all</c-><c- p>(</c-><c- k>volatile</c-> <c- n>atomic_flag</c-><c- o>*</c-> <c- n>object</c-><c- p>)</c-> <c- k>const</c-> <c- k>noexcept</c-><c- p>;</c->
<c- b>void</c-> <c- nf>atomic_flag_notify_all</c-><c- p>(</c-><c- n>atomic_flag</c-><c- o>*</c-> <c- n>object</c-><c- p>)</c-> <c- k>const</c-> <c- k>noexcept</c-><c- p>;</c->
<c- b>void</c-> <c- n>atomic_flag</c-><c- o>::</c-><c- n>notify_all</c-><c- p>()</c-> <c- k>volatile</c-> <c- k>noexcept</c-><c- p>;</c->
<c- b>void</c-> <c- n>atomic_flag</c-><c- o>::</c-><c- n>notify_all</c-><c- p>()</c-> <c- k>noexcept</c-><c- p>;</c->
</pre>
     <div class="numbered"> <em>Effects:</em> Unblocks the execution of all atomic waiting operations that are eligible to be unblocked ([<strong>atomics.wait</strong>]) by this call. </div>
     <div class="numbered"> <em>Remarks:</em> This function is an atomic notifying operation ([<strong>atomics.wait</strong>]). </div>
    </div>
   </blockquote>
   <p>Modify Table 134 "Thread support library summary" in <a href="http://eel.is/c++draft/thread.general">[<strong>thread.general</strong>]</a> as follows:</p>
   <blockquote>
    <div style="text-align: center;"> Table 134 — Thread support library summary </div>
    <table border="1" style="margin: auto;">
     <tbody>
      <tr>
       <th>
       <th>Subclause
       <th>Header(s)
      <tr>
       <td>32.2
       <td>Requirements
       <td>
      <tr>
       <td>32.3
       <td>Threads
       <td><code class="highlight"><c- o>&lt;</c-><c- kr>thread</c-><c- o>></c-></code>
      <tr>
       <td>32.4
       <td>Mutual exclusion
       <td><code class="highlight"><c- o>&lt;</c-><c- n>mutex</c-><c- o>></c-></code> <code class="highlight"><c- o>&lt;</c-><c- n>shared_mutex</c-><c- o>></c-></code>
      <tr>
       <td>32.5
       <td>Condition variables
       <td><code class="highlight"><c- o>&lt;</c-><c- n>condition_variable</c-><c- o>></c-></code>
      <tr class="ins">
       <td>32.�
       <td>Semaphores
       <td><code class="highlight"><c- o>&lt;</c-><c- n>semaphore</c-><c- o>></c-></code>
      <tr class="ins">
       <td>32.�
       <td>Latches and barriers
       <td><code class="highlight"><c- o>&lt;</c-><c- n>latch</c-><c- o>></c-></code> <code class="highlight"><c- o>&lt;</c-><c- n>barrier</c-><c- o>></c-></code>
      <tr>
       <td>32.6
       <td>Futures
       <td><code class="highlight"><c- o>&lt;</c-><c- n>future</c-><c- o>></c-></code>
    </table>
   </blockquote>
   <p>Add two new subclauses after <a href="http://eel.is/c++draft/thread.condition">[<strong>thread.condition</strong>]</a>:</p>
   <blockquote class="ins">
     <b>32.� Semaphores <span style="float: right;">[thread.semaphore]</span></b> 
    <div class="numbered"> Semaphores are lightweight synchronization primitives used to constrain concurrent access to a shared resource. They are widely used to implement other synchronization primitives and, whenever both are applicable, can be more efficient than condition variables. </div>
    <div class="numbered"> A counting semaphore is a semaphore object that models a non-negative resource count. A binary semaphore is a semaphore object that has only two states. A binary semaphore should be more efficient than the default implementation of a counting semaphore with a unit resource count. </div>
   </blockquote>
   <blockquote class="ins">
     <b>32.�.1 Header <code class="highlight"><c- o>&lt;</c-><c- n>semaphore</c-><c- o>></c-></code> synopsis <span style="float: right;">[thread.semaphore.syn]</span></b> 
<pre class="highlight"><code class="highlight"><c- k><c- k>namespace</c-></c-> <c- n><c- n>std</c-></c-> <c- p><c- p>{</c-></c->  
  <c- k><c- k>template</c-></c-><c- o><c- o>&lt;</c-></c-><c- b><c- b>ptrdiff_t</c-></c-> <c- n><c- n>least_max_value</c-></c-> <c- o><c- o>=</c-></c-> <i><c- n><c- n>implementation</c-></c-><c- o><c- o>-</c-></c-><c- n><c- n>defined</c-></c-></i><c- o><c- o>></c-></c->
    <c- k><c- k>class</c-></c-> <c- nc><c- nc>counting_semaphore</c-></c-><c- p><c- p>;</c-></c->

  <c- k><c- k>using</c-></c-> <c- n><c- n>binary_semaphore</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>counting_semaphore</c-></c-><c- o><c- o>&lt;</c-></c-><c- mi><c- mi>1</c-></c-><c- o><c- o>></c-></c-><c- p><c- p>;</c-></c->
<c- p><c- p>}</c-></c->
</code></pre>
   </blockquote>
   <blockquote class="ins">
     <b>32.�.2 Class template <code class="highlight"><c- n>counting_semaphore</c-></code> <span style="float: right;">[thread.semaphore.counting.class]</span></b> 
<pre class="highlight"><code class="highlight"><c- k><c- k>namespace</c-></c-> <c- n><c- n>std</c-></c-> <c- p><c- p>{</c-></c->
  <c- k><c- k>template</c-></c-><c- o><c- o>&lt;</c-></c-><c- b><c- b>ptrdiff_t</c-></c-> <c- n><c- n>least_max_value</c-></c-> <c- o><c- o>=</c-></c-> <i><c- n><c- n>implementation</c-></c-><c- o><c- o>-</c-></c-><c- n><c- n>defined</c-></c-></i><c- o><c- o>></c-></c->
  <c- k><c- k>class</c-></c-> <c- nc><c- nc>counting_semaphore</c-></c-> <c- p><c- p>{</c-></c->
  <c- k><c- k>public</c-></c-><c- o><c- o>:</c-></c->
    <c- k><c- k>static</c-></c-> <c- k><c- k>constexpr</c-></c-> <c- b><c- b>ptrdiff_t</c-></c-> <c- n><c- n>max</c-></c-><c- p><c- p>()</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->

    <c- k><c- k>constexpr</c-></c-> <c- k><c- k>explicit</c-></c-> <c- nf><c- nf>counting_semaphore</c-></c-><c- p><c- p>(</c-></c-><c- b><c- b>ptrdiff_t</c-></c-> <c- n><c- n>desired</c-></c-><c- p><c- p>);</c-></c->
    <c- o><c- o>~</c-></c-><c- n><c- n>counting_semaphore</c-></c-><c- p><c- p>();</c-></c->

    <c- n><c- n>counting_semaphore</c-></c-><c- p><c- p>(</c-></c-><c- k><c- k>const</c-></c-> <c- n><c- n>counting_semaphore</c-></c-><c- o><c- o>&amp;</c-></c-><c- p><c- p>)</c-></c-> <c- o><c- o>=</c-></c-> <c- k><c- k>delete</c-></c-><c- p><c- p>;</c-></c->
    <c- n><c- n>counting_semaphore</c-></c-><c- o><c- o>&amp;</c-></c-> <c- k><c- k>operator</c-></c-><c- o><c- o>=</c-></c-><c- p><c- p>(</c-></c-><c- k><c- k>const</c-></c-> <c- n><c- n>counting_semaphore</c-></c-><c- o><c- o>&amp;</c-></c-><c- p><c- p>)</c-></c-> <c- o><c- o>=</c-></c-> <c- k><c- k>delete</c-></c-><c- p><c- p>;</c-></c->

    <c- b><c- b>void</c-></c-> <c- nf><c- nf>release</c-></c-><c- p><c- p>(</c-></c-><c- b><c- b>ptrdiff_t</c-></c-> <c- n><c- n>update</c-></c-> <c- o><c- o>=</c-></c-> <c- mi><c- mi>1</c-></c-><c- p><c- p>);</c-></c->
    <c- b><c- b>void</c-></c-> <c- nf><c- nf>acquire</c-></c-><c- p><c- p>();</c-></c->
    <c- b><c- b>bool</c-></c-> <c- nf><c- nf>try_acquire</c-></c-><c- p><c- p>()</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- k><c- k>template</c-></c-><c- o><c- o>&lt;</c-></c-><c- k><c- k>class</c-></c-> <c- nc><c- nc>Rep</c-></c-><c- p><c- p>,</c-></c-> <c- k><c- k>class</c-></c-> <c- nc><c- nc>Period</c-></c-><c- o><c- o>></c-></c->
      <c- b><c- b>bool</c-></c-> <c- n><c- n>try_acquire_for</c-></c-><c- p><c- p>(</c-></c-><c- k><c- k>const</c-></c-> <c- n><c- n>chrono</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>duration</c-></c-><c- o><c- o>&lt;</c-></c-><c- n><c- n>Rep</c-></c-><c- p><c- p>,</c-></c-> <c- n><c- n>Period</c-></c-><c- o><c- o>>&amp;</c-></c-> <c- n><c- n>rel_time</c-></c-><c- p><c- p>);</c-></c->
    <c- k><c- k>template</c-></c-><c- o><c- o>&lt;</c-></c-><c- k><c- k>class</c-></c-> <c- nc><c- nc>Clock</c-></c-><c- p><c- p>,</c-></c-> <c- k><c- k>class</c-></c-> <c- nc><c- nc>Duration</c-></c-><c- o><c- o>></c-></c->
      <c- b><c- b>bool</c-></c-> <c- n><c- n>try_acquire_until</c-></c-><c- p><c- p>(</c-></c-><c- k><c- k>const</c-></c-> <c- n><c- n>chrono</c-></c-><c- o><c- o>::</c-></c-><c- n><c- n>time_point</c-></c-><c- o><c- o>&lt;</c-></c-><c- n><c- n>Clock</c-></c-><c- p><c- p>,</c-></c-> <c- n><c- n>Duration</c-></c-><c- o><c- o>>&amp;</c-></c-> <c- n><c- n>abs_time</c-></c-><c- p><c- p>);</c-></c->

  <c- k><c- k>private</c-></c-><c- o><c- o>:</c-></c->
    <c- b><c- b>ptrdiff_t</c-></c-> <c- n><c- n>counter</c-></c-><c- p><c- p>;</c-></c-> <i><c- c1><c- c1>// exposition only</c-></c-></i>
  <c- p><c- p>};</c-></c->
<c- p><c- p>}</c-></c->
</code></pre>
    <div class="numbered"> Class <code class="highlight"><c- n>counting_semaphore</c-></code> maintains an internal counter that is initialized when the semaphore is created. The counter is decremented when a thread acquires the semaphore, and is incremented when a thread releases the semaphore.  If a thread tries to acquire the semaphore when the counter is zero, the thread will block until another thread increments the counter by releasing the semaphore. </div>
    <div class="numbered"> <code class="highlight"><c- n>least_max_value</c-></code> shall be non-negative; otherwise the program is ill-formed. </div>
    <div class="numbered"> Concurrent invocations of the member functions of <code class="highlight"><c- n>counting_semaphore</c-></code>, other than its destructor, do not introduce data races. </div>
<pre class="highlight"><c- k>static</c-> <c- k>constexpr</c-> <c- b>ptrdiff_t</c-> <c- nf>max</c-><c- p>()</c-> <c- k>noexcept</c-><c- p>;</c->
</pre>
    <div class="numbered"> <em>Returns:</em> The maximum value of <code class="highlight"><c- n>counter</c-></code>. This value is greater than or equal to <code class="highlight"><c- n>least_max_value</c-></code>. </div>
<pre class="highlight"><c- k>constexpr</c-> <c- k>explicit</c-> <c- nf>counting_semaphore</c-><c- p>(</c-><c- b>ptrdiff_t</c-> <c- n>desired</c-><c- p>);</c->
</pre>
    <div class="numbered"> <em>Expects:</em> <code class="highlight"><c- n>desired</c-> <c- o>>=</c-> <c- mi>0</c-></code> is <code class="highlight">true</code>, and <code class="highlight"><c- n>desired</c-> <c- o>&lt;=</c-> <c- n>max</c-><c- p>()</c-></code> is <code class="highlight">true</code>. </div>
    <div class="numbered"> <em>Effects:</em> Initializes <code class="highlight"><c- n>counter</c-></code> with <code class="highlight"><c- n>desired</c-></code>. </div>
    <div class="numbered"> <em>Throws:</em> Nothing. </div>
<pre class="highlight"><c- b>void</c-> <c- nf>release</c-><c- p>(</c-><c- b>ptrdiff_t</c-> <c- n>update</c-> <c- o>=</c-> <c- mi>1</c-><c- p>);</c->
</pre>
    <div class="numbered"> <em>Expects:</em> <code class="highlight"><c- n>update</c-> <c- o>>=</c-> <c- mi>0</c-></code> is <code class="highlight">true</code>, and <code class="highlight"><c- n>update</c-> <c- o>&lt;=</c-> <c- n>max</c-><c- p>()</c-> <c- o>-</c-> <c- n>counter</c-></code> is <code class="highlight">true</code>. </div>
    <div class="numbered"> <em>Effects:</em> Atomically execute <code class="highlight"><c- n>counter</c-> <c- o>+=</c-> <c- n>update</c-></code>. Then, unblock any threads that are waiting for <code class="highlight"><c- n>counter</c-></code> to be greater than zero. </div>
    <div class="numbered"> <em>Synchronization:</em> Strongly happens before invocations of <code class="highlight"><c- n>try_acquire</c-></code> that observe the result of the effects. </div>
    <div class="numbered"> <em>Throws:</em> <code class="highlight"><c- n>system_error</c-></code> when an exception is required (<a href="http://eel.is/c++draft/thread.req.exception">[<strong>thread.req.exception</strong>]</a>). </div>
    <div class="numbered"> <em>Error conditions:</em> Any of the error conditions allowed for mutex types (<a href="http://eel.is/c++draft/thread.mutex.requirements.mutex">[<strong>thread.mutex.requirements.mutex</strong>]</a>). </div>
<pre class="highlight"><c- b>bool</c-> <c- nf>try_acquire</c-><c- p>()</c-> <c- k>noexcept</c-><c- p>;</c->
</pre>
    <div class="numbered">
      <em>Effects:</em> 
     <ul>
      <li data-md>
       <p>With low probability, returns immediately. An implementation should ensure that <code class="highlight"><c- n>try_acquire</c-></code> does not consistently return <code class="highlight">false</code> in the absence of contending acquisitions.</p>
      <li data-md>
       <p>Otherwise, atomically check whether <code class="highlight"><c- n>counter</c-></code> is greater than zero and, if so, decrement <code class="highlight"><c- n>counter</c-></code> by one.</p>
     </ul>
    </div>
    <div class="numbered"> <em>Returns:</em> <code class="highlight">true</code> if <code class="highlight"><c- n>counter</c-></code> was decremented, otherwise <code class="highlight">false</code>. </div>
<pre class="highlight"><c- b>void</c-> <c- nf>acquire</c-><c- p>();</c->
</pre>
    <div class="numbered">
      <em>Effects:</em> Repeatedly performs the following steps, in order: 
     <ul>
      <li data-md>
       <p>Evaluates <code class="highlight"><c- n>try_acquire</c-></code>. If the result is <code class="highlight">true</code>, returns.</p>
      <li data-md>
       <p>Blocks on <code class="highlight"><c- o>*</c-><c- k>this</c-></code> until <code class="highlight"><c- n>counter</c-></code> is greater than zero.</p>
     </ul>
    </div>
    <div class="numbered"> <em>Throws:</em> <code class="highlight"><c- n>system_error</c-></code> when an exception is required (<a href="http://eel.is/c++draft/thread.req.exception">[<strong>thread.req.exception</strong>]</a>). </div>
    <div class="numbered"> <em>Error conditions:</em> Any of the error conditions allowed for mutex types (<a href="http://eel.is/c++draft/thread.mutex.requirements.mutex">[<strong>thread.mutex.requirements.mutex</strong>]</a>). </div>
<pre class="highlight"><c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>Rep</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Period</c-><c- o>></c->
  <c- b>bool</c-> <c- n>try_acquire_for</c-><c- p>(</c-><c- k>const</c-> <c- n>chrono</c-><c- o>::</c-><c- n>duration</c-><c- o>&lt;</c-><c- n>Rep</c-><c- p>,</c-> <c- n>Period</c-><c- o>>&amp;</c-> <c- n>rel_time</c-><c- p>);</c->
<c- k>template</c-><c- o>&lt;</c-><c- k>class</c-> <c- nc>Clock</c-><c- p>,</c-> <c- k>class</c-> <c- nc>Duration</c-><c- o>></c->
  <c- b>bool</c-> <c- n>try_acquire_until</c-><c- p>(</c-><c- k>const</c-> <c- n>chrono</c-><c- o>::</c-><c- n>time_point</c-><c- o>&lt;</c-><c- n>Clock</c-><c- p>,</c-> <c- n>Duration</c-><c- o>>&amp;</c-> <c- n>abs_time</c-><c- p>);</c->
</pre>
    <div class="numbered">
      <em>Effects:</em> Repeatedly performs the following steps, in order: 
     <ul>
      <li data-md>
       <p>Evaluates <code class="highlight"><c- n>try_acquire</c-></code>. If the result is <code class="highlight">true</code>, returns <code class="highlight">true</code>.</p>
      <li data-md>
       <p>Blocks on <code class="highlight"><c- o>*</c-><c- k>this</c-></code> until <code class="highlight"><c- n>counter</c-></code> is greater than zero or until the timeout expires.  If it is unblocked by the timeout expiring, returns <code class="highlight">false</code>.</p>
     </ul>
     <p>The timeout expires (<a href="http://eel.is/c++draft/thread.req.timing">[<strong>thread.req.timing</strong>]</a>)
when the current time is after <code class="highlight"><c- n>abs_time</c-></code> (for <code class="highlight"><c- n>try_acquire_until</c-></code>) or when at least <code class="highlight"><c- n>rel_time</c-></code> has passed from the start of the function (for <code class="highlight"><c- n>try_acquire_for</c-></code>).</p>
    </div>
    <div class="numbered"> <em>Throws:</em> Timeout-related exceptions (<a href="http://eel.is/c++draft/thread.req.timing">[<strong>thread.req.timing</strong>]</a>), or <code class="highlight"><c- n>system_error</c-></code> when a non-timeout-related exception is required (<a href="http://eel.is/c++draft/thread.req.exception">[<strong>thread.req.exception</strong>]</a>). </div>
    <div class="numbered"> <em>Error conditions:</em> Any of the error conditions allowed for mutex types (<a href="http://eel.is/c++draft/thread.mutex.requirements.mutex">[<strong>thread.mutex.requirements.mutex</strong>]</a>). </div>
   </blockquote>
   <blockquote class="ins">
     <b>32.� Coordination Types <span style="float: right;">[thread.coord]</span></b> 
    <div class="numbered"> This subclause describes various concepts related to thread coordination, and defines the coordination types <code class="highlight"><c- n>latch</c-></code> and <code class="highlight"><c- n>barrier</c-></code>. These types facilitate concurrent computation performed by a number of threads. </div>
   </blockquote>
   <blockquote class="ins">
     <b>32.�.1 Latches <span style="float: right;">[thread.coord.latch]</span></b> 
    <div class="numbered"> A latch is a thread coordination mechanism that allows any number of threads to block until an expected number of threads arrive at the latch (via the <code class="highlight"><c- n>count_down</c-></code> function).  The expected count is set when the latch is created.  An individual latch is a single-use object; once the expected count has been reached, the latch cannot be reused. </div>
   </blockquote>
   <blockquote class="ins">
     <b>32.�.1.1 Header <code class="highlight"><c- o>&lt;</c-><c- n>latch</c-><c- o>></c-></code> synopsis <span style="float: right;">[thread.coord.latch.syn]</span></b> 
<pre class="highlight"><c- k>namespace</c-> <c- n>std</c-> <c- p>{</c->
  <c- k>class</c-> <c- nc>latch</c-><c- p>;</c->
<c- p>}</c->
</pre>
   </blockquote>
   <blockquote class="ins">
     <b>32.�.1.2 Class <code class="highlight"><c- n>latch</c-></code> <span style="float: right;">[thread.coord.latch.class]</span></b> 
<pre class="highlight"><code class="highlight"><c- k><c- k>namespace</c-></c-> <c- n><c- n>std</c-></c-> <c- p><c- p>{</c-></c->
  <c- k><c- k>class</c-></c-> <c- nc><c- nc>latch</c-></c-> <c- p><c- p>{</c-></c->
  <c- k><c- k>public</c-></c-><c- o><c- o>:</c-></c->
    <c- k><c- k>constexpr</c-></c-> <c- k><c- k>explicit</c-></c-> <c- n><c- n>latch</c-></c-><c- p><c- p>(</c-></c-><c- b><c- b>ptrdiff_t</c-></c-> <c- n><c- n>expected</c-></c-><c- p><c- p>);</c-></c->
    <c- o><c- o>~</c-></c-><c- n><c- n>latch</c-></c-><c- p><c- p>();</c-></c->

    <c- n><c- n>latch</c-></c-><c- p><c- p>(</c-></c-><c- k><c- k>const</c-></c-> <c- n><c- n>latch</c-></c-><c- o><c- o>&amp;</c-></c-><c- p><c- p>)</c-></c-> <c- o><c- o>=</c-></c-> <c- k><c- k>delete</c-></c-><c- p><c- p>;</c-></c->
    <c- n><c- n>latch</c-></c-><c- o><c- o>&amp;</c-></c-> <c- k><c- k>operator</c-></c-><c- o><c- o>=</c-></c-><c- p><c- p>(</c-></c-><c- k><c- k>const</c-></c-> <c- n><c- n>latch</c-></c-><c- o><c- o>&amp;</c-></c-><c- p><c- p>)</c-></c-> <c- o><c- o>=</c-></c-> <c- k><c- k>delete</c-></c-><c- p><c- p>;</c-></c->
    
    <c- b><c- b>void</c-></c-> <c- nf><c- nf>count_down</c-></c-><c- p><c- p>(</c-></c-><c- b><c- b>ptrdiff_t</c-></c-> <c- n><c- n>update</c-></c-> <c- o><c- o>=</c-></c-> <c- mi><c- mi>1</c-></c-><c- p><c- p>);</c-></c->
    <c- b><c- b>bool</c-></c-> <c- nf><c- nf>try_wait</c-></c-><c- p><c- p>()</c-></c-> <c- k><c- k>const</c-></c-> <c- k><c- k>noexcept</c-></c-><c- p><c- p>;</c-></c->
    <c- b><c- b>void</c-></c-> <c- nf><c- nf>wait</c-></c-><c- p><c- p>()</c-></c-> <c- k><c- k>const</c-></c-><c- p><c- p>;</c-></c->
    <c- b><c- b>void</c-></c-> <c- nf><c- nf>arrive_and_wait</c-></c-><c- p><c- p>(</c-></c-><c- b><c- b>ptrdiff_t</c-></c-> <c- n><c- n>update</c-></c-> <c- o><c- o>=</c-></c-> <c- mi><c- mi>1</c-></c-><c- p><c- p>);</c-></c->

  <c- k><c- k>private</c-></c-><c- o><c- o>:</c-></c->
    <c- b><c- b>ptrdiff_t</c-></c-> <c- n><c- n>counter</c-></c-><c- p><c- p>;</c-></c-> <i><c- c1><c- c1>// exposition only</c-></c-></i>
  <c- p><c- p>};</c-></c->
<c- p><c- p>}</c-></c-> 
</code></pre>
    <div class="numbered"> A <code class="highlight"><c- n>latch</c-></code> maintains an internal counter that is initialized when the <code class="highlight"><c- n>latch</c-></code> is created. Threads can block on the latch object, waiting for <code class="highlight"><c- n>counter</c-></code> to be decremented to zero. </div>
    <div class="numbered"> Concurrent invocations of the member functions of <code class="highlight"><c- n>latch</c-></code>, other than its destructor, do not introduce data races. </div>
<pre class="highlight"><c- k>constexpr</c-> <c- k>explicit</c-> <c- nf>latch</c-><c- p>(</c-><c- b>ptrdiff_t</c-> <c- n>expected</c-><c- p>);</c->
</pre>
    <div class="numbered"> <em>Expects:</em> <code class="highlight"><c- n>expected</c-> <c- o>>=</c-> <c- mi>0</c-></code> is <code class="highlight">true</code>. </div>
    <div class="numbered"> <em>Effects:</em> Initializes <code class="highlight"><c- n>counter</c-></code> with <code class="highlight"><c- n>expected</c-></code>. </div>
    <div class="numbered"> <em>Throws:</em> Nothing. </div>
<pre class="highlight"><c- b>void</c-> <c- nf>count_down</c-><c- p>(</c-><c- b>ptrdiff_t</c-> <c- n>update</c-> <c- o>=</c-> <c- mi>1</c-><c- p>);</c->
</pre>
    <div class="numbered"> <em>Expects:</em> <code class="highlight"><c- n>update</c-> <c- o>>=</c-> <c- mi>0</c-></code> is <code class="highlight">true</code>, and <code class="highlight"><c- n>update</c-> <c- o>&lt;=</c-> <c- n>counter</c-></code> is <code class="highlight">true</code>. </div>
    <div class="numbered"> <em>Effects:</em> Atomically decrements <code class="highlight"><c- n>counter</c-></code> by <code class="highlight"><c- n>update</c-></code>.  If <code class="highlight"><c- n>counter</c-></code> is equal to zero, unblocks all threads blocked on <code class="highlight"><c- o>*</c-><c- k>this</c-></code>. </div>
    <div class="numbered"> <em>Synchronization:</em> Strongly happens before the returns from all calls that are unblocked. </div>
    <div class="numbered"> <em>Throws:</em> <code class="highlight"><c- n>system_error</c-></code> when an exception is required (<a href="http://eel.is/c++draft/thread.req.exception">[<strong>thread.req.exception</strong>]</a>). </div>
    <div class="numbered"> <em>Error conditions:</em> Any of the error conditions allowed for mutex types (<a href="http://eel.is/c++draft/thread.mutex.requirements.mutex">[<strong>thread.mutex.requirements.mutex</strong>]</a>). </div>
<pre class="highlight"><c- b>bool</c-> <c- nf>try_wait</c-><c- p>()</c-> <c- k>const</c-> <c- k>noexcept</c-><c- p>;</c->
</pre>
    <div class="numbered"> <em>Returns:</em> With very low probability <code class="highlight">false</code>.  Otherwise <code class="highlight"><c- n>counter</c-> <c- o>==</c-> <c- mi>0</c-></code>. </div>
<pre class="highlight"><c- b>void</c-> <c- nf>wait</c-><c- p>()</c-> <c- k>const</c-><c- p>;</c->
</pre>
    <div class="numbered"> <em>Effects:</em> If <code class="highlight"><c- n>counter</c-></code> equals zero, returns immediately. Otherwise, blocks on <code class="highlight"><c- o>*</c-><c- k>this</c-></code> until a call to <code class="highlight"><c- n>count_down</c-></code> that decrements <code class="highlight"><c- n>counter</c-></code> to zero. </div>
    <div class="numbered"> <em>Throws:</em> <code class="highlight"><c- n>system_error</c-></code> when an exception is required (<a href="http://eel.is/c++draft/thread.req.exception">[<strong>thread.req.exception</strong>]</a>). </div>
    <div class="numbered"> <em>Error conditions:</em> Any of the error conditions allowed for mutex types (<a href="http://eel.is/c++draft/thread.mutex.requirements.mutex">[<strong>thread.mutex.requirements.mutex</strong>]</a>). </div>
<pre class="highlight"><c- b>void</c-> <c- nf>arrive_and_wait</c-><c- p>(</c-><c- b>ptrdiff_t</c-> <c- n>update</c-> <c- o>=</c-> <c- mi>1</c-><c- p>);</c->
</pre>
    <div class="numbered">
      <em>Effects:</em> Equivalent to: 
<pre class="highlight"><code class="highlight">  <c- n><c- n>count_down</c-></c-><c- p><c- p>(</c-></c-><c- n><c- n>update</c-></c-><c- p><c- p>);</c-></c->
  <c- n><c- n>wait</c-></c-><c- p><c- p>();</c-></c->
</code></pre>
    </div>
   </blockquote>
   <blockquote class="ins">
     <b>32.�.2 Barriers <span style="float: right;">[thread.coord.barrier]</span></b> 
    <div class="numbered"> A barrier is a thread coordination mechanism whose lifetime consists of a sequence of barrier phases, where each phase allows at most an expected number of threads to block until the expected number of threads arrive at the barrier.  [ <em>Note:</em> A barrier is useful for managing repeated tasks that are handled by multiple threads. - <em>end note</em> ] </div>
   </blockquote>
   <blockquote class="ins">
     <b>32.�.2.1 Header <code class="highlight"><c- o>&lt;</c-><c- n>barrier</c-><c- o>></c-></code> synopsis <span style="float: right;">[thread.coord.barrier.syn]</span></b> 
<pre class="highlight"><code class="highlight"><c- k><c- k>namespace</c-></c-> <c- n><c- n>std</c-></c-> <c- p><c- p>{</c-></c->
  <c- k><c- k>template</c-></c-><c- o><c- o>&lt;</c-></c-><c- k><c- k>class</c-></c-> <c- nc><c- nc>CompletionFunction</c-></c-> <c- o><c- o>=</c-></c-> <i><c- n><c- n>see</c-></c-> <c- n><c- n>below</c-></c-></i><c- o><c- o>></c-></c->
    <c- k><c- k>class</c-></c-> <c- nc><c- nc>barrier</c-></c-><c- p><c- p>;</c-></c->
<c- p><c- p>}</c-></c->
</code></pre>
   </blockquote>
   <blockquote class="ins">
     <b>32.�.2.2 Class template <code class="highlight"><c- n>barrier</c-></code> <span style="float: right;">[thread.coord.barrier.class]</span></b> 
<pre class="highlight"><code class="highlight"><c- k><c- k>namespace</c-></c-> <c- n><c- n>std</c-></c-> <c- p><c- p>{</c-></c->
  <c- k><c- k>template</c-></c-><c- o><c- o>&lt;</c-></c-><c- k><c- k>class</c-></c-> <c- nc><c- nc>CompletionFunction</c-></c-> <c- o><c- o>=</c-></c-> <i><c- n><c- n>see</c-></c-> <c- n><c- n>below</c-></c-></i><c- o><c- o>></c-></c->
  <c- k><c- k>class</c-></c-> <c- nc><c- nc>barrier</c-></c-> <c- p><c- p>{</c-></c->
  <c- k><c- k>public</c-></c-><c- o><c- o>:</c-></c->
    <c- k><c- k>using</c-></c-> <c- n><c- n>arrival_token</c-></c-> <c- o><c- o>=</c-></c-> <i><c- n><c- n>see</c-></c-> <c- n><c- n>below</c-></c-></i><c- p><c- p>;</c-></c->

    <c- k><c- k>constexpr</c-></c-> <c- k><c- k>explicit</c-></c-> <c- nf><c- nf>barrier</c-></c-><c- p><c- p>(</c-></c-><c- b><c- b>ptrdiff_t</c-></c-> <c- n><c- n>phase_count</c-></c-><c- p><c- p>,</c-></c->
                               <c- n><c- n>CompletionFunction</c-></c-> <c- n><c- n>f</c-></c-> <c- o><c- o>=</c-></c-> <c- n><c- n>CompletionFunction</c-></c-><c- p><c- p>());</c-></c->
    <c- o><c- o>~</c-></c-><c- n><c- n>barrier</c-></c-><c- p><c- p>();</c-></c->

    <c- n><c- n>barrier</c-></c-><c- p><c- p>(</c-></c-><c- k><c- k>const</c-></c-> <c- n><c- n>barrier</c-></c-><c- o><c- o>&amp;</c-></c-><c- p><c- p>)</c-></c-> <c- o><c- o>=</c-></c-> <c- k><c- k>delete</c-></c-><c- p><c- p>;</c-></c->
    <c- n><c- n>barrier</c-></c-><c- o><c- o>&amp;</c-></c-> <c- k><c- k>operator</c-></c-><c- o><c- o>=</c-></c-><c- p><c- p>(</c-></c-><c- k><c- k>const</c-></c-> <c- n><c- n>barrier</c-></c-><c- o><c- o>&amp;</c-></c-><c- p><c- p>)</c-></c-> <c- o><c- o>=</c-></c-> <c- k><c- k>delete</c-></c-><c- p><c- p>;</c-></c->

    <c- p><c- p>[[</c-></c-><c- n><c- n>nodiscard</c-></c-><c- p><c- p>]]</c-></c-> <c- n><c- n>arrival_token</c-></c-> <c- n><c- n>arrive</c-></c-><c- p><c- p>(</c-></c-><c- b><c- b>ptrdiff_t</c-></c-> <c- n><c- n>update</c-></c-> <c- o><c- o>=</c-></c-> <c- mi><c- mi>1</c-></c-><c- p><c- p>);</c-></c->
    <c- b><c- b>void</c-></c-> <c- nf><c- nf>wait</c-></c-><c- p><c- p>(</c-></c-><c- n><c- n>arrival_token</c-></c-><c- o><c- o>&amp;&amp;</c-></c-> <c- n><c- n>arrival</c-></c-><c- p><c- p>)</c-></c-> <c- k><c- k>const</c-></c-><c- p><c- p>;</c-></c->

    <c- b><c- b>void</c-></c-> <c- nf><c- nf>arrive_and_wait</c-></c-><c- p><c- p>();</c-></c->
    <c- b><c- b>void</c-></c-> <c- nf><c- nf>arrive_and_drop</c-></c-><c- p><c- p>();</c-></c->

  <c- k><c- k>private</c-></c-><c- o><c- o>:</c-></c->
    <c- n><c- n>CompletionFunction</c-></c-> <c- n><c- n>completion</c-></c-><c- p><c- p>;</c-></c-> <i><c- c1><c- c1>// exposition only</c-></c-></i>
  <c- p><c- p>};</c-></c->
<c- p><c- p>}</c-></c->
</code></pre>
    <div class="numbered">
      Each <dfn data-dfn-type="dfn" data-noexport id="barrier-phase">barrier phase<a class="self-link" href="#barrier-phase"></a></dfn> consists of the following steps: 
     <ul>
      <li data-md>
       <p>The expected count is decremented by each call to <code class="highlight"><c- n>arrive</c-></code> or <code class="highlight"><c- n>arrive_and_drop</c-></code>.</p>
      <li data-md>
       <p>When the expected count reaches zero, the phase completion step is run. For the specialization with the default value of the <code class="highlight"><c- n>CompletionFunction</c-></code> template parameter, the completion step is run as part of the call to <code class="highlight"><c- n>arrive</c-></code> or <code class="highlight"><c- n>arrive_and_drop</c-></code> that caused the expected count to reach zero. For other specializations, the completion step is run on one of the threads that arrived at the barrier during the phase.</p>
      <li data-md>
       <p>When the completion step finishes, the expected count is reset to what was specified by the <code class="highlight"><c- n>expected</c-></code> argument to the constructor, possibly adjusted by calls to <code class="highlight"><c- n>arrive_and_drop</c-></code>, and the next phase starts.</p>
     </ul>
    </div>
    <div class="numbered"> Each phase defines a <dfn data-dfn-type="dfn" data-noexport id="phase-synchronization-point">phase synchronization point<a class="self-link" href="#phase-synchronization-point"></a></dfn>.  Threads that arrive at the barrier during the phase can block on the phase synchronization point by calling <code class="highlight"><c- n>wait</c-></code>, and will remain blocked until the phase completion step is run. </div>
    <div class="numbered">
      The <dfn data-dfn-type="dfn" data-noexport id="phase-completion-step">phase completion step<a class="self-link" href="#phase-completion-step"></a></dfn> that is executed at the end of each phase has the following effects: 
     <ul>
      <li data-md>
       <p>Invokes the completion function, equivalent to <code class="highlight"><c- n>completion</c-><c- p>()</c-></code>.</p>
      <li data-md>
       <p>Unblocks all threads that are blocked on the phase synchronization point.</p>
     </ul>
     <p>The end of the completion step strongly happens before the returns from all calls that were unblocked by the completion step.  For specializations that do not have the default value of the <code class="highlight"><c- n>CompletionFunction</c-></code> template parameter, the behavior is undefined if any of the <code class="highlight"><c- n>barrier</c-></code> object’s member functions other than <code class="highlight"><c- n>wait</c-></code> are called while the completion step is in progress.</p>
    </div>
    <div class="numbered"> Concurrent invocations of the member functions of <code class="highlight"><c- n>barrier</c-></code>, other than its destructor, do not introduce data races. The member functions <code class="highlight"><c- n>arrive</c-></code> and <code class="highlight"><c- n>arrive_and_drop</c-></code> execute atomically. </div>
    <div class="numbered"> <code class="highlight"><c- n>CompletionFunction</c-></code> shall meet the <em>Cpp17MoveConstructible</em> requirements (Table <a href="http://eel.is/c++draft/utility.arg.requirements#tab:moveconstructible">26</a>) and the <em>Cpp17Destructible</em> requirements (Table <a href="http://eel.is/c++draft/utility.arg.requirements#tab:destructible">30</a>). <code class="highlight"><c- n>is_nothrow_invocable_v</c-><c- o>&lt;</c-><c- n>CompletionFunction</c-><c- o>&amp;></c-></code> shall be <code class="highlight">true</code>. </div>
    <div class="numbered"> The default value of the <code class="highlight"><c- n>CompletionFunction</c-></code> template parameter is an unspecified type, such that, in addition to satisfying the requirements of <code class="highlight"><c- n>CompletionFunction</c-></code>, it meets the <em>Cpp17DefaultConstructible</em> requirements (Table <a href="http://eel.is/c++draft/utility.arg.requirements#tab:defaultconstructible">25</a>) and <code class="highlight"><c- n>completion</c-><c- p>()</c-></code> has no effects. </div>
    <div class="numbered"> <code class="highlight"><c- n>barrier</c-><c- o>::</c-><c- n>arrival_token</c-></code> is an unspecified type, such that it meets the <em>Cpp17MoveConstructible</em> (Table <a href="http://eel.is/c++draft/utility.arg.requirements#tab:moveconstructible">26</a>), <em>Cpp17MoveAssignable</em> (Table <a href="http://eel.is/c++draft/utility.arg.requirements#tab:moveassignable">28</a>), and <em>Cpp17Destructible</em> (Table <a href="http://eel.is/c++draft/utility.arg.requirements#tab:destructible">30</a>) requirements. </div>
<pre class="highlight"><c- k>constexpr</c-> <c- k>explicit</c-> <c- nf>barrier</c-><c- p>(</c-><c- b>ptrdiff_t</c-> <c- n>phase_count</c-><c- p>,</c->
                           <c- n>CompletionFunction</c-> <c- n>f</c-> <c- o>=</c-> <c- n>CompletionFunction</c-><c- p>());</c->
</pre>
    <div class="numbered"> <em>Expects:</em> <code class="highlight"><c- n>phase_count</c-> <c- o>>=</c-> <c- mi>0</c-></code> is <code class="highlight">true</code>. </div>
    <div class="numbered"> <em>Effects:</em> Sets both the initial expected count for each barrier phase and the current expected count for the first phase to <code class="highlight"><c- n>phase_count</c-></code>.  Initializes <code class="highlight"><c- n>completion</c-></code> with <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>move</c-><c- p>(</c-><c- n>f</c-><c- p>)</c-></code>.  Starts the first phase. [ <em>Note:</em> If <code class="highlight"><c- n>phase_count</c-></code> is <code class="highlight"><c- mi>0</c-></code> this object can only be destroyed. — <em>end note</em> ] </div>
    <div class="numbered"> <em>Throws:</em> Any exception thrown by <code class="highlight"><c- n>CompletionFunction</c-></code>'s move constructor. </div>
<pre class="highlight"><c- p>[[</c-><c- n>nodiscard</c-><c- p>]]</c-> <c- n>arrival_token</c-> <c- n>arrive</c-><c- p>(</c-><c- b>ptrdiff_t</c-> <c- n>update</c-> <c- o>=</c-> <c- mi>1</c-><c- p>);</c->
</pre>
    <div class="numbered"> <em>Expects:</em> <code class="highlight"><c- n>update</c-> <c- o>></c-> <c- mi>0</c-></code> is <code class="highlight">true</code>, and <code class="highlight"><c- n>update</c-></code> is less than or equal to the expected count for the current barrier phase. </div>
    <div class="numbered"> <em>Effects:</em> Constructs an object of type <code class="highlight"><c- n>arrival_token</c-></code> that is associated with the phase synchronization point for the current phase.  Then, decrements the expected count by <code class="highlight"><c- n>update</c-></code>. </div>
    <div class="numbered"> <em>Synchronization:</em> The call to <code class="highlight"><c- n>arrive</c-></code> strongly happens before the start of the phase completion step for the current phase. </div>
    <div class="numbered"> <em>Returns:</em> The constructed <code class="highlight"><c- n>arrival_token</c-></code> object. </div>
    <div class="numbered"> <em>Throws:</em> <code class="highlight"><c- n>system_error</c-></code> when an exception is required (<a href="http://eel.is/c++draft/thread.req.exception">[<strong>thread.req.exception</strong>]</a>). </div>
    <div class="numbered"> <em>Error conditions:</em> Any of the error conditions allowed for mutex types (<a href="http://eel.is/c++draft/thread.mutex.requirements.mutex">[<strong>thread.mutex.requirements.mutex</strong>]</a>). </div>
    <div class="numbered"> [ <em>Note</em>: This call can cause the completion step for the current phase to start. - <em>end note</em> ] </div>
<pre class="highlight"><c- b>void</c-> <c- nf>wait</c-><c- p>(</c-><c- n>arrival_token</c-><c- o>&amp;&amp;</c-> <c- n>arrival</c-><c- p>)</c-> <c- k>const</c-><c- p>;</c->
</pre>
    <div class="numbered"> <em>Expects:</em> <code class="highlight"><c- n>arrival</c-></code> is associated with the phase synchronization point for the current phase or the immediately preceding phase of the same barrier object. </div>
    <div class="numbered"> <em>Effects:</em> Blocks at the synchronization point associated with <code class="highlight"><c- n>std</c-><c- o>::</c-><c- n>move</c-><c- p>(</c-><c- n>arrival</c-><c- p>)</c-></code> until the phase completion step of the synchronization point’s phase is run. [ <em>Note:</em> If <code class="highlight"><c- n>arrival</c-></code> is associated with the synchronization point for a previous phase, the call returns immediately. - <em>end note</em> ] </div>
    <div class="numbered"> <em>Throws:</em> <code class="highlight"><c- n>system_error</c-></code> when an exception is required (<a href="http://eel.is/c++draft/thread.req.exception">[<strong>thread.req.exception</strong>]</a>). </div>
    <div class="numbered"> <em>Error conditions:</em> Any of the error conditions allowed for mutex types (<a href="http://eel.is/c++draft/thread.mutex.requirements.mutex">[<strong>thread.mutex.requirements.mutex</strong>]</a>). </div>
<pre class="highlight"><c- b>void</c-> <c- nf>arrive_and_wait</c-><c- p>();</c->
</pre>
    <div class="numbered"> <em>Effects:</em> Equivalent to: <code class="highlight"><c- n>wait</c-><c- p>(</c-><c- n>arrive</c-><c- p>())</c-></code>. </div>
<pre class="highlight"><c- b>void</c-> <c- nf>arrive_and_drop</c-><c- p>();</c->
</pre>
    <div class="numbered"> <em>Expects:</em> The expected count for the current barrier phase is greater than zero. </div>
    <div class="numbered"> <em>Effects:</em> Decrements the initial expected count for all subsequent phases by one.  Then decrements the expected count for the current phase by one. </div>
    <div class="numbered"> <em>Synchronization:</em> The call to <code class="highlight"><c- n>arrive_and_drop</c-></code> strongly happens before the start of the phase completion step for the current phase. </div>
    <div class="numbered"> <em>Throws:</em> <code class="highlight"><c- n>system_error</c-></code> when an exception is required (<a href="http://eel.is/c++draft/thread.req.exception">[<strong>thread.req.exception</strong>]</a>). </div>
    <div class="numbered"> <em>Error conditions:</em> Any of the error conditions allowed for mutex types (<a href="http://eel.is/c++draft/thread.mutex.requirements.mutex">[<strong>thread.mutex.requirements.mutex</strong>]</a>). </div>
    <div class="numbered"> [ <em>Note:</em> This call can cause the completion step for the current phase to start. - <em>end note</em> ] </div>
   </blockquote>
   <p>Create the following feature test macros with the given headers, adding them to the table in [support.limits.general]:</p>
   <ul>
    <li data-md>
     <p><code class="highlight"><c- n>__cpp_lib_atomic_lock_free_type_aliases</c-></code> in <code class="highlight"><c- o>&lt;</c-><c- n>atomic</c-><c- o>></c-></code>, which implies that <code class="highlight"><c- n>atomic_signed_lock_free</c-></code> and <code class="highlight"><c- n>atomic_unsigned_lock_free</c-></code> types are available.</p>
    <li data-md>
     <p><code class="highlight"><c- n>__cpp_lib_atomic_flag_test</c-></code> in <code class="highlight"><c- o>&lt;</c-><c- n>atomic</c-><c- o>></c-></code>, which implies the <code class="highlight"><c- n>test</c-></code> methods and free functions for <code class="highlight"><c- n>atomic_flag</c-></code> are available.</p>
    <li data-md>
     <p><code class="highlight"><c- n>__cpp_lib_atomic_wait</c-></code> in <code class="highlight"><c- o>&lt;</c-><c- n>atomic</c-><c- o>></c-></code>, which implies the <code class="highlight"><c- n>wait</c-></code>, <code class="highlight"><c- n>notify_one</c-></code>, and <code class="highlight"><c- n>notify_all</c-></code> methods and free functions for <code class="highlight"><c- n>atomic</c-></code> and <code class="highlight"><c- n>atomic_flag</c-></code> are available.</p>
    <li data-md>
     <p><code class="highlight"><c- n>__cpp_lib_semaphore</c-></code> in <code class="highlight"><c- o>&lt;</c-><c- n>semaphore</c-><c- o>></c-></code>, which implies that <code class="highlight"><c- n>counting_semaphore</c-></code> and <code class="highlight"><c- n>binary_semaphore</c-></code> are available.</p>
    <li data-md>
     <p><code class="highlight"><c- n>__cpp_lib_latch</c-></code> in <code class="highlight"><c- o>&lt;</c-><c- n>latch</c-><c- o>></c-></code>, which implies that <code class="highlight"><c- n>latch</c-></code> is available.</p>
    <li data-md>
     <p><code class="highlight"><c- n>__cpp_lib_barrier</c-></code> in <code class="highlight"><c- o>&lt;</c-><c- n>barrier</c-><c- o>></c-></code>, which implies that <code class="highlight"><c- n>barrier</c-></code> is available.</p>
   </ul>
  </main>
<script>
(function() {
  "use strict";
  var collapseSidebarText = '<span aria-hidden="true">←</span> '
                          + '<span>Collapse Sidebar</span>';
  var expandSidebarText   = '<span aria-hidden="true">→</span> '
                          + '<span>Pop Out Sidebar</span>';
  var tocJumpText         = '<span aria-hidden="true">↑</span> '
                          + '<span>Jump to Table of Contents</span>';

  var sidebarMedia = window.matchMedia('screen and (min-width: 78em)');
  var autoToggle   = function(e){ toggleSidebar(e.matches) };
  if(sidebarMedia.addListener) {
    sidebarMedia.addListener(autoToggle);
  }

  function toggleSidebar(on) {
    if (on == undefined) {
      on = !document.body.classList.contains('toc-sidebar');
    }

    /* Don’t scroll to compensate for the ToC if we’re above it already. */
    var headY = 0;
    var head = document.querySelector('.head');
    if (head) {
      // terrible approx of "top of ToC"
      headY += head.offsetTop + head.offsetHeight;
    }
    var skipScroll = window.scrollY < headY;

    var toggle = document.getElementById('toc-toggle');
    var tocNav = document.getElementById('toc');
    if (on) {
      var tocHeight = tocNav.offsetHeight;
      document.body.classList.add('toc-sidebar');
      document.body.classList.remove('toc-inline');
      toggle.innerHTML = collapseSidebarText;
      if (!skipScroll) {
        window.scrollBy(0, 0 - tocHeight);
      }
      tocNav.focus();
      sidebarMedia.addListener(autoToggle); // auto-collapse when out of room
    }
    else {
      document.body.classList.add('toc-inline');
      document.body.classList.remove('toc-sidebar');
      toggle.innerHTML = expandSidebarText;
      if (!skipScroll) {
        window.scrollBy(0, tocNav.offsetHeight);
      }
      if (toggle.matches(':hover')) {
        /* Unfocus button when not using keyboard navigation,
           because I don’t know where else to send the focus. */
        toggle.blur();
      }
    }
  }

  function createSidebarToggle() {
    /* Create the sidebar toggle in JS; it shouldn’t exist when JS is off. */
    var toggle = document.createElement('a');
      /* This should probably be a button, but appearance isn’t standards-track.*/
    toggle.id = 'toc-toggle';
    toggle.class = 'toc-toggle';
    toggle.href = '#toc';
    toggle.innerHTML = collapseSidebarText;

    sidebarMedia.addListener(autoToggle);
    var toggler = function(e) {
      e.preventDefault();
      sidebarMedia.removeListener(autoToggle); // persist explicit off states
      toggleSidebar();
      return false;
    }
    toggle.addEventListener('click', toggler, false);


    /* Get <nav id=toc-nav>, or make it if we don’t have one. */
    var tocNav = document.getElementById('toc-nav');
    if (!tocNav) {
      tocNav = document.createElement('p');
      tocNav.id = 'toc-nav';
      /* Prepend for better keyboard navigation */
      document.body.insertBefore(tocNav, document.body.firstChild);
    }
    /* While we’re at it, make sure we have a Jump to Toc link. */
    var tocJump = document.getElementById('toc-jump');
    if (!tocJump) {
      tocJump = document.createElement('a');
      tocJump.id = 'toc-jump';
      tocJump.href = '#toc';
      tocJump.innerHTML = tocJumpText;
      tocNav.appendChild(tocJump);
    }

    tocNav.appendChild(toggle);
  }

  var toc = document.getElementById('toc');
  if (toc) {
    createSidebarToggle();
    toggleSidebar(sidebarMedia.matches);

    /* If the sidebar has been manually opened and is currently overlaying the text
       (window too small for the MQ to add the margin to body),
       then auto-close the sidebar once you click on something in there. */
    toc.addEventListener('click', function(e) {
      if(e.target.tagName.toLowerCase() == "a" && document.body.classList.contains('toc-sidebar') && !sidebarMedia.matches) {
        toggleSidebar(false);
      }
    }, false);
  }
  else {
    console.warn("Can’t find Table of Contents. Please use <nav id='toc'> around the ToC.");
  }

  /* Wrap tables in case they overflow */
  var tables = document.querySelectorAll(':not(.overlarge) > table.data, :not(.overlarge) > table.index');
  var numTables = tables.length;
  for (var i = 0; i < numTables; i++) {
    var table = tables[i];
    var wrapper = document.createElement('div');
    wrapper.className = 'overlarge';
    table.parentNode.insertBefore(wrapper, table);
    wrapper.appendChild(table);
  }

})();
</script>
  <h2 class="no-num no-ref heading settled" id="index"><span class="content">Index</span><a class="self-link" href="#index"></a></h2>
  <h3 class="no-num no-ref heading settled" id="index-defined-here"><span class="content">Terms defined by this specification</span><a class="self-link" href="#index-defined-here"></a></h3>
  <ul class="index">
   <li><a href="#atomic-notifying-operations">atomic notifying operations</a><span>, in §3</span>
   <li><a href="#atomic-waiting-operations">Atomic waiting operations</a><span>, in §3</span>
   <li><a href="#barrier-phase">barrier phase</a><span>, in §3</span>
   <li><a href="#eligible-to-be-unblocked">eligible to be unblocked</a><span>, in §3</span>
   <li><a href="#phase-completion-step">phase completion step</a><span>, in §3</span>
   <li><a href="#phase-synchronization-point">phase synchronization point</a><span>, in §3</span>
  </ul>
  <h2 class="no-num no-ref heading settled" id="references"><span class="content">References</span><a class="self-link" href="#references"></a></h2>
  <h3 class="no-num no-ref heading settled" id="informative"><span class="content">Informative References</span><a class="self-link" href="#informative"></a></h3>
  <dl>
   <dt id="biblio-n4810">[N4810]
   <dd>Richard Smith. <a href="https://wg21.link/n4810">Working Draft, Standard for Programming Language C++</a>. 15 March 2019. URL: <a href="https://wg21.link/n4810">https://wg21.link/n4810</a>
   <dt id="biblio-p0514r4">[P0514R4]
   <dd>Olivier Giroux. <a href="https://wg21.link/p0514r4">Efficient concurrent waiting for C++20</a>. 3 May 2018. URL: <a href="https://wg21.link/p0514r4">https://wg21.link/p0514r4</a>
   <dt id="biblio-p0666r2">[P0666R2]
   <dd>Olivier Giroux. <a href="https://wg21.link/p0666r2">Revised Latches and Barriers for C++20</a>. 6 May 2018. URL: <a href="https://wg21.link/p0666r2">https://wg21.link/p0666r2</a>
   <dt id="biblio-p0995r1">[P0995R1]
   <dd>JF Bastien, Olivier Giroux, Andrew Hunter. <a href="https://wg21.link/p0995r1">Improving atomic_flag</a>. 22 June 2018. URL: <a href="https://wg21.link/p0995r1">https://wg21.link/p0995r1</a>
   <dt id="biblio-p1258r0">[P1258R0]
   <dd>Detlef Vollmann. <a href="https://wg21.link/p1258r0">Don't Make C++ Unimplementable On Small CPUs</a>. 8 October 2018. URL: <a href="https://wg21.link/p1258r0">https://wg21.link/p1258r0</a>
   <dt id="biblio-p1633r0">[P1633R0]
   <dd>David Olsen, Olivier Giroux. <a href="https://wg21.link/p1633r0">Amendments to the C++20 Synchronization Library</a>. 16 June 2019. URL: <a href="https://wg21.link/p1633r0">https://wg21.link/p1633r0</a>
  </dl>