c# - C# 中的泛型与非泛型性能

Question

我写了两种等效的方法：

static bool F<T>(T a, T b) where T : class
{
    return a == b;
}

static bool F2(A a, A b)
{
    return a == b;
}

时差：
00:00:00.0380022
00:00:00.0170009

测试代码：

var a = new A();
for (int i = 0; i < 100000000; i++)
    F<A>(a, a);
Console.WriteLine(DateTime.Now - dt);

dt = DateTime.Now;
for (int i = 0; i < 100000000; i++)
    F2(a, a);
Console.WriteLine(DateTime.Now - dt);

有谁知道为什么？

在下面的评论中，dtb*显示CIL：

IL for F2: ldarg.0, ldarg.1, ceq, ret. IL for F<T>: ldarg.0, box !!T, ldarg.1, box !!T, ceq, ret.

我认为这是我问题的答案，但我可以用什么魔法来拒绝拳击？

接下来我使用Psilon的代码：

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;

namespace ConsoleApplication58
{
    internal class Program
    {
        private class A
        {

        }

        private static bool F<T>(T a, T b) where T : class
        {
            return a == b;
        }

        private static bool F2(A a, A b)
        {
            return a == b;
        }

        private static void Main()
        {
            const int rounds = 100, n = 10000000;
            var a = new A();
            var fList = new List<TimeSpan>();
            var f2List = new List<TimeSpan>();
            for (int i = 0; i < rounds; i++)
            {
                // Test generic
                GCClear();
                bool res;
                var sw = new Stopwatch();
                sw.Start();
                for (int j = 0; j < n; j++)
                {
                    res = F(a, a);
                }
                sw.Stop();
                fList.Add(sw.Elapsed);

                // Test not-generic
                GCClear();
                bool res2;
                var sw2 = new Stopwatch();
                sw2.Start();
                for (int j = 0; j < n; j++)
                {
                    res2 = F2(a, a);
                }
                sw2.Stop();
                f2List.Add(sw2.Elapsed);
            }
            double f1AverageTicks = fList.Average(ts => ts.Ticks);
            Console.WriteLine("Elapsed for F = {0} \t ticks = {1}", fList.Average(ts => ts.TotalMilliseconds),
                              f1AverageTicks);
            double f2AverageTicks = f2List.Average(ts => ts.Ticks);
            Console.WriteLine("Elapsed for F2 = {0} \t ticks = {1}", f2List.Average(ts => ts.TotalMilliseconds),
                  f2AverageTicks);
            Console.WriteLine("Not-generic method is {0} times faster, or on {1}%", f1AverageTicks/f2AverageTicks,
                              (f1AverageTicks/f2AverageTicks - 1)*100);
            Console.ReadKey();
        }

        private static void GCClear()
        {
            GC.Collect();
            GC.WaitForPendingFinalizers();
            GC.Collect();
        }
    }
}

Windows 7、.NET 4.5、Visual Studio 2012，发布，优化，无需附加。

x64

Elapsed for F = 23.68157         ticks = 236815.7
Elapsed for F2 = 1.701638        ticks = 17016.38
Not-generic method is 13.916925926666 times faster, or on 1291.6925926666%

x86

Elapsed for F = 6.713223         ticks = 67132.23
Elapsed for F2 = 6.729897        ticks = 67298.97
Not-generic method is 0.997522398931217 times faster, or on -0.247760106878314%

而且我有了新的魔力：x64 速度快了三倍……

PS：我的目标平台是 x64。

score 27 · Accepted Answer

我确实对您的代码进行了一些更改以正确测量性能。

使用秒表
执行释放模式
防止内联。
使用 GetHashCode() 做一些实际的工作
查看生成的汇编代码

这是代码：

class A
{
}

[MethodImpl(MethodImplOptions.NoInlining)]
static bool F<T>(T a, T b) where T : class
{
    return a.GetHashCode() == b.GetHashCode();
}

[MethodImpl(MethodImplOptions.NoInlining)]
static bool F2(A a, A b)
{
    return a.GetHashCode() == b.GetHashCode();
}

