Opcje konfiguracji środowiska uruchomieniowego dla odzyskiwania pamięci

Artykuł
08/09/2024

Ta strona zawiera informacje o ustawieniach modułu odśmieceń pamięci środowiska uruchomieniowego platformy .NET (GC). Jeśli próbujesz osiągnąć szczytową wydajność uruchomionej aplikacji, rozważ użycie tych ustawień. Jednak wartości domyślne zapewniają optymalną wydajność dla większości aplikacji w typowych sytuacjach.

Ustawienia są rozmieszczane w grupach na tej stronie. Ustawienia w każdej grupie są często używane w połączeniu ze sobą w celu osiągnięcia określonego wyniku.

Uwaga

Te konfiguracje są odczytywane tylko przez środowisko uruchomieniowe, gdy GC jest inicjowane (zazwyczaj oznacza to w czasie uruchamiania procesu). Jeśli zmienisz zmienną środowiskową, gdy proces jest już uruchomiony, zmiana nie zostanie odzwierciedlona w tym procesie. Ustawienia, które można zmienić za pomocą interfejsów API w czasie wykonywania, takie jak poziom opóźnienia, zostaną pominięte na tej stronie.
Ponieważ GC jest na proces, rzadko ma sens ustawić te konfiguracje na poziomie maszyny. Na przykład nie chcesz, aby każdy proces platformy .NET na maszynie używał serwera GC lub tego samego limitu twardego sterty.
W przypadku wartości liczbowych użyj notacji dziesiętnej dla ustawień w pliku runtimeconfig.json lub runtimeconfig.template.json i notacji szesnastkowej dla ustawień zmiennych środowiskowych. W przypadku wartości szesnastkowej można określić je z prefiksem "0x" lub bez niego.
Jeśli używasz zmiennych środowiskowych, program .NET 6 i nowsze wersje są standardami w prefiksie DOTNET_ zamiast COMPlus_. COMPlus_ Jednak prefiks będzie nadal działać. Jeśli używasz poprzedniej wersji środowiska uruchomieniowego platformy .NET, nadal należy użyć prefiksu COMPlus_ , na przykład COMPlus_gcServer.

Sposoby określania konfiguracji

W przypadku różnych wersji środowiska uruchomieniowego platformy .NET istnieją różne sposoby określania wartości konfiguracji. W poniższej tabeli przedstawiono podsumowanie.

Lokalizacja konfiguracji	Wersje platformy .NET, których dotyczy ta lokalizacja	Formaty	Jak jest interpretowany
runtimeconfig.json plik/ plik runtimeconfig.template.json	.NET (Core)	n	n jest interpretowany jako wartość dziesiętna.
Zmienna środowiskowa	.NET Framework, .NET (Core)	0xn lub n	n jest interpretowany jako wartość szesnastkowy w obu formatach
plik app.config	.NET Framework	0xn	n jest interpretowany jako wartość^{szesnastkowy 1}

¹ Można określić wartość bez prefiksu 0x dla ustawienia pliku app.config, ale nie jest to zalecane. W programie .NET Framework 4.8 lub nowszym z powodu usterki wartość określona bez prefiksu 0x jest interpretowana jako szesnastkowa, ale w poprzednich wersjach programu .NET Framework jest interpretowana jako dziesiętna. Aby uniknąć konieczności zmiany konfiguracji, użyj prefiksu 0x podczas określania wartości w pliku app.config.

Aby na przykład określić 12 stert dla GCHeapCount aplikacji .NET Framework o nazwie A.exe, dodaj następujący kod XML do pliku A.exe.config .

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

W przypadku platformy .NET (Core) i .NET Framework można użyć zmiennych środowiskowych.

W systemie Windows przy użyciu platformy .NET 6 lub nowszej wersji:

SET DOTNET_gcServer=1
SET DOTNET_GCHeapCount=c

W systemie Windows przy użyciu platformy .NET 5 lub starszej:

SET COMPlus_gcServer=1
SET COMPlus_GCHeapCount=c

W innych systemach operacyjnych:

W przypadku platformy .NET 6 lub nowszej wersji:

export DOTNET_gcServer=1
export DOTNET_GCHeapCount=c

W przypadku platformy .NET 5 i starszych wersji:

export COMPlus_gcServer=1
export COMPlus_GCHeapCount=c

Jeśli nie używasz programu .NET Framework, możesz również ustawić wartość w pliku runtimeconfig.json lub runtimeconfig.template.json .

plik runtimeconfig.json:

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

plik runtimeconfig.template.json:

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

Smaki odzyskiwania pamięci

Dwa główne smaki odzyskiwania pamięci to stacja robocza GC i serwer GC. Aby uzyskać więcej informacji na temat różnic między nimi, zobacz Stacja robocza i odzyskiwanie pamięci serwera.

Podklawy odzyskiwania pamięci są w tle i nie są współbieżne.

Użyj następujących ustawień, aby wybrać smaki odzyskiwania pamięci:

