क्षमता का परिक्षण
नोट: 2015-08-20 के रूप में नए नेता
मैंने कुछ क्रूड Stopwatchप्रदर्शन परीक्षण, एक यादृच्छिक वाक्य (n = 61, 1000 पुनरावृत्तियों) के साथ एक रन और प्रोजेक्ट गुटेनबर्ग पाठ (n = 1,238,957, 150 पुनरावृत्तियों) के साथ एक रन के माध्यम से विभिन्न रूपांतरण विधियों में से प्रत्येक को चलाया। यहाँ परिणाम हैं, मोटे तौर पर सबसे तेजी से सबसे धीमी गति से। सभी माप टिक्स में हैं ( 10,000 टिक्स = 1 एमएस ) और सभी रिश्तेदार नोटों की तुलना [सबसे धीमी] StringBuilderकार्यान्वयन से की जाती है। उपयोग किए गए कोड के लिए, नीचे देखें या परीक्षण ढांचा रेपो जहां मैं अब इसे चलाने के लिए कोड बनाए रखता हूं।
अस्वीकरण
चेतावनी: किसी भी चीज़ के लिए इन आँकड़ों पर भरोसा न करें; वे बस नमूना डेटा का एक नमूना रन हैं। यदि आपको वास्तव में शीर्ष प्रदर्शन की आवश्यकता है, तो कृपया अपने उत्पादन जरूरतों के पर्यावरण प्रतिनिधि में इन विधियों का परीक्षण करें जो आप उपयोग करेंगे के डेटा प्रतिनिधि के साथ।
परिणाम
- बाइट द्वारा लुकअप
unsafe(कोड्स इनचैचोस के माध्यम से) ( एयरब्रीथर द्वारा रेपो का परीक्षण करने के लिए जोड़ा गया )
- पाठ: 4,727.85 (105.2X)
- वाक्य: 0.28 (99.7X)
- लुक बाईट (कोडइन्चोस के माध्यम से)
- पाठ: 10,853.96 (45.8X तेज़)
- वाक्य: 0.65 (42.7X तेज़)
- बाइट मैनिपुलेशन 2 (कोडइन्चोस के माध्यम से)
- पाठ: 12,967.69 (38.4X तेज़)
- वाक्य: 0.73 (तेजी से 37.9X)
- बाइट मैनिपुलेशन (Waleed Eissa के माध्यम से)
- पाठ: 16,856.64 (29.5X तेज़)
- सजा: 0.70 (तेजी से 39.5X)
- लुकअप / शिफ्ट (नाथन मोइनवाज़िरी के माध्यम से)
- पाठ: 23,201.23 (21.4X तेज़)
- वाक्य: 1.24 (तेजी से 22.3X)
- भोला-भाला (ब्रायन लैम्बर्ट के माध्यम से)
- पाठ: 23,879.41 (20.8X तेज़)
- वाक्य: 1.15 (23.9X तेज़)
BitConverter (तोमलक के माध्यम से)
- पाठ: 113,269.34 (4.4X तेज़)
- वाक्य: 9.98 (2.8X तेज़)
{SoapHexBinary}.ToString (मायक्रॉफ्ट के माध्यम से)
- पाठ: 178,601.39 (2.8X तेज़)
- वाक्य: 10.68 (2.6X तेज़)
{byte}.ToString("X2")(उपयोग foreach) (विल डीन के उत्तर से प्राप्त)
- पाठ: 308,805.38 (तेजी से 2.4X)
- वाक्य: 16.89 (2.4X तेज़)
{byte}.ToString("X2")(उपयोग करते हुए {IEnumerable}.Aggregate, System.Linq की आवश्यकता होती है) (मार्क के माध्यम से)
- पाठ: 352,828.20 (2.1X तेज़)
- वाक्य: 16.87 (2.4X तेज़)
Array.ConvertAll(का उपयोग करते हुए string.Join) (विल डीन के माध्यम से)
- पाठ: 675,451.57 (1.1X तेज़)
- वाक्य: 17.95 (2.2X तेज़)
Array.ConvertAll(उपयोग करना string.Concat, .NET 4.0 की आवश्यकता है) (विल डीन के माध्यम से)
- पाठ: 752,078.70 (1.0X तेज़)
- वाक्य: 18.28 (2.2X तेज़)
{StringBuilder}.AppendFormat(का उपयोग कर foreach) (Tomalak के माध्यम से)
- पाठ: 672,115.77 (1.1X तेज़)
- वाक्य: 36.82 (1.1X तेज़)
{StringBuilder}.AppendFormat(का उपयोग करते हुए {IEnumerable}.Aggregate, System.Linq की आवश्यकता होती है) (तोमलक के उत्तर से प्राप्त)
- पाठ: 718,380.63 (1.0X तेज़)
- वाक्य: 39.71 (1.0X तेज़)
लुकअप टेबल ने बाइट हेरफेर पर बढ़त बना ली है। मूल रूप से, वहाँ किसी भी दिए गए कुतरना या बाइट हेक्स में होगा precomputing के कुछ रूप है। फिर, जैसा कि आप डेटा के माध्यम से चीरते हैं, आप बस अगले हिस्से को देखते हैं कि हेक्स स्ट्रिंग क्या है। उस मूल्य को फिर कुछ फैशन में परिणामी स्ट्रिंग आउटपुट में जोड़ा जाता है। लंबे समय तक बाइट हेरफेर के लिए, कुछ डेवलपर्स द्वारा पढ़ने के लिए संभवतः कठिन, शीर्ष-प्रदर्शन दृष्टिकोण था।
आपका सबसे अच्छा दांव अभी भी कुछ प्रतिनिधि डेटा खोजने और इसे उत्पादन जैसे वातावरण में आज़माने जा रहा है। यदि आपके पास अलग-अलग मेमोरी बाधाएं हैं, तो आप कम आवंटन वाले एक विधि को पसंद कर सकते हैं जो कि तेज होगी लेकिन अधिक मेमोरी का उपभोग करेगी।
परीक्षण कोड
मेरे द्वारा उपयोग किए गए परीक्षण कोड के साथ खेलने के लिए स्वतंत्र महसूस करें। एक संस्करण यहां शामिल है लेकिन रेपो क्लोन करने और अपने स्वयं के तरीकों को जोड़ने के लिए स्वतंत्र महसूस करें । कृपया एक पुल अनुरोध प्रस्तुत करें यदि आप कुछ भी दिलचस्प पाते हैं या परीक्षण ढांचे का उपयोग करने में मदद करना चाहते हैं।
- नई स्थिर विधि (
Func<byte[], string>) /Tests/ConvertByteArrayToHexString/Test.cs में जोड़ें।
- उस विधि का नाम
TestCandidatesउसी वर्ग में वापसी मान में जोड़ें ।
- सुनिश्चित करें कि आप उसी संस्करण में टिप्पणियों को टॉगल करके अपने इच्छित इनपुट संस्करण को चला रहे हैं, वाक्य या पाठ
GenerateTestInput।
- हिट F5और आउटपुट के लिए प्रतीक्षा करें (एक HTML डंप भी / बिन फ़ोल्डर में उत्पन्न होता है)।
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();
}
अपडेट (2010-01-13)
विश्लेषण के लिए Waleed का उत्तर जोड़ा गया। जल्दी।
अपडेट (2011-10-05)
string.Concat Array.ConvertAllपूर्णता के लिए जोड़ा गया संस्करण (.NET 4.0 की आवश्यकता है)। string.Joinसंस्करण के साथ सममूल्य पर ।
अपडेट (2012-02-05)
टेस्ट रेपो में अधिक वेरिएंट शामिल हैं जैसे कि StringBuilder.Append(b.ToString("X2"))। कोई भी परिणाम किसी को परेशान नहीं करता है। उदाहरण के लिए, foreachतेजी से है {IEnumerable}.Aggregate, लेकिन BitConverterअभी भी जीतता है।
अपडेट (2012-04-03)
SoapHexBinaryविश्लेषण में माईक्रोफ्ट का उत्तर जोड़ा गया , जिसने तीसरा स्थान हासिल किया।
अपडेट (2013-01-15)
जोड़े गए कोडइनचैट्स के बाइट हेरफेर का उत्तर, जिसने पहले स्थान पर ले लिया (पाठ के बड़े ब्लॉकों पर एक बड़े मार्जिन द्वारा)।
अपडेट (2013-05-23)
नाथन मोइनवाज़िरी के लुकअप उत्तर और ब्रायन लैम्बर्ट के ब्लॉग के संस्करण को जोड़ा गया। दोनों तेजी से, लेकिन मैंने परीक्षण मशीन (एएमडी फेनोम 9750) का इस्तेमाल नहीं किया।
अपडेट (2014-07-31)
जोड़ा गया @ CodesInChaos का नया बाइट-आधारित लुकअप उत्तर। ऐसा प्रतीत होता है कि दोनों वाक्य परीक्षणों और पूर्ण-पाठ परीक्षणों पर बढ़त ले ली है।
अपडेट (2015-08-20)
इस उत्तर के रेपो में एयरब्रेथ के अनुकूलन और unsafeसंस्करण जोड़े गए । यदि आप असुरक्षित गेम में खेलना चाहते हैं, तो आप शॉर्ट स्ट्रिंग्स और बड़े टेक्स्ट दोनों पर किसी भी पूर्व शीर्ष विजेता पर कुछ बड़ा प्रदर्शन हासिल कर सकते हैं।