static int Main(string[] args)
{
    const int Runs = 100 * 1000 * 1000;
    var a = new A();
    bool lret = F<A>(a, a);
    var sw = Stopwatch.StartNew();
    for (int i = 0; i < Runs; i++)
    {
        F<A>(a, a);
    }
    sw.Stop();
    Console.WriteLine("Generic: {0:F2}s", sw.Elapsed.TotalSeconds);

    lret = F2(a, a);
    sw = Stopwatch.StartNew();
    for (int i = 0; i < Runs; i++)
    {
        F2(a, a);
    }
    sw.Stop();
    Console.WriteLine("Non Generic: {0:F2}s", sw.Elapsed.TotalSeconds);

    return lret ? 1 : 0;
}

在我的测试中，非通用版本稍微快一些（.NET 4.5 x32 Windows 7）。但在速度上几乎没有可测量的差异。我会说两者都是平等的。为了完整起见，这里是通用版本的汇编代码：我通过调试器在 Release 模式下获得了汇编代码，并启用了 JIT 优化。默认是在调试期间禁用 JIT 优化，以使设置断点和变量检查更容易。

通用的

static bool F<T>(T a, T b) where T : class
{
        return a.GetHashCode() == b.GetHashCode();
}

push        ebp 
mov         ebp,esp 
push        ebx 
sub         esp,8 // reserve stack for two locals 
mov         dword ptr [ebp-8],ecx // store first arg on stack
mov         dword ptr [ebp-0Ch],edx // store second arg on stack
mov         ecx,dword ptr [ebp-8] // get first arg from stack --> stupid!
mov         eax,dword ptr [ecx]   // load MT pointer from a instance
mov         eax,dword ptr [eax+28h] // Locate method table start
call        dword ptr [eax+8] //GetHashCode // call GetHashCode function pointer which is the second method starting from the method table
mov         ebx,eax           // store result in ebx
mov         ecx,dword ptr [ebp-0Ch] // get second arg
mov         eax,dword ptr [ecx]     // call method as usual ...
mov         eax,dword ptr [eax+28h] 
call        dword ptr [eax+8] //GetHashCode
cmp         ebx,eax 
sete        al 
movzx       eax,al 
lea         esp,[ebp-4] 
pop         ebx 
pop         ebp 
ret         4

非通用

static bool F2(A a, A b)
{
  return a.GetHashCode() == b.GetHashCode();
}

push        ebp 
mov         ebp,esp 
push        esi 
push        ebx 
mov         esi,edx 
mov         eax,dword ptr [ecx] 
mov         eax,dword ptr [eax+28h] 
call        dword ptr [eax+8] //GetHashCode
mov         ebx,eax 
mov         ecx,esi 
mov         eax,dword ptr [ecx] 
mov         eax,dword ptr [eax+28h] 
call        dword ptr [eax+8] //GetHashCode
cmp         ebx,eax 
sete        al 
movzx       eax,al 
pop         ebx 
pop         esi 
pop         ebp 
ret

正如您所看到的，由于更多的堆栈内存操作并不完美，通用版本看起来效率略低，但实际上差异无法衡量，因为所有内容都适合处理器的 L1 缓存，这使得内存操作的成本低于非通用版本的纯寄存器操作。如果您需要为不来自任何 CPU 缓存的真实内存访问付费，我怀疑非通用版本在现实世界中的性能应该会好一些。

出于所有实际目的，这两种方法都是相同的。您应该查看其他地方以获得真实世界的性能提升。我将首先查看数据访问模式和使用的数据结构。算法变化往往比这种低级的东西带来更多的性能增益。

Edit1：如果你想使用 == 那么你会发现

00000000  push        ebp 
00000001  mov         ebp,esp 
00000003  cmp         ecx,edx // Check for reference equality 
00000005  sete        al 
00000008  movzx       eax,al 
0000000b  pop         ebp 
0000000c  ret         4

这两种方法都产生完全相同的机器代码。您测量的任何差异都是您的测量误差。

score 7 · Accepted Answer

你的测试方法有缺陷。你是怎么做的有几个大问题。

