Options de configuration du runtime pour le garbage collection

Article
08/09/2024

Cette page contient des informations sur les paramètres du garbage collector (GC) du runtime .NET. Si vous essayez d’atteindre les performances maximales d’une application en cours d’exécution, envisagez d’utiliser ces paramètres. Toutefois, les valeurs par défaut fournissent des performances optimales pour la plupart des applications dans des situations standard.

Les paramètres sont organisés en groupes dans cette page. Les paramètres au sein de chaque groupe sont couramment utilisés conjointement les uns avec les autres pour fournir un résultat spécifique.

Notes

Ces configurations ne sont lues par le runtime que lorsque le GC est initialisé (cela signifie généralement pendant le démarrage du processus). Si vous modifiez une variable d’environnement lorsqu’un processus est déjà en cours d’exécution, la modification ne sera pas répercutée dans ce processus. Les paramètres qui peuvent être modifiés via les API au moment de l’exécution, tels que le niveau de latence, sont omis dans cette page.
Étant donné que le GC est par processus, il est rarement judicieux de définir ces configurations au niveau de l’ordinateur. Par exemple, vous ne souhaitez pas que tous les processus .NET sur un ordinateur utilisent le serveur GC ou la même limite matérielle de tas.
Pour les valeurs numériques, utilisez la notation décimale pour les paramètres dans le fichier runtimeconfig.json ou runtimeconfig.template.json et la notation hexadécimale pour les paramètres des variables d’environnement. Pour les valeurs hexadécimales, vous pouvez les spécifier avec ou sans le préfixe « 0x ».
Si vous utilisez les variables d’environnement, .NET 6 et les versions ultérieures standardisent sur le préfixe DOTNET_ au lieu de COMPlus_. Toutefois, le préfixe COMPlus_ continuera à fonctionner. Si vous utilisez une version précédente du runtime .NET, vous devez tout de même utiliser le préfixe COMPlus_, par exemple COMPlus_gcServer.

Méthodes de spécification de la configuration

Pour différentes versions du runtime .NET, il existe différentes façons de spécifier les valeurs de configuration. Le tableau suivant présente un résumé.

Emplacement de configuration	Les versions de .NET à cet emplacement s’appliquent à	Formats	Interprétation
Fichier runtimeconfig.json ou fichier runtimeconfig.template.json	.NET (Core)	n	n est interprété comme une valeur décimale.
Variable d'environnement	.NET Framework, .NET (Core)	0xn ou n	n est interprété comme une valeur hexadécimal dans les deux formats
Fichier app.config	.NET Framework	0xn	n est interprété comme une valeur hexadécimal¹

¹ Vous pouvez spécifier une valeur sans préfixe pour un 0x paramètre de fichier app.config, mais ce n’est pas recommandé. Sur .NET Framework 4.8+, en raison d’un bogue, une valeur spécifiée sans le préfixe 0x est interprétée comme hexadécimale, mais sur les versions précédentes de .NET Framework, elle est interprétée comme décimale. Pour éviter d’avoir à modifier votre configuration, utilisez le préfixe 0x lors de la spécification d’une valeur dans votre fichier app.config.

Par exemple, pour spécifier 12 tas pour GCHeapCount pour une application .NET Framework nommée A.exe, ajoutez le code XML suivant au fichier A.exe.config.

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
    ...
    <runtime>
        <gcServer enabled="true"/>
        <GCHeapCount>0xc</GCHeapCount>
    </runtime>
</configuration>

Pour .NET (Core) et .NET Framework, vous pouvez utiliser des variables d’environnement.

Sur Windows à l’aide de .NET 6 ou version ultérieure :

SET DOTNET_gcServer=1
SET DOTNET_GCHeapCount=c

Sur Windows à l’aide de .NET 5 ou version antérieure :

SET COMPlus_gcServer=1
SET COMPlus_GCHeapCount=c

Sur d’autres systèmes d’exploitation :

Pour .NET 6 ou versions ultérieures :

export DOTNET_gcServer=1
export DOTNET_GCHeapCount=c

Pour .NET 5 et versions antérieures :

export COMPlus_gcServer=1
export COMPlus_GCHeapCount=c

Si vous n’utilisez pas .NET Framework, vous pouvez également définir la valeur dans le fichier runtimeconfig.json ou runtimeconfig.template.json.

Fichier runtimeconfig.json :

{
  "runtimeOptions": {
   "configProperties": {
      "System.GC.Server": true,
      "System.GC.HeapCount": 12
   }
  }
}

Fichier runtimeconfig.template.json :

{
  "configProperties": {
    "System.GC.Server": true,
    "System.GC.HeapCount": 12
  }
}

Saveurs du garbage collection

Les deux principales saveurs de garbage collection sont GC de station de travail et GC de serveur. Pour plus d’informations sur les différences entre les deux, consultez Garbage collection de station de travail et serveur.

Les sous-saveurs de garbage collection sont en arrière-plan et non simultanées.

Utilisez les paramètres suivants pour sélectionner des saveurs de garbage collection :