Stacja robocza a serwer GC
GC tła

Stacja robocza a serwer

Określa, czy aplikacja używa odzyskiwania pamięci stacji roboczej, czy odzyskiwania pamięci serwera.
Ustawienie domyślne: Odzyskiwanie pamięci stacji roboczej. Jest to równoważne ustawieniu wartości na false.

	Nazwa ustawienia	Wartości	Wprowadzona wersja
runtimeconfig.json	`System.GC.Server`	`false` -stacja robocza `true` -serwer	.NET Core 1.0
Właściwość MSBuild	`ServerGarbageCollection`	`false` -stacja robocza `true` -serwer	.NET Core 1.0
Zmienna środowiskowa	`COMPlus_gcServer`	`0` -stacja robocza `1` -serwer	.NET Core 1.0
Zmienna środowiskowa	`DOTNET_gcServer`	`0` -stacja robocza `1` -serwer	.NET 6
app.config dla programu .NET Framework	GCServer	`false` -stacja robocza `true` -serwer

Przykłady

plik runtimeconfig.json:

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

plik runtimeconfig.template.json:

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

Plik projektu:

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

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

</Project>

Odzyskiwanie pamięci w tle

Określa, czy funkcja odzyskiwania pamięci w tle (współbieżna) jest włączona.
Ustawienie domyślne: użyj funkcji GC w tle. Jest to równoważne ustawieniu wartości na true.
Aby uzyskać więcej informacji, zobacz Odzyskiwanie pamięci w tle.

	Nazwa ustawienia	Wartości	Wprowadzona wersja
runtimeconfig.json	`System.GC.Concurrent`	`true` - tło GC `false` - niebieżne GC	.NET Core 1.0
Właściwość MSBuild	`ConcurrentGarbageCollection`	`true` - tło GC `false` - niebieżne GC	.NET Core 1.0
Zmienna środowiskowa	`COMPlus_gcConcurrent`	`1` - tło GC `0` - niebieżne GC	.NET Core 1.0
Zmienna środowiskowa	`DOTNET_gcConcurrent`	`1` - tło GC `0` - niebieżne GC	.NET 6
app.config dla programu .NET Framework	gcConcurrent	`true` - tło GC `false` - niebieżne GC

Przykłady

plik runtimeconfig.json:

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

plik runtimeconfig.template.json:

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

Plik projektu:

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

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

</Project>

Zarządzanie użyciem zasobów

Użyj następujących ustawień, aby zarządzać pamięcią modułu odśmiecającego pamięci i użyciem procesora:

Affinitize
Maska Affinitize
Affinitize zakresów
Grupy procesora CPU
Liczba stert
Limit twardy sterty
Procent twardego limitu sterty
Limity twarde sterty dla poszczególnych obiektów
Procenty twardego limitu sterty na obiekt
Procent dużej ilości pamięci
Zachowaj maszynę wirtualną

Aby uzyskać więcej informacji na temat niektórych z tych ustawień, zobacz wpis w blogu Middle ground between workstation and server GC (Środkowe podstawy między stacją roboczą i serwerem GC ).

Liczba stert

Ogranicza liczbę stertów utworzonych przez moduł odśmiecenia pamięci.
Dotyczy tylko odzyskiwania pamięci serwera.
Jeśli koligacja procesora GC jest włączona, co jest wartością domyślną, liczba stertów ustawia wartość affinitizes n heaps/threads GC na pierwsze n procesory. (Użyj ustawienia maski affinitize lub affinitize zakresów , aby określić dokładnie, które procesory mają być affinitize).
Jeśli koligacja procesora GC jest wyłączona, to ustawienie ogranicza liczbę stertów GC.
Aby uzyskać więcej informacji, zobacz uwagi GCHeapCount.

	Nazwa ustawienia	Wartości	Wprowadzona wersja
runtimeconfig.json	`System.GC.HeapCount`	wartość dziesiętna	.NET Core 3.0
Zmienna środowiskowa	`COMPlus_GCHeapCount`	wartość szesnastkowa	.NET Core 3.0
Zmienna środowiskowa	`DOTNET_GCHeapCount`	wartość szesnastkowa	.NET 6
app.config dla programu .NET Framework	GCHeapCount	wartość dziesiętna	.NET Framework 4.6.2

To ustawienie konfiguracji nie ma określonej właściwości MSBuild. Można jednak dodać RuntimeHostConfigurationOption element MSBuild. Użyj nazwy ustawienia runtimeconfig.json jako wartości atrybutuInclude. Aby zapoznać się z przykładem, zobacz Właściwości programu MSBuild.

Przykłady

plik runtimeconfig.json:

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

plik runtimeconfig.template.json:

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

Napiwek

Jeśli ustawiasz opcję w runtimeconfig.json, określ wartość dziesiętną. Jeśli ustawiasz opcję jako zmienną środowiskową, określ wartość szesnastkowa. Na przykład, aby ograniczyć liczbę ściągnięć do 16, wartości będą wynosić 16 dla pliku JSON i 0x10 lub 10 dla zmiennej środowiskowej.

