Identifying possibility of interference

Question

In multi tasking environment. If a task has the expression y = x + x; is there a possibility of an interrupt(task switching) occurring between the two reads of x.

Answer 1

In most cases a compiler generate code would read x only once since the optimisation is trivial. In fact it might even translate the operation into a right-shift, equivalent to x << 1. However you cannot guarantee that, and if x were declared volatile it would necessarily make two reads that will then be uninterruptible between reading of the low-order and high-order words (or vice versa),and in that case the assignment of y is also interruptable.

Another issue is that if x were not an atomic data type (i.e. could not be read in a single instruction) such as a 32 bit type on a 16 bit target for example, then even if it were a single read, it may be interruptable.

In either case it is only normally a problem if the x itself (or y in the second case) is shared between contexts (in which case it should also be declared volatile so two reads would then be necessary), or if for some reason the timing of the assignment were somehow critical and needed to be entirely deterministic (unlikely).

If x is shared and therefore volatile but is an atomic type, the simple solution in this example is to write the expression y = x << 1 or y = x * 2 to ensure that x is read only once. Where x is not atomic - you might need to lock the scheduler or disable interrupts (i.e. use a critical section), or more selectively protect the access with a mutex for example. For more complex expressions where the expression cannot be reduced to a single reference to the shared variable, simply assigning the variable to a non-shared local temporary variable ensures that it is read just once. The issue of atomicity still stands.

Answer 2

Here a specific answer for x86 like architectures, used with a traditional scheduler (https://en.wikipedia.org/wiki/Completely_Fair_Scheduler). Have a look at this asm code, generated for x86 by gcc with optimization set to -OS0.

https://godbolt.org/g/AfKTkF

int main(void) {
  int y;
  int x = 5;
  y = x + x;
}

turns to

main:
        pushq   %rbp
        movq    %rsp, %rbp
        movl    $5, -4(%rbp)
        movl    -4(%rbp), %eax  #read x
        addl    %eax, %eax      #execute x + x
        movl    %eax, -8(%rbp)
        movl    $0, %eax
        popq    %rbp
        ret

As you can see x is only read once, thus implying that even if there WAS a task switch, there would be no second read on x.

---

Edit: EOL states in the comments that x indeed can be read two times, modifying the code above yields following:

volatile x = 5;

forces the compiler to insert two movl operations (instead of one):

movl    -8(%rbp), %edx
movl    -8(%rbp), %eax

This does not make my first guess wrong though. The compiler would optimize the read access of the variable (if it is a simple type) and remove the second read. The volatile keyword forces the compiler to access the latest value in the registers. The first code won't force that read - thus giving a other result in case of thread switches and modification of x.