@djfoxer
Blog (220)
Komentarze (4k)
Recenzje (1)

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

@djfoxer.NET Linux vs Windows - test wydajności .NET Core 3.1, .NET 5.0, a także Mono17.05.2020 23:28

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ć.

Krótkie podsumowanie tego wpisu w j. angielskim pojawi się na GitHubie:  https://github.com/djfoxer/DotNetFrameworkVsCore/
© dobreprogramy·Redakcja·Regulamin·Polityka prywatności·Reklama·Kontakt
Szanowna Użytkowniczko! Szanowny Użytkowniku!
×
Aby dalej móc dostarczać coraz lepsze materiały redakcyjne i udostępniać coraz lepsze usługi, potrzebujemy zgody na dopasowanie treści marketingowych do Twojego zachowania. Twoje dane są u nas bezpieczne, a zgodę możesz wycofać w każdej chwili na podstronie polityka prywatności.

Kliknij "PRZECHODZĘ DO SERWISU" lub na symbol "X" w górnym rogu tej planszy, jeżeli zgadzasz się na przetwarzanie przez Wirtualną Polskę i naszych Zaufanych Partnerów Twoich danych osobowych, zbieranych w ramach korzystania przez Ciebie z usług, portali i serwisów internetowych Wirtualnej Polski (w tym danych zapisywanych w plikach cookies) w celach marketingowych realizowanych na zlecenie naszych Zaufanych Partnerów. Jeśli nie zgadzasz się na przetwarzanie Twoich danych osobowych skorzystaj z ustawień w polityce prywatności. Zgoda jest dobrowolna i możesz ją w dowolnym momencie wycofać zmieniając ustawienia w polityce prywatności (w której znajdziesz odpowiedzi na wszystkie pytania związane z przetwarzaniem Twoich danych osobowych).

Od 25 maja 2018 roku obowiązuje Rozporządzenie Parlamentu Europejskiego i Rady (UE) 2016/679 (określane jako "RODO"). W związku z tym chcielibyśmy poinformować o przetwarzaniu Twoich danych oraz zasadach, na jakich odbywa się to po dniu 25 maja 2018 roku.

Kto będzie administratorem Twoich danych?

Administratorami Twoich danych będzie Wirtualna Polska Media Spółka Akcyjna z siedzibą w Warszawie, oraz pozostałe spółki z grupy Wirtualna Polska, jak również nasi Zaufani Partnerzy, z którymi stale współpracujemy. Szczegółowe informacje dotyczące administratorów znajdują się w polityce prywatności.

O jakich danych mówimy?

Chodzi o dane osobowe, które są zbierane w ramach korzystania przez Ciebie z naszych usług, portali i serwisów internetowych udostępnianych przez Wirtualną Polskę, w tym zapisywanych w plikach cookies, które są instalowane na naszych stronach przez Wirtualną Polskę oraz naszych Zaufanych Partnerów.

Dlaczego chcemy przetwarzać Twoje dane?

Przetwarzamy je dostarczać coraz lepsze materiały redakcyjne, dopasować ich tematykę do Twoich zainteresowań, tworzyć portale i serwisy internetowe, z których będziesz korzystać z przyjemnością, zapewniać większe bezpieczeństwo usług, udoskonalać nasze usługi i maksymalnie dopasować je do Twoich zainteresowań, pokazywać reklamy dopasowane do Twoich potrzeb. Szczegółowe informacje dotyczące celów przetwarzania Twoich danych znajdują się w polityce prywatności.

Komu możemy przekazać dane?

Twoje dane możemy przekazywać podmiotom przetwarzającym je na nasze zlecenie oraz podmiotom uprawnionym do uzyskania danych na podstawie obowiązującego prawa – oczywiście tylko, gdy wystąpią z żądaniem w oparciu o stosowną podstawę prawną.

Jakie masz prawa w stosunku do Twoich danych?

Masz prawo żądania dostępu, sprostowania, usunięcia lub ograniczenia przetwarzania danych. Możesz wycofać zgodę na przetwarzanie, zgłosić sprzeciw oraz skorzystać z innych praw wymienionych szczegółowo w polityce prywatności.

Jakie są podstawy prawne przetwarzania Twoich danych?

Podstawą prawną przetwarzania Twoich danych w celu świadczenia usług jest niezbędność do wykonania umów o ich świadczenie (tymi umowami są zazwyczaj regulaminy). Podstawą prawną przetwarzania danych w celu pomiarów statystycznych i marketingu własnego administratorów jest tzw. uzasadniony interes administratora. Przetwarzanie Twoich danych w celach marketingowych realizowanych przez Wirtualną Polskę na zlecenie Zaufanych Partnerów i bezpośrednio przez Zaufanych Partnerów będzie odbywać się na podstawie Twojej dobrowolnej zgody.