Q: Optimization issues?

[Jakob Bieling]

Hi,

I have a question regarding optimization of code that uses
synchronization.

template <typename T>
T somefunc ()
{
enter_mutex ();
T t = shared_variable;
leave_mutex ();
return t;
}

Is the compiler allowed to optimize it, so that the code looks sort of
as if it was:

template <typename T>
T somefunc ()
{
enter_mutex ();
leave_mutex ();
return shared_variable;
}

? This is important, since 'shared_variable' must only be accessed after
'enter_mutex' but before 'leave_mutex' is called. Can this be a problem or
do I not have to worry?

thanks!

 

[Antonio]

Hi,

I have a question regarding optimization of code that uses
synchronization.

template <typename T>
T somefunc ()
{
enter_mutex ();
T t = shared_variable;
leave_mutex ();
return t;
}

Replace T t = shared_variable with volatile T t ...
and try.

Antonio

 

[stephan beal]

template <typename T>
T somefunc ()
{
enter_mutex ();
T t = shared_variable;
leave_mutex ();
return t;
}

Is the compiler allowed to optimize it, so that the code looks sort of
as if it was:

template <typename T>
T somefunc ()
{
enter_mutex ();
leave_mutex ();
return shared_variable;
}

The compiler cannot blindly optimize away 'T t = ...' because that line does
*something* and the compiler doesn't really know what it does. As moving
removing it would definately change the meaning of the code the compiler,
at least as far as i understand, is not allowed to change it in this way
(and indeed should not, as the compiler should never change the *meaning*
of your source).


--
----- stephan beal
Registered Linux User #71917 http://counter.li.org
I speak for myself, not my employer. Contents may
be hot. Slippery when wet. Reading disclaimers makes
you go blind. Writing them is worse. You have been Warned.

 

[wogston]

I have a question regarding optimization of code that uses

synchronization.

template <typename T>
T somefunc ()
{
enter_mutex ();
T t = shared_variable;
leave_mutex ();
return t;
}

Is the compiler allowed to optimize it, so that the code looks sort of
as if it was:

template <typename T>
T somefunc ()
{
enter_mutex ();
leave_mutex ();
return shared_variable;
}

? This is important, since 'shared_variable' must only be accessed after
'enter_mutex' but before 'leave_mutex' is called. Can this be a problem or
do I not have to worry?

Compiler doesn't have to resort to the "optimization" you present here if it
implements NRVO, it will write the shared_variable directly to the return
value slot. If no NRVO, worst case is little extra copying stuff around.. if
compiler does the "optimization" you ask if it would do, the compiler would
be broken and not usable for threading.