GC de station de travail ou de serveur
GC d’arrière-plan

Station de travail ou serveur

Configure si l’application utilise le garbage collection de station de travail ou le garbage collection de serveur.
Par défaut : garbage collection de station de travail. Ceci équivaut à définir la valeur sur false.

	Nom du paramètre	Valeurs	Version introduite
runtimeconfig.json	`System.GC.Server`	`false` – station de travail `true` – serveur	.NET Core 1.0
Propriété MSBuild	`ServerGarbageCollection`	`false` – station de travail `true` – serveur	.NET Core 1.0
Variable d'environnement	`COMPlus_gcServer`	`0` – station de travail `1` – serveur	.NET Core 1.0
Variable d'environnement	`DOTNET_gcServer`	`0` – station de travail `1` – serveur	.NET 6
app.config pour .NET Framework	GCServer	`false` – station de travail `true` – serveur

Exemples

Fichier runtimeconfig.json :

{
   "runtimeOptions": {
      "configProperties": {
         "System.GC.Server": true
      }
   }
}

Fichier runtimeconfig.template.json :

{
   "configProperties": {
      "System.GC.Server": true
   }
}

Fichier projet :

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <ServerGarbageCollection>true</ServerGarbageCollection>
  </PropertyGroup>

</Project>

GC d’arrière-plan

Configure si le garbage collection en arrière-plan (simultané) est activé.
Par défaut : utiliser le GC en arrière-plan. Ceci équivaut à définir la valeur sur true.
Pour plus d’informations, consultez Garbage collection en arrière-plan.

	Nom du paramètre	Valeurs	Version introduite
runtimeconfig.json	`System.GC.Concurrent`	`true` – GC en arrière-plan `false` – GC non simultané	.NET Core 1.0
Propriété MSBuild	`ConcurrentGarbageCollection`	`true` – GC en arrière-plan `false` – GC non simultané	.NET Core 1.0
Variable d'environnement	`COMPlus_gcConcurrent`	`1` – GC en arrière-plan `0` – GC non simultané	.NET Core 1.0
Variable d'environnement	`DOTNET_gcConcurrent`	`1` – GC en arrière-plan `0` – GC non simultané	.NET 6
app.config pour .NET Framework	gcConcurrent	`true` – GC en arrière-plan `false` – GC non simultané

Exemples

Fichier runtimeconfig.json :

{
   "runtimeOptions": {
      "configProperties": {
         "System.GC.Concurrent": false
      }
   }
}

Fichier runtimeconfig.template.json :

{
   "configProperties": {
      "System.GC.Concurrent": false
   }
}

Fichier projet :

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <ConcurrentGarbageCollection>false</ConcurrentGarbageCollection>
  </PropertyGroup>

</Project>

Gérer l’utilisation des ressources

Utilisez les paramètres suivants pour gérer l’utilisation de la mémoire et du processeur du garbage collector :

Créer des affinités
Masque d’affinités
Plages d’affinités
Groupes de processeurs
Nombre de tas
Limite matérielle du tas
Pourcentage de limite de tas dur
Limites matérielles par objet-tas
Pourcentages de limite matérielle par objet-tas
Pourcentage de mémoire élevé
Conserver la machine virtuelle

Pour plus d’informations sur certains de ces paramètres, consultez l’entrée de blog Middle ground between workstation and server GC.

Nombre de tas

Limite le nombre de tas créés par le garbage collector.
S’applique uniquement au garbage collection de serveurs.
Si l’affinité du processeur GC est activée, ce qui est le cas par défaut, le paramètre de nombre de tas crée des affinités entre les n threads/tas de GC et les n premiers processeurs. (Utilisez les paramètres masque d’affinité ou plages d’affinités afin de spécifier exactement les processeurs pour lesquels créer des affinités.)
Si l’affinité du processeur GC est désactivée, ce paramètre limite le nombre de tas de GC.
Pour plus d’informations, consultez les remarques sur GCHeapCount.

	Nom du paramètre	Valeurs	Version introduite
runtimeconfig.json	`System.GC.HeapCount`	valeur décimale	.NET Core 3.0
Variable d'environnement	`COMPlus_GCHeapCount`	valeur hexadécimale	.NET Core 3.0
Variable d'environnement	`DOTNET_GCHeapCount`	valeur hexadécimale	.NET 6
app.config pour .NET Framework	GCHeapCount	valeur décimale	.NET Framework 4.6.2

Ce paramètre de configuration n'a pas de propriété MSBuild spécifique. Toutefois, vous pouvez ajouter un élément MSBuild RuntimeHostConfigurationOption à la place. Utilisez le nom du paramètre runtimeconfig.json comme valeur de l’attribut Include. Pour obtenir un exemple, consultez les propriétés MSBuild.

Exemples

Fichier runtimeconfig.json :

{
   "runtimeOptions": {
      "configProperties": {
         "System.GC.HeapCount": 16
      }
   }
}

Fichier runtimeconfig.template.json :

{
   "configProperties": {
      "System.GC.HeapCount": 16
   }
}

