Körningskonfigurationsalternativ för skräpinsamling

Artikel
10/31/2024

Den här sidan innehåller information om inställningar för .NET-runtime-skräpinsamlaren (GC). Om du försöker uppnå högsta prestanda för en app som körs kan du överväga att använda de här inställningarna. Standardinställningarna ger dock optimala prestanda för de flesta program i vanliga situationer.

Inställningarna är ordnade i grupper på den här sidan. Inställningarna i varje grupp används ofta tillsammans med varandra för att uppnå ett specifikt resultat.

Kommentar

Dessa konfigurationer skrivs endast av körningen när GC initieras (vanligtvis innebär det under processens starttid). Om du ändrar en miljövariabel när en process redan körs återspeglas inte ändringen i den processen. Inställningar som kan ändras via API:er vid körning, till exempel svarstidsnivå, utelämnas från den här sidan.
Eftersom GC är per process är det sällan meningsfullt att ställa in dessa konfigurationer på datornivå. Du vill till exempel inte att alla .NET-processer på en dator ska använda server GC eller samma heap hårda gräns.
För talvärden använder du decimal notation för inställningar i runtimeconfig.json - eller runtimeconfig.template.json-filen och hexadecimal notation för miljövariabelinställningar. För hexadecimala värden kan du ange dem med eller utan prefixet "0x".
Om du använder miljövariablerna standardiseras .NET 6- och senare versioner på prefixet DOTNET_ i stället för COMPlus_. Prefixet COMPlus_ fortsätter dock att fungera. Om du använder en tidigare version av .NET-körningen bör du fortfarande använda prefixet COMPlus_ , COMPlus_gcServertill exempel .

Sätt att ange konfigurationen

För olika versioner av .NET-körningen finns det olika sätt att ange konfigurationsvärdena. Följande tabell visar en sammanfattning.

Konfigurationsplats	.NET-versioner som den här platsen gäller för	Format	Så tolkas det
runtimeconfig.json fil/ runtimeconfig.template.json fil	.NET (Core)	n	n tolkas som ett decimalvärde.
Miljövariabel	.NET Framework, .NET (Core)	0xn eller n	n tolkas som ett hexvärde i båda formaten
app.config-fil	.NET Framework	0xn	n tolkas som ett hexvärde¹

¹ Du kan ange ett värde utan prefixet 0x för en app.config-filinställning, men det rekommenderas inte. På .NET Framework 4.8+ tolkas ett värde som angetts utan prefixet 0x som hexadecimalt på grund av en bugg, men i tidigare versioner av .NET Framework tolkas det som decimaltecken. Om du vill undvika att behöva ändra konfigurationen använder du prefixet 0x när du anger ett värde i filen app.config.

Om du till exempel vill ange 12 heaps för GCHeapCount en .NET Framework-app med namnet A.exe lägger du till följande XML i filen A.exe.config .

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

För både .NET (Core) och .NET Framework kan du använda miljövariabler.

I Windows med hjälp av .NET 6 eller en senare version:

SET DOTNET_gcServer=1
SET DOTNET_GCHeapCount=c

I Windows med .NET 5 eller tidigare:

SET COMPlus_gcServer=1
SET COMPlus_GCHeapCount=c

På andra operativsystem:

För .NET 6 eller senare versioner:

export DOTNET_gcServer=1
export DOTNET_GCHeapCount=c

För .NET 5 och tidigare versioner:

export COMPlus_gcServer=1
export COMPlus_GCHeapCount=c

Om du inte använder .NET Framework kan du också ange värdet i filen runtimeconfig.json eller runtimeconfig.template.json .

runtimeconfig.json fil:

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

runtimeconfig.template.json fil:

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

Smaker av skräpinsamling

De två viktigaste smakerna av skräpinsamling är arbetsstation GC och server GC. Mer information om skillnaderna mellan de två finns i Arbetsstation och skräpinsamling för servrar.

Underflavorna för skräpinsamling är bakgrund och icke-samtidiga.

Använd följande inställningar för att välja varianter av skräpinsamling:

Arbetsstation jämfört med server-GC
Bakgrunds-GC

Arbetsstation jämfört med server

Konfigurerar om programmet använder skräpinsamling för arbetsstationer eller skräpinsamling på servern.
Standard: Skräpinsamling för arbetsstation. Detta motsvarar att ange värdet till false.

	Inställningsnamn	Värden	Version introducerad