Maska Affinitize

Określa dokładne procesory, których powinny używać wątki modułu odśmiecającego pamięci.
Jeśli koligacja procesora GC jest wyłączona, to ustawienie jest ignorowane.
Dotyczy tylko odzyskiwania pamięci serwera.
Wartość jest maską bitową, która definiuje procesory, które są dostępne dla procesu. Na przykład wartość dziesiętna 1023 (lub wartość szesnastkowa 0x3FF lub 3FF, jeśli używasz zmiennej środowiskowej) to 0011 1111 1111 w notacji binarnej. Określa, że należy użyć pierwszych 10 procesorów. Aby określić następne 10 procesorów, czyli procesory 10–19, określ wartość dziesiętną 1047552 (lub wartość szesnastkowa 0xFFC00 lub FFC00), która jest równoważna wartości binarnej 1111 1111 111 1100 000 000 000.

	Nazwa ustawienia	Wartości	Wprowadzona wersja
runtimeconfig.json	`System.GC.HeapAffinitizeMask`	wartość dziesiętna	.NET Core 3.0
Zmienna środowiskowa	`COMPlus_GCHeapAffinitizeMask`	wartość szesnastkowa	.NET Core 3.0
Zmienna środowiskowa	`DOTNET_GCHeapAffinitizeMask`	wartość szesnastkowa	.NET 6
app.config dla programu .NET Framework	GCHeapAffinitizeMask	wartość dziesiętna	.NET Framework 4.6.2

Przykłady

plik runtimeconfig.json:

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

plik runtimeconfig.template.json:

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

Affinitize zakresów

Określa listę procesorów do użycia dla wątków modułu odśmiecniania pamięci.
To ustawienie jest podobne do System.GC.HeapAffinitizeMask, z wyjątkiem tego, że umożliwia określenie więcej niż 64 procesorów.
W przypadku systemów operacyjnych Windows przedrostek numeru procesora lub zakresu z odpowiednią grupą procesorów, na przykład "0:1-10,0:12,1:50-52,1:7". Jeśli w rzeczywistości nie masz więcej niż 1 grupy procesora CPU, nie możesz użyć tego ustawienia. Należy użyć ustawienia maski Affinitize. A podane liczby znajdują się w tej grupie, co oznacza, że nie może być >= 64.
W przypadku systemów operacyjnych Linux, w których koncepcja grupy procesora CPU nie istnieje, można użyć zarówno tego ustawienia, jak i ustawienia maski Affinitize, aby określić te same zakresy. I zamiast "0:1-10", określ wartość "1-10", ponieważ nie musisz określać indeksu grupy.
Jeśli koligacja procesora GC jest wyłączona, to ustawienie jest ignorowane.
Dotyczy tylko odzyskiwania pamięci serwera.
Aby uzyskać więcej informacji, zobacz Artykuł Making CPU configuration better for GC on machines with 64 CPUus on Maoni Stephens blog (Tworzenie konfiguracji procesora CPU w przypadku maszyn z 64 procesorami > CPU w blogu Maoni Stephens).

	Nazwa ustawienia	Wartości	Wprowadzona wersja
runtimeconfig.json	`System.GC.HeapAffinitizeRanges`	Rozdzielona przecinkami lista numerów procesorów lub zakresów liczb procesora. Przykład systemu Unix: "1-10,12,50-52,70" Przykład systemu Windows: "0:1–10,0:12,1:50-52,1:7"	.NET Core 3.0
Zmienna środowiskowa	`COMPlus_GCHeapAffinitizeRanges`	Rozdzielona przecinkami lista numerów procesorów lub zakresów liczb procesora. Przykład systemu Unix: "1-10,12,50-52,70" Przykład systemu Windows: "0:1–10,0:12,1:50-52,1:7"	.NET Core 3.0
Zmienna środowiskowa	`DOTNET_GCHeapAffinitizeRanges`	Rozdzielona przecinkami lista numerów procesorów lub zakresów liczb procesora. Przykład systemu Unix: "1-10,12,50-52,70" Przykład systemu Windows: "0:1–10,0:12,1:50-52,1:7"	.NET 6

Przykłady

plik runtimeconfig.json:

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

plik runtimeconfig.template.json:

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

Grupy procesora CPU

Określa, czy moduł odśmiecający pamięć używa grup procesora CPU, czy nie.

Gdy 64-bitowy komputer z systemem Windows ma wiele grup procesora CPU, to znaczy, że istnieje więcej niż 64 procesory, włączenie tego elementu rozszerza odzyskiwanie pamięci we wszystkich grupach procesora CPU. Moduł odśmieceń pamięci używa wszystkich rdzeni do tworzenia i równoważenia stertów.

Uwaga

