Runtimeconfiguratieopties voor garbagecollection

Artikel
08/09/2024

Deze pagina bevat informatie over instellingen voor de .NET Runtime garbage collector (GC). Als u probeert piekprestaties van een actieve app te bereiken, kunt u overwegen deze instellingen te gebruiken. De standaardinstellingen bieden echter optimale prestaties voor de meeste toepassingen in typische situaties.

Instellingen zijn gerangschikt in groepen op deze pagina. De instellingen binnen elke groep worden vaak gebruikt in combinatie met elkaar om een specifiek resultaat te bereiken.

Notitie

Deze configuraties worden alleen gelezen door de runtime wanneer de GC wordt geïnitialiseerd (meestal betekent dit tijdens de opstarttijd van het proces). Als u een omgevingsvariabele wijzigt wanneer een proces al wordt uitgevoerd, wordt de wijziging niet doorgevoerd in dat proces. Instellingen die tijdens runtime kunnen worden gewijzigd via API's, zoals latentieniveau, worden van deze pagina weggelaten.
Omdat GC per proces is, is het zelden zinvol om deze configuraties op machineniveau in te stellen. U wilt bijvoorbeeld niet dat elk .NET-proces op een computer server GC of dezelfde heap harde limiet gebruikt.
Gebruik voor getalwaarden decimaalnotatie voor instellingen in het bestand runtimeconfig.json of runtimeconfig.template.json en hexadecimale notatie voor omgevingsvariabeleinstellingen. Voor hexadecimale waarden kunt u deze opgeven met of zonder het voorvoegsel '0x'.
Als u de omgevingsvariabelen gebruikt, worden .NET 6 en nieuwere versies standaardiseren op het voorvoegsel DOTNET_ in plaats van COMPlus_. COMPlus_ Het voorvoegsel blijft echter werken. Als u een eerdere versie van de .NET-runtime gebruikt, moet u nog steeds het COMPlus_ voorvoegsel gebruiken, bijvoorbeeld COMPlus_gcServer.

Manieren om de configuratie op te geven

Voor verschillende versies van de .NET-runtime zijn er verschillende manieren om de configuratiewaarden op te geven. In de volgende tabel ziet u een samenvatting.

Configuratielocatie	.NET-versies waarop deze locatie van toepassing is	Notaties	Hoe het wordt geïnterpreteerd
bestand/ runtimeconfig.template.json bestand runtimeconfig.json	.NET (Core)	n	n wordt geïnterpreteerd als een decimale waarde.
Omgevingsvariabele	.NET Framework, .NET (Core)	0xn of n	n wordt geïnterpreteerd als een hexwaarde in beide indelingen
bestand app.config	.NET Framework	0xn	n wordt geïnterpreteerd als een hexwaarde¹

¹ U kunt een waarde opgeven zonder het 0x voorvoegsel voor een app.config-bestandsinstelling, maar dit wordt niet aanbevolen. In .NET Framework 4.8+, vanwege een fout, wordt een waarde die zonder voorvoegsel 0x is opgegeven, geïnterpreteerd als hexadecimaal, maar in eerdere versies van .NET Framework wordt deze geïnterpreteerd als decimaal. Gebruik het voorvoegsel bij het 0x opgeven van een waarde in uw app.config-bestand om te voorkomen dat u de configuratie hoeft te wijzigen.

Als u bijvoorbeeld 12 heaps wilt opgeven voor GCHeapCount een .NET Framework-app met de naam A.exe, voegt u de volgende XML toe aan het bestand A.exe.config .

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

Voor zowel .NET (Core) als .NET Framework kunt u omgevingsvariabelen gebruiken.

In Windows met .NET 6 of een latere versie:

SET DOTNET_gcServer=1
SET DOTNET_GCHeapCount=c

In Windows met .NET 5 of eerder:

SET COMPlus_gcServer=1
SET COMPlus_GCHeapCount=c

Op andere besturingssystemen:

Voor .NET 6 of nieuwere versies:

export DOTNET_gcServer=1
export DOTNET_GCHeapCount=c

Voor .NET 5 en eerdere versies:

export COMPlus_gcServer=1
export COMPlus_GCHeapCount=c

Als u .NET Framework niet gebruikt, kunt u ook de waarde instellen in het bestand runtimeconfig.json of runtimeconfig.template.json .

runtimeconfig.json bestand:

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

runtimeconfig.template.json bestand:

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

Smaken van garbagecollection

De twee belangrijkste smaken van garbagecollection zijn werkstation GC en server GC. Zie Werkstation en server garbagecollection voor meer informatie over verschillen tussen de twee.

De subflavors van garbagecollection zijn achtergrond en niet-gelijktijdig.

Gebruik de volgende instellingen om smaken van garbagecollection te selecteren:

Werkstation versus server GC
Achtergrond GC

