What is the difference between atomic and critical in OpenMP?

by

The effect on g_qCount is the same, but what’s done is different.

An OpenMP critical section is completely general – it can surround any arbitrary block of code. You pay for that generality, however, by incurring significant overhead every time a thread enters and exits the critical section (on top of the inherent cost of serialization).

(In addition, in OpenMP all unnamed critical sections are considered identical (if you prefer, there’s only one lock for all unnamed critical sections), so that if one thread is in one [unnamed] critical section as above, no thread can enter any [unnamed] critical section. As you might guess, you can get around this by using named critical sections).

An atomic operation has much lower overhead. Where available, it takes advantage on the hardware providing (say) an atomic increment operation; in that case there’s no lock/unlock needed on entering/exiting the line of code, it just does the atomic increment which the hardware tells you can’t be interfered with.

The upsides are that the overhead is much lower, and one thread being in an atomic operation doesn’t block any (different) atomic operations about to happen. The downside is the restricted set of operations that atomic supports.

Of course, in either case, you incur the cost of serialization.

More Related Contents:

  1. Fill histograms (array reduction) in parallel with OpenMP without using a critical section
  2. Mixing C++11 atomics and OpenMP
  3. How are firstprivate and lastprivate different than private clauses in OpenMP?
  4. How does the SECTIONS directive in OpenMP distribute work?
  5. How to use lock in OpenMP?
  6. Does the Intel Memory Model make SFENCE and LFENCE redundant?
  7. Cholesky decomposition with OpenMP
  8. How to implement multithread safe singleton in C++11 without using
  9. Where is the lock for a std::atomic?
  10. Error enabling openmp – “ld: library not found for -lgomp” and Clang errors
  11. What do each memory_order mean?
  12. Can I safely use OpenMP with C++11?
  13. OpenMP set_num_threads() is not working
  14. Alignment requirements for atomic x86 instructions vs. MS’s InterlockedCompareExchange documentation?
  15. Understanding the collapse clause in openmp
  16. Are IEnumerable Linq methods thread-safe?
  17. How to atomically update a maximum value?
  18. Why is the volatile qualifier used through out std::atomic?
  19. How does OpenMP handle nested loops?
  20. How to do an atomic increment and fetch in C?
  21. c++, std::atomic, what is std::memory_order and how to use them?
  22. Java: is there no AtomicFloat or AtomicDouble?
  23. OpenMP: What is the benefit of nesting parallelizations?
  24. omp parallel vs. omp parallel for
  25. Are C/C++ fundamental types atomic?
  26. How to atomically rename a file in Java, even if the dest file already exists?
  27. C++11 memory_order_acquire and memory_order_release semantics?
  28. Acquire/Release versus Sequentially Consistent memory order
  29. Why is the != operator not allowed with OpenMP?
  30. Using OpenMP with clang

Leave a Comment