Question

EDIT: I am asking what happens when two threads concurrently access the same data without proper synchronization (before this edit, that point was not expressed clearly).

I have a question about the optimizations that are performed by the C# compiler and by the JIT compiler.

Consider the following simplified example:

class Example {
    private Action _action;

    private void InvokeAction() {
        var local = this._action;
        if (local != null) {
            local();
        }
    }
}

Please ignore in the example that reading _action might yield a cached and outdated value as there is no volatile specifier nor any other sychronization. That is not the point 🙂

Is the compiler (or actually the jitter at runtime) allowed to optimize the assignment to the local variable out and instead reading _action from memory twice:

class Example {
    private Action _action;

    private void InvokeAction() {
        if (this._action != null) {
            this._action(); // might be set to null by an other thread.
        }
    }
}

which might throw a NullReferenceException when the field _action is set to null by a concurrent assignment.

Of course in this example such an “optimization” would not make any sense because it would be faster to store the value in a register and thus using the local variable. But in more complex cases, is there a guarantee that this works as expected without re-reading the value from memory?

Answer 1

It is legal optimization according to the memory model defined in the ECMA specification. If the _action were volatile, memory model would guarantee that the value is read only once and so this optimization could not happen.

However, I think that current Microsoft’s CLR implementations do not optimize local variables away.