Werkstation versus server

Hiermee configureert u of de toepassing gebruikmaakt van garbagecollection voor werkstations of de garbagecollection van de server.
Standaard: Garbagecollection van werkstation. Dit komt overeen met het instellen van de waarde op false.

	Naam instelling	Waarden	Versie geïntroduceerd
runtimeconfig.json	`System.GC.Server`	`false` -Workstation `true` -server	.NET Core 1.0
MSBuild-eigenschap	`ServerGarbageCollection`	`false` -Workstation `true` -server	.NET Core 1.0
Omgevingsvariabele	`COMPlus_gcServer`	`0` -Workstation `1` -server	.NET Core 1.0
Omgevingsvariabele	`DOTNET_gcServer`	`0` -Workstation `1` -server	.NET 6
app.config voor .NET Framework	GCServer	`false` -Workstation `true` -server

Voorbeelden

runtimeconfig.json bestand:

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

runtimeconfig.template.json bestand:

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

Projectbestand:

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

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

</Project>

Achtergrond GC

Hiermee configureert u of de achtergrond (gelijktijdige) garbagecollection is ingeschakeld.
Standaard: gebruik achtergrond-GC. Dit komt overeen met het instellen van de waarde op true.
Zie Achtergrond garbagecollection voor meer informatie.

	Naam instelling	Waarden	Versie geïntroduceerd
runtimeconfig.json	`System.GC.Concurrent`	`true` - achtergrond GC `false` - niet-gelijktijdige GC	.NET Core 1.0
MSBuild-eigenschap	`ConcurrentGarbageCollection`	`true` - achtergrond GC `false` - niet-gelijktijdige GC	.NET Core 1.0
Omgevingsvariabele	`COMPlus_gcConcurrent`	`1` - achtergrond GC `0` - niet-gelijktijdige GC	.NET Core 1.0
Omgevingsvariabele	`DOTNET_gcConcurrent`	`1` - achtergrond GC `0` - niet-gelijktijdige GC	.NET 6
app.config voor .NET Framework	gcConcurrent	`true` - achtergrond GC `false` - niet-gelijktijdige GC

Voorbeelden

runtimeconfig.json bestand:

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

runtimeconfig.template.json bestand:

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

Projectbestand:

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

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

</Project>

Resourcegebruik beheren

Gebruik de volgende instellingen om het geheugen- en processorgebruik van de garbagecollector te beheren:

Affiniteit
Affiniteitsmasker
Affiniteitsbereiken
CPU-groepen
Heap count
Harde limiet voor heap
Heap harde limietpercentage
Harde limieten per object-heap
Harde limieten per object-heap
Hoog geheugenpercentage
VM behouden

Zie de middle ground between workstation and server GC blog entry voor meer informatie over een aantal van deze instellingen.

Heap count

Beperkt het aantal heaps dat door de garbagecollector is gemaakt.
Alleen van toepassing op de garbagecollection van de server.
Als GC-processoraffiniteit is ingeschakeld, wat de standaardinstelling is, n worden GC-heaps/threads ingesteld op de eerste n processors. (Gebruik de instellingen voor affiniteitsmasker of affiniteitsbereiken om precies op te geven welke processors moeten worden geaffineerd.)
Als GC-processoraffiniteit is uitgeschakeld, beperkt deze instelling het aantal GC-heaps.
Zie de opmerkingen van GCHeapCount voor meer informatie.

	Naam instelling	Waarden	Versie geïntroduceerd
runtimeconfig.json	`System.GC.HeapCount`	decimale waarde	.NET Core 3.0
Omgevingsvariabele	`COMPlus_GCHeapCount`	hexadecimale waarde	.NET Core 3.0
Omgevingsvariabele	`DOTNET_GCHeapCount`	hexadecimale waarde	.NET 6
app.config voor .NET Framework	GCHeapCount	decimale waarde	.NET Framework 4.6.2

Deze configuratie-instelling heeft geen specifieke MSBuild-eigenschap. U kunt echter in plaats daarvan een RuntimeHostConfigurationOption MSBuild-item toevoegen. Gebruik de naam van de instelling runtimeconfig.json als de waarde van het Include kenmerk. Zie MSBuild-eigenschappen voor een voorbeeld.

Voorbeelden

runtimeconfig.json bestand:

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

runtimeconfig.template.json bestand:

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

Tip

Als u de optie instelt in runtimeconfig.json, geeft u een decimale waarde op. Als u de optie instelt als een omgevingsvariabele, geeft u een hexadecimale waarde op. Als u bijvoorbeeld het aantal heaps wilt beperken tot 16, zijn de waarden 16 voor het JSON-bestand en 0x10 of 10 voor de omgevingsvariabele.

Affiniteitsmasker