首先，您没有提供“热身”。在 .NET 中，您第一次访问某些内容时会比后续调用慢，因此它可以加载任何需要的程序集。如果您要执行这样的测试，您必须至少执行每个功能一次，否则第一次运行的测试将受到很大的惩罚。继续并交换订单，您可能会看到相反的结果。

SecondDateTime仅精确到 16ms，因此在比较两次时，您的 +/- 误差为 32 ms。两个结果之间的差异为 21 ms，完全在实验误差范围内。您必须使用更准确的计时器，例如Stopwatch类。

最后，不要做这样的人为测试。除了吹嘘某一类或另一类的权利之外，它们不会向您显示任何有用的信息。而是学习使用Code Profiler。这将向您展示是什么降低了您的代码速度，您可以就如何解决问题做出明智的决定，而不是“猜测”不使用模板化类会使您的代码更快。

这是一个示例代码，显示了它“应该”如何完成：

using System;
using System.Diagnostics;

namespace Sandbox_Console
{
    class A
    {
    }

    internal static class Program
    {
        static bool F<T>(T a, T b) where T : class
        {
            return a == b;
        }

        static bool F2(A a, A b)
        {
            return a == b;
        }

        private static void Main()
        {
            var a = new A();
            Stopwatch st = new Stopwatch();

            Console.WriteLine("warmup");
            st.Start();
            for (int i = 0; i < 100000000; i++)
                F<A>(a, a);
            Console.WriteLine(st.Elapsed);

            st.Restart();
            for (int i = 0; i < 100000000; i++)
                F2(a, a);
            Console.WriteLine(st.Elapsed);

            Console.WriteLine("real");
            st.Restart();
            for (int i = 0; i < 100000000; i++)
                F<A>(a, a);
            Console.WriteLine(st.Elapsed);

            st.Restart();
            for (int i = 0; i < 100000000; i++)
                F2(a, a);
            Console.WriteLine(st.Elapsed);

            Console.WriteLine("Done");
            Console.ReadLine();
        }

    }
}

结果如下：

warmup
00:00:00.0297904
00:00:00.0298949
real
00:00:00.0296838
00:00:00.0297823
Done

交换最后两个的顺序，第一个总是更短，所以实际上它们是“相同的时间”，因为它在实验误差内。

score 6 · Accepted Answer

停止担心时间，担心正确性。

这些方法是不等价的。其中一种使用class A's operator==，另一种使用object's operator==。

score 3 · Accepted Answer

两件事情：

您正在使用DateTime.Now. 改为使用Stopwatch。
您正在运行不在正常情况下的代码。JIT 最有可能影响第一次运行，使您的第一个方法变慢。

如果您切换测试顺序（即先测试非泛型方法），您的结果会反转吗？我会怀疑的。当我将您的代码插入到LINQPad中，然后将其复制以便它运行两次测试时，第二次迭代的执行时间彼此相差几百个滴答声。

所以，回答你的问题：是的，有人知道为什么。这是因为您的基准不准确！

score 3 · Accepted Answer

我重写了你的测试代码：

var stopwatch = new Stopwatch();
var a = new A();

stopwatch.Reset();
stopwatch.Start();
for (int i = 0; i < 100000000; i++)
    F<A>(a, a);
stopwatch.Stop();
Console.WriteLine(stopwatch.ElapsedMilliseconds);

stopwatch.Reset();
stopwatch.Start();
for (int i = 0; i < 100000000; i++)
    F2(a, a);
stopwatch.Stop();
Console.WriteLine(stopwatch.ElapsedMilliseconds);

交换订单不会改变任何事情。

通用方法的CIL ：

L_0000: nop
L_0001: ldarg.0
L_0002: box !!T
L_0007: ldarg.1
L_0008: box !!T
L_000d: ceq
L_000f: stloc.0
L_0010: br.s L_0012
L_0012: ldloc.0
L_0013: ret

对于非泛型：

L_0000: nop
L_0001: ldarg.0
L_0002: ldarg.1
L_0003: ceq
L_0005: stloc.0
L_0006: br.s L_0008
L_0008: ldloc.0
L_0009: ret

