<html><head><meta http-equiv="Content-Type" content="text/html charset=utf-8"></head><body style="word-wrap: break-word; -webkit-nbsp-mode: space; -webkit-line-break: after-white-space;" class=""><br class=""><div><blockquote type="cite" class=""><div class="">On 29 May 2017, at 21:20, Gil Tene <<a href="mailto:gil@azul.com" class="">gil@azul.com</a>> wrote:</div><br class="Apple-interchange-newline"><div class="">

<meta http-equiv="Content-Type" content="text/html; charset=utf-8" class="">

<div style="word-wrap: break-word; -webkit-nbsp-mode: space; -webkit-line-break: after-white-space;" class="">
<br class="">
<div class="">
<blockquote type="cite" class="">
<div class="">On May 29, 2017, at 11:43 AM, Alex Otenko <<a href="mailto:oleksandr.otenko@gmail.com" class="">oleksandr.otenko@gmail.com</a>> wrote:</div>
<br class="Apple-interchange-newline">
<div class="">
<div style="word-wrap: break-word; -webkit-nbsp-mode: space; -webkit-line-break: after-white-space;" class="">
<div class=""><br class="">
</div>
<div class="">
<blockquote type="cite" class="">
<div class="">On 29 May 2017, at 15:42, Gil Tene <<a href="mailto:gil@azul.com" class="">gil@azul.com</a>> wrote:</div>
<br class="Apple-interchange-newline">
<div class=""><span class="" style="float: none; display: inline !important;">When a set of accesses is atomic, they appear to happen instantaneously, with no opportunity for any external observer or mutator to interleave within them</span></div>
</blockquote>
</div>
<br class="">
<div class="">When you said “no opportunity … to interleave”, you defined a total order: the operations are not allowed to start before something atomic has finished, and something atomic is not allowed to start, if any other operation hasn’t finished - this
 is equivalent to defining a total order of operations.</div>
</div>
</div>
</blockquote>
<div class=""><br class="">
</div>
<div class="">Nothing about "any other operation" is implied. Only about operations on the field(s) involved in the atomic operation. That's a key difference, and the reason there is no total order implied or involved here. There is no implied order or relationship
 whatsoever with operations involving any other fields. So no order of any sort.</div></div></div></div></blockquote><blockquote type="cite" class=""><div class=""><div style="word-wrap: break-word; -webkit-nbsp-mode: space; -webkit-line-break: after-white-space;" class=""><div class="">
<div class=""><br class="">
</div>
<div class="">If you are referring to some "total order" that only applies to the the field involved in the CAS (and not in relationship to any other operations or fields), I'd buy that a a possible statemewnt. But it is not a very meaningful one because it would be
 orthogonal to any ordering statements in the rest of the program.</div>
<br class="">
<blockquote type="cite" class="">
<div class="">
<div style="word-wrap: break-word; -webkit-nbsp-mode: space; -webkit-line-break: after-white-space;" class="">
<div class="">ll/sc sequence does not create atomicity, that’s a very important point. ll/sc does not *stop* interleavings from happening. ll/sc only *witnesses* whether any interleavings happened. So it is meaningless to say “a successful ll/sc is atomic”.</div>
</div>
</div>
</blockquote>
<div class=""><br class="">
</div>
<div class="">ll/sc (on a successful sc) is no less atomic with regards to the field involved than a successful CAS is. Successes are always atomic. And failures in both cases are not. A failed CAS performed only one operation (the read), so it has nothing to be atomic.
 </div></div></div></div></blockquote><div><br class=""></div><div>It has, potentially.</div><div><br class=""></div><div>Let me recap the diagram I’ve posted before.</div><div><br class=""></div><div>A weak CAS:</div><div><br class=""></div><div>   store z 0</div><div>load z</div><div>   store z 2</div><div>// skip store z 1</div><div><br class=""></div><div>Here the weak CAS managed to execute a load, then observed something it believes to be an interleaving store, and skipped store of 1. Weak CAS does not synchronize-with the store that failed it, so it can be detected to be non-atomic. (Weak CAS is allowed to also fail for other reasons, but that’s not part of the problem)</div><div><br class=""></div><div>A version of a strong CAS:</div><div><br class=""></div><div><div>   store z 0</div><div>load z</div><div>   store z 2</div><div>// interleaving store triggers retry - ll/sc-based primitive has to ascertain it is not a “spurious” failure</div><div>load z</div><div>// skip store z 1</div><div class=""><br class=""></div></div><div>Here the strong CAS managed to execute a load, then observed something happened, then loaded again to be sure it was not due to false sharing but a true interleaving store to z. This second load synchronizes-with the store that failed it. This version of strong CAS is no less atomic than a successful CAS - as in “a single entity in the total order of all stores to z”, because it behaves like a CAS that was scheduled strictly after the store that failed it and before any other stores.</div><div><br class=""></div><div><br class=""></div><div>So my big question is: can a strong CAS detect the presence of an interleaving store without synchronizing-with it? Can it tell it is an interleaving store and not something else, without issuing a load or having effect of such a load?</div><div><br class=""></div><div><br class=""></div><div>Alex</div><br class=""><blockquote type="cite" class=""><div class=""><div style="word-wrap: break-word; -webkit-nbsp-mode: space; -webkit-line-break: after-white-space;" class=""><div class=""><div class="">A successful sc ensures no "witnessing" of interleaving occurred, just like a successful CAS does. The (additional potential) causes of failure [where no atomicity is provided] may vary between ll/sc, strong CAS, and weak CAS, but the knowledge upon success
 is the same. Success is atomic.</div>
<div class=""><br class="">
</div>
<div class="">I have previously worked on a weakly ordered architecture that implemented an atomic but completely unordered CAS instruction. That implementation, being weakly ordered, simply froze the L1 cache coherence protocol for the duration of the atomic operation
 after establishing the cache line exclusive in L1. By ensuring the protocol could not proceed with respect to the field involved, it trivially ensured atomicity without making any ordering requirements about nay other operations. Ordering was controlled separately,
 with explicit fences for combinations of ldld, ldst, stst, and stld. Any amount of reordering was allowed if fences were not there to prevent it, so a CAS was not guaranteed to be ordered against any other operations unless one or more of those fences actually
 existed in the instruction flow between them. </div>