Hiermee geeft u de exacte processors die garbagecollection threads moeten gebruiken.
Als GC-processoraffiniteit is uitgeschakeld, wordt deze instelling genegeerd.
Alleen van toepassing op de garbagecollection van de server.
De waarde is een bitmasker dat de processors definieert die beschikbaar zijn voor het proces. Een decimale waarde van 1023 (of een hexadecimale waarde van 0x3FF of 3FF als u de omgevingsvariabele gebruikt) is bijvoorbeeld 0011 1111 1111 in binaire notatie. Hiermee geeft u op dat de eerste 10 processors moeten worden gebruikt. Als u de volgende 10 processors wilt opgeven, dat wil gezegd: processors 10-19, geeft u een decimale waarde van 1047552 (of een hexadecimale waarde van 0xFFC00 of FFC00), die gelijk is aan een binaire waarde van 1111 1111 1100 0000 0000.

	Naam instelling	Waarden	Versie geïntroduceerd
runtimeconfig.json	`System.GC.HeapAffinitizeMask`	decimale waarde	.NET Core 3.0
Omgevingsvariabele	`COMPlus_GCHeapAffinitizeMask`	hexadecimale waarde	.NET Core 3.0
Omgevingsvariabele	`DOTNET_GCHeapAffinitizeMask`	hexadecimale waarde	.NET 6
app.config voor .NET Framework	GCHeapAffinitizeMask	decimale waarde	.NET Framework 4.6.2

Voorbeelden

runtimeconfig.json bestand:

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

runtimeconfig.template.json bestand:

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

Affiniteitsbereiken

Hiermee geeft u de lijst met processors te gebruiken voor garbagecollection threads.
Deze instelling is vergelijkbaar met System.GC.HeapAffinitizeMask, behalve dat u meer dan 64 processors kunt opgeven.
Voor Windows-besturingssystemen moet u het processornummer of bereik vooraf laten gaan aan de bijbehorende CPU-groep, bijvoorbeeld '0:1-10,0:12,1:50-52,1:7'. Als u niet meer dan 1 CPU-groep hebt, kunt u deze instelling niet gebruiken. U moet de instelling Affinitize-masker gebruiken. En de getallen die u opgeeft, bevinden zich binnen die groep, wat betekent dat het niet = 64 kan zijn >.
Voor Linux-besturingssystemen, waarbij het concept van de CPU-groep niet bestaat, kunt u deze instelling en de instelling Affinitize-masker gebruiken om dezelfde bereiken op te geven. En in plaats van '0:1-10' geeft u '1-10' op omdat u geen groepsindex hoeft op te geven.
Als GC-processoraffiniteit is uitgeschakeld, wordt deze instelling genegeerd.
Alleen van toepassing op de garbagecollection van de server.
Zie Cpu-configuratie verbeteren voor GC op machines met > 64 CPU's op de blog van Maoni Stephens voor meer informatie.

	Naam instelling	Waarden	Versie geïntroduceerd
runtimeconfig.json	`System.GC.HeapAffinitizeRanges`	Door komma's gescheiden lijst met processornummers of bereiken van processornummers. Unix-voorbeeld: "1-10,12,50-52,70" Windows-voorbeeld: "0:1-10,0:12,1:50-52,1:7"	.NET Core 3.0
Omgevingsvariabele	`COMPlus_GCHeapAffinitizeRanges`	Door komma's gescheiden lijst met processornummers of bereiken van processornummers. Unix-voorbeeld: "1-10,12,50-52,70" Windows-voorbeeld: "0:1-10,0:12,1:50-52,1:7"	.NET Core 3.0
Omgevingsvariabele	`DOTNET_GCHeapAffinitizeRanges`	Door komma's gescheiden lijst met processornummers of bereiken van processornummers. Unix-voorbeeld: "1-10,12,50-52,70" Windows-voorbeeld: "0:1-10,0:12,1:50-52,1:7"	.NET 6

Voorbeelden

runtimeconfig.json bestand:

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

runtimeconfig.template.json bestand:

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

CPU-groepen

Hiermee configureert u of de garbagecollector CPU-groepen gebruikt of niet.

Wanneer een 64-bits Windows-computer meerdere CPU-groepen heeft, zijn er meer dan 64 processors, waardoor dit element de garbagecollection voor alle CPU-groepen uitbreidt. De garbagecollector gebruikt alle kernen om heaps te maken en te verdelen.

Notitie

