【问题标题】:Generic vs not-generic performance in C#C# 中的泛型与非泛型性能
【发布时间】:2013-06-25 20:53:27
【问题描述】:

我写了两个等价的方法:

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。

【问题讨论】:

  • 我得到 00:00:00.2080244 和 00:00:00.0071957 在没有调试器的发布版本中使用秒表。
  • 你检查过 IL 吗?第二个示例可能由编译器内联。
  • 我用过.net 4.5,它内联了这两种方法; dtb,我想如果你添加 [MethodImpl(MethodImplOptions.AggressiveInlining)] - 你会得到相同的结果
  • F2 的 IL:ldarg.0, ldarg.1, ceq, ret。 F 的 IL:ldarg.0, box !!T, ldarg.1, box !!T, ceq, ret。所以答案是因为参数被装箱了。但是为什么它们会被装箱呢?
  • @dtb:你在看 IL,这没关系。您需要查看 JIT 生成的本机代码。

标签: c# performance templates generics


【解决方案1】:

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

  1. 使用秒表
  2. 执行发布模式
  3. 防止内联。
  4. 使用 GetHashCode() 做一些实际的工作
  5. 查看生成的汇编代码

代码如下:

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)。 但在速度上几乎没有可测量的差异。我会说两者都是平等的。 为了完整起见,这里是通用版本的汇编代码: 我在发布模式下通过调试器获得了汇编代码,并启用了 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 

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

【讨论】:

  • 谢谢,但我对如何加快我的应用程序很感兴趣,我不想使用 GetHashCode,在这种情况下它很慢
  • 查看我的编辑。两种方法生成的汇编代码是相同的。之前所有猜测 IL 代码差异和其他影响因素的海报都没有看实际执行的代码。组装级别没有区别!任何性能差异都只是测量误差。
  • 有趣,我有 IL 差异,请参阅主帖中的 UPD
【解决方案2】:

您的测试方法有缺陷。您的操作方式存在一些大问题。

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

第二个DateTime is only accurate to 16ms,因此在比较两次时,您的 +/- 误差为 32 毫秒。两个结果之间的差异为 21 毫秒,完全在实验误差范围内。您必须使用更准确的计时器,例如 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

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

【讨论】:

  • 好建议,但不是答案。我使用秒表、热身等验证了结果。请参阅上面的评论。
  • @dtb 我不同意你的结果,我刚刚发布了我的结果,我得到了 0.1ms 的差异,第一个总是赢。你做错了什么,导致第一个运行速度非常慢。
  • 热身
    00:00:00.2611852
    00:00:00.0265555
    真实
    00:00:00.2700937
    00:00:00.0181213
    win7、vs 12、.net 4.5、x64
  • A 用的是什么?一个类(如我的)或类似 int 的东西(它实际上是一个结构)?另外,您是否在没有附加调试器的情况下以发布模式运行?附加调试器会极大地影响结果,因为它会禁用许多处理垃圾收集的内置优化器(因为如果您暂停程序并想查看监视窗口中的变量值,您可以t 在附加调试器时让变量很容易超出范围)。
  • 有趣.... 以 x86 重新运行您的代码,看看会发生什么;)。我不知道为什么构建为 x64 会减慢两者之一的速度。
【解决方案3】:

不要担心时间,担心正确性。

这些方法等效。其中一个使用class Aoperator==,另一个使用objectoperator==

【讨论】:

  • F使用object的operator==,而F2使用class A的operator==对吧?
  • @dtb:是的,泛型必须使用System.Object 的运算符来调用。
  • 所以除非 A 类重载 operator==,否则两者都使用对象的 operator==,因此等价的。
  • @dtb 好吧,如果A 或其任何超类型重载operator ==。如果object 是继承链中重载== 的派生最多的类型,那么它将使用它。
  • @dtb:这个问题中没有任何内容可以告诉我class A 是否有operator==... 并且至少对于一些可能的通用参数,结果会有所不同。
【解决方案4】:

两件事:

  1. 您正在使用DateTime.Now 进行基准测试。请改用Stopwatch
  2. 您正在运行的代码不是在正常情况下。 JIT 很可能会影响第一次运行,使您的第一个方法变慢。

如果您切换测试顺序(即先测试非泛型方法),您的结果会反转吗?我会怀疑的。当我将您的代码插入LINQPad,然后复制它以便它运行两个测试两次时,第二次迭代的执行时间在几百个滴答声内。

所以,回答您的问题:是的,有人知道原因。这是因为你的基准不准确!

【讨论】:

  • 订单不会改变任何东西。问题在于泛型方法中的装箱操作
  • @nirmus:这里没有拳击。对于引用类型,box 指令什么都不做。它将被 JIT 删除。
【解决方案5】:

我重写了你的测试代码:

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

所以拳击操作是你时差的原因。问题是为什么要加装箱操作。检查一下,堆栈溢出问题 Boxing when using generics in C#

【讨论】:

  • 但是box指令如何影响JIT生成的代码(也就是处理器实际执行的代码)?
  • 是的,我怎样才能停止在模板中装箱?
  • @Dmitry:C# 没有模板。 .NET 泛型与 C++ 模板完全不同(至少就这个问题而言)。
【解决方案6】:

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

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

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

【讨论】:

    【解决方案7】:

    这似乎更公平,不是吗?: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

    【讨论】:

    • 您使用了哪些编译选项?文件名表明它是一个调试版本,没有优化,这并不有趣。
    • 为了公平测试,我已将其发布在 ideone 上,您可以自己测试。什么是优化 - 我没有使用它,因为编译器无法编译一个没有在任何地方使用的变量的循环。您也可以将此代码复制粘贴到您的环境中,并随心所欲地进行测试
    • 在我的笔记本电脑上,结果:非通用方法快 13.9610133964644 倍,或在 1296.10133964644% 上
    • 这很奇怪......你没有改变N?增加 N 增加泛型性能... как-то странно, ну не может в 13 раз отличаться...
    • 没有改变 N,但我使用的是 x64。有趣的 x86 结果遗传/不一样,但大 6 倍
    【解决方案8】:

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

    如果您的目标只是比较,您可以这样做:

        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;
        }
    

    这将避免拳击。

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

    【讨论】:

      猜你喜欢
      • 2012-06-28
      • 1970-01-01
      • 2011-10-08
      • 1970-01-01
      • 2012-04-12
      • 2017-12-31
      • 1970-01-01
      • 1970-01-01
      • 2015-07-30
      相关资源
      最近更新 更多