<br class="">
<blockquote type="cite" class="">
<div class="">
<div style="word-wrap: break-word; -webkit-nbsp-mode: space; -webkit-line-break: after-white-space;" class="">
<div class=""><br class="">
</div>
<div class="">Alex</div>
<div class=""><br class="">
</div>
<div class=""><br class="">
</div>
<div class="">
<blockquote type="cite" class="">
<div class="">On 29 May 2017, at 15:42, Gil Tene <<a href="mailto:gil@azul.com" class="">gil@azul.com</a>> wrote:</div>
<br class="Apple-interchange-newline">
<div class="">
<div dir="auto" class="">
<div class="">Atomicity has nothing to do with order. Atomicity only applies to the locations it refers to (e.g. a field, a cache line, a set of fields or cache lines [with HTM for example]), and it either is or isn't. When a set of accesses is atomic, they
 appear to happen instantaneously, with no opportunity for any external observer or mutator to interleave within them. This has absolutely nothing to do with the order in which those accesses appear in relation to accesses (by this thread or others) to values
 that are not included in the atomic operation.</div>
<div class=""><br class="">
</div>
<div class="">With no relation to atomicity (there are plenty of ways to perform non-atomic CAS), a "weak" CAS means that the store to the field will occur only if the value observed in the field is equal to the expected value. A "strong" CAS means
<span style="background-color: rgba(255, 255, 255, 0);" class="">that the store to the field will occur if and only if the value observed in the field is equal to the expected value. Neither of those descriptions have anything to do with atomicity. The difference
 between them is that a strong CAS must write to the field if it observes the right value in the field, while a weak CAS may spuriously decide not to write (no IFF requirement).</span></div>
<div class=""><span style="background-color: rgba(255, 255, 255, 0);" class=""><br class="">
</span></div>
<div class=""><span style="background-color: rgba(255, 255, 255, 0);" class="">An atomic CAS (weak or strong) simply makes the observation and write (if the write happens) occur atomically. The atomicity property prevents external interference in the sequence.
 Nothing else. Atomicity does not affect the weak/strong part (a weak CAS may still fail spuriously, even without external interference with the observed value). Atomicity has no implications on the memory ordering semantics of the operations in the sequence
 with respect to location not covered by the atomicity property, and other than the atomicity property, it makes no claims about memory ordering with respect to other threads.</span></div>
<div class=""><span style="background-color: rgba(255, 255, 255, 0);" class=""><br class="">
</span></div>
<div class=""><span style="background-color: rgba(255, 255, 255, 0);" class="">There are plenty of atomic but non-ordered CAS implementations out there. Including some hardware CAS instruction implementations, as well as the hardware instruction combinations
 commonly used to construct a CAS operation on some architectures.</span></div>
<div class=""><span style="background-color: rgba(255, 255, 255, 0);" class=""><br class="">
</span></div>
<div class=""><span style="background-color: rgba(255, 255, 255, 0);" class="">E.g. a</span><span style="background-color: rgba(255, 255, 255, 0);" class=""> ll/sc sequence where the sc was successful guarantees atomicity for the combination of the ll and sc
 operations performed on the same memory location</span><span style="background-color: rgba(255, 255, 255, 0);" class="">. This primitive can be used to construct a weak CAS directly, and typically requires a loop to construct a strong CAS (since many things,
 including interrupts, can cause spurious failures). A ll/sc does not in itself imply ordering against accesses to other memory locations (unless the specific architecture defines it that way).</span></div>
<div class=""><span style="background-color: rgba(255, 255, 255, 0);" class=""><br class="">
</span></div>
<div class=""><span style="background-color: rgba(255, 255, 255, 0);" class="">In Java, compareAndSet has been previously defined to to mean a strong (non-spuriously-failing) CAS with unconditional memory ordering semantics of a volatile read and a volatile
 write. weakCompareAndSet was previously defined as a weak (may spuriously fail) CAS with no implied memory ordering semantics. Both are atomic.</span></div>
<div class=""><br class="">
</div>
<div class="">The recent discussion here is focused on whether a relaxing of the memory ordering semantics of compareAndSet, from the volatile write semantics being unconditional to being conditional (on the write actually occurring) is advisable. The claim
 is that there is existing Java software out there that may rely on the existing unconditional definition for correctness, and that relaxing the definition will break such software. Examples of how the conditional/unconditional behavior difference can be observed
 by a concurrent algorithm were given (I believe) as proof that such software can (and likely does) exist.</div>
<div class=""><br class="">
</div>
<div class="">Sent from my iPad</div>
<div class=""><br class="">
On May 29, 2017, at 4:39 AM, Alex Otenko <<a href="mailto:oleksandr.otenko@gmail.com" class="">oleksandr.otenko@gmail.com</a>> wrote:<br class="">
<br class="">
</div>
<blockquote type="cite" class="">
<div class="">I also have this intuition, but this looks like a proof by example, not a specification.
<div class=""><br class="">
</div>
<div class="">A specification would look something like:</div>
<div class="">1. CAS executes a volatile load unconditionally.</div>
<div class="">2. CAS executes a volatile store conditionally. The store is added to the total order of all operations if and only if the value loaded is equal to the expected value, and no other store appears in the total order of accesses to the same volatile
 variable after the load and before the volatile store.</div>
<div class=""><br class="">
</div>
<div class="">In this way CAS store is not atomic - the correct description is closer to “*exclusive* with other stores”.</div>
<div class=""><br class="">
</div>
<div class="">That is a weak CAS. It does not say anything about when it fails, so is allowed to fail at will (spuriously fail).</div>
<div class=""><br class="">
</div>
<div class="">A strong CAS also has:</div>
<div class=""><br class="">
</div>
<div class="">3. If there are no volatile stores to the variable after the load in step 1, the volatile store is always executed.</div>
<div class=""><br class="">
</div>
<div class="">This makes the CAS store “*mutually* exclusive with other strong CASes”. (Still, “atomic” is a wrong term.)</div>
<div class=""><br class="">
</div>
<div class="">The question then is - in order to fail, it has to observe a volatile store; is it able to ascertain the presence of volatile stores to the variable without establishing a synchronizes-with relationship to such a store? It does not seem possible,
 and atomicity of the failing strong CAS follows. (That is, non-atomicity of implementation is not observable.)</div>
