Mixing C++11 atomics and OpenMP

by

Update:

OpenMP 5.0 defines the interactions to C++11 and further. Among others, it says that using the following features may result in unspecified behavior:

  • Data-dependency ordering: atomics and memory model
  • Additions to the standard library
  • C++11 library

So clearly, mixing C++11 atomics and OpenMP 5.0 will result in unspecified behavior. At least the standard itself promises that “future versions of the OpenMP specification are expected to address [these] features”.

Old discussion:

Interestingly, the OpenMP 4.5 standard (2.13.6) has a rather vague reference to C++11 atomics, or more specific std::memory_order:

The intent is that, when the analogous operation exists in C++11 or
C11, a sequentially consistent atomic construct has the same semantics
as a memory_order_seq_cst atomic operation in C++11/C11. Similarly, a
non-sequentially consistent atomic construct has the same semantics as
a memory_order_relaxed atomic operation in C++11/C11.

Unfortunately this is only a note, there is nothing that defines that they are playing nicely together. In particular, even the latest OpenMP 5.0 preview still refers to C++98 as the only normative reference for C++. So technically, OpenMP doesn’t even support C++11 itself.

That aside, it will probably work most of the time in practice. I would agree that using std::atomic has less potential for trouble if used together with OpenMP than C++11 threading. But if there is any trouble, it may not be as obvious. Worst case would be a atomic that doesn’t operate atomically, even though I have serious trouble imagining a realistic scenario where this may happen. At the end of the day, it may not be worth it and the safest thing is to stick with pure OpenMP or pure C++11 thread/atomics.

Maybe Hristo has something to say about this, in the mean time check out this answer for a more general discussion. While a bit dated, I’m afraid it still holds.

More Related Contents:

  1. What exactly is std::atomic?
  2. How to implement multithread safe singleton in C++11 without using
  3. Understanding std::atomic::compare_exchange_weak() in C++11
  4. Double-Checked Lock Singleton in C++11
  5. C++11 introduced a standardized memory model. What does it mean? And how is it going to affect C++ programming?
  6. When to use volatile with multi threading?
  7. How do I terminate a thread in C++11?
  8. Concurrency: Atomic and volatile in C++11 memory model
  9. Passing object by reference to std::thread in C++11
  10. Why don’t compilers merge redundant std::atomic writes?
  11. What are the correct link options to use std::thread in GCC under linux?
  12. std::thread pass by reference calls copy constructor
  13. What’s the difference between “static” and “dynamic” schedule in OpenMP?
  14. How to use std::async on a member function?
  15. When do I really need to use atomic instead of bool? [duplicate]
  16. Which std::async implementations use thread pools?
  17. C++0x thread interruption
  18. What is the difference between packaged_task and async
  19. Get the status of a std::future
  20. C++11 Thread safety of Random number generators
  21. Why are std::atomic objects not copyable?
  22. Is it smart to replace boost::thread and boost::mutex with c++11 equivalents?
  23. Can I use std::async without waiting for the future limitation?
  24. C++ terminate called without an active exception
  25. What is different between join() and detach() for multi threading in C++?
  26. std::thread error (thread not member of std)
  27. thread safety of MPI send using threads created with std::async
  28. Is a memory barrier required to read a value that is atomically modified?
  29. C++11 Implementation of Spinlock using header “
  30. About thread-safety of weak_ptr

Leave a Comment