<!DOCTYPE html>

<html lang="en">

<head>
    <meta charset="utf-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=no">
    <meta name="apple-mobile-web-app-capable" content="yes">
    <meta name="apple-mobile-web-app-status-bar-style" content="black">
    <meta name="mobile-web-app-capable" content="yes">
    <title>
        User-defined Atomic Read-Modify-Write Operations
    </title>

    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/twitter-bootstrap/3.3.7/css/bootstrap.min.css" integrity="sha256-916EbMg70RQy9LHiGkXzG8hSg9EdNy97GazNG/aiY1w=" crossorigin="anonymous" />
    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/4.7.0/css/font-awesome.min.css" integrity="sha256-eZrrJcwDc/3uDhsdt61sL2oOBY362qM3lon1gyExkL0=" crossorigin="anonymous" />
    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/ionicons/2.0.1/css/ionicons.min.css" integrity="sha256-3iu9jgsy9TpTwXKb7bNQzqWekRX7pPK+2OLj3R922fo=" crossorigin="anonymous" />
    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/octicons/3.5.0/octicons.min.css" integrity="sha256-QiWfLIsCT02Sdwkogf6YMiQlj4NE84MKkzEMkZnMGdg=" crossorigin="anonymous" />
    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/prism/1.5.1/themes/prism.min.css" integrity="sha256-vtR0hSWRc3Tb26iuN2oZHt3KRUomwTufNIf5/4oeCyg=" crossorigin="anonymous" />
    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@hackmd/emojify.js@2.1.0/dist/css/basic/emojify.min.css" integrity="sha256-UOrvMOsSDSrW6szVLe8ZDZezBxh5IoIfgTwdNDgTjiU=" crossorigin="anonymous" />
    <style>
        @import url(https://fonts.googleapis.com/css?family=Roboto:300,300i,400,400i,500,500i|Source+Code+Pro:300,400,500|Source+Sans+Pro:300,300i,400,400i,600,600i|Source+Serif+Pro&subset=latin-ext);.hljs{background:#fff;color:#333;display:block;overflow-x:auto;padding:.5em}.hljs-comment,.hljs-meta{color:#969896}.hljs-emphasis,.hljs-quote,.hljs-string,.hljs-strong,.hljs-template-variable,.hljs-variable{color:#df5000}.hljs-keyword,.hljs-selector-tag,.hljs-type{color:#a71d5d}.hljs-attribute,.hljs-bullet,.hljs-literal,.hljs-number,.hljs-symbol{color:#0086b3}.hljs-built_in,.hljs-builtin-name{color:#005cc5}.hljs-name,.hljs-section{color:#63a35c}.hljs-tag{color:#333}.hljs-attr,.hljs-selector-attr,.hljs-selector-class,.hljs-selector-id,.hljs-selector-pseudo,.hljs-title{color:#795da3}.hljs-addition{background-color:#eaffea;color:#55a532}.hljs-deletion{background-color:#ffecec;color:#bd2c00}.hljs-link{text-decoration:underline}.markdown-body{word-wrap:break-word;font-size:16px;line-height:1.5}.markdown-body:after,.markdown-body:before{content:"";display:table}.markdown-body:after{clear:both}.markdown-body>:first-child{margin-top:0!important}.markdown-body>:last-child{margin-bottom:0!important}.markdown-body a:not([href]){color:inherit;text-decoration:none}.markdown-body .absent{color:#c00}.markdown-body .anchor{float:left;line-height:1;margin-left:-20px;padding-right:4px}.markdown-body .anchor:focus{outline:none}.markdown-body blockquote,.markdown-body dl,.markdown-body ol,.markdown-body p,.markdown-body pre,.markdown-body table,.markdown-body ul{margin-bottom:16px;margin-top:0}.markdown-body hr{background-color:#e7e7e7;border:0;height:.25em;margin:24px 0;padding:0}.markdown-body blockquote{border-left:.25em solid #ddd;color:#777;font-size:16px;padding:0 1em}.markdown-body blockquote>:first-child{margin-top:0}.markdown-body blockquote>:last-child{margin-bottom:0}.markdown-body kbd,.popover kbd{background-color:#fcfcfc;border:1px solid;border-color:#ccc #ccc #bbb;border-radius:3px;box-shadow:inset 0 -1px 0 #bbb;color:#555;display:inline-block;font-size:11px;line-height:10px;padding:3px 5px;vertical-align:middle}.markdown-body .loweralpha{list-style-type:lower-alpha}.markdown-body h1,.markdown-body h2,.markdown-body h3,.markdown-body h4,.markdown-body h5,.markdown-body h6{font-weight:600;line-height:1.25;margin-bottom:16px;margin-top:24px}.markdown-body h1 .octicon-link,.markdown-body h2 .octicon-link,.markdown-body h3 .octicon-link,.markdown-body h4 .octicon-link,.markdown-body h5 .octicon-link,.markdown-body h6 .octicon-link{color:#000;vertical-align:middle;visibility:hidden}.markdown-body h1:hover .anchor,.markdown-body h2:hover .anchor,.markdown-body h3:hover .anchor,.markdown-body h4:hover .anchor,.markdown-body h5:hover .anchor,.markdown-body h6:hover .anchor{text-decoration:none}.markdown-body h1:hover .anchor .octicon-link,.markdown-body h2:hover .anchor .octicon-link,.markdown-body h3:hover .anchor .octicon-link,.markdown-body h4:hover .anchor .octicon-link,.markdown-body h5:hover .anchor .octicon-link,.markdown-body h6:hover .anchor .octicon-link{visibility:visible}.markdown-body h1 code,.markdown-body h1 tt,.markdown-body h2 code,.markdown-body h2 tt,.markdown-body h3 code,.markdown-body h3 tt,.markdown-body h4 code,.markdown-body h4 tt,.markdown-body h5 code,.markdown-body h5 tt,.markdown-body h6 code,.markdown-body h6 tt{font-size:inherit}.markdown-body h1{font-size:2em}.markdown-body h1,.markdown-body h2{border-bottom:1px solid #eee;padding-bottom:.3em}.markdown-body h2{font-size:1.5em}.markdown-body h3{font-size:1.25em}.markdown-body h4{font-size:1em}.markdown-body h5{font-size:.875em}.markdown-body h6{color:#777;font-size:.85em}.markdown-body ol,.markdown-body ul{padding-left:2em}.markdown-body ol.no-list,.markdown-body ul.no-list{list-style-type:none;padding:0}.markdown-body ol ol,.markdown-body ol ul,.markdown-body ul ol,.markdown-body ul ul{margin-bottom:0;margin-top:0}.markdown-body li>p{margin-top:16px}.markdown-body li+li{padding-top:.25em}.markdown-body dl{padding:0}.markdown-body dl dt{font-size:1em;font-style:italic;font-weight:700;margin-top:16px;padding:0}.markdown-body dl dd{margin-bottom:16px;padding:0 16px}.markdown-body table{display:block;overflow:auto;width:100%;word-break:normal;word-break:keep-all}.markdown-body table th{font-weight:700}.markdown-body table td,.markdown-body table th{border:1px solid #ddd;padding:6px 13px}.markdown-body table tr{background-color:#fff;border-top:1px solid #ccc}.markdown-body table tr:nth-child(2n){background-color:#f8f8f8}.markdown-body img{background-color:#fff;box-sizing:initial;max-width:100%}.markdown-body img[align=right]{padding-left:20px}.markdown-body img[align=left]{padding-right:20px}.markdown-body .emoji{background-color:initial;max-width:none;vertical-align:text-top}.markdown-body span.frame{display:block;overflow:hidden}.markdown-body span.frame>span{border:1px solid #ddd;display:block;float:left;margin:13px 0 0;overflow:hidden;padding:7px;width:auto}.markdown-body span.frame span img{display:block;float:left}.markdown-body span.frame span span{clear:both;color:#333;display:block;padding:5px 0 0}.markdown-body span.align-center{clear:both;display:block;overflow:hidden}.markdown-body span.align-center>span{display:block;margin:13px auto 0;overflow:hidden;text-align:center}.markdown-body span.align-center span img{margin:0 auto;text-align:center}.markdown-body span.align-right{clear:both;display:block;overflow:hidden}.markdown-body span.align-right>span{display:block;margin:13px 0 0;overflow:hidden;text-align:right}.markdown-body span.align-right span img{margin:0;text-align:right}.markdown-body span.float-left{display:block;float:left;margin-right:13px;overflow:hidden}.markdown-body span.float-left span{margin:13px 0 0}.markdown-body span.float-right{display:block;float:right;margin-left:13px;overflow:hidden}.markdown-body span.float-right>span{display:block;margin:13px auto 0;overflow:hidden;text-align:right}.markdown-body code,.markdown-body tt{background-color:#0000000a;border-radius:3px;font-size:85%;margin:0;padding:.2em 0}.markdown-body code:after,.markdown-body code:before,.markdown-body tt:after,.markdown-body tt:before{content:"\00a0";letter-spacing:-.2em}.markdown-body code br,.markdown-body tt br{display:none}.markdown-body del code{text-decoration:inherit}.markdown-body pre{word-wrap:normal}.markdown-body pre>code{background:#0000;border:0;font-size:100%;margin:0;padding:0;white-space:pre;word-break:normal}.markdown-body .highlight{margin-bottom:16px}.markdown-body .highlight pre{margin-bottom:0;word-break:normal}.markdown-body .highlight pre,.markdown-body pre{border-radius:3px;font-size:85%;line-height:1.45;overflow:auto}.markdown-body:not(.next-editor) pre{background-color:#f7f7f7;padding:16px}.markdown-body pre code,.markdown-body pre tt{word-wrap:normal;background-color:initial;border:0;display:inline;line-height:inherit;margin:0;max-width:auto;overflow:visible;padding:0}.markdown-body pre code:after,.markdown-body pre code:before,.markdown-body pre tt:after,.markdown-body pre tt:before{content:normal}.markdown-body .csv-data td,.markdown-body .csv-data th{font-size:12px;line-height:1;overflow:hidden;padding:5px;text-align:left;white-space:nowrap}.markdown-body .csv-data .blob-line-num{background:#fff;border:0;padding:10px 8px 9px;text-align:right}.markdown-body .csv-data tr{border-top:0}.markdown-body .csv-data th{background:#f8f8f8;border-top:0;font-weight:700}.news .alert .markdown-body blockquote{border:0;padding:0 0 0 40px}.activity-tab .news .alert .commits,.activity-tab .news .markdown-body blockquote{padding-left:0}.task-list-item{list-style-type:none}.task-list-item label{font-weight:400}.task-list-item.enabled label{cursor:pointer}.task-list-item+.task-list-item{margin-top:3px}.task-list-item-checkbox{cursor:default!important;float:left;margin:.31em 0 .2em -1.3em!important;vertical-align:middle}.markdown-alert{border-left-style:solid;border-left-width:4px;color:inherit;margin-bottom:16px;padding:8px 16px}.markdown-alert .markdown-alert-title{align-items:center;display:flex;font-weight:500;line-height:1;white-space:break-spaces}.markdown-body .markdown-alert>*{margin-bottom:0;margin-top:16px}.markdown-body .markdown-alert .selection-popover,.markdown-body .markdown-alert>:first-child{margin-top:0}.markdown-alert.markdown-alert-note{border-left-color:#0969da}.markdown-alert.markdown-alert-note .markdown-alert-title{fill:currentColor;color:#0969da}.markdown-alert.markdown-alert-tip{border-left-color:#1a7f37}.markdown-alert.markdown-alert-tip .markdown-alert-title{fill:currentColor;color:#1a7f37}.markdown-alert.markdown-alert-important{border-left-color:#8250df}.markdown-alert.markdown-alert-important .markdown-alert-title{fill:currentColor;color:#8250df}.markdown-alert.markdown-alert-warning{border-left-color:#9a6700}.markdown-alert.markdown-alert-warning .markdown-alert-title{fill:currentColor;color:#9a6700}.markdown-alert.markdown-alert-caution{border-left-color:#d1242f}.markdown-alert.markdown-alert-caution .markdown-alert-title{fill:currentColor;color:#d1242f}.markdown-body{max-width:758px;overflow:visible!important;padding-bottom:40px;padding-top:40px;position:relative}.markdown-body.next-editor{overflow-x:hidden!important}.markdown-body .emoji{vertical-align:top}.markdown-body pre{border:inherit!important}.markdown-body code{color:inherit!important}.markdown-body pre code .wrapper{display:-moz-inline-flex;display:-ms-inline-flex;display:-o-inline-flex;display:inline-flex}.markdown-body pre code .gutter{float:left;overflow:hidden;-webkit-user-select:none;user-select:none}.markdown-body pre code .gutter.linenumber{border-right:3px solid #6ce26c!important;box-sizing:initial;color:#afafaf!important;cursor:default;display:inline-block;min-width:20px;padding:0 8px 0 0;position:relative;text-align:right;z-index:4}.markdown-body pre code .gutter.linenumber>span:before{content:attr(data-linenumber)}.markdown-body pre code .code{float:left;margin:0 0 0 16px}.markdown-body .gist .line-numbers{border-bottom:none;border-left:none;border-top:none}.markdown-body .gist .line-data{border:none}.markdown-body .gist table{border-collapse:inherit!important;border-spacing:0}.markdown-body code[data-gist-id]{background:none;padding:0}.markdown-body code[data-gist-id]:after,.markdown-body code[data-gist-id]:before{content:""}.markdown-body code[data-gist-id] .blob-num{border:unset}.markdown-body code[data-gist-id] table{margin-bottom:unset;overflow:unset}.markdown-body code[data-gist-id] table tr{background:unset}.markdown-body[dir=rtl] pre{direction:ltr}.markdown-body[dir=rtl] code{direction:ltr;unicode-bidi:embed}.markdown-body .alert{display:flex;flex-direction:column;gap:16px}.markdown-body .alert>*{margin:0}.markdown-body pre.abc,.markdown-body pre.flow-chart,.markdown-body pre.graphviz,.markdown-body pre.mermaid,.markdown-body pre.sequence-diagram,.markdown-body pre.vega{background-color:inherit;border-radius:0;overflow:visible;text-align:center;white-space:inherit}.markdown-body pre.abc>code,.markdown-body pre.flow-chart>code,.markdown-body pre.graphviz>code,.markdown-body pre.mermaid>code,.markdown-body pre.sequence-diagram>code,.markdown-body pre.vega>code{text-align:left}.markdown-body pre.abc>svg,.markdown-body pre.flow-chart>svg,.markdown-body pre.graphviz>svg,.markdown-body pre.mermaid>svg,.markdown-body pre.sequence-diagram>svg,.markdown-body pre.vega>svg{height:100%;max-width:100%}.markdown-body pre>code.wrap{word-wrap:break-word;white-space:pre-wrap;white-space:-moz-pre-wrap;white-space:-pre-wrap;white-space:-o-pre-wrap}.markdown-body pre.pseudocode{white-space-collapse:collapse}.markdown-body summary{display:list-item}.markdown-body summary:focus{outline:none}.markdown-body details summary{cursor:pointer}.markdown-body details:not([open])>:not(summary){display:none}.markdown-body figure{margin:1em 40px}.markdown-body .mark,.markdown-body mark{background-color:#fff1a7}.vimeo,.youtube{background-color:#000;background-position:50%;background-repeat:no-repeat;background-size:contain;cursor:pointer;display:table;overflow:hidden;text-align:center}.vimeo,.youtube{position:relative;width:100%}.youtube{padding-bottom:56.25%}.vimeo img{object-fit:contain;width:100%;z-index:0}.youtube img{object-fit:cover;z-index:0}.vimeo iframe,.youtube iframe,.youtube img{height:100%;left:0;position:absolute;top:0;width:100%}.vimeo iframe,.youtube iframe{vertical-align:middle;z-index:1}.vimeo .icon,.youtube .icon{color:#fff;height:auto;left:50%;opacity:.3;position:absolute;top:50%;transform:translate(-50%,-50%);transition:opacity .2s;width:auto;z-index:0}.vimeo:hover .icon,.youtube:hover .icon{opacity:.6;transition:opacity .2s}.slideshare .inner,.speakerdeck .inner{position:relative;width:100%}.slideshare .inner iframe,.speakerdeck .inner iframe{bottom:0;height:100%;left:0;position:absolute;right:0;top:0;width:100%}.figma{display:table;padding-bottom:56.25%;position:relative;width:100%}.figma iframe{border:1px solid #eee;bottom:0;height:100%;left:0;position:absolute;right:0;top:0;width:100%}.markmap-container{height:300px}.markmap-container>svg{height:100%;width:100%}.MJX_Assistive_MathML{display:none}#MathJax_Message{z-index:1000!important}.ui-infobar{color:#777;margin:25px auto -25px;max-width:760px;position:relative;z-index:2}.toc .invisable-node{list-style-type:none}.ui-toc{bottom:20px;position:fixed;z-index:998}.ui-toc.both-mode{margin-left:8px}.ui-toc.both-mode .ui-toc-label{border-bottom-left-radius:0;border-top-left-radius:0;height:40px;padding:10px 4px}.ui-toc-label{background-color:#e6e6e6;border:none;color:#868686;transition:opacity .2s}.ui-toc .open .ui-toc-label{color:#fff;opacity:1;transition:opacity .2s}.ui-toc-label:focus{background-color:#ccc;color:#000;opacity:.3}.ui-toc-label:hover{background-color:#ccc;opacity:1;transition:opacity .2s}.ui-toc-dropdown{margin-bottom:20px;margin-top:20px;max-height:70vh;max-width:45vw;overflow:auto;padding-left:10px;padding-right:10px;text-align:inherit;width:25vw}.ui-toc-dropdown>.toc{max-height:calc(70vh - 100px);overflow:auto}.ui-toc-dropdown[dir=rtl] .nav{letter-spacing:.0029em;padding-right:0}.ui-toc-dropdown a{overflow:hidden;text-overflow:ellipsis;white-space:pre}.ui-toc-dropdown .nav>li>a{color:#767676;display:block;font-size:13px;font-weight:500;padding:4px 20px}.ui-toc-dropdown .nav>li:first-child:last-child>ul,.ui-toc-dropdown .toc.expand ul{display:block}.ui-toc-dropdown .nav>li>a:focus,.ui-toc-dropdown .nav>li>a:hover{background-color:initial;border-left:1px solid #000;color:#000;padding-left:19px;text-decoration:none}.ui-toc-dropdown[dir=rtl] .nav>li>a:focus,.ui-toc-dropdown[dir=rtl] .nav>li>a:hover{border-left:none;border-right:1px solid #000;padding-right:19px}.ui-toc-dropdown .nav>.active:focus>a,.ui-toc-dropdown .nav>.active:hover>a,.ui-toc-dropdown .nav>.active>a{background-color:initial;border-left:2px solid #000;color:#000;font-weight:700;padding-left:18px}.ui-toc-dropdown[dir=rtl] .nav>.active:focus>a,.ui-toc-dropdown[dir=rtl] .nav>.active:hover>a,.ui-toc-dropdown[dir=rtl] .nav>.active>a{border-left:none;border-right:2px solid #000;padding-right:18px}.ui-toc-dropdown .nav .nav{display:none;padding-bottom:10px}.ui-toc-dropdown .nav>.active>ul{display:block}.ui-toc-dropdown .nav .nav>li>a{font-size:12px;font-weight:400;padding-bottom:1px;padding-left:30px;padding-top:1px}.ui-toc-dropdown[dir=rtl] .nav .nav>li>a{padding-right:30px}.ui-toc-dropdown .nav .nav>li>ul>li>a{font-size:12px;font-weight:400;padding-bottom:1px;padding-left:40px;padding-top:1px}.ui-toc-dropdown[dir=rtl] .nav .nav>li>ul>li>a{padding-right:40px}.ui-toc-dropdown .nav .nav>li>a:focus,.ui-toc-dropdown .nav .nav>li>a:hover{padding-left:29px}.ui-toc-dropdown[dir=rtl] .nav .nav>li>a:focus,.ui-toc-dropdown[dir=rtl] .nav .nav>li>a:hover{padding-right:29px}.ui-toc-dropdown .nav .nav>li>ul>li>a:focus,.ui-toc-dropdown .nav .nav>li>ul>li>a:hover{padding-left:39px}.ui-toc-dropdown[dir=rtl] .nav .nav>li>ul>li>a:focus,.ui-toc-dropdown[dir=rtl] .nav .nav>li>ul>li>a:hover{padding-right:39px}.ui-toc-dropdown .nav .nav>.active:focus>a,.ui-toc-dropdown .nav .nav>.active:hover>a,.ui-toc-dropdown .nav .nav>.active>a{font-weight:500;padding-left:28px}.ui-toc-dropdown[dir=rtl] .nav .nav>.active:focus>a,.ui-toc-dropdown[dir=rtl] .nav .nav>.active:hover>a,.ui-toc-dropdown[dir=rtl] .nav .nav>.active>a{padding-right:28px}.ui-toc-dropdown .nav .nav>.active>.nav>.active:focus>a,.ui-toc-dropdown .nav .nav>.active>.nav>.active:hover>a,.ui-toc-dropdown .nav .nav>.active>.nav>.active>a{font-weight:500;padding-left:38px}.ui-toc-dropdown[dir=rtl] .nav .nav>.active>.nav>.active:focus>a,.ui-toc-dropdown[dir=rtl] .nav .nav>.active>.nav>.active:hover>a,.ui-toc-dropdown[dir=rtl] .nav .nav>.active>.nav>.active>a{padding-right:38px}.markdown-body{font-family:-apple-system,BlinkMacSystemFont,Segoe UI,Helvetica Neue,Helvetica,Roboto,Arial,sans-serif,Apple Color Emoji,Segoe UI Emoji,Segoe UI Symbol}html[lang^=ja] .markdown-body{font-family:-apple-system,BlinkMacSystemFont,Segoe UI,Helvetica Neue,Helvetica,Roboto,Arial,Hiragino Kaku Gothic Pro,ヒラギノ角ゴ Pro W3,Osaka,Meiryo,メイリオ,MS Gothic,ＭＳ ゴシック,sans-serif,Apple Color Emoji,Segoe UI Emoji,Segoe UI Symbol}html[lang=zh-tw] .markdown-body{font-family:-apple-system,BlinkMacSystemFont,Segoe UI,Helvetica Neue,Helvetica,Roboto,Arial,PingFang TC,Microsoft JhengHei,微軟正黑,sans-serif,Apple Color Emoji,Segoe UI Emoji,Segoe UI Symbol}html[lang=zh-cn] .markdown-body{font-family:-apple-system,BlinkMacSystemFont,Segoe UI,Helvetica Neue,Helvetica,Roboto,Arial,PingFang SC,Microsoft YaHei,微软雅黑,sans-serif,Apple Color Emoji,Segoe UI Emoji,Segoe UI Symbol}html .markdown-body[lang^=ja]{font-family:-apple-system,BlinkMacSystemFont,Segoe UI,Helvetica Neue,Helvetica,Roboto,Arial,Hiragino Kaku Gothic Pro,ヒラギノ角ゴ Pro W3,Osaka,Meiryo,メイリオ,MS Gothic,ＭＳ ゴシック,sans-serif,Apple Color Emoji,Segoe UI Emoji,Segoe UI Symbol}html .markdown-body[lang=zh-tw]{font-family:-apple-system,BlinkMacSystemFont,Segoe UI,Helvetica Neue,Helvetica,Roboto,Arial,PingFang TC,Microsoft JhengHei,微軟正黑,sans-serif,Apple Color Emoji,Segoe UI Emoji,Segoe UI Symbol}html .markdown-body[lang=zh-cn]{font-family:-apple-system,BlinkMacSystemFont,Segoe UI,Helvetica Neue,Helvetica,Roboto,Arial,PingFang SC,Microsoft YaHei,微软雅黑,sans-serif,Apple Color Emoji,Segoe UI Emoji,Segoe UI Symbol}html[lang^=ja] .ui-toc-dropdown{font-family:Source Sans Pro,Helvetica,Arial,Meiryo UI,MS PGothic,ＭＳ Ｐゴシック,sans-serif}html[lang=zh-tw] .ui-toc-dropdown{font-family:Source Sans Pro,Helvetica,Arial,Microsoft JhengHei UI,微軟正黑UI,sans-serif}html[lang=zh-cn] .ui-toc-dropdown{font-family:Source Sans Pro,Helvetica,Arial,Microsoft YaHei UI,微软雅黑UI,sans-serif}html .ui-toc-dropdown[lang^=ja]{font-family:Source Sans Pro,Helvetica,Arial,Meiryo UI,MS PGothic,ＭＳ Ｐゴシック,sans-serif}html .ui-toc-dropdown[lang=zh-tw]{font-family:Source Sans Pro,Helvetica,Arial,Microsoft JhengHei UI,微軟正黑UI,sans-serif}html .ui-toc-dropdown[lang=zh-cn]{font-family:Source Sans Pro,Helvetica,Arial,Microsoft YaHei UI,微软雅黑UI,sans-serif}.ui-affix-toc{max-height:70vh;max-width:15vw;overflow:auto;position:fixed;top:0}.back-to-top,.expand-toggle,.go-to-bottom{color:#999;display:block;font-size:12px;font-weight:500;margin-left:10px;margin-top:10px;padding:4px 10px}.back-to-top:focus,.back-to-top:hover,.expand-toggle:focus,.expand-toggle:hover,.go-to-bottom:focus,.go-to-bottom:hover{color:#563d7c;text-decoration:none}.back-to-top,.go-to-bottom{margin-top:0}.ui-user-icon{background-position:50%;background-repeat:no-repeat;background-size:cover;border-radius:50%;display:block;height:20px;margin-bottom:2px;margin-right:5px;margin-top:2px;width:20px}.ui-user-icon.small{display:inline-block;height:18px;margin:0 0 .2em;vertical-align:middle;width:18px}.ui-infobar>small>span{line-height:22px}.ui-infobar>small .dropdown{display:inline-block}.ui-infobar>small .dropdown a:focus,.ui-infobar>small .dropdown a:hover{text-decoration:none}.ui-more-info{color:#888;cursor:pointer;vertical-align:middle}.ui-more-info .fa{font-size:16px}.ui-connectedGithub,.ui-published-note{color:#888}.ui-connectedGithub{line-height:23px;white-space:nowrap}.ui-connectedGithub a.file-path{color:#888;padding-left:22px;text-decoration:none}.ui-connectedGithub a.file-path:active,.ui-connectedGithub a.file-path:hover{color:#888;text-decoration:underline}.ui-connectedGithub .fa{font-size:20px}.ui-published-note .fa{font-size:20px;vertical-align:top}.unselectable{-webkit-user-select:none;-o-user-select:none;user-select:none}.selectable{-webkit-user-select:text;-o-user-select:text;user-select:text}.inline-spoiler-section{cursor:pointer}.inline-spoiler-section .spoiler-text{background-color:#333;border-radius:2px}.inline-spoiler-section .spoiler-text>*{opacity:0}.inline-spoiler-section .spoiler-img{filter:blur(10px)}.inline-spoiler-section.raw{background-color:#333;border-radius:2px}.inline-spoiler-section.raw>*{opacity:0}.inline-spoiler-section.unveil{cursor:auto}.inline-spoiler-section.unveil .spoiler-text{background-color:#3333331a}.inline-spoiler-section.unveil .spoiler-text>*{opacity:1}.inline-spoiler-section.unveil .spoiler-img{filter:none}@media print{blockquote,div,img,pre,table{page-break-inside:avoid!important}a[href]:after{font-size:12px!important}}.markdown-body.slides{color:#222;position:relative;z-index:1}.markdown-body.slides:before{background-color:currentColor;bottom:0;box-shadow:0 0 0 50vw;content:"";display:block;left:0;position:absolute;right:0;top:0;z-index:-1}.markdown-body.slides section[data-markdown]{background-color:#fff;margin-bottom:1.5em;position:relative;text-align:center}.markdown-body.slides section[data-markdown] code{text-align:left}.markdown-body.slides section[data-markdown]:before{content:"";display:block;padding-bottom:56.23%}.markdown-body.slides section[data-markdown]>div:first-child{left:1em;max-height:100%;overflow:hidden;position:absolute;right:1em;top:50%;transform:translateY(-50%)}.markdown-body.slides section[data-markdown]>ul{display:inline-block}.markdown-body.slides>section>section+section:after{border:3px solid #777;content:"";height:1.5em;position:absolute;right:1em;top:-1.5em}.site-ui-font{font-family:Source Sans Pro,Helvetica,Arial,sans-serif}html[lang^=ja] .site-ui-font{font-family:Source Sans Pro,Helvetica,Arial,Hiragino Kaku Gothic Pro,ヒラギノ角ゴ Pro W3,Osaka,Meiryo,メイリオ,MS Gothic,ＭＳ ゴシック,sans-serif}html[lang=zh-tw] .site-ui-font{font-family:Source Sans Pro,Helvetica,Arial,PingFang TC,Microsoft JhengHei,微軟正黑,sans-serif}html[lang=zh-cn] .site-ui-font{font-family:Source Sans Pro,Helvetica,Arial,PingFang SC,Microsoft YaHei,微软雅黑,sans-serif}body{font-smoothing:subpixel-antialiased!important;-webkit-font-smoothing:subpixel-antialiased!important;-moz-osx-font-smoothing:auto!important;-webkit-overflow-scrolling:touch;font-family:Source Sans Pro,Helvetica,Arial,sans-serif;letter-spacing:.025em}html[lang^=ja] body{font-family:Source Sans Pro,Helvetica,Arial,Hiragino Kaku Gothic Pro,ヒラギノ角ゴ Pro W3,Osaka,Meiryo,メイリオ,MS Gothic,ＭＳ ゴシック,sans-serif}html[lang=zh-tw] body{font-family:Source Sans Pro,Helvetica,Arial,PingFang TC,Microsoft JhengHei,微軟正黑,sans-serif}html[lang=zh-cn] body{font-family:Source Sans Pro,Helvetica,Arial,PingFang SC,Microsoft YaHei,微软雅黑,sans-serif}abbr[title]{border-bottom:none;text-decoration:underline;-webkit-text-decoration:underline dotted;text-decoration:underline dotted}abbr[data-original-title],abbr[title]{cursor:help}body.modal-open{overflow-y:auto;padding-right:0!important}svg{text-shadow:none}
    </style>
    <!-- HTML5 shim and Respond.js for IE8 support of HTML5 elements and media queries -->
    <!-- WARNING: Respond.js doesn't work if you view the page via file:// -->
    <!--[if lt IE 9]>
    	<script src="https://cdnjs.cloudflare.com/ajax/libs/html5shiv/3.7.3/html5shiv.min.js" integrity="sha256-3Jy/GbSLrg0o9y5Z5n1uw0qxZECH7C6OQpVBgNFYa0g=" crossorigin="anonymous"></script>
    	<script src="https://cdnjs.cloudflare.com/ajax/libs/respond.js/1.4.2/respond.min.js" integrity="sha256-g6iAfvZp+nDQ2TdTR/VVKJf3bGro4ub5fvWSWVRi2NE=" crossorigin="anonymous"></script>
		<script src="https://cdnjs.cloudflare.com/ajax/libs/es5-shim/4.5.9/es5-shim.min.js" integrity="sha256-8E4Is26QH0bD52WoQpcB+R/tcWQtpzlCojrybUd7Mxo=" crossorigin="anonymous"></script>
    <![endif]-->
</head>

<body>
    <div id="doc" class="markdown-body container-fluid comment-enabled" data-hard-breaks="true" style=""><p><strong><span>Document number</span></strong><span>: P3330R0</span><br>
<strong><span>Date</span></strong><span>: 2024-6-17.</span><br>
<strong><span>Authors</span></strong><span>: Gonzalo Brito Gadeschi, Damien Lebrun-Grandie.</span><br>
<strong><span>Reply to</span></strong><span>: Gonzalo Brito Gadeschi &lt;gonzalob _at_ </span><a href="http://nvidia.com" target="_blank" rel="noopener"><span>nvidia.com</span></a><span>&gt;.</span><br>
<strong><span>Audience</span></strong><span>: SG1.</span></p><style>
ins {
    color:green;
    text-decoration:underline;
}
del {
    color:red;
    background-color:yellow;
    text-decoration:line-through;
}
bdi {
    color:black;
    background-color:lightblue;
    text-decoration:underline;
}
.markdown-body {
    max-width: 900px;
    text-align: justify;
}
</style><p><big><span>Table of Contents</span></big></p><p><span class="toc"><ul>
<li><a href="#User-defined-Atomic-Read-Modify-Write-Operations" title="User-defined Atomic Read-Modify-Write Operations">User-defined Atomic Read-Modify-Write Operations</a><ul>
<li><a href="#Motivation" title="Motivation">Motivation</a></li>
<li><a href="#Design" title="Design">Design</a><ul>
<li><a href="#Implementation-strategies" title="Implementation strategies">Implementation strategies</a></li>
<li><a href="#Requirements-on-the-user-defined-operation" title="Requirements on the user-defined operation">Requirements on the user-defined operation</a></li>
<li><a href="#Requirements-on-the-implementation" title="Requirements on the implementation">Requirements on the implementation</a></li>
<li><a href="#Limitations-for-users" title="Limitations for users">Limitations for users</a></li>
</ul>
</li>
<li><a href="#Alternatives" title="Alternatives">Alternatives</a><ul>
<li><a href="#Does-restricting-UnaryOp-to-be-constexpr-suffice" title="Does restricting UnaryOp to be constexpr suffice?">Does restricting UnaryOp to be constexpr suffice?</a></li>
<li><a href="#Portable-CAS-loop" title="Portable CAS-loop">Portable CAS-loop</a></li>
<li><a href="#Transactional-guarantees" title="Transactional guarantees">Transactional guarantees</a></li>
<li><a href="#stdexpected-based-API" title="std::expected-based API">std::expected-based API</a></li>
<li><a href="#Function-object-return-type" title="Function object return type">Function object return type</a></li>
<li><a href="#Prior-art" title="Prior art">Prior art</a></li>
</ul>
</li>
<li><a href="#Wording" title="Wording">Wording</a></li>
</ul>
</li>
</ul>
</span></p><h1 id="User-defined-Atomic-Read-Modify-Write-Operations" data-id="User-defined-Atomic-Read-Modify-Write-Operations" style=""><a class="anchor hidden-xs" href="#User-defined-Atomic-Read-Modify-Write-Operations" title="User-defined-Atomic-Read-Modify-Write-Operations"><span class="octicon octicon-link"></span></a><span>User-defined Atomic Read-Modify-Write Operations</span></h1><p><span>We propose extending the read-modify-write APIs of </span><code>std::atomic</code><span> and </span><code>std::atomic_ref</code><span> with user-defined read-modify-write atomic operations. These move the responsibility of writing CAS-like loops from user code into the implementation, improving the portability, performance, and forward-progress of C++ applications.</span></p><h2 id="Motivation" data-id="Motivation" style=""><a class="anchor hidden-xs" href="#Motivation" title="Motivation"><span class="octicon octicon-link"></span></a><span>Motivation</span></h2><p><span>Without these extensions, users are required to implement user-defined read-modify-write operations with </span><code>compare_exchange</code><span> loops (CAS-loops from now on), which:</span></p><ul>
<li><span>are hard to write correctly without compromising the QoI of forward progress,</span></li>
<li><span>complicate compiler optimizations (no compiler optimizes a CAS-loop that does an </span><code>add</code><span> into an atomic read-modify-write </span><code>fetch_add</code><span>), and</span></li>
<li><span>do not perform well for non-lockfree atomics since CAS-loops take and release the lock multiple times per iteration.</span></li>
</ul><h2 id="Design" data-id="Design" style=""><a class="anchor hidden-xs" href="#Design" title="Design"><span class="octicon octicon-link"></span></a><span>Design</span></h2><blockquote>
<p><strong><span>Note</span></strong><span>: a portable reference implementation is provided </span><a href="https://gcc.godbolt.org/z/jvo8jEfzj" target="_blank" rel="noopener"><span>here</span></a><span> for exposition purposes.</span></p>
</blockquote><p><span>We propose extending </span><code>std::atomic</code><span> and </span><code>std::atomic_ref</code><span> with user-defined read-modify-write atomic operations:</span></p><pre><code class="wrap cpp hljs"><span class="token keyword">template</span> <span class="token operator">&lt;</span><span class="token keyword">typename</span> <span class="token class-name">T</span><span class="token punctuation">,</span> <span class="token keyword">typename</span> <span class="token class-name">UnaryOp</span><span class="token operator">&gt;</span>
<span class="token keyword">bool</span> <span class="token function">fetch_update</span><span class="token punctuation">(</span>T<span class="token operator">&amp;</span> old<span class="token punctuation">,</span> UnaryOp uop<span class="token punctuation">,</span> 
                  memory_order order <span class="token operator">=</span> memory_order<span class="token double-colon punctuation">::</span>seq_cst<span class="token punctuation">)</span> <span class="token keyword">const</span> <span class="token keyword">noexcept</span><span class="token punctuation">;</span>

<span class="token keyword">template</span> <span class="token operator">&lt;</span><span class="token keyword">typename</span> <span class="token class-name">T</span><span class="token punctuation">,</span> <span class="token keyword">typename</span> <span class="token class-name">UnaryOp</span><span class="token operator">&gt;</span>
<span class="token keyword">bool</span> <span class="token function">fetch_update</span><span class="token punctuation">(</span>T<span class="token operator">&amp;</span> old<span class="token punctuation">,</span> UnaryOp uop<span class="token punctuation">,</span> 
                  memory_order success <span class="token operator">=</span> memory_order<span class="token double-colon punctuation">::</span>seq_cst<span class="token punctuation">,</span>
                  memory_order failure <span class="token operator">=</span> memory_order<span class="token double-colon punctuation">::</span>seq_cst<span class="token punctuation">)</span> <span class="token keyword">const</span> <span class="token keyword">noexcept</span><span class="token punctuation">;</span>
</code></pre><p><span>The result of the unary operation </span><code>uop</code><span> is used to atomically update the value refered by the atomic type and it may be of type </span><code>T</code><span> or </span><code>optional&lt;T&gt;</code><span>. If </span><code>uop</code><span> returns:</span></p><ul>
<li><span>a value of type </span><code>T</code><span>, or of type </span><code>optional&lt;T&gt;</code><span> with </span><code>has_value()</code><span> true, then </span><code>fetch_update</code><span> writes the value returned by </span><code>uop</code><span> to memory and returns </span><code>true</code><span> to indicate its effect is that of an atomic read-modify-write operation,</span></li>
<li><code>nullopt</code><span>, then </span><code>fetch_update</code><span> returns </span><code>false</code><span> to indicate its effect is that of an atomic read operation.</span></li>
</ul><p><span>In both cases, the value fetched by </span><code>fetch_update</code><span> and passed to </span><code>uop</code><span> is written to </span><code>old</code><span>.</span></p><p><span>This API is similar to that of </span><code>compare_exchange</code><span> operations and enables exposing vendor-specific atomic operations (e.g., </span><code>fetch_fp_exp</code><span>):</span></p><table>
<tbody><tr>
<td>
<p><strong><span>Before</span></strong></p>
</td>
<td>
<p><strong><span>After</span></strong></p>
</td>    
</tr>
<tr>
<td>
<pre><code class="cpp hljs"><div class="wrapper"><div class="gutter linenumber"><span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span></div><div class="code"><span class="token macro property"><span class="token directive-hash">#</span><span class="token directive keyword">include</span> <span class="token string">&lt;atomic&gt;</span></span>
atomic<span class="token operator">&lt;</span><span class="token keyword">float</span><span class="token operator">&gt;</span> a <span class="token operator">=</span> <span class="token number">0.f</span><span class="token punctuation">;</span>
    
<span class="token keyword">int</span> <span class="token function">main</span><span class="token punctuation">(</span><span class="token punctuation">)</span> <span class="token punctuation">{</span>
  <span class="token keyword">float</span> old <span class="token operator">=</span> a<span class="token punctuation">.</span><span class="token function">load</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">,</span> next<span class="token punctuation">;</span>
  <span class="token keyword">do</span> <span class="token punctuation">{</span>
    next <span class="token operator">=</span> std<span class="token double-colon punctuation">::</span><span class="token function">fexp</span><span class="token punctuation">(</span>old<span class="token punctuation">,</span> <span class="token number">2.f</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
  <span class="token punctuation">}</span> <span class="token keyword">while</span><span class="token punctuation">(</span>a<span class="token punctuation">.</span><span class="token function">compare_exchange_strong</span><span class="token punctuation">(</span>old<span class="token punctuation">,</span> next<span class="token punctuation">)</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
  <span class="token keyword">return</span> <span class="token number">0</span><span class="token punctuation">;</span>    
<span class="token punctuation">}</span>
</div></div></code></pre>
</td>
<td>
<pre><code class="cpp hljs"><div class="wrapper"><div class="gutter linenumber"><span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span></div><div class="code"><span class="token macro property"><span class="token directive-hash">#</span><span class="token directive keyword">include</span> <span class="token string">&lt;atomic&gt;</span></span>
atomic<span class="token operator">&lt;</span><span class="token keyword">float</span><span class="token operator">&gt;</span> a <span class="token operator">=</span> <span class="token number">0.f</span><span class="token punctuation">;</span>
    
<span class="token keyword">int</span> <span class="token function">main</span><span class="token punctuation">(</span><span class="token punctuation">)</span> <span class="token punctuation">{</span>
  <span class="token keyword">float</span> old<span class="token punctuation">;</span>
  a<span class="token punctuation">.</span><span class="token function">fetch_update</span><span class="token punctuation">(</span>old<span class="token punctuation">,</span> <span class="token punctuation">[</span><span class="token punctuation">]</span><span class="token punctuation">(</span><span class="token keyword">float</span> o<span class="token punctuation">)</span> <span class="token punctuation">{</span>
      <span class="token keyword">return</span> std<span class="token double-colon punctuation">::</span><span class="token function">fexp</span><span class="token punctuation">(</span>o<span class="token punctuation">,</span> <span class="token number">2.f</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
  <span class="token punctuation">}</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
  <span class="token keyword">return</span> <span class="token number">0</span><span class="token punctuation">;</span>    
<span class="token punctuation">}</span>
</div></div></code></pre>
</td>    
</tr>
</tbody></table><p><span>The following example shows how to use the API to update a </span><code>pair</code><span> depending on the value of one of its sub-objects, aborting the update and turning the operation into an atomic read when a certain condition is met:</span></p><pre><code class="cpp hljs"><div class="wrapper"><div class="gutter linenumber"><span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span></div><div class="code">atomic<span class="token operator">&lt;</span>pair<span class="token operator">&lt;</span><span class="token keyword">char</span><span class="token punctuation">,</span> <span class="token keyword">short</span><span class="token operator">&gt;&gt;</span> atom<span class="token punctuation">;</span>
    
pair<span class="token operator">&lt;</span><span class="token keyword">char</span><span class="token punctuation">,</span> <span class="token keyword">short</span><span class="token operator">&gt;</span> old<span class="token punctuation">;</span>
<span class="token keyword">bool</span> success 
  <span class="token operator">=</span> atom<span class="token punctuation">.</span><span class="token function">fetch_update</span><span class="token punctuation">(</span>old<span class="token punctuation">,</span> <span class="token punctuation">[</span><span class="token punctuation">]</span><span class="token punctuation">(</span>pair<span class="token operator">&lt;</span><span class="token keyword">char</span><span class="token punctuation">,</span> <span class="token keyword">short</span><span class="token operator">&gt;</span> p<span class="token punctuation">)</span> <span class="token operator">-&gt;</span> optional<span class="token operator">&lt;</span>par<span class="token operator">&lt;</span><span class="token keyword">char</span><span class="token punctuation">,</span> <span class="token keyword">short</span><span class="token operator">&gt;&gt;</span> <span class="token punctuation">{</span>
    <span class="token keyword">if</span> <span class="token punctuation">(</span>p<span class="token punctuation">.</span>first <span class="token operator">&gt;</span> <span class="token number">42</span><span class="token punctuation">)</span> <span class="token keyword">return</span> nullopt<span class="token punctuation">;</span>
    <span class="token keyword">return</span> <span class="token function">make_pair</span><span class="token punctuation">(</span>p<span class="token punctuation">.</span>first<span class="token operator">+</span><span class="token number">1</span><span class="token punctuation">,</span> p<span class="token punctuation">.</span>second<span class="token operator">+</span><span class="token number">2</span><span class="token punctuation">)</span><span class="token punctuation">}</span><span class="token punctuation">;</span>
<span class="token punctuation">}</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token function">assert</span><span class="token punctuation">(</span><span class="token punctuation">(</span>success <span class="token operator">&amp;&amp;</span> old<span class="token punctuation">.</span>first <span class="token operator">&lt;=</span> <span class="token number">42</span><span class="token punctuation">)</span> <span class="token operator">||</span> <span class="token punctuation">(</span><span class="token operator">!</span>success <span class="token operator">&amp;&amp;</span> old<span class="token punctuation">.</span>first <span class="token operator">&gt;</span> <span class="token number">42</span><span class="token punctuation">)</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
</div></div></code></pre><h3 id="Implementation-strategies" data-id="Implementation-strategies" style=""><a class="anchor hidden-xs" href="#Implementation-strategies" title="Implementation-strategies"><span class="octicon octicon-link"></span></a><span>Implementation strategies</span></h3><p><span>The semantics this API may provide are restricted by the implementation strategies allowed and vice-versa. This design chooses to support, among others, following implementation strategies:</span></p><ol>
<li><strong><span>CAS-loop</span></strong><span> based implementation using atomic CAS operations.</span></li>
<li><strong><span>Lock</span></strong><span> based implementations that take the lock:</span>
<ul>
<li><span>Multiple-times (e.g. lock-based CAS-loop).</span></li>
<li><span>Only once.</span></li>
</ul>
</li>
<li><strong><span>LL/SC</span></strong><span> based implementations.</span></li>
<li><strong><span>Hardware Transactional Memory</span></strong><span> (HTM) based implementations.</span></li>
</ol><p><span>The design also aims at simplifying the implementation requirements for leveraging hardware acceleration.</span></p><h3 id="Requirements-on-the-user-defined-operation" data-id="Requirements-on-the-user-defined-operation" style=""><a class="anchor hidden-xs" href="#Requirements-on-the-user-defined-operation" title="Requirements-on-the-user-defined-operation"><span class="octicon octicon-link"></span></a><span>Requirements on the user-defined operation</span></h3><p><span>To support these implementation strategies, the </span><code>UnaryOp(T)</code><span> call-operator and </span><code>uop(old)</code><span> call-expression are required to:</span></p><ul>
<li><span>satisfy </span><code>regular_invocable</code><span> (for same inputs, produces same output), and</span></li>
<li><span>be an implicit-lifetime type, and</span></li>
<li><code>noexcept(declval&lt;UnaryOp&gt;()(declval&lt;T&gt;()))</code><span> is true, and,</span></li>
<li><span>only accesses its operands or its non-static data-members, and</span></li>
<li><span>not perform a library I/O function call, a synchronization operation, or an atomic operation, and</span></li>
<li><span>eventually return.</span></li>
</ul><p><span>This requirements should imply that:</span></p><ul>
<li><span>the only side-effects </span><code>uop(old)</code><span> may have are modifying its non-static data members,</span></li>
<li><span>for the same inputs it always produces the same outputs, independetly of whether other state of the program has changed because </span><code>uop(old)</code><span> can't access such state.</span></li>
</ul><h3 id="Requirements-on-the-implementation" data-id="Requirements-on-the-implementation" style=""><a class="anchor hidden-xs" href="#Requirements-on-the-implementation" title="Requirements-on-the-implementation"><span class="octicon octicon-link"></span></a><span>Requirements on the implementation</span></h3><p><span>The effect of </span><code>fetch_update</code><span> is to call </span><code>uop(old)</code><span> </span><em><span>exactly once</span></em><span>. Implementation strategies that call </span><code>uop(old)</code><span> multiple times are allowed as long as they behave "as if" </span><code>uop(old)</code><span> was called exactly once.</span></p><p><span>For example, CAS-loop based implementations must use that </span><code>UnaryOp</code><span> is implicit-lifetime to back up the </span><code>uop</code><span> object, and call </span><code>uop(old)</code><span> on a fresh copy of the backup every iteration, to discard any modifications that </span><code>uop(old)</code><span> may have done to the </span><code>uop</code><span> object itself.</span></p><h3 id="Limitations-for-users" data-id="Limitations-for-users" style=""><a class="anchor hidden-xs" href="#Limitations-for-users" title="Limitations-for-users"><span class="octicon octicon-link"></span></a><span>Limitations for users</span></h3><p><span>The major downsides of these requirements are that:</span></p><ul>
<li><span>they prevent the use of </span><code>printf</code><span>-based debugging within </span><code>UnaryOp</code><span>,</span></li>
</ul><p><span>Do the requirements protect from </span><a href="https://en.wikipedia.org/wiki/ABA_problem" target="_blank" rel="noopener"><span>ABA</span></a><span>? (TODO: add an example showing that they do not).</span></p><h2 id="Alternatives" data-id="Alternatives" style=""><a class="anchor hidden-xs" href="#Alternatives" title="Alternatives"><span class="octicon octicon-link"></span></a><span>Alternatives</span></h2><h3 id="Does-restricting-UnaryOp-to-be-constexpr-suffice" data-id="Does-restricting-UnaryOp-to-be-constexpr-suffice" style=""><a class="anchor hidden-xs" href="#Does-restricting-UnaryOp-to-be-constexpr-suffice" title="Does-restricting-UnaryOp-to-be-constexpr-suffice"><span class="octicon octicon-link"></span></a><span>Does restricting </span><code>UnaryOp</code><span> to be </span><code>constexpr</code><span> suffice?</span></h3><p><span>No, </span><code>constexpr</code><span> functions in C++26 may not return in a finite set of steps, e.g., on free-standing implementations that do not replace the empty iteration statement in </span><code>while(1);</code><span> with a call to the non-</span><code>constexpr</code><span> API </span><code>std::this_thread::yield()</code><span>, enabling </span><code>while(1)</code><span> within constant evaluation:</span></p><pre><code class="cpp hljs"><span class="token keyword">constexpr</span> <span class="token keyword">void</span> <span class="token function">hang</span><span class="token punctuation">(</span><span class="token punctuation">)</span> <span class="token punctuation">{</span> <span class="token keyword">while</span><span class="token punctuation">(</span><span class="token number">1</span><span class="token punctuation">)</span><span class="token punctuation">;</span> <span class="token punctuation">}</span>
</code></pre><p><span>Furthermore, </span><a href="http://wg21.link/P3309" target="_blank" rel="noopener"><span>P3309</span></a><span> proposes </span><code>constexpr</code><span> atomics and synchronization operations.</span></p><h4 id="Notes-on-Forward-progress" data-id="Notes-on-Forward-progress"><a class="anchor hidden-xs" href="#Notes-on-Forward-progress" title="Notes-on-Forward-progress"><span class="octicon octicon-link"></span></a><span>Notes on Forward progress</span></h4><p><span>Notice that relaxing </span><code>UnaryOp</code><span> constraints to:</span></p><ul>
<li><span>allowing </span><code>UnaryOp</code><span> to write to memory outside the </span><code>UnaryOp</code><span> itself, and</span></li>
<li><span>calling synchronization functions (like atomics),</span></li>
</ul><p><span>would make the following program legal:</span></p><pre><code class="wrap cpp hljs"><span class="token comment">// Litmus test 0: discovered concurrency</span>
atomic<span class="token operator">&lt;</span><span class="token keyword">int</span><span class="token operator">&gt;</span> atom<span class="token punctuation">,</span> counter <span class="token operator">=</span> <span class="token number">0</span><span class="token punctuation">;</span>
<span class="token keyword">static_assert</span><span class="token punctuation">(</span>atomic<span class="token operator">&lt;</span><span class="token keyword">int</span><span class="token operator">&gt;</span><span class="token double-colon punctuation">::</span>is_lockfree<span class="token punctuation">)</span><span class="token punctuation">;</span>

<span class="token keyword">int</span> <span class="token function">main</span><span class="token punctuation">(</span><span class="token punctuation">)</span> <span class="token punctuation">{</span>
  std<span class="token double-colon punctuation">::</span>jthread <span class="token function">t0</span><span class="token punctuation">(</span><span class="token punctuation">[</span><span class="token operator">&amp;</span><span class="token punctuation">]</span> <span class="token punctuation">{</span> atom<span class="token punctuation">.</span><span class="token function">fetch_update</span><span class="token punctuation">(</span><span class="token punctuation">[</span><span class="token operator">&amp;</span><span class="token punctuation">]</span><span class="token punctuation">(</span><span class="token keyword">int</span><span class="token punctuation">)</span> <span class="token punctuation">{</span>
    counter<span class="token operator">++</span><span class="token punctuation">;</span>
    <span class="token keyword">while</span><span class="token punctuation">(</span>counter<span class="token punctuation">.</span><span class="token function">load</span><span class="token punctuation">(</span><span class="token punctuation">)</span> <span class="token operator">!=</span> <span class="token number">2</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
    <span class="token keyword">return</span> <span class="token number">0</span><span class="token punctuation">;</span>
  <span class="token punctuation">}</span><span class="token punctuation">)</span><span class="token punctuation">}</span><span class="token punctuation">)</span><span class="token punctuation">;</span>

  std<span class="token double-colon punctuation">::</span>jthread <span class="token function">t1</span><span class="token punctuation">(</span><span class="token punctuation">[</span><span class="token operator">&amp;</span><span class="token punctuation">]</span> <span class="token punctuation">{</span> atom<span class="token punctuation">.</span><span class="token function">fetch_update</span><span class="token punctuation">(</span><span class="token punctuation">[</span><span class="token operator">&amp;</span><span class="token punctuation">]</span><span class="token punctuation">(</span><span class="token keyword">int</span><span class="token punctuation">)</span> <span class="token punctuation">{</span>
    counter<span class="token operator">++</span><span class="token punctuation">;</span>
    <span class="token keyword">while</span><span class="token punctuation">(</span>counter<span class="token punctuation">.</span><span class="token function">load</span><span class="token punctuation">(</span><span class="token punctuation">)</span> <span class="token operator">!=</span> <span class="token number">2</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
    <span class="token keyword">return</span> <span class="token number">0</span><span class="token punctuation">;</span>
  <span class="token punctuation">}</span><span class="token punctuation">)</span><span class="token punctuation">}</span><span class="token punctuation">)</span><span class="token punctuation">;</span>

  <span class="token keyword">return</span> <span class="token number">0</span><span class="token punctuation">;</span>
<span class="token punctuation">}</span>
</code></pre><p><span>If the specification would require that this program terminates, then the following implementations become invalid for this execution:</span></p><ol>
<li><span>Taking a single lock for the whole duration of </span><code>fetch_update</code><span>:</span>
<ul>
<li><span>Such an implementation deadlocks for the execution above.</span></li>
</ul>
</li>
<li><span>Hardware transactional memory (HTM):</span>
<ul>
<li><span>Such an implementation does not make progress: as transaction time out is exceeded, the transaction is reverted, including the counter++ update, before yielding to the other thread.</span></li>
</ul>
</li>
</ol><p><span>It would not prevent a lock-based implementation that uses a CAS-loop, since an implementation that takes the lock multiple times within </span><code>fetch_update</code><span> makes progress.</span></p><p><span>The restrictions above preserve these two implementation opportunities.</span></p><h3 id="Portable-CAS-loop" data-id="Portable-CAS-loop" style=""><a class="anchor hidden-xs" href="#Portable-CAS-loop" title="Portable-CAS-loop"><span class="octicon octicon-link"></span></a><span>Portable CAS-loop</span></h3><p><span>The proposed </span><code>fetch_update</code><span> semantics could be weakened by removing </span><em><span>all</span></em><span> restrictions on </span><code>UnaryOp</code><span>, since atomic read-modify-write operations are atomic w.r.t. the modification order of the memory location being operated on. This is the implementation pursued by, e.g., Rust's atomic </span><a href="https://doc.rust-lang.org/std/sync/atomic/struct.AtomicUsize.html#method.fetch_update" target="_blank" rel="noopener"><span>fetch_update</span></a><span> APIs.</span></p><p><span>Then </span><em><span>concurrent forward progress</span></em><span> guarantees that Litmust test 0 (discovered concurrency) terminates, which implementations that take a single-lock for the whole </span><code>fetch_update</code><span> or use HTM fail to uphold in that case.</span></p><p><span>That does not mean that single-lock or HTM cannot be used, but rather that compiler analysis is required to prove that </span><code>UnaryOp</code><span> does not perform any of the operations that would enable those implementations to be valid (if the compiler can prove that, then they can still be used).</span></p><p><span>The proposed semantics are forward compatible with this weakening, i.e., it can be done later without breaking any valid code.</span></p><h3 id="Transactional-guarantees" data-id="Transactional-guarantees" style=""><a class="anchor hidden-xs" href="#Transactional-guarantees" title="Transactional-guarantees"><span class="octicon octicon-link"></span></a><span>Transactional guarantees</span></h3><p><span>The proposed </span><code>fetch_update</code><span> semantics could be strengthened by guaranteeing that every </span><code>UnaryOp</code><span> call happens-before another </span><code>fetch_update</code><span> call as part of an atomic access to the same memory location.</span></p><p><span>This would require implementing </span><code>fetch_update</code><span> as an </span><em><span>atomic transaction</span></em><span> (e.g. as per </span><a href="https://open-std.org/JTC1/SC22/WG21/docs/papers/2021/p1875r2.pdf" target="_blank" rel="noopener"><span>P1875: Transactional Memory Lite</span></a><span>), and would guarantee the absence of data-races in the following litmus test:</span></p><pre><code class="cpp hljs"><div class="wrapper"><div class="gutter linenumber"><span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span></div><div class="code"><span class="token comment">// Litmus Test 1: atomic transaction</span>
atomic<span class="token operator">&lt;</span><span class="token keyword">int</span><span class="token operator">&gt;</span> atom<span class="token punctuation">;</span>
<span class="token keyword">int</span> counter <span class="token operator">=</span> <span class="token number">0</span><span class="token punctuation">;</span>

<span class="token keyword">int</span> <span class="token function">main</span><span class="token punctuation">(</span><span class="token punctuation">)</span> <span class="token punctuation">{</span>
  std<span class="token double-colon punctuation">::</span>jthread <span class="token function">t0</span><span class="token punctuation">(</span><span class="token punctuation">[</span><span class="token operator">&amp;</span><span class="token punctuation">]</span> <span class="token punctuation">{</span> atom<span class="token punctuation">.</span><span class="token function">fetch_update</span><span class="token punctuation">(</span><span class="token punctuation">[</span><span class="token operator">&amp;</span><span class="token punctuation">]</span><span class="token punctuation">(</span><span class="token keyword">int</span><span class="token punctuation">)</span> <span class="token punctuation">{</span>
    counter<span class="token operator">++</span><span class="token punctuation">;</span>
    <span class="token keyword">return</span> <span class="token number">0</span><span class="token punctuation">;</span>
  <span class="token punctuation">}</span><span class="token punctuation">)</span><span class="token punctuation">}</span><span class="token punctuation">)</span><span class="token punctuation">;</span>

  std<span class="token double-colon punctuation">::</span>jthread <span class="token function">t1</span><span class="token punctuation">(</span><span class="token punctuation">[</span><span class="token operator">&amp;</span><span class="token punctuation">]</span> <span class="token punctuation">{</span> atom<span class="token punctuation">.</span><span class="token function">fetch_update</span><span class="token punctuation">(</span><span class="token punctuation">[</span><span class="token operator">&amp;</span><span class="token punctuation">]</span><span class="token punctuation">(</span><span class="token keyword">int</span><span class="token punctuation">)</span> <span class="token punctuation">{</span>
    counter<span class="token operator">++</span><span class="token punctuation">;</span>
    <span class="token keyword">return</span> <span class="token number">0</span><span class="token punctuation">;</span>
  <span class="token punctuation">}</span><span class="token punctuation">)</span><span class="token punctuation">}</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
  <span class="token keyword">return</span> <span class="token number">0</span><span class="token punctuation">;</span>
<span class="token punctuation">}</span>
</div></div></code></pre><p><span>This strengthening would require implementing </span><code>fetch_update</code><span>:</span></p><ul>
<li><span>with a single lock for the whole </span><code>fetch_update</code><span>, or</span></li>
<li><span>hardware transactional memory.</span></li>
</ul><p><span>The proposed semantics are forward compatible with this strengthening, i.e., it can be done later without breaking any valid code.</span></p><h3 id="stdexpected-based-API" data-id="stdexpected-based-API" style=""><a class="anchor hidden-xs" href="#stdexpected-based-API" title="stdexpected-based-API"><span class="octicon octicon-link"></span></a><code>std::expected</code><span>-based API</span></h3><p><span>An alternative API choice is to use </span><code>std::expected</code><span> to return the value in the success or failure case:</span></p><pre><code class="wrap cpp hljs"><span class="token keyword">template</span> <span class="token operator">&lt;</span><span class="token keyword">typename</span> <span class="token class-name">UnaryOp</span><span class="token operator">&gt;</span>
expected<span class="token operator">&lt;</span>T<span class="token punctuation">,</span> T<span class="token operator">&gt;</span> <span class="token function">fetch_update</span><span class="token punctuation">(</span>UnaryOp uop<span class="token punctuation">,</span> 
               memory_order order <span class="token operator">=</span> memory_order<span class="token double-colon punctuation">::</span>seq_cst<span class="token punctuation">)</span> <span class="token keyword">const</span> <span class="token keyword">noexcept</span><span class="token punctuation">;</span>

atomic<span class="token operator">&lt;</span>pair<span class="token operator">&lt;</span><span class="token keyword">char</span><span class="token punctuation">,</span> <span class="token keyword">short</span><span class="token operator">&gt;&gt;</span> atom<span class="token punctuation">;</span>
    
<span class="token keyword">auto</span> r <span class="token operator">=</span> atom<span class="token punctuation">.</span><span class="token function">fetch_update</span><span class="token punctuation">(</span><span class="token punctuation">[</span><span class="token punctuation">]</span><span class="token punctuation">(</span>pair<span class="token operator">&lt;</span><span class="token keyword">char</span><span class="token punctuation">,</span> <span class="token keyword">short</span><span class="token operator">&gt;</span> p<span class="token punctuation">)</span> <span class="token operator">-&gt;</span> optional<span class="token operator">&lt;</span>pair<span class="token operator">&lt;</span><span class="token keyword">char</span><span class="token punctuation">,</span> <span class="token keyword">short</span><span class="token operator">&gt;&gt;</span> <span class="token punctuation">{</span>
    <span class="token keyword">if</span> <span class="token punctuation">(</span>p<span class="token punctuation">.</span>first <span class="token operator">&gt;</span> <span class="token number">42</span><span class="token punctuation">)</span> <span class="token keyword">return</span> nullopt<span class="token punctuation">;</span>
    <span class="token keyword">return</span> <span class="token function">make_pair</span><span class="token punctuation">(</span>p<span class="token punctuation">.</span>first<span class="token operator">+</span><span class="token number">1</span><span class="token punctuation">,</span> p<span class="token punctuation">.</span>second<span class="token operator">+</span><span class="token number">2</span><span class="token punctuation">)</span><span class="token punctuation">}</span><span class="token punctuation">;</span>
<span class="token punctuation">}</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token keyword">if</span> <span class="token punctuation">(</span>r<span class="token punctuation">)</span> <span class="token function">assert</span><span class="token punctuation">(</span>r<span class="token punctuation">.</span><span class="token function">value</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">.</span>first <span class="token operator">&lt;=</span> <span class="token number">42</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
<span class="token keyword">else</span> <span class="token function">assert</span><span class="token punctuation">(</span>r<span class="token punctuation">.</span><span class="token function">error</span><span class="token punctuation">(</span><span class="token punctuation">)</span><span class="token punctuation">.</span>first <span class="token operator">&gt;</span> <span class="token number">42</span><span class="token punctuation">)</span><span class="token punctuation">;</span>
</code></pre><h3 id="Function-object-return-type" data-id="Function-object-return-type" style=""><a class="anchor hidden-xs" href="#Function-object-return-type" title="Function-object-return-type"><span class="octicon octicon-link"></span></a><span>Function object return type</span></h3><p><span>The function object return type is mandated to be </span><code>T</code><span> or </span><code>optional&lt;T&gt;</code><span>.</span></p><p><span>Alternatives considered:</span></p><ul>
<li><code>UnaryOp(T, bool&amp;) -&gt; T</code><span> and signal failure through </span><code>bool&amp;</code><span>: requires constructing a </span><code>T</code><span> dead value for the return.</span></li>
<li><code>UnaryOp(T) -&gt; T</code><span> and signal failure by throwing an exception: no.</span></li>
<li><span>Don't support failure: e.g. by returning the same value as passed in, would either perform an extra write, or whether an atomic read-modify-write vs atomic read happens would be "implicit" depending on whether the value </span><code>memcmp</code><span>'s the same.</span></li>
</ul><h3 id="Prior-art" data-id="Prior-art" style=""><a class="anchor hidden-xs" href="#Prior-art" title="Prior-art"><span class="octicon octicon-link"></span></a><span>Prior art</span></h3><p><span>Rust's </span><a href="https://doc.rust-lang.org/std/sync/atomic/struct.AtomicUsize.html#method.fetch_update" target="_blank" rel="noopener"><span>fetch_update</span></a><span>. Kokkos uses a similar API internally.</span></p><h2 id="Wording" data-id="Wording" style=""><a class="anchor hidden-xs" href="#Wording" title="Wording"><span class="octicon octicon-link"></span></a><span>Wording</span></h2><p><span>Add feature test macro to </span><code>&lt;version&gt;</code><span> synopsis:</span></p><pre><code class="cpp hljs"><span class="token macro property"><span class="token directive-hash">#</span><span class="token directive keyword">define</span> <span class="token macro-name">__cpp_lib_atomic_fetch_update</span> <span class="token expression"><span class="token number">202</span>XXXL </span><span class="token comment">// also in &lt;atomic&gt;</span></span>
</code></pre><p><span>For each of the following specializations [atomics.ref.int], [atomics.ref.float], [atomics.types.int], [atomics.types.float], and the generic [atomics.ref.generic.general] and [atomics.types.generic.general], add the following public function after their last public function:</span></p><pre><code class="cpp hljs"><div class="wrapper"><div class="gutter linenumber"><span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span>
<span></span></div><div class="code"><span class="token punctuation">.</span><span class="token punctuation">.</span><span class="token punctuation">.</span>
<span class="token keyword">template</span> <span class="token operator">&lt;</span><span class="token keyword">typename</span> <span class="token class-name">T</span><span class="token punctuation">,</span> <span class="token keyword">typename</span> <span class="token class-name">UnaryOp</span><span class="token operator">&gt;</span>
<span class="token keyword">bool</span> <span class="token function">fetch_update</span><span class="token punctuation">(</span>T<span class="token operator">&amp;</span> old<span class="token punctuation">,</span> UnaryOp uop<span class="token punctuation">,</span> 
                  memory_order order <span class="token operator">=</span> memory_order<span class="token double-colon punctuation">::</span>seq_cst<span class="token punctuation">)</span> <span class="token keyword">const</span> <span class="token keyword">noexcept</span><span class="token punctuation">;</span>
<span class="token keyword">template</span> <span class="token operator">&lt;</span><span class="token keyword">typename</span> <span class="token class-name">T</span><span class="token punctuation">,</span> <span class="token keyword">typename</span> <span class="token class-name">UnaryOp</span><span class="token operator">&gt;</span>
<span class="token keyword">bool</span> <span class="token function">fetch_update</span><span class="token punctuation">(</span>T<span class="token operator">&amp;</span> old<span class="token punctuation">,</span> UnaryOp uop<span class="token punctuation">,</span> 
                  memory_order success <span class="token operator">=</span> memory_order<span class="token double-colon punctuation">::</span>seq_cst<span class="token punctuation">,</span>
                  memory_order failure <span class="token operator">=</span> memory_order<span class="token double-colon punctuation">::</span>seq_cst<span class="token punctuation">)</span> <span class="token keyword">const</span> <span class="token keyword">noexcept</span><span class="token punctuation">;</span>
<span class="token punctuation">.</span><span class="token punctuation">.</span><span class="token punctuation">.</span>
</div></div></code></pre><ul>
<li>
<p><ins><em><span>Mandates</span></em><span>: </span><code>regular_invocable&lt;UnaryOp, T&gt;</code><span> is true, </span><code>noexcept(uop(declval&lt;T&gt;()))</code><span> is true, and either </span><code>is_same_v&lt;invoke_result_t&lt;UnaryOp, T&gt;, T&gt;</code><span> or </span><code>is_same_v&lt;invoke_result_t&lt;UnaryOp, T&gt;, optional&lt;T&gt;&gt;</code><span> is true.</span></ins></p>
</li>
<li>
<p><ins><em><span>Preconditions</span></em><span>: </span><code>failure</code><span> is </span><code>memory_order::relaxed</code><span>, </span><code>memory_order::consume</code><span>, </span><code>memory_order::acquire</code><span>, or </span><code>memory_order::seq_cst</code><span>. The </span><code>UnaryOp</code><span> call operator selected by the </span><code>uop(old)</code><span> call expression:</span></ins></p>
<ul>
<li><ins><span>only accesses its operand or the non-static data-members of </span><code>uop</code><span>, and</span></ins></li>
<li><ins><span>does not perform a library I/O function call, a synchronization operation, or an atomic operation, and</span></ins></li>
<li><ins><span>eventually returns </span><a href="https://eel.is/c++draft/intro.progress" target="_blank" rel="noopener"><span>[intro.progress]</span></a><span>.</span></ins></li>
</ul>
</li>
<li>
<p><ins><em><span>Effects</span></em><span>: Atomically:</span></ins></p>
<ul>
<li><ins><span>retrieves the value referenced by </span><code>*ptr</code><span> into </span><code>old</code><span>, and</span></ins></li>
<li><ins><span>if </span><code>invoke_result_t&lt;UnaryOp, T&gt;</code><span> is </span><code>T</code><span>, replaces the value referenced by </span><code>*ptr</code><span> with the result of </span><code>uop(old)</code><span>, in which case memory is affected according to the value of </span><code>success</code><span>, or</span></ins></li>
<li><ins><code>uop(old).has_value()</code><span> is </span><code>true</code><span>, replaces the value referenced by </span><code>*ptr</code><span> with the result of </span><code>uop(old).value()</code><span>, in which case memory is affected according to the value of </span><code>success</code><span>, or</span></ins></li>
<li><ins><span>memory is affected according to the value of </span><code>failure</code><span>.</span></ins></li>
</ul>
<p><ins><span>When only one </span><code>memory_order</code><span> argument is supplied, the value of </span><code>success</code><span> is </span><code>order</code><span>, and the value of </span><code>failure</code><span> is </span><code>order</code><span> except that a value of </span><code>memory_order::acq_rel</code><span> shall be replaced by the value </span><code>memory_order::acquire</code><span> and a value of </span><code>memory_order::release</code><span> shall be replaced by the value </span><code>memory_order::relaxed</code><span>. </span></ins></p>
</li>
<li>
<p><ins><em><span>Returns</span></em><span>: </span><code>true</code><span> if the operation replaced the value of </span><code>*ptr</code><span> and </span><code>false</code><span> otherwise.</span></ins><br>
<ins><span>[Note: if </span><code>fetch_update</code><span> returns </span><code>true</code><span>, it is an atomic read-modify-write operation according to [intro.races], and an atomic read otherwise - end note]</span></ins></p>
</li>
</ul></div>
    <div class="ui-toc dropup unselectable hidden-print" style="display:none;">
        <div class="pull-right dropdown">
            <a id="tocLabel" class="ui-toc-label btn btn-default" data-toggle="dropdown" href="#" role="button" aria-haspopup="true" aria-expanded="false" title="Table of content">
                <i class="fa fa-bars"></i>
            </a>
            <ul id="ui-toc" class="ui-toc-dropdown dropdown-menu" aria-labelledby="tocLabel">
                <div class="toc"><ul class="nav">
<li><a href="#User-defined-Atomic-Read-Modify-Write-Operations" title="User-defined Atomic Read-Modify-Write Operations">User-defined Atomic Read-Modify-Write Operations</a><ul class="nav">
<li><a href="#Motivation" title="Motivation">Motivation</a></li>
<li><a href="#Design" title="Design">Design</a><ul class="nav">
<li><a href="#Implementation-strategies" title="Implementation strategies">Implementation strategies</a></li>
<li><a href="#Requirements-on-the-user-defined-operation" title="Requirements on the user-defined operation">Requirements on the user-defined operation</a></li>
<li><a href="#Requirements-on-the-implementation" title="Requirements on the implementation">Requirements on the implementation</a></li>
<li><a href="#Limitations-for-users" title="Limitations for users">Limitations for users</a></li>
</ul>
</li>
<li><a href="#Alternatives" title="Alternatives">Alternatives</a><ul class="nav">
<li><a href="#Does-restricting-UnaryOp-to-be-constexpr-suffice" title="Does restricting UnaryOp to be constexpr suffice?">Does restricting UnaryOp to be constexpr suffice?</a></li>
<li><a href="#Portable-CAS-loop" title="Portable CAS-loop">Portable CAS-loop</a></li>
<li><a href="#Transactional-guarantees" title="Transactional guarantees">Transactional guarantees</a></li>
<li><a href="#stdexpected-based-API" title="std::expected-based API">std::expected-based API</a></li>
<li><a href="#Function-object-return-type" title="Function object return type">Function object return type</a></li>
<li><a href="#Prior-art" title="Prior art">Prior art</a></li>
</ul>
</li>
<li><a href="#Wording" title="Wording">Wording</a></li>
</ul>
</li>
</ul>
</div><div class="toc-menu"><a class="expand-toggle" href="#">Expand all</a><a class="back-to-top" href="#">Back to top</a><a class="go-to-bottom" href="#">Go to bottom</a></div>
            </ul>
        </div>
    </div>
    <div id="ui-toc-affix" class="ui-affix-toc ui-toc-dropdown unselectable hidden-print" data-spy="affix" style="top:17px;display:none;"  >
        <div class="toc"><ul class="nav">
<li><a href="#User-defined-Atomic-Read-Modify-Write-Operations" title="User-defined Atomic Read-Modify-Write Operations">User-defined Atomic Read-Modify-Write Operations</a><ul class="nav">
<li><a href="#Motivation" title="Motivation">Motivation</a></li>
<li><a href="#Design" title="Design">Design</a><ul class="nav">
<li><a href="#Implementation-strategies" title="Implementation strategies">Implementation strategies</a></li>
<li><a href="#Requirements-on-the-user-defined-operation" title="Requirements on the user-defined operation">Requirements on the user-defined operation</a></li>
<li><a href="#Requirements-on-the-implementation" title="Requirements on the implementation">Requirements on the implementation</a></li>
<li><a href="#Limitations-for-users" title="Limitations for users">Limitations for users</a></li>
</ul>
</li>
<li><a href="#Alternatives" title="Alternatives">Alternatives</a><ul class="nav">
<li><a href="#Does-restricting-UnaryOp-to-be-constexpr-suffice" title="Does restricting UnaryOp to be constexpr suffice?">Does restricting UnaryOp to be constexpr suffice?</a></li>
<li><a href="#Portable-CAS-loop" title="Portable CAS-loop">Portable CAS-loop</a></li>
<li><a href="#Transactional-guarantees" title="Transactional guarantees">Transactional guarantees</a></li>
<li><a href="#stdexpected-based-API" title="std::expected-based API">std::expected-based API</a></li>
<li><a href="#Function-object-return-type" title="Function object return type">Function object return type</a></li>
<li><a href="#Prior-art" title="Prior art">Prior art</a></li>
</ul>
</li>
<li><a href="#Wording" title="Wording">Wording</a></li>
</ul>
</li>
</ul>
</div><div class="toc-menu"><a class="expand-toggle" href="#">Expand all</a><a class="back-to-top" href="#">Back to top</a><a class="go-to-bottom" href="#">Go to bottom</a></div>
    </div>
    <script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/3.1.1/jquery.min.js" integrity="sha256-hVVnYaiADRTO2PzUGmuLJr8BLUSjGIZsDYGmIJLv2b8=" crossorigin="anonymous"></script>
    <script src="https://cdnjs.cloudflare.com/ajax/libs/twitter-bootstrap/3.3.7/js/bootstrap.min.js" integrity="sha256-U5ZEeKfGNOja007MMD3YBI0A3OSZOQbeG6z2f2Y0hu8=" crossorigin="anonymous" defer></script>
    <script src="https://cdnjs.cloudflare.com/ajax/libs/gist-embed/2.6.0/gist-embed.min.js" integrity="sha256-KyF2D6xPIJUW5sUDSs93vWyZm+1RzIpKCexxElmxl8g=" crossorigin="anonymous" defer></script>
    <script>
        var markdown = $(".markdown-body");
        //smooth all hash trigger scrolling
        function smoothHashScroll() {
            var hashElements = $("a[href^='#']").toArray();
            for (var i = 0; i < hashElements.length; i++) {
                var element = hashElements[i];
                var $element = $(element);
                var hash = element.hash;
                if (hash) {
                    $element.on('click', function (e) {
                        // store hash
                        var hash = this.hash;
                        if ($(hash).length <= 0) return;
                        // prevent default anchor click behavior
                        e.preventDefault();
                        // animate
                        $('body, html').stop(true, true).animate({
                            scrollTop: $(hash).offset().top
                        }, 100, "linear", function () {
                            // when done, add hash to url
                            // (default click behaviour)
                            window.location.hash = hash;
                        });
                    });
                }
            }
        }

        smoothHashScroll();
        var toc = $('.ui-toc');
        var tocAffix = $('.ui-affix-toc');
        var tocDropdown = $('.ui-toc-dropdown');
        //toc
        tocDropdown.click(function (e) {
            e.stopPropagation();
        });

        var enoughForAffixToc = true;

        function generateScrollspy() {
            $(document.body).scrollspy({
                target: ''
            });
            $(document.body).scrollspy('refresh');
            if (enoughForAffixToc) {
                toc.hide();
                tocAffix.show();
            } else {
                tocAffix.hide();
                toc.show();
            }
            $(document.body).scroll();
        }

        function windowResize() {
            //toc right
            var paddingRight = parseFloat(markdown.css('padding-right'));
            var right = ($(window).width() - (markdown.offset().left + markdown.outerWidth() - paddingRight));
            toc.css('right', right + 'px');
            //affix toc left
            var newbool;
            var rightMargin = (markdown.parent().outerWidth() - markdown.outerWidth()) / 2;
            //for ipad or wider device
            if (rightMargin >= 133) {
                newbool = true;
                var affixLeftMargin = (tocAffix.outerWidth() - tocAffix.width()) / 2;
                var left = markdown.offset().left + markdown.outerWidth() - affixLeftMargin;
                tocAffix.css('left', left + 'px');
            } else {
                newbool = false;
            }
            if (newbool != enoughForAffixToc) {
                enoughForAffixToc = newbool;
                generateScrollspy();
            }
        }
        $(window).resize(function () {
            windowResize();
        });
        $(document).ready(function () {
            windowResize();
            generateScrollspy();
        });

        //remove hash
        function removeHash() {
            window.location.hash = '';
        }

        var backtotop = $('.back-to-top');
        var gotobottom = $('.go-to-bottom');

        backtotop.click(function (e) {
            e.preventDefault();
            e.stopPropagation();
            if (scrollToTop)
                scrollToTop();
            removeHash();
        });
        gotobottom.click(function (e) {
            e.preventDefault();
            e.stopPropagation();
            if (scrollToBottom)
                scrollToBottom();
            removeHash();
        });

        var toggle = $('.expand-toggle');
        var tocExpand = false;

        checkExpandToggle();
        toggle.click(function (e) {
            e.preventDefault();
            e.stopPropagation();
            tocExpand = !tocExpand;
            checkExpandToggle();
        })

        function checkExpandToggle () {
            var toc = $('.ui-toc-dropdown .toc');
            var toggle = $('.expand-toggle');
            if (!tocExpand) {
                toc.removeClass('expand');
                toggle.text('Expand all');
            } else {
                toc.addClass('expand');
                toggle.text('Collapse all');
            }
        }

        function scrollToTop() {
            $('body, html').stop(true, true).animate({
                scrollTop: 0
            }, 100, "linear");
        }

        function scrollToBottom() {
            $('body, html').stop(true, true).animate({
                scrollTop: $(document.body)[0].scrollHeight
            }, 100, "linear");
        }
    </script>
</body>

</html>