<div class=""><br class="">
</div>
<div class=""><br class="">
</div>
<div class="">Alex</div>
<div class=""><br class="">
</div>
<div class=""><br class="">
<div class="">
<blockquote type="cite" class="">
<div class="">On 29 May 2017, at 12:10, David Holmes <<a href="mailto:davidcholmes@aapt.net.au" class="">davidcholmes@aapt.net.au</a>> wrote:</div>
<br class="Apple-interchange-newline">
<div class="">
<div class="WordSection1" style="page: WordSection1; font-family: Helvetica; font-size: 12px; font-style: normal; font-variant: normal; font-weight: normal; letter-spacing: normal; line-height: normal; orphans: auto; text-align: start; text-indent: 0px; text-transform: none; white-space: normal; widows: auto; word-spacing: 0px; -webkit-text-stroke-width: 0px;">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
The atomicity property of CAS ensures that the value being CAS’d updates in the manner proscribed by the application logic. If I want all threads to get a unique Id they can CAS a global “int id” and always increment the value. The atomicity of CAS ensures
 no two threads get the same Id and that there are no gaps in the assigned id values. The CAS may be the only means by which the variable is accessed so no other stores even enter into the picture.<o:p class=""></o:p></div>
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
<o:p class=""> </o:p></div>
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
David<o:p class=""></o:p></div>
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
<o:p class=""> </o:p></div>
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
<o:p class=""> </o:p></div>
<div style="border-style: none none none solid; border-left-color: blue; border-left-width: 1.5pt; padding: 0in 0in 0in 4pt;" class="">
<div class="">
<div style="border-style: solid none none; border-top-color: rgb(225, 225, 225); border-top-width: 1pt; padding: 3pt 0in 0in;" class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
<b class="">From:</b><span class="Apple-converted-space"> </span>Alex Otenko [<a href="mailto:oleksandr.otenko@gmail.com" class="">mailto:oleksandr.otenko@gmail.com</a>]<span class="Apple-converted-space"> </span><br class="">
<b class="">Sent:</b><span class="Apple-converted-space"> </span>Monday, May 29, 2017 7:43 PM<br class="">
<b class="">To:</b><span class="Apple-converted-space"> </span><a href="mailto:dholmes@ieee.org" class="">dholmes@ieee.org</a><br class="">
<b class="">Cc:</b><span class="Apple-converted-space"> </span><a href="mailto:concurrency-interest@cs.oswego.edu" class="">concurrency-interest@cs.oswego.edu</a><br class="">
<b class="">Subject:</b><span class="Apple-converted-space"> </span>Re: [concurrency-interest] AtomicReference.updateAndGet() mandatory updating<o:p class=""></o:p></div>
</div>
</div>
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
<o:p class=""> </o:p></div>
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
Sorry, but I don’t see how you separate synchronization properties of CAS and atomicity :-)<o:p class=""></o:p></div>
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
<o:p class=""> </o:p></div>
</div>
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
I don’t see how you could describe atomicity without specifying the place of CAS with respect to the other stores. Once you placed it somewhere among the other stores, it synchronizes-with those preceding it.<o:p class=""></o:p></div>
</div>
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
<o:p class=""> </o:p></div>
</div>
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
Now, atomicity of a succeeding CAS is not falsifiable. It can just as well be non-atomic, and succeed, if the other stores were ordered in the same way. There is no meaning whatsoever in declaring a succeeding CAS atomic.<o:p class=""></o:p></div>
</div>
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
<o:p class=""> </o:p></div>
</div>
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
<span style="font-family: Courier;" class="">Successful CAS atomic        Successful CAS not atomic</span><o:p class=""></o:p></div>
</div>
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
<span style="font-family: Courier;" class="">store z 0                    store z 0</span><o:p class=""></o:p></div>
</div>
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
<span style="font-family: Courier;" class="">CAS z 0 1                    load z</span><o:p class=""></o:p></div>
</div>
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
<span style="font-family: Courier;" class="">                             store z 1</span><o:p class=""></o:p></div>
</div>
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
<span style="font-family: Courier;" class="">store z 2                    store z 2</span><o:p class=""></o:p></div>
</div>
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
<o:p class=""> </o:p></div>
</div>
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
Can you detect the effects of a successful CAS being not atomic? What does atomicity of a successful CAS promise? I see nothing.<o:p class=""></o:p></div>
</div>
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
<o:p class=""> </o:p></div>
</div>
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
<o:p class=""> </o:p></div>
</div>
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
There is a difference between atomic and non-atomic failing CAS - that’s where it makes sense to specify whether it is atomic or not.<o:p class=""></o:p></div>
</div>
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
<o:p class=""> </o:p></div>
</div>
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
<span style="font-family: Courier;" class="">Failing CAS atomic intrinsic          Failing CAS not atomic</span><o:p class=""></o:p></div>
</div>
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
<span style="font-family: Courier;" class="">                             Not detectable    Detectable             Not detectable</span><o:p class=""></o:p></div>
</div>
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
<span style="font-family: Courier;" class="">store z 0                    store z 0         store z 0              store z 0</span><o:p class=""></o:p></div>
</div>
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
<span style="font-family: Courier;" class="">store z 2                    store z 2         load z                 load z</span><o:p class=""></o:p></div>
</div>
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
<span style="font-family: Courier;" class="">CAS z 0 1                    load z              store z 2              store z 2</span><o:p class=""></o:p></div>
</div>
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
<span style="font-family: Courier;" class="">                                               // store z 1 skipped   // store z 2 triggers retry</span><o:p class=""></o:p></div>
</div>
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
<span style="font-family: Courier;" class="">                                                                      load z</span><o:p class=""></o:p></div>
</div>
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
<span style="font-family: Courier;" class="">                                                                      // store z 1 skipped</span><o:p class=""></o:p></div>
</div>
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
<o:p class=""> </o:p></div>
</div>
</div>
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
If non-atomicity of a failing CAS can be detected, it becomes even closer to weakCompareAndSet, which fails spuriously, and is a concern. On the other hand, it may just as well promise atomicity even of a failing CAS, because it needs to distinguish a spurious
 failure of the underlying ll/sc primitive, and the procedure for distinguishing that possibly necessarily establishes the synchronizes-with edge with the store that failed it.<o:p class=""></o:p></div>
</div>
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
<o:p class=""> </o:p></div>
</div>
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
I don’t see all ends, so maybe someone wants to not promise atomicity of the failing strong CAS. But in that case there is no need to promise atomicity at all, because the promise of atomicity of a succeeding CAS gives you nothing. Unless you can show how a
 non-atomic successful CAS could be detected?<o:p class=""></o:p></div>