runtimeconfig.json	`System.GC.Server`	`false` -Arbetsstation `true` -server	.NET Core 1.0
MSBuild-egenskap	`ServerGarbageCollection`	`false` -Arbetsstation `true` -server	.NET Core 1.0
Miljövariabel	`COMPlus_gcServer`	`0` -Arbetsstation `1` -server	.NET Core 1.0
Miljövariabel	`DOTNET_gcServer`	`0` -Arbetsstation `1` -server	.NET 6
app.config för .NET Framework	GCServer	`false` -Arbetsstation `true` -server

Exempel

runtimeconfig.json fil:

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

runtimeconfig.template.json fil:

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

Projektfil:

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

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

</Project>

Bakgrunds-GC

Konfigurerar om skräpinsamling i bakgrunden (samtidig) är aktiverad.
Standard: Använd bakgrunds-GC. Detta motsvarar att ange värdet till true.
Mer information finns i Skräpinsamling i bakgrunden.

	Inställningsnamn	Värden	Version introducerad
runtimeconfig.json	`System.GC.Concurrent`	`true` - bakgrund GC `false` - icke-samtidig GC	.NET Core 1.0
MSBuild-egenskap	`ConcurrentGarbageCollection`	`true` - bakgrund GC `false` - icke-samtidig GC	.NET Core 1.0
Miljövariabel	`COMPlus_gcConcurrent`	`1` - bakgrund GC `0` - icke-samtidig GC	.NET Core 1.0
Miljövariabel	`DOTNET_gcConcurrent`	`1` - bakgrund GC `0` - icke-samtidig GC	.NET 6
app.config för .NET Framework	gcConcurrent	`true` - bakgrund GC `false` - icke-samtidig GC

Exempel

runtimeconfig.json fil:

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

runtimeconfig.template.json fil:

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

Projektfil:

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

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

</Project>

Hantera resursanvändning

Använd följande inställningar för att hantera skräpinsamlarens minnes- och processoranvändning:

Tillhörighet
Tillhörighetsmask
Tillhörighetsintervall
CPU-grupper
Antal heap
Heap hård gräns
Heap hård gränsprocent
Hårda gränser per objekt-heap
Procent för hård gräns per objekt-heap
Hög minnesprocent
Behålla virtuell dator

Mer information om några av de här inställningarna finns i blogginlägget Mellan arbetsstation och server GC .

Antal heap

Begränsar antalet heaps som skapats av skräpinsamlaren.
Gäller endast för serverskräpinsamling.
Om GC-processortillhörighet är aktiverat, vilket är standardinställningen för antal heaps, mappas n GC-heaps/trådar till de första n processorerna. (Använd inställningarna för tillhörighetsmask eller tillhörighetsintervall för att ange exakt vilka processorer som ska mappas.)
Om GC-processortillhörighet är inaktiverad begränsar den här inställningen antalet GC-heaps.
Mer information finns i GCHeapCount-kommentarerna.

	Inställningsnamn	Värden	Version introducerad
runtimeconfig.json	`System.GC.HeapCount`	Decimalvärde	.NET Core 3.0
Miljövariabel	`COMPlus_GCHeapCount`	hexadecimalt värde	.NET Core 3.0
Miljövariabel	`DOTNET_GCHeapCount`	hexadecimalt värde	.NET 6
app.config för .NET Framework	GCHeapCount	Decimalvärde	.NET Framework 4.6.2

Den här konfigurationsinställningen har ingen specifik MSBuild-egenskap. Du kan dock lägga till ett RuntimeHostConfigurationOption MSBuild-objekt i stället. Använd runtimeconfig.json inställningsnamnet som värdet för attributetInclude. Ett exempel finns i MSBuild-egenskaper.

Exempel

runtimeconfig.json fil:

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

runtimeconfig.template.json fil:

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

Dricks

Om du anger alternativet i runtimeconfig.json anger du ett decimalvärde. Om du anger alternativet som en miljövariabel anger du ett hexadecimalt värde. Om du till exempel vill begränsa antalet heaps till 16 blir värdena 16 för JSON-filen och 0x10 eller 10 för miljövariabeln.

Tillhörighetsmask

