Be careful working with the atomic directive in OpenMP

I would like to tell you about an error that a person, not familiar with OpenMP technology, can easily make. The error is related to a wrong supposition about how atomic directive works. The atomic directive works faster than critical sections because some atomic operations can be directly replaced with processor commands. That is why it is convenient to use when calculating various expressions. But you should keep in mind that atomic in no way influences the calls of the functions used in the expression.

1817ze

Let us explain it using an example:

class Example
{
public:
  unsigned m_value;
  Example() : m_value(0) {}
  unsigned GetValue()
  {
    return ++m_value;
  }
  unsigned GetSum()
  {
    unsigned sum = 0;
    #pragma omp parallel for
    for (ptrdiff_t i = 0; i < 100; i++)
    {
      #pragma omp atomic
      sum += GetValue();
    }
    return sum;
  }
};

This example contains a race condition error and the value returned by it can vary every time the code is executed. If you try this example and the result is always correct you may change the function GetValue as shown below to make the error more evident:

unsigned GetValue()
{
  Sleep(0);
  m_value++;
  Sleep(0);
  return m_value;
}

In the code, the sum variable is protected from increment with the atomic directive. But this directive does not influence the call of the function GetValue(). The calls occur in parallel threads and it leads to errors when executing “++m_value” operation inside the GetValue function.

Keep in mind that the functions used in the expressions to which atomic directive is applied, must be thread-safe. The atomic directive deals with operations of the following types only:

  • x binop= expr
  • x++
  • ++x
  • x??
  • ??x

Here x is a scalar variable, expr is an expression with scalar types that misses x variable, binop is a non-overloaded operator +, *, -, /, &, ^, |, <<, or >>. In all the other cases you cannot use the atomic directive.

In the example above, atomic directive protects “sum += ” operation but not the call of the function GetValue. To correct the error mentioned you should use a critical section or other ways to protect m_value variable.

Written by Andrey Karpov. This error was found with PVS-Studio static analysis tool.

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s