为什么 Mono 运行 一个简单的方法速度较慢，而 RyuJIT 运行 却明显更快？
Why does Mono run a simple method slower whereas RyuJIT runs it significantly faster?
我出于好奇创建了一个简单的基准测试，但无法解释结果。
作为基准数据，我准备了一个具有一些随机值的结构数组。准备阶段未进行基准测试：
struct Val
{
public float val;
public float min;
public float max;
public float padding;
}
const int iterations = 1000;
Val[] values = new Val[iterations];
// fill the array with randoms
基本上，我想比较这两个 clamp 实现：
static class Clamps
{
public static float ClampSimple(float val, float min, float max)
{
if (val < min) return min;
if (val > max) return max;
return val;
}
public static T ClampExt<T>(this T val, T min, T max) where T : IComparable<T>
{
if (val.CompareTo(min) < 0) return min;
if (val.CompareTo(max) > 0) return max;
return val;
}
}
这是我的基准测试方法：
[Benchmark]
public float Extension()
{
float result = 0;
for (int i = 0; i < iterations; ++i)
{
ref Val v = ref values[i];
result += v.val.ClampExt(v.min, v.max);
}
return result;
}
[Benchmark]
public float Direct()
{
float result = 0;
for (int i = 0; i < iterations; ++i)
{
ref Val v = ref values[i];
result += Clamps.ClampSimple(v.val, v.min, v.max);
}
return result;
}
我正在使用 BenchmarkDotNet 版本 0.10.12 和两个作业：
[MonoJob]
[RyuJitX64Job]
这些是我得到的结果：
BenchmarkDotNet=v0.10.12, OS=Windows 7 SP1 (6.1.7601.0)
Intel Core i7-6920HQ CPU 2.90GHz (Skylake), 1 CPU, 8 logical cores and 4 physical cores
Frequency=2836123 Hz, Resolution=352.5940 ns, Timer=TSC
[Host] : .NET Framework 4.7 (CLR 4.0.30319.42000), 64bit RyuJIT-v4.7.3062.0
Mono : Mono 5.12.0 (Visual Studio), 64bit
RyuJitX64 : .NET Framework 4.7 (CLR 4.0.30319.42000), 64bit RyuJIT-v4.7.3062.0
Method | Job | Runtime | Mean | Error | StdDev |
---------- |---------- |-------- |----------:|----------:|----------:|
Extension | Mono | Mono | 10.860 us | 0.0063 us | 0.0053 us |
Direct | Mono | Mono | 11.211 us | 0.0074 us | 0.0062 us |
Extension | RyuJitX64 | Clr | 5.711 us | 0.0014 us | 0.0012 us |
Direct | RyuJitX64 | Clr | 1.395 us | 0.0056 us | 0.0052 us |
我可以接受 Mono 在这里总体上有点慢。但是我不明白的是：
为什么 Mono 运行 Direct 方法 比 Extension 慢 请记住 Direct 使用一个非常简单的比较方法，而 Extension 使用带有附加方法调用的方法？
RyuJIT 在这里展示了简单方法的 4 倍优势。
谁能解释一下？
既然没有人想做一些反汇编的事情，我回答我自己的问题。
看来原因是 JIT 生成的本机代码，而不是评论中提到的数组边界检查或缓存问题。
RyuJIT 为 ClampSimple 方法生成了一个非常高效的代码：
vucomiss xmm1,xmm0
jbe M01_L00
vmovaps xmm0,xmm1
ret
M01_L00:
vucomiss xmm0,xmm2
jbe M01_L01
vmovaps xmm0,xmm2
ret
M01_L01:
ret
它使用 CPU 的原生 ucomiss 操作来比较 floats 并且还使用快速 movaps 操作在 floats 之间移动 floats =56=]的寄存器。
扩展方法较慢，因为它有几个函数调用 System.Single.CompareTo(System.Single)，这是第一个分支：
lea rcx,[rsp+30h]
vmovss dword ptr [rsp+38h],xmm1
call mscorlib_ni+0xda98f0
test eax,eax
jge M01_L00
vmovss xmm0,dword ptr [rsp+38h]
add rsp,28h
ret
让我们看一下 Mono 为 ClampSimple 方法生成的本机代码：
cvtss2sd xmm0,xmm0
movss xmm1,dword ptr [rsp+8]
cvtss2sd xmm1,xmm1
comisd xmm1,xmm0
jbe M01_L00
movss xmm0,dword ptr [rsp+8]
cvtss2sd xmm0,xmm0
cvtsd2ss xmm0,xmm0
jmp M01_L01
M01_L00:
movss xmm0,dword ptr [rsp]
cvtss2sd xmm0,xmm0
movss xmm1,dword ptr [rsp+10h]
cvtss2sd xmm1,xmm1
comisd xmm1,xmm0
jp M01_L02
jae M01_L02
movss xmm0,dword ptr [rsp+10h]
cvtss2sd xmm0,xmm0
cvtsd2ss xmm0,xmm0
jmp M01_L01
M01_L02:
movss xmm0,dword ptr [rsp]
cvtss2sd xmm0,xmm0
cvtsd2ss xmm0,xmm0
M01_L01:
add rsp,18h
ret
Mono 的代码将 floats 转换为 double 并使用 comisd 进行比较。此外，在准备return值时，还有奇怪的"convert flips"float➞double➞float。而且在内存和寄存器之间还有更多的移动。这解释了为什么 Mono 的简单方法代码比 RyuJIT 的代码慢。
Extension 方法代码与 RyuJIT 的代码非常相似，但同样有奇怪的转换翻转 float ➞ double ➞ float:
movss xmm0,dword ptr [rbp-10h]
cvtss2sd xmm0,xmm0
movsd xmm1,xmm0
cvtsd2ss xmm1,xmm1
lea rbp,[rbp]
mov r11,2061520h
call r11
test eax,eax
jge M0_L0
movss xmm0,dword ptr [rbp-10h]
cvtss2sd xmm0,xmm0
cvtsd2ss xmm0,xmm0
ret
RyuJIT 似乎可以生成更高效的代码来处理 floats。 Mono 将 floats 视为 doubles 并每次转换值，这也会导致 CPU 寄存器和内存之间的额外值传输。
请注意，所有这些仅对 Windows x64 有效。我不知道这个基准测试在 Linux 或 Mac.
上的表现如何
我出于好奇创建了一个简单的基准测试，但无法解释结果。
作为基准数据，我准备了一个具有一些随机值的结构数组。准备阶段未进行基准测试：
struct Val
{
public float val;
public float min;
public float max;
public float padding;
}
const int iterations = 1000;
Val[] values = new Val[iterations];
// fill the array with randoms
基本上，我想比较这两个 clamp 实现：
static class Clamps
{
public static float ClampSimple(float val, float min, float max)
{
if (val < min) return min;
if (val > max) return max;
return val;
}
public static T ClampExt<T>(this T val, T min, T max) where T : IComparable<T>
{
if (val.CompareTo(min) < 0) return min;
if (val.CompareTo(max) > 0) return max;
return val;
}
}
这是我的基准测试方法：
[Benchmark]
public float Extension()
{
float result = 0;
for (int i = 0; i < iterations; ++i)
{
ref Val v = ref values[i];
result += v.val.ClampExt(v.min, v.max);
}
return result;
}
[Benchmark]
public float Direct()
{
float result = 0;
for (int i = 0; i < iterations; ++i)
{
ref Val v = ref values[i];
result += Clamps.ClampSimple(v.val, v.min, v.max);
}
return result;
}
我正在使用 BenchmarkDotNet 版本 0.10.12 和两个作业：
[MonoJob]
[RyuJitX64Job]
这些是我得到的结果：
BenchmarkDotNet=v0.10.12, OS=Windows 7 SP1 (6.1.7601.0)
Intel Core i7-6920HQ CPU 2.90GHz (Skylake), 1 CPU, 8 logical cores and 4 physical cores
Frequency=2836123 Hz, Resolution=352.5940 ns, Timer=TSC
[Host] : .NET Framework 4.7 (CLR 4.0.30319.42000), 64bit RyuJIT-v4.7.3062.0
Mono : Mono 5.12.0 (Visual Studio), 64bit
RyuJitX64 : .NET Framework 4.7 (CLR 4.0.30319.42000), 64bit RyuJIT-v4.7.3062.0
Method | Job | Runtime | Mean | Error | StdDev |
---------- |---------- |-------- |----------:|----------:|----------:|
Extension | Mono | Mono | 10.860 us | 0.0063 us | 0.0053 us |
Direct | Mono | Mono | 11.211 us | 0.0074 us | 0.0062 us |
Extension | RyuJitX64 | Clr | 5.711 us | 0.0014 us | 0.0012 us |
Direct | RyuJitX64 | Clr | 1.395 us | 0.0056 us | 0.0052 us |
我可以接受 Mono 在这里总体上有点慢。但是我不明白的是：
为什么 Mono 运行 Direct 方法 比 Extension 慢 请记住 Direct 使用一个非常简单的比较方法，而 Extension 使用带有附加方法调用的方法？
RyuJIT 在这里展示了简单方法的 4 倍优势。
谁能解释一下？
既然没有人想做一些反汇编的事情，我回答我自己的问题。
看来原因是 JIT 生成的本机代码，而不是评论中提到的数组边界检查或缓存问题。
RyuJIT 为 ClampSimple 方法生成了一个非常高效的代码：
vucomiss xmm1,xmm0
jbe M01_L00
vmovaps xmm0,xmm1
ret
M01_L00:
vucomiss xmm0,xmm2
jbe M01_L01
vmovaps xmm0,xmm2
ret
M01_L01:
ret
它使用 CPU 的原生 ucomiss 操作来比较 floats 并且还使用快速 movaps 操作在 floats 之间移动 floats =56=]的寄存器。
扩展方法较慢，因为它有几个函数调用 System.Single.CompareTo(System.Single)，这是第一个分支：
lea rcx,[rsp+30h]
vmovss dword ptr [rsp+38h],xmm1
call mscorlib_ni+0xda98f0
test eax,eax
jge M01_L00
vmovss xmm0,dword ptr [rsp+38h]
add rsp,28h
ret
让我们看一下 Mono 为 ClampSimple 方法生成的本机代码：
cvtss2sd xmm0,xmm0
movss xmm1,dword ptr [rsp+8]
cvtss2sd xmm1,xmm1
comisd xmm1,xmm0
jbe M01_L00
movss xmm0,dword ptr [rsp+8]
cvtss2sd xmm0,xmm0
cvtsd2ss xmm0,xmm0
jmp M01_L01
M01_L00:
movss xmm0,dword ptr [rsp]
cvtss2sd xmm0,xmm0
movss xmm1,dword ptr [rsp+10h]
cvtss2sd xmm1,xmm1
comisd xmm1,xmm0
jp M01_L02
jae M01_L02
movss xmm0,dword ptr [rsp+10h]
cvtss2sd xmm0,xmm0
cvtsd2ss xmm0,xmm0
jmp M01_L01
M01_L02:
movss xmm0,dword ptr [rsp]
cvtss2sd xmm0,xmm0
cvtsd2ss xmm0,xmm0
M01_L01:
add rsp,18h
ret
Mono 的代码将 floats 转换为 double 并使用 comisd 进行比较。此外，在准备return值时，还有奇怪的"convert flips"float➞double➞float。而且在内存和寄存器之间还有更多的移动。这解释了为什么 Mono 的简单方法代码比 RyuJIT 的代码慢。
Extension 方法代码与 RyuJIT 的代码非常相似，但同样有奇怪的转换翻转 float ➞ double ➞ float:
movss xmm0,dword ptr [rbp-10h]
cvtss2sd xmm0,xmm0
movsd xmm1,xmm0
cvtsd2ss xmm1,xmm1
lea rbp,[rbp]
mov r11,2061520h
call r11
test eax,eax
jge M0_L0
movss xmm0,dword ptr [rbp-10h]
cvtss2sd xmm0,xmm0
cvtsd2ss xmm0,xmm0
ret
RyuJIT 似乎可以生成更高效的代码来处理 floats。 Mono 将 floats 视为 doubles 并每次转换值，这也会导致 CPU 寄存器和内存之间的额外值传输。
请注意，所有这些仅对 Windows x64 有效。我不知道这个基准测试在 Linux 或 Mac.
上的表现如何