Anger de exakta processorer som skräpinsamlingstrådar ska använda.
Om GC-processortillhörighet är inaktiverad ignoreras den här inställningen.
Gäller endast för serverskräpinsamling.
Värdet är en bitmask som definierar de processorer som är tillgängliga för processen. Till exempel är ett decimalvärde på 1023 (eller ett hexadecimalt värde på 0x3FF eller 3FF om du använder miljövariabeln) 0011 1111 1111 i binär notation. Detta anger att de första 10 processorerna ska användas. Om du vill ange nästa 10 processorer, dvs. processorer 10–19, anger du ett decimalvärde på 1047552 (eller ett hexadecimalt värde på 0xFFC00 eller FFC00), vilket motsvarar ett binärt värde på 1111 1111 1100 0000 0000.

	Inställningsnamn	Värden	Version introducerad
runtimeconfig.json	`System.GC.HeapAffinitizeMask`	Decimalvärde	.NET Core 3.0
Miljövariabel	`COMPlus_GCHeapAffinitizeMask`	hexadecimalt värde	.NET Core 3.0
Miljövariabel	`DOTNET_GCHeapAffinitizeMask`	hexadecimalt värde	.NET 6
app.config för .NET Framework	GCHeapAffinitizeMask	Decimalvärde	.NET Framework 4.6.2

Exempel

runtimeconfig.json fil:

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

runtimeconfig.template.json fil:

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

Tillhörighetsintervall

Anger listan över processorer som ska användas för skräpinsamlingstrådar.
Den här inställningen liknar System.GC.HeapAffinitizeMask, förutom att du kan ange fler än 64 processorer.
För Windows-operativsystem prefixar du processornumret eller intervallet med motsvarande CPU-grupp, till exempel "0:1-10,0:12,1:50-52,1:7". Om du inte har fler än 1 CPU-grupp kan du inte använda den här inställningen. Du måste använda inställningen Mappningsmask . Och de tal som du anger finns i den gruppen, vilket innebär att det inte kan vara >= 64.
För Linux-operativsystem, där cpu-gruppkonceptet inte finns, kan du använda både den här inställningen och inställningen Tillhörighetsmask för att ange samma intervall. Och i stället för "0:1-10" anger du "1–10" eftersom du inte behöver ange ett gruppindex.
Om GC-processortillhörighet är inaktiverad ignoreras den här inställningen.
Gäller endast för serverskräpinsamling.
Mer information finns i Göra CPU-konfigurationen bättre för GC på datorer med > 64 processorer på Maoni Stephens blogg.

	Inställningsnamn	Värden	Version introducerad
runtimeconfig.json	`System.GC.HeapAffinitizeRanges`	Kommaavgränsad lista över processornummer eller processornummerintervall. Unix-exempel: "1-10,12,50-52,70" Windows-exempel: "0:1-10,0:12,1:50-52,1:7"	.NET Core 3.0
Miljövariabel	`COMPlus_GCHeapAffinitizeRanges`	Kommaavgränsad lista över processornummer eller processornummerintervall. Unix-exempel: "1-10,12,50-52,70" Windows-exempel: "0:1-10,0:12,1:50-52,1:7"	.NET Core 3.0
Miljövariabel	`DOTNET_GCHeapAffinitizeRanges`	Kommaavgränsad lista över processornummer eller processornummerintervall. Unix-exempel: "1-10,12,50-52,70" Windows-exempel: "0:1-10,0:12,1:50-52,1:7"	.NET 6

Exempel

runtimeconfig.json fil:

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

runtimeconfig.template.json fil:

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

CPU-grupper

Konfigurerar om skräpinsamlaren använder CPU-grupper eller inte.

När en 64-bitars Windows-dator har flera CPU-grupper, det vill sa att det finns fler än 64 processorer, utökar aktiveringen av det här elementet skräpinsamling över alla CPU-grupper. Skräpinsamlaren använder alla kärnor för att skapa och balansera högar.

Kommentar

