Dela via

jitCompilationStart MDA

Kommentar

Den här artikeln är specifik för .NET Framework. Det gäller inte för nyare implementeringar av .NET, inklusive .NET 6 och senare versioner.

Den jitCompilationStart hanterade felsökningsassistenten (MDA) aktiveras för att rapportera när jit-kompilatorn (just-in-time) börjar kompilera en funktion.

Symtom

Storleken på arbetsuppsättningen ökar för ett program som redan är i inbyggt bildformat, eftersom mscorjit.dll läses in i processen.

Orsak

Alla sammansättningar som programmet är beroende av har inte genererats i internt format, eller så har en sammansättning inte registrerats korrekt.

Åtgärd

Genom att aktivera den här MDA:en kan du identifiera vilken funktion som jit-kompileras. Kontrollera att sammansättningen som innehåller funktionen genereras till internt format och registreras korrekt.

Effekt på körningen

Denna MDA loggar ett meddelande precis innan en metod är JIT-kompilerad, så aktivering av denna MDA har betydande inverkan på prestanda. Om en metod är infogad genererar denna MDA inte ett separat meddelande.

Output

Följande kodexempel visar exempelutdata. I det här fallet visar utdata att i sammansättningstestet kompilerades metoden "m" på klassen "ns2.CO".

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

Konfiguration

Följande konfigurationsfil visar en mängd olika filter som kan användas för att filtrera bort vilka metoder som rapporteras när de först är JIT-kompilerade. Du kan ange att alla metoder ska rapporteras genom att ange värdet för namnattributet till *.

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

Exempel

Följande kodexempel är avsett att användas med föregående konfigurationsfil.

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

Se även