我有三个案例来测试类、继承类和结构体的相对性能。这些将用于紧密循环，因此性能很重要。点积是2D和3D几何中许多算法的一部分，我已经在真实代码上运行了分析器。下面的测试反映了我见过的真实世界性能问题。
100000000次循环和点积应用的结果如下：
测试时未开启调试和优化。我的问题是，在这种情况下，是什么导致类变得如此缓慢？我认为JIT仍然能够内联所有的调用，无论是类还是结构体，因此结果应该是相同的。请注意，如果我禁用优化，则结果相同。
结构体和类在点乘方面的区别消失了。为什么有些设置不需要该属性，但对我来说却不清楚。然而，我没有放弃。供应商代码仍存在性能问题，我认为DotProduct不是最好的例子。 我修改了@pkuderov的代码以实现“向量加法”，这将创建结构体和类的新实例。结果在此处。
Add class/class 2777ms Add struct/struct 2457ms
DotProd class/class 1909ms DotProd struct/struct 2108ms
如果有人想尝试，请查看完整的代码和结果here。
再次编辑：
对于向量相加的示例，其中一个向量数组被总结在一起，结构体版本将累加器保留在3个寄存器中。
但是对于基于类的向量版本，它每次都需要读取和写入累加器到主内存中，这是低效的。
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的代码以实现“向量加法”，这将创建结构体和类的新实例。结果在此处。
https://gist.github.com/bradphelan/9b383c8e99edc38068fcc0dccc8a7b48
In the example, 我还修改了代码，从数组中选择一个伪随机向量，以避免实例粘在寄存器上的问题（希望如此）。结果表明：对于类Vector Add和我假设的任何创建新对象的操作，DotProduct性能相同或更快。Add class/class 2777ms Add struct/struct 2457ms
DotProd class/class 1909ms DotProd struct/struct 2108ms
如果有人想尝试，请查看完整的代码和结果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