Любопытство: Почему делает Выражение <…>, когда скомпилировано выполненный быстрее, чем минимальный DynamicMethod?

Метод, созданный с помощью DynamicMethod , проходит через два преобразователя, а метод, созданный с помощью Expression <> ни через что не проходит.

Вот как это работает. Вот вызывающая последовательность для вызова fn (0, 1) в методе Time (я жестко запрограммировал аргументы на 0 и 1 для облегчения отладки):

00cc032c 6a01            push    1           // 1 argument
00cc032e 8bcf            mov     ecx,edi
00cc0330 33d2            xor     edx,edx     // 0 argument
00cc0332 8b410c          mov     eax,dword ptr [ecx+0Ch]
00cc0335 8b4904          mov     ecx,dword ptr [ecx+4]
00cc0338 ffd0            call    eax // 1 arg on stack, two in edx, ecx

Для первый вызов, который я исследовал, DynamicMethod , строка call eax выглядит следующим образом:

00cc0338 ffd0            call    eax {003c2084}
0:000> !u 003c2084
Unmanaged code
003c2084 51              push    ecx
003c2085 8bca            mov     ecx,edx
003c2087 8b542408        mov     edx,dword ptr [esp+8]
003c208b 8b442404        mov     eax,dword ptr [esp+4]
003c208f 89442408        mov     dword ptr [esp+8],eax
003c2093 58              pop     eax
003c2094 83c404          add     esp,4
003c2097 83c010          add     eax,10h
003c209a ff20            jmp     dword ptr [eax]

Похоже, что это происходит с изменением порядка аргументов в стеке. Я предполагаю, что это происходит из-за разницы между делегатами, которые используют неявный аргумент this, и теми, которые этого не делают.

Этот переход в конце разрешается следующим образом:

003c209a ff20            jmp     dword ptr [eax]      ds:0023:012f7edc=0098c098
0098c098 e963403500      jmp     00ce0100

Остальная часть кода 0098c098 выглядит как преобразователь JIT, начало которого было переписано с помощью jmp после JIT. И только после этого перехода мы переходим к реальному коду:

0:000> !u eip
Normal JIT generated code
DynamicClass.TestMethod(Int32, Int32)
Begin 00ce0100, size 5
>>> 00ce0100 03ca            add     ecx,edx
00ce0102 8bc1            mov     eax,ecx
00ce0104 c3              ret

Последовательность вызова метода, созданного с помощью Expression <> , отличается - в нем отсутствует код переключения стека. Вот он, из первого перехода через eax :

00cc0338 ffd0            call    eax {00ce00a8}

0:000> !u eip
Normal JIT generated code
DynamicClass.lambda_method(System.Runtime.CompilerServices.ExecutionScope, Int32, Int32)
Begin 00ce00a8, size b
>>> 00ce00a8 8b442404        mov     eax,dword ptr [esp+4]
00ce00ac 03d0            add     edx,eax
00ce00ae 8bc2            mov     eax,edx
00ce00b0 c20400          ret     4

Итак, как все получилось?

1. В смене стека не было необходимости (фактически используется неявный первый аргумент от делегата, то есть не как делегат, привязанный к статическому методу)
2. JIT должен был быть принудительно принудительно выполнен логикой компиляции LINQ, чтобы делегат содержал реальный адрес назначения, а не поддельный.

Я не знаю, как LINQ вынудил JIT, но я знаю, как вызвать JIT самостоятельно - вызвав функцию хотя бы один раз. ОБНОВЛЕНИЕ: я нашел другой способ принудительно выполнить JIT: используйте аргумент limitedSkipVisibility в конструкторе и передайте true . Итак, вот модифицированный код, который исключает смену стека с помощью неявного параметра this и использует альтернативный конструктор для предварительной компиляции, так что привязанный адрес является реальным адресом, а не преобразователем:

using System;
using System.Linq.Expressions;
using System.Reflection.Emit;
using System.Diagnostics;