Dit is een windows-only concept. In oudere Windows-versies beperkt Windows een proces tot één CPU-groep. GC heeft dus slechts één CPU-groep gebruikt, tenzij u deze instelling hebt gebruikt om meerdere CPU-groepen in te schakelen. Deze beperking van het besturingssysteem is opgeheven in Windows 11 en Server 2022. Vanaf .NET 7 gebruikt GC standaard alle CPU-groepen wanneer ze worden uitgevoerd op Windows 11 of Server 2022.
Alleen van toepassing op de garbagecollection van de server op 64-bits Windows-besturingssystemen.
Standaard: GC wordt niet uitgebreid tussen CPU-groepen. Dit komt overeen met het instellen van de waarde op 0.
Zie Cpu-configuratie verbeteren voor GC op machines met > 64 CPU's op de blog van Maoni Stephens voor meer informatie.

	Naam instelling	Waarden	Versie geïntroduceerd
runtimeconfig.json	`System.GC.CpuGroup`	`false` -invalide `true` -Ingeschakeld	.NET 5
Omgevingsvariabele	`COMPlus_GCCpuGroup`	`0` -invalide `1` -Ingeschakeld	.NET Core 1.0
Omgevingsvariabele	`DOTNET_GCCpuGroup`	`0` -invalide `1` -Ingeschakeld	.NET 6
app.config voor .NET Framework	GCCpuGroup	`false` -invalide `true` -Ingeschakeld

Notitie

Als u de Common Language Runtime (CLR) wilt configureren om ook threads uit de threadgroep over alle CPU-groepen te distribueren, schakelt u de optie Thread_UseAllCpuGroups element in. Voor .NET Core-apps kunt u deze optie inschakelen door de waarde van de DOTNET_Thread_UseAllCpuGroups omgevingsvariabele in te stellen op 1.

Affiniteit

Hiermee geeft u op of u threads voor garbagecollection wilt affinitiseren met processors. Als u een GC-thread wilt affinitiseren, betekent dit dat deze alleen kan worden uitgevoerd op de specifieke CPU. Er wordt een heap gemaakt voor elke GC-thread.
Alleen van toepassing op de garbagecollection van de server.
Standaard: Affiniteit met threads voor garbagecollection met processors. Dit komt overeen met het instellen van de waarde op false.

	Naam instelling	Waarden	Versie geïntroduceerd
runtimeconfig.json	`System.GC.NoAffinitize`	`false` - affiniteit `true` - geen affiniteit	.NET Core 3.0
Omgevingsvariabele	`COMPlus_GCNoAffinitize`	`0` - affiniteit `1` - geen affiniteit	.NET Core 3.0
Omgevingsvariabele	`DOTNET_GCNoAffinitize`	`0` - affiniteit `1` - geen affiniteit	.NET 6
app.config voor .NET Framework	GCNoAffinitize	`false` - affiniteit `true` - geen affiniteit	.NET Framework 4.6.2

Voorbeelden

runtimeconfig.json bestand:

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

runtimeconfig.template.json bestand:

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

Harde limiet voor heap

De heap harde limiet wordt gedefinieerd als de maximale doorvoergrootte, in bytes, voor de GC-heap en GC-boekhouding.
Deze instelling is alleen van toepassing op 64-bits computers.
Als deze limiet niet is geconfigureerd, maar het proces wordt uitgevoerd in een omgeving met geheugenbeperking, wordt in een container met een opgegeven geheugenlimiet een standaardwaarde ingesteld. Deze standaardwaarde is groter dan 20 MB of 75% van de geheugenlimiet voor de container.
Deze instelling wordt genegeerd als de vaste limieten per object-heap zijn geconfigureerd.

	Naam instelling	Waarden	Versie geïntroduceerd
runtimeconfig.json	`System.GC.HeapHardLimit`	decimale waarde	.NET Core 3.0
Omgevingsvariabele	`COMPlus_GCHeapHardLimit`	hexadecimale waarde	.NET Core 3.0
Omgevingsvariabele	`DOTNET_GCHeapHardLimit`	hexadecimale waarde	.NET 6

Voorbeelden

runtimeconfig.json bestand:

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

runtimeconfig.template.json bestand:

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

Tip

Als u de optie instelt in runtimeconfig.json, geeft u een decimale waarde op. Als u de optie instelt als een omgevingsvariabele, geeft u een hexadecimale waarde op. Als u bijvoorbeeld een heap-harde limiet van 200 mebibytes (MiB) wilt opgeven, worden de waarden 209715200 voor het JSON-bestand en 0xC800000 of C800000 voor de omgevingsvariabele.

Heap harde limietpercentage

Hiermee geeft u de heap harde limiet op als percentage van het totale fysieke geheugen. Als het proces wordt uitgevoerd in een omgeving met geheugenbeperking, dat wil gezegd, binnen een container met een opgegeven geheugenlimiet, is het totale fysieke geheugen de geheugenlimiet; anders is het wat er beschikbaar is op de computer.
Deze instelling is alleen van toepassing op 64-bits computers.
Deze instelling wordt genegeerd als de harde limieten per object-heap zijn geconfigureerd of als de heap-harde limiet is geconfigureerd.

	Naam instelling	Waarden	Versie geïntroduceerd
