C#: struct constructor performance

Question

Why creating struct with constructor more slower than direct assignment? In code below I get 10 second with custom constructor and 6 second without! Pure cycle take a 5 second. Custom constructor five (!sic) times slower than direct access.

Is there any hack or something to speed up a custom constructor?

class Program
{
    public struct Point
    {
        public int x, y;

        public Point(int x, int y)
        {
            this.x = x;
            this.y = y;
        }
    }

    static void Main(string[] args)
    {
        Stopwatch sw = new Stopwatch();

        sw.Start();
        for(int i =0; i < int.MaxValue; i++)
        {
            var a = new Point(i, i);
        }
        sw.Stop();
        Console.WriteLine(sw.ElapsedMilliseconds);

        sw.Restart();
        for (int i = 0; i < int.MaxValue; i++)
        {
            var a = new Point();
            a.x = i;
            a.y = i;
        }
        sw.Stop();
        Console.WriteLine(sw.ElapsedMilliseconds);
        Console.ReadLine();
    }
}

Your analysis is wrong. It is not 5x slower. You have to divide by int.MaxValue to make the comparison above relative speed. The constructor is make a call to your custom constructor Point() method which is taking the extra time. The call should be very small but when int.MaxValue is very large it can take seconds. — jdweng, Mar 05 '17 at 14:55
These results are probably being completely skewed by GC time. Try swapping around the two loops and see what results you get. — Matthew Watson, Mar 05 '17 at 15:05
Also ensure that you're testing a release build, and you aren't running it inside the debugger. — Matthew Watson, Mar 05 '17 at 15:21
Simple loop take 5 second. Loop with custom constructor 10 second. Loop without custom constructor 6 second. Performance = (10 - 5)/(6-5) ? — Grey, Mar 06 '17 at 11:04

score 7 · Accepted Answer · edited May 23 '17 at 12:09

In code below i get 10 second with custom constructor

That is not code that takes 10 seconds, unless you have a very old machine. Tells us what you did wrong, you are running the unoptimized Debug build or run with the debugger attached. The kind of scenario where the optimizer that is built into the jitter is not allowed to do its job.

Put a loop around the code to run it 10 times, helps to get rid of startup overhead and measuring the standard deviation, always very high on very fast code like this. Switch to the Release build and run it with Ctrl+F5. Now you get the real perf of this code, ought to be south of ~1.5 seconds. That is just how long the loops take, none of the Point code remains, removed by the optimizer. Which it could do because the a variable is not used anywhere and the constructor has no observable side-effects.

Having the code you want to profile completely removed is a classic benchmark hazard. You can prevent that from happening by hoisting the a variable out of the loop and using:

  Console.WriteLine("{0}", sw.ElapsedMilliseconds, a);

Now the optimizer cannot eliminate the Point code anymore since the variable is used beyond the loop. You'll know you are benchmarking it right if it is still just as fast. It just doesn't matter how you initialize the struct. More about what the jitter optimizer does in this post.

Yep, it all about enabled debug – Grey Mar 06 '17 at 11:32 — Grey, Mar 06 '17 at 11:32

score 5 · Answer 2 · answered Mar 05 '17 at 17:25

Your profiling code simplifies a lot of things, but it also makes the measurement quite inaccurate. I'd suggest using tools like BenchmarkDotNet to get more accurate results.

A quick test shows that direct assignments are a bit faster, but nothing like 5x you're claiming:

[BenchmarkDotNet.Attributes.Benchmark(Baseline = true)]
public static Point GetPoint()
{
    return new Point(x, y);
}

[BenchmarkDotNet.Attributes.Benchmark]
public static Point GetPoint2()
{
    Point point = new Point();
    point.x = x;
    point.y = y;
    return point;
}

    Method |       Mean |    StdDev | Scaled | Scaled-StdDev |
---------- |----------- |---------- |------- |-------------- |
  GetPoint | 10.2038 ns | 0.2593 ns |   1.00 |          0.00 |
 GetPoint2 |  9.3272 ns | 0.0767 ns |   0.91 |          0.02 |

That's 10% difference, not 5x.

C#: struct constructor performance

2 Answers2