Conseil

Si vous définissez l’option dans runtimeconfig.json, spécifiez une valeur décimale. Si vous définissez l’option en tant que variable d’environnement, spécifiez une valeur hexadécimale. Par exemple, pour limiter le nombre de tas à 16, les valeurs doivent être 16 pour le fichier JSON et 0x10 ou 10 pour la variable d’environnement.

Masque d’affinités

Spécifie les processeurs exacts que les threads du garbage collector doivent utiliser.
Si l’affinité du processeur GC est désactivée, ce paramètre est ignoré.
S’applique uniquement au garbage collection de serveurs.
La valeur est un masque de bits qui définit les processeurs disponibles pour le processus. Par exemple, une valeur décimale de 1023 (ou une valeur hexadécimale de 0x3FF ou 3FF si vous utilisez la variable d’environnement) correspond à 0011 1111 1111 en notation binaire. Cela spécifie que les 10 premiers processeurs doivent être utilisés. Pour spécifier les 10 processeurs suivants, c’est-à-dire les processeurs 10-19, spécifiez une valeur décimale de 1047552 (ou une valeur hexadécimale de 0xFFC00 ou FFC00), ce qui équivaut à la valeur binaire 1111 1111 1100 0000 0000.

	Nom du paramètre	Valeurs	Version introduite
runtimeconfig.json	`System.GC.HeapAffinitizeMask`	valeur décimale	.NET Core 3.0
Variable d'environnement	`COMPlus_GCHeapAffinitizeMask`	valeur hexadécimale	.NET Core 3.0
Variable d'environnement	`DOTNET_GCHeapAffinitizeMask`	valeur hexadécimale	.NET 6
app.config pour .NET Framework	GCHeapAffinitizeMask	valeur décimale	.NET Framework 4.6.2

Exemples

Fichier runtimeconfig.json :

{
   "runtimeOptions": {
      "configProperties": {
         "System.GC.HeapAffinitizeMask": 1023
      }
   }
}

Fichier runtimeconfig.template.json :

{
   "configProperties": {
      "System.GC.HeapAffinitizeMask": 1023
   }
}

Plages d’affinités

Spécifie la liste des processeurs à utiliser pour les threads du récupérateur de mémoire.
Ce paramètre est semblable à System.GC.HeapAffinitizeMask, si ce n’est qu’il vous permet de spécifier plus de 64 processeurs.
Pour les systèmes d’exploitation Windows, préfixez la plage ou le numéro de processeur avec le groupe de processeurs correspondant, par exemple « 0:1-10,0:12,1:50-52,1:7 ». Si vous n’avez pas plus d’un groupe de CPU, vous ne pouvez pas utiliser ce paramètre. Vous devez utiliser le paramètre Affinitize mask. De plus, les nombres que vous spécifiez se trouvent dans ce groupe, ce qui signifie qu’il ne peut pas être >= 64.
Pour les systèmes d’exploitation Linux, où le concept de groupe de CPU n’existe pas, vous pouvez utiliser ce paramètre et le paramètre Affinitize mask pour spécifier les mêmes plages. Au lieu de « 0 :1-10 », spécifiez « 1-10 », car vous n’avez pas besoin de spécifier un index de groupe.
Si l’affinité du processeur GC est désactivée, ce paramètre est ignoré.
S’applique uniquement au garbage collection de serveurs.
Pour plus d’informations, consultez Making CPU configuration better for GC on machines with > 64 CPUs dans le blog de Maoni Stephens.

	Nom du paramètre	Valeurs	Version introduite
runtimeconfig.json	`System.GC.HeapAffinitizeRanges`	Liste séparée par des virgules des numéros de processeur ou des plages de numéros de processeur. Exemple Unix : « 1-10,12,50-52,70 » Exemple Windows : « 0:1-10,0:12,1:50-52,1:7 »	.NET Core 3.0
Variable d'environnement	`COMPlus_GCHeapAffinitizeRanges`	Liste séparée par des virgules des numéros de processeur ou des plages de numéros de processeur. Exemple Unix : « 1-10,12,50-52,70 » Exemple Windows : « 0:1-10,0:12,1:50-52,1:7 »	.NET Core 3.0
Variable d'environnement	`DOTNET_GCHeapAffinitizeRanges`	Liste séparée par des virgules des numéros de processeur ou des plages de numéros de processeur. Exemple Unix : « 1-10,12,50-52,70 » Exemple Windows : « 0:1-10,0:12,1:50-52,1:7 »	.NET 6

Exemples

Fichier runtimeconfig.json :

{
   "runtimeOptions": {
      "configProperties": {
         "System.GC.HeapAffinitizeRanges": "0:1-10,0:12,1:50-52,1:7"
      }
   }
}

Fichier runtimeconfig.template.json :

{
   "configProperties": {
      "System.GC.HeapAffinitizeRanges": "0:1-10,0:12,1:50-52,1:7"
   }
}

Groupes de processeurs

Configure si le garbage collector utilise ou non des groupes de processeurs.

