A reproducible example of volatile usage

by

The exact semantics of volatile is a jitter implementation detail. The compiler emits the Opcodes.Volatile IL instruction where ever you access a variable that’s declared volatile. It does some checking to verify that the variable type is legal, you can’t declare value types larger than 4 bytes volatile but that’s where the buck stops.

The C# language specification defines the behavior of volatile, quoted here by Eric Lippert. The ‘release’ and ‘acquire’ semantics is something that only makes sense on a processor core with a weak memory model. Those kind of processors have not done well in the market, probably because they are such an enormous pain to program. The odds that your code will ever run on a Titanium are slim to none.

What’s especially bad about the C# language specification definition is that it doesn’t mention at all what really happens. Declaring a variable volatile prevents the jitter optimizer from optimizing the code to store the variable in a cpu register. Which is why the code that Marc linked is hanging. This will only happen with the current x86 jitter, another strong hint that volatile is really a jitter implementation detail.

The poor semantics of volatile has a rich history, it comes from the C language. Whose code generators have lots of trouble getting it right as well. Here’s a interesting report about it (pdf). It dates from 2008, a good 30+ years of opportunity to get it right. Or wrong, this goes belly-up when the code optimizer is forgetting about a variable being volatile. Unoptimized code never has a problem with it. Notable is that the jitter in the ‘open source’ version of .NET (SSLI20) completely ignores the IL instruction. It can also be argued that the current behavior of the x86 jitter is a bug. I think it is, it is not easy to bump it into the failure mode. But nobody can argue that it actually is a bug.

The writing is on the wall, only ever declare a variable volatile if it is stored in a memory mapped register. The original intention of the keyword. The odds that you’ll run into such a usage in the C# language should be vanishingly small, code like that belongs in a device driver. And above all, never assume that it is useful in a multi-threading scenario.

More Related Contents:

  1. Creating a blocking Queue in .NET?
  2. What’s the difference between Invoke() and BeginInvoke()
  3. Question about terminating a thread cleanly in .NET
  4. How do I update the GUI from another thread?
  5. What operations are atomic in C#?
  6. Accessing UI (Main) Thread safely in WPF
  7. BackgroundWorker RunWorkerCompleted Event
  8. ‘using’ statement vs ‘try finally’
  9. Thread.Sleep for less than 1 millisecond
  10. Returning a value from thread?
  11. Async process start and wait for it to finish
  12. Regarding local variable passing in Thread
  13. STAThread and multithreading
  14. How expensive is the lock statement?
  15. The calling thread cannot access this object because a different thread owns it.WPF [duplicate]
  16. Lock-free multi-threading is for real threading experts
  17. How to achieve remove_if functionality in .NET ConcurrentDictionary
  18. C# Windows Forms Application – Updating GUI from another thread AND class?
  19. How to interrupt Console.ReadLine
  20. Error: Must create DependencySource on same Thread as the DependencyObject even by using Dispatcher
  21. When is ReaderWriterLockSlim better than a simple lock?
  22. Async thread body loop, It just works, but how?
  23. Locking pattern for proper use of .NET MemoryCache
  24. Access to disposed closure in C#?
  25. Starting a new thread in a foreach loop
  26. Does Func.BeginInvoke use the ThreadPool?
  27. Multithreaded NamePipeServer in C#
  28. Wrapping ManualResetEvent as awaitable task
  29. Half – fences and full fences? [duplicate]
  30. Memory usage in C#

Leave a Comment