runtimeconfig.json	`System.GC.HeapHardLimitPercent`	decimale waarde	.NET Core 3.0
Omgevingsvariabele	`COMPlus_GCHeapHardLimitPercent`	hexadecimale waarde	.NET Core 3.0
Omgevingsvariabele	`DOTNET_GCHeapHardLimitPercent`	hexadecimale waarde	.NET 6

Voorbeelden

runtimeconfig.json bestand:

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

runtimeconfig.template.json bestand:

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

Tip

Als u de optie instelt in runtimeconfig.json, geeft u een decimale waarde op. Als u de optie instelt als een omgevingsvariabele, geeft u een hexadecimale waarde op. Als u bijvoorbeeld het heap-gebruik wilt beperken tot 30%, zijn de waarden 30 voor het JSON-bestand en 0x1E of 1E voor de omgevingsvariabele.

Harde limieten per object-heap

U kunt de heap-limiet van de GC opgeven op basis van een heap per object. De verschillende heaps zijn de grote object heap (LOH), kleine object heap (SOH) en vastgemaakte object heap (POH).

Als u een waarde opgeeft voor een van de DOTNET_GCHeapHardLimitSOH, DOTNET_GCHeapHardLimitLOHof DOTNET_GCHeapHardLimitPOH instellingen, moet u ook een waarde opgeven voor DOTNET_GCHeapHardLimitSOH en DOTNET_GCHeapHardLimitLOH. Als u dit niet doet, kan de runtime niet worden geïnitialiseerd.
De standaardwaarde voor DOTNET_GCHeapHardLimitPOH is 0. DOTNET_GCHeapHardLimitSOH en DOTNET_GCHeapHardLimitLOH geen standaardwaarden hebben.

	Naam instelling	Waarden	Versie geïntroduceerd
runtimeconfig.json	`System.GC.HeapHardLimitSOH`	decimale waarde	.NET 5
Omgevingsvariabele	`COMPlus_GCHeapHardLimitSOH`	hexadecimale waarde	.NET 5
Omgevingsvariabele	`DOTNET_GCHeapHardLimitSOH`	hexadecimale waarde	.NET 6

	Naam instelling	Waarden	Versie geïntroduceerd
runtimeconfig.json	`System.GC.HeapHardLimitLOH`	decimale waarde	.NET 5
Omgevingsvariabele	`COMPlus_GCHeapHardLimitLOH`	hexadecimale waarde	.NET 5
Omgevingsvariabele	`DOTNET_GCHeapHardLimitLOH`	hexadecimale waarde	.NET 6

	Naam instelling	Waarden	Versie geïntroduceerd
runtimeconfig.json	`System.GC.HeapHardLimitPOH`	decimale waarde	.NET 5
Omgevingsvariabele	`COMPlus_GCHeapHardLimitPOH`	hexadecimale waarde	.NET 5
Omgevingsvariabele	`DOTNET_GCHeapHardLimitPOH`	hexadecimale waarde	.NET 6

Deze configuratie-instellingen hebben geen specifieke MSBuild-eigenschappen. U kunt echter in plaats daarvan een RuntimeHostConfigurationOption MSBuild-item toevoegen. Gebruik de naam van de instelling runtimeconfig.json als de waarde van het Include kenmerk. Zie MSBuild-eigenschappen voor een voorbeeld.

Tip

Als u de optie instelt in runtimeconfig.json, geeft u een decimale waarde op. Als u de optie instelt als een omgevingsvariabele, geeft u een hexadecimale waarde op. Als u bijvoorbeeld een heap-harde limiet van 200 mebibytes (MiB) wilt opgeven, worden de waarden 209715200 voor het JSON-bestand en 0xC800000 of C800000 voor de omgevingsvariabele.

Harde limieten per object-heap

U kunt de heap-limiet van de GC opgeven op basis van een heap per object. De verschillende heaps zijn de grote object heap (LOH), kleine object heap (SOH) en vastgemaakte object heap (POH).

Als u een waarde opgeeft voor een van de DOTNET_GCHeapHardLimitSOHPercent, DOTNET_GCHeapHardLimitLOHPercentof DOTNET_GCHeapHardLimitPOHPercent instellingen, moet u ook een waarde opgeven voor DOTNET_GCHeapHardLimitSOHPercent en DOTNET_GCHeapHardLimitLOHPercent. Als u dit niet doet, kan de runtime niet worden geïnitialiseerd.
Deze instellingen worden genegeerd als DOTNET_GCHeapHardLimitSOH, DOTNET_GCHeapHardLimitLOHen DOTNET_GCHeapHardLimitPOH worden opgegeven.
Een waarde van 1 betekent dat GC 1% van het totale fysieke geheugen voor dat object heap gebruikt.
Elke waarde moet groter zijn dan nul en kleiner dan 100. Daarnaast moet de som van de drie percentagewaarden kleiner zijn dan 100. Anders kan de runtime niet worden geïnitialiseerd.

	Naam instelling	Waarden	Versie geïntroduceerd