Quand un ordinateur Windows 64 bits a plusieurs groupes de processeurs, c’est-à-dire qu’il y a plus de 64 processeurs, l’activation de cet élément étend le garbage collection à tous les groupes de processeurs. Le garbage collector utilise tous les cœurs pour créer et équilibrer les tas.

Remarque

Ce concept est réservé à Windows. Dans les versions antérieures de Windows, Windows a limité un processus à un groupe de CPU. Par conséquent, GC n’a utilisé qu’un seul groupe de CPU, sauf si vous avez utilisé ce paramètre pour activer plusieurs groupes de CPU. Cette limitation du système d’exploitation a été levée dans Windows 11 et Server 2022. En outre, à compter de .NET 7, GC utilise par défaut tous les groupes de CPU lors de l’exécution sur Windows 11 ou Server 2022.
S’applique au garbage collection de serveur sur les systèmes d’exploitation Windows 64 bits uniquement.
Par défaut : GC ne s’étend pas aux groupes de processeurs. Cela équivaut à définir la valeur sur 0.
Pour plus d’informations, consultez Making CPU configuration better for GC on machines with > 64 CPUs dans le blog de Maoni Stephens.

	Nom du paramètre	Valeurs	Version introduite
runtimeconfig.json	`System.GC.CpuGroup`	`false` - désactivé `true` – activé	.NET 5
Variable d'environnement	`COMPlus_GCCpuGroup`	`0` - désactivé `1` – activé	.NET Core 1.0
Variable d'environnement	`DOTNET_GCCpuGroup`	`0` - désactivé `1` – activé	.NET 6
app.config pour .NET Framework	GCCpuGroup	`false` - désactivé `true` – activé

Ce paramètre de configuration n’a pas de propriété MSBuild spécifique. Toutefois, vous pouvez ajouter un élément MSBuild RuntimeHostConfigurationOption à la place. Utilisez le nom du paramètre runtimeconfig.json comme valeur de l’attribut Include. Pour obtenir un exemple, consultez les propriétés MSBuild.

Remarque

Pour configurer le Common Language Runtime (CLR) afin de distribuer également les threads du pool de threads sur tous les groupes de processeurs, activez l’option d’élément Thread_UseAllCpuGroups. Pour les applications .NET Core, vous pouvez activer cette option en définissant la valeur de la variable d’environnement DOTNET_Thread_UseAllCpuGroups sur 1.

Créer des affinités

Spécifie s’il faut créer des affinités entre les threads de garbage collection et les processeurs. La création d’affinités d’un thread de GC signifie qu’il ne peut s’exécuter que sur son processeur spécifique. Un tas est créé pour chaque thread de GC.
S’applique uniquement au garbage collection de serveurs.
Par défaut : créer des affinités entre les threads de garbage collection et les processeurs. Ceci équivaut à définir la valeur sur false.

	Nom du paramètre	Valeurs	Version introduite
runtimeconfig.json	`System.GC.NoAffinitize`	`false` – créer des affinités `true` – ne pas créer d’affinités	.NET Core 3.0
Variable d'environnement	`COMPlus_GCNoAffinitize`	`0` – créer des affinités `1` – ne pas créer d’affinités	.NET Core 3.0
Variable d'environnement	`DOTNET_GCNoAffinitize`	`0` – créer des affinités `1` – ne pas créer d’affinités	.NET 6
app.config pour .NET Framework	GCNoAffinitize	`false` – créer des affinités `true` – ne pas créer d’affinités	.NET Framework 4.6.2

Exemples

Fichier runtimeconfig.json :

{
   "runtimeOptions": {
      "configProperties": {
         "System.GC.NoAffinitize": true
      }
   }
}

Fichier runtimeconfig.template.json :

{
   "configProperties": {
      "System.GC.NoAffinitize": true
   }
}

Limite matérielle du tas

La limite matérielle du tas est définie comme la taille maximale de validation, en octets, pour le tas GC et la comptabilité GC.
Ce paramètre s’applique uniquement aux ordinateurs 64 bits.
Si cette limite n’est pas configurée, mais que le processus s’exécute dans un environnement limité en mémoire, c’est-à-dire à l’intérieur d’un conteneur avec une limite de mémoire spécifiée, une valeur par défaut est définie. Cette valeur par défaut est supérieure à 20 Mo ou 75 % de la limite de mémoire sur le conteneur.
Ce paramètre est ignoré si les limites matérielles par objet-tas sont configurées.

	Nom du paramètre	Valeurs	Version introduite
runtimeconfig.json	`System.GC.HeapHardLimit`	valeur décimale	.NET Core 3.0
Variable d'environnement	`COMPlus_GCHeapHardLimit`	valeur hexadécimale	.NET Core 3.0
Variable d'environnement	`DOTNET_GCHeapHardLimit`	valeur hexadécimale	.NET 6

Exemples

Fichier runtimeconfig.json :

{
   "runtimeOptions": {
      "configProperties": {
         "System.GC.HeapHardLimit": 209715200
      }
   }
}

Fichier runtimeconfig.template.json :

