我有三个案例来测试类、具有继承的类和结构的相对性能。这些将用于紧密循环，因此性能很重要。点积被用作 2D 和 3D 几何中许多算法的一部分，我已经在真实代码上运行了分析器。以下测试表明了我所见过的现实世界中的性能问题。

循环100000000次点积的结果

ControlA 208 ms   ( class with inheritence )
ControlB 201 ms   ( class with no inheritence )
ControlC 85  ms   ( struct )

测试在没有调试和优化的情况下运行。 我的问题是，在这种情况下，类是什么导致它们如此缓慢？

我假设 JIT 仍然能够内联所有调用、类或结构，因此实际上结果应该是相同的。请注意，如果我禁用优化，那么我的结果是相同的。

ControlA 3239
ControlB 3228
ControlC 3213

如果重新运行测试，它们之间的差距始终在 20 毫秒以内。

正在研究的类

using System;
using System.Diagnostics;

public class PointControlA
{
    public double X
    {
        get;
        set;
    }

    public double Y
    {
        get;
        set;
    }

    public PointControlA(double x, double y)
    {
        X = x;
        Y = y;
    }
}

public class Point3ControlA : PointControlA
{
    public double Z
    {
        get;
        set;
    }

    public Point3ControlA(double x, double y, double z): base (x, y)
    {
        Z = z;
    }

    public static double Dot(Point3ControlA a, Point3ControlA b)
    {
        return a.X * b.X + a.Y * b.Y + a.Z * b.Z;
    }
}

public class Point3ControlB
{
    public double X
    {
        get;
        set;
    }

    public double Y
    {
        get;
        set;
    }

    public double Z
    {
        get;
        set;
    }

    public Point3ControlB(double x, double y, double z)
    {
        X = x;
        Y = y;
        Z = z;
    }

    public static double Dot(Point3ControlB a, Point3ControlB b)
    {
        return a.X * b.X + a.Y * b.Y + a.Z * b.Z;
    }
}

public struct Point3ControlC
{
    public double X
    {
        get;
        set;
    }

    public double Y
    {
        get;
        set;
    }

    public double Z
    {
        get;
        set;
    }

    public Point3ControlC(double x, double y, double z):this()
    {
        X = x;
        Y = y;
        Z = z;
    }

    public static double Dot(Point3ControlC a, Point3ControlC b)
    {
        return a.X * b.X + a.Y * b.Y + a.Z * b.Z;
    }
}

测试脚本

public class Program
{
    public static void TestStructClass()
    {
        var vControlA = new Point3ControlA(11, 12, 13);
        var vControlB = new Point3ControlB(11, 12, 13);
        var vControlC = new Point3ControlC(11, 12, 13);
        var sw = Stopwatch.StartNew();
        var n = 10000000;
        double acc = 0;
        sw = Stopwatch.StartNew();
        for (int i = 0; i < n; i++)
        {
            acc += Point3ControlA.Dot(vControlA, vControlA);
        }

        Console.WriteLine("ControlA " + sw.ElapsedMilliseconds);
        acc = 0;
        sw = Stopwatch.StartNew();
        for (int i = 0; i < n; i++)
        {
            acc += Point3ControlB.Dot(vControlB, vControlB);
        }

        Console.WriteLine("ControlB " + sw.ElapsedMilliseconds);
        acc = 0;
        sw = Stopwatch.StartNew();
        for (int i = 0; i < n; i++)
        {
            acc += Point3ControlC.Dot(vControlC, vControlC);
        }

        Console.WriteLine("ControlC " + sw.ElapsedMilliseconds);
    }

    public static void Main()
    {
        TestStructClass();
    }
}

这dotnet fiddle只是编译证明。它没有显示性能差异。

我正在尝试向供应商解释为什么他们选择对小数字类型使用类而不是结构是一个坏的想法。我现在有测试用例来证明这一点，但我不明白为什么。

注意:我尝试在启用 JIT 优化的调试器中设置断点，但调试器不会中断。在关闭 JIT 优化的情况下查看 IL 并没有告诉我任何信息。

编辑