Jest to pojęcie tylko dla systemu Windows. W starszych wersjach systemu Windows system Windows ograniczył proces do jednej grupy procesorów CPU. W związku z tym usługa GC używała tylko jednej grupy procesora CPU, chyba że to ustawienie zostało użyte do włączenia wielu grup procesora CPU. To ograniczenie systemu operacyjnego zostało zniesione w systemach Windows 11 i Server 2022. Ponadto, począwszy od platformy .NET 7, GC domyślnie używa wszystkich grup procesora CPU podczas uruchamiania w systemie Windows 11 lub Server 2022.
Dotyczy tylko odzyskiwania pamięci serwera w 64-bitowych systemach operacyjnych Windows.
Ustawienie domyślne: GC nie rozszerza się między grupy procesora CPU. Jest to równoważne ustawieniu wartości na 0.
Aby uzyskać więcej informacji, zobacz Artykuł Making CPU configuration better for GC on machines with 64 CPUus on Maoni Stephens blog (Tworzenie konfiguracji procesora CPU w przypadku maszyn z 64 procesorami > CPU w blogu Maoni Stephens).

	Nazwa ustawienia	Wartości	Wprowadzona wersja
runtimeconfig.json	`System.GC.CpuGroup`	`false` -niepełnosprawny `true` -Włączone	.NET 5
Zmienna środowiskowa	`COMPlus_GCCpuGroup`	`0` -niepełnosprawny `1` -Włączone	.NET Core 1.0
Zmienna środowiskowa	`DOTNET_GCCpuGroup`	`0` -niepełnosprawny `1` -Włączone	.NET 6
app.config dla programu .NET Framework	GCCpuGroup	`false` -niepełnosprawny `true` -Włączone

Uwaga

Aby skonfigurować środowisko uruchomieniowe języka wspólnego (CLR), aby również dystrybuować wątki z puli wątków we wszystkich grupach procesora CPU, włącz opcję Thread_UseAllCpuGroups elementu . W przypadku aplikacji platformy .NET Core można włączyć tę opcję, ustawiając wartość zmiennej środowiskowej DOTNET_Thread_UseAllCpuGroups na 1.

Affinitize

Określa, czy wątki odzyskiwania pamięci mają być affinitize z procesorami. Aby zasumuć wątek GC oznacza, że może działać tylko na określonym procesorze CPU. Sterta jest tworzona dla każdego wątku GC.
Dotyczy tylko odzyskiwania pamięci serwera.
Ustawienie domyślne: Affinitize wątki odzyskiwania pamięci za pomocą procesorów. Jest to równoważne ustawieniu wartości na false.

	Nazwa ustawienia	Wartości	Wprowadzona wersja
runtimeconfig.json	`System.GC.NoAffinitize`	`false` - affinitize `true` - nie affinitize	.NET Core 3.0
Zmienna środowiskowa	`COMPlus_GCNoAffinitize`	`0` - affinitize `1` - nie affinitize	.NET Core 3.0
Zmienna środowiskowa	`DOTNET_GCNoAffinitize`	`0` - affinitize `1` - nie affinitize	.NET 6
app.config dla programu .NET Framework	GCNoAffinitize	`false` - affinitize `true` - nie affinitize	.NET Framework 4.6.2

Przykłady

plik runtimeconfig.json:

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

plik runtimeconfig.template.json:

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

Limit twardy sterty

Limit twardy sterty jest definiowany jako maksymalny rozmiar zatwierdzenia w bajtach dla sterty GC i księgowania GC.
To ustawienie dotyczy tylko komputerów 64-bitowych.
Jeśli ten limit nie jest skonfigurowany, ale proces jest uruchomiony w środowisku ograniczonym pamięci, czyli wewnątrz kontenera z określonym limitem pamięci, zostanie ustawiona wartość domyślna. Ta wartość domyślna to większa niż 20 MB lub 75% limitu pamięci w kontenerze.
To ustawienie jest ignorowane, jeśli skonfigurowano limity twarde sterty dla poszczególnych obiektów.

	Nazwa ustawienia	Wartości	Wprowadzona wersja
runtimeconfig.json	`System.GC.HeapHardLimit`	wartość dziesiętna	.NET Core 3.0
Zmienna środowiskowa	`COMPlus_GCHeapHardLimit`	wartość szesnastkowa	.NET Core 3.0
Zmienna środowiskowa	`DOTNET_GCHeapHardLimit`	wartość szesnastkowa	.NET 6

Przykłady

plik runtimeconfig.json:

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

plik runtimeconfig.template.json:

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

Napiwek

Jeśli ustawiasz opcję w runtimeconfig.json, określ wartość dziesiętną. Jeśli ustawiasz opcję jako zmienną środowiskową, określ wartość szesnastkowa. Na przykład aby określić limit stosu twardego 200 mebibajtów (MiB), wartości będą 209715200 dla pliku JSON i 0xC800000 lub C800000 dla zmiennej środowiskowej.

Procent twardego limitu sterty

