MDA jitCompilationStart

Articolo
04/08/2023

L'assistente al debug gestito jitCompilationStart viene attivato per segnalare il momento in cui il compilatore JIT avvia la compilazione di una funzione.

Sintomi

Le dimensioni del set di lavoro aumentano per un programma già in formato immagine nativo, perché mscorjit.dll viene caricato nel processo.

Causa

Non tutti gli assembly a seconda del programma sono stati generati in formato nativo o un assembly non è registrato correttamente.

Soluzione

L'abilitazione di questo MDA consente di identificare quale funzione è in fase di compilazione JIT. Assicurarsi che l'assembly contenente la funzione venga generato in formato nativo e registrato correttamente.

Effetto sul runtime

Poiché questo assistente al debug gestito registra un messaggio appena prima della compilazione JIT di un metodo, la sua abilitazione ha un notevole impatto sulle prestazioni. Se un metodo è inline, questo MDA non genererà un messaggio separato.

Output

L'esempio di codice seguente mostra l'output di esempio. In questo caso, l'output mostra che, in assembly Test, il metodo "m" nella classe "ns2.CO" è stato compilato JIT.

method name="Test!ns2.C0::m"

Configurazione

Il file di configurazione seguente mostra diversi filtri che è possibile usare per escludere i metodi segnalati quando vengono prima compilati tramite JIT. È possibile specificare che devono essere segnalati tutti i metodi impostando il valore dell'attributo name su *.

<mdaConfig>  
  <assistants>  
    <jitCompilationStart>  
      <methods>  
        <match name="C0::m" />  
        <match name="MyMethod" />  
        <match name="C2::*" />  
        <match name="ns0::*" />  
        <match name="ns1.C0::*" />  
        <match name="ns2.C0::m" />  
        <match name="ns2.C0+N0::m" />  
      </methods>  
    </jitCompilationStart >  
  </assistants>  
</mdaConfig>

Esempio

L'esempio seguente mostra il codice da usare con il file di configurazione precedente.

using System;  
using System.Reflection;  
using System.Runtime.CompilerServices;  
using System.Runtime.InteropServices;  
  
public class Entry  
{  
    public static void Main(string[] args)  
    {  
        C0.m();  
        C1.MyMethod();  
        C2.m();  
  
        ns0.C0.m();  
        ns0.C0.N0.m();  
        ns0.C1.m();  
  
        ns1.C0.m();  
        ns1.C0.N0.m();  
  
        ns2.C0.m();  
        ns2.C0.N0.m();  
    }  
}  
  
public class C0  
{  
    [MethodImpl(MethodImplOptions.NoInlining)]  
    public static void m() { }  
}  
  
public class C1  
{  
    [MethodImpl(MethodImplOptions.NoInlining)]  
    public static void MyMethod() { }  
}  
  
public class C2  
{  
    [MethodImpl(MethodImplOptions.NoInlining)]  
    public static void m() { }  
}  
  
namespace ns0  
{  
    public class C0  
    {  
        [MethodImpl(MethodImplOptions.NoInlining)]  
        public static void m() { }  
  
        public class N0  
        {  
            [MethodImpl(MethodImplOptions.NoInlining)]  
            public static void m() { }  
        }  
    }  
  
    public class C1  
    {  
        [MethodImpl(MethodImplOptions.NoInlining)]  
        public static void m() { }  
    }  
}  
  
namespace ns1  
{  
    public class C0  
    {  
        [MethodImpl(MethodImplOptions.NoInlining)]  
        public static void m() { }  
        public class N0  
        {  
            [MethodImpl(MethodImplOptions.NoInlining)]  
            public static void m() { }  
        }  
    }  
}  
  
namespace ns2  
{  
    public class C0  
    {  
        [MethodImpl(MethodImplOptions.NoInlining)]  
        public static void m() { }  
  
        public class N0  
        {  
            [MethodImpl(MethodImplOptions.NoInlining)]  
            public static void m() { }  
        }  
    }  
}

Share via