Re: What guarantees do I have on the order of execution?
Am 03.10.2013 19:19, schrieb DeMarcus:
Hi,
In a multithreaded environment (both pre- and post C++11), which of
these are guaranteed to protect the value?
int MyClass::getValue() const
{
SomeScopedMutex lock();
return someMemberValue;
}
Question to above: Will the value be copied to the return value
before the destructor of SomeScopedMutex?
Here are actually three issues involved:
1) In this code there does not happen any call of a destructor of
class SomeScopedMutex, because
SomeScopedMutex lock();
is a function declaration and has no further effects.
2) Assuming you have fixed that to e.g.
SomeScopedMutex lock;
Now to answer your question there needs to be a clear understanding
about what guarantees your type SomeScopedMutex provides. The mutexes
provided by the Standard library provide a very important guarantee
specified in [thread.mutex.requirements.mutex]. Among these we have
"The lock and unlock operations on a single mutex shall appear to
occur in a single total order. [ Note: this can be viewed as the
modification order (1.10) of the mutex. ?end note ]"
and
"Synchronization: Prior unlock() operations on the same object shall
synchronize with (1.10) this operation."
For the unlock operation of a mutex we have:
"Synchronization: This operation synchronizes with (1.10) subsequent
lock operations that obtain ownership on the same object."
The meaning of synchronization operations is a core language term that
is related to the fundamental properties of thread synchronisation and
are also fences, as described in sub-clause [intro.multithread].
int MyClass::getValue() const
{
SomeScopedMutex lock();
int retVal = someMemberValue;
return retVal;
}
int MyClass::getValue() const
{
int retVal;
SomeScopedMutex lock();
retVal = someMemberValue;
return retVal;
}
Question to all above: Am I guaranteed that the compiler won't
optimize those to a malign order of execution?
Assuming you applied the fix above in point (1) of my description and
assuming that the relevant SomeScopedMutex operations satisfy the
synchonisation order guarantees all three forms should be equivalent:
3) In regard to the destructor call order relative to the evaluation
of the return statement we have:
[stmt.return] p2:
"The value of the expression is implicitly converted to the return
type of the function in which it appears."
[basic.stc.auto] p3:
"If a variable with automatic storage duration has initialization or a
destructor with side effects, it shall not be destroyed before the end
of its block, nor shall it be eliminated as an optimization even if it
appears to be unused, except that a class object or its copy/move may
be eliminated as specified in 12.8."
[class.dtor] p11:
"Destructors are invoked implicitly
[..]
? for constructed objects with automatic storage duration (3.7.3) when
the block in which an object is created exits (6.7),"
I think from this it is clear that the destructor must be called
*after* the evaluation of the implicit conversion to the return type,
because the block exit *follows* the return statement in any case.
HTH & Greetings from Bremen,
Daniel Kr?gler
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]