<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Issue 1442: "happens-before" should be "synchronizes-with"</title>
<meta property="og:title" content="Issue 1442: &quot;happens-before&quot; should be &quot;synchronizes-with&quot;">
<meta property="og:description" content="C++ library issue. Status: NAD Editorial">
<meta property="og:url" content="https://cplusplus.github.io/LWG/issue1442.html">
<meta property="og:type" content="website">
<meta property="og:image" content="http://cplusplus.github.io/LWG/images/cpp_logo.png">
<meta property="og:image:alt" content="C++ logo">
<style>
  p {text-align:justify}
  li {text-align:justify}
  pre code.backtick::before { content: "`" }
  pre code.backtick::after { content: "`" }
  blockquote.note
  {
    background-color:#E0E0E0;
    padding-left: 15px;
    padding-right: 15px;
    padding-top: 1px;
    padding-bottom: 1px;
  }
  ins {background-color:#A0FFA0}
  del {background-color:#FFA0A0}
  table.issues-index { border: 1px solid; border-collapse: collapse; }
  table.issues-index th { text-align: center; padding: 4px; border: 1px solid; }
  table.issues-index td { padding: 4px; border: 1px solid; }
  table.issues-index td:nth-child(1) { text-align: right; }
  table.issues-index td:nth-child(2) { text-align: left; }
  table.issues-index td:nth-child(3) { text-align: left; }
  table.issues-index td:nth-child(4) { text-align: left; }
  table.issues-index td:nth-child(5) { text-align: center; }
  table.issues-index td:nth-child(6) { text-align: center; }
  table.issues-index td:nth-child(7) { text-align: left; }
  table.issues-index td:nth-child(5) span.no-pr { color: red; }
  @media (prefers-color-scheme: dark) {
     html {
        color: #ddd;
        background-color: black;
     }
     ins {
        background-color: #225522
     }
     del {
        background-color: #662222
     }
     a {
        color: #6af
     }
     a:visited {
        color: #6af
     }
     blockquote.note
     {
        background-color: rgba(255, 255, 255, .10)
     }
  }
</style>
</head>
<body>
<hr>
<p><em>This page is a snapshot from the LWG issues list, see the <a href="lwg-active.html">Library Active Issues List</a> for more information and the meaning of <a href="lwg-active.html#NAD_Editorial">NAD Editorial</a> status.</em></p>
<h3 id="1442"><a href="lwg-closed.html#1442">1442</a>. "happens-before" should be "synchronizes-with"</h3>
<p><b>Section:</b> 32 <a href="https://wg21.link/thread">[thread]</a> <b>Status:</b> <a href="lwg-active.html#NAD_Editorial">NAD Editorial</a>
 <b>Submitter:</b> Canada <b>Opened:</b> 2010-08-25 <b>Last modified:</b> 2016-01-28</p>
<p><b>Priority: </b>Not Prioritized
</p>
<p><b>View all other</b> <a href="lwg-index.html#thread">issues</a> in [thread].</p>
<p><b>View all issues with</b> <a href="lwg-status.html#NAD Editorial">NAD Editorial</a> status.</p>
<p><b>Duplicate of:</b> <a href="lwg-closed.html#1443" title="Imposed happens-before edges are not made transitive (Status: Dup)">1443</a></p>
<p><b>Discussion:</b></p>
<p><b>Addresses CA-9, GB-122</b></p>

<p><i>[CA-9:]</i></p>

<p>
Imposed happens-before edges should be in
synchronizes-with<br/>
Each use of the words "happens-before" should be
replaced with the words "synchronizes-with" in the
following sentences:<br/>
27.2.3p2<br/>
30.3.1.2p6<br/>
30.3.1.5p7<br/>
30.6.4p7<br/>
30.6.9p5<br/>
30.6.10.1p23<br/>
Rationale: Happens-before is defined in 1.10p11 in a way
that (deliberately) does not make it explicitly transitively
closed. Adding edges to happens-before directly, as in
27.2.3p2 etc., does not provide transitivity with
sequenced-before or any other existing happens-before
edge. This lack of transitivity seems to be unintentional.
</p>

<p><i>[GB-122]</i></p>


<p>At various points in the standard new edges are added to
happens-before, for example 27.2.3:2 adds happens-before edges between
writes and reads from a stream:</p>

<p>If one thread makes a library call a that writes a value to a
stream and, as a result, another thread reads this value from the
stream through a library call b such that this does not result in a
data race, then a happens before b.</p>

<p>Happens-before is defined in 1.10:11 in a deliberate way that makes it
not explicitly transitively closed. Adding edges to happens-before
directly, as in 27.2.3:2, does not provide transitivity with
sequenced-before or any other existing happens-before edge. This lack
of transitivity seems to be unintentional. In order to achieve
transitivity we suggest each edge be added to
inter-thread-happens-before as a synchronises-with edge (as per
conversation with Hans Boehm). In the standard, each use of the words
"happens-before" should be replaced with the words "synchronizes-with"
in the following sentences:</p>

<p>27.2.3:2,
30.3.1.2:6,
30.3.1.5:7,
30.6.4:7,
30.6.9:5,
30.6.10.1:23</p>

<p id="res-1442"><b>Proposed resolution:</b></p>

<p><i>[Beman provided specific wording for the proposed resolution.]</i></p>


<p>Change 27.2.3 Thread Safety [iostreams.threadsafety] paragraph 2:</p>

<p>If one thread makes a library call <code>a</code> that writes a value to a stream 
and, as a result, another thread reads this value from the stream through a library 
call <code>b</code> such that this does not result in a data race, then <code>a</code> 
<del>happens before</del> <ins>synchronizes with</ins> <code>b</code>.</p>

<p>Change 30.3.1.2 thread constructors [thread.thread.constr] paragraph 6:</p>

<p><i>Synchronization:</i> The invocation of the constructor <del>happens 
before</del> <ins>synchronizes with</ins> the invocation of the copy of <code>f</code>.</p>

<p>Change 30.3.1.5 thread members [thread.thread.member] paragraph 7:</p>

<p><i>Synchronization:</i> The completion of the thread represented by <code>*this</code> 
<del>happens before</del> <ins>synchronizes with</ins> (1.10) <code>join()</code> 
<del>returns</del> <ins>returning</ins>. [ Note: Operations on <code>*this</code> 
are not synchronized. --end note ]</p>

<p>Change 30.6.4 Associated asynchronous state [futures.state] paragraph 7:</p>

<p>Calls to functions that successfully set the stored result of an associated 
asynchronous state synchronize with (1.10) calls to functions successfully detecting 
the ready state resulting from that setting. The storage of the result (whether normal 
or exceptional) into the associated asynchronous state <del>happens before</del> 
<ins>synchronizes with</ins> (1.10) that state <del>is</del> <ins>being</ins> set to ready.</p>

<p>Change 30.6.9 Function template async [futures.async] paragraph 5:</p>

<p><i>Synchronization:</i> the invocation of <code>async</code> <del>happens before</del> 
<ins>synchronizes with</ins> (1.10) the invocation of <code>f</code>. [ <i>Note</i>: this
statement applies even when the corresponding future object is moved to another thread. &mdash; <i>end
note</i> ] If the invocation is not deferred, a call to a waiting function on an asynchronous return object
that shares the associated asynchronous state created by this async call shall block until the associated
thread has completed. If the invocation is not deferred, the <code>join()</code> on the created thread 
<del>happens before</del> <ins>synchronizes with</ins> (1.10) the first function that successfully 
detects the ready status of the associated asynchronous state returns or before the function that 
gives up the last reference to the associated asynchronous state returns, whichever happens first. 
If the invocation is deferred, the completion of the invocation of the deferred function <del>happens 
before</del> <ins>synchronizes with</ins> the calls to the waiting functions return.</p>

<p>Change 30.6.10.1 packaged_task member functions [futures.task.members] paragraph 23:</p>

<p><i>Synchronization:</i> a successful call to <code>operator()</code> synchronizes with (1.10) a call 
to any member function of a <code>future</code>, <code>shared_future</code>, or <code>atomic_future</code> object 
that shares the associated asynchronous state of <code>*this</code>. The completion of the invocation 
of the stored task and the storage of the result (whether normal or exceptional) into the associated 
asynchronous state <del>happens before</del> <ins>synchronizes with</ins> (1.10) the state <del>is</del> 
<ins>being</ins> set to ready. [ Note: <code>operator()</code> synchronizes and serializes with other 
functions through the associated asynchronous state. &mdash;end note ]</p>






</body>
</html>
