性能：从泛型派生的类型

Question

我遇到了一个我不太理解的性能问题。我知道如何解决它，但我不明白为什么会这样。这只是为了好玩！
让我们谈谈代码。我尽可能地简化了代码以重现该问题。
假设我们有一个泛型类。它内部有一个空列表，并在构造函数中使用T 执行某些操作。它具有Run 方法，该方法调用列表中的IEnumerable<T> 方法，例如Any().

public class BaseClass<T>
{
    private List<T> _list = new List<T>();

    public BaseClass()
    {
        Enumerable.Empty<T>();
        // or Enumerable.Repeat(new T(), 10);
        // or even new T();
        // or foreach (var item in _list) {}
    }

    public void Run()
    {
        for (var i = 0; i < 8000000; i++)
        {
            if (_list.Any())
            // or if (_list.Count() > 0)
            // or if (_list.FirstOrDefault() != null)
            // or if (_list.SingleOrDefault() != null)
            // or other IEnumerable<T> method
            {
                return;
            }
        }
    }
}

然后我们有一个空的派生类：

public class DerivedClass : BaseClass<object>
{
}

让我们测量从两个类中运行ClassBase<T>.Run 方法的性能。从派生类型访问比从基类访问慢 4 倍。我不明白为什么会这样。在 Release 模式下编译，结果与 warm up 相同。它仅发生在 .NET 4.5 上。

public class Program
{
    public static void Main()
    {
        Measure(new DerivedClass());
        Measure(new BaseClass<object>());
    }

    private static void Measure(BaseClass<object> baseClass)
    {
        var sw = Stopwatch.StartNew();
        baseClass.Run();
        sw.Stop();
        Console.WriteLine(sw.ElapsedMilliseconds);
    }
}

完整列表on gist

Answer 1

更新：
CLR 团队在Microsoft Connect

上提供了答案

它与共享泛型代码中的字典查找有关。运行时的启发式和 JIT 不适用于这个特定的测试。我们将看看可以做些什么。

与此同时，您可以通过向 BaseClass 添加两个虚拟方法（甚至不需要调用）来解决它。它将使启发式算法按预期工作。

原文：
那是 JIT 失败。

可以被这个疯狂的东西修复：

    public class BaseClass<T>
    {
        private List<T> _list = new List<T>();

        public BaseClass()
        {
            Enumerable.Empty<T>();
            // or Enumerable.Repeat(new T(), 10);
            // or even new T();
            // or foreach (var item in _list) {}
        }

        public void Run()
        {
            for (var i = 0; i < 8000000; i++)
            {
                if (_list.Any())
                {
                    return;
                }
            }
        }

        public void Run2()
        {
            for (var i = 0; i < 8000000; i++)
            {
                if (_list.Any())
                {
                    return;
                }
            }
        }

        public void Run3()
        {
            for (var i = 0; i < 8000000; i++)
            {
                if (_list.Any())
                {
                    return;
                }
            }
        }
    }

请注意，Run2()/Run3() 不会从任何地方调用。但是如果你注释掉 Run2 或 Run3 方法 - 你会像以前一样受到性能损失。

我猜这与堆栈对齐或方法表的大小有关。

附：你可以替换

 Enumerable.Empty<T>();
 // with
 var x = new Func<IEnumerable<T>>(Enumerable.Empty<T>);

还是同样的错误。

Answer 2

经过一番实验，发现Enumerable.Empty<T>在T为class类型时总是很慢；如果它是一个值类型，它会更快，但取决于结构大小。 我测试了对象、字符串、int、PointF、RectangleF、DateTime、Guid。

看看它是如何实现的，我尝试了不同的替代方案，并找到了一些运行速度很快的替代方案。

Enumerable.Empty<T> 依赖于内部类EmptyEnumerable<TElement> 的Instance 静态属性。

该属性只做一些小事：

• 检查私有静态 volatile 字段是否为空。
• 将一个空数组分配给该字段一次（仅当为空时）。
• 返回字段的值。

那么，Enumerable.Empty<T> 真正要做的只是返回一个空的 T 数组。

尝试不同的方法，我发现缓慢是由 both property 和 volatile 修饰符引起的。

采用初始化为 T[0] 的静态字段，而不是 Enumerable.Empty<T> 之类的

public static readonly T[] EmptyArray = new T[0];

问题消失了。 请注意，只读修饰符不是决定性的。 使用 volatile 声明或通过 property 访问相同的静态字段会导致问题。

问候， 丹尼尔。

Answer 3

似乎存在 CLR 优化器问题。关闭“构建”选项卡上的“优化代码”并尝试再次运行测试。