</div>
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
<o:p class=""> </o:p></div>
</div>
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
<o:p class=""> </o:p></div>
</div>
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
Alex<o:p class=""></o:p></div>
</div>
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
<o:p class=""> </o:p></div>
<div class="">
<blockquote style="margin-top: 5pt; margin-bottom: 5pt;" class="" type="cite">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
On 29 May 2017, at 09:31, David Holmes <<a href="mailto:davidcholmes@aapt.net.au" style="color: purple; text-decoration: underline;" class="">davidcholmes@aapt.net.au</a>> wrote:<o:p class=""></o:p></div>
</div>
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
<o:p class=""> </o:p></div>
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
Sorry but I don’t see what you describe as atomicity. The atomicity of a successful CAS is the only atomicity the API is concerned about. The memory synchronization properties of CAS are distinct from its atomicity property.<o:p class=""></o:p></div>
</div>
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
David<o:p class=""></o:p></div>
</div>
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
<div style="border-style: none none none solid; border-left-color: blue; border-left-width: 1.5pt; padding: 0in 0in 0in 4pt;" class="">
<div class="">
<div style="border-style: solid none none; border-top-color: rgb(225, 225, 225); border-top-width: 1pt; padding: 3pt 0in 0in;" class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
<b class="">From:</b><span class="apple-converted-space"> </span>Concurrency-interest [<a href="mailto:concurrency-interest-bounces@cs.oswego.edu" style="color: purple; text-decoration: underline;" class="">mailto:concurrency-interest-bounces@cs.oswego.edu</a>]<span class="apple-converted-space"> </span><b class="">On
 Behalf Of<span class="apple-converted-space"> </span></b>Alex Otenko<br class="">
<b class="">Sent:</b><span class="apple-converted-space"> </span>Monday, May 29, 2017 6:15 PM<br class="">
<b class="">To:</b><span class="apple-converted-space"> </span><a href="mailto:dholmes@ieee.org" style="color: purple; text-decoration: underline;" class="">dholmes@ieee.org</a><br class="">
<b class="">Cc:</b><span class="apple-converted-space"> </span><a href="mailto:concurrency-interest@cs.oswego.edu" style="color: purple; text-decoration: underline;" class="">concurrency-interest@cs.oswego.edu</a><br class="">
<b class="">Subject:</b><span class="apple-converted-space"> </span>Re: [concurrency-interest] AtomicReference.updateAndGet() mandatory updating<o:p class=""></o:p></div>
</div>
</div>
</div>
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
Thanks.<o:p class=""></o:p></div>
</div>
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
</div>
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
No, I am not concerned about the atomicity of hardware instructions. I am concerned about atomicity as the property of the memory model.<o:p class=""></o:p></div>
</div>
</div>
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
</div>
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
Claiming atomicity of a successful CAS is pointless. If CAS is not atomic on failure, then there is no need to claim it is atomic at all.<o:p class=""></o:p></div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
</div>
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
Example where you can claim atomicity of a failing CAS:<o:p class=""></o:p></div>
</div>
</div>
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
</div>
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
do{<o:p class=""></o:p></div>
</div>
</div>
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
  tmp = load_linked(z);<o:p class=""></o:p></div>
</div>
</div>
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
} while(tmp == expected && store_conditional(z, updated));<o:p class=""></o:p></div>
</div>
</div>
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
</div>
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
Here if store_conditional fails, it is followed by another volatile load, so the construct will synchronize-with the write that failed it, and it will appear atomic to the observer.<o:p class=""></o:p></div>
</div>
</div>
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
</div>
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
</div>
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
Alex<o:p class=""></o:p></div>
</div>
</div>
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
</div>
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
<div class="">
<blockquote style="margin-top: 5pt; margin-bottom: 5pt;" class="" type="cite">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
On 29 May 2017, at 09:03, David Holmes <<a href="mailto:davidcholmes@aapt.net.au" style="color: purple; text-decoration: underline;" class=""><span style="color: purple;" class="">davidcholmes@aapt.net.au</span></a>> wrote:<o:p class=""></o:p></div>
</div>
</div>
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
Sorry Alex but you are using “atomicity” in a way that doesn’t make sense to me. The only thing that is atomic is the successful CAS. I see what you are trying to say about a failing ll/sc CAS and the write that caused it to fail, but that is not “atomicity”
 to me – at least from the API perspective. You seem to be concerned about the atomicity of a sequence of hardware instructions. The API doesn’t tell you anything about how the implementation is done, only that the result of a successful operation is atomic
 with respect to any other update of the variable.<o:p class=""></o:p></div>
</div>
</div>
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
</div>
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
David<o:p class=""></o:p></div>
</div>
</div>
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
</div>
<div style="border-style: none none none solid; border-left-color: blue; border-left-width: 1.5pt; padding: 0in 0in 0in 4pt;" class="">
<div class="">
<div style="border-style: solid none none; border-top-color: rgb(225, 225, 225); border-top-width: 1pt; padding: 3pt 0in 0in;" class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
<b class="">From:</b><span class="apple-converted-space"> </span>Alex Otenko [<a href="mailto:oleksandr.otenko@gmail.com" style="color: purple; text-decoration: underline;" class=""><span style="color: purple;" class="">mailto:oleksandr.otenko@gmail.com</span></a>]<span class="apple-converted-space"> </span><br class="">
<b class="">Sent:</b><span class="apple-converted-space"> </span>Monday, May 29, 2017 5:55 PM<br class="">
<b class="">To:</b><span class="apple-converted-space"> </span><a href="mailto:dholmes@ieee.org" style="color: purple; text-decoration: underline;" class=""><span style="color: purple;" class="">dholmes@ieee.org</span></a><br class="">
<b class="">Cc:</b><span class="apple-converted-space"> </span>Hans Boehm <<a href="mailto:boehm@acm.org" style="color: purple; text-decoration: underline;" class=""><span style="color: purple;" class="">boehm@acm.org</span></a>>;<span class="apple-converted-space"> </span><a href="mailto:concurrency-interest@cs.oswego.edu" style="color: purple; text-decoration: underline;" class=""><span style="color: purple;" class="">concurrency-interest@cs.oswego.edu</span></a><br class="">
<b class="">Subject:</b><span class="apple-converted-space"> </span>Re: [concurrency-interest] AtomicReference.updateAndGet() mandatory updating<o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
</div>
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
This came out a bit garbled. So, here it goes a bit clearer why the spec and the “ubiquitous terminology” are not enough, perhaps.<o:p class=""></o:p></div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
The claim of “atomicity” for succeeding CAS is not interesting, because it is not falsifiable: if CAS succeeded, it is evidence in itself that no volatile write appeared between the read and write parts of CAS, not evidence of atomicity as the property of the
 construct. We cannot explain atomicity of CAS by giving the specification of effects of the successful CAS. But Javadocs does just that, and *only* that.<o:p class=""></o:p></div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
ll/sc as a construct does not synchronize-with the write failing the sc instruction. So if CAS that uses ll/sc does not make efforts to synchronize-with that write, we can detect it is not atomic - we can detect that it cannot be seen as an operation that appeared
 entirely before or after all stores to the same variable.<o:p class=""></o:p></div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