Det här är ett begrepp som endast gäller Windows. I äldre Windows-versioner begränsade Windows en process till en processorgrupp. Därför använde GC bara en CPU-grupp om du inte använde den här inställningen för att aktivera flera CPU-grupper. Den här os-begränsningen hävdes i Windows 11 och Server 2022. Från och med .NET 7 använder GC som standard alla CPU-grupper när de körs på Windows 11 eller Server 2022.
Gäller endast för serverskräpinsamling på 64-bitars Windows-operativsystem.
Standard: GC sträcker sig inte över cpu-grupper. Detta motsvarar att ange värdet till 0.
Mer information finns i Göra CPU-konfigurationen bättre för GC på datorer med > 64 processorer på Maoni Stephens blogg.

	Inställningsnamn	Värden	Version introducerad
runtimeconfig.json	`System.GC.CpuGroup`	`false` -handikappad `true` -Aktiverat	.NET 5
Miljövariabel	`COMPlus_GCCpuGroup`	`0` -handikappad `1` -Aktiverat	.NET Core 1.0
Miljövariabel	`DOTNET_GCCpuGroup`	`0` -handikappad `1` -Aktiverat	.NET 6
app.config för .NET Framework	GCCpuGroup	`false` -handikappad `true` -Aktiverat

Kommentar

Om du vill konfigurera CLR (Common Language Runtime) för att även distribuera trådar från trådpoolen över alla CPU-grupper aktiverar du alternativet Thread_UseAllCpuGroups element . För .NET Core-appar kan du aktivera det här alternativet genom att ange värdet för DOTNET_Thread_UseAllCpuGroups miljövariabeln till 1.

Tillhörighet

Anger om skräpinsamlingstrådar ska mappas till processorer. Om du vill mappa en GC-tråd innebär det att den bara kan köras på sin specifika CPU. En heap skapas för varje GC-tråd.
Gäller endast för serverskräpinsamling.
Standard: Mappa skräpinsamlingstrådar med processorer. Detta motsvarar att ange värdet till false.

	Inställningsnamn	Värden	Version introducerad
runtimeconfig.json	`System.GC.NoAffinitize`	`false` – tillhörighet `true` - mappa inte	.NET Core 3.0
Miljövariabel	`COMPlus_GCNoAffinitize`	`0` – tillhörighet `1` - mappa inte	.NET Core 3.0
Miljövariabel	`DOTNET_GCNoAffinitize`	`0` – tillhörighet `1` - mappa inte	.NET 6
app.config för .NET Framework	GCNoAffinitize	`false` – tillhörighet `true` - mappa inte	.NET Framework 4.6.2

Exempel

runtimeconfig.json fil:

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

runtimeconfig.template.json fil:

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

Heap hård gräns

Den hårda heapgränsen definieras som den maximala incheckningsstorleken, i byte, för GC-heap- och GC-bokföringen.
Den här inställningen gäller endast för 64-bitars datorer.
Om den här gränsen inte har konfigurerats men processen körs i en minnesbegränsad miljö, dvs. i en container med en angiven minnesgräns, anges ett standardvärde. Standardvärdet är större än 20 MB eller 75 % av minnesgränsen för containern.
Den här inställningen ignoreras om de hårda gränserna per objekt-heap har konfigurerats.

	Inställningsnamn	Värden	Version introducerad
runtimeconfig.json	`System.GC.HeapHardLimit`	Decimalvärde	.NET Core 3.0
Miljövariabel	`COMPlus_GCHeapHardLimit`	hexadecimalt värde	.NET Core 3.0
Miljövariabel	`DOTNET_GCHeapHardLimit`	hexadecimalt värde	.NET 6

Exempel

runtimeconfig.json fil:

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

runtimeconfig.template.json fil:

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

Dricks

Om du anger alternativet i runtimeconfig.json anger du ett decimalvärde. Om du anger alternativet som en miljövariabel anger du ett hexadecimalt värde. Om du till exempel vill ange en hård heapgräns på 200 mebibyte (MiB) skulle värdena vara 209715200 för JSON-filen och 0xC800000 eller C800000 för miljövariabeln.

Heap hård gränsprocent

Anger den hårda heapgränsen som en procentandel av det totala fysiska minnet. Om processen körs i en minnesbegränsad miljö, dvs. i en container med en angiven minnesgräns, är det totala fysiska minnet minnesgränsen. annars är det det som är tillgängligt på datorn.
Den här inställningen gäller endast för 64-bitars datorer.
Den här inställningen ignoreras om de hårda gränserna per objekt-heap har konfigurerats eller om heapens hårda gräns har konfigurerats.

	Inställningsnamn	Värden	Version introducerad
