Does “volatile” guarantee anything at all in portable C code for multi-core systems?

by

I’m no expert, but cppreference.com has what appears to me to be some pretty good information on volatile. Here’s the gist of it:

Every access (both read and write) made through an lvalue expression
of volatile-qualified type is considered an observable side effect for
the purpose of optimization and is evaluated strictly according to the
rules of the abstract machine (that is, all writes are completed at
some time before the next sequence point). This means that within a
single thread of execution, a volatile access cannot be optimized out
or reordered relative to another visible side effect that is separated
by a sequence point from the volatile access.

It also gives some uses:

Uses of volatile

1) static volatile objects model memory-mapped I/O ports, and static
const volatile objects model memory-mapped input ports, such as a
real-time clock

2) static volatile objects of type sig_atomic_t are used for
communication with signal handlers.

3) volatile variables that are local to a function that contains an
invocation of the setjmp macro are the only local variables guaranteed
to retain their values after longjmp returns.

4) In addition, volatile variables can be used to disable certain
forms of optimization, e.g. to disable dead store elimination or
constant folding for microbenchmarks.

And of course, it mentions that volatile is not useful for thread synchronization:

Note that volatile variables are not suitable for communication
between threads; they do not offer atomicity, synchronization, or
memory ordering. A read from a volatile variable that is modified by
another thread without synchronization or concurrent modification from
two unsynchronized threads is undefined behavior due to a data race.

More Related Contents:

  1. Is malloc thread-safe?
  2. Best way to multi-thread? [closed]
  3. Please explain the following parallel code template
  4. Why is volatile not considered useful in multithreaded C or C++ programming?
  5. Automating the InvokeRequired code pattern
  6. Undefined reference to pthread_create in Linux
  7. Why is volatile needed in C?
  8. How to measure time in milliseconds using ANSI C?
  9. Multithreading program stuck in optimized mode but runs normally in -O0
  10. Concurrent HashSet in .NET Framework?
  11. How should I print types like off_t and size_t?
  12. When the main thread exits, do other threads also exit?
  13. strtok function thread safety
  14. Does Interlocked.CompareExchange use a memory barrier?
  15. Can I get Unix’s pthread.h to compile in Windows?
  16. How to use printf to display off_t, nlink_t, size_t and other special types?
  17. Working of __asm__ __volatile__ (“” : : : “memory”)
  18. Pthread Run a thread right after it’s creation
  19. Do threads have a distinct heap?
  20. Difference between Interlocked.Exchange and Volatile.Write?
  21. Linux/POSIX equivalent for Win32’s CreateEvent, SetEvent, WaitForSingleObject
  22. How to correctly read an Interlocked.Increment’ed int field?
  23. Is it safe to use a boolean flag to stop a thread from running in C#
  24. ConcurrentDictionary Pitfall – Are delegates factories from GetOrAdd and AddOrUpdate synchronized?
  25. Thread safety on readonly static field initialisation
  26. Can multithreading be implemented on a single processor system?
  27. C# and thread-safety of a bool
  28. WaitForSingleObject and WaitForMultipleObjects equivalent in Linux?
  29. How to get the number of CPUs in Linux using C?
  30. Writing to file in a thread safe manner

Leave a Comment