Multiple assignment vs object creation

time and space

Which would be faster?

                                 oldPosition = new Vector2(position.X, position.Y);          
 

                                 oldPosition.X = position.X;          
             oldPosition.Y = position.Y;          
 

I'm assuming the second example is more efficient since a new object isn't being created, unless the compiler automatically optimises such things?

6 Replies

Know the answer? Post it — somebody with the same question will find it here.

Vulpes15y ago
Accepted answer
The only authorative account I can find is this 2003 MSDN article (http://msdn.microsoft.com/en-us/library/ms973858.aspx#highperfmanagedapps_topic10) which states in the 'Method Inlining' section that:

"If any of the method's formal arguments are structs, the method will not be inlined."

In this particular case, the Vector2 constructor takes 2 float arguments and 'float' is, of course, an alias for the System.Single struct. So, on that evidence (and very surprisingly IMO) the constructor call will not be inlined even if it only contains 2 lines of assignment code!

There have been two versions of the CLR since then and so things might have changed. However, I thought I'd do my own test using .NET 4.0 and initializing 100 million structs using both approaches. Here's the code:

using System;
using System.Diagnostics;

struct Vector2
{
public float X, Y;

public Vector2(float x, float y)
{
X = x;
Y = y;
}
}

class Test
{
static void Main()
{
Vector2 position, position2;

Stopwatch sw = Stopwatch.StartNew();

for(int i = 1; i <= 100000000; i++)
{
position.X = 1.0f;
position.Y = 2.0f;
}
sw.Stop();
Console.WriteLine(sw.ElapsedTicks);

sw = Stopwatch.StartNew();

for(int i = 1; i <= 100000000; i++)
{
position2 = new Vector2(1.0f, 2.0f);
}
sw.Stop();
Console.WriteLine(sw.ElapsedTicks);

Console.ReadKey();
}
}

I compiled this in release mode with the optimize switch turned on and the first approach (not using the constructor) was consistently 6 times faster than the second approach.

With the optimize switch turned off, the first approach was still faster but only by about 33%.

So, my conclusion is that the constructor call is not inlined and so, for maximum performance, you should use multiple assignments instead.
time and space15y ago
I meant CPU time. Normally I'd agree with you but I don't think copy and pasting a short line of code and changing a single alpha character is going to have a significant impact on coding time, and the code is no less readable in my 2nd example.
Sam Hobbs15y ago
When you say faster, do you mean for the computer or you? Your time is valuable. Developers sometimes make innefficient use of their time by trying to save a few microseconds worth of computer time.
time and space15y ago
Thanks for testing that. Much appreciated.
time and space15y ago
Thanks for the reply. Is there any documented evidence that the compiler does in fact do that?
Vulpes15y ago
Well, Vector2 is a struct and, assuming oldPosition is a local variable, it will therefore be allocated on the stack rather than the heap. So, there's no object creation involved here.

You're correct that the second example may be slightly more efficient because it avoids the overhead of a constructor call; the fields are initialized directly. However, in practice, the JIT compiler will probably inline the constructor call and so there will be no actual difference between the two.