jitCompilationStart MDA

Note

Cet article est spécifique à .NET Framework. Ceci ne s’applique pas aux implémentations plus récentes de .NET, y compris .NET 6 et versions ultérieures.

L’Assistant jitCompilationStart débogage managé (MDA) est activé pour signaler quand le compilateur juste-à-temps (JIT) commence à compiler une fonction.

Symptoms

La taille du jeu de travail augmente pour un programme déjà au format d’image natif, car mscorjit.dll est chargé dans le processus.

Cause

Tous les assemblys dont dépend le programme sont générés au format natif, ou un assembly n’est pas inscrit correctement.

Résolution

L’activation de ce MDA vous permet d’identifier la fonction qui est compilée par JIT. Assurez-vous que l’assembly qui contient la fonction est généré au format natif et correctement inscrit.

Effet sur le runtime

Ce MDA enregistre un message juste avant qu’une méthode soit compilée par JIT, ce qui permet à ce MDA d’avoir un impact significatif sur les performances. Si une méthode est inline, cette MDA ne génère pas de message distinct.

Sortie

L’exemple de code suivant montre l’exemple de sortie. Dans ce cas, la sortie indique que, dans le test d’assembly, la méthode « m » sur la classe « ns2.CO » a été compilée par JIT.

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

Configuration

Le fichier de configuration suivant montre un large éventail de filtres qui peuvent être utilisés pour filtrer les méthodes signalées lorsqu’elles sont compilées pour la première fois en JIT. Vous pouvez spécifier que toutes les méthodes doivent être signalées en définissant la valeur de l’attribut name sur *.

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

Example

L’exemple de code suivant est destiné à être utilisé avec le fichier de configuration précédent.

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

Voir aussi

  • Last updated on