Analyse de performance
Remarque: nouveau leader au 20/08/2015.
J'ai exécuté chacune des différentes méthodes de conversion à travers des Stopwatchtests de performances bruts , une analyse avec une phrase aléatoire (n = 61, 1000 itérations) et une analyse avec un texte Project Gutenburg (n = 1238957, 150 itérations). Voici les résultats, du plus rapide au plus lent. Toutes les mesures sont en ticks ( 10 000 ticks = 1 ms ) et toutes les notes relatives sont comparées à l' StringBuilderimplémentation [la plus lente] . Pour le code utilisé, voir ci-dessous ou le référentiel du framework de test où je maintiens maintenant le code pour l'exécuter.
Avertissement
AVERTISSEMENT: ne vous fiez pas à ces statistiques pour quoi que ce soit de concret; ce sont simplement des échantillons de données. Si vous avez vraiment besoin de performances de premier ordre, veuillez tester ces méthodes dans un environnement représentatif de vos besoins de production avec des données représentatives de ce que vous utiliserez.
Résultats
- Recherche par octet
unsafe(via CodesInChaos) (ajouté au test repo par airbreather )
- Texte: 4727,85 (105,2X)
- Phrase: 0,28 (99,7X)
- Recherche par octet (via CodesInChaos)
- Texte: 10 853,96 (45,8 fois plus rapide)
- Phrase: 0,65 (42,7 fois plus rapide)
- Manipulation d'octets 2 (via CodesInChaos)
- Texte: 12967,69 (38,4 fois plus rapide)
- Phrase: 0,73 (37,9 fois plus rapide)
- Manipulation d'octets (via Waleed Eissa)
- Texte: 16 856,64 (29,5 fois plus rapide)
- Phrase: 0,70 (39,5 fois plus rapide)
- Recherche / changement (via Nathan Moinvaziri)
- Texte: 23201,23 (21,4 fois plus rapide)
- Phrase: 1,24 (22,3 fois plus rapide)
- Recherche par grignotage (via Brian Lambert)
- Texte: 23 879,41 (20,8 fois plus rapide)
- Phrase: 1,15 (23,9 fois plus rapide)
BitConverter (via Tomalak)
- Texte: 113,269.34 (4.4X plus rapide)
- Phrase: 9,98 (2,8 fois plus rapide)
{SoapHexBinary}.ToString (via Mykroft)
- Texte: 178 601,39 (2,8 fois plus rapide)
- Phrase: 10,68 (2,6 fois plus rapide)
{byte}.ToString("X2")(en utilisant foreach) (dérivé de la réponse de Will Dean)
- Texte: 308 805,38 (2,4 fois plus rapide)
- Phrase: 16,89 (2,4 fois plus rapide)
{byte}.ToString("X2")(utilisation {IEnumerable}.Aggregate, nécessite System.Linq) (via Mark)
- Texte: 352828,20 (2,1 fois plus rapide)
- Phrase: 16,87 (2,4 fois plus rapide)
Array.ConvertAll(en utilisant string.Join) (via Will Dean)
- Texte: 675 451,57 (1,1 fois plus rapide)
- Phrase: 17,95 (2,2 fois plus rapide)
Array.ConvertAll(en utilisant string.Concat, nécessite .NET 4.0) (via Will Dean)
- Texte: 752 078,70 (1,0 fois plus rapide)
- Phrase: 18,28 (2,2 fois plus rapide)
{StringBuilder}.AppendFormat(en utilisant foreach) (via Tomalak)
- Texte: 672 115,77 (1,1 fois plus rapide)
- Phrase: 36.82 (1.1X plus rapide)
{StringBuilder}.AppendFormat(en utilisant {IEnumerable}.Aggregate, nécessite System.Linq) (dérivé de la réponse de Tomalak)
- Texte: 718 380,63 (1,0 fois plus rapide)
- Phrase: 39,71 (1,0 fois plus rapide)
Les tables de recherche ont pris le pas sur la manipulation des octets. Fondamentalement, il existe une certaine forme de précalcul du grignotage ou de l'octet donné en hexadécimal. Ensuite, lorsque vous extrayez les données, vous recherchez simplement la partie suivante pour voir quelle chaîne hexadécimale il s'agirait. Cette valeur est ensuite ajoutée à la sortie de chaîne résultante d'une certaine manière. Pendant longtemps, la manipulation d'octets, potentiellement plus difficile à lire par certains développeurs, a été l'approche la plus performante.
Votre meilleur pari sera toujours de trouver des données représentatives et de les essayer dans un environnement de production. Si vous avez des contraintes de mémoire différentes, vous pouvez préférer une méthode avec moins d'allocations à une qui serait plus rapide mais consommerait plus de mémoire.
Code de test
N'hésitez pas à jouer avec le code de test que j'ai utilisé. Une version est incluse ici, mais n'hésitez pas à cloner le dépôt et à ajouter vos propres méthodes. Veuillez soumettre une demande d'extraction si vous trouvez quelque chose d'intéressant ou souhaitez aider à améliorer le cadre de test qu'il utilise.
- Ajoutez la nouvelle méthode statique (
Func<byte[], string>) à /Tests/ConvertByteArrayToHexString/Test.cs.
- Ajoutez le nom de cette méthode à la
TestCandidatesvaleur de retour dans cette même classe.
- Assurez-vous que vous exécutez la version d'entrée souhaitée, phrase ou texte, en basculant les commentaires
GenerateTestInputdans cette même classe.
- Appuyez F5et attendez la sortie (un vidage HTML est également généré dans le dossier / 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();
}
Mise à jour (2010-01-13)
Ajout de la réponse de Waleed à l'analyse. Tres rapide.
Mise à jour (2011-10-05)
Ajout d'une string.Concat Array.ConvertAllvariante pour être complet (nécessite .NET 4.0). Au même niveau que la string.Joinversion.
Mise à jour (2012-02-05)
Le repo de test comprend plus de variantes telles que StringBuilder.Append(b.ToString("X2")). Aucun n'a bouleversé les résultats. foreachest plus rapide que {IEnumerable}.Aggregate, par exemple, mais BitConvertergagne toujours.
Mise à jour (2012-04-03)
Ajout de la SoapHexBinaryréponse de Mykroft à l'analyse, qui a pris la troisième place.
Mise à jour (2013-01-15)
Ajout de la réponse de manipulation d'octets de CodesInChaos, qui a pris la première place (par une grande marge sur de gros blocs de texte).
Mise à jour (2013-05-23)
Ajout de la réponse de recherche de Nathan Moinvaziri et de la variante du blog de Brian Lambert. Tous deux assez rapides, mais ne prenant pas les devants sur la machine de test que j'ai utilisée (AMD Phenom 9750).
Mise à jour (2014-07-31)
Ajout de la nouvelle réponse de recherche basée sur octets de @ CodesInChaos. Il semble avoir pris la tête des tests de phrases et des tests de texte intégral.
Mise à jour (2015-08-20)
Ajout des optimisations et de la unsafevariante de l' aérographe au dépôt de cette réponse . Si vous voulez jouer dans le jeu dangereux, vous pouvez obtenir d'énormes gains de performance par rapport à l'un des meilleurs gagnants précédents sur les chaînes courtes et les gros textes.