So I am asking whether the *failing* CAS promises atomicity.<o:p class=""></o:p></div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
Alex<o:p class=""></o:p></div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
</div>
<div class="">
<blockquote style="margin-top: 5pt; margin-bottom: 5pt;" class="" type="cite">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
On 29 May 2017, at 00:26, Alex Otenko <<a href="mailto:oleksandr.otenko@gmail.com" style="color: purple; text-decoration: underline;" class=""><span style="color: purple;" class="">oleksandr.otenko@gmail.com</span></a>> wrote:<o:p class=""></o:p></div>
</div>
</div>
</div>
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
Yeah, I know what atomicity means in x86. But since the “write semantics” of the CAS are questioned, I have to also ask whether the other formulations are precise enough.<o:p class=""></o:p></div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
Atomicity means “indivisible”. It means that it either appears before a store, or after a store. If it appears after the store, then it synchronizes-with that store, and I am bound to observe stores preceding it. But not so in the weaker semantics Hans talks
 about! If the failure occurs during the sc part, you have to assume the load is before that store (but why does it fail then), or you have to assume it overlaps with a concurrent store. Either way, the core function is *not* atomic.<o:p class=""></o:p></div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
Unless there are extra volatile loads upon failure of (strong) compareAndSet.<o:p class=""></o:p></div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
It’s not just the “no intervening store”, meaning “if it’s stored, the condition expected=actual was not violated by any other store”.<o:p class=""></o:p></div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
The gist of atomicity:<o:p class=""></o:p></div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
int x=0;<o:p class=""></o:p></div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
volatile int z=0;<o:p class=""></o:p></div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
Thread 1:<o:p class=""></o:p></div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
if (! CAS(z, 0, 1)) {<o:p class=""></o:p></div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
  return x;<o:p class=""></o:p></div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
}<o:p class=""></o:p></div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
return 1;<o:p class=""></o:p></div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
Thread 2:<o:p class=""></o:p></div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
x=1;<o:p class=""></o:p></div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
z=1;<o:p class=""></o:p></div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
If CAS is atomic, failing CAS synchronizes-with the volatile write that fails it, and Thread 1 will always return 1. <o:p class=""></o:p></div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
Alex<o:p class=""></o:p></div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
</div>
<div class="">
<blockquote style="margin-top: 5pt; margin-bottom: 5pt;" class="" type="cite">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
On 28 May 2017, at 23:52, David Holmes <<a href="mailto:davidcholmes@aapt.net.au" style="color: purple; text-decoration: underline;" class=""><span style="color: purple;" class="">davidcholmes@aapt.net.au</span></a>> wrote:<o:p class=""></o:p></div>
</div>
</div>
</div>
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
Alex,<o:p class=""></o:p></div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
I don’t recall anyone ever questioning what the atomic means in these atomic operations – it is ubiquitous terminology. If the store happens it is because the current value was the expected value. That is indivisible ie atomic. There can be no intervening store.
 This is either the semantics of the hardware instruction (e.g. cmpxchg) or else must be emulated using whatever is available e.g. ll/sc instructions (where an intervening store, in the strong CAS, must cause a retry).<o:p class=""></o:p></div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
David<o:p class=""></o:p></div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
</div>
</div>
<div style="border-style: none none none solid; border-left-color: blue; border-left-width: 1.5pt; padding: 0in 0in 0in 4pt;" class="">
<div class="">
<div style="border-style: solid none none; border-top-color: rgb(225, 225, 225); border-top-width: 1pt; padding: 3pt 0in 0in;" class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
<b class="">From:</b><span class="apple-converted-space"> </span>Concurrency-interest [<a href="mailto:concurrency-interest-bounces@cs.oswego.edu" style="color: purple; text-decoration: underline;" class=""><span style="color: purple;" class="">mailto:concurrency-interest-bounces@cs.oswego.edu</span></a>]<span class="apple-converted-space"> </span><b class="">On
 Behalf Of<span class="apple-converted-space"> </span></b>Alex Otenko<br class="">
<b class="">Sent:</b><span class="apple-converted-space"> </span>Monday, May 29, 2017 7:40 AM<br class="">
<b class="">To:</b><span class="apple-converted-space"> </span>Hans Boehm <<a href="mailto:boehm@acm.org" style="color: purple; text-decoration: underline;" class=""><span style="color: purple;" class="">boehm@acm.org</span></a>><br class="">
<b class="">Cc:</b><span class="apple-converted-space"> </span><a href="mailto:concurrency-interest@cs.oswego.edu" style="color: purple; text-decoration: underline;" class=""><span style="color: purple;" class="">concurrency-interest@cs.oswego.edu</span></a><br class="">
<b class="">Subject:</b><span class="apple-converted-space"> </span>Re: [concurrency-interest] AtomicReference.updateAndGet() mandatory updating<o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
Yes, you could read it both ways. You see, lock-based implementations and x86 LOCK:CMPXCHG semantics inspire to interpret the statement such that there is at least some write-like semantics (hence “memory *effects*”) - not necessarily a write to z, but fences
 or whatever that imitates a volatile write to z from JMM.<o:p class=""></o:p></div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
The other source of confusion is the claim of atomicity. Is it “atomically (sets the value) (to the given updated value if the current value = the expected value)” or “atomically (sets the value to the given updated value if the current value == the expected
 value)”? Does atomicity imply it is a single item in total order of all operations? Or all stores? Or just stores to that variable? If you know how it’s implemented, it turns out it is far from atomic.<o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
Does it at least *implement* atomic behaviour, does it *appear* atomic to an observer? For example, if a concurrent store appears between the load and “the store”  (in quotes, because it may not be executed - so in that case it is no longer “between”), do we
 get synchronizes-with edge with the store that preceded the load, or also the store that intervened? If we don’t get synchronizes-with edge to the store that intervened (which I suspect it doesn’t), then it is not atomic in any of those senses (but x86 and
 lock-based implementations create false analogies, so we get “atomic” in the method description).<o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
It needs to be specced out, best of all formally in JMM as the source of authority, rather than higher-level API javadocs, spread all over the place.<o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
Alex<o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
</div>
</div>
<div class="">
<blockquote style="margin-top: 5pt; margin-bottom: 5pt;" class="" type="cite">
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
On 28 May 2017, at 18:30, Hans Boehm <<a href="mailto:boehm@acm.org" style="color: purple; text-decoration: underline;" class=""><span style="color: purple;" class="">boehm@acm.org</span></a>> wrote:<o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
Thanks. I think I understand now. If Thread 2 returns false, the Thread 2 CAS failed, and the initial CAS in Thread 1 succeeds. Either x immediately reads back as 1 in Thread 1, or we set b to true after Thread 2 returns b. Thus the second (successful) CAS
 in Thread 1 must follow the unsuccessful Thread 2 CAS in synchronization order. So any write to z by the failed CAS synchronizes with the second successful CAS in Thread 1, and we could thus conclude that x is 1 in the Thread 1 return.<o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
