Compiled expression tree performance

Question

using System;
using System.Linq.Expressions;
using System.Diagnostics;

public class E
{
    public double V { get; set; }
}

public class Program
{
    public static void Main()
    {
        E e = new E();
        Func<double> f = () => e.V;

        Expression expr = Expression.Property(Expression.Constant(e), "V");
        Expression<Func<double>> exp = Expression.Lambda<Func<double>>(expr);
        Func<double> ef = exp.Compile();

        e.V = 123;

        int attempts = 5;
        for (int j = 0; j < attempts; j++)
        {
            int c = 100000;

            double[] r1 = new double[c];
            Stopwatch sw = new Stopwatch();
            sw.Start();
            for (int i = 0; i < c; i++)
            {
                r1[i] = f();
            }
            sw.Stop();

            double[] r2 = new double[c];
            Stopwatch sw2 = new Stopwatch();
            sw2.Start();
            for (int i = 0; i < c; i++)
            {
                r2[i] = ef();
            }
            sw2.Stop();

            double rat = (double)sw.ElapsedTicks / sw2.ElapsedTicks;

            Console.WriteLine(rat);
        }
    }
}

then it turns out that compiled expression is much slower than just a lambda. Is it expected result? Is it possible to rewrite to expression somehow to get equivalent code but which will work faster?

http://stackoverflow.com/questions/35805609/performance-of-expression-compile-vs-lambda-direct-vs-virtual-calls — Kevin Gosse, Mar 12 '17 at 19:08
Do you test with release mode with optimizations enabled? How much slower? — Evk, Mar 12 '17 at 19:54
You didn't answer if you run that in release mode with optimizations, or debug? — Evk, Mar 12 '17 at 21:03
Most likely JIT inlines your lambda and performs optimizations on it, which it cannot do with your dynamically generated method. — Evk, Mar 12 '17 at 21:19

Tony THONG · Answer 1 · 2017-04-03T18:13:19.903

your delegate f is created with a compiled generated class with a field e of type E and access value like this :

return <Target>.e.V;

In the second case (expression), delegate is created using constant instruction that use a Closure as target with an array of object where e is the first element. Code can be represented like this :

return ((E)<Target>.Constants[0]).V;

That's why performance is better for first case.

note : with "Watch window" in Visual Studio, when you debug the code, you can inspect "f.Target" and "ef.Target" to confirm it.

Compiled expression tree performance

1 Answers1