我注意到包装单个 float 的结构比直接使用 float 要慢得多，性能只有大约一半。

using System;
using System.Diagnostics;

struct Vector1 {

    public float X;

    public Vector1(float x) {
        X = x;
    }

    public static Vector1 operator +(Vector1 a, Vector1 b) {
        a.X = a.X + b.X;
        return a;
    }
}

然而，在添加额外的“额外”字段后，似乎发生了一些神奇的事情，性能再次变得更加合理:

struct Vector1Magic {

    public float X;
    private bool magic;

    public Vector1Magic(float x) {
        X = x;
        magic = true;
    }

    public static Vector1Magic operator +(Vector1Magic a, Vector1Magic b) {
        a.X = a.X + b.X;
        return a;
    }
}

我用来对这些进行基准测试的代码如下:

class Program {
    static void Main(string[] args) {
        int iterationCount = 1000000000;
        var sw = new Stopwatch();
        sw.Start();
        var total = 0.0f;
        for (int i = 0; i < iterationCount; i++) {
            var v = (float) i;
            total = total + v;
        }
        sw.Stop();
        Console.WriteLine("Float time was {0} for {1} iterations.", sw.Elapsed, iterationCount);
        Console.WriteLine("total = {0}", total);
        sw.Reset();
        sw.Start();
        var totalV = new Vector1(0.0f);
        for (int i = 0; i < iterationCount; i++) {
            var v = new Vector1(i);
            totalV += v;
        }
        sw.Stop();
        Console.WriteLine("Vector1 time was {0} for {1} iterations.", sw.Elapsed, iterationCount);
        Console.WriteLine("totalV = {0}", totalV);
        sw.Reset();
        sw.Start();
        var totalVm = new Vector1Magic(0.0f);
        for (int i = 0; i < iterationCount; i++) {
            var vm = new Vector1Magic(i);
            totalVm += vm;
        }
        sw.Stop();
        Console.WriteLine("Vector1Magic time was {0} for {1} iterations.", sw.Elapsed, iterationCount);
        Console.WriteLine("totalVm = {0}", totalVm);
        Console.Read();
    }
}

基准测试结果:

Float time was 00:00:02.2444910 for 1000000000 iterations.
Vector1 time was 00:00:04.4490656 for 1000000000 iterations.
Vector1Magic time was 00:00:02.2262701 for 1000000000 iterations.

编译器/环境设置: 操作系统:Windows 10 64 位 工具链:VS2017 框架:.Net 4.6.2 目标:任何喜欢 32 位的 CPU

如果将 64 位设置为目标，我们的结果更可预测，但比我们在 32 位目标上使用 Vector1Magic 时看到的要差得多:

Float time was 00:00:00.6800014 for 1000000000 iterations.
Vector1 time was 00:00:04.4572642 for 1000000000 iterations.
Vector1Magic time was 00:00:05.7806399 for 1000000000 iterations.

对于真正的向导，我在这里包含了 IL 的转储:https://pastebin.com/sz2QLGEx

进一步的调查表明这似乎特定于 Windows 运行时，因为单声道编译器生成相同的 IL。

在单声道运行时，与原始 float 相比，两种结构变体的性能大约慢 2 倍。这与我们在 .Net 上看到的性能有很大不同。

这是怎么回事？

*注意这个问题最初包含一个有缺陷的基准过程(感谢 Max Payne 指出这一点)，并且已经更新以更准确地反射(reflect)时间。

最佳答案

jit 有一个称为“结构提升”的优化，它可以有效地用多个局部变量替换一个结构局部变量或参数，一个用于结构的每个字段。

然而，单个结构包装 float 的结构提升被禁用。原因有点晦涩，但大致是:

• 简单包装原始类型的结构在传递给调用或从调用返回时被视为结构大小的整数值
• 在提升分析期间，jit 无法判断该结构是否曾传递给调用或从调用返回。
• 将 int 重新分类为 float(反之亦然)的调用所需的代码序列被认为在运行时开销很大。
• 因此不会提升结构，因此对浮点字段的访问和操作会有点慢。

所以粗略地说，jit 优先考虑降低调用点的成本，而不是提高使用字段的地方的成本。有时(如上述情况，运营成本占主导地位)这不是正确的选择。

如您所见，如果您使结构变大，则传递和返回结构的规则会发生变化(现在它通过引用返回传递)并且这会取消阻止提升。

在CoreCLR sources您可以在 Compiler::lvaShouldPromoteStructVar 中看到这个逻辑。

关于c# - 为什么向结构体添加一个额外的字段会大大提高其性能？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/44344765/