{
   "configProperties": {
      "System.GC.HeapHardLimit": 209715200
   }
}

Conseil

Si vous définissez l’option dans runtimeconfig.json, spécifiez une valeur décimale. Si vous définissez l’option en tant que variable d’environnement, spécifiez une valeur hexadécimale. Par exemple, pour spécifier une limite imposée de tas de 200 mébioctets (Mio), les valeurs sont 209715200 pour le fichier JSON et 0xC800000 ou C800000 pour la variable d’environnement.

Pourcentage de limite de tas dur

Spécifie la limite matérielle du tas sous la forme d’un pourcentage de la mémoire physique totale. Si le processus s’exécute dans un environnement limité en mémoire, autrement dit, à l’intérieur d’un conteneur avec une limite de mémoire spécifiée, la mémoire physique totale est la limite de mémoire ; sinon, il s’agit de ce qui est disponible sur la machine.
Ce paramètre s’applique uniquement aux ordinateurs 64 bits.
Ce paramètre est ignoré si les limites matérielles par objet-tas sont configurées ou si la limite matérielle du tas est configurée.

	Nom du paramètre	Valeurs	Version introduite
runtimeconfig.json	`System.GC.HeapHardLimitPercent`	valeur décimale	.NET Core 3.0
Variable d'environnement	`COMPlus_GCHeapHardLimitPercent`	valeur hexadécimale	.NET Core 3.0
Variable d'environnement	`DOTNET_GCHeapHardLimitPercent`	valeur hexadécimale	.NET 6

Exemples

Fichier runtimeconfig.json :

{
   "runtimeOptions": {
      "configProperties": {
         "System.GC.HeapHardLimitPercent": 30
      }
   }
}

Fichier runtimeconfig.template.json :

{
   "configProperties": {
      "System.GC.HeapHardLimitPercent": 30
   }
}

Conseil

Si vous définissez l’option dans runtimeconfig.json, spécifiez une valeur décimale. Si vous définissez l’option en tant que variable d’environnement, spécifiez une valeur hexadécimale. Par exemple, pour limiter l’utilisation de tas à 30 %, les valeurs doivent être 30 pour le fichier JSON et 0x1E ou 1E pour la variable d’environnement.

Limites matérielles par objet-tas

Vous pouvez spécifier la limite matérielle du tas du GC sur une base par objet-tas. Les différents tas correspondent au tas d’objets volumineux (LOH), au tas de petits objets (SOH) et au tas d’objets épinglés (POH).

Si vous spécifiez une valeur pour l’un des paramètres DOTNET_GCHeapHardLimitSOH, DOTNET_GCHeapHardLimitLOH ou DOTNET_GCHeapHardLimitPOH, vous devez également spécifier une valeur pour DOTNET_GCHeapHardLimitSOH et DOTNET_GCHeapHardLimitLOH. Dans le cas contraire, l’initialisation du runtime échoue.
La valeur par défaut pour DOTNET_GCHeapHardLimitPOH est 0. DOTNET_GCHeapHardLimitSOH et DOTNET_GCHeapHardLimitLOH n’ont pas de valeurs par défaut.

	Nom du paramètre	Valeurs	Version introduite
runtimeconfig.json	`System.GC.HeapHardLimitSOH`	valeur décimale	.NET 5
Variable d'environnement	`COMPlus_GCHeapHardLimitSOH`	valeur hexadécimale	.NET 5
Variable d'environnement	`DOTNET_GCHeapHardLimitSOH`	valeur hexadécimale	.NET 6

	Nom du paramètre	Valeurs	Version introduite
runtimeconfig.json	`System.GC.HeapHardLimitLOH`	valeur décimale	.NET 5
Variable d'environnement	`COMPlus_GCHeapHardLimitLOH`	valeur hexadécimale	.NET 5
Variable d'environnement	`DOTNET_GCHeapHardLimitLOH`	valeur hexadécimale	.NET 6

	Nom du paramètre	Valeurs	Version introduite
runtimeconfig.json	`System.GC.HeapHardLimitPOH`	valeur décimale	.NET 5
Variable d'environnement	`COMPlus_GCHeapHardLimitPOH`	valeur hexadécimale	.NET 5
Variable d'environnement	`DOTNET_GCHeapHardLimitPOH`	valeur hexadécimale	.NET 6

Ces paramètres de configuration n'a pas de propriétés MSBuild spécifiques. Toutefois, vous pouvez ajouter un élément MSBuild RuntimeHostConfigurationOption à la place. Utilisez le nom du paramètre runtimeconfig.json comme valeur de l’attribut Include. Pour obtenir un exemple, consultez les propriétés MSBuild.

Conseil

Si vous définissez l’option dans runtimeconfig.json, spécifiez une valeur décimale. Si vous définissez l’option en tant que variable d’environnement, spécifiez une valeur hexadécimale. Par exemple, pour spécifier une limite imposée de tas de 200 mébioctets (Mio), les valeurs sont 209715200 pour le fichier JSON et 0xC800000 ou C800000 pour la variable d’environnement.

