7

ストックオブジェクトのリストで式コンパイルされたツリーのパフォーマンスをテストしようとしている単純なシナリオがあります。以下はコードです

式コンパイル ツリーのパフォーマンスは、静的ラムダ呼び出しよりも 5 倍遅くなります。これが式コンパイルされたツリーで期待できる標準的なパフォーマンスであるかどうかはわかりません。洞察をいただければ幸いです。

LambdaExpression();
List<Stock> stocks = new List<Stock>();
for (int ctr = 0; ctr <= 5000000; ctr++)
{
    Stock stk1 = new Stock() { Price = ctr, Symbol = "A", CloseDate = DateTime.Now, FaceValue = ctr } ;
    stocks.Add(stk1);
}
CompileTimeLamda(a);
DynamicLambda(a);


public static void LambdaExpression()
{
    ParameterExpression CS1 = Expression.Parameter(typeof(Stock), "d");

    var line1 = Expression.Equal(Expression.Property(CS1, typeof(Stock).GetProperty("Symbol")), Expression.Constant("MSFT", typeof(string)));
    var line2 = Expression.GreaterThan(Expression.Property(Expression.Property(CS1, typeof(Stock).GetProperty("CloseDate")),typeof(DateTime).GetProperty("Millisecond")), 
                                 Expression.Constant(0, typeof(int)));
    var line3 = Expression.GreaterThan(Expression.Property(CS1, typeof(Stock).GetProperty("Price")), Expression.Constant((double)0, typeof(double)));
    var line4 = Expression.And(line1,line2);
    var line5 = Expression.OrElse(line4, line3);

    func = Expression.Lambda<Func<Stock, bool>>(line5, new ParameterExpression[] {  CS1 } ).Compile();
}


public static void DynamicLambda(List<Stock> stks)
{
    Stopwatch watch = new Stopwatch();
    watch.Start();
    foreach (var d in stks)
    {
        func(d);
    }
    watch.Stop();
    Console.WriteLine("Dynamic Lambda :" + watch.ElapsedMilliseconds);
}

public static void CompileTimeLamda(List<Stock> stks)
{
    Stopwatch watch = new Stopwatch();
    watch.Start();
    foreach (var d in stks)
    {
        if (d.Symbol == "MSFT" && d.CloseDate.Millisecond > 0 ||
                                  (d.Price) > 0) ;
    }
    watch.Stop();
    Console.WriteLine("Compile Time Lamda " +watch.ElapsedMilliseconds);
}
4

3 に答える 3

7

ラムダ式、コンパイルされた式ツリー、ストレートな関数呼び出し、インライン コードを比較して、自分自身を少しテストしました。結果は非常に興味深いものでした。式ツリーの方が高速だったので、テストに問題があると思いますが、これは不可能ではないと思います。ラムダ式が一番遅い!! 興味深いことに、式ツリーは関数呼び出しよりも速く、インライン コードよりもわずかに遅いだけです。私がまったく期待していたものではありません。

編集:実際には、ラムダとコンパイルされた関数は、以下の結果で速度が等しいと考えます

    void TestIt()
    {
        var ints = new int[10000000];
        Random rand = new Random();
        for (int i = 0; i < ints.Length; i++)
            ints[i] = rand.Next(100);

        Func<int, int> func1 = i => i + 2;
        Func<int, int> func2 = CompileIt();

        var stopwatch = new Stopwatch();

        for (int x = 0; x < 3; x++)
        {
            stopwatch.Restart();
            for (int i = 0; i < ints.Length; i++)
                ints[i] = func1(ints[i]);
            stopwatch.Stop();
            Console.Write("Lamba                       ");
            Console.Write(stopwatch.ElapsedMilliseconds);
            ShowSum(ints);

            stopwatch.Restart();
            for (int i = 0; i < ints.Length; i++)
                ints[i] = func2(ints[i]);
            stopwatch.Stop();
            Console.Write("Lambda from expression tree ");
            Console.Write(stopwatch.ElapsedMilliseconds);
            ShowSum(ints);

            stopwatch.Restart();
            for (int i = 0; i < ints.Length; i++)
                ints[i] = AddTwo(ints[i]);
            stopwatch.Stop();
            Console.Write("Compiled function           ");
            Console.Write(stopwatch.ElapsedMilliseconds);
            ShowSum(ints);

            stopwatch.Restart();
            for (int i = 0; i < ints.Length; i++)
                ints[i] = ints[i] + 2;
            stopwatch.Stop();
            Console.Write("Compiled code               ");
            Console.Write(stopwatch.ElapsedMilliseconds);
            ShowSum(ints);
        }
    }

    private int AddTwo(int value)
    {
        return value + 2;
    }

    private void ShowSum(int[] ints)
    {
        Console.WriteLine("    Sum = " + ints.Sum(i => i).ToString());
    }

    private Func<int, int> CompileIt()
    {
        var param1 = Expression.Parameter(typeof(int));
        Expression body = Expression.Add(param1, Expression.Constant(2));
        return Expression.Lambda<Func<int, int>>(body, new [] { param1 }).Compile();
    }

3 回実行した結果は次のとおりです。

Lamba                       164    Sum = 515074919
Lambda from expression tree 86    Sum = 535074919
Compiled function           155    Sum = 555074919
Compiled code               54    Sum = 575074919

Lamba                       153    Sum = 595074919
Lambda from expression tree 88    Sum = 615074919
Compiled function           156    Sum = 635074919
Compiled code               53    Sum = 655074919

Lamba                       156    Sum = 675074919
Lambda from expression tree 88    Sum = 695074919
Compiled function           157    Sum = 715074919
Compiled code               54    Sum = 735074919
于 2012-07-26T22:23:13.313 に答える
3

違いは、実行時ではなくコンパイル時にコンパイルする場合、コンパイラがより多くの情報を持ち、コードの最適化により多くの労力を費やすことに関係しています...また、ラムダを使用すると、より「柔軟な」プログラムが得られます(実行時にラムダを選択できます)。これには、追加の関数呼び出しが必要であり、多くの潜在的な最適化が失われます。

より「公正な」比較を行うために、次のようなものを使用して静的ラムダと動的ラムダを比較できます。

Func<Stock, bool> compileTime = (Stock d) => (d.Symbol == "MSFT" && d.CloseDate.Millisecond > 0) || d.Price > 0;

ハードコードされたコードの代わりに..

そこにも違いがありますが、わずかに小さいものです...違いは同じ理由によるものです（最適化の増加）...手動でラムダを最適化することで違いを減らすことができます（ただし、常に可能であるとは限りませんコンパイラは、ラムダを使用して手動で作成できない有効な CLI コードを作成できるためです)。

ただし、たとえば、動的ラムダを次のように変更した場合:

var line5 = Expression.OrElse(line4, line3);

に：

var line5 = Expression.OrElse(line3, line4);

元のコンパイル済みコードの 1 倍から 2 倍の間でラムダがどのように実行されるかがわかります。

于 2012-07-26T21:37:54.080 に答える
0

ここでは、式の手動アクセスと効果的なコードの発行を利用する代替アプローチを示します。

于 2015-11-24T11:45:21.760 に答える