This relies critically on the assumption that the Thread 2 failed CAS has the semantics of a volatile write to z.<o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
I think the actual relevant spec text is:<o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
1) "c<code style="font-family: 'Courier New';" class=""><span style="font-size: 10pt; font-family: 'DejaVu Sans Mono'; color: rgb(71, 71, 71);" class="">ompareAndSet</span></code><span style="font-family: 'DejaVu Serif', serif; color: rgb(71, 71, 71);" class=""> and
 all other read-and-update operations such as </span><code style="font-family: 'Courier New';" class=""><span style="font-size: 10pt; font-family: 'DejaVu Sans Mono'; color: rgb(71, 71, 71);" class="">getAndIncrement</span></code><span style="font-family: 'DejaVu Serif', serif; color: rgb(71, 71, 71);" class=""> have
 the memory effects of both reading and writing </span><code style="font-family: 'Courier New';" class=""><span style="font-size: 10pt; font-family: 'DejaVu Sans Mono'; color: rgb(71, 71, 71);" class="">volatile</span></code><span style="font-family: 'DejaVu Serif', serif; color: rgb(71, 71, 71);" class=""> variables."</span><o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
<span style="font-family: 'DejaVu Serif', serif; color: rgb(71, 71, 71);" class="">2) "Atomically sets the value to the given updated value if the current value </span><code style="font-family: 'Courier New';" class=""><span style="font-size: 10pt; font-family: 'DejaVu Sans Mono'; color: rgb(71, 71, 71);" class="">==</span></code><span style="font-family: 'DejaVu Serif', serif; color: rgb(71, 71, 71);" class=""> the
 expected value."</span><o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
<span style="font-family: 'DejaVu Serif', serif; color: rgb(71, 71, 71);" class="">I would not read this as guaranteeing that property. But I agree the spec doesn't make much sense; I read (2) as saying there is no write at all if the CAS fails, as I would
 expect. Thus it seems like a stretch to assume that the write from (1) is to z, though I have no idea what write it would refer to.</span><o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
<span style="font-size: 10.5pt; font-family: 'DejaVu Serif', serif; color: rgb(71, 71, 71);" class="">The prior implementation discussion now does make sense to me. I don't think this is an issue for lock-based implementations. But the only reasonable way to
 support it on ARMv8 seems to be with a conditionally executed fence in the failing case. That adds two instructions, as well as a large amount of time overhead for algorithms that don't retry on a strong CAS. My impression is that those algorithms are frequent
 enough to be a concern.</span><o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
On Sat, May 27, 2017 at 4:49 PM, Alex Otenko <<a href="mailto:oleksandr.otenko@gmail.com" target="_blank" style="color: purple; text-decoration: underline;" class=""><span style="color: purple;" class="">oleksandr.otenko@gmail.com</span></a>> wrote:<o:p class=""></o:p></div>
</div>
</div>
</div>
<blockquote style="border-style: none none none solid; border-left-color: rgb(204, 204, 204); border-left-width: 1pt; padding: 0in 0in 0in 6pt; margin: 5pt 0in 5pt 4.8pt;" class="" type="cite">
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
That’s right.<o:p class=""></o:p></div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
Atomicity (for some definition of atomicity - ie atomic with respect to which operations) is not needed here. As long as the store in CAS occurs always, x=1 is not “reordered” (certainly, not entirely - can’t escape the “store” that is declared in the spec).<o:p class=""></o:p></div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
<span style="color: rgb(136, 136, 136);" class="">Alex</span><o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
</div>
</div>
<div class="">
<blockquote style="margin-top: 5pt; margin-bottom: 5pt;" class="" type="cite">
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
On 28 May 2017, at 00:43, Hans Boehm <<a href="mailto:boehm@acm.org" target="_blank" style="color: purple; text-decoration: underline;" class=""><span style="color: purple;" class="">boehm@acm.org</span></a>> wrote:<o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
I gather the interesting scenario here is the one in which the Thread 2 CAS fails and Thread 2 returns false, while the initial Thread 1 CAS succeeds?<o:p class=""></o:p></div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
The correctness argument here relies on the fact that the load of x in Thread 1 must, in this scenario, see the store of x in Thread 2? This assumes the load of z in the failing CAS in Thread 2 can't be reordered with the ordinary (and racey!) store to x by
 the same thread. I agree that the j.u.c.atomic spec was not clear in this respect, but I don't think it was ever the intent to guarantee that. It's certainly false for either a lock-based or ARMv8 implementation of CAS. Requiring it would raise serious questions
 about practical implementability on several architectures.<o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
The C++ standard is quite clear that this is not required; atomicity means only that the load of a RMW operation sees the immediately prior write in the coherence order for that location. It doesn't guarantee anything about other accesses somehow appearing
 to be performed in the middle of the operation. It's completely analogous to the kind of atomicity you get in a lock-based implementation.<o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
On Sat, May 27, 2017 at 3:26 PM, Alex Otenko <<a href="mailto:oleksandr.otenko@gmail.com" target="_blank" style="color: purple; text-decoration: underline;" class=""><span style="color: purple;" class="">oleksandr.otenko@gmail.com</span></a>> wrote:<o:p class=""></o:p></div>
</div>
</div>
</div>
<blockquote style="border-style: none none none solid; border-left-color: rgb(204, 204, 204); border-left-width: 1pt; padding: 0in 0in 0in 6pt; margin: 5pt 0in 5pt 4.8pt;" class="" type="cite">
<div class="">
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
Not sure what you mean by “acting as a fence” being broken.<o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
There’s probably even more code that relies on atomicity of CAS - that is, when the write happened on successful CAS, it happened atomically with the read; it constitutes a single operation in the total order of all volatile stores.<o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
int x=0; // non-volatile<o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
volatile int z=0;<o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
volatile boolean b=false;<o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
Thread1:<o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
if (CAS(z, 0, 1)) {<o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
  if (x == 0) {<o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
    b=true;<o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
    CAS(z, 1, 2);<o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
  }<o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
}<o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
return x;<o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
Thread2:<o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
x=1;<o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
if (!CAS(z, 0, 2)) {<o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
  return b;<o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
}<o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
return true;<o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
In essence, if CAS failure is caused by a real mismatch of z (not a spurious failure), then we can guarantee there is a return 1 or a further CAS in the future from the point of the first successful CAS (by program order), and we can get a witness b whether
 that CAS is in the future from the point of the failing CAS (by total order of operations).<o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