runtimeconfig.json	`System.GC.HeapHardLimitSOHPercent`	decimale waarde	.NET 5
Omgevingsvariabele	`COMPlus_GCHeapHardLimitSOHPercent`	hexadecimale waarde	.NET 5
Omgevingsvariabele	`DOTNET_GCHeapHardLimitSOHPercent`	hexadecimale waarde	.NET 6

	Naam instelling	Waarden	Versie geïntroduceerd
runtimeconfig.json	`System.GC.HeapHardLimitLOHPercent`	decimale waarde	.NET 5
Omgevingsvariabele	`COMPlus_GCHeapHardLimitLOHPercent`	hexadecimale waarde	.NET 5
Omgevingsvariabele	`DOTNET_GCHeapHardLimitLOHPercent`	hexadecimale waarde	.NET 6

	Naam instelling	Waarden	Versie geïntroduceerd
runtimeconfig.json	`System.GC.HeapHardLimitPOHPercent`	decimale waarde	.NET 5
Omgevingsvariabele	`COMPlus_GCHeapHardLimitPOHPercent`	hexadecimale waarde	.NET 5
Omgevingsvariabele	`DOTNET_GCHeapHardLimitPOHPercent`	hexadecimale waarde	.NET 6

Tip

Als u de optie instelt in runtimeconfig.json, geeft u een decimale waarde op. Als u de optie instelt als een omgevingsvariabele, geeft u een hexadecimale waarde op. Als u bijvoorbeeld het heap-gebruik wilt beperken tot 30%, zijn de waarden 30 voor het JSON-bestand en 0x1E of 1E voor de omgevingsvariabele.

Hoog geheugenpercentage

Geheugenbelasting wordt aangegeven door het percentage van het fysieke geheugen dat wordt gebruikt. Wanneer de fysieke geheugenbelasting 90% bereikt, wordt garbagecollection standaard agressiever over het uitvoeren van volledige, comprimeren van garbagecollection's om paginering te voorkomen. Wanneer de geheugenbelasting lager is dan 90%, geeft GC de voorkeur aan achtergrondverzamelingen voor volledige garbagecollecties, die kortere pauzes hebben, maar de totale heapgrootte niet veel verminderen. Op computers met een aanzienlijke hoeveelheid geheugen (80 GB of meer) is de standaardbelastingsdrempel tussen 90% en 97%.

De drempelwaarde voor hoge geheugenbelasting kan worden aangepast door de DOTNET_GCHighMemPercent omgevingsvariabele of System.GC.HighMemoryPercent JSON-configuratie-instelling. Overweeg de drempelwaarde aan te passen als u de heapgrootte wilt beheren. Voor het dominante proces op een machine met 64 GB geheugen is het bijvoorbeeld redelijk dat GC reageert wanneer er 10% van het geheugen beschikbaar is. Maar voor kleinere processen, bijvoorbeeld een proces dat slechts 1 GB geheugen verbruikt, kan GC comfortabel worden uitgevoerd met minder dan 10% van het beschikbare geheugen. Voor deze kleinere processen kunt u overwegen om de drempelwaarde hoger in te stellen. Als u echter wilt dat grotere processen kleinere heapgrootten hebben (zelfs wanneer er voldoende fysiek geheugen beschikbaar is), is het verlagen van deze drempelwaarde een effectieve manier om GC sneller te laten reageren om de heap te comprimeren.

Notitie

Voor processen die in een container worden uitgevoerd, beschouwt GC het fysieke geheugen op basis van de containerlimiet.

	Naam instelling	Waarden	Versie geïntroduceerd
runtimeconfig.json	`System.GC.HighMemoryPercent`	decimale waarde	.NET 5
Omgevingsvariabele	`COMPlus_GCHighMemPercent`	hexadecimale waarde	.NET Core 3.0 .NET Framework 4.7.2
Omgevingsvariabele	`DOTNET_GCHighMemPercent`	hexadecimale waarde	.NET 6

Tip

Als u de optie instelt in runtimeconfig.json, geeft u een decimale waarde op. Als u de optie instelt als een omgevingsvariabele, geeft u een hexadecimale waarde op. Als u bijvoorbeeld de hoge geheugendrempel wilt instellen op 75%, zijn de waarden 75 voor het JSON-bestand en 0x4B of 4B voor de omgevingsvariabele.

VM behouden

