Разница в производительности между C # for-loop и Array.Fill

Question

Я реализовал следующий тест, используя BenchmarkDotNet:

public class ForVsFillVsEnumerable
{
    private bool[] data;

    [Params(10, 100, 1000)]
    public int N;

    [GlobalSetup]
    public void Setup()
    {
        data = new bool[N];
    }

    [Benchmark]
    public void Fill()
    {
        Array.Fill(data, true);
    }

    [Benchmark]
    public void For()
    {           
        for (int i = 0; i < data.Length; i++)
        {
            data[i] = true;
        }
    }

    [Benchmark]
    public void EnumerableRepeat()
    {
        data = Enumerable.Repeat(true, N).ToArray();
    }
}

Результаты:

BenchmarkDotNet=v0.11.3, OS=Windows 10.0.17763.195 (1809/October2018Update/Redstone5)
Intel Core i7-8700K CPU 3.70GHz (Coffee Lake), 1 CPU, 12 logical and 6 physical cores
.NET Core SDK=2.2.200-preview-009648
  [Host] : .NET Core 2.2.0 (CoreCLR 4.6.27110.04, CoreFX 4.6.27110.04), 64bit RyuJIT
  Core   : .NET Core 2.2.0 (CoreCLR 4.6.27110.04, CoreFX 4.6.27110.04), 64bit RyuJIT

Job=Core  Runtime=Core
           Method |    N |       Mean |      Error |      StdDev |     Median | Ratio | Rank |
----------------- |----- |-----------:|-----------:|------------:|-----------:|------:|-----:|
             Fill |   10 |   3.675 ns |  0.2550 ns |   0.7150 ns |   3.331 ns |  1.00 |    1 |
                  |      |            |            |             |            |       |      |
              For |   10 |   6.615 ns |  0.3928 ns |   1.1581 ns |   6.056 ns |  1.00 |    1 |
                  |      |            |            |             |            |       |      |
 EnumerableRepeat |   10 |  25.388 ns |  1.0451 ns |   2.9307 ns |  24.170 ns |  1.00 |    1 |
                  |      |            |            |             |            |       |      |
             Fill |  100 |  50.557 ns |  2.0766 ns |   6.1229 ns |  46.690 ns |  1.00 |    1 |
                  |      |            |            |             |            |       |      |
              For |  100 |  64.330 ns |  4.0058 ns |  11.8111 ns |  59.442 ns |  1.00 |    1 |
                  |      |            |            |             |            |       |      |
 EnumerableRepeat |  100 |  81.784 ns |  4.2407 ns |  12.5039 ns |  75.937 ns |  1.00 |    1 |
                  |      |            |            |             |            |       |      |
             Fill | 1000 | 447.016 ns | 15.4420 ns |  45.5312 ns | 420.239 ns |  1.00 |    1 |
                  |      |            |            |             |            |       |      |
              For | 1000 | 589.243 ns | 51.3450 ns | 151.3917 ns | 495.177 ns |  1.00 |    1 |
                  |      |            |            |             |            |       |      |
 EnumerableRepeat | 1000 | 519.124 ns | 21.3580 ns |  62.9746 ns | 505.573 ns |  1.00 |    1 |

Изначально я догадывался, что Array.Fill выполняет некоторые оптимизации, благодаря которым он работает лучше, чем for -loop, но затем я проверил исходный код. NET Core , чтобы убедиться, что реализация Array.Fill довольно просто:

public static void Fill<T>(T[] array, T value)
{
    if (array == null)
    {
        ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
    }

    for (int i = 0; i < array.Length; i++)
    {
        array[i] = value;
    }
}

Производительность достаточно близка, но все равно кажется, что Fill неизменно немного быстрее, чем for, хотя под капотом он точно такой же код. Вы можете объяснить, почему? Или я просто неправильно читаю результаты?

Answer 1

Я удивлен Enumerable.Repeat(), в отличие от моей первой мысли, что она довольно хорошо масштабируется. В любом случае, чтобы ответить на ваш вопрос: когда вы используете For(), вы неоднократно обращаетесь к члену класса, а при вызове Array.Fill() вы получаете его адрес только один раз.

Я даже больше удивлен, что компилятор не обнаруживает и не оптимизирует это, но для чтения значения члена класса вам нужно ldarg.0, чтобы получить значение this, а затем ldfld ForVsFillVsEnumerable.data, чтобы получить его фактическое значение. адрес. В ForVsFillVsEnumerable.Fill() это делается только один раз для вызова Array.Fill().

Вы можете проверить это, написав собственную функцию заполнения:

[Benchmark]
public void For2()
{
    ForImpl(data);
}

private static void ForImpl(bool[] data)
{
    for (int i = 0; i < data.Length; i++)
    {
        data[i] = true;
    }
}

Примечание 1: независимо от производительности, использовать библиотечную функцию всегда лучше, потому что она может потенциально извлечь выгоду из будущих оптимизаций (они могут решить, например, добавить определенные перегрузки для Array.Fill() и реализовать их с собственным кодом, где - для некоторых архитектур - просто memset() очень быстро).

Примечание 2: если код цикла настолько мал (и быстр), я бы не стал измерять что-либо маленькими векторами (10 или 100 элементов), потому что крайне трудно настроить правильную среду тестирования для надежного измерения разницы в несколько наносекунд , Я бы посчитал 1000 (или даже 100 000) самым минимальным для начала (и даже в этом случае очень много других вещей будут играть соответствующую роль ...) Если ваш реальный сценарий использования не равен 10/100 ... в в этом случае я бы попытался измерить больший алгоритм, где эта разница более очевидна (а если нет, то вам все равно).