MoveNext/Current 型列挙と TryMoveNext の比較

IFastEnumerator.cs

using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.CompilerServices;

/// <summary>
/// MoveNext/Current で2回 virtual call するのが嫌で、1つにまとめようというもの。
///
/// <typeparamref name="T"/> の共変性を確保するために、戻り値が T で out の方が bool になってしまう。
/// なので結構使い勝手は悪い。
/// out 引数とか、タプルを使った (T, bool) で共変性を担保できないっていう .NET の問題。
/// </summary>
interface IFastEnumerator<out T>
{
    T TryMoveNext(out bool success);
}

/// <summary>
/// <see cref="IEnumerable{T}"/> 同様、<see cref="IFastEnumerator{T}"/> を返すだけのインターフェイスも。
/// ただ、今回のベンチマークでは enumerator の方だけパフォーマンスを見るんで、こいつは使ってない。
/// </summary>
interface IFastEnumerable<out T>
{
    IFastEnumerator<T> GetEnumerator();
}

/// <summary>
/// <see cref="IEnumerator{T}"/> 実装。
/// 単に配列を列挙。
/// <see cref="Array.GetEnumerator"/> を呼ぶのでもいいんだけど、比較のために自作。
/// パフォーマンス優先でチェックをさぼってる。MoveNext を int がオーバーフローするまで呼ぶと MoveNext が再び true を返すようになるけど、そんな使い方はしないという前提。
/// </summary>
class NormalEnumerator : IEnumerator<int>
{
    private readonly int[] _data;
    public NormalEnumerator(int[] data) => _data = data;

    private int _i = -1;

    public int Current => _data[_i];
    public bool MoveNext() => ++_i < _data.Length;

    object IEnumerator.Current => Current;
    public void Dispose() { }
    public void Reset() => throw new NotImplementedException();
}

/// <summary>
/// <see cref="NormalEnumerator"/> と同じことを <see cref="IFastEnumerator{T}"/> で実装。
/// </summary>
class FastEnumerator : IFastEnumerator<int>
{
    private readonly int[] _data;
    public FastEnumerator(int[] data) => _data = data;

    private int _i = -1;

    public int TryMoveNext(out bool success)
    {
        var i = ++_i;
        var data = _data;
        if((uint)i < (uint)data.Length)
        {
            success = true;
            return data[i];
        }
        else
        {
            success = false;
            return default;
        }
    }
}

/// <summary>
/// 配列に対する和の計算を、<see cref="NormalEnumerator"/> と <see cref="FastEnumerator"/> を介するのでどのくらい違うかを試す。
/// あと、具象型を渡す(non-virtual なのでインライン化を期待できる)と、インターフェイスを渡す(virtual なのでインライン化されない)でどのくらい差が付くかも試す。
///
/// 実行例:
///            Method |     Mean |    Error |   StdDev |
/// ----------------- |---------:|---------:|---------:|
///  NonVirtualNormal | 165.8 ns | 2.225 ns | 2.082 ns |
///    NonVirtualFast | 161.2 ns | 2.208 ns | 2.065 ns |
///     VirtualNormal | 449.6 ns | 2.595 ns | 2.300 ns |
///       VirtualFast | 271.3 ns | 2.338 ns | 2.072 ns |
///
/// non-virtual な場合(具象型を直接渡す場合)はどの道インライン化で最適化がかかるのでそんなに差が出ない。
///
/// 問題は virtual に呼んだ場合(インターフェイスを介して呼んだ)で、4割くらい差が出る。
/// 今回の場合、MoveNext/Current/TryMoveNext の呼び出し以外にやってることがほとんどないので、virtual call の負担の差がはっきりと出る(たぶん上限)。
/// あと、MoveNext/Current の場合、インデックスの範囲チェック(i &lt; length)とアクセス(data[i])がわかれることで、配列の最適化が効きにくくなってるはず。
/// </summary>
public class ForeachBenchmark
{
    int[] _data;

    [GlobalSetup]
    public void Setup()
    {
        _data = Enumerable.Range(0, 100).ToArray();
    }

    [Benchmark]
    public int NonVirtualNormal() => NonVirtualSum(new NormalEnumerator(_data));

    [Benchmark]
    public int NonVirtualFast() => NonVirtualSum(new FastEnumerator(_data));

    [Benchmark]
    public int VirtualNormal() => VirtualSum(new NormalEnumerator(_data));

    [Benchmark]
    public int VirtualFast() => VirtualSum(new FastEnumerator(_data));

    [MethodImpl(MethodImplOptions.NoInlining)]
    static int NonVirtualSum(NormalEnumerator e)
    {
        var sum = 0;
        while (e.MoveNext())
        {
            var x = e.Current;
            sum += x;
        }
        return sum;
    }

    [MethodImpl(MethodImplOptions.NoInlining)]
    static int NonVirtualSum(FastEnumerator e)
    {
        var sum = 0;
        while (true)
        {
            var x = e.TryMoveNext(out var success);
            if (!success) break;
            sum += x;
        }
        return sum;
    }

    [MethodImpl(MethodImplOptions.NoInlining)]
    static int VirtualSum(IEnumerator<int> e)
    {
        var sum = 0;
        while (e.MoveNext())
        {
            var x = e.Current;
            sum += x;
        }
        return sum;
    }

    [MethodImpl(MethodImplOptions.NoInlining)]
    static int VirtualSum(IFastEnumerator<int> e)
    {
        var sum = 0;
        while (true)
        {
            var x = e.TryMoveNext(out var success);
            if (!success) break;
            sum += x;
        }
        return sum;
    }
}

class Program
{
    static void Main()
    {
        BenchmarkRunner.Run<ForeachBenchmark>();
    }
}