If failing CAS in Thread2 does not have store semantics, then nothing in Thread1 synchronizes-with it, and Thread1 is not guaranteed to return 1 even if Thread2 returns false.<o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
If failing CAS in Thread2 does have store semantics, then if Thread2 returns false, Thread1 returns 1.<o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
Not sure what you mean by “real programming concerns”. It sounds a bit like “true Scotsman”. The concern I am trying to convey, is that Java 8 semantics offer a very strong CAS that can be used to enforce mutual exclusion using a single CAS call, and that this
 can be combined with inductive types to produce strong guarantees of correctness. Having set the field right, I can make sure most contenders execute less than a single CAS after mutation. Sounds real enough concern to me :)<o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
Anyhow, I also appreciate that most designs do not look that deep into the spec, and won’t notice the meaning getting closer to the actual hardware trends. If Java 8 CAS semantics gets deprecated, the algorithm will become obsolete, and will need modification
 with extra fences in the proprietary code that needs it, or whatever is not broken in the new JMM that will lay the memory semantics of CAS to rest.<o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
<span style="color: rgb(136, 136, 136);" class=""> </span><o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
<span style="color: rgb(136, 136, 136);" class=""> </span><o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
<span style="color: rgb(136, 136, 136);" class="">Alex</span><o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
</div>
</div>
<div class="">
<blockquote style="margin-top: 5pt; margin-bottom: 5pt;" class="" type="cite">
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
On 27 May 2017, at 18:34, Hans Boehm <<a href="mailto:boehm@acm.org" target="_blank" style="color: purple; text-decoration: underline;" class=""><span style="color: purple;" class="">boehm@acm.org</span></a>> wrote:<o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
This still makes no sense to me. Nobody is suggesting that we remove the volatile read guarantee on failure (unlike the weak... version). If the CAS fails, you are guaranteed to see memory affects that happen before the successful change to z. We're talking
 about the "volatile write semantics" for the write that didn't happen.<o:p class=""></o:p></div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
This would all be much easier if we had a litmus test (including code snippets for all involved threads) that could distinguish between the two behaviors. I conjecture that all such tests involve potentially infinite loops, and that none of them reflect real
 programming concerns.<o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
I also conjecture that there exists real code that relies on CAS acting as a fence. We should be crystal clear that such code is broken.<o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
On Fri, May 26, 2017 at 11:42 PM, Alex Otenko <<a href="mailto:oleksandr.otenko@gmail.com" target="_blank" style="color: purple; text-decoration: underline;" class=""><span style="color: purple;" class="">oleksandr.otenko@gmail.com</span></a>> wrote:<o:p class=""></o:p></div>
</div>
</div>
</div>
<blockquote style="border-style: none none none solid; border-left-color: rgb(204, 204, 204); border-left-width: 1pt; padding: 0in 0in 0in 6pt; margin: 5pt 0in 5pt 4.8pt;" class="" type="cite">
<div class="">
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
Integers provide extra structure to plain boolean “failed/succeeded”. Linked data structures with extra dependencies of their contents can also offer extra structure.<o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
if( ! z.CAS(i, j) ) {<o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
  k = z.get();<o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
  if(k < j) {<o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
    // i < k < j<o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
    // whoever mutated z from i to k, should also negotiate mutation of z from k to j<o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
    // with someone else, and they should observe whatever stores precede z.CAS<o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
    // because I won’t contend.<o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
    // of course, I need to check they are still at it - but that, too, does not require<o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
    // stores or CASes<o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
    ...<o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
    return;<o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
  }<o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
}<o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
If whoever mutated z from i to k cannot observe stores that precede z.CAS, they won’t attempt to mutate z to j.<o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
In return can someone explain what the difference is between a weakCompareAndSet failing spuriously and compareAndSet not guaranteeing volatile store semantics on fail? Why should we weaken the promise, if there is already a weak promise to not guarantee visibility
 on fail?<o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
<span style="color: rgb(136, 136, 136);" class=""> </span><o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
<span style="color: rgb(136, 136, 136);" class=""> </span><o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
<span style="color: rgb(136, 136, 136);" class="">Alex</span><o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
</div>
</div>
<div class="">
<blockquote style="margin-top: 5pt; margin-bottom: 5pt;" class="" type="cite">
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
On 26 May 2017, at 22:35, Hans Boehm <<a href="mailto:boehm@acm.org" target="_blank" style="color: purple; text-decoration: underline;" class=""><span style="color: purple;" class="">boehm@acm.org</span></a>> wrote:<o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
Could we please get an example (i.e. litmus test) of how the "memory effect of at least one volatile ... write" is visible, and where it's useful? Since some people seem really attached to it, it shouldn't be that hard to generate a litmus test.<o:p class=""></o:p></div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
So far we have a claim that it could affect progress guarantees, i.e. whether prior writes eventually become visible without further synchronization. I kind of, sort of, half-way believe that.<o:p class=""></o:p></div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
I haven't been able to make sense out of the subsequent illustration attempts. I really don't think it makes sense to require such weird behavior unless we can at least clearly define exactly what the weird behavior buys us. We really need a concise, or at
 least precise and understandable, rationale.<o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
As has been pointed out before, a volatile write W by T1 to x of the same value that was there before is not easily observable. If I read that value in another thread T2, I can't tell which write I'm seeing, and hence hence a failure to see prior T1 writes
 is OK; I might have not seen the final write to x. Thus I would need to communicate the  fact that T1 completed W without actually looking at x. That seems to involve another synchronization of T1 with T2, which by itself would ensure the visibility of prior
 writes to T2.<o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
Thus, aside from possible really obscure progress/liveness issues, I really don't see the difference. I think this requirement, if it is indeed not vacuous and completely ignorable, would lengthen the ARMv8 code sequence for a CAS by at least 2 instructions,
 and introduce a very obscure divergence from C and C++.<o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
