jitCompilationStart-MDA

Artikel
06/04/2024

Hinweis

Dieser Artikel gilt für das .NET Framework. Sie gilt nicht für neuere Implementierungen von .NET, einschließlich .NET 6 und höherer Versionen.

Der Assistent für verwaltetes Debuggen (MDA) jitCompilationStart berichtet, wann der JIT-Compiler mit der Kompilierung einer Funktion beginnt.

Symptome

Die Größe der Arbeitssätze wird für ein Programm größer, das bereits im nativen Bildformat vorhanden ist, da „mscorjit.dll“ in den Prozess geladen wird.

Ursache

Nicht alle Assemblys, von denen die Anwendung abhängt, wurden im nativen Format generiert oder ein Assembly wurde nicht korrekt registriert.

Lösung

Durch die Aktivierung dieses MDA können Sie bestimmen, welche Funktion JIT-kompiliert wird. Stellen Sie sicher, dass die Assembly mit der Funktion im nativen Format generiert und ordnungsgemäß registriert wird.

Auswirkungen auf die Laufzeit

Dieser MDA protokolliert eine Meldung, kurz bevor eine Methode JIT-kompiliert wird. Deshalb hat die Aktivierung dieses MDA erhebliche Auswirkungen auf die Leistung. Dieser MDA generiert keine separate Nachricht, wenn eine Methode inline ist.

Ausgabe

Das folgende Codebeispiel zeigt eine Beispielausgabe. In diesem Fall zeigt die Ausgabe an, dass in der Assembly „Die M-Methode testen“ der Klasse „ns2.CO“ JIT-kompiliert wurde.

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

Konfiguration

Die folgende Konfigurationsdatei zeigt eine Reihe von Filtern, die filtern können, welche Methoden gemeldet werden, wenn sie zuerst JIT-kompiliert werden. Sie können angeben, dass alle Methoden gemeldet werden müssen, indem Sie den Wert des Namensattributs auf * festlegen.

<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>

Beispiel

Das folgende Codebeispiel ist dazu vorgesehen, mit der vorangegangenen Konfigurationsdatei verwendet zu werden.

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() { }
        }
    }
}

Freigeben über