Реализация цикла List.Contains () появляется быстрее, чем встроенная. Это? Если так, то почему?

(Этот вопрос возникает из обсуждения, которое началось здесь)

Я сравнивал время поискаtrue значение вList<bool> с помощьюList.Contains() с тем для петли, свернутой вручную.

Я вижу результаты, отличные от тех, о которых сообщили другие люди. Я пробовал это на нескольких системах, и цикл кажется быстрее от 2 до 3,5 раз на всех системах, на которых я это пробовал. Эти системы варьируются от 5-летних ноутбуков под управлением XP с .Net 4 до последних компьютеров под управлением Windows 8 и .Net 4.5.

Другие люди сообщают о других результатах, а именно, чтоList.Contains() примерно такая же скорость, или немного быстрее, чем петля.

Вот мой тестовый код.

using System;
using System.Collections.Generic;
using System.Diagnostics;

namespace ConsoleApplication1
{
    internal class Program
    {
        private static void Main()
        {
            int size = 10000000;
            int count = 10;
            List<bool> data = new List<bool>(size);

            for (int i = 0; i < size; ++i)
                data.Add(false);

            var sw = new Stopwatch();

            for (int trial = 0; trial < 5; ++trial)
            {
                sw.Restart();

                for (int i = 0; i < count; ++i)
                    TestViaLoop(data);

                sw.Stop();
                Console.WriteLine(sw.ElapsedMilliseconds + " TestViaLoop()");
                sw.Restart();

                for (int i = 0; i < count; ++i)
                    TestViaListContains(data);

                sw.Stop();
                Console.WriteLine(sw.ElapsedMilliseconds + " TestViaListContains()");
                Console.WriteLine();
            }
        }

        static bool TestViaLoop(List<bool> data)
        {
            for (int i = 0; i < data.Count; ++i)
                if (data[i])
                    return true;

            return false;
        }

        static bool TestViaListContains(List<bool> data)
        {
            return data.Contains(true);
        }
    }
}

Чтобы проверить этот код, вы должны скомпилировать его как сборку x86 RELEASE и запустить изснаружи отладчик.

Вот мои результаты с моего компьютера с Windows 8 x64, использующего .Net 4.5 framework (хотя я получаю аналогичные результаты с .Net 4):

Times are in milliseconds

126 TestViaLoop()
441 TestViaListContains()

122 TestViaLoop()
428 TestViaListContains()

131 TestViaLoop()
431 TestViaListContains()

138 TestViaLoop()
426 TestViaListContains()

122 TestViaLoop()
439 TestViaListContains()

Как вы можете видеть, цикл занимает около 1/3 времени в моей системе.

Теперь, если мы используемResharper смотреть на реализациюList.Contains() это выглядит так:

bool Contains(T item)
{
    if (item == null)
    {
        for (int j = 0x0; j < this._size; j++)
        {
            if (this._items[j] == null)
            {
                return true;
            }
        }
        return false;
    }
    EqualityComparer<T> comparer = EqualityComparer<T>.Default;
    for (int i = 0x0; i < this._size; i++)
    {
        if (comparer.Equals(this._items[i], item))
        {
            return true;
        }
    }
    return false;
}

Хотя он используетComparer.Equals() (что должно сделать это медленнее, чем цикл), он также использует частный_items[] непосредственно к массиву, что позволяет избежать проверки диапазона индекса, который будет использоваться для реализации моего цикла.

У меня три вопроса:

Кто-нибудь еще может повторить результаты, которые я вижу? (Не забудьте запустить сборку релиза вне отладчика.)Если так, кто-нибудь может объяснить, как мой цикл может быть намного быстрее, чемList.Contains()?Если нет, может кто-нибудь объяснить, почему я вижу, что мой цикл будет быстрее?

Это не просто академический интерес для меня, так как я пишу код, который работает с большими объемами числовых данных и должен быть максимально быстрым, и это то, о чем мне нужно знать. (Примечание: да, я профилирую вещи и пытаюсь оптимизировать только то, что нужно оптимизировать ... Я знаю о проблемах преждевременной оптимизации.)

[РЕДАКТИРОВАТЬ]

Мне приходит в голову, что это может быть связано с процессором. Все системы, на которых я это пробовал, имеют процессоры Intel, хотя и очень разных моделей: от Quad Core с частотой 3,8 ГГц до одноядерного процессора Pentium M с частотой 1,6 ГГц ...

Для тех из вас, кто видит, что цикл работает медленнее, вы используете процессоры Intel?

Ответы на вопрос(2)

Ваш ответ на вопрос