namespace Sandbox
{
    public class Program
    {
        public static void Main(String[] args)
        {
            DynamicMethod method = new DynamicMethod("TestMethod",
                typeof(Int32), new Type[] { typeof(object), typeof(Int32),
                typeof(Int32) }, true);
            var il = method.GetILGenerator();

            il.Emit(OpCodes.Ldarg_1);
            il.Emit(OpCodes.Ldarg_2);
            il.Emit(OpCodes.Add);
            il.Emit(OpCodes.Ret);

            Func<Int32, Int32, Int32> f1 =
                (Func<Int32, Int32, Int32>)method.CreateDelegate(
                    typeof(Func<Int32, Int32, Int32>), null);
            Func<Int32, Int32, Int32> f2 = (Int32 a, Int32 b) => a + b;
            Func<Int32, Int32, Int32> f3 = Sum;
            Expression<Func<Int32, Int32, Int32>> f4x = (a, b) => a + b;
            Func<Int32, Int32, Int32> f4 = f4x.Compile();
            for (Int32 pass = 1; pass <= 2; pass++)
            {
                // Pass 1 just runs all the code without writing out anything
                // to avoid JIT overhead influencing the results
                Time(f1, "DynamicMethod", pass);
                Time(f2, "Lambda", pass);
                Time(f3, "Method", pass);
                Time(f4, "Expression", pass);
            }
        }

        private static void Time(Func<Int32, Int32, Int32> fn,
            String name, Int32 pass)
        {
            Stopwatch sw = new Stopwatch();
            sw.Start();
            for (Int32 index = 0; index <= 100000000; index++)
            {
                Int32 result = fn(index, 1);
            }
            sw.Stop();
            if (pass == 2)
                Console.WriteLine(name + ": " + sw.ElapsedMilliseconds + " ms");
        }

        private static Int32 Sum(Int32 a, Int32 b)
        {
            return a + b;
        }
    }
}

Вот время выполнения на моем system:

DynamicMethod: 312 ms
Lambda: 417 ms
Method: 417 ms
Expression: 312 ms

ОБНОВЛЕНО ДОБАВИТЬ :

Я попытался запустить этот код в своей новой системе, которая представляет собой Core i7 920 под управлением Windows 7 x64 с установленным .NET 4 beta 2 (mscoree.dll ver. 4.0. 30902), и результаты, ну, переменные.

csc 3.5, /platform:x86, runtime v2.0.50727 (via .config)

Run #1
DynamicMethod: 214 ms
Lambda: 571 ms
Method: 570 ms
Expression: 249 ms

Run #2
DynamicMethod: 463 ms
Lambda: 392 ms
Method: 392 ms
Expression: 463 ms

Run #3
DynamicMethod: 463 ms
Lambda: 570 ms
Method: 570 ms
Expression: 463 ms

Возможно, это Intel SpeedStep, влияющий на результаты, или, возможно, Turbo Boost. В любом случае это очень раздражает.

csc 3.5, /platform:x64, runtime v2.0.50727 (via .config)
DynamicMethod: 428 ms
Lambda: 392 ms
Method: 392 ms
Expression: 428 ms

csc 3.5, /platform:x64, runtime v4
DynamicMethod: 428 ms
Lambda: 356 ms
Method: 356 ms
Expression: 428 ms

csc 4, /platform:x64, runtime v4
DynamicMethod: 428 ms
Lambda: 356 ms
Method: 356 ms
Expression: 428 ms

csc 4, /platform:x86, runtime v4
DynamicMethod: 463 ms
Lambda: 570 ms
Method: 570 ms
Expression: 463 ms

csc 3.5, /platform:x86, runtime v4
DynamicMethod: 214 ms
Lambda: 570 ms
Method: 571 ms
Expression: 249 ms

Многие из этих результатов будут зависеть от времени, независимо от того, что вызывает случайное ускорение в сценарии C # 3.5 / runtime v2.0. Мне придется перезагрузиться, чтобы узнать, не влияет ли SpeedStep или Turbo Boost за эти эффекты.