У мене є список 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, пошук завершується приблизно за чотири секунди. Знаючи про чудеса, які сортування робить для пошуку , однак я вирішив сортувати свої дані - спочатку Item1, потім Item2, і нарешті Item3- перед тим, як запустити мої 100 пошукових запитів. Я очікував, що відсортована версія буде виконуватись трохи швидше через передбачення гілок: я міркував, що як тільки ми дістанемося до того, коли 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стануть правильно передбачити гілку як «не приймати», прискоривши хвостову частину пошуку. Очевидно, що ця думка була доведена неправильною суворою реальністю :)