Określa limit twardego sterty jako procent całkowitej pamięci fizycznej. Jeśli proces jest uruchomiony w środowisku ograniczonym pamięci, to znaczy wewnątrz kontenera z określonym limitem pamięci, łączna ilość pamięci fizycznej jest limitem pamięci; w przeciwnym razie jest to, co jest dostępne na maszynie.
To ustawienie dotyczy tylko komputerów 64-bitowych.
To ustawienie jest ignorowane, jeśli skonfigurowano limity twarde sterty dla poszczególnych obiektów lub skonfigurowano limit twardy sterty.

	Nazwa ustawienia	Wartości	Wprowadzona wersja
runtimeconfig.json	`System.GC.HeapHardLimitPercent`	wartość dziesiętna	.NET Core 3.0
Zmienna środowiskowa	`COMPlus_GCHeapHardLimitPercent`	wartość szesnastkowa	.NET Core 3.0
Zmienna środowiskowa	`DOTNET_GCHeapHardLimitPercent`	wartość szesnastkowa	.NET 6

Przykłady

plik runtimeconfig.json:

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

plik runtimeconfig.template.json:

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

Napiwek

Jeśli ustawiasz opcję w runtimeconfig.json, określ wartość dziesiętną. Jeśli ustawiasz opcję jako zmienną środowiskową, określ wartość szesnastkowa. Na przykład aby ograniczyć użycie sterta do 30%, wartości będą wynosić 30 dla pliku JSON i 0x1E lub 1E dla zmiennej środowiskowej.

Limity twarde sterty dla poszczególnych obiektów

Można określić twardy limit sterty GC na podstawie sterty dla poszczególnych obiektów. Różne sterty są dużym stertą obiektów (LOH), stertą małego obiektu (SOH) i przypiętą stertą obiektu (POH).

Jeśli określisz wartość dla dowolnego z DOTNET_GCHeapHardLimitSOHustawień , DOTNET_GCHeapHardLimitLOHlub DOTNET_GCHeapHardLimitPOH , należy również określić wartość dla DOTNET_GCHeapHardLimitSOH i DOTNET_GCHeapHardLimitLOH. Jeśli tego nie zrobisz, inicjowanie środowiska uruchomieniowego zakończy się niepowodzeniem.
Wartość domyślna parametru DOTNET_GCHeapHardLimitPOH to 0. DOTNET_GCHeapHardLimitSOH i DOTNET_GCHeapHardLimitLOH nie mają wartości domyślnych.

	Nazwa ustawienia	Wartości	Wprowadzona wersja
runtimeconfig.json	`System.GC.HeapHardLimitSOH`	wartość dziesiętna	.NET 5
Zmienna środowiskowa	`COMPlus_GCHeapHardLimitSOH`	wartość szesnastkowa	.NET 5
Zmienna środowiskowa	`DOTNET_GCHeapHardLimitSOH`	wartość szesnastkowa	.NET 6

	Nazwa ustawienia	Wartości	Wprowadzona wersja
runtimeconfig.json	`System.GC.HeapHardLimitLOH`	wartość dziesiętna	.NET 5
Zmienna środowiskowa	`COMPlus_GCHeapHardLimitLOH`	wartość szesnastkowa	.NET 5
Zmienna środowiskowa	`DOTNET_GCHeapHardLimitLOH`	wartość szesnastkowa	.NET 6

	Nazwa ustawienia	Wartości	Wprowadzona wersja
runtimeconfig.json	`System.GC.HeapHardLimitPOH`	wartość dziesiętna	.NET 5
Zmienna środowiskowa	`COMPlus_GCHeapHardLimitPOH`	wartość szesnastkowa	.NET 5
Zmienna środowiskowa	`DOTNET_GCHeapHardLimitPOH`	wartość szesnastkowa	.NET 6

Te ustawienia konfiguracji nie mają określonych właściwości programu MSBuild. Można jednak dodać RuntimeHostConfigurationOption element MSBuild. Użyj nazwy ustawienia runtimeconfig.json jako wartości atrybutuInclude. Aby zapoznać się z przykładem, zobacz Właściwości programu MSBuild.

Napiwek

Procenty twardego limitu sterty na obiekt

Jeśli określisz wartość dla dowolnego z DOTNET_GCHeapHardLimitSOHPercentustawień , DOTNET_GCHeapHardLimitLOHPercentlub DOTNET_GCHeapHardLimitPOHPercent , należy również określić wartość dla DOTNET_GCHeapHardLimitSOHPercent i DOTNET_GCHeapHardLimitLOHPercent. Jeśli tego nie zrobisz, inicjowanie środowiska uruchomieniowego zakończy się niepowodzeniem.
Te ustawienia są ignorowane, jeśli DOTNET_GCHeapHardLimitSOHokreślono wartości , DOTNET_GCHeapHardLimitLOHi DOTNET_GCHeapHardLimitPOH .
Wartość 1 oznacza, że GC używa 1% całkowitej pamięci fizycznej dla tego sterta obiektu.
Każda wartość musi być większa niż zero i mniejsza niż 100. Ponadto suma trzech wartości procentowych musi być mniejsza niż 100. W przeciwnym razie inicjowanie środowiska uruchomieniowego zakończy się niepowodzeniem.

	Nazwa ustawienia	Wartości	Wprowadzona wersja
