मेरे पास 500000 बेतरतीब ढंग से उत्पन्न Tuple<long,long,string>वस्तुओं की एक सूची है, जिस पर मैं "खोज" के बीच एक सरल प्रदर्शन कर रहा हूं:
var data = new List<Tuple<long,long,string>>(500000);
...
var cnt = data.Count(t => t.Item1 <= x && t.Item2 >= x);जब मैं अपना रैंडम सरणी उत्पन्न करता हूं और अपनी खोज को यादृच्छिक रूप से उत्पन्न 100 मानों के लिए चलाता हूं x, तो खोजें लगभग चार सेकंड में पूरी हो जाती हैं। उन महान आश्चर्यों के बारे में जानकर, जिन्हें छांटना खोज करने के लिए करता है , हालाँकि, मैंने अपने 100 खोजों को चलाने से पहले अपने डेटा को क्रमबद्ध करने का निर्णय लिया - पहले बाय Item1बाय Item2और फिर अंत में Item3। मुझे उम्मीद थी कि सॉर्ट किए गए संस्करण को शाखा की भविष्यवाणी के कारण थोड़ा तेज़ प्रदर्शन करना होगा: मेरी सोच यह रही है कि एक बार जब हम उस बिंदु पर पहुंच जाते हैं, जहां शाखा के Item1 == xसभी आगे की जाँच t.Item1 <= x"नो नो" के रूप में शाखा का सही अनुमान लगाती है, जिससे टेल भाग की गति बढ़ जाती है। खोज। मेरे आश्चर्य के लिए, खोजों को एक क्रमबद्ध सरणी पर दो बार लिया गया !
मैंने उस क्रम के चारों ओर स्विच करने का प्रयास किया जिसमें मैंने अपने प्रयोगों को चलाया, और यादृच्छिक संख्या जनरेटर के लिए अलग-अलग बीज का उपयोग किया, लेकिन प्रभाव एक ही रहा है: एक अनसुलझी सरणी में खोज उसी सरणी में खोजों के रूप में लगभग दो बार तेजी से चली, लेकिन सॉर्ट किया गया!
किसी को भी इस अजीब प्रभाव की एक अच्छी व्याख्या है? मेरे परीक्षणों का स्रोत कोड निम्न है; मैं .NET 4.0 का उपयोग कर रहा हूं।
private const int TotalCount = 500000;
private const int TotalQueries = 100;
private static long NextLong(Random r) {
var data = new byte[8];
r.NextBytes(data);
return BitConverter.ToInt64(data, 0);
}
private class TupleComparer : IComparer<Tuple<long,long,string>> {
public int Compare(Tuple<long,long,string> x, Tuple<long,long,string> y) {
var res = x.Item1.CompareTo(y.Item1);
if (res != 0) return res;
res = x.Item2.CompareTo(y.Item2);
return (res != 0) ? res : String.CompareOrdinal(x.Item3, y.Item3);
}
}
static void Test(bool doSort) {
var data = new List<Tuple<long,long,string>>(TotalCount);
var random = new Random(1000000007);
var sw = new Stopwatch();
sw.Start();
for (var i = 0 ; i != TotalCount ; i++) {
var a = NextLong(random);
var b = NextLong(random);
if (a > b) {
var tmp = a;
a = b;
b = tmp;
}
var s = string.Format("{0}-{1}", a, b);
data.Add(Tuple.Create(a, b, s));
}
sw.Stop();
if (doSort) {
data.Sort(new TupleComparer());
}
Console.WriteLine("Populated in {0}", sw.Elapsed);
sw.Reset();
var total = 0L;
sw.Start();
for (var i = 0 ; i != TotalQueries ; i++) {
var x = NextLong(random);
var cnt = data.Count(t => t.Item1 <= x && t.Item2 >= x);
total += cnt;
}
sw.Stop();
Console.WriteLine("Found {0} matches in {1} ({2})", total, sw.Elapsed, doSort ? "Sorted" : "Unsorted");
}
static void Main() {
Test(false);
Test(true);
Test(false);
Test(true);
}Populated in 00:00:01.3176257
Found 15614281 matches in 00:00:04.2463478 (Unsorted)
Populated in 00:00:01.3345087
Found 15614281 matches in 00:00:08.5393730 (Sorted)
Populated in 00:00:01.3665681
Found 15614281 matches in 00:00:04.1796578 (Unsorted)
Populated in 00:00:01.3326378
Found 15614281 matches in 00:00:08.6027886 (Sorted)Item1 == x, आगे की सभी जाँच t.Item1 <= xशाखा को "नो टेक" के रूप में सही ढंग से भविष्यवाणी करेगी, जिससे खोज के टेल भाग में तेजी आएगी। जाहिर है, सोच की वह लाइन कठोर वास्तविकता से गलत साबित हुई है :)