Hiermee configureert u of segmenten die moeten worden verwijderd, worden geplaatst op een stand-bylijst voor toekomstig gebruik of worden vrijgegeven aan het besturingssysteem (OS).
Standaard: Releasesegmenten terug naar het besturingssysteem. Dit komt overeen met het instellen van de waarde op false.

	Naam instelling	Waarden	Versie geïntroduceerd
runtimeconfig.json	`System.GC.RetainVM`	`false` - release van het besturingssysteem `true` - stand-by zetten	.NET Core 1.0
MSBuild-eigenschap	`RetainVMGarbageCollection`	`false` - release van het besturingssysteem `true` - stand-by zetten	.NET Core 1.0
Omgevingsvariabele	`COMPlus_GCRetainVM`	`0` - release van het besturingssysteem `1` - stand-by zetten	.NET Core 1.0
Omgevingsvariabele	`DOTNET_GCRetainVM`	`0` - release van het besturingssysteem `1` - stand-by zetten	.NET 6

Voorbeelden

runtimeconfig.json bestand:

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

runtimeconfig.template.json bestand:

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

Projectbestand:

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

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

</Project>

Grote pagina's

Hiermee geeft u op of grote pagina's moeten worden gebruikt wanneer een heap harde limiet is ingesteld.
Standaard: gebruik geen grote pagina's wanneer een heap harde limiet is ingesteld. Dit komt overeen met het instellen van de waarde op 0.
Dit is een experimentele instelling.

	Naam instelling	Waarden	Versie geïntroduceerd
runtimeconfig.json	N.v.t.	N.v.t.	N.v.t.
Omgevingsvariabele	`COMPlus_GCLargePages`	`0` -invalide `1` -Ingeschakeld	.NET Core 3.0
Omgevingsvariabele	`DOTNET_GCLargePages`	`0` -invalide `1` -Ingeschakeld	.NET 6

Grote objecten toestaan

Hiermee configureert u ondersteuning voor garbagecollection op 64-bits platforms voor matrices die groter zijn dan 2 GIGABYTE (GB) in totale grootte.
Standaard: GC ondersteunt matrices die groter zijn dan 2 GB. Dit komt overeen met het instellen van de waarde op 1.
Deze optie kan verouderd raken in een toekomstige versie van .NET.

	Naam instelling	Waarden	Versie geïntroduceerd
runtimeconfig.json	N.v.t.	N.v.t.	N.v.t.
Omgevingsvariabele	`COMPlus_gcAllowVeryLargeObjects`	`1` -Ingeschakeld `0` -invalide	.NET Core 1.0
Omgevingsvariabele	`DOTNET_gcAllowVeryLargeObjects`	`1` -Ingeschakeld `0` -invalide	.NET 6
app.config voor .NET Framework	gcAllowVeryLargeObjects	`1` -Ingeschakeld `0` -invalide	.NET Framework 4.5

Drempelwaarde voor grote object-heap

Hiermee geeft u de drempelwaardegrootte in bytes op die ervoor zorgt dat objecten op de grote object heap (LOH) gaan.
De standaarddrempelwaarde is 85.000 bytes.
De waarde die u opgeeft, moet groter zijn dan de standaarddrempelwaarde.
De waarde kan worden beperkt door de runtime tot de maximale grootte voor de huidige configuratie. U kunt de waarde die tijdens runtime wordt gebruikt controleren via de GC.GetConfigurationVariables() API.

	Naam instelling	Waarden	Versie geïntroduceerd
runtimeconfig.json	`System.GC.LOHThreshold`	decimale waarde	.NET Core 1.0
Omgevingsvariabele	`COMPlus_GCLOHThreshold`	hexadecimale waarde	.NET Core 1.0
Omgevingsvariabele	`DOTNET_GCLOHThreshold`	hexadecimale waarde	.NET 6
app.config voor .NET Framework	GCLOHThreshold	decimale waarde	.NET Framework 4.8

Voorbeelden

runtimeconfig.json bestand:

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

runtimeconfig.template.json bestand:

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

Tip

Als u de optie instelt in runtimeconfig.json, geeft u een decimale waarde op. Als u de optie instelt als een omgevingsvariabele, geeft u een hexadecimale waarde op. Als u bijvoorbeeld een drempelwaarde van 120.000 bytes wilt instellen, zijn de waarden 120000 voor het JSON-bestand en 0x1D4C0 of 1D4C0 voor de omgevingsvariabele.

Zelfstandige GC

Als u een zelfstandige garbagecollector wilt gebruiken in plaats van de standaard GC-implementatie, kunt u het pad (in .NET 9 en latere versies) of de naam van een systeemeigen GC-bibliotheek opgeven.

Pad

Hiermee geeft u het volledige pad van een systeemeigen GC-bibliotheek op die door de runtime wordt geladen in plaats van de standaard GC-implementatie. Om veilig te zijn, moet deze locatie worden beschermd tegen mogelijk schadelijke manipulatie.

	Naam instelling	Waarden	Versie geïntroduceerd
