Are C/C++ fundamental types atomic?

by

No, fundamental data types (e.g., int, double) are not atomic, see std::atomic.

Instead you can use std::atomic<int> or std::atomic<double>.

Note: std::atomic was introduced with C++11 and my understanding is that prior to C++11, the C++ standard didn’t recognize the existence of multithreading at all.

As pointed out by @Josh, std::atomic_flag is an atomic boolean type. It is guaranteed to be lock-free, unlike the std::atomic specializations.

The quoted documentation is from: http://open-std.org/JTC1/SC22/WG21/docs/papers/2015/n4567.pdf. I’m pretty sure the standard is not free and therefore this isn’t the final/official version.

1.10 Multi-threaded executions and data races

  1. Two expression evaluations conflict if one of them modifies a memory location (1.7) and the other one reads or modifies the same memory location.
  2. The library defines a number of atomic operations (Clause 29) and operations on mutexes (Clause 30) that are specially identified as synchronization operations. These operations play a special role in making assignments in one thread visible to another. A synchronization operation on one or more memory locations is either a consume operation, an acquire operation, a release operation, or both an acquire and release operation. A synchronization operation without an associated memory location is a fence and can be either an acquire fence, a release fence, or both an acquire and release fence. In addition, there are relaxed atomic operations, which are not synchronization operations, and atomic read-modify-write operations, which have special characteristics.

  1. Two actions are potentially concurrent if

    (23.1) — they are performed by different threads, or

    (23.2) — they are unsequenced, and at least one is performed by a signal handler.

    The execution of a program contains a data race if it contains two potentially concurrent conflicting actions, at least one of which is not atomic, and neither happens before the other, except for the special case for signal handlers described below. Any such data race results in undefined behavior.

29.5 Atomic types

  1. There shall be explicit specializations of the atomic template for the integral types “char, signed char, unsigned char, short, unsigned short, int, unsigned int, long, unsigned long, long long, unsigned long long, char16_t, char32_t, wchar_t, and any other types needed by the typedefs in the header <cstdint>. For each integral type integral, the specialization atomic<integral> provides additional atomic operations appropriate to integral types. There shall be a specialization atomic<bool> which provides the general atomic operations as specified in 29.6.1..

  1. There shall be pointer partial specializations of the atomic class template. These specializations shall have standard layout, trivial default constructors, and trivial destructors. They shall each support aggregate initialization syntax.

29.7 Flag type and operations

  1. Operations on an object of type atomic_flag shall be lock-free. [ Note: Hence the operations should also be address-free. No other type requires lock-free operations, so the atomic_flag type is the minimum hardware-implemented type needed to conform to this International standard. The remaining types can be emulated with atomic_flag, though with less than ideal properties. — end note ]

More Related Contents:

  1. When to use volatile with multi threading?
  2. Can num++ be atomic for ‘int num’?
  3. Atomicity on x86
  4. What exactly is std::atomic?
  5. How to implement multithread safe singleton in C++11 without using
  6. Mixing C++11 atomics and OpenMP
  7. c++, std::atomic, what is std::memory_order and how to use them?
  8. Understanding std::atomic::compare_exchange_weak() in C++11
  9. Double-Checked Lock Singleton in C++11
  10. Is a memory barrier required to read a value that is atomically modified?
  11. Why is volatile not considered useful in multithreaded C or C++ programming?
  12. Simple example of threading in C++
  13. Concurrency: Atomic and volatile in C++11 memory model
  14. Programmatically find the number of cores on a machine
  15. How can I implement ABA counter with c++11 CAS?
  16. Using stdlib’s rand() from multiple threads
  17. Lock-free Progress Guarantees in a circular buffer queue
  18. Are C++ Reads and Writes of an int Atomic?
  19. When should I use _mm_sfence _mm_lfence and _mm_mfence
  20. How to efficiently display OpenCV video in Qt?
  21. Precise thread sleep needed. Max 1ms error
  22. What is the difference between packaged_task and async
  23. Thread safe lazy construction of a singleton in C++
  24. Atomicity in C++ : Myth or Reality
  25. c++ work queues with blocking
  26. Is C++ static member variable initialization thread-safe?
  27. Using condition variable in a producer-consumer situation
  28. GCC std::thread not found in namespace std
  29. Threadsafe Vector class for C++
  30. Why does this simple std::thread example not work?

Leave a Comment