runtimeconfig.json	`System.GC.HeapHardLimitSOHPercent`	wartość dziesiętna	.NET 5
Zmienna środowiskowa	`COMPlus_GCHeapHardLimitSOHPercent`	wartość szesnastkowa	.NET 5
Zmienna środowiskowa	`DOTNET_GCHeapHardLimitSOHPercent`	wartość szesnastkowa	.NET 6

	Nazwa ustawienia	Wartości	Wprowadzona wersja
runtimeconfig.json	`System.GC.HeapHardLimitLOHPercent`	wartość dziesiętna	.NET 5
Zmienna środowiskowa	`COMPlus_GCHeapHardLimitLOHPercent`	wartość szesnastkowa	.NET 5
Zmienna środowiskowa	`DOTNET_GCHeapHardLimitLOHPercent`	wartość szesnastkowa	.NET 6

	Nazwa ustawienia	Wartości	Wprowadzona wersja
runtimeconfig.json	`System.GC.HeapHardLimitPOHPercent`	wartość dziesiętna	.NET 5
Zmienna środowiskowa	`COMPlus_GCHeapHardLimitPOHPercent`	wartość szesnastkowa	.NET 5
Zmienna środowiskowa	`DOTNET_GCHeapHardLimitPOHPercent`	wartość szesnastkowa	.NET 6

Napiwek

Procent dużej ilości pamięci

Obciążenie pamięcią jest wskazywane przez procent używanej pamięci fizycznej. Domyślnie gdy obciążenie pamięci fizycznej osiągnie 90%, odzyskiwanie pamięci staje się bardziej agresywne w przypadku wykonywania pełnych, kompaktowania odzyskiwania pamięci w celu uniknięcia stronicowania. Gdy obciążenie pamięci jest mniejsze niż 90%, GC preferuje zbieranie w tle pełnych pamięci, które mają krótsze wstrzymanie, ale nie zmniejszają całkowitego rozmiaru sterty o wiele. Na maszynach ze znaczną ilością pamięci (co najmniej 80 GB) domyślny próg obciążenia wynosi od 90% do 97%.

Próg dużego obciążenia pamięci można dostosować za pomocą zmiennej środowiskowej DOTNET_GCHighMemPercent lub System.GC.HighMemoryPercent ustawienia konfiguracji JSON. Rozważ dostosowanie progu, jeśli chcesz kontrolować rozmiar sterty. Na przykład w przypadku dominującego procesu na maszynie z 64 GB pamięci warto zacząć reagować, gdy jest dostępna 10% pamięci. Jednak w przypadku mniejszych procesów, na przykład, proces, który zużywa tylko 1 GB pamięci, GC może wygodnie działać z mniej niż 10% dostępnej pamięci. W przypadku tych mniejszych procesów rozważ ustawienie progu wyższego. Z drugiej strony, jeśli chcesz, aby większe procesy miały mniejsze rozmiary sterty (nawet jeśli jest dużo dostępnej pamięci fizycznej), obniżenie tego progu jest skutecznym sposobem, aby GC reagować wcześniej na kompaktowanie sterty w dół.

Uwaga

W przypadku procesów uruchomionych w kontenerze usługa GC uwzględnia pamięć fizyczną na podstawie limitu kontenera.

	Nazwa ustawienia	Wartości	Wprowadzona wersja
runtimeconfig.json	`System.GC.HighMemoryPercent`	wartość dziesiętna	.NET 5
Zmienna środowiskowa	`COMPlus_GCHighMemPercent`	wartość szesnastkowa	.NET Core 3.0 .NET Framework 4.7.2
Zmienna środowiskowa	`DOTNET_GCHighMemPercent`	wartość szesnastkowa	.NET 6

Napiwek

Jeśli ustawiasz opcję w runtimeconfig.json, określ wartość dziesiętną. Jeśli ustawiasz opcję jako zmienną środowiskową, określ wartość szesnastkowa. Na przykład aby ustawić wysoki próg pamięci na 75%, wartości będą wynosić 75 dla pliku JSON i 0x4B lub 4B dla zmiennej środowiskowej.

Zachowaj maszynę wirtualną

Określa, czy segmenty, które mają zostać usunięte, są umieszczane na liście rezerwowej do użytku w przyszłości lub są zwalniane z powrotem do systemu operacyjnego.
Ustawienie domyślne: segmenty wydania są przywracane do systemu operacyjnego. Jest to równoważne ustawieniu wartości na false.

	Nazwa ustawienia	Wartości	Wprowadzona wersja
