C# 中的泛型与非泛型性能
Posted
技术标签:
【中文标题】C# 中的泛型与非泛型性能【英文标题】：Generic vs not-generic performance in 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。 Fldarg.0, box !!T, ldarg.1, box !!T, ceq, ret。所以答案是因为参数被装箱了。但是为什么它们会被装箱呢？我确实对您的代码进行了一些更改以正确测量性能。
-
使用秒表
执行发布模式
防止内联。
使用 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:F2s", 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:F2s", 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、x64A 用的是什么？一个类（如我的）或类似 int 的东西（它实际上是一个结构）？另外，您是否在没有附加调试器的情况下以发布模式运行？附加调试器会极大地影响结果，因为它会禁用许多处理垃圾收集的内置优化器（因为如果您暂停程序并想查看监视窗口中的变量值，您可以t 在附加调试器时让变量很容易超出范围）。
有趣.... 以 x86 重新运行您的代码，看看会发生什么;)。我不知道为什么构建为 x64 会减慢两者之一的速度。【参考方案3】：
不要担心时间，担心正确性。
这些方法不等效。其中一个使用class A的operator==，另一个使用object的operator==。
【讨论】：
FSystem.Object 的运算符来调用。
所以除非 A 类重载 operator==，否则两者都使用对象的 operator==，因此是等价的。
@dtb 好吧，如果A 或其任何超类型重载operator ==。如果object 是继承链中重载== 的派生最多的类型，那么它将使用它。
@dtb：这个问题中没有任何内容可以告诉我class A 是否有operator==... 并且至少对于一些可能的通用参数，结果会有所不同。【参考方案4】：
两件事：
-
您正在使用
DateTime.Now 进行基准测试。请改用Stopwatch。
您正在运行的代码不是在正常情况下。 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;
这将避免拳击。
至于主要的计时偏差，我想每个人都已经确定，你如何设置秒表存在问题。我使用了一种不同的技术，如果我想从时间结果中删除循环本身，我会取一个空基线，然后从时间差中减去它。它并不完美，但它产生了一个公平的结果，并且不会因为一遍又一遍地启动和停止计时器而减慢。
【讨论】：
以上是关于C# 中的泛型与非泛型性能的主要内容，如果未能解决你的问题，请参考以下文章