コンパイルされたC＃ラムダ式のパフォーマンス
コレクションに対する次の簡単な操作を検討してください。
_static List<int> x = new List<int>() { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
var result = x.Where(i => i % 2 == 0).Where(i => i > 5);
_式を使用してみましょう。次のコードはほぼ同等です。
_static void UsingLambda() {
Func<IEnumerable<int>, IEnumerable<int>> lambda = l => l.Where(i => i % 2 == 0).Where(i => i > 5);
var t0 = DateTime.Now.Ticks;
for (int j = 1; j < MAX; j++)
var sss = lambda(x).ToList();
var tn = DateTime.Now.Ticks;
Console.WriteLine("Using lambda: {0}", tn - t0);
}
_しかし、その場で式を作成したいので、ここに新しいテストがあります：
_static void UsingCompiledExpression() {
var f1 = (Expression<Func<IEnumerable<int>, IEnumerable<int>>>)(l => l.Where(i => i % 2 == 0));
var f2 = (Expression<Func<IEnumerable<int>, IEnumerable<int>>>)(l => l.Where(i => i > 5));
var argX = Expression.Parameter(typeof(IEnumerable<int>), "x");
var f3 = Expression.Invoke(f2, Expression.Invoke(f1, argX));
var f = Expression.Lambda<Func<IEnumerable<int>, IEnumerable<int>>>(f3, argX);
var c3 = f.Compile();
var t0 = DateTime.Now.Ticks;
for (int j = 1; j < MAX; j++)
var sss = c3(x).ToList();
var tn = DateTime.Now.Ticks;
Console.WriteLine("Using lambda compiled: {0}", tn - t0);
}
_もちろん、上記とまったく同じではないので、公平を期すために、最初のものを少し変更します。
_static void UsingLambdaCombined() {
Func<IEnumerable<int>, IEnumerable<int>> f1 = l => l.Where(i => i % 2 == 0);
Func<IEnumerable<int>, IEnumerable<int>> f2 = l => l.Where(i => i > 5);
Func<IEnumerable<int>, IEnumerable<int>> lambdaCombined = l => f2(f1(l));
var t0 = DateTime.Now.Ticks;
for (int j = 1; j < MAX; j++)
var sss = lambdaCombined(x).ToList();
var tn = DateTime.Now.Ticks;
Console.WriteLine("Using lambda combined: {0}", tn - t0);
}
_次に、MAX = 100000、VS2008、デバッグONの結果があります。
_Using lambda compiled: 23437500
Using lambda: 1250000
Using lambda combined: 1406250
_デバッグがオフの場合：
_Using lambda compiled: 21718750
Using lambda: 937500
Using lambda combined: 1093750
_サプライズ。コンパイルされた式は、他の選択肢よりも約17倍遅くなります。ここから質問が来ます。
- 同等でない表現を比較していますか？
- .NETがコンパイルされた式を「最適化」するメカニズムはありますか？
- 同じチェーンコール
l.Where(i => i % 2 == 0).Where(i => i > 5);をプログラムで表現するにはどうすればよいですか？
いくつかの統計。 Visual Studio 2010、デバッグオン、最適化オフ：
_Using lambda: 1093974
Using lambda compiled: 15315636
Using lambda combined: 781410
_デバッグON、最適化ON：
_Using lambda: 781305
Using lambda compiled: 15469839
Using lambda combined: 468783
_デバッグはオフ、最適化はオン：
_Using lambda: 625020
Using lambda compiled: 14687970
Using lambda combined: 468765
_新しいサプライズ VS2008（C＃3）からVS2010（C＃4）に切り替えると、UsingLambdaCombinedがネイティブラムダよりも高速になります。
OK、ラムダコンパイルのパフォーマンスを1桁以上改善する方法を見つけました。ここにヒントがあります。プロファイラーの実行後、92％の時間が費やされます。
_System.Reflection.Emit.DynamicMethod.CreateDelegate(class System.Type, object)
_うーん...繰り返しのたびに新しいデリゲートを作成するのはなぜですか？よくわかりませんが、解決策は別の投稿で続きます。
内側のラムダがコンパイルされていない可能性がありますか？！？概念実証は次のとおりです。
static void UsingCompiledExpressionWithMethodCall() {
var where = typeof(Enumerable).GetMember("Where").First() as System.Reflection.MethodInfo;
where = where.MakeGenericMethod(typeof(int));
var l = Expression.Parameter(typeof(IEnumerable<int>), "l");
var arg0 = Expression.Parameter(typeof(int), "i");
var lambda0 = Expression.Lambda<Func<int, bool>>(
Expression.Equal(Expression.Modulo(arg0, Expression.Constant(2)),
Expression.Constant(0)), arg0).Compile();
var c1 = Expression.Call(where, l, Expression.Constant(lambda0));
var arg1 = Expression.Parameter(typeof(int), "i");
var lambda1 = Expression.Lambda<Func<int, bool>>(Expression.GreaterThan(arg1, Expression.Constant(5)), arg1).Compile();
var c2 = Expression.Call(where, c1, Expression.Constant(lambda1));
var f = Expression.Lambda<Func<IEnumerable<int>, IEnumerable<int>>>(c2, l);
var c3 = f.Compile();
var t0 = DateTime.Now.Ticks;
for (int j = 1; j < MAX; j++)
{
var sss = c3(x).ToList();
}
var tn = DateTime.Now.Ticks;
Console.WriteLine("Using lambda compiled with MethodCall: {0}", tn - t0);
}
そして今、タイミングは次のとおりです。
Using lambda: 625020
Using lambda compiled: 14687970
Using lambda combined: 468765
Using lambda compiled with MethodCall: 468765
すごい！高速であるだけでなく、ネイティブラムダよりも高速です。 （スクラッチヘッド）。
もちろん、上記のコードは単純に書くには苦痛です。簡単な魔法をやってみましょう：
static void UsingCompiledConstantExpressions() {
var f1 = (Func<IEnumerable<int>, IEnumerable<int>>)(l => l.Where(i => i % 2 == 0));
var f2 = (Func<IEnumerable<int>, IEnumerable<int>>)(l => l.Where(i => i > 5));
var argX = Expression.Parameter(typeof(IEnumerable<int>), "x");
var f3 = Expression.Invoke(Expression.Constant(f2), Expression.Invoke(Expression.Constant(f1), argX));
var f = Expression.Lambda<Func<IEnumerable<int>, IEnumerable<int>>>(f3, argX);
var c3 = f.Compile();
var t0 = DateTime.Now.Ticks;
for (int j = 1; j < MAX; j++) {
var sss = c3(x).ToList();
}
var tn = DateTime.Now.Ticks;
Console.WriteLine("Using lambda compiled constant: {0}", tn - t0);
}
そして、いくつかのタイミング、VS2010、最適化オン、デバッグオフ：
Using lambda: 781260
Using lambda compiled: 14687970
Using lambda combined: 468756
Using lambda compiled with MethodCall: 468756
Using lambda compiled constant: 468756
ここで、式全体を動的に生成しているわけではないと主張できます。連鎖呼び出しのみ。しかし、上記の例では、式全体を生成します。そして、タイミングが一致します。これは、より少ないコードを記述するための単なるショートカットです。
私の理解では、.Compile（）メソッドはコンパイルを内部ラムダに伝播せず、したがってCreateDelegateの定数呼び出しは行われません。しかし、これを本当に理解するために、.NETの第一人者に内部の状況について少しコメントしてもらいたいと思います。
そしてwhy、oh whyこれはネイティブラムダよりも高速になりました！？
最近、私はほとんど同じ質問をしました：
私にとっての解決策は、CompileでExpressionを呼び出さないで、動的アセンブリでCompileToMethodを呼び出してExpressionをstaticメソッドにコンパイルすることです。
そのようです：
var assemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(
new AssemblyName("MyAssembly_" + Guid.NewGuid().ToString("N")),
AssemblyBuilderAccess.Run);
var moduleBuilder = assemblyBuilder.DefineDynamicModule("Module");
var typeBuilder = moduleBuilder.DefineType("MyType_" + Guid.NewGuid().ToString("N"),
TypeAttributes.Public));
var methodBuilder = typeBuilder.DefineMethod("MyMethod",
MethodAttributes.Public | MethodAttributes.Static);
expression.CompileToMethod(methodBuilder);
var resultingType = typeBuilder.CreateType();
var function = Delegate.CreateDelegate(expression.Type,
resultingType.GetMethod("MyMethod"));
しかし、理想的ではありません。どのタイプがこれに正確に当てはまるかはよくわかりませんが、デリゲートによってパラメーターとして取得されるタイプ、またはデリゲートによって返されるタイプhavepublicかつ非汎用である必要があります。ジェネリック型は明らかに、ジェネリック型の内部で.NETによって使用される内部型であるSystem.__Canonにアクセスし、これは「public型の規則でなければならない」ため、非ジェネリックでなければなりません。
これらのタイプには、明らかに遅いCompileを使用できます。次の方法でそれらを検出します。
private static bool IsPublicType(Type t)
{
if ((!t.IsPublic && !t.IsNestedPublic) || t.IsGenericType)
{
return false;
}
int lastIndex = t.FullName.LastIndexOf('+');
if (lastIndex > 0)
{
var containgTypeName = t.FullName.Substring(0, lastIndex);
var containingType = Type.GetType(containgTypeName + "," + t.Assembly);
if (containingType != null)
{
return containingType.IsPublic;
}
return false;
}
else
{
return t.IsPublic;
}
}
しかし、私が言ったように、これは理想的ではなく、動的アセンブリへのメソッドのコンパイルが時々桁違いに速い理由を知りたい。 ExpressionでコンパイルされたCompileが通常のメソッドと同じくらい高速である場合も見たので、時々言います。そのための私の質問を参照してください。
または、動的アセンブリで「nopublic型」制約をバイパスする方法を誰かが知っているなら、それも歓迎します。
あなたの表現は同等ではないため、歪んだ結果になります。これをテストするためのテストベンチを作成しました。テストには、通常のラムダ呼び出し、同等のコンパイル式、手作りの同等のコンパイル式、および合成バージョンが含まれます。これらは、より正確な数値である必要があります。興味深いことに、プレーンバージョンと合成バージョンの間に大きな違いは見られません。そして、コンパイルされた式は自然に遅くなりますが、ほんの少しだけです。適切な数値を得るには、十分な大きさの入力と反復カウントが必要です。違いが生まれます。
2番目の質問については、どうすればこれからより多くのパフォーマンスを得ることができるかわかりませんので、私はそこであなたを助けることはできません。それは得ようとしているように見えます。
3番目の質問に対する私の答えは、HandMadeLambdaExpression()メソッドにあります。拡張メソッドのために構築する最も簡単な式ではありませんが、実行可能です。
using System;
using System.Collections.Generic;
using System.Linq;
using System.Diagnostics;
using System.Linq.Expressions;
namespace ExpressionBench
{
class Program
{
static void Main(string[] args)
{
var values = Enumerable.Range(0, 5000);
var lambda = GetLambda();
var lambdaExpression = GetLambdaExpression().Compile();
var handMadeLambdaExpression = GetHandMadeLambdaExpression().Compile();
var composed = GetComposed();
var composedExpression = GetComposedExpression().Compile();
var handMadeComposedExpression = GetHandMadeComposedExpression().Compile();
DoTest("Lambda", values, lambda);
DoTest("Lambda Expression", values, lambdaExpression);
DoTest("Hand Made Lambda Expression", values, handMadeLambdaExpression);
Console.WriteLine();
DoTest("Composed", values, composed);
DoTest("Composed Expression", values, composedExpression);
DoTest("Hand Made Composed Expression", values, handMadeComposedExpression);
}
static void DoTest<TInput, TOutput>(string name, TInput sequence, Func<TInput, TOutput> operation, int count = 1000000)
{
for (int _ = 0; _ < 1000; _++)
operation(sequence);
var sw = Stopwatch.StartNew();
for (int _ = 0; _ < count; _++)
operation(sequence);
sw.Stop();
Console.WriteLine("{0}:", name);
Console.WriteLine(" Elapsed: {0,10} {1,10} (ms)", sw.ElapsedTicks, sw.ElapsedMilliseconds);
Console.WriteLine(" Average: {0,10} {1,10} (ms)", decimal.Divide(sw.ElapsedTicks, count), decimal.Divide(sw.ElapsedMilliseconds, count));
}
static Func<IEnumerable<int>, IList<int>> GetLambda()
{
return v => v.Where(i => i % 2 == 0).Where(i => i > 5).ToList();
}
static Expression<Func<IEnumerable<int>, IList<int>>> GetLambdaExpression()
{
return v => v.Where(i => i % 2 == 0).Where(i => i > 5).ToList();
}
static Expression<Func<IEnumerable<int>, IList<int>>> GetHandMadeLambdaExpression()
{
var enumerableMethods = typeof(Enumerable).GetMethods();
var whereMethod = enumerableMethods
.Where(m => m.Name == "Where")
.Select(m => m.MakeGenericMethod(typeof(int)))
.Where(m => m.GetParameters()[1].ParameterType == typeof(Func<int, bool>))
.Single();
var toListMethod = enumerableMethods
.Where(m => m.Name == "ToList")
.Select(m => m.MakeGenericMethod(typeof(int)))
.Single();
// helpers to create the static method call expressions
Func<Expression, ParameterExpression, Func<ParameterExpression, Expression>, Expression> WhereExpression =
(instance, param, body) => Expression.Call(whereMethod, instance, Expression.Lambda(body(param), param));
Func<Expression, Expression> ToListExpression =
instance => Expression.Call(toListMethod, instance);
//return v => v.Where(i => i % 2 == 0).Where(i => i > 5).ToList();
var exprParam = Expression.Parameter(typeof(IEnumerable<int>), "v");
var expr0 = WhereExpression(exprParam,
Expression.Parameter(typeof(int), "i"),
i => Expression.Equal(Expression.Modulo(i, Expression.Constant(2)), Expression.Constant(0)));
var expr1 = WhereExpression(expr0,
Expression.Parameter(typeof(int), "i"),
i => Expression.GreaterThan(i, Expression.Constant(5)));
var exprBody = ToListExpression(expr1);
return Expression.Lambda<Func<IEnumerable<int>, IList<int>>>(exprBody, exprParam);
}
static Func<IEnumerable<int>, IList<int>> GetComposed()
{
Func<IEnumerable<int>, IEnumerable<int>> composed0 =
v => v.Where(i => i % 2 == 0);
Func<IEnumerable<int>, IEnumerable<int>> composed1 =
v => v.Where(i => i > 5);
Func<IEnumerable<int>, IList<int>> composed2 =
v => v.ToList();
return v => composed2(composed1(composed0(v)));
}
static Expression<Func<IEnumerable<int>, IList<int>>> GetComposedExpression()
{
Expression<Func<IEnumerable<int>, IEnumerable<int>>> composed0 =
v => v.Where(i => i % 2 == 0);
Expression<Func<IEnumerable<int>, IEnumerable<int>>> composed1 =
v => v.Where(i => i > 5);
Expression<Func<IEnumerable<int>, IList<int>>> composed2 =
v => v.ToList();
var exprParam = Expression.Parameter(typeof(IEnumerable<int>), "v");
var exprBody = Expression.Invoke(composed2, Expression.Invoke(composed1, Expression.Invoke(composed0, exprParam)));
return Expression.Lambda<Func<IEnumerable<int>, IList<int>>>(exprBody, exprParam);
}
static Expression<Func<IEnumerable<int>, IList<int>>> GetHandMadeComposedExpression()
{
var enumerableMethods = typeof(Enumerable).GetMethods();
var whereMethod = enumerableMethods
.Where(m => m.Name == "Where")
.Select(m => m.MakeGenericMethod(typeof(int)))
.Where(m => m.GetParameters()[1].ParameterType == typeof(Func<int, bool>))
.Single();
var toListMethod = enumerableMethods
.Where(m => m.Name == "ToList")
.Select(m => m.MakeGenericMethod(typeof(int)))
.Single();
Func<ParameterExpression, Func<ParameterExpression, Expression>, Expression> LambdaExpression =
(param, body) => Expression.Lambda(body(param), param);
Func<Expression, ParameterExpression, Func<ParameterExpression, Expression>, Expression> WhereExpression =
(instance, param, body) => Expression.Call(whereMethod, instance, Expression.Lambda(body(param), param));
Func<Expression, Expression> ToListExpression =
instance => Expression.Call(toListMethod, instance);
var composed0 = LambdaExpression(Expression.Parameter(typeof(IEnumerable<int>), "v"),
v => WhereExpression(
v,
Expression.Parameter(typeof(int), "i"),
i => Expression.Equal(Expression.Modulo(i, Expression.Constant(2)), Expression.Constant(0))));
var composed1 = LambdaExpression(Expression.Parameter(typeof(IEnumerable<int>), "v"),
v => WhereExpression(
v,
Expression.Parameter(typeof(int), "i"),
i => Expression.GreaterThan(i, Expression.Constant(5))));
var composed2 = LambdaExpression(Expression.Parameter(typeof(IEnumerable<int>), "v"),
v => ToListExpression(v));
var exprParam = Expression.Parameter(typeof(IEnumerable<int>), "v");
var exprBody = Expression.Invoke(composed2, Expression.Invoke(composed1, Expression.Invoke(composed0, exprParam)));
return Expression.Lambda<Func<IEnumerable<int>, IList<int>>>(exprBody, exprParam);
}
}
}
そして私のマシンでの結果：
ラムダ： 経過時間：340971948 123230（ms） 平均：340.971948 0.12323（ms） ラムダ式： 経過時間：357077202 129051（ms ） 平均：357.077202 0.129051（ms） 手作りのラムダ式： 経過：345029281 124696（ms） 平均：345.029281 0.124696（ms） Composed： Elapsed：340409238 123027（ms） Average：340.409238 0.123027（ms） Composed Expression： Elapsed：350800599 126782 （ms） 平均：350.800599 0.126782（ms） 手作りの構成式： 経過：352811359 127509（ms） 平均：352.811359 0.127509（ms）
実行時のコンパイル済みコードは最適化されない場合がありますが、手動で作成したコードとC＃コンパイラーでコンパイルされたコードは最適化されるため、デリゲートに対するコンパイル済みラムダのパフォーマンスは遅くなります。
第二に、複数のラムダ式は複数の匿名メソッドを意味し、それらのそれぞれを呼び出すには、ストレートメソッドを評価するよりも余分な時間がかかりません。たとえば、呼び出し
Console.WriteLine(x);
そして
Action x => Console.WriteLine(x);
x(); // this means two different calls..
が異なり、コンパイラの観点から見ると、実際には2つの異なる呼び出しであるため、もう1つ少しオーバーヘッドが必要です。最初にx自体を呼び出し、次にその呼び出しxのステートメント内で呼び出します。
そのため、組み合わせたラムダは、単一のラムダ式よりもパフォーマンスがほとんど低下しません。
また、これは正しいロジックを評価しているが、コンパイラが実行する追加のステップを追加しているため、内部で実行されているものとは無関係です。
式ツリーがコンパイルされた後でも、最適化は行われず、小さな複雑な構造が保持されます。評価と呼び出しには追加の検証、nullチェックなどがあり、コンパイルされたラムダ式のパフォーマンスが低下する可能性があります。