runtimeconfig.json	`System.GC.HeapHardLimitPercent`	Decimalvärde	.NET Core 3.0
Miljövariabel	`COMPlus_GCHeapHardLimitPercent`	hexadecimalt värde	.NET Core 3.0
Miljövariabel	`DOTNET_GCHeapHardLimitPercent`	hexadecimalt värde	.NET 6

Exempel

runtimeconfig.json fil:

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

runtimeconfig.template.json fil:

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

Dricks

Om du anger alternativet i runtimeconfig.json anger du ett decimalvärde. Om du anger alternativet som en miljövariabel anger du ett hexadecimalt värde. Om du till exempel vill begränsa heapanvändningen till 30 % blir värdena 30 för JSON-filen och 0x1E eller 1E för miljövariabeln.

Hårda gränser per objekt-heap

Du kan ange GC:s hårda gräns per objekt-heap. De olika heaparna är den stora objekthögen (LOH), den lilla objekthögen (SOH) och den fästa objekthögen (POH).

Om du anger ett värde för någon av DOTNET_GCHeapHardLimitSOHinställningarna , DOTNET_GCHeapHardLimitLOHeller DOTNET_GCHeapHardLimitPOH måste du också ange ett värde för DOTNET_GCHeapHardLimitSOH och DOTNET_GCHeapHardLimitLOH. Om du inte gör det kan körningen inte initieras.
Standardvärdet för DOTNET_GCHeapHardLimitPOH är 0. DOTNET_GCHeapHardLimitSOH och DOTNET_GCHeapHardLimitLOH har inte standardvärden.

	Inställningsnamn	Värden	Version introducerad
runtimeconfig.json	`System.GC.HeapHardLimitSOH`	Decimalvärde	.NET 5
Miljövariabel	`COMPlus_GCHeapHardLimitSOH`	hexadecimalt värde	.NET 5
Miljövariabel	`DOTNET_GCHeapHardLimitSOH`	hexadecimalt värde	.NET 6

	Inställningsnamn	Värden	Version introducerad
runtimeconfig.json	`System.GC.HeapHardLimitLOH`	Decimalvärde	.NET 5
Miljövariabel	`COMPlus_GCHeapHardLimitLOH`	hexadecimalt värde	.NET 5
Miljövariabel	`DOTNET_GCHeapHardLimitLOH`	hexadecimalt värde	.NET 6

	Inställningsnamn	Värden	Version introducerad
runtimeconfig.json	`System.GC.HeapHardLimitPOH`	Decimalvärde	.NET 5
Miljövariabel	`COMPlus_GCHeapHardLimitPOH`	hexadecimalt värde	.NET 5
Miljövariabel	`DOTNET_GCHeapHardLimitPOH`	hexadecimalt värde	.NET 6

De här konfigurationsinställningarna har inte specifika MSBuild-egenskaper. Du kan dock lägga till ett RuntimeHostConfigurationOption MSBuild-objekt i stället. Använd runtimeconfig.json inställningsnamnet som värdet för attributetInclude. Ett exempel finns i MSBuild-egenskaper.

Dricks

Om du anger alternativet i runtimeconfig.json anger du ett decimalvärde. Om du anger alternativet som en miljövariabel anger du ett hexadecimalt värde. Om du till exempel vill ange en hård heapgräns på 200 mebibyte (MiB) skulle värdena vara 209715200 för JSON-filen och 0xC800000 eller C800000 för miljövariabeln.

Procent för hård gräns per objekt-heap

Du kan ange GC:s hårda gräns per objekt-heap. De olika heaparna är den stora objekthögen (LOH), den lilla objekthögen (SOH) och den fästa objekthögen (POH).

Om du anger ett värde för någon av DOTNET_GCHeapHardLimitSOHPercentinställningarna , DOTNET_GCHeapHardLimitLOHPercenteller DOTNET_GCHeapHardLimitPOHPercent måste du också ange ett värde för DOTNET_GCHeapHardLimitSOHPercent och DOTNET_GCHeapHardLimitLOHPercent. Om du inte gör det kan körningen inte initieras.
De här inställningarna ignoreras om DOTNET_GCHeapHardLimitSOH, DOTNET_GCHeapHardLimitLOHoch DOTNET_GCHeapHardLimitPOH anges.
Värdet 1 innebär att GC använder 1 % av det totala fysiska minnet för objektets heap.
Varje värde måste vara större än noll och mindre än 100. Dessutom måste summan av de tre procentvärdena vara mindre än 100. Annars kan körningen inte initieras.

	Inställningsnamn	Värden	Version introducerad
