2

出于某种奇怪的原因，这个泛型方法不会被内联到另一个方法中，除非另一个方法包含一个循环。什么可以解释这种奇怪的行为？对于非泛型方法，内联在两种情况下都会发生，无论有无循环。

代码：

using System;
using System.Runtime.CompilerServices;
using SharpLab.Runtime;

[JitGeneric(typeof(int))]
public static class GenericOps<T> where T : unmanaged
{
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public static bool Less(T left, T right)
    {
        if (typeof(T) == typeof(byte)) return (byte)(object)left < (byte)(object)right;
        if (typeof(T) == typeof(sbyte)) return (sbyte)(object)left < (sbyte)(object)right;
        if (typeof(T) == typeof(ushort)) return (ushort)(object)left < (ushort)(object)right;
        if (typeof(T) == typeof(short)) return (short)(object)left < (short)(object)right;
        if (typeof(T) == typeof(uint)) return (uint)(object)left < (uint)(object)right;
        if (typeof(T) == typeof(int)) return (int)(object)left < (int)(object)right;
        if (typeof(T) == typeof(ulong)) return (ulong)(object)left < (ulong)(object)right;
        if (typeof(T) == typeof(long)) return (long)(object)left < (long)(object)right;
        if (typeof(T) == typeof(float)) return (float)(object)left < (float)(object)right;
        if (typeof(T) == typeof(double)) return (double)(object)left < (double)(object)right;
        return default;
    }
}

[JitGeneric(typeof(int))]
public static class C<T> where T : unmanaged
{      
    public static bool M1(T a, T b)
    {
        return GenericOps<T>.Less(a, b);      
    }
        
    public static bool M2(T a, T b)
    {
        for(int i = 0; i<0; i++) {}
            
        return GenericOps<T>.Less(a, b);    
    }        
}

JIT：（使用 SharpLab 反编译）

// All the type checks are omitted since the type is known during compile time
// This generated JIT equals to a direct int < int JIT.
GenericOps`1[[System.Int32, System.Private.CoreLib]].Less(Int32, Int32)
    L0000: cmp ecx, edx
    L0002: setl al
    L0005: movzx eax, al
    L0008: ret

// No Inlining
C`1[[System.Int32, System.Private.CoreLib]].M1(Int32, Int32)
    L0000: mov rax, GenericOps`1[[System.Int32, System.Private.CoreLib]].Less(Int32, Int32)
    L000a: jmp rax

// Direct Inline
C`1[[System.Int32, System.Private.CoreLib]].M2(Int32, Int32) // Direct Inline
    L0000: cmp ecx, edx
    L0002: setl al
    L0005: movzx eax, al
    L0008: ret

要点：

  • 奇怪的是，C.M1()即使它使生成的 JIT 大小更小，它也不会内联方法调用——我也用不同的方法进行了测试。
  • 这种奇怪的行为只有在方法是泛型时才会发生，它总是内联直接的非泛型实现。
  • 它与泛型方法中的类型切换有关。如果泛型方法不包含这些类型开关，那么只要方法很短，即使没有属性，它也会在两种情况下（M1和）都被内联。M2AggressiveInlining
  • 循环启动了一些启发式方法，导致内联发生。

这个例子提出的问题是：

  • 这种行为是故意的还是一个错误？
  • 有没有办法保证方法的内联Less()，而不在调用者方法中使用奇怪的循环？
  • 这种行为是否也发生在System.Numerics.Vector<T>类中，因为它使用了相同的通用类型开关，这些开关已经被优化掉了？
4

1 回答 1

3

鉴于这是在 中修复的.NET 5，我将其称为错误。在SharpLab中通过以下.NET版本验证：

  • x64 (.NET 5) -内联
  • x86 上的核心 CLR v5.0.321.7212 -内联
  • x86/amd64 上的桌面 CLR v4.8.4261.00 - 未内联
  • x86 上的核心 CLR v4.700.20.20201 - 未内联
  • x86 上的核心 CLR v4.700.19.46205 - 未内联

所以，回答你的问题：

  1. 是的，这很可能是一个错误。
  2. 你不能保证内联。尤其不是<T>类型。规则/启发式可能非常复杂。
  3. 答案的线索可以在这里看到。Microsoft 非常了解 JIT，因此如果像这样的高性能类Vector<T>会遇到内联问题，那就有点令人惊讶了。
于 2021-03-03T12:04:44.137 回答