Странное увеличение производительности в простом бенчмарке

вчера я нашел статья Кристофа Нахра под названием ".NET Struct Performance" который сравнивал несколько языков (C++, C#, Java, JavaScript) для метода, который добавляет две точечные структуры (double ОК).

как оказалось, версия C++ занимает около 1000 мс для выполнения (1e9 итераций), в то время как C# не может получить под ~3000ms на той же машине (и выполняет еще хуже в x64).

чтобы проверить это сам, я взял код C# (и упростил слегка вызвать только метод, где параметры передаются по значению), и запустил его на машине i7-3610QM (3.1 Ghz boost для одного ядра), 8GB RAM, Win8.1, используя .NET 4.5.2, RELEASE build 32-bit (x86 WoW64, так как моя ОС 64-разрядная). Это упрощенная версия:

public static class CSharpTest
{
    private const int ITERATIONS = 1000000000;

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    private static Point AddByVal(Point a, Point b)
    {
        return new Point(a.X + b.Y, a.Y + b.X);
    }

    public static void Main()
    {
        Point a = new Point(1, 1), b = new Point(1, 1);

        Stopwatch sw = Stopwatch.StartNew();
        for (int i = 0; i < ITERATIONS; i++)
            a = AddByVal(a, b);
        sw.Stop();

        Console.WriteLine("Result: x={0} y={1}, Time elapsed: {2} ms", 
            a.X, a.Y, sw.ElapsedMilliseconds);
    }
}

С Point определен как просто:

public struct Point 
{
    private readonly double _x, _y;

    public Point(double x, double y) { _x = x; _y = y; }

    public double X { get { return _x; } }

    public double Y { get { return _y; } }
}

запуск его дает результаты, аналогичные тем, что в статье:

Result: x=1000000001 y=1000000001, Time elapsed: 3159 ms

первая странная наблюдение

поскольку метод должен быть встроен, я задавался вопросом, как будет работать код, если я полностью удалю структуры и просто встрою все это вместе:

public static class CSharpTest
{
    private const int ITERATIONS = 1000000000;

    public static void Main()
    {
        // not using structs at all here
        double ax = 1, ay = 1, bx = 1, by = 1;

        Stopwatch sw = Stopwatch.StartNew();
        for (int i = 0; i < ITERATIONS; i++)
        {
            ax = ax + by;
            ay = ay + bx;
        }
        sw.Stop();

        Console.WriteLine("Result: x={0} y={1}, Time elapsed: {2} ms", 
            ax, ay, sw.ElapsedMilliseconds);
    }
}

и получил практически тот же результат (на самом деле на 1% медленнее после нескольких попыток), что означает, что JIT-ter, похоже, хорошо оптимизирует все вызовы функций:

Result: x=1000000001 y=1000000001, Time elapsed: 3200 ms

это также означает, что бенчмарк, похоже, не измеряет никаких struct производительность и на самом деле только кажется, чтобы измерить basic double арифметика (после того, как все остальное оптимизируется).

странные вещи

теперь идет странная часть. Если я просто добавлю еще один секундомер вне цикла (да, я сузил его до этого сумасшедшего шага после нескольких попыток), код работает в три раза быстрее:

public static void Main()
{
    var outerSw = Stopwatch.StartNew();     // <-- added

    {
        Point a = new Point(1, 1), b = new Point(1, 1);

        var sw = Stopwatch.StartNew();
        for (int i = 0; i < ITERATIONS; i++)
            a = AddByVal(a, b);
        sw.Stop();

        Console.WriteLine("Result: x={0} y={1}, Time elapsed: {2} ms",
            a.X, a.Y, sw.ElapsedMilliseconds);
    }

    outerSw.Stop();                         // <-- added
}

Result: x=1000000001 y=1000000001, Time elapsed: 961 ms

это смешно! И это не похоже на Stopwatch дает мне неправильные результаты, потому что Я ясно вижу, что это заканчивается через одну секунду.

может кто-нибудь сказать мне, что происходит?

(обновить)

вот два метода в одной программе, которая показывает, что причина не JITting:

public static class CSharpTest
{
    private const int ITERATIONS = 1000000000;

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    private static Point AddByVal(Point a, Point b)
    {
        return new Point(a.X + b.Y, a.Y + b.X);
    }

    public static void Main()
    {
        Test1();
        Test2();

        Console.WriteLine();

        Test1();
        Test2();
    }

    private static void Test1()
    {
        Point a = new Point(1, 1), b = new Point(1, 1);

        var sw = Stopwatch.StartNew();
        for (int i = 0; i < ITERATIONS; i++)
            a = AddByVal(a, b);
        sw.Stop();

        Console.WriteLine("Test1: x={0} y={1}, Time elapsed: {2} ms", 
            a.X, a.Y, sw.ElapsedMilliseconds);
    }

    private static void Test2()
    {
        var swOuter = Stopwatch.StartNew();

        Point a = new Point(1, 1), b = new Point(1, 1);

        var sw = Stopwatch.StartNew();
        for (int i = 0; i < ITERATIONS; i++)
            a = AddByVal(a, b);
        sw.Stop();

        Console.WriteLine("Test2: x={0} y={1}, Time elapsed: {2} ms", 
            a.X, a.Y, sw.ElapsedMilliseconds);

        swOuter.Stop();
    }
}

выход:

Test1: x=1000000001 y=1000000001, Time elapsed: 3242 ms
Test2: x=1000000001 y=1000000001, Time elapsed: 974 ms

Test1: x=1000000001 y=1000000001, Time elapsed: 3251 ms
Test2: x=1000000001 y=1000000001, Time elapsed: 972 ms

вот пастебин. вы должны запустить его как 32-разрядный релиз на .NET 4.x (есть несколько проверок код для обеспечения этого).

(обновление 4)

после комментариев @usr на ответ @Hans я проверил оптимизированную разборку для обоих методов, и они довольно разные:

это, кажется, показывает, что разница может быть связана с компилятором, действующим смешно в первом случае, а не с двойным выравниванием полей?

также, если я добавить два переменные (общее смещение 8 bytes), я все еще получаю тот же прирост скорости - и больше не кажется, что это связано с упоминанием выравнивания полей Хансом Пассантом:

// this is still fast?
private static void Test3()
{
    var magical_speed_booster_1 = "whatever";
    var magical_speed_booster_2 = "whatever";

    {
        Point a = new Point(1, 1), b = new Point(1, 1);

        var sw = Stopwatch.StartNew();
        for (int i = 0; i < ITERATIONS; i++)
            a = AddByVal(a, b);
        sw.Stop();

        Console.WriteLine("Test2: x={0} y={1}, Time elapsed: {2} ms",
            a.X, a.Y, sw.ElapsedMilliseconds);
    }

    GC.KeepAlive(magical_speed_booster_1);
    GC.KeepAlive(magical_speed_booster_2);
}