Почему Mono запускает простой метод медленнее, а RyuJIT запускает его значительно быстрее?

Я создал простой тест из любопытства, но не могу объяснить результаты.

В качестве эталонных данных я подготовил массив структур с некоторыми случайными значениями. Этап подготовки не измеряется:

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

По сути, я хотел сравнить эти две реализации зажима:

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 здесь несколько медленнее. Но я не понимаю:

Почему Моно управляет Direct метод медленнее, чем Extension имея в виду, что Direct использует очень простой метод сравнения, тогда как Extension использует метод с дополнительными вызовами методов?

RyuJIT показывает здесь 4-кратное преимущество простого метода.

Кто-нибудь может объяснить это?

Источник

1 ответ

Поскольку никто не хотел заниматься разборкой, я отвечаю на свой вопрос.

Кажется, что причина в том, что исходный код генерируется 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

Он использует родной процессор ucomiss операции для сравнения floatс, а также быстро movaps операции по перемещению тех floatмежду регистрами процессора.

Метод расширения медленнее, потому что он имеет несколько вызовов функций 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

Код моно конвертирует floats в doubleи сравнивает их, используя comisd, Кроме того, есть странные "конвертирующие флипы" 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. Моно лечит floatкак doubles и преобразует значения каждый раз, что также вызывает дополнительную передачу значений между регистрами ЦП и памятью.

Обратите внимание, что все это действительно только для Windows x64. Я не знаю, как этот тест будет работать на Linux или Mac.

Источник
Другие вопросы по тегам