Analiza wydajności
Uwaga: nowy lider od 20.08.2015.
Przeanalizowałem każdą z różnych metod konwersji przez pewne prymitywne Stopwatchtesty wydajności, przebieg z losowym zdaniem (n = 61, 1000 iteracji) i przebieg z tekstem Projektu Gutenburga (n = 1 238 957, 150 iteracji). Oto wyniki, z grubsza od najszybszego do najwolniejszego. Wszystkie pomiary są w tikach ( 10 000 tików = 1 ms ), a wszystkie uwagi względne są porównywane z [najwolniejszą] StringBuilderimplementacją. Informacje na temat użytego kodu znajdują się poniżej lub w repozytorium środowiska testowego, w którym teraz utrzymuję kod do uruchomienia tego.
Zrzeczenie się
OSTRZEŻENIE: Nie polegaj na tych statystykach na niczym konkretnym; są po prostu próbką danych przykładowych. Jeśli naprawdę potrzebujesz najwyższej wydajności, przetestuj te metody w środowisku reprezentatywnym dla twoich potrzeb produkcyjnych, z danymi reprezentującymi to, czego będziesz używać.
Wyniki
- Wyszukiwanie według bajtu
unsafe(przez CodesInChaos) (dodane do testowego repozytorium przez airbreather )
- Tekst: 4 727,85 (105,2X)
- Zdanie: 0,28 (99,7X)
- Wyszukiwanie według bajtu (przez CodesInChaos)
- Tekst: 10 853,96 (45,8X szybciej)
- Zdanie: 0,65 (42,7X szybciej)
- Byte Manipulation 2 (via CodesInChaos)
- Tekst: 12967,69 (38,4X szybciej)
- Zdanie: 0,73 (37,9X szybciej)
- Manipulacja bajtami (przez Waleed Eissa)
- Tekst: 166,66.64 (29,5X szybciej)
- Zdanie: 0,70 (39,5 x szybciej)
- Lookup / Shift (via Nathan Moinvaziri)
- Tekst: 23.201,23 (21,4X szybciej)
- Zdanie: 1,24 (22,3X szybciej)
- Wyszukiwanie przez nibble (via Brian Lambert)
- Tekst: 23.879.41 (20.8X szybciej)
- Zdanie: 1,15 (23,9 x szybciej)
BitConverter (przez Tomalak)
- Tekst: 113 269,34 (4,4 x szybciej)
- Zdanie: 9,98 (2,8 x szybciej)
{SoapHexBinary}.ToString (przez Mykroft)
- Tekst: 178 601,39 (2,8 x szybciej)
- Zdanie: 10,68 (2,6 razy szybszy)
{byte}.ToString("X2")(using foreach) (pochodzi z odpowiedzi Willa Deana)
- Tekst: 308,805,38 (2,4 razy szybszy)
- Zdanie: 16,89 (2,4 x szybciej)
{byte}.ToString("X2")(używanie {IEnumerable}.Aggregate, wymaga System.Linq) (przez Mark)
- Tekst: 352 828,20 (2,1 razy szybszy)
- Zdanie: 16,87 (2,4 x szybciej)
Array.ConvertAll(za pomocą string.Join) (przez Will Dean)
- Tekst: 675,451,57 (1,1 raza szybszy)
- Zdanie: 17,95 (2,2 x szybciej)
Array.ConvertAll(używanie string.Concat, wymaga .NET 4.0) (przez Will Dean)
- Tekst: 752 028,70 (1,0X szybciej)
- Zdanie: 18,28 (2,2 x szybciej)
{StringBuilder}.AppendFormat(za pomocą foreach) (przez Tomalak)
- Tekst: 672,115,77 (1,1 x szybciej)
- Zdanie: 36,82 (1,1 x szybciej)
{StringBuilder}.AppendFormat(używanie {IEnumerable}.Aggregate, wymaga System.Linq) (pochodzi z odpowiedzi Tomalaka)
- Tekst: 718,380,63 (1,0X szybciej)
- Zdanie: 39,71 (1,0X szybciej)
Tabele odnośników przejęły kontrolę nad przetwarzaniem bajtów. Zasadniczo istnieje pewna forma wstępnego obliczania tego, co dany skubek lub bajt będzie w formacie szesnastkowym. Następnie, przeglądając dane, po prostu przeglądasz kolejną część, aby zobaczyć, jaki to byłby szesnastkowy ciąg znaków. Ta wartość jest następnie dodawana do wynikowego ciągu w pewien sposób. Przez długi czas manipulowanie bajtami, potencjalnie trudniejsze do odczytania przez niektórych programistów, było najskuteczniejszym podejściem.
Najlepszym rozwiązaniem będzie znalezienie reprezentatywnych danych i wypróbowanie ich w środowisku produkcyjnym. Jeśli masz inne ograniczenia pamięci, możesz preferować metodę z mniejszą alokacją niż taką, która byłaby szybsza, ale zużywałaby więcej pamięci.
Kod testowy
Zachęcamy do zabawy przy użyciu kodu testowego, którego użyłem. Dołączona jest tutaj wersja, ale możesz sklonować repozytorium i dodać własne metody. Prześlij żądanie ściągnięcia, jeśli znajdziesz coś interesującego lub chcesz ulepszyć używaną platformę testową.
- Dodaj nową metodę statyczną (
Func<byte[], string>) do /Tests/ConvertByteArrayToHexString/Test.cs.
- Dodaj nazwę tej metody do
TestCandidateswartości zwracanej w tej samej klasie.
- Upewnij się, że korzystasz z żądanej wersji wejściowej, zdania lub tekstu, przełączając komentarze
GenerateTestInputw tej samej klasie.
- Naciśnij F5i poczekaj na wynik (zrzut HTML jest również generowany w folderze / bin).
static string ByteArrayToHexStringViaStringJoinArrayConvertAll(byte[] bytes) {
return string.Join(string.Empty, Array.ConvertAll(bytes, b => b.ToString("X2")));
}
static string ByteArrayToHexStringViaStringConcatArrayConvertAll(byte[] bytes) {
return string.Concat(Array.ConvertAll(bytes, b => b.ToString("X2")));
}
static string ByteArrayToHexStringViaBitConverter(byte[] bytes) {
string hex = BitConverter.ToString(bytes);
return hex.Replace("-", "");
}
static string ByteArrayToHexStringViaStringBuilderAggregateByteToString(byte[] bytes) {
return bytes.Aggregate(new StringBuilder(bytes.Length * 2), (sb, b) => sb.Append(b.ToString("X2"))).ToString();
}
static string ByteArrayToHexStringViaStringBuilderForEachByteToString(byte[] bytes) {
StringBuilder hex = new StringBuilder(bytes.Length * 2);
foreach (byte b in bytes)
hex.Append(b.ToString("X2"));
return hex.ToString();
}
static string ByteArrayToHexStringViaStringBuilderAggregateAppendFormat(byte[] bytes) {
return bytes.Aggregate(new StringBuilder(bytes.Length * 2), (sb, b) => sb.AppendFormat("{0:X2}", b)).ToString();
}
static string ByteArrayToHexStringViaStringBuilderForEachAppendFormat(byte[] bytes) {
StringBuilder hex = new StringBuilder(bytes.Length * 2);
foreach (byte b in bytes)
hex.AppendFormat("{0:X2}", b);
return hex.ToString();
}
static string ByteArrayToHexViaByteManipulation(byte[] bytes) {
char[] c = new char[bytes.Length * 2];
byte b;
for (int i = 0; i < bytes.Length; i++) {
b = ((byte)(bytes[i] >> 4));
c[i * 2] = (char)(b > 9 ? b + 0x37 : b + 0x30);
b = ((byte)(bytes[i] & 0xF));
c[i * 2 + 1] = (char)(b > 9 ? b + 0x37 : b + 0x30);
}
return new string(c);
}
static string ByteArrayToHexViaByteManipulation2(byte[] bytes) {
char[] c = new char[bytes.Length * 2];
int b;
for (int i = 0; i < bytes.Length; i++) {
b = bytes[i] >> 4;
c[i * 2] = (char)(55 + b + (((b - 10) >> 31) & -7));
b = bytes[i] & 0xF;
c[i * 2 + 1] = (char)(55 + b + (((b - 10) >> 31) & -7));
}
return new string(c);
}
static string ByteArrayToHexViaSoapHexBinary(byte[] bytes) {
SoapHexBinary soapHexBinary = new SoapHexBinary(bytes);
return soapHexBinary.ToString();
}
static string ByteArrayToHexViaLookupAndShift(byte[] bytes) {
StringBuilder result = new StringBuilder(bytes.Length * 2);
string hexAlphabet = "0123456789ABCDEF";
foreach (byte b in bytes) {
result.Append(hexAlphabet[(int)(b >> 4)]);
result.Append(hexAlphabet[(int)(b & 0xF)]);
}
return result.ToString();
}
static readonly uint* _lookup32UnsafeP = (uint*)GCHandle.Alloc(_Lookup32, GCHandleType.Pinned).AddrOfPinnedObject();
static string ByteArrayToHexViaLookup32UnsafeDirect(byte[] bytes) {
var lookupP = _lookup32UnsafeP;
var result = new string((char)0, bytes.Length * 2);
fixed (byte* bytesP = bytes)
fixed (char* resultP = result) {
uint* resultP2 = (uint*)resultP;
for (int i = 0; i < bytes.Length; i++) {
resultP2[i] = lookupP[bytesP[i]];
}
}
return result;
}
static uint[] _Lookup32 = Enumerable.Range(0, 255).Select(i => {
string s = i.ToString("X2");
return ((uint)s[0]) + ((uint)s[1] << 16);
}).ToArray();
static string ByteArrayToHexViaLookupPerByte(byte[] bytes) {
var result = new char[bytes.Length * 2];
for (int i = 0; i < bytes.Length; i++)
{
var val = _Lookup32[bytes[i]];
result[2*i] = (char)val;
result[2*i + 1] = (char) (val >> 16);
}
return new string(result);
}
static string ByteArrayToHexViaLookup(byte[] bytes) {
string[] hexStringTable = new string[] {
"00", "01", "02", "03", "04", "05", "06", "07", "08", "09", "0A", "0B", "0C", "0D", "0E", "0F",
"10", "11", "12", "13", "14", "15", "16", "17", "18", "19", "1A", "1B", "1C", "1D", "1E", "1F",
"20", "21", "22", "23", "24", "25", "26", "27", "28", "29", "2A", "2B", "2C", "2D", "2E", "2F",
"30", "31", "32", "33", "34", "35", "36", "37", "38", "39", "3A", "3B", "3C", "3D", "3E", "3F",
"40", "41", "42", "43", "44", "45", "46", "47", "48", "49", "4A", "4B", "4C", "4D", "4E", "4F",
"50", "51", "52", "53", "54", "55", "56", "57", "58", "59", "5A", "5B", "5C", "5D", "5E", "5F",
"60", "61", "62", "63", "64", "65", "66", "67", "68", "69", "6A", "6B", "6C", "6D", "6E", "6F",
"70", "71", "72", "73", "74", "75", "76", "77", "78", "79", "7A", "7B", "7C", "7D", "7E", "7F",
"80", "81", "82", "83", "84", "85", "86", "87", "88", "89", "8A", "8B", "8C", "8D", "8E", "8F",
"90", "91", "92", "93", "94", "95", "96", "97", "98", "99", "9A", "9B", "9C", "9D", "9E", "9F",
"A0", "A1", "A2", "A3", "A4", "A5", "A6", "A7", "A8", "A9", "AA", "AB", "AC", "AD", "AE", "AF",
"B0", "B1", "B2", "B3", "B4", "B5", "B6", "B7", "B8", "B9", "BA", "BB", "BC", "BD", "BE", "BF",
"C0", "C1", "C2", "C3", "C4", "C5", "C6", "C7", "C8", "C9", "CA", "CB", "CC", "CD", "CE", "CF",
"D0", "D1", "D2", "D3", "D4", "D5", "D6", "D7", "D8", "D9", "DA", "DB", "DC", "DD", "DE", "DF",
"E0", "E1", "E2", "E3", "E4", "E5", "E6", "E7", "E8", "E9", "EA", "EB", "EC", "ED", "EE", "EF",
"F0", "F1", "F2", "F3", "F4", "F5", "F6", "F7", "F8", "F9", "FA", "FB", "FC", "FD", "FE", "FF",
};
StringBuilder result = new StringBuilder(bytes.Length * 2);
foreach (byte b in bytes) {
result.Append(hexStringTable[b]);
}
return result.ToString();
}
Aktualizacja (13.01.2010)
Dodano odpowiedź Waleeda do analizy. Dosyć szybko.
Aktualizacja (2011-10-05)
Dodano string.Concat Array.ConvertAllwariant kompletności (wymaga .NET 4.0). Na równi z string.Joinwersją.
Aktualizacja (2012-02-05)
Repozytorium testów zawiera więcej wariantów, takich jak StringBuilder.Append(b.ToString("X2")). Żadne nie zakłóciło żadnych wyników. foreachjest szybszy niż {IEnumerable}.Aggregate, na przykład, ale BitConverterwciąż wygrywa.
Aktualizacja (2012-04-03)
Dodano SoapHexBinaryodpowiedź Mykroft do analizy, która zajęła trzecie miejsce.
Aktualizacja (15.01.2013)
Dodano odpowiedź manipulacji bajtami CodesInChaos, która zajęła pierwsze miejsce (z dużym marginesem na dużych blokach tekstu).
Aktualizacja (23.05.2013)
Dodano odpowiedź Nathana Moinvaziriego i wariant z bloga Briana Lamberta. Oba są dość szybkie, ale nie przejmują prowadzenia na testowej maszynie, z której korzystałem (AMD Phenom 9750).
Aktualizacja (2014-07-31)
Dodano nową odpowiedź bajtową @ CodesInChaos. Wydaje się, że przejął inicjatywę zarówno w testach zdań, jak i testach pełnotekstowych.
Aktualizacja (2015-08-20)
Dodano optymalizacje i wariant airbreatherunsafe do repozytorium tej odpowiedzi . Jeśli chcesz zagrać w niebezpieczną grę, możesz uzyskać ogromny wzrost wydajności w stosunku do któregokolwiek z poprzednich najlepszych zwycięzców zarówno w przypadku krótkich ciągów, jak i dużych tekstów.