.NET Linux vs Windows - test wydajności .NET Core 3.1, .NET 5.0, a także Mono

Jakiś czas temu przedstawiłem wyniki porównania kilku środowisk uruchomieniowych platofrmy .NET - artykuł: Umarł .NET Framework, niech żyje .NET Core (oraz .NET 5) i jego wydajność (link do wpisu). Wówczas testy odpalałem na Windows 10, a sprawdzany był .NET Framework 4.8, .NET Core 3.1, a także nowy .NET 5.0 (wersja preview).

Trzeba jednak zdać sobie sprawę, że .NET od dłuższego już czasu (Mono, he he) jest środowiskiem wieloplatformowym. Warto zatem sprawdzić, jak różne środowiska uruchomieniowe .NET radzą sobie na Windows i Linuxie. Mimo, iż Mono jest z nami od wielu lat, to nowy .NET Core sprawił, że tworzenie aplikacji .NET i ich hostowanie na Linuxie stało się bardzo kuszące (cena). Zatem które z nich jest szybsze i na jakiej platformie? Pod uwagę wziąłem .NET Core 3.1, .NET 5 (zwany też jako .NET Core 5) oraz poczciwe Mono.

DotNetFrameworkVsCore

Do testów wykorzystałem własny projekt na GitHube:

https://github.com/djfoxer/DotNetFrameworkVsCore

Jest to niewielka aplikacja testująca różne platformy .NET z wykorzystaniem BenchmarkDotNet, narzędzia wspierającego prace związane z testowaniem wydajności.

Środowisko testowe

Testy odbyły się na Windows 10 i Ubuntu 20.04, które zainstalowane były obok siebie, na tej samej maszynie. Oba systemy miały najnowsze aktualizacje na dzień uruchomienia testu. Na obu systemach wykorzystano następujące frameworki:

• .NET Core 3.1.3
• .NET Core 5.0.0 (prev 3)
• Mono 6.8.0

Wyniki testów

Im mniejszy słupek, tym lepiej. Czas przedstawiony jest w ns. Linux to kolor pomarańczowy, Windows - niebieski.

EnumParse

public DayOfWeek EnumParse() => (DayOfWeek)Enum.Parse(typeof(DayOfWeek), "Thursday");

Linux

| EnumParse | .NET Core 3.1 | 356.8 ns | 1.00 |

| EnumParse | .NET Core 5.0 | 338.6 ns | 0.94 |

| EnumParse | Mono | 1,480.1 ns | 4.15 |

Windows

| EnumParse | .NET Core 3.1 | 269.1 ns | 0.60 |

| EnumParse | .NET Core 5.0 | 275.7 ns | 0.61 |

| EnumParse | Mono | 1,045.2 ns | 2.32 |

LinqOrderBySkipFirst

//IEnumerable<int> _tenMillionToZero = Enumerable.Range(0, 10_000_000).Reverse();

public int LinqOrderBySkipFirst() => _tenMillionToZero.OrderBy(i => i).Skip(4).First();

Linux

| LinqOrderBySkipFirst | .NET Core 3.1 | 448,238,907.6 ns | 1.00 |

| LinqOrderBySkipFirst | .NET Core 5.0 | 461,649,361.2 ns | 1.03 |

| LinqOrderBySkipFirst | Mono | 723,006,230.8 ns | 1.61 |

Windows

| LinqOrderBySkipFirst | .NET Core 3.1 | 385,832,466.7 ns | 0.13 |

| LinqOrderBySkipFirst | .NET Core 5.0 | 389,613,273.3 ns | 0.13 |

| LinqOrderBySkipFirst | Mono | 537,856,120.0 ns | 0.18 |

Sha256

//SHA256 _sha256 = SHA256.Create();
//byte[] _raw = new byte[100 * 1024 * 1024];

public byte[] Sha256() => _sha256.ComputeHash(_raw);

Linux

| Sha256 | .NET Core 3.1 | 711,369,840.9 ns | 1.00 |

| Sha256 | .NET Core 5.0 | 710,919,296.6 ns | 0.99 |

| Sha256 | Mono | 3,559,924,342.9 ns | 5.00 |

Windows

| Sha256 | .NET Core 3.1 | 994,021,960.0 ns | 0.52 |

| Sha256 | .NET Core 5.0 | 994,006,557.1 ns | 0.52 |

| Sha256 | Mono | 3,132,956,778.6 ns | 1.63 |

StringStartsWith

//static string _s = "abcdefghijklmnopqrstuvwxyz";

public bool StringStartsWith()
{
    var data = false;
    for (int i = 0; i < 100_000_000; i++)
    {
        data = _s.StartsWith("abcdefghijklmnopqrstuvwxy-", StringComparison.Ordinal);
    }
    return data;
}

Linux

| StringStartsWith | .NET Core 3.1 | 1,720,277,846.6 ns | 1.00 |

| StringStartsWith | .NET Core 5.0 | 1,768,026,087.7 ns | 1.03 |

| StringStartsWith | Mono | 6,117,435,107.7 ns | 3.56 |

Windows

| StringStartsWith | .NET Core 3.1 | 1,768,587,228.6 ns | 0.51 |

| StringStartsWith | .NET Core 5.0 | 1,720,654,321.4 ns | 0.49 |

| StringStartsWith | Mono | 5,214,443,466.7 ns | 1.49 |

Deserialize

//var _books = new List<Book>();
//for (int i = 0; i < 1_00000; i++)
//{
//    string id = i.ToString();
//    _books.Add(new Book { Name = id, Id = id });
//}

public object Deserialize()
{
    var formatter = new BinaryFormatter();
    var mem = new MemoryStream();
    formatter.Serialize(mem, _books );
    mem.Position = 0;

