Re: C++0x: release sequence
On Jun 17, 10:48 am, Anthony Williams <anthony....@gmail.com> wrote:
"Dmitriy V'jukov" <dvyu...@gmail.com> writes:
On 17 =C9=C0=CE, 00:27, Anthony Williams <anthony....@gmail.com> wrote:
Looking forward to next draft. Btw, what about dependent memory
ordering (memory_order_consume)? Is it going to be accepted?
Yes. That's been voted in too.
Oooo, it's a bad news. I only start understading current "1.10", and
they change it almost completely! :)
It's all additions, so it's not too bad. The key thing is that the
paper adds memory_order_consume and dependency ordering, which
provides an additional mechanism for introducing a happens-before
relationship between threads.
The latest proposal about dependent ordering is:
http://open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2556.html
Right?
That's the latest pre-meeting paper. The latest (which is what was
voted on) is N2664 which is currently only available on the committee
site. It should be in the post-meeting mailing.
I hope that in N2664 'happens before' definition is changed. Because
now I can't understand it.
For example in following code:
int data;
std::atomic<int> x;
thread 1:
data = 1;
x.store(1, std::memory_order_release); (A)
thread2:
if (x.load(std::memory_order_consume)) (B)
assert(1 == data); (C)
A dependency-ordered before B, B sequenced before C.
So according to definition of 'happens before' in n2556, A happens-
before C.
According to my understanding, this is simply wrong. There is no data-
dependency between B and C, so A must not happens-before C. (there is
control dependency, but currently C++0x doesn't respect control-
dependency)
------------------------------------
Another moment:
An evaluation A carries a dependency to an evaluation B if
* the value of A is used as an operand of B, and:
o B is not an invocation of any specialization of
std::kill_dependency, and
o A is not the left operand to the comma (',') operator,
I think here ---------------------------------/\/\/\/\/\/\/\
must be 'built-in comma operator'. Because consider following example:
struct X
{
int data;
};
void operator , (int y, X& x)
{
x.data = y;
}
std::atomic<int> a;
int main()
{
int y = a.load(std::memory_order_consume);
X x;
y, x; // here 'carries a dependency' is broken, because 'y' is a
left operand of comma operator
int z = x.data; // but I think, that 'z' still must be in
'dependency tree' rooted by 'y'
}
Where I am wrong this time? :)
Dmitriy V'jukov