runtimeconfig.json	`System.GC.RetainVM`	`false` — wydanie do systemu operacyjnego `true` - umieścić w stanie wstrzymania	.NET Core 1.0
Właściwość MSBuild	`RetainVMGarbageCollection`	`false` — wydanie do systemu operacyjnego `true` - umieścić w stanie wstrzymania	.NET Core 1.0
Zmienna środowiskowa	`COMPlus_GCRetainVM`	`0` — wydanie do systemu operacyjnego `1` - umieścić w stanie wstrzymania	.NET Core 1.0
Zmienna środowiskowa	`DOTNET_GCRetainVM`	`0` — wydanie do systemu operacyjnego `1` - umieścić w stanie wstrzymania	.NET 6

Przykłady

plik runtimeconfig.json:

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

plik runtimeconfig.template.json:

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

Plik projektu:

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

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

</Project>

Duże strony

Określa, czy w przypadku ustawienia limitu twardego sterty należy używać dużych stron.
Ustawienie domyślne: nie używaj dużych stron, gdy ustawiony jest limit twardy sterty. Jest to równoważne ustawieniu wartości na 0.
Jest to ustawienie eksperymentalne.

	Nazwa ustawienia	Wartości	Wprowadzona wersja
runtimeconfig.json	Brak	NIE DOTYCZY	Brak
Zmienna środowiskowa	`COMPlus_GCLargePages`	`0` -niepełnosprawny `1` -Włączone	.NET Core 3.0
Zmienna środowiskowa	`DOTNET_GCLargePages`	`0` -niepełnosprawny `1` -Włączone	.NET 6

Zezwalaj na duże obiekty

Konfiguruje obsługę modułu odśmiecającego pamięci na 64-bitowych platformach dla tablic, które są większe niż 2 gigabajty (GB) w całkowitym rozmiarze.
Ustawienie domyślne: GC obsługuje tablice większe niż 2 GB. Jest to równoważne ustawieniu wartości na 1.
Ta opcja może stać się przestarzała w przyszłej wersji platformy .NET.

	Nazwa ustawienia	Wartości	Wprowadzona wersja
runtimeconfig.json	Brak	NIE DOTYCZY	Brak
Zmienna środowiskowa	`COMPlus_gcAllowVeryLargeObjects`	`1` -Włączone `0` -niepełnosprawny	.NET Core 1.0
Zmienna środowiskowa	`DOTNET_gcAllowVeryLargeObjects`	`1` -Włączone `0` -niepełnosprawny	.NET 6
app.config dla programu .NET Framework	gcAllowVeryLargeObjects	`1` -Włączone `0` -niepełnosprawny	.NET Framework 4.5

Próg stert dużych obiektów

Określa rozmiar progu w bajtach, który powoduje, że obiekty przechodzą na dużą stertę obiektu (LOH).
Domyślny próg to 85 000 bajtów.
Określona wartość musi być większa niż domyślny próg.
Wartość może być ograniczona przez środowisko uruchomieniowe do maksymalnego możliwego rozmiaru dla bieżącej konfiguracji. Wartość używaną w czasie wykonywania można sprawdzić za pośrednictwem interfejsu GC.GetConfigurationVariables() API.

	Nazwa ustawienia	Wartości	Wprowadzona wersja
runtimeconfig.json	`System.GC.LOHThreshold`	wartość dziesiętna	.NET Core 1.0
Zmienna środowiskowa	`COMPlus_GCLOHThreshold`	wartość szesnastkowa	.NET Core 1.0
Zmienna środowiskowa	`DOTNET_GCLOHThreshold`	wartość szesnastkowa	.NET 6
app.config dla programu .NET Framework	GCLOHThreshold	wartość dziesiętna	.NET Framework 4.8

Przykłady

plik runtimeconfig.json:

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

plik runtimeconfig.template.json:

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

Napiwek

Jeśli ustawiasz opcję w runtimeconfig.json, określ wartość dziesiętną. Jeśli ustawiasz opcję jako zmienną środowiskową, określ wartość szesnastkowa. Na przykład aby ustawić rozmiar progu 120 000 bajtów, wartości będą wynosić 120000 dla pliku JSON i 0x1D4C0 lub 1D4C0 dla zmiennej środowiskowej.

Autonomiczna usługa GC

Aby użyć autonomicznego modułu odśmieceń pamięci zamiast domyślnej implementacji GC, można określić ścieżkę (w wersji .NET 9 i nowszych) lub nazwę biblioteki natywnej GC.

Ścieżka

Określa pełną ścieżkę biblioteki natywnej GC, którą środowisko uruchomieniowe ładuje zamiast domyślnej implementacji GC. Aby zapewnić bezpieczeństwo, ta lokalizacja powinna być chroniona przed potencjalnie złośliwym naruszeniem.

	Nazwa ustawienia	Wartości	Wprowadzona wersja
runtimeconfig.json	`System.GC.Path`	string_path	.NET 9
Zmienna środowiskowa	`DOTNET_GCPath`	string_path	.NET 9

Nazwisko

Określa nazwę biblioteki natywnej GC, którą środowisko uruchomieniowe ładuje zamiast domyślnej implementacji GC. Zachowanie zostało zmienione na platformie .NET 9 wraz z wprowadzeniem konfiguracji ścieżki.

