metodo ILGenerator inlining

Question

Dato seguente codice:

using System; 
using System.Reflection.Emit; 
using System.Diagnostics; 
using System.Reflection; 

namespace ConsoleApplication1 
{ 
    class A 
    { 
     public int Do(int n) 
     { 
      return n; 
     } 
    } 

    public delegate int DoDelegate(); 

    class Program 
    { 
     public static void Main(string[] args) 
     { 
      A a = new A(); 

      Stopwatch stopwatch = Stopwatch.StartNew(); 
      int s = 0; 
      for (int i = 0; i < 100000000; i++) 
      { 
       s += a.Do(i); 
      } 

      Console.WriteLine(stopwatch.ElapsedMilliseconds); 
      Console.WriteLine(s); 


      DynamicMethod dm = new DynamicMethod("Echo", typeof(int), new Type[] { typeof(int) }, true); 
      ILGenerator il = dm.GetILGenerator(); 

      il.Emit(OpCodes.Ldarg_0); 
      il.Emit(OpCodes.Ret); 

      DynamicMethod dm2 = new DynamicMethod("Test", typeof(int), new Type[0]); 
      il = dm2.GetILGenerator(); 


      Label loopStart = il.DefineLabel(); 
      Label loopCond = il.DefineLabel(); 

      il.DeclareLocal(typeof(int)); // i 
      il.DeclareLocal(typeof(int)); // s 

      // s = 0; 
      il.Emit(OpCodes.Ldc_I4_0); 
      il.Emit(OpCodes.Stloc_1); 

      // i = 0; 
      il.Emit(OpCodes.Ldc_I4_0); 
      il.Emit(OpCodes.Stloc_0); 

      il.Emit(OpCodes.Br_S, loopCond); 

      il.MarkLabel(loopStart); 

      // s += Echo(i); 
      il.Emit(OpCodes.Ldloc_1); // Load s 
      il.Emit(OpCodes.Ldloc_0); // Load i 
      il.Emit(OpCodes.Call, dm); // Call echo method 
      il.Emit(OpCodes.Add); 
      il.Emit(OpCodes.Stloc_1); 

      // i++ 
      il.Emit(OpCodes.Ldloc_0); 
      il.Emit(OpCodes.Ldc_I4_1); 
      il.Emit(OpCodes.Add); 
      il.Emit(OpCodes.Stloc_0); 

      il.MarkLabel(loopCond); 

      // Check for loop condition 
      il.Emit(OpCodes.Ldloc_0); 
      il.Emit(OpCodes.Ldc_I4, 100000000); 
      il.Emit(OpCodes.Blt_S, loopStart); 

      il.Emit(OpCodes.Ldloc_1); 
      il.Emit(OpCodes.Ret); 


      DoDelegate doDel = (DoDelegate)dm2.CreateDelegate(typeof(DoDelegate)); 
      s = doDel.Invoke();  // Dummy run to force JIT 


      stopwatch = Stopwatch.StartNew(); 
      s = doDel.Invoke(); 
      Console.WriteLine(stopwatch.ElapsedMilliseconds); 
      Console.WriteLine(s); 
     } 
    } 
} 

Chiama per il metodo Do viene inline. Il ciclo termina in circa 40 ms. Se io, ad esempio, crei Do per essere una funzione virtuale, essa non viene evidenziata e il ciclo termina in 240 ms. Fin qui tutto bene. Quando utilizzo ILGenerator per generare il metodo Do (Echo) e quindi generare DynamicMethod con lo stesso loop del metodo principale specificato, la chiamata al metodo Echo non viene mai eseguita in linea e per il ciclo sono necessari circa 240 ms. Il codice MSIL è corretto poiché restituisce lo stesso risultato del codice C#. Ero sicuro che l'inlining del metodo è qualcosa che viene fatto dalla JIT, quindi non vedo alcun motivo per non incorporare il metodo Echo.

Qualcuno sa perché questo semplice metodo non verrà sottolineato dal JIT.

Answer 1

Se sto capendo correttamente, la mia ipotesi è che, poiché il metodo è generato dinamicamente, il compilatore JIT non sa di inserirlo per i chiamanti.

Ho scritto una grande quantità di IL ma non ho esaminato il comportamento inlining (principalmente perché i metodi dinamici sono in genere abbastanza veloci per i miei scopi senza ulteriore ottimizzazione).

Vorrei dare il benvenuto a qualcuno più esperto sull'argomento per dare un feedback (per favore non solo a bassa quota, mi piacerebbe imparare qualcosa qui se sbaglio).

non dinamici

• si scrive "normale" codice .NET (ad esempio, C#, VB.NET, qualsiasi lingua CLS-aware)
• IL si crea al momento della compilazione
• il codice macchina viene creato in fase di runtime; metodi sono inline se del caso

dinamica

• si scrive "normale" codice .NET il cui scopo è quello di creare un metodo dinamico
• IL si crea al momento della compilazione per questo codice, ma il metodo dinamico non viene creato
• il codice macchina viene creato in fase di esecuzione per il codice che genera il metodo dinamico
• quando viene richiamato quel codice, la dinamica viene soddisfatta hod viene creato come IL in un complesso speciale
• IL del metodo dinamico viene compilato in codice macchina
• tuttavia, JIT compilatore non ricompila altri chiamanti all'inline il nuovo metodo dinamico. O forse gli altri chiamanti sono dinamici e non sono ancora stati creati.

Answer 2

Dopo ulteriori indagini ho concluso seguente: metodi generati

1. ILGenerator potrà mai ottenere inline. Non importa se li chiami usando delegato, da un altro DynamicMethod o da un metodo creato con MethodBuilder.
2. I metodi esistenti (quelli codificati in C# e compilati da VS) possono essere inseriti solo se richiamati da un metodo creato con MethodBuilder.Se chiamati da DynamicMethod, non verranno mai evidenziati.

Ho concluso questo dopo aver testato a fondo molti campioni e esaminando il codice assembler finale.

Answer 3

Si potrebbe provare a generare un assembly dinamico. La mia comprensione è che la maggior parte del runtime non è consapevole del fatto che sia dinamico. Penso che internamente venga caricato come un qualsiasi altro byte [] assembly. Pertanto il JIT/inliner potrebbe anche non esserne consapevole (o non gliene importa).