Pourcentages de limite matérielle par objet-tas

Si vous spécifiez une valeur pour l’un des paramètres DOTNET_GCHeapHardLimitSOHPercent, DOTNET_GCHeapHardLimitLOHPercent ou DOTNET_GCHeapHardLimitPOHPercent, vous devez également spécifier une valeur pour DOTNET_GCHeapHardLimitSOHPercent et DOTNET_GCHeapHardLimitLOHPercent. Dans le cas contraire, l’initialisation du runtime échoue.
Ces paramètres sont ignorés si DOTNET_GCHeapHardLimitSOH, DOTNET_GCHeapHardLimitLOH et DOTNET_GCHeapHardLimitPOH sont spécifiés.
La valeur 1 signifie que le garbage collection utilise 1 % de la mémoire physique totale pour ce tas d’objets.
Chaque valeur doit être supérieure à zéro et inférieure à 100. En outre, la somme des trois valeurs de pourcentage doit être inférieure à 100. Dans le cas contraire, l’initialisation du runtime échoue.

	Nom du paramètre	Valeurs	Version introduite
runtimeconfig.json	`System.GC.HeapHardLimitSOHPercent`	valeur décimale	.NET 5
Variable d'environnement	`COMPlus_GCHeapHardLimitSOHPercent`	valeur hexadécimale	.NET 5
Variable d'environnement	`DOTNET_GCHeapHardLimitSOHPercent`	valeur hexadécimale	.NET 6

	Nom du paramètre	Valeurs	Version introduite
runtimeconfig.json	`System.GC.HeapHardLimitLOHPercent`	valeur décimale	.NET 5
Variable d'environnement	`COMPlus_GCHeapHardLimitLOHPercent`	valeur hexadécimale	.NET 5
Variable d'environnement	`DOTNET_GCHeapHardLimitLOHPercent`	valeur hexadécimale	.NET 6

	Nom du paramètre	Valeurs	Version introduite
runtimeconfig.json	`System.GC.HeapHardLimitPOHPercent`	valeur décimale	.NET 5
Variable d'environnement	`COMPlus_GCHeapHardLimitPOHPercent`	valeur hexadécimale	.NET 5
Variable d'environnement	`DOTNET_GCHeapHardLimitPOHPercent`	valeur hexadécimale	.NET 6

Conseil

Si vous définissez l’option dans runtimeconfig.json, spécifiez une valeur décimale. Si vous définissez l’option en tant que variable d’environnement, spécifiez une valeur hexadécimale. Par exemple, pour limiter l’utilisation de tas à 30 %, les valeurs doivent être 30 pour le fichier JSON et 0x1E ou 1E pour la variable d’environnement.

Pourcentage de mémoire élevé

La charge de mémoire est indiquée par le pourcentage de mémoire physique utilisée. Par défaut, quand la charge de mémoire physique atteint 90 %, le garbage collection devient plus agressif pour effectuer un nettoyage de la mémoire complet et compact afin d’éviter la pagination. Lorsque la charge de mémoire est inférieure à 90 %, le GC favorise les collections en arrière-plan pour effectuer des garbage collections complets qui effectuent des pauses plus courtes mais ne réduisent pas de beaucoup la taille totale des tas. Sur les machines dotées d’une quantité importante de mémoire (80 Go ou plus), le seuil de charge par défaut est compris entre 90 % et 97 %.

Le seuil de charge de mémoire élevé peut être ajusté par la variable d’environnement DOTNET_GCHighMemPercent ou par le paramètre de configuration JSON System.GC.HighMemoryPercent. Envisagez d’ajuster le seuil si vous souhaitez contrôler la taille de tas. Par exemple, pour le processus dominant sur une machine dotée de 64 Go de mémoire, il est raisonnable que le garbage collection commence à réagir quand 10 % de mémoire est disponible. Toutefois, pour les processus plus petits, par exemple, un processus qui ne consomme que 1 Go de mémoire, le garbage collection peut s’exécuter confortablement avec moins de 10 % de mémoire disponible. Pour ces plus petits processus, envisagez de définir un seuil plus élevé. D’un autre côté, si vous souhaitez que les processus plus volumineux aient des tailles de tas plus petites (même lorsqu’il y a beaucoup de mémoire physique disponible), l’abaissement de ce seuil est un moyen efficace pour faire réagir plus tôt le garbage collection pour compacter le tas.

Notes

Pour les processus s’exécutant dans un conteneur, le GC considère la mémoire physique en fonction de la limite de conteneur.

	Nom du paramètre	Valeurs	Version introduite
runtimeconfig.json	`System.GC.HighMemoryPercent`	valeur décimale	.NET 5
Variable d'environnement	`COMPlus_GCHighMemPercent`	valeur hexadécimale	.NET Core 3.0 .NET Framework 4.7.2
Variable d'environnement	`DOTNET_GCHighMemPercent`	valeur hexadécimale	.NET 6

Conseil