I'm worried that we're adding something to make RMW operations behave more like fences. They don't, they can't, and they shouldn't.<o:p class=""></o:p></div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
On Fri, May 26, 2017 at 1:08 PM, Nathan and Ila Reynolds <<a href="mailto:nathanila@gmail.com" target="_blank" style="color: purple; text-decoration: underline;" class=""><span style="color: purple;" class="">nathanila@gmail.com</span></a>> wrote:<o:p class=""></o:p></div>
</div>
</div>
</div>
<blockquote style="border-style: none none none solid; border-left-color: rgb(204, 204, 204); border-left-width: 1pt; padding: 0in 0in 0in 6pt; margin: 5pt 0in 5pt 4.8pt;" class="" type="cite">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
> "The memory effects of a write occur regardless of outcome."<br class="">
> "This method has memory effects of at least one volatile read and write."<br class="">
<br class="">
I am not sure what memory effects means.  If this is defined somewhere in the specs, then ignore this since I haven't read JDK 9 specs.<br class="">
<br class="">
Does memory effects mean the cache line will be switched into the modified state even if an actual write doesn't occur?  Or does memory effects have to do with ordering of memory operations with respect to the method's operation?<br class="">
<br class="">
-Nathan<o:p class=""></o:p></div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
<br class="">
On 5/26/2017 1:59 PM, Doug Lea wrote:<o:p class=""></o:p></div>
</div>
</div>
</div>
<blockquote style="border-style: none none none solid; border-left-color: rgb(204, 204, 204); border-left-width: 1pt; padding: 0in 0in 0in 6pt; margin: 5pt 0in 5pt 4.8pt;" class="" type="cite"><p class="MsoNormal" style="margin: 0in 0in 12pt; font-size: 11pt; font-family: Calibri, sans-serif;">
On 05/26/2017 12:22 PM, Gil Tene wrote:<o:p class=""></o:p></p>
<blockquote style="border-style: none none none solid; border-left-color: rgb(204, 204, 204); border-left-width: 1pt; padding: 0in 0in 0in 6pt; margin: 5pt 0in 5pt 4.8pt;" class="" type="cite">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
Actually this is another case where the Java 9 spec needs to be adjusted…<o:p class=""></o:p></div>
</div>
</div>
</div>
</blockquote>
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
The pre-jdk9 method for weak CAS is now available in four<br class="">
flavors: weakCompareAndSetPlain, weakCompareAndSet,<br class="">
weakCompareAndSetAcquire, weakCompareAndSetRelease.<br class="">
They have different read/write access modes. The specs reflect this.<br class="">
The one keeping the name weakCompareAndSet is stronger, the others<br class="">
weaker than before (this is the only naming scheme that works).<br class="">
<br class="">
About those specs... see JBS JDK-8181104<br class="">
   <a href="https://bugs.openjdk.java.net/browse/JDK-8181104" target="_blank" style="color: purple; text-decoration: underline;" class=""><span style="color: purple;" class="">https://bugs.openjdk.java.net/browse/JDK-8181104</span></a><br class="">
The plan is for all CAS VarHandle methods to include the sentence<br class="">
   "The memory effects of a write occur regardless of outcome."<br class="">
And for j.u.c.atomic methods getAndUpdate, updateAndGet,<br class="">
getAndAccumulate, accumulateAndGet to include the sentence:<br class="">
   "This method has memory effects of at least one volatile read and write."<br class="">
<br class="">
Which should clear up confusion.<br class="">
<br class="">
-Doug<br class="">
<br class="">
<br class="">
<br class="">
_______________________________________________<br class="">
Concurrency-interest mailing list<br class="">
<a href="mailto:Concurrency-interest@cs.oswego.edu" target="_blank" style="color: purple; text-decoration: underline;" class=""><span style="color: purple;" class="">Concurrency-interest@cs.oswego.edu</span></a><br class="">
<a href="http://cs.oswego.edu/mailman/listinfo/concurrency-interest" target="_blank" style="color: purple; text-decoration: underline;" class=""><span style="color: purple;" class="">http://cs.oswego.edu/mailman/listinfo/concurrency-interest</span></a><o:p class=""></o:p></div>
</div>
</div>
</div>
</blockquote>
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
<span class="m-6162653600462780782m8037708059649428697m1300513861833670576hoenzb"><span style="color: rgb(136, 136, 136);" class="">--</span></span><span class="apple-converted-space"><span style="color: rgb(136, 136, 136);" class=""> </span></span><span style="color: rgb(136, 136, 136);" class=""><br class="">
<span class="m-6162653600462780782m8037708059649428697m1300513861833670576hoenzb">-Nathan</span></span><o:p class=""></o:p></div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
<br class="">
<br class="">
_______________________________________________<br class="">
Concurrency-interest mailing list<br class="">
<a href="mailto:Concurrency-interest@cs.oswego.edu" target="_blank" style="color: purple; text-decoration: underline;" class=""><span style="color: purple;" class="">Concurrency-interest@cs.oswego.edu</span></a><br class="">
<a href="http://cs.oswego.edu/mailman/listinfo/concurrency-interest" target="_blank" style="color: purple; text-decoration: underline;" class=""><span style="color: purple;" class="">http://cs.oswego.edu/mailman/listinfo/concurrency-interest</span></a><o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
</div>
</blockquote>
</div>
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
 <o:p class=""></o:p></div>
</div>
</div>
</div>
</div>
</div>
</div>
</div>
<div class="">
<div class="">
<div class="">
<div style="margin: 0in 0in 0.0001pt; font-size: 11pt; font-family: Calibri, sans-serif;" class="">
_______________________________________________<br class="">
Concurrency-interest mailing list<br class="">
<a href="mailto:Concurrency-interest@cs.oswego.edu" target="_blank" style="color: purple; text-decoration: underline;" class=""><span style="color: purple;" class="">Concurrency-interest@cs.oswego.edu</span></a><br class="">
<a href="http://cs.oswego.edu/mailman/listinfo/concurrency-interest" target="_blank" style="color: purple; text-decoration: underline;" class=""><span style="color: purple;" class="">http://cs.oswego.edu/mailman/listinfo/concurrency-interest</span></a></div>
</div>
</div>
</div>
</div>
</blockquote>
</div>
</div>
</div>
</div>
</blockquote>
</div>
</div>
</div>
</blockquote>
</div>
</div>
</div>
</div>
</blockquote>
</div>
</div>
</div>
</blockquote>
</div>
</div>
</div>
</div>
</div>
</div>
</blockquote>
</div>
</div>
</div>
</blockquote>
</div>
</div>
</div>
</div>
</blockquote>
</div>
</div>
</div>
</div>
</div>
</div>
</div>
</blockquote>
</div>
</div>
</div>
</div>
</div>
</div>
</blockquote>
</div>
</div>
</div>
</div>
</div>
</blockquote>
</div>
</div>
</div>
</div>
</div>
</blockquote>
</div>
<br class="">
</div>
</div>
</blockquote>
<blockquote type="cite" class="">
<div class=""><span class="">_______________________________________________</span><br class="">
<span class="">Concurrency-interest mailing list</span><br class="">
<span class=""><a href="mailto:Concurrency-interest@cs.oswego.edu" class="">Concurrency-interest@cs.oswego.edu</a></span><br class="">
<span class=""><a href="http://cs.oswego.edu/mailman/listinfo/concurrency-interest" class="">http://cs.oswego.edu/mailman/listinfo/concurrency-interest</a></span><br class="">
</div>
</blockquote>
</div>
</div>
</blockquote>
</div>
<br class="">
</div>
</div>
</blockquote>
</div>
<br class="">
</div>

</div></blockquote></div><br class=""></body></html>