runtimeconfig.json	`System.GC.HeapHardLimitSOHPercent`	Decimalvärde	.NET 5
Miljövariabel	`COMPlus_GCHeapHardLimitSOHPercent`	hexadecimalt värde	.NET 5
Miljövariabel	`DOTNET_GCHeapHardLimitSOHPercent`	hexadecimalt värde	.NET 6

	Inställningsnamn	Värden	Version introducerad
runtimeconfig.json	`System.GC.HeapHardLimitLOHPercent`	Decimalvärde	.NET 5
Miljövariabel	`COMPlus_GCHeapHardLimitLOHPercent`	hexadecimalt värde	.NET 5
Miljövariabel	`DOTNET_GCHeapHardLimitLOHPercent`	hexadecimalt värde	.NET 6

	Inställningsnamn	Värden	Version introducerad
runtimeconfig.json	`System.GC.HeapHardLimitPOHPercent`	Decimalvärde	.NET 5
Miljövariabel	`COMPlus_GCHeapHardLimitPOHPercent`	hexadecimalt värde	.NET 5
Miljövariabel	`DOTNET_GCHeapHardLimitPOHPercent`	hexadecimalt värde	.NET 6

Dricks

Om du anger alternativet i runtimeconfig.json anger du ett decimalvärde. Om du anger alternativet som en miljövariabel anger du ett hexadecimalt värde. Om du till exempel vill begränsa heapanvändningen till 30 % blir värdena 30 för JSON-filen och 0x1E eller 1E för miljövariabeln.

Hög minnesprocent

Minnesbelastning indikeras av procentandelen fysiskt minne som används. När den fysiska minnesbelastningen når 90 % blir skräpinsamlingen som standard mer aggressiv när det gäller att göra fullständiga, komprimera skräpsamlingar för att undvika växling. När minnesbelastningen är lägre än 90 % föredrar GC bakgrundssamlingar för fullständiga skräpsamlingar, som har kortare pauser men inte minskar den totala heapstorleken med mycket. På datorer med en betydande mängd minne (80 GB eller mer) är standardtröskelvärdet för belastning mellan 90 % och 97 %.

Tröskelvärdet för hög minnesbelastning kan justeras med DOTNET_GCHighMemPercent miljövariabeln eller System.GC.HighMemoryPercent JSON-konfigurationsinställningen. Överväg att justera tröskelvärdet om du vill kontrollera heapstorleken. För den dominerande processen på en dator med 64 GB minne är det till exempel rimligt att GC börjar reagera när det finns 10 % tillgängligt minne. Men för mindre processer, till exempel en process som bara förbrukar 1 GB minne, kan GC bekvämt köras med mindre än 10 % tillgängligt minne. För dessa mindre processer bör du överväga att ange tröskelvärdet högre. Å andra sidan, om du vill att större processer ska ha mindre heapstorlekar (även om det finns gott om fysiskt minne tillgängligt), är en sänkning av detta tröskelvärde ett effektivt sätt för GC att reagera tidigare för att komprimera ner heapen.

Kommentar

För processer som körs i en container tar GC hänsyn till det fysiska minnet baserat på containergränsen.

	Inställningsnamn	Värden	Version introducerad
runtimeconfig.json	`System.GC.HighMemoryPercent`	Decimalvärde	.NET 5
Miljövariabel	`COMPlus_GCHighMemPercent`	hexadecimalt värde	.NET Core 3.0 .NET Framework 4.7.2
Miljövariabel	`DOTNET_GCHighMemPercent`	hexadecimalt värde	.NET 6

Dricks

Om du anger alternativet i runtimeconfig.json anger du ett decimalvärde. Om du anger alternativet som en miljövariabel anger du ett hexadecimalt värde. Om du till exempel vill ange tröskelvärdet för högt minne till 75 % blir värdena 75 för JSON-filen och 0x4B eller 4B för miljövariabeln.

Behålla virtuell dator