Si vous définissez l’option dans runtimeconfig.json, spécifiez une valeur décimale. Si vous définissez l’option en tant que variable d’environnement, spécifiez une valeur hexadécimale. Par exemple, pour définir le seuil de mémoire élevé sur 75 %, les valeurs sont 75 pour le fichier JSON et 0x4B ou 4B pour la variable d’environnement.

Conserver la machine virtuelle

Configure si les segments qui doivent être supprimés sont placés sur une liste d’attente pour une utilisation ultérieure ou s’ils sont remis au système d’exploitation (SE).
Par défaut : libérer les segments pour le système d’exploitation. Ceci équivaut à définir la valeur sur false.

	Nom du paramètre	Valeurs	Version introduite
runtimeconfig.json	`System.GC.RetainVM`	`false` – libérer pour le système d’exploitation `true` – mettre en attente	.NET Core 1.0
Propriété MSBuild	`RetainVMGarbageCollection`	`false` – libérer pour le système d’exploitation `true` – mettre en attente	.NET Core 1.0
Variable d'environnement	`COMPlus_GCRetainVM`	`0` – libérer pour le système d’exploitation `1` – mettre en attente	.NET Core 1.0
Variable d'environnement	`DOTNET_GCRetainVM`	`0` – libérer pour le système d’exploitation `1` – mettre en attente	.NET 6

Exemples

Fichier runtimeconfig.json :

{
   "runtimeOptions": {
      "configProperties": {
         "System.GC.RetainVM": true
      }
   }
}

Fichier runtimeconfig.template.json :

{
   "configProperties": {
      "System.GC.RetainVM": true
   }
}

Fichier projet :

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <RetainVMGarbageCollection>true</RetainVMGarbageCollection>
  </PropertyGroup>

</Project>

Pages volumineuses

Spécifie si des pages volumineuses doivent être utilisées quand une limite imposée de tas est définie.
Par défaut : ne pas utiliser de pages volumineuses quand une limite imposée de tas est définie. Cela équivaut à définir la valeur sur 0.
Il s’agit d’un paramètre expérimental.

	Nom du paramètre	Valeurs	Version introduite
runtimeconfig.json	N/A	N/A	N/A
Variable d'environnement	`COMPlus_GCLargePages`	`0` - désactivé `1` – activé	.NET Core 3.0
Variable d'environnement	`DOTNET_GCLargePages`	`0` - désactivé `1` – activé	.NET 6

Autoriser les objets volumineux

Configure la prise en charge du garbage collector sur les plateformes 64 bits pour les tableaux dont la taille totale dépasse 2 gigaoctets (Go).
Par défaut : le GC prend en charge les tableaux de plus de 2 Go. Ceci équivaut à définir la valeur sur 1.
Cette option peut devenir obsolète dans une prochaine version de .NET.

	Nom du paramètre	Valeurs	Version introduite
runtimeconfig.json	N/A	N/A	N/A
Variable d'environnement	`COMPlus_gcAllowVeryLargeObjects`	`1` – activé `0` - désactivé	.NET Core 1.0
Variable d'environnement	`DOTNET_gcAllowVeryLargeObjects`	`1` – activé `0` - désactivé	.NET 6
app.config pour .NET Framework	gcAllowVeryLargeObjects	`1` – activé `0` - désactivé	.NET Framework 4.5

Seuil du tas d’objets volumineux

Spécifie la taille du seuil, en octets, au dessus de laquelle les objets sont dirigés vers le tas d’objets volumineux (LOH).
Le seuil par défaut est de 85 000 octets.
La valeur que vous spécifiez doit être supérieure au seuil par défaut.
La valeur peut être plafonnée par la durée d'exécution à la taille maximale possible pour la configuration actuelle. Vous pouvez inspecter la valeur en cours d’utilisation au moment de l’exécution via l’API GC.GetConfigurationVariables().

	Nom du paramètre	Valeurs	Version introduite
runtimeconfig.json	`System.GC.LOHThreshold`	valeur décimale	.NET Core 1.0
Variable d'environnement	`COMPlus_GCLOHThreshold`	valeur hexadécimale	.NET Core 1.0
Variable d'environnement	`DOTNET_GCLOHThreshold`	valeur hexadécimale	.NET 6
app.config pour .NET Framework	GCLOHThreshold	valeur décimale	.NET Framework 4.8

Exemples

Fichier runtimeconfig.json :

{
   "runtimeOptions": {
      "configProperties": {
         "System.GC.LOHThreshold": 120000
      }
   }
}

Fichier runtimeconfig.template.json :

{
   "configProperties": {
      "System.GC.LOHThreshold": 120000
   }
}

Conseil

Si vous définissez l’option dans runtimeconfig.json, spécifiez une valeur décimale. Si vous définissez l’option en tant que variable d’environnement, spécifiez une valeur hexadécimale. Par exemple, pour définir une taille de seuil de 120 000 octets, les valeurs sont 120000 pour le fichier JSON et 0x1D4C0 ou 1D4C0 pour la variable d’environnement.

GC autonome

