编译表达式树的性能

Question

我有一个简单的场景，我试图测试编译表达式树在股票对象列表上的性能。以下是代码：

编译表达式树的性能比静态lambda调用慢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);
}

- GammaVega

---

请检查已编译的IL代码；优化器可能会使您的所有代码失效。 - SLaks

实际上，你并没有比较两个lambda表达式。第二个只是编译代码，即没有委托。很有可能是委托使它变慢了。 - MikeKulls

你似乎在比较苹果和橙子。"编译时lambda"实际上根本不使用lambda。另外，编译器可能会优化循环，因为你并没有做任何事情（空语句“;”）。 - Peter Ritchie

Answer 1

我自己进行了一些测试，比较了lambda表达式、编译表达式树、直接函数调用和内联代码。结果非常有趣。我几乎认为我的测试有误，因为表达式树更快，但我想这不是不可能的。Lambda表达式最慢！！有趣的是，表达式树比函数调用更快，只比内联代码略慢。完全出乎我的意料。

编辑：实际上，在下面的结果中，我认为Lambda表达式和编译函数的速度相等。

    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

- MikeKulls

Answer 2

这个差别与编译器在编译时具有更多信息并花费更多精力来优化代码有关，而不是在运行时编译...此外，使用lambda，您有一个更加"灵活"的程序（您可以在运行时选择lambda）。这是以牺牲额外的函数调用和失去许多潜在优化为代价的。

为了进行更加公正的比较，您可以使用以下内容比较静态lambda和动态lambda：

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

不要硬编码代码...

在这里你也会发现一个差异，但是稍微小一些...... 这个差异是由于同样的原因（更多优化）...... 你可以通过手动优化lambda来减少这个差异（尽管这并不总是可能的，因为编译器可以创建有效的CLI代码，而无法使用lambda手动创建）。

例如，如果您将动态lambda从以下内容更改：

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

to:

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

您将看到Lambda函数在原始编译代码的1倍和2倍之间的表现。

- user1494736

Answer 3

这里有另一种方法，它利用手动访问表达式并发出有效代码。

- dadhi