Re: Concurrency-interest Digest, Vol 138, Issue 1

classic Classic list List threaded Threaded
5 messages Options
Reply | Threaded
Open this post in threaded view
|

Re: Concurrency-interest Digest, Vol 138, Issue 1

Sergey Zaytsev
Well, I think I got the whole point, which might be very obvious to lots of people but might also be useful for those who is still looking for precise expiation. I hope Aleksey and Matrin could verify the following:
the reason we use _actions_ judging about program’s possible result is because we care about real execution. When things are going on. Of course, those executions come from program’ statements and here is the connection point. But statements are static.They do nothing until being executed. And ‘cause results only possible after execution we use term _action_ pointing out only those important for discussion, leaving statement behind.

This might sound very simple, but since JMM likes definitions I thought sharing this particular hindsight might be useful ( Of course considering its correctness )


Sergey


> On 08 Jul 2016, at 19:00, [hidden email] wrote:
>
> Send Concurrency-interest mailing list submissions to
> [hidden email]
>
> To subscribe or unsubscribe via the World Wide Web, visit
> http://cs.oswego.edu/mailman/listinfo/concurrency-interest
> or, via email, send a message with subject or body 'help' to
> [hidden email]
>
> You can reach the person managing the list at
> [hidden email]
>
> When replying, please edit your Subject line so it is more specific
> than "Re: Contents of Concurrency-interest digest..."
>
>
> Today's Topics:
>
>   1. JMM actions to statements transition (Sergey Zaytsev)
>   2. Re: JMM actions to statements transition (Martin Buchholz)
>   3. Re: JMM actions to statements transition (Aleksey Shipilev)
>
>
> ----------------------------------------------------------------------
>
> Message: 1
> Date: Thu, 7 Jul 2016 19:00:28 +0300
> From: Sergey Zaytsev <[hidden email]>
> To: [hidden email]
> Subject: [concurrency-interest] JMM actions to statements transition
> Message-ID: <[hidden email]>
> Content-Type: text/plain; charset=us-ascii
>
> Hi all. Can somebody , please, bring some light on JMM actions ? How can one use such abstract term like "action" to argue about correctness or possible results, since there is no strict definition is term "action" ?
>
> I mean is volatile read simply equals to var local = va and volatile write action to va = "some value" ?
>
> Sergey
>
> ------------------------------
>
> Message: 2
> Date: Thu, 7 Jul 2016 13:32:22 -0700
> From: Martin Buchholz <[hidden email]>
> To: Sergey Zaytsev <[hidden email]>
> Cc: concurrency-interest <[hidden email]>
> Subject: Re: [concurrency-interest] JMM actions to statements
> transition
> Message-ID:
> <CA+kOe08MPpr=QpqVDePm0_S+kiZ9rOJLukRv8ua=[hidden email]>
> Content-Type: text/plain; charset="utf-8"
>
> There is an attempt to define them in the jls (but it's hard to understand)
> https://docs.oracle.com/javase/specs/jls/se8/html/jls-17.html#jls-17.4.2
> People don't think about "actions", but do think about "synchronization
> actions".
>
> On Thu, Jul 7, 2016 at 9:00 AM, Sergey Zaytsev <[hidden email]> wrote:
>
>> Hi all. Can somebody , please, bring some light on JMM actions ? How can
>> one use such abstract term like "action" to argue about correctness or
>> possible results, since there is no strict definition is term "action" ?
>>
>> I mean is volatile read simply equals to var local = va and volatile write
>> action to va = "some value" ?
>>
>> Sergey
>> _______________________________________________
>> Concurrency-interest mailing list
>> [hidden email]
>> http://cs.oswego.edu/mailman/listinfo/concurrency-interest
>>
> -------------- next part --------------
> An HTML attachment was scrubbed...
> URL: <http://cs.oswego.edu/pipermail/concurrency-interest/attachments/20160707/68114a1d/attachment-0001.html>
>
> ------------------------------
>
> Message: 3
> Date: Fri, 8 Jul 2016 13:48:35 +0300
> From: Aleksey Shipilev <[hidden email]>
> To: [hidden email]
> Subject: Re: [concurrency-interest] JMM actions to statements
> transition
> Message-ID: <[hidden email]>
> Content-Type: text/plain; charset="utf-8"
>
> On 07/07/2016 07:00 PM, Sergey Zaytsev wrote:
>> Hi all. Can somebody , please, bring some light on JMM actions ? How
>> can one use such abstract term like "action" to argue about
>> correctness or possible results, since there is no strict definition
>> is term "action" ?
>
> What do you mean "no strict definition"? There is JLS 17.4.2 "Actions"
> that enumerate them.
>
>
>> I mean is volatile read simply equals to var local = va and volatile
>> write action to va = "some value" ?
>
> This is where it gets messy. Actions and program statements are
> connected with program order. More precisely, out of the entire "soup of
> executions" that you may construct with arbitrary actions, you can only
> select those executions where the actions of one particular thread can
> be derived from the original program, to reason about that particular
> program outcomes.
>
> I thought I explained it here:
>  https://shipilev.net/blog/2014/jmm-pragmatics/#_java_memory_model
>
> Thanks,
> -Aleksey
>
> -------------- next part --------------
> A non-text attachment was scrubbed...
> Name: signature.asc
> Type: application/pgp-signature
> Size: 819 bytes
> Desc: OpenPGP digital signature
> URL: <http://cs.oswego.edu/pipermail/concurrency-interest/attachments/20160708/09cf1a71/attachment-0001.sig>
>
> ------------------------------
>
> Subject: Digest Footer
>
> _______________________________________________
> Concurrency-interest mailing list
> [hidden email]
> http://cs.oswego.edu/mailman/listinfo/concurrency-interest
>
>
> ------------------------------
>
> End of Concurrency-interest Digest, Vol 138, Issue 1
> ****************************************************

_______________________________________________
Concurrency-interest mailing list
[hidden email]
http://cs.oswego.edu/mailman/listinfo/concurrency-interest
Reply | Threaded
Open this post in threaded view
|

Re: Concurrency-interest Digest, Vol 138, Issue 1

Aleksey Shipilev-2
On 07/08/2016 11:32 PM, Sergey Zaytsev wrote:

> Well, I think I got the whole point, which might be very obvious to
> lots of people but might also be useful for those who is still
> looking for precise expiation. I hope Aleksey and Matrin could verify
> the following: the reason we use _actions_ judging about program’s
> possible result is because we care about real execution. When things
> are going on. Of course, those executions come from program’
> statements and here is the connection point. But statements are
> static.They do nothing until being executed. And ‘cause results only
> possible after execution we use term _action_ pointing out only those
> important for discussion, leaving statement behind.
Yes, that sounds reasonable.

In memory model, we want to capture the fact that we have indeed written
and read a particular value to/from the particular location. Program (as
the set of statements) itself is a very cumbersome abstraction to
capture that.

We also don't really care about statements that do not affect memory,
this is why it is handy to enumerate the actual actions (reading/writing
variables, locking/unlocking) that interest us, leaving the rest of the
program alone.

-Aleksey


_______________________________________________
Concurrency-interest mailing list
[hidden email]
http://cs.oswego.edu/mailman/listinfo/concurrency-interest

signature.asc (836 bytes) Download Attachment
Reply | Threaded
Open this post in threaded view
|

Re: Concurrency-interest Digest, Vol 138, Issue 1

Alex Otenko
In reply to this post by Sergey Zaytsev
An action is an instance of a statement in history.


Without referring to history we cannot speak of temporal relationships.

And there may be multiple instances of the same statement in a history, so there is no 1:1 correspondence between program statements and actions in history - you cannot use program statements as a substitute for actions.

Alex

> On 8 Jul 2016, at 21:32, Sergey Zaytsev <[hidden email]> wrote:
>
> Well, I think I got the whole point, which might be very obvious to lots of people but might also be useful for those who is still looking for precise expiation. I hope Aleksey and Matrin could verify the following:
> the reason we use _actions_ judging about program’s possible result is because we care about real execution. When things are going on. Of course, those executions come from program’ statements and here is the connection point. But statements are static.They do nothing until being executed. And ‘cause results only possible after execution we use term _action_ pointing out only those important for discussion, leaving statement behind.
>
> This might sound very simple, but since JMM likes definitions I thought sharing this particular hindsight might be useful ( Of course considering its correctness )
>
>
> Sergey
>
>
>> On 08 Jul 2016, at 19:00, [hidden email] wrote:
>>
>> Send Concurrency-interest mailing list submissions to
>> [hidden email]
>>
>> To subscribe or unsubscribe via the World Wide Web, visit
>> http://cs.oswego.edu/mailman/listinfo/concurrency-interest
>> or, via email, send a message with subject or body 'help' to
>> [hidden email]
>>
>> You can reach the person managing the list at
>> [hidden email]
>>
>> When replying, please edit your Subject line so it is more specific
>> than "Re: Contents of Concurrency-interest digest..."
>>
>>
>> Today's Topics:
>>
>>  1. JMM actions to statements transition (Sergey Zaytsev)
>>  2. Re: JMM actions to statements transition (Martin Buchholz)
>>  3. Re: JMM actions to statements transition (Aleksey Shipilev)
>>
>>
>> ----------------------------------------------------------------------
>>
>> Message: 1
>> Date: Thu, 7 Jul 2016 19:00:28 +0300
>> From: Sergey Zaytsev <[hidden email]>
>> To: [hidden email]
>> Subject: [concurrency-interest] JMM actions to statements transition
>> Message-ID: <[hidden email]>
>> Content-Type: text/plain; charset=us-ascii
>>
>> Hi all. Can somebody , please, bring some light on JMM actions ? How can one use such abstract term like "action" to argue about correctness or possible results, since there is no strict definition is term "action" ?
>>
>> I mean is volatile read simply equals to var local = va and volatile write action to va = "some value" ?
>>
>> Sergey
>>
>> ------------------------------
>>
>> Message: 2
>> Date: Thu, 7 Jul 2016 13:32:22 -0700
>> From: Martin Buchholz <[hidden email]>
>> To: Sergey Zaytsev <[hidden email]>
>> Cc: concurrency-interest <[hidden email]>
>> Subject: Re: [concurrency-interest] JMM actions to statements
>> transition
>> Message-ID:
>> <CA+kOe08MPpr=QpqVDePm0_S+kiZ9rOJLukRv8ua=[hidden email]>
>> Content-Type: text/plain; charset="utf-8"
>>
>> There is an attempt to define them in the jls (but it's hard to understand)
>> https://docs.oracle.com/javase/specs/jls/se8/html/jls-17.html#jls-17.4.2
>> People don't think about "actions", but do think about "synchronization
>> actions".
>>
>> On Thu, Jul 7, 2016 at 9:00 AM, Sergey Zaytsev <[hidden email]> wrote:
>>
>>> Hi all. Can somebody , please, bring some light on JMM actions ? How can
>>> one use such abstract term like "action" to argue about correctness or
>>> possible results, since there is no strict definition is term "action" ?
>>>
>>> I mean is volatile read simply equals to var local = va and volatile write
>>> action to va = "some value" ?
>>>
>>> Sergey
>>> _______________________________________________
>>> Concurrency-interest mailing list
>>> [hidden email]
>>> http://cs.oswego.edu/mailman/listinfo/concurrency-interest
>>>
>> -------------- next part --------------
>> An HTML attachment was scrubbed...
>> URL: <http://cs.oswego.edu/pipermail/concurrency-interest/attachments/20160707/68114a1d/attachment-0001.html>
>>
>> ------------------------------
>>
>> Message: 3
>> Date: Fri, 8 Jul 2016 13:48:35 +0300
>> From: Aleksey Shipilev <[hidden email]>
>> To: [hidden email]
>> Subject: Re: [concurrency-interest] JMM actions to statements
>> transition
>> Message-ID: <[hidden email]>
>> Content-Type: text/plain; charset="utf-8"
>>
>> On 07/07/2016 07:00 PM, Sergey Zaytsev wrote:
>>> Hi all. Can somebody , please, bring some light on JMM actions ? How
>>> can one use such abstract term like "action" to argue about
>>> correctness or possible results, since there is no strict definition
>>> is term "action" ?
>>
>> What do you mean "no strict definition"? There is JLS 17.4.2 "Actions"
>> that enumerate them.
>>
>>
>>> I mean is volatile read simply equals to var local = va and volatile
>>> write action to va = "some value" ?
>>
>> This is where it gets messy. Actions and program statements are
>> connected with program order. More precisely, out of the entire "soup of
>> executions" that you may construct with arbitrary actions, you can only
>> select those executions where the actions of one particular thread can
>> be derived from the original program, to reason about that particular
>> program outcomes.
>>
>> I thought I explained it here:
>> https://shipilev.net/blog/2014/jmm-pragmatics/#_java_memory_model
>>
>> Thanks,
>> -Aleksey
>>
>> -------------- next part --------------
>> A non-text attachment was scrubbed...
>> Name: signature.asc
>> Type: application/pgp-signature
>> Size: 819 bytes
>> Desc: OpenPGP digital signature
>> URL: <http://cs.oswego.edu/pipermail/concurrency-interest/attachments/20160708/09cf1a71/attachment-0001.sig>
>>
>> ------------------------------
>>
>> Subject: Digest Footer
>>
>> _______________________________________________
>> Concurrency-interest mailing list
>> [hidden email]
>> http://cs.oswego.edu/mailman/listinfo/concurrency-interest
>>
>>
>> ------------------------------
>>
>> End of Concurrency-interest Digest, Vol 138, Issue 1
>> ****************************************************
>
> _______________________________________________
> Concurrency-interest mailing list
> [hidden email]
> http://cs.oswego.edu/mailman/listinfo/concurrency-interest

_______________________________________________
Concurrency-interest mailing list
[hidden email]
http://cs.oswego.edu/mailman/listinfo/concurrency-interest
Reply | Threaded
Open this post in threaded view
|

Re: Concurrency-interest Digest, Vol 138, Issue 1

Sergey Zaytsev
Very intersting point, but doesn't look like a handy abstraction since it seems to take quite an affort to build lots of history time lines ( term "histroy" automatically introduces term "time" ) accroding to your quote  

> there may be multiple instances of the same statement in a history


to consider about particular programm output.

If It is even possible to think about history in terms of SC means we have single timeline. But, JMM avoid notion of time as much as it even possible. So, how is that possible being on top of JMM, which got rid of time, to use the notion of time ? Is it correct ?


Sergey


> On 11 Jul 2016, at 11:44, Alex Otenko <[hidden email]> wrote:
>
> An action is an instance of a statement in history.
>
>
> Without referring to history we cannot speak of temporal relationships.
>
> And there may be multiple instances of the same statement in a history, so there is no 1:1 correspondence between program statements and actions in history - you cannot use program statements as a substitute for actions.
>
> Alex
>
>> On 8 Jul 2016, at 21:32, Sergey Zaytsev <[hidden email]> wrote:
>>
>> Well, I think I got the whole point, which might be very obvious to lots of people but might also be useful for those who is still looking for precise expiation. I hope Aleksey and Matrin could verify the following:
>> the reason we use _actions_ judging about program’s possible result is because we care about real execution. When things are going on. Of course, those executions come from program’ statements and here is the connection point. But statements are static.They do nothing until being executed. And ‘cause results only possible after execution we use term _action_ pointing out only those important for discussion, leaving statement behind.
>>
>> This might sound very simple, but since JMM likes definitions I thought sharing this particular hindsight might be useful ( Of course considering its correctness )
>>
>>
>> Sergey
>>
>>
>>> On 08 Jul 2016, at 19:00, [hidden email] wrote:
>>>
>>> Send Concurrency-interest mailing list submissions to
>>> [hidden email]
>>>
>>> To subscribe or unsubscribe via the World Wide Web, visit
>>> http://cs.oswego.edu/mailman/listinfo/concurrency-interest
>>> or, via email, send a message with subject or body 'help' to
>>> [hidden email]
>>>
>>> You can reach the person managing the list at
>>> [hidden email]
>>>
>>> When replying, please edit your Subject line so it is more specific
>>> than "Re: Contents of Concurrency-interest digest..."
>>>
>>>
>>> Today's Topics:
>>>
>>> 1. JMM actions to statements transition (Sergey Zaytsev)
>>> 2. Re: JMM actions to statements transition (Martin Buchholz)
>>> 3. Re: JMM actions to statements transition (Aleksey Shipilev)
>>>
>>>
>>> ----------------------------------------------------------------------
>>>
>>> Message: 1
>>> Date: Thu, 7 Jul 2016 19:00:28 +0300
>>> From: Sergey Zaytsev <[hidden email]>
>>> To: [hidden email]
>>> Subject: [concurrency-interest] JMM actions to statements transition
>>> Message-ID: <[hidden email]>
>>> Content-Type: text/plain; charset=us-ascii
>>>
>>> Hi all. Can somebody , please, bring some light on JMM actions ? How can one use such abstract term like "action" to argue about correctness or possible results, since there is no strict definition is term "action" ?
>>>
>>> I mean is volatile read simply equals to var local = va and volatile write action to va = "some value" ?
>>>
>>> Sergey
>>>
>>> ------------------------------
>>>
>>> Message: 2
>>> Date: Thu, 7 Jul 2016 13:32:22 -0700
>>> From: Martin Buchholz <[hidden email]>
>>> To: Sergey Zaytsev <[hidden email]>
>>> Cc: concurrency-interest <[hidden email]>
>>> Subject: Re: [concurrency-interest] JMM actions to statements
>>> transition
>>> Message-ID:
>>> <CA+kOe08MPpr=QpqVDePm0_S+kiZ9rOJLukRv8ua=[hidden email]>
>>> Content-Type: text/plain; charset="utf-8"
>>>
>>> There is an attempt to define them in the jls (but it's hard to understand)
>>> https://docs.oracle.com/javase/specs/jls/se8/html/jls-17.html#jls-17.4.2
>>> People don't think about "actions", but do think about "synchronization
>>> actions".
>>>
>>> On Thu, Jul 7, 2016 at 9:00 AM, Sergey Zaytsev <[hidden email]> wrote:
>>>
>>>> Hi all. Can somebody , please, bring some light on JMM actions ? How can
>>>> one use such abstract term like "action" to argue about correctness or
>>>> possible results, since there is no strict definition is term "action" ?
>>>>
>>>> I mean is volatile read simply equals to var local = va and volatile write
>>>> action to va = "some value" ?
>>>>
>>>> Sergey
>>>> _______________________________________________
>>>> Concurrency-interest mailing list
>>>> [hidden email]
>>>> http://cs.oswego.edu/mailman/listinfo/concurrency-interest
>>>>
>>> -------------- next part --------------
>>> An HTML attachment was scrubbed...
>>> URL: <http://cs.oswego.edu/pipermail/concurrency-interest/attachments/20160707/68114a1d/attachment-0001.html>
>>>
>>> ------------------------------
>>>
>>> Message: 3
>>> Date: Fri, 8 Jul 2016 13:48:35 +0300
>>> From: Aleksey Shipilev <[hidden email]>
>>> To: [hidden email]
>>> Subject: Re: [concurrency-interest] JMM actions to statements
>>> transition
>>> Message-ID: <[hidden email]>
>>> Content-Type: text/plain; charset="utf-8"
>>>
>>> On 07/07/2016 07:00 PM, Sergey Zaytsev wrote:
>>>> Hi all. Can somebody , please, bring some light on JMM actions ? How
>>>> can one use such abstract term like "action" to argue about
>>>> correctness or possible results, since there is no strict definition
>>>> is term "action" ?
>>>
>>> What do you mean "no strict definition"? There is JLS 17.4.2 "Actions"
>>> that enumerate them.
>>>
>>>
>>>> I mean is volatile read simply equals to var local = va and volatile
>>>> write action to va = "some value" ?
>>>
>>> This is where it gets messy. Actions and program statements are
>>> connected with program order. More precisely, out of the entire "soup of
>>> executions" that you may construct with arbitrary actions, you can only
>>> select those executions where the actions of one particular thread can
>>> be derived from the original program, to reason about that particular
>>> program outcomes.
>>>
>>> I thought I explained it here:
>>> https://shipilev.net/blog/2014/jmm-pragmatics/#_java_memory_model
>>>
>>> Thanks,
>>> -Aleksey
>>>
>>> -------------- next part --------------
>>> A non-text attachment was scrubbed...
>>> Name: signature.asc
>>> Type: application/pgp-signature
>>> Size: 819 bytes
>>> Desc: OpenPGP digital signature
>>> URL: <http://cs.oswego.edu/pipermail/concurrency-interest/attachments/20160708/09cf1a71/attachment-0001.sig>
>>>
>>> ------------------------------
>>>
>>> Subject: Digest Footer
>>>
>>> _______________________________________________
>>> Concurrency-interest mailing list
>>> [hidden email]
>>> http://cs.oswego.edu/mailman/listinfo/concurrency-interest
>>>
>>>
>>> ------------------------------
>>>
>>> End of Concurrency-interest Digest, Vol 138, Issue 1
>>> ****************************************************
>>
>> _______________________________________________
>> Concurrency-interest mailing list
>> [hidden email]
>> http://cs.oswego.edu/mailman/listinfo/concurrency-interest
>

_______________________________________________
Concurrency-interest mailing list
[hidden email]
http://cs.oswego.edu/mailman/listinfo/concurrency-interest
Reply | Threaded
Open this post in threaded view
|

Re: Concurrency-interest Digest, Vol 138, Issue 1

Alex Otenko
No, I didn’t introduce time. No, I didn’t introduce single global history as a total order of all events in all threads.

Short “definitions” do suffer from misinterpretations, yes. When you clarify it, you get JMM.


Alex


> On 11 Jul 2016, at 10:15, Sergey Zaytsev <[hidden email]> wrote:
>
> Very intersting point, but doesn't look like a handy abstraction since it seems to take quite an affort to build lots of history time lines ( term "histroy" automatically introduces term "time" ) accroding to your quote  
>
>> there may be multiple instances of the same statement in a history
>
>
> to consider about particular programm output.
>
> If It is even possible to think about history in terms of SC means we have single timeline. But, JMM avoid notion of time as much as it even possible. So, how is that possible being on top of JMM, which got rid of time, to use the notion of time ? Is it correct ?
>
>
> Sergey
>
>
>> On 11 Jul 2016, at 11:44, Alex Otenko <[hidden email]> wrote:
>>
>> An action is an instance of a statement in history.
>>
>>
>> Without referring to history we cannot speak of temporal relationships.
>>
>> And there may be multiple instances of the same statement in a history, so there is no 1:1 correspondence between program statements and actions in history - you cannot use program statements as a substitute for actions.
>>
>> Alex
>>
>>> On 8 Jul 2016, at 21:32, Sergey Zaytsev <[hidden email]> wrote:
>>>
>>> Well, I think I got the whole point, which might be very obvious to lots of people but might also be useful for those who is still looking for precise expiation. I hope Aleksey and Matrin could verify the following:
>>> the reason we use _actions_ judging about program’s possible result is because we care about real execution. When things are going on. Of course, those executions come from program’ statements and here is the connection point. But statements are static.They do nothing until being executed. And ‘cause results only possible after execution we use term _action_ pointing out only those important for discussion, leaving statement behind.
>>>
>>> This might sound very simple, but since JMM likes definitions I thought sharing this particular hindsight might be useful ( Of course considering its correctness )
>>>
>>>
>>> Sergey
>>>
>>>
>>>> On 08 Jul 2016, at 19:00, [hidden email] wrote:
>>>>
>>>> Send Concurrency-interest mailing list submissions to
>>>> [hidden email]
>>>>
>>>> To subscribe or unsubscribe via the World Wide Web, visit
>>>> http://cs.oswego.edu/mailman/listinfo/concurrency-interest
>>>> or, via email, send a message with subject or body 'help' to
>>>> [hidden email]
>>>>
>>>> You can reach the person managing the list at
>>>> [hidden email]
>>>>
>>>> When replying, please edit your Subject line so it is more specific
>>>> than "Re: Contents of Concurrency-interest digest..."
>>>>
>>>>
>>>> Today's Topics:
>>>>
>>>> 1. JMM actions to statements transition (Sergey Zaytsev)
>>>> 2. Re: JMM actions to statements transition (Martin Buchholz)
>>>> 3. Re: JMM actions to statements transition (Aleksey Shipilev)
>>>>
>>>>
>>>> ----------------------------------------------------------------------
>>>>
>>>> Message: 1
>>>> Date: Thu, 7 Jul 2016 19:00:28 +0300
>>>> From: Sergey Zaytsev <[hidden email]>
>>>> To: [hidden email]
>>>> Subject: [concurrency-interest] JMM actions to statements transition
>>>> Message-ID: <[hidden email]>
>>>> Content-Type: text/plain; charset=us-ascii
>>>>
>>>> Hi all. Can somebody , please, bring some light on JMM actions ? How can one use such abstract term like "action" to argue about correctness or possible results, since there is no strict definition is term "action" ?
>>>>
>>>> I mean is volatile read simply equals to var local = va and volatile write action to va = "some value" ?
>>>>
>>>> Sergey
>>>>
>>>> ------------------------------
>>>>
>>>> Message: 2
>>>> Date: Thu, 7 Jul 2016 13:32:22 -0700
>>>> From: Martin Buchholz <[hidden email]>
>>>> To: Sergey Zaytsev <[hidden email]>
>>>> Cc: concurrency-interest <[hidden email]>
>>>> Subject: Re: [concurrency-interest] JMM actions to statements
>>>> transition
>>>> Message-ID:
>>>> <CA+kOe08MPpr=QpqVDePm0_S+kiZ9rOJLukRv8ua=[hidden email]>
>>>> Content-Type: text/plain; charset="utf-8"
>>>>
>>>> There is an attempt to define them in the jls (but it's hard to understand)
>>>> https://docs.oracle.com/javase/specs/jls/se8/html/jls-17.html#jls-17.4.2
>>>> People don't think about "actions", but do think about "synchronization
>>>> actions".
>>>>
>>>> On Thu, Jul 7, 2016 at 9:00 AM, Sergey Zaytsev <[hidden email]> wrote:
>>>>
>>>>> Hi all. Can somebody , please, bring some light on JMM actions ? How can
>>>>> one use such abstract term like "action" to argue about correctness or
>>>>> possible results, since there is no strict definition is term "action" ?
>>>>>
>>>>> I mean is volatile read simply equals to var local = va and volatile write
>>>>> action to va = "some value" ?
>>>>>
>>>>> Sergey
>>>>> _______________________________________________
>>>>> Concurrency-interest mailing list
>>>>> [hidden email]
>>>>> http://cs.oswego.edu/mailman/listinfo/concurrency-interest
>>>>>
>>>> -------------- next part --------------
>>>> An HTML attachment was scrubbed...
>>>> URL: <http://cs.oswego.edu/pipermail/concurrency-interest/attachments/20160707/68114a1d/attachment-0001.html>
>>>>
>>>> ------------------------------
>>>>
>>>> Message: 3
>>>> Date: Fri, 8 Jul 2016 13:48:35 +0300
>>>> From: Aleksey Shipilev <[hidden email]>
>>>> To: [hidden email]
>>>> Subject: Re: [concurrency-interest] JMM actions to statements
>>>> transition
>>>> Message-ID: <[hidden email]>
>>>> Content-Type: text/plain; charset="utf-8"
>>>>
>>>> On 07/07/2016 07:00 PM, Sergey Zaytsev wrote:
>>>>> Hi all. Can somebody , please, bring some light on JMM actions ? How
>>>>> can one use such abstract term like "action" to argue about
>>>>> correctness or possible results, since there is no strict definition
>>>>> is term "action" ?
>>>>
>>>> What do you mean "no strict definition"? There is JLS 17.4.2 "Actions"
>>>> that enumerate them.
>>>>
>>>>
>>>>> I mean is volatile read simply equals to var local = va and volatile
>>>>> write action to va = "some value" ?
>>>>
>>>> This is where it gets messy. Actions and program statements are
>>>> connected with program order. More precisely, out of the entire "soup of
>>>> executions" that you may construct with arbitrary actions, you can only
>>>> select those executions where the actions of one particular thread can
>>>> be derived from the original program, to reason about that particular
>>>> program outcomes.
>>>>
>>>> I thought I explained it here:
>>>> https://shipilev.net/blog/2014/jmm-pragmatics/#_java_memory_model
>>>>
>>>> Thanks,
>>>> -Aleksey
>>>>
>>>> -------------- next part --------------
>>>> A non-text attachment was scrubbed...
>>>> Name: signature.asc
>>>> Type: application/pgp-signature
>>>> Size: 819 bytes
>>>> Desc: OpenPGP digital signature
>>>> URL: <http://cs.oswego.edu/pipermail/concurrency-interest/attachments/20160708/09cf1a71/attachment-0001.sig>
>>>>
>>>> ------------------------------
>>>>
>>>> Subject: Digest Footer
>>>>
>>>> _______________________________________________
>>>> Concurrency-interest mailing list
>>>> [hidden email]
>>>> http://cs.oswego.edu/mailman/listinfo/concurrency-interest
>>>>
>>>>
>>>> ------------------------------
>>>>
>>>> End of Concurrency-interest Digest, Vol 138, Issue 1
>>>> ****************************************************
>>>
>>> _______________________________________________
>>> Concurrency-interest mailing list
>>> [hidden email]
>>> http://cs.oswego.edu/mailman/listinfo/concurrency-interest
>>
>

_______________________________________________
Concurrency-interest mailing list
[hidden email]
http://cs.oswego.edu/mailman/listinfo/concurrency-interest