කාර්ය සාධන විශ්ලේෂණය
සටහන: 2015-08-20 වන විට නව නායකයා.
මම එක් එක් විවිධ පරිවර්තන ක්රම ක්රියාත්මක කළේ කිසියම් ගොරහැඩි Stopwatchකාර්ය සාධන පරීක්ෂණයක්, අහඹු වාක්‍යයක් සහිත ධාවනය (n = 61, 1000 පුනරාවර්තන) සහ ව්‍යාපෘති ගුටන්බර්ග් පා text යක් (n = 1,238,957, 150 පුනරාවර්තන) සමඟ ධාවනය කිරීමෙනි. දළ වශයෙන් වේගවත් සිට මන්දගාමී දක්වා ප්‍රති results ල මෙන්න. සියලුම මිනුම් කිනිතුල්ලන් තුළ ඇත (කිනිතුල්ලන් 10,000 = 1 එම්එස් ) සහ සියලු සාපේක්ෂ සටහන් [මන්දගාමී] StringBuilderක්රියාත්මක කිරීම සමඟ සැසඳේ . භාවිතා කරන කේතය සඳහා, මෙය ක්රියාත්මක කිරීම සඳහා මම දැන් කේතය නඩත්තු කරන පරීක්ෂණ රාමුව නැවත බලන්න .
වියාචනය
අවවාදයයි: කොන්ක්‍රීට් කිසිවක් සඳහා මෙම සංඛ්‍යාලේඛන මත රඳා නොසිටින්න; ඒවා හුදෙක් නියැදි දත්තවල නියැදි ධාවනයකි. ඔබට සැබවින්ම ඉහළ මට්ටමේ කාර්ය සාධනයක් අවශ්ය නම්, කරුණාකර මෙම ක්රම ඔබේ නිෂ්පාදන අවශ්‍යතා පිළිබඳ පරිසර නියෝජිතයෙකුගෙන් ඔබ භාවිතා කරන දේ පිළිබඳ දත්ත නියෝජිතයා සමඟ පරීක්ෂා කරන්න.
ප්රතිපල
- බයිට විසින් විමසුම්
unsafe(CodesInChaos හරහා) (විසින් ටෙස්ට් ණයකට එකතු airbreather )
- පෙළ: 4,727.85 (105.2X)
- වාක්‍යය: 0.28 (99.7X)
- බයිට් එකෙන් බලන්න (CodesInChaos හරහා)
- පෙළ: 10,853.96 (45.8X වේගවත්)
- වාක්‍යය: 0.65 (42.7X වේගවත්)
- බයිට් හැසිරවීම 2 (CodesInChaos හරහා)
- පෙළ: 12,967.69 (38.4X වේගවත්)
- වාක්‍යය: 0.73 (37.9X වේගවත්)
- බයිට් හැසිරවීම (වලීඩ් ඊසා හරහා)
- පෙළ: 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) (ටොමලක් හරහා)
- පෙළ: 672,115.77 (1.1X වේගවත්)
- වාක්‍යය: 36.82 (1.1X වේගවත්)
{StringBuilder}.AppendFormat(භාවිතා කිරීම {IEnumerable}.Aggregateසඳහා System.Linq අවශ්ය වේ) (ටොමලක්ගේ පිළිතුරෙන් උපුටා ගන්නා ලදි)
- පෙළ: 718,380.63 (1.0X වේගවත්)
- වාක්‍යය: 39.71 (1.0X වේගවත්)
බැලීමේ වගු බයිට් හැසිරවීමට පෙරමුණ ගෙන ඇත. මූලික වශයෙන්, කිසියම් නිබ්ල් හෝ බයිට් හෙක්ස් වල ඇති දේ පූර්ව ගණනය කිරීමේ ක්‍රමයක් තිබේ. ඉන්පසු, ඔබ දත්ත ඉරා දැමූ විට, ඊළඟ කොටස දෙස බැලීමෙන් එය කුමන හෙක්ස් නූල් දැයි බලන්න. එම අගය පසුව යම් ආකාරයකින් ප්‍රති string ලය වන නූල් ප්‍රතිදානයට එකතු වේ. දිගු කලක් තිස්සේ බයිට් හැසිරවීම, සමහර සංවර්ධකයින්ට කියවීමට අපහසු විය හැකි ඉහළම ක්‍රියාකාරී ප්‍රවේශය විය.
ඔබගේ හොඳම ඔට්ටුව තවමත් නියෝජිත දත්ත කිහිපයක් සොයාගෙන එය නිෂ්පාදන වැනි පරිසරයක අත්හදා බැලීමට ය. ඔබට වෙනස් මතක සීමාවන් තිබේ නම්, වේගවත් නමුත් වැඩි මතකයක් පරිභෝජනය කරන ක්‍රමයකට අඩු ප්‍රතිපාදන සහිත ක්‍රමයකට ඔබ කැමති විය හැකිය.
පරීක්ෂණ කේතය
මා භාවිතා කළ පරීක්ෂණ කේතය සමඟ සෙල්ලම් කිරීමට නිදහස් වන්න. ඒ අනුවාදය මෙහි ඇතුළත් නමුත් පරිගණක ක්රිඩාවට සමාන නිදහස් හැඟීම වේ ණයකට හා ඔබේ ම ක්රම එකතු කරන්න. ඔබට සිත්ගන්නාසුලු යමක් හමු වුවහොත් හෝ එය භාවිතා කරන පරීක්ෂණ රාමුව වැඩිදියුණු කිරීමට උදව් කිරීමට අවශ්ය නම් කරුණාකර අදින්න ඉල්ලීමක් ඉදිරිපත් කරන්න.
- නව ස්ථිතික ක්‍රමය (
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)
විශ්ලේෂණයට වලීඩ්ගේ පිළිතුර එකතු කරන ලදි. ඉතා වේගවත්.
යාවත්කාලීන කිරීම (2011-10-05)
එකතු string.Concat Array.ConvertAllසම්පූර්ණත්වය සඳහා ප්රභේද්යයක් (.NET 4.0 අවශ්ය). හා සම string.Joinඅනුවාදය.
යාවත්කාලීන කිරීම (2012-02-05)
ටෙස්ට් රෙපෝ වැනි තවත් ප්‍රභේද ඇතුළත් වේ StringBuilder.Append(b.ToString("X2")). කිසිවෙකු ප්‍රති the ල අවුල් කළේ නැත. foreachවේගවත් වඩා {IEnumerable}.Aggregateඋදාහරණයක් වශයෙන්, නමුත්, BitConverterතවමත් ජයග්රහණය කර තිබෙනවා.
යාවත්කාලීන කිරීම (2012-04-03)
SoapHexBinaryවිශ්ලේෂණයට මයික්‍රොෆ්ට්ගේ පිළිතුර එක් කළ අතර එය තෙවන ස්ථානයට පත්විය.
යාවත්කාලීන කිරීම (2013-01-15)
CodesInChaos හි බයිට් හැසිරවීමේ පිළිතුර එකතු කරන ලද අතර එය පළමු ස්ථානය ලබා ගත්තේය (විශාල පෙළ කොටස්වල විශාල ආන්තිකයකින්).
යාවත්කාලීන කිරීම (2013-05-23)
නේතන් මොයින්වසිරිගේ විමසුම් පිළිතුර සහ බ්‍රයන් ලැම්බර්ට්ගේ බ්ලොග් අඩවියෙන් ප්‍රභේදය එක් කරන ලදි. දෙකම වේගවත්, නමුත් මා භාවිතා කළ පරීක්ෂණ යන්ත්‍රයට පෙරමුණ නොගැනීම (AMD Phenom 9750).
යාවත්කාලීන කිරීම (2014-07-31)
@ CodesInChaos හි නව බයිට් මත පදනම් වූ විමසුම් පිළිතුර එක් කරන ලදි. එය වාක්‍ය පරීක්ෂණ සහ පූර්ණ-පෙළ පරීක්ෂණ යන දෙකටම පෙරමුණ ගෙන ඇති බව පෙනේ.
යාවත්කාලීන කිරීම (2015-08-20)
එකතු airbreather ගේ ප්රතිස්තිකරණය හා unsafeමේ ප්රභේද්යයක් පිළිතුර ගේ ණයකට . ඔබට අනාරක්ෂිත ක්‍රීඩාවට ක්‍රීඩා කිරීමට අවශ්ය නම්, කෙටි නූල් සහ විශාල පෙළ යන දෙකෙහිම පෙර ඕනෑම ජයග්‍රාහකයෙකුට වඩා විශාල කාර්ය සාධනයක් ලබා ගත හැකිය.