Is there any performance difference between x+=y and x=x+y (x and y are both simple types) in C#?

Question

In C/C++,

The compound-assignment operators combine the simple-assignment operator with another binary operator. Compound-assignment operators perform the operation specified by the additional operator, then assign the result to the left operand. For example, a compound-assignment expression such as

expression1 += expression2

can be understood as

expression1 = expression1 + expression2

However, the compound-assignment expression is not equivalent to the expanded version because the compound-assignment expression evaluates expression1 only once, while the expanded version evaluates expression1 twice: in the addition operation and in the assignment operation.

(Quoted from Microsoft Docs)

---

For example:

1. For i+=2;, i would be modified directly without any new objects being created.
2. For i=i+2;, a copy of i would be created at first. The copied one would be modified and then be assigned back to i.

        i_copied = i;
        i_copied += 2;
        i = i_copied;

Without any optimizations from compiler, the second method will construct a useless instance, which degrades the performance.

---

In C#, operators like += are not permitted to be overloaded. And all simple types like int or double are declared as readonly struct (Does that mean all of structs in C# are immutable in truth?).

I wonder in C#, is there a certain expression to force object be modified (at least for simple types) directly, without any useless instances being created.

And also, is it possible the C#-compiler optimizes the expression x=x+y to x+=y as expected, if there's no side-effect from constructors and deconstructors.

Answer 1

---

C#

When you compile C# into a .NET assembly, the code is in MSIL (Microsoft Intermediate Language). This allows the code to be portable. The .NET Runtime will compile it JIT for execution.

MSIL is an stack language. It does not know details of the target hardware (such as how many registers does the CPU have). There is only one way to write that addition:

    ldloc.0
    ldloc.1
    add
    stloc.0

Load the first local in the stack, load the second, add※ them, set the first local from the stack.

※: add pops two elements from the stack, adds them, and pushes the result back into the stack.

Thus, both x=x+y and x+=y will yield the same code.

---

Of course, there are optimizations that happens after. The JIT compiler will convert that into actual machine code.

This is what I see with SharpLab:

mov ecx, [ebp-4]
add ecx, [ebp-8]
mov [ebp-4], ecx

So, we copy [ebp-4] into ecx, add [ebp-8] to it, and then copy ecx back to [ebp-4].

So... Is the register ecx a useless instance?

---

Well, that is SharpLab, and that is JIT. A different compiler could in theory convert the code into something different on a different platform.

You can compile .NET code AOT to a native image, which will be more aggressive with optimizations. Although, I do not see how you are going to improve upon a simple addition. Oh, I know, it might see that you do not use this value and remove it, or may see that you are always adding the same values and replace it with a constant.

It might be worth noting that modern .NET JIT is able to continue to optimize the code during execution (it will quickly make a poorly optimized native version of the code, and later - once it is ready - replace it with a better version). This decision comes from the fact that on a JIT runtime, the performance depends on both the time it takes to create the native code and the time that native code takes to run.

---

C++

Let us see what C++ does. This is what I see for both x = x + y and x += y using godbolt (default settings※):

    mov     eax, DWORD PTR [rbp-8]
    add     DWORD PTR [rbp-4], eax
    mov     eax, DWORD PTR [rbp-4]

The instructions mov, add, mov match the ones we got from SharpLab, with a different choice of registers.

※: x86-64 gcc 9.3 with -g -o /tmp/compiler-explorer-compiler2020424-22672-17cap6k.bjoj/output.s -masm=intel -S -fdiagnostics-color=always /tmp/compiler-explorer-compiler2020424-22672-17cap6k.bjoj/example.cpp

Adding the compiler option -O made the code go away. Which makes sense because I was not using it.

Answer 2

To answer such questions you can use SharpLab.

As you can see both the generated IL and the JITted code are the same in both cases.

Answer 3

It is strictly equivalent. The form x += y is syntactic sugar for x = x + y.