Is it a sensible optimization to check whether a v

Question

if (var != X)
  var = X;

Is it sensible or not? Will the compiler always optimize-out the if statement? Are there any use cases that would benefit from the if statement?

What if var is a volatile variable?

I'm interested in both C++ and Java answers as the volatile variables have different semantics in both of the languages. Also the Java's JIT-compiling can make a difference.

The if statement introduces branching and additional read that wouldn't happen if we always overwrote var with X, so it's bad. On the other hand, if var == X then using this optimization we perform only a read and we do not perform a write, which could have some effects on cache. Clearly, there are some trade-offs here. I'd like to know how it looks like in practice. Has anyone done any testing on this?

EDIT:

I'm mostly interested about how it looks like in a multi-processor environment. In a trivial situation there doesn't seem to be much sense in checking the variable first. But when cache coherency has to be kept between processors/cores the extra check might be actually beneficial. I just wonder how big impact can it have? Also shouldn't the processor do such an optimization itself? If var == X assigning it once more value X should not 'dirt-up' the cache. But can we rely on this?

Answer 1

It would be sensible if you had read-write locking semantics involved, whenever reading is usually less disruptive than writing.

Answer 2

There are situations where even a trivial assignment of say a pointersized variable can be more expensive than a read and branch (especially if predictable).

Why? Multithreading. If several threads are only reading the same value, they can all share that value in their caches. But as soon as you write to it, you have to invalidate the cacheline and get the new value the next time you want to read it or you have to get the updated value to keep your cache coherent. Both situations lead to more traffic between the cores and add latency to the reads.

If the branch is pretty unpredictable though it's probably still slower.