为什么 64 位比 32 位更快？

我一直在进行一些性能测试，主要是为了了解迭代器和简单 for 循环之间的区别。作为其中的一部分，我创建了一组简单的测试，然后对结果感到非常惊讶。对于某些方法，64 位比 32 位快近 10 倍。

我正在寻找的是对为什么会发生这种情况的一些解释。

[下面的答案指出这是由于 32 位应用程序中的 64 位算术造成的。将长整型更改为整数会在 32 和 64 位系统上带来良好的性能。]

这是有问题的 3 种方法。

private static long ForSumArray(long[] array)
{
    var result = 0L;
    for (var i = 0L; i < array.LongLength; i++)
    {
        result += array[i];
    }
    return result;
}

private static long ForSumArray2(long[] array)
{
    var length = array.LongLength;
    var result = 0L;
    for (var i = 0L; i < length; i++)
    {
        result += array[i];
    }
    return result;
}

private static long IterSumArray(long[] array)
{
    var result = 0L;
    foreach (var entry in array)
    {
        result += entry;
    }
    return result;
}

我有一个简单的测试工具来测试这个

var repeat = 10000;

var arrayLength = 100000;
var array = new long[arrayLength];
for (var i = 0; i < arrayLength; i++)
{
    array[i] = i;
}

Console.WriteLine("For: {0}", AverageRunTime(repeat, () => ForSumArray(array)));

repeat = 100000;
Console.WriteLine("For2: {0}", AverageRunTime(repeat, () => ForSumArray2(array)));
Console.WriteLine("Iter: {0}", AverageRunTime(repeat, () => IterSumArray(array)));

private static TimeSpan AverageRunTime(int count, Action method)
{
    var stopwatch = new Stopwatch();
    stopwatch.Start();
    for (var i = 0; i < count; i++)
    {
        method();
    }
    stopwatch.Stop();
    var average = stopwatch.Elapsed.Ticks / count;
    return new TimeSpan(average);
}

当我运行这些时，我得到以下结果：
32 bit:

For: 00:00:00.0006080
For2: 00:00:00.0005694
Iter: 00:00:00.0001717  

64 bit

For: 00:00:00.0007421
For2: 00:00:00.0000814
Iter: 00:00:00.0000818  

我从中读到的内容是使用 LongLength 很慢。如果我使用 array.Length，第一个 for 循环的性能在 64 位中相当不错，但在 32 位中则不然。

我从中读到的另一件事是，迭代数组与 for 循环一样高效，并且代码更干净、更易于阅读！

x64 处理器包含 64 位通用寄存器，可以使用这些寄存器在单个指令中计算 64 位整数的运算。 32位处理器没有这个。这与您的程序特别相关，因为它大量使用long（64 位整数）变量。

例如，在 x64 汇编中，要添加存储在寄存器中的几个 64 位整数，您可以简单地执行以下操作：

; adds rbx to rax
add rax, rbx

要在 32 位 x86 处理器上执行相同的操作，您必须使用两个寄存器，并在第二个操作中手动使用第一个操作的进位：

; adds ecx:ebx to edx:eax
add eax, ebx
adc edx, ecx

更多的指令和更少的寄存器意味着更多的时钟周期、内存读取……这最终会导致性能下降。在数字处理应用程序中，差异非常显着。

对于 .NET 应用程序，64 位 JIT 编译器似乎会执行更积极的优化，从而提高整体性能。

关于您关于数组迭代的观点，C# 编译器足够聪明，可以识别foreach对数组进行特殊处理。生成的代码与使用for循环，建议您使用foreach如果不需要更改循环中的数组元素。除此之外，运行时还可以识别该模式for (int i = 0; i < a.Length; ++i)并省略循环内数组访问的边界检查。这不会发生在LongLength情况下会导致性能下降（32 位和 64 位情况）；因为你将使用long变量与LongLength，32 位性能会进一步下降。