Konfigurerar om segment som ska tas bort placeras i en väntelista för framtida användning eller släpps tillbaka till operativsystemet (OS).
Standard: Versionssegment tillbaka till operativsystemet. Detta motsvarar att ange värdet till false.

	Inställningsnamn	Värden	Version introducerad
runtimeconfig.json	`System.GC.RetainVM`	`false` – release to OS `true` - sätta i vänteläge	.NET Core 1.0
MSBuild-egenskap	`RetainVMGarbageCollection`	`false` – release to OS `true` - sätta i vänteläge	.NET Core 1.0
Miljövariabel	`COMPlus_GCRetainVM`	`0` – release to OS `1` - sätta i vänteläge	.NET Core 1.0
Miljövariabel	`DOTNET_GCRetainVM`	`0` – release to OS `1` - sätta i vänteläge	.NET 6

Exempel

runtimeconfig.json fil:

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

runtimeconfig.template.json fil:

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

Projektfil:

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

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

</Project>

Stora sidor

Anger om stora sidor ska användas när en heap hård gräns anges.
Standard: Använd inte stora sidor när en heap hård gräns har angetts. Detta motsvarar att ange värdet till 0.
Det här är en experimentell inställning.

	Inställningsnamn	Värden	Version introducerad
runtimeconfig.json	Saknas	Saknas	Saknas
Miljövariabel	`COMPlus_GCLargePages`	`0` -handikappad `1` -Aktiverat	.NET Core 3.0
Miljövariabel	`DOTNET_GCLargePages`	`0` -handikappad `1` -Aktiverat	.NET 6

Tillåt stora objekt

Konfigurerar stöd för skräpinsamlare på 64-bitarsplattformar för matriser som är större än 2 GIGABYTE (GB) i total storlek.
Standard: GC stöder matriser som är större än 2 GB. Detta motsvarar att ange värdet till 1.
Det här alternativet kan bli föråldrat i en framtida version av .NET.

	Inställningsnamn	Värden	Version introducerad
runtimeconfig.json	Saknas	Saknas	Saknas
Miljövariabel	`COMPlus_gcAllowVeryLargeObjects`	`1` -Aktiverat `0` -handikappad	.NET Core 1.0
Miljövariabel	`DOTNET_gcAllowVeryLargeObjects`	`1` -Aktiverat `0` -handikappad	.NET 6
app.config för .NET Framework	gcAllowVeryLargeObjects	`1` -Aktiverat `0` -handikappad	Microsoft .NET Framework 4.5

Tröskelvärde för stora objekts heap

Anger tröskelvärdets storlek, i byte, som gör att objekt hamnar på den stora objekthögen (LOH).
Standardtröskelvärdet är 85 000 byte.
Värdet du anger måste vara större än standardtröskelvärdet.
Värdet kan begränsas av körningen till den maximala möjliga storleken för den aktuella konfigurationen. Du kan kontrollera värdet som används vid körning via API:et GC.GetConfigurationVariables() .

	Inställningsnamn	Värden	Version introducerad
runtimeconfig.json	`System.GC.LOHThreshold`	Decimalvärde	.NET Core 1.0
Miljövariabel	`COMPlus_GCLOHThreshold`	hexadecimalt värde	.NET Core 1.0
Miljövariabel	`DOTNET_GCLOHThreshold`	hexadecimalt värde	.NET 6
app.config för .NET Framework	GCLOHThreshold	Decimalvärde	.NET Framework 4.8

Exempel

runtimeconfig.json fil:

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

runtimeconfig.template.json fil:

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

Dricks

Om du anger alternativet i runtimeconfig.json anger du ett decimalvärde. Om du anger alternativet som en miljövariabel anger du ett hexadecimalt värde. Om du till exempel vill ange en tröskelvärdesstorlek på 120 000 byte blir värdena 120000 för JSON-filen och 0x1D4C0 eller 1D4C0 för miljövariabeln.

Fristående GC

Om du vill använda en fristående skräpinsamlare i stället för GC-standardimplementeringen kan du ange antingen sökvägen (i .NET 9 och senare versioner) eller namnet på ett internt GC-bibliotek.

Sökväg

Anger den fullständiga sökvägen för ett inbyggt GC-bibliotek som körningen läser in i stället för standardimplementeringen av GC. För att vara säker bör den här platsen skyddas från potentiellt skadlig manipulering.

	Inställningsnamn	Värden	Version introducerad