在@pkuderov 回答后，我拿走了他的代码并开始使用它。我更改了代码，发现如果我通过

   [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static double Dot(Point3Class a)
    {
        return a.X * a.X + a.Y * a.Y + a.Z * a.Z;
    }

点积的结构和类之间的差异消失了。为什么有些设置不需要该属性，但对我来说还不清楚。然而我并没有放弃。供应商代码仍然存在性能问题，我认为 DotProduct 不是最好的例子。

我修改了@pkuderov 的代码以实现Vector Add，这将创建结构和类的新实例。结果在这里

https://gist.github.com/bradphelan/9b383c8e99edc38068fcc0dccc8a7b48

在示例中，我还修改了代码以从数组中选择一个伪随机向量，以避免实例粘在寄存器中的问题(我希望如此)。

结果表明:

类的 DotProduct 性能相同或更快
Vector Add，我假设创建新对象的任何东西都比较慢。

添加类/类 2777ms 添加结构/结构 2457ms

DotProd 类/类 1909ms DotProd 结构/结构 2108 毫秒

完整的代码和结果是here如果有人想尝试一下。

重新编辑

对于将向量数组相加在一起的向量加法示例，结构版本将累加器保存在 3 个寄存器中

 var accStruct = new Point3Struct(0, 0, 0);
 for (int i = 0; i < n; i++)
     accStruct = Point3Struct.Add(accStruct, pointStruct[(i + 1) % m]);

汇编体是

// load the next vector into a register
00007FFA3CA2240E  vmovsd      xmm3,qword ptr [rax]  
00007FFA3CA22413  vmovsd      xmm4,qword ptr [rax+8]  
00007FFA3CA22419  vmovsd      xmm5,qword ptr [rax+10h]  
// Sum the accumulator (the accumulator stays in the registers )
00007FFA3CA2241F  vaddsd      xmm0,xmm0,xmm3  
00007FFA3CA22424  vaddsd      xmm1,xmm1,xmm4  
00007FFA3CA22429  vaddsd      xmm2,xmm2,xmm5  

但是对于基于类的向量版本，它每次都读取累加器并将其写入主内存，这是低效的

var accPC = new Point3Class(0, 0, 0);
for (int i = 0; i < n; i++)
    accPC = Point3Class.Add(accPC, pointClass[(i + 1) % m]);

汇编体是

// Read and add both accumulator X and Xnext from main memory
00007FFA3CA2224A  vmovsd      xmm0,qword ptr [r14+8]     
00007FFA3CA22250  vmovaps     xmm7,xmm0                   
00007FFA3CA22255  vaddsd      xmm7,xmm7,mmword ptr [r12+8]  


// Read and add both accumulator Y and Ynext from main memory
00007FFA3CA2225C  vmovsd      xmm0,qword ptr [r14+10h]  
00007FFA3CA22262  vmovaps     xmm8,xmm0  
00007FFA3CA22267  vaddsd      xmm8,xmm8,mmword ptr [r12+10h] 

// Read and add both accumulator Z and Znext from main memory
00007FFA3CA2226E  vmovsd      xmm9,qword ptr [r14+18h]  
00007FFA3CA22283  vmovaps     xmm0,xmm9  
00007FFA3CA22288  vaddsd      xmm0,xmm0,mmword ptr [r12+18h]

// Move accumulator accumulator X,Y,Z back to main memory.
00007FFA3CA2228F  vmovsd      qword ptr [rax+8],xmm7  
00007FFA3CA22295  vmovsd      qword ptr [rax+10h],xmm8  
00007FFA3CA2229B  vmovsd      qword ptr [rax+18h],xmm0  

最佳答案

更新

在花了一些时间思考问题后，我认为我同意@DavidHaim 的观点，即内存跳跃开销不是这里的情况，因为缓存。

我还为您的测试添加了更多选项(并删除了第一个具有继承性的选项)。所以我有:

• cl = 具有 3 个点的类变量:
  • Dot(cl, cl) - 初始化方法
  • Dot(cl) - 这是“方形产品”
  • Dot(cl.X, cl.Y, cl.Z, cl.X, cl.Y, cl.Z) 又名 Dot(cl.xyz)- 传递字段
• st = 具有 3 个点的结构变量:
  • 点(st, st) - 首字母
  • Dot(st) - 方积
  • Dot(st.X, st.Y, st.Z, st.X, st.Y, st.Z) 又名 Dot(st.xyz) - 传递字段
• st6 = variable of struct with 6 points:
  • Dot(st6) - 想要检查结构的大小是否重要
• Dot(x, y, z, x, y, z) 又名 Dot(xyz) - 只是局部常量 double 变量。

结果时间为:

• Dot(cl.xyz) 最差 ~570ms，
• Dot(st6)、Dot(st.xyz) 是第二差的 ~440ms 和 ~480ms
• 其他是~325ms

...我不太确定为什么会看到这些结果。

也许对于普通原始类型，编译器通过寄存器优化进行更积极的传递，也许它更确定生命周期边界或常数，然后再次进行更积极的优化。也许是某种循环展开。

我认为我的专业知识还不够 :) 但是，我的结果仍然与您的结果相反。

我机器上的完整测试代码和结果以及生成的 IL 代码，您可以找到 here .

在 C# 中，类是引用类型，而结构是值类型。一个主要影响是值类型可以(大多数情况下是!)分配在堆栈上，而引用类型总是分配在堆上。

因此，每次访问引用类型变量的内部状态时，都需要取消引用指向堆中内存的指针(这是一种跳转)，而对于值类型，它已经在堆栈中甚至被优化掉了到寄存器。

我认为您因此而看到了差异。

附言顺便说一句，“大部分时间”是指拳击；它是一种用于将值类型对象放置在堆上的技术(例如，将值类型转换为接口(interface)或用于动态方法调用绑定(bind))。

关于c# - 为什么对于这种特定情况，结构比类快得多？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/44949454/