Performance difference between AnyCPU vs x64 platform on a 64 bit machine

Question

According to this QA there should be no performance difference between application built using Any CPU and x64 when run on a 64 bit machine, however I'm seeing around a double increase in performance in my use case when I specifically built for the x64 platform.

My use case is for manipulating 64 bit bitboards, the majority of processing is on bit operations and arithmetic on ulong variables.

As an example:

public static ulong ReverseBits(ulong x)
{
    ulong t;
    x = (x << 32) | (x >> 32); // Swap register halves.
    x = (x & 0x0001FFFF0001FFFFUL) << 15 | // Rotate left
        (x & 0xFFFE0000FFFE0000UL) >> 17; // 15.
    t = (x ^ (x >> 10)) & 0x003F801F003F801FUL;
    x = (t | (t << 10)) ^ x;
    t = (x ^ (x >> 4)) & 0x0E0384210E038421UL;
    x = (t | (t << 4)) ^ x;
    t = (x ^ (x >> 2)) & 0x2248884222488842UL;
    x = (t | (t << 2)) ^ x;
    return x;
}

static void Main(string[] args)
{
    ulong sum = 0;
    var s = Stopwatch.StartNew();
    for (ulong i = 0; i < 1000000000; i++)
    {
        sum += ReverseBits(i);
    }
    s.Stop();

    Console.WriteLine("Sum = {0}, took {1}ms", sum, s.ElapsedMilliseconds);
    Console.ReadLine();
}

In Release build with Any CPU platform the results are: Sum = 9745675244420464640, took 13148ms

In Release build with x64 platform the results are: Sum = 9745675244420464640, took 5693ms

That's more than double performance increase. Why is there such a big difference if the common assumption is that Any CPU vs x64 builds should perform the same on a 64 bit machine?

Answer 1

No, you compared perf between 32-bit and 64-bit code. The x64 flavor is much faster because it can do the math with a single 64-bit processor register. It is much more of a slog in 32-bit machine code, it has to juggle two 32-bit registers. Easy to see the difference between the two with Debug > Windows > Disassembly.

This went wrong because you paid too much attention to the solution platform name. Too prominently displayed, but a selection that only matters to C++ projects. And, unfortunately, on UWP projects due to .NET Native. It selects the build tool flavors, C# has only one compiler that can target any platform.

The real settings that matters are the jitter forcing options. Project > Properties > Build tab. Select the Release build if necessary and choose the Platform target and "Prefer 32-bit" settings. Untick the latter. You'll now see that AnyCPU == x64 on a 64-bit operating system.