runtimeconfig.json	`System.GC.Path`	string_path	.NET 9
Miljövariabel	`DOTNET_GCPath`	string_path	.NET 9

Name

Anger namnet på ett inbyggt GC-bibliotek som körningen läser in i stället för GC-standardimplementeringen. Beteendet ändrades i .NET 9 med introduktionen av path-konfigurationen.

I .NET 8 och tidigare versioner:
- Om endast ett namn på biblioteket anges måste biblioteket finnas i samma katalog som .NET-körningen (coreclr.dll i Windows, libcoreclr.so i Linux eller libcoreclr.dylib på OSX).
- Värdet kan också vara en relativ sökväg, till exempel om du anger ".. \clrgc.dll" i Windows läses clrgc.dll in från den överordnade katalogen i .NET-körningskatalogen.
I .NET 9 och senare versioner anger det här värdet endast ett filnamn (sökvägar tillåts inte):
- .NET söker efter det namn som du anger i katalogen där sammansättningen som innehåller appens Main metod finns.
- Om filen inte hittas genomsöks .NET-körningskatalogen.
Den här konfigurationsinställningen ignoreras om sökvägskonfigurationen har angetts.

	Inställningsnamn	Värden	Version introducerad
runtimeconfig.json	`System.GC.Name`	string_name	.NET 7
Miljövariabel	`COMPlus_GCName`	string_name	.NET Core 2.0
Miljövariabel	`DOTNET_GCName`	string_name	.NET 6

Spara minne

Konfigurerar skräpinsamlaren för att spara minne på bekostnad av vanligare skräpsamlingar och eventuellt längre paustider.
Standardvärdet är 0 – det innebär ingen ändring.
Förutom standardvärdet 0 är värdena mellan 1 och 9 (inklusive) giltiga. Ju högre värde, desto mer försöker skräpinsamlaren spara minne och därmed hålla högen liten.
Om värdet inte är noll komprimeras den stora objekthögen automatiskt om den har för mycket fragmentering.

	Inställningsnamn	Värden	Version introducerad
runtimeconfig.json	`System.GC.ConserveMemory`	`0` - `9`	.NET 6
Miljövariabel	`COMPlus_GCConserveMemory`	`0` -`9`	.NET Framework 4.8
Miljövariabel	`DOTNET_GCConserveMemory`	`0` -`9`	.NET 6
app.config för .NET Framework	GCConserveMemory	`0` -`9`	.NET Framework 4.8

Exempel på app.config-fil :


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

Dricks

Experimentera med olika tal för att se vilket värde som fungerar bäst för dig. Börja med ett värde mellan 5 och 7.

Dynamisk anpassning till programstorlekar (DATAS)

Konfigurerar skräpinsamlaren att använda DATAS. DATAS anpassar sig till kraven på programminne, vilket innebär att appens heapstorlek ska vara ungefär proportionell mot den långlivade datastorleken.
Aktiverad som standard med början i .NET 9.

	Inställningsnamn	Värden	Version introducerad
Miljövariabel	`DOTNET_GCDynamicAdaptationMode`	`1` -Aktiverat `0` -handikappad	.NET 8
MSBuild-egenskap	`GarbageCollectionAdaptationMode`	`1` -Aktiverat `0` -handikappad	.NET 8
runtimeconfig.json	`System.GC.DynamicAdaptationMode`	`1` -Aktiverat `0` -handikappad	.NET 8

Dela via

Körningskonfigurationsalternativ för skräpinsamling

Sätt att ange konfigurationen

Smaker av skräpinsamling

Arbetsstation jämfört med server

Exempel

Bakgrunds-GC

Exempel

Hantera resursanvändning

Antal heap

Exempel

Tillhörighetsmask

Exempel

Tillhörighetsintervall

Exempel

CPU-grupper

Tillhörighet

Exempel

Heap hård gräns

Exempel

Heap hård gränsprocent

Exempel

Hårda gränser per objekt-heap

Procent för hård gräns per objekt-heap

Hög minnesprocent

Behålla virtuell dator

Exempel

Stora sidor

Tillåt stora objekt

Tröskelvärde för stora objekts heap

Exempel

Fristående GC

Sökväg

Name

Spara minne

Dynamisk anpassning till programstorlekar (DATAS)

Ytterligare resurser