C++ memory model and race conditions on char arrays

by

I think Bjarne is wrong about this, or at least, he’s
simplifying things considerably. Most modern processors are
capable of writing a byte without reading a complete word first,
or rather, they behave “as if” this were the case. In
particular, if you have a char array[2];, and thread one only
accesses array[0] and thread two only accesses array[1]
(including when both threads are mutating the value), then you
do not need any additional synchronization; this is guaranteed
by the standard. If the hardware does not allow this directly,
the compiler will have to add the synchronization itself.

It’s very important to note the “as if”, above. Modern hardware
does access main memory by cache lines, not bytes. But it also
has provisions for modifying single bytes in a cache line, so
that when writing back, the processor core will not modify bytes
that have not been modified in its cache.

More Related Contents:

  1. C++11 introduced a standardized memory model. What does it mean? And how is it going to affect C++ programming?
  2. Will two atomic writes to different locations in different threads always be seen in the same order by other threads?
  3. What do each memory_order mean?
  4. C++11: the difference between memory_order_relaxed and memory_order_consume
  5. How do memory_order_seq_cst and memory_order_acq_rel differ?
  6. [[carries_dependency]] what it means and how to implement
  7. Using generic std::function objects with member functions in one class
  8. Reusing a moved container?
  9. C++0x lambda capture by value always const?
  10. ‘colon’ and ‘auto’ in for loop c++? need some help understanding the syntax
  11. Computing length of a C string at compile time. Is this really a constexpr?
  12. Detecting constexpr with SFINAE
  13. Does moving leave the object in a usable state?
  14. Copy constructor is not inherited
  15. C++11 lambda implementation and memory model
  16. How to construct std::array object with initializer list? [duplicate]
  17. What are declarations and declarators and how are their types interpreted by the standard?
  18. Doing a static_assert that a template type is another template
  19. std::bind overload resolution
  20. So why is i = ++i + 1 well-defined in C++11?
  21. Forwarding all constructors in C++0x
  22. What expressions yield a reference type when decltype is applied to them?
  23. How can I have multiple parameter packs in a variadic template?
  24. What is the difference between C++03 `throw()` specifier and C++11 `noexcept`?
  25. What am I allowed to do with a static, constexpr, in-class initialized data member?
  26. reinterpret_cast between char* and std::uint8_t* – safe?
  27. Check if a type is from a particular namespace
  28. How does =delete on destructor prevent stack allocation?
  29. Does ‘auto’ type assignments of a pointer in c++11 require ‘*’?
  30. Why can’t C++11 move a noncopyable functor to a std::function?

Leave a Comment