W programie .NET 8 i poprzednich wersjach:
- Jeśli zostanie określona tylko nazwa biblioteki, biblioteka musi znajdować się w tym samym katalogu co środowisko uruchomieniowe platformy .NET (coreclr.dll w systemie Windows, libcoreclr.so w systemie Linux lub libcoreclr.dylib w systemie OSX).
- Wartość może być również ścieżką względną, na przykład jeśli określisz wartość ".. \clrgc.dll" w systemie Windows clrgc.dll jest ładowany z katalogu nadrzędnego katalogu środowiska uruchomieniowego platformy .NET.
W programie .NET 9 i nowszych wersjach ta wartość określa tylko nazwę pliku (ścieżki nie są dozwolone):
- Platforma .NET wyszukuje nazwę podaną w katalogu, w którym znajduje się zestaw zawierający metodę aplikacji Main .
- Jeśli plik nie zostanie znaleziony, przeszukiwany jest katalog środowiska uruchomieniowego platformy .NET.
To ustawienie konfiguracji jest ignorowane, jeśli określono konfigurację ścieżki .

	Nazwa ustawienia	Wartości	Wprowadzona wersja
runtimeconfig.json	`System.GC.Name`	string_name	.NET 7
Zmienna środowiskowa	`COMPlus_GCName`	string_name	.NET Core 2.0
Zmienna środowiskowa	`DOTNET_GCName`	string_name	.NET 6

Oszczędzanie pamięci

Konfiguruje moduł odśmiecywania pamięci, aby oszczędzać pamięć kosztem częstszych odzyskiwania pamięci i ewentualnie dłuższy czas wstrzymania.
Wartość domyślna to 0 — nie oznacza to żadnej zmiany.
Oprócz wartości domyślnej 0 wartości z zakresu od 1 do 9 (włącznie) są prawidłowe. Im większa wartość, tym bardziej moduł odśmiecający pamięć próbuje zaoszczędzić pamięć, a tym samym zachować stertę małą.
Jeśli wartość jest inna niż zero, sterta dużych obiektów zostanie zwarta automatycznie, jeśli ma zbyt dużą fragmentację.

	Nazwa ustawienia	Wartości	Wprowadzona wersja
runtimeconfig.json	`System.GC.ConserveMemory`	`0` - `9`	.NET 6
Zmienna środowiskowa	`COMPlus_GCConserveMemory`	`0` -`9`	.NET Framework 4.8
Zmienna środowiskowa	`DOTNET_GCConserveMemory`	`0` -`9`	.NET 6
app.config dla programu .NET Framework	GCConserveMemory	`0` -`9`	.NET Framework 4.8

Przykładowy plik app.config :


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

Napiwek

Poeksperymentuj z różnymi liczbami, aby zobaczyć, która wartość jest najlepsza dla Ciebie. Zacznij od wartości z zakresu od 5 do 7.

Dynamiczna adaptacja do rozmiarów aplikacji (DATAS)

Konfiguruje moduł odśmieceń pamięci do używania usługi DATAS. Usługa DATAS dostosowuje się do wymagań dotyczących pamięci aplikacji, co oznacza, że rozmiar sterty aplikacji powinien być w przybliżeniu proporcjonalny do rozmiaru danych długotrwałych.
Domyślnie jest włączona począwszy od platformy .NET 9.

	Nazwa ustawienia	Wartości	Wprowadzona wersja
Zmienna środowiskowa	`DOTNET_GCDynamicAdaptationMode`	`1` -Włączone `0` -niepełnosprawny	.NET 8
Właściwość MSBuild	`GarbageCollectionAdaptationMode`	`1` -Włączone `0` -niepełnosprawny	.NET 8
runtimeconfig.json	`System.GC.DynamicAdaptationMode`	`1` -Włączone `0` -niepełnosprawny	.NET 8

Udostępnij za pośrednictwem

Opcje konfiguracji środowiska uruchomieniowego dla odzyskiwania pamięci

Sposoby określania konfiguracji

Smaki odzyskiwania pamięci

Stacja robocza a serwer

Przykłady

Odzyskiwanie pamięci w tle

Przykłady

Zarządzanie użyciem zasobów

Liczba stert

Przykłady

Maska Affinitize

Przykłady

Affinitize zakresów

Przykłady

Grupy procesora CPU

Affinitize

Przykłady

Limit twardy sterty

Przykłady

Procent twardego limitu sterty

Przykłady

Limity twarde sterty dla poszczególnych obiektów

Procenty twardego limitu sterty na obiekt

Procent dużej ilości pamięci

Zachowaj maszynę wirtualną

Przykłady

Duże strony

Zezwalaj na duże obiekty

Próg stert dużych obiektów

Przykłady

Autonomiczna usługa GC

Ścieżka

Nazwisko

Oszczędzanie pamięci

Dynamiczna adaptacja do rozmiarów aplikacji (DATAS)

Dodatkowe zasoby