【C#】抽象メソッドをインライン化する

# はじめに

インターフェイスのメソッド呼び出しはコンパイル時に呼び出されるメソッド（型）は決定せず、実行時に決定します。これは一般的にメソッドのインライン化がされないため、パフォーマンス面でほんのちょっぴり不利です。

値型ジェネリックを使うとインライン化が効く <https://ufcpp.net/study/csharp/sp2_generics.html?p=3#pseudo-static>

↑ によれば、値型のジェネリックを使うとインライン化されます。

```cs
interface IWork
{
    int GetNumber(int number);
}

struct StructWork : IWork
{
    public readonly int GetNumber(int number) => number;
}

static int SumNumbers<T>(ReadOnlySpan<int> numbers, T work) where T : IWork
{
    int sum = 0;
    foreach (var n in numbers)
        sum += work.GetNumber(n);

    return sum;
}

SumNumbers([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], default(StructWork));
```

これは**値型のジェネリック**は実行時その型専用のメソッドを作るのでインライン化されるという仕組みです（参照型のジェネリックはひとつだけメソッドが作られ使い回す）。

## サンプルコード

<details>
<summary>テストコード</summary>

```cs
using System.Runtime.CompilerServices;
using Xunit;

public class __GenericInliningTest
{
    interface IWork
    {
        int GetNumber(int number);
    }

    class ClassWork : IWork
    {
        public int GetNumber(int number) => number;
    }

    class NoInliningWork : IWork
    {
        [MethodImpl(MethodImplOptions.NoInlining)]
        public int GetNumber(int number) => number;
    }

    struct StructWork : IWork
    {
        public readonly int GetNumber(int number) => number;
    }

    static int SumNumbersInterface(ReadOnlySpan<int> numbers, IWork work)
    {
        int sum = 0;
        foreach (var n in numbers)
            sum += work.GetNumber(n);

        return sum;
    }

    static int SumNumbers<T>(ReadOnlySpan<int> numbers, T work) where T : IWork
    {
        int sum = 0;
        foreach (var n in numbers)
            sum += work.GetNumber(n);

        return sum;
    }

    static void InterfacePerformance(Performance p)
    {
        var noInliningWork = new NoInliningWork();
        p.AddTest("NoInlining", () =>
        {
            var sum = 0;
            for (var n = 0; n < 10000; n++)
                sum += SumNumbersInterface([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], noInliningWork);
        });

        var classWork = new ClassWork();
        p.AddTest("Class", () =>
        {
            var sum = 0;
            for (var n = 0; n < 10000; n++)
                sum += SumNumbersInterface([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], classWork);
        });

        IWork structWork = new StructWork();
        p.AddTest("Struct", () =>
        {
            var sum = 0;
            for (var n = 0; n < 10000; n++)
                sum += SumNumbersInterface([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], structWork);
        });
    }

    static void InliningPerformance(Performance p)
    {
        var noInliningWork = new NoInliningWork();
        p.AddTest("NoInlining", () =>
        {
            var sum = 0;
            for (var n = 0; n < 10000; n++)
                sum += SumNumbers([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], noInliningWork);
        });

        var classWork = new ClassWork();
        p.AddTest("Class", () =>
        {
            var sum = 0;
            for (var n = 0; n < 10000; n++)
                sum += SumNumbers([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], classWork);
        });

        p.AddTest("Struct", () =>
        {
            var sum = 0;
            for (var n = 0; n < 10000; n++)
                sum += SumNumbers([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], default(StructWork));
        });
    }

    static void InliningPerformance2(Performance p)
    {
        var noInliningWork = new NoInliningWork();
        p.AddTest("NoInlining", () =>
        {
            var sum = 0;
            for (var n = 0; n < 1000000; n++)
                sum += SumNumbers([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], noInliningWork);
        });

        var classWork = new ClassWork();
        p.AddTest("Class", () =>
        {
            var sum = 0;
            for (var n = 0; n < 1000000; n++)
                sum += SumNumbers([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], classWork);
        });

        p.AddTest("Struct", () =>
        {
            var sum = 0;
            for (var n = 0; n < 1000000; n++)
                sum += SumNumbers([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], default(StructWork));
        });
    }

    static T Sum<T>(ReadOnlySpan<T> values) where T : struct, System.Numerics.IAdditionOperators<T, T, T>, System.Numerics.INumberBase<T>
    {
        T result = T.Zero;
        foreach (var value in values)
            result += value;

        return result;
    }

    [Fact]
    void SumTest()
    {
        Assert.Equal(10, Sum([1, 2, 3, 4]));
        Assert.Equal(12f, Sum([1.5f, 2.5f, 3.5f, 4.5f]));
    }
}
```

</details>

## パフォーマンス比較

```cs
var noInliningWork = new NoInliningWork();
p.AddTest("NoInlining", () =>
{
    var sum = 0;
    for (var n = 0; n < 1000000; n++)
        sum += SumNumbers([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], noInliningWork);
});

var classWork = new ClassWork();
p.AddTest("Class", () =>
{
    var sum = 0;
    for (var n = 0; n < 1000000; n++)
        sum += SumNumbers([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], classWork);
});

p.AddTest("Struct", () =>
{
    var sum = 0;
    for (var n = 0; n < 1000000; n++)
        sum += SumNumbers([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], default(StructWork));
});
```

|Test|Score|%|GC0|
|---|---:|---:|---:|
|**x64**||||
|NoInlining|285|100.0%|0|
|Class|529|185.6%|0|
|Struct|1,079|**378.6%**|0|

実行環境: Windows11 x64 .NET Runtime 10.0.0  
**Score** は高いほどパフォーマンスがよいです。  
**GC0** はガベージコレクション回数を表します（少ないほどパフォーマンスがよい）。

- インライン化しない版との比較です
- 値型はインライン化され高速です
- 参照型もちょっとインライン化されてね？ -> 段階コンパイル (Tiered Compilation) <https://ufcpp.net/blog/2018/12/tieredcompilation/>

## 数値型のインターフェイス

.NET Framework 時代は `1 + 1` のような数値計算は、すべての組み込み型のオーバーロードを用意する必要がありました。  
今は `System.Numerics` 名前空間に `IAdditionOperators` のような、数値計算用のインターフェイスが用意されており、ジェネリックにできます。

```cs
static T Sum<T>(ReadOnlySpan<T> values)
  where T : struct, System.Numerics.IAdditionOperators<T, T, T>,
  System.Numerics.INumberBase<T>
{
    T result = T.Zero;
    foreach (var value in values)
        result += value;

    return result;
}
```

.NET になってからインターフェイスの拡張がありましたので、この辺の導入に至ったわけです。

参考：C# の静的メンバー <https://ufcpp.net/study/csharp/oo_interface.html?p=5#static-member>

## おわりに

このテクニックはかなりマニアックなもので、自分は実践で使ったことはないです。  
近年はランタイム最適化によって、よく使うメソッドはインライン化されるようで（前述の段階コンパイル <https://ufcpp.net/blog/2018/12/tieredcompilation/>）、プログラマが意識して最適化する必要はなくなりつつあります。  
とはいえ現時点では最速っぽいので、どうしてもパフォーマンスが必要なときの飛び道具になりそうです。