所以拳击操作是你时差的原因。问题是为什么要加装箱操作。检查它，堆栈溢出问题 拳击在 C# 中使用泛型时

score 2 · Accepted Answer

在我的职业生涯中，我曾多次以专业身份进行过绩效分析，并有一些观察。

首先，测试太短而无法有效。我的经验法则是性能测试应该运行 30 分钟左右。
其次，重要的是要多次运行测试，以获得一系列时间。
第三，我很惊讶编译器没有优化循环，因为没有使用函数结果并且被调用的函数没有副作用。
第四，微观基准往往具有误导性。

我曾经在一个有一个大胆的性能目标的编译器团队工作。一个版本引入了一种优化，消除了特定序列的几条指令。它本应提高性能，但一个基准测试的性能却急剧下降。我们在具有直接映射缓存的硬件上运行。事实证明，循环的代码和内部循环中调用的函数占用了相同的缓存行，新的优化已经到位，但之前生成的代码没有。换句话说，该基准实际上是一个内存基准，并且完全依赖于内存缓存命中和未命中，而作者认为他们编写了一个计算基准。

score 1 · Accepted Answer

我认为这是我问题的答案，但我可以用什么魔法来拒绝拳击？

如果您的目标只是比较，您可以这样做：

    public class A : IEquatable<A> {
        public bool Equals( A other ) { return this == other; }
    }
    static bool F<T>( IEquatable<T> a, IEquatable<T> b ) where T : IEquatable<T> {
        return a==b;
    }

这将避免拳击。

至于主要的计时偏差，我想每个人都已经确定你如何设置秒表存在问题。我使用了一种不同的技术，如果我想从时间结果中删除循环本身，我会取一个空基线，然后从时间差中减去它。它并不完美，但它产生了一个公平的结果，并且一遍又一遍地启动和停止计时器并不会减慢速度。

score 1 · Accepted Answer

这似乎更公平，不是吗？：D

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;

namespace ConsoleApplication58
{
    internal class Program
    {
        private class A
        {

        }

        private static bool F<T>(T a, T b) where T : class
        {
            return a == b;
        }

        private static bool F2(A a, A b)
        {
            return a == b;
        }

        private static void Main()
        {
            const int rounds = 100, n = 10000000;
            var a = new A();
            var fList = new List<TimeSpan>();
            var f2List = new List<TimeSpan>();
            for (int i = 0; i < rounds; i++)
            {
                //test generic
                GCClear();
                bool res;
                var sw = new Stopwatch();
                sw.Start();
                for (int j = 0; j < n; j++)
                {
                    res = F(a, a);
                }
                sw.Stop();
                fList.Add(sw.Elapsed);

                //test not-generic
                GCClear();
                bool res2;
                var sw2 = new Stopwatch();
                sw2.Start();
                for (int j = 0; j < n; j++)
                {
                    res2 = F2(a, a);
                }
                sw2.Stop();
                f2List.Add(sw2.Elapsed);
            }
            double f1AverageTicks = fList.Average(ts => ts.Ticks);
            Console.WriteLine("Elapsed for F = {0} \t ticks = {1}", fList.Average(ts => ts.TotalMilliseconds),
                              f1AverageTicks);
            double f2AverageTicks = f2List.Average(ts => ts.Ticks);
            Console.WriteLine("Elapsed for F2 = {0} \t ticks = {1}", f2List.Average(ts => ts.TotalMilliseconds),
                  f2AverageTicks);
            Console.WriteLine("Not-generic method is {0} times faster, or on {1}%", f1AverageTicks/f2AverageTicks,
                              (f1AverageTicks/f2AverageTicks - 1)*100);
            Console.ReadKey();
        }

        private static void GCClear()
        {
            GC.Collect();
            GC.WaitForPendingFinalizers();
            GC.Collect();
        }
    }
}

在我的笔记本电脑 i7-3615qm 上，通用比非通用更快。

请参阅http://ideone.com/Y1GIJK。

c# - C# 中的泛型与非泛型性能

8 回答 8

Related

Reference