runtimeconfig.json	`System.GC.Path`	string_path	.NET 9
Omgevingsvariabele	`DOTNET_GCPath`	string_path	.NET 9

Naam

Hiermee geeft u de naam op van een systeemeigen GC-bibliotheek die door de runtime wordt geladen in plaats van de standaard-GC-implementatie. Het gedrag is gewijzigd in .NET 9 met de introductie van de padconfiguratie .

In .NET 8 en vorige versies:
- Als alleen een naam van de bibliotheek is opgegeven, moet de bibliotheek zich in dezelfde map bevinden als de .NET-runtime (coreclr.dll in Windows, libcoreclr.so op Linux of libcoreclr.dylib in OSX).
- De waarde kan ook een relatief pad zijn, bijvoorbeeld als u '.. \clrgc.dll" in Windows wordt clrgc.dll geladen vanuit de bovenliggende map van de .NET Runtime-directory.
In .NET 9 en latere versies geeft deze waarde alleen een bestandsnaam op (paden zijn niet toegestaan):
- .NET zoekt naar de naam die u opgeeft in de map waarin de assembly die de methode van Main uw app bevat zich bevindt.
- Als het bestand niet wordt gevonden, wordt de .NET-runtimemap doorzocht.
Deze configuratie-instelling wordt genegeerd als de padconfiguratie is opgegeven.

	Naam instelling	Waarden	Versie geïntroduceerd
runtimeconfig.json	`System.GC.Name`	string_name	.NET 7
Omgevingsvariabele	`COMPlus_GCName`	string_name	.NET Core 2.0
Omgevingsvariabele	`DOTNET_GCName`	string_name	.NET 6

Geheugen besparen

Hiermee configureert u de garbagecollector om geheugen te besparen ten koste van frequentere garbageverzamelingen en mogelijk langere onderbrekingstijden.
De standaardwaarde is 0. Dit impliceert geen wijziging.
Naast de standaardwaarde 0 zijn waarden tussen 1 en 9 (inclusief) geldig. Hoe hoger de waarde, hoe meer de garbagecollector probeert geheugen te besparen en zo de heap klein te houden.
Als de waarde niet nul is, wordt de grote object-heap automatisch gecomprimeerd als deze te veel fragmentatie heeft.

	Naam instelling	Waarden	Versie geïntroduceerd
runtimeconfig.json	`System.GC.ConserveMemory`	`0` - `9`	.NET 6
Omgevingsvariabele	`COMPlus_GCConserveMemory`	`0` -`9`	.NET Framework 4.8
Omgevingsvariabele	`DOTNET_GCConserveMemory`	`0` -`9`	.NET 6
app.config voor .NET Framework	GCConserveMemory	`0` -`9`	.NET Framework 4.8

Voorbeeld van app.config-bestand :


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

Tip

Experimenteer met verschillende getallen om te zien welke waarde het beste werkt voor u. Begin met een waarde tussen 5 en 7.

Dynamische aanpassing van toepassingsgrootten (DATAS)

Hiermee configureert u de garbagecollector voor het gebruik van DATAS. DATAS past zich aan de vereisten voor toepassingsgeheugen aan, wat betekent dat de grootte van de app heap ongeveer evenredig moet zijn met de gegevensgrootte met een lange levensduur.
Standaard ingeschakeld vanaf .NET 9.

	Naam instelling	Waarden	Versie geïntroduceerd
Omgevingsvariabele	`DOTNET_GCDynamicAdaptationMode`	`1` -Ingeschakeld `0` -invalide	.NET 8
MSBuild-eigenschap	`GarbageCollectionAdaptationMode`	`1` -Ingeschakeld `0` -invalide	.NET 8
runtimeconfig.json	`System.GC.DynamicAdaptationMode`	`1` -Ingeschakeld `0` -invalide	.NET 8

Delen via

Runtimeconfiguratieopties voor garbagecollection

Manieren om de configuratie op te geven

Smaken van garbagecollection

Werkstation versus server

Voorbeelden

Achtergrond GC

Voorbeelden

Resourcegebruik beheren

Heap count

Voorbeelden

Affiniteitsmasker

Voorbeelden

Affiniteitsbereiken

Voorbeelden

CPU-groepen

Affiniteit

Voorbeelden

Harde limiet voor heap

Voorbeelden

Heap harde limietpercentage

Voorbeelden

Harde limieten per object-heap

Harde limieten per object-heap

Hoog geheugenpercentage

VM behouden

Voorbeelden

Grote pagina's

Grote objecten toestaan

Drempelwaarde voor grote object-heap

Voorbeelden

Zelfstandige GC

Pad

Naam

Geheugen besparen

Dynamische aanpassing van toepassingsgrootten (DATAS)

Aanvullende resources