    return formatter.Deserialize(mem);
}

Linux

| Deserialize | .NET Core 3.1 | 824,364,136.9 ns | 1.00 |

| Deserialize | .NET Core 5.0 | 810,707,776.3 ns | 0.98 |

| Deserialize | Mono | 2,064,200,521.4 ns | 2.50 |

Windows

| Deserialize | .NET Core 3.1 | 741,902,228.6 ns | 0.51 |

| Deserialize | .NET Core 5.0 | 753,425,773.3 ns | 0.51 |

| Deserialize | Mono | 1,632,568,114.3 ns | 1.11 |

Regex_Email

_regexEmail = new Regex(@"[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?", RegexOptions.Compiled);

 _regexEmail.IsMatch(_commonInput);

Linux

| Regex_Email | .NET Core 3.1 | 4,028,325.0 ns | 1.00 |

| Regex_Email | .NET Core 5.0 | 1,578,693.2 ns | 0.39 |

| Regex_Email | Mono | 17,027,565.0 ns | 4.23 |

Windows

| Regex_Email | .NET Core 3.1 | 4,074,111.3 ns | 0.99 |

| Regex_Email | .NET Core 5.0 | 1,617,011.8 ns | 0.39 |

| Regex_Email | Mono | 16,978,524.4 ns | 4.12 |

Regex_StrongPassword

_regexStrongPassword = new Regex(@"^(?=.*\d)(?=.*[a-z])(?=.*[A-Z])(?=.*[a-zA-Z]).{8,}$", RegexOptions.Compiled);

_regexStrongPassword.IsMatch(_commonInput);

Linux

| Regex_StrongPassword | .NET Core 3.1 | 3,390.0 ns | 1.00 |

| Regex_StrongPassword | .NET Core 5.0 | 946.5 ns | 0.28 |

| Regex_StrongPassword | Mono | 10,457.0 ns | 3.08 |

Windows

| Regex_StrongPassword | .NET Core 3.1 | 3,209.7 ns | 0.93 |

| Regex_StrongPassword | .NET Core 5.0 | 783.9 ns | 0.23 |

| Regex_StrongPassword | Mono | 10,303.6 ns | 2.97 |

Regex_SpanSearching

_regexSpanSearching = new Regex("([ab]cd|ef[g-i])jklm", RegexOptions.Compiled);

_regexSpanSearching.IsMatch(_commonInput);

Linux

| Regex_SpanSearching | .NET Core 3.1 | 632,332.0 ns | 1.00 |

| Regex_SpanSearching | .NET Core 5.0 | 44,157.2 ns | 0.07 |

| Regex_SpanSearching | Mono | 1,679,815.0 ns | 2.66 |

Windows

| Regex_SpanSearching | .NET Core 3.1 | 574,516.8 ns | 0.90 |

| Regex_SpanSearching | .NET Core 5.0 | 43,260.0 ns | 0.07 |

| Regex_SpanSearching | Mono | 1,561,626.8 ns | 2.44 |

Regex_BackTracking

_regexBackTracking = new Regex("a*a*a*a*a*a*a*b", RegexOptions.Compiled);;

_regexBackTracking.IsMatch("aaaaaaaaaaaaaaaaaaaaa");

Linux

| Regex_BackTracking | .NET Core 3.1 | 82,438,384.0 ns | 1.00 |

| Regex_BackTracking | .NET Core 5.0 | 998.0 ns | 0.00 |

| Regex_BackTracking | Mono | 495,128,733.0 ns | 6.01 |

Windows

| Regex_BackTracking | .NET Core 3.1 | 65,198,029.5 ns | 0.847 |

| Regex_BackTracking | .NET Core 5.0 | 1,036.2 ns | 0.000 |

| Regex_BackTracking | Mono | 487,440,846.7 ns | 6.331 |

Podsumowanie

Dane i wykresy pokazują, iż .NET Core 3.1, oraz świeży .NET 5.0 mają bardzo zbliżone wyniki. Wydajność w obu przypadkach jest bardzo podobna. Windows najbardziej wyróżnił się na plus jeśli chodzi o działania na Enumach, a także operacje LINQ. Co jednak warto odnotować obliczanie SHA256 na Linuxie jest znacząco szybsze, niż ma to miejsce na Windows. Tutaj zapewne wychodzi na jaw, jak działa .NET Core. W przypadku obliczeń kryptograficznych używane są natywne, zewnętrzne narzędzia o jakich pisałem we wcześniejszym wpisie. Zatem OpenSSL na Linuxa jest wydajniejszy niż CNG Windows.

Temat Mono to już inna bajka. Wyniki wydajnościowe odstają znacznie na obu platformach od tego co widzimy w przypadku .NET Core 3.1 oraz .NET 5.0. Wydajność Mono na Windows jest znacznie lepsza, niż na Linux, aczkolwiek marne to pocieszenie jeśli spojrzymy na wykresy globalnie. Jeśli nowy .NET 5.0 ma posiadać dwa silniki uruchomieniowe: .NET Core i Mono, to Microsoft ma jeszcze daleeeką drogę i wiele pracy przed sobą, aby można było nazwać Mono szybkim. Możliwe, że kolejne wydania .NET 5.0 i Mono coś w tej kwestii zmienią.

Same porównania platform .NET Core 3.1 i .NET 5.0 pokazało, że Linux nie jest wcale znacząco gorszy od Windowsa, w kwestii wydajności .NET. Tutaj nawet można znaleźć elementy (jak chociażby kryptografia), które na Linuxie działają szybciej, niż na "matczynym" Windows. Bardzo jestem ciekaw co przyniosą kolejne wydania .NET 5.0, które powinny przyspieszyć Mono. Wówczas testy można będzie powtórzyć.