Pour utiliser un garbage collector autonome au lieu de l’implémentation GC par défaut, vous pouvez spécifier le chemin d’accès (dans .NET 9 et versions ultérieures) ou le nom d’une bibliothèque native GC.

Chemin d’accès

Spécifie le chemin complet d’une bibliothèque native GC que le runtime charge à la place de l’implémentation GC par défaut. Pour être sécurisé, cet emplacement doit être protégé contre les falsifications potentiellement malveillantes.

	Nom du paramètre	Valeurs	Version introduite
runtimeconfig.json	`System.GC.Path`	string_path	.NET 9
Variable d'environnement	`DOTNET_GCPath`	string_path	.NET 9

Nom

Spécifie le nom d’une bibliothèque native GC que le runtime charge à la place de l’implémentation GC par défaut. Le comportement a changé dans .NET 9 avec l’introduction de la configuration path .

Dans .NET 8 et les versions précédentes :
- Si seul un nom de la bibliothèque est spécifié, la bibliothèque doit résider dans le même répertoire que le runtime .NET (coreclr.dll sur Windows, libcoreclr.so sur Linux ou libcoreclr.dylib sur OSX).
- La valeur peut également être un chemin relatif, par exemple, si vous spécifiez .. \clrgc.dll » sur Windows, clrgc.dll est chargé à partir du répertoire parent du répertoire du runtime .NET.
Dans .NET 9 et versions ultérieures, cette valeur spécifie un nom de fichier uniquement (les chemins d’accès ne sont pas autorisés) :
- .NET recherche le nom que vous spécifiez dans le répertoire où réside l’assembly qui contient la méthode de Main votre application.
- Si le fichier est introuvable, le répertoire du runtime .NET est recherché.
Ce paramètre de configuration est ignoré si la configuration du chemin d’accès est spécifiée.

	Nom du paramètre	Valeurs	Version introduite
runtimeconfig.json	`System.GC.Name`	string_name	.NET 7
Variable d'environnement	`COMPlus_GCName`	string_name	.NET Core 2.0
Variable d'environnement	`DOTNET_GCName`	string_name	.NET 6

Conserver la mémoire

Configure le récupérateur de mémoire pour conserver la mémoire, au prix de nettoyages de la mémoire plus fréquents et de temps de pause éventuellement plus longs.
La valeur par défaut est 0 : cela n’implique aucune modification.
Outre la valeur par défaut 0, les valeurs comprises entre 1 et 9 (inclus) sont valides. Plus la valeur est élevée, plus le récupérateur de mémoire tente de conserver la mémoire et donc de garder le tas petit.
Si la valeur est différente de zéro, le tas d’objets volumineux est compacté automatiquement s’il est trop fragmenté.

	Nom du paramètre	Valeurs	Version introduite
runtimeconfig.json	`System.GC.ConserveMemory`	`0` - `9`	.NET 6
Variable d’environnement	`COMPlus_GCConserveMemory`	`0` -`9`	.NET Framework 4.8
Variable d'environnement	`DOTNET_GCConserveMemory`	`0` -`9`	.NET 6
app.config pour .NET Framework	GCConserveMemory	`0` -`9`	.NET Framework 4.8

Exemple de fichier app.config :


<configuration>
  <runtime>
    <GCConserveMemory enabled="5"/>
  </runtime>
</configuration>

Conseil

Testez différents nombres pour voir quelle valeur vous convient le mieux. Commencez par une valeur comprise entre 5 et 7.

DATAS (Dynamic Adaptation To Application Sizes)

Configure le garbage collector pour utiliser DATAS. DATAS s’adapte aux besoins en mémoire de l’application, ce qui signifie que la taille du tas de l’application doit être proportionnelle à la taille des données de longue durée.
Activé par défaut à partir de .NET 9.

	Nom du paramètre	Valeurs	Version introduite
Variable d'environnement	`DOTNET_GCDynamicAdaptationMode`	`1` – activé `0` - désactivé	.NET 8
Propriété MSBuild	`GarbageCollectionAdaptationMode`	`1` - activé `0` - désactivé	.NET 8
runtimeconfig.json	`System.GC.DynamicAdaptationMode`	`1` - activé `0` - désactivé	.NET 8

Partager via

Options de configuration du runtime pour le garbage collection

Méthodes de spécification de la configuration

Saveurs du garbage collection

Station de travail ou serveur

Exemples

GC d’arrière-plan

Exemples

Gérer l’utilisation des ressources

Nombre de tas

Exemples

Masque d’affinités

Exemples

Plages d’affinités

Exemples

Groupes de processeurs

Créer des affinités

Exemples

Limite matérielle du tas

Exemples

Pourcentage de limite de tas dur

Exemples

Limites matérielles par objet-tas

Pourcentages de limite matérielle par objet-tas

Pourcentage de mémoire élevé

Conserver la machine virtuelle

Exemples

Pages volumineuses

Autoriser les objets volumineux

Seuil du tas d’objets volumineux

Exemples

GC autonome

Chemin d’accès

Nom

Conserver la mémoire

DATAS (Dynamic Adaptation To Application Sizes)

Ressources supplémentaires