Opzioni di configurazione di runtime per Garbage Collection

Articolo
08/09/2024

Questa pagina contiene informazioni sulle impostazioni per Garbage Collector (GC) di runtime .NET. Se si sta provando a ottenere prestazioni eccellenti per un'app in esecuzione, è consigliabile usare queste impostazioni. Tuttavia, le impostazioni predefinite offrono prestazioni ottimali per la maggior parte delle applicazioni in situazioni tipiche.

Le impostazioni sono suddivise in gruppi in questa pagina. Le impostazioni all'interno di ogni gruppo vengono comunemente usate insieme tra loro per ottenere un risultato specifico.

Nota

Queste configurazioni vengono lette dal runtime solo al momento dell'inizializzazione di GC (in genere questo significa durante la fase di avvio del processo). Se si modifica una variabile di ambiente quando un processo è già in esecuzione, la modifica non verrà riflessa in tale processo. Le impostazioni che possono essere modificate tramite API in fase di esecuzione, ad esempio il livello di latenza, vengono omesse da questa pagina.
Poiché GC opera per processo, raramente ha senso impostare queste configurazioni a livello di computer. Ad esempio, non sarebbe utile fare in modo che ogni processo .NET in un computer usi GC per server o lo stesso limite fisso per l'heap.
Per i valori numerici, usare la notazione decimale per le impostazioni nel file runtimeconfig.json o runtimeconfig.template.json e la notazione esadecimale per le impostazioni delle variabili di ambiente. I valori esadecimali possono essere specificati con o senza il prefisso "0x".
Se si usano le variabili di ambiente, .NET 6 e versioni successive usano come standard il prefisso DOTNET_ anziché COMPlus_. Tuttavia, il prefisso COMPlus_ continuerà a funzionare. Se si usa una versione precedente del runtime .NET, è comunque consigliabile usare il prefisso COMPlus_, ad esempio COMPlus_gcServer.

Modi per specificare la configurazione

Per versioni diverse del runtime .NET, esistono modi differenti per specificare i valori di configurazione. Nella tabella seguente è disponibile un riepilogo.

Posizione di configurazione	Versioni di .NET a cui si applica questa posizione	Formati	Interpretazione
file runtimeconfig.json/ file runtimeconfig.template.json	.NET (Core)	n	n viene interpretato come valore decimale.
Variabile di ambiente	.NET Framework, .NET (Core)	0xn o n	n viene interpretato come valore esadecimale in entrambi i formati
file app.config	.NET Framework	0xn	n viene interpretato come valore esadecimale¹

¹ È possibile specificare un valore senza il prefisso 0x per un'impostazione del file app.config, ma non è consigliabile. In .NET Framework 4.8+, a causa di un bug, un valore specificato senza il prefisso 0x viene interpretato come esadecimale, ma nelle versioni precedenti di .NET Framework viene interpretato come decimale. Per evitare di dover modificare la configurazione, usare il prefisso 0x quando si specifica un valore nel file app.config.

Ad esempio, per specificare 12 heap per GCHeapCount un'app .NET Framework denominata A.exe, aggiungere il codice XML seguente al file A.exe.config.

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

Sia per .NET (Core) che per .NET Framework, è possibile usare le variabili di ambiente.

In Windows con .NET 6 o versione successiva:

SET DOTNET_gcServer=1
SET DOTNET_GCHeapCount=c

In Windows con .NET 5 o versioni precedenti:

SET COMPlus_gcServer=1
SET COMPlus_GCHeapCount=c

In altri sistemi operativi:

Per .NET 6 o versioni successive:

export DOTNET_gcServer=1
export DOTNET_GCHeapCount=c

Per .NET 5 e versioni precedenti:

export COMPlus_gcServer=1
export COMPlus_GCHeapCount=c

Se non si usa .NET Framework, è anche possibile impostare il valore nel file runtimeconfig.json o runtimeconfig.template.json.

File runtimeconfig.json:

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

File runtimeconfig.template.json:

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

Tipi di Garbage Collection

I due tipi principali di Garbage Collection sono GC per workstation e GC per server. Per altre informazioni sulle differenze, vedere Operazione di Garbage Collection per workstation e server.

I sottotipi di Garbage Collection sono in background e non simultanea.

Usare le impostazioni seguenti per selezionare i tipi di Garbage Collection:

GC per workstation o server
GC in background

Per workstation o server

Questa impostazione consente di configurare se l'applicazione usa il processo di Garbage Collection per workstation o per server.
Impostazione predefinita: Garbage Collection per workstation. Equivale a impostare il valore su false.

	Nome impostazione	Valori	Versione introdotta
runtimeconfig.json	`System.GC.Server`	`false` - workstation `true` - server	.NET Core 1.0
Proprietà MSBuild	`ServerGarbageCollection`	`false` - workstation `true` - server	.NET Core 1.0
Variabile di ambiente	`COMPlus_gcServer`	`0` - workstation `1` - server	.NET Core 1.0
Variabile di ambiente	`DOTNET_gcServer`	`0` - workstation `1` - server	.NET 6
app.config per .NET Framework	GCServer	`false` - workstation `true` - server

Esempi

File runtimeconfig.json:

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

File runtimeconfig.template.json:

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

File di progetto:

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

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

</Project>

GC in background

Questa impostazione consente di configurare se il processo di Garbage Collection (simultanea) in background è abilitato.
Impostazione predefinita: uso di GC in background. Equivale a impostare il valore su true.
Per altre informazioni, vedere Garbage Collection in background.

	Nome impostazione	Valori	Versione introdotta
runtimeconfig.json	`System.GC.Concurrent`	`true` - GC in background `false` - GC non simultanea	.NET Core 1.0
Proprietà MSBuild	`ConcurrentGarbageCollection`	`true` - GC in background `false` - GC non simultanea	.NET Core 1.0
Variabile di ambiente	`COMPlus_gcConcurrent`	`1` - GC in background `0` - GC non simultanea	.NET Core 1.0
Variabile di ambiente	`DOTNET_gcConcurrent`	`1` - GC in background `0` - GC non simultanea	.NET 6
app.config per .NET Framework	gcConcurrent	`true` - GC in background `false` - GC non simultanea

Esempi

File runtimeconfig.json:

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

File runtimeconfig.template.json:

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

File di progetto:

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

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

</Project>

Gestire l'utilizzo delle risorse

Usare le impostazioni seguenti per gestire l'utilizzo della memoria e del processore di Garbage Collector:

Affinità
Maschera di affinità
Intervalli di affinità
Gruppi di CPU
Conteggio degli heap
Limite rigido dell'heap
Percentuale limite rigido heap
Limiti rigidi per oggetto-heap
Percentuali limite rigido per oggetto-heap
Limite degli heap in percentuale
Mantenere la memoria virtuale

Per altre informazioni su alcune di queste impostazioni, vedere l'articolo di blogMiddle ground between workstation and server GC.

Conteggio degli heap

Limita il numero di heap creati dal Garbage Collector.
Si applica solo al processo di Garbage Collection per server.
Se l'affinità dei processori GC è abilitata, ovvero l'impostazione predefinita, l'impostazione del conteggio di heap imposta l'affinità di n heap/thread GC sui primi n processori. Usare le impostazioni della maschera di affinità o degli intervalli di affinità per specificare esattamente i processori per cui impostare l'affinità.
Se l'affinità dei processori GC è disabilitata, questa impostazione limita il numero di heap GC.
Per altre informazioni, vedere la sezione Osservazioni per GCHeapCount.

	Nome impostazione	Valori	Versione introdotta
runtimeconfig.json	`System.GC.HeapCount`	valore decimale	.NET Core 3.0
Variabile di ambiente	`COMPlus_GCHeapCount`	valore esadecimale	.NET Core 3.0
Variabile di ambiente	`DOTNET_GCHeapCount`	valore esadecimale	.NET 6
app.config per .NET Framework	GCHeapCount	valore decimale	.NET Framework 4.6.2

Questa impostazione di configurazione non ha una proprietà MSBuild specifica. È tuttavia possibile aggiungere un elemento MSBuild RuntimeHostConfigurationOption in alternativa. Usare il nome dell'impostazione runtimeconfig.json come valore dell'attributo Include. Per un esempio, vedere Proprietà di MSBuild.

Esempi

File runtimeconfig.json:

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

File runtimeconfig.template.json:

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

Suggerimento

Se si imposta l'opzione in runtimeconfig.json, specificare un valore decimale. Se si imposta l'opzione come variabile di ambiente, specificare un valore esadecimale. Ad esempio, per limitare il numero di heap a 16, i valori saranno 16 per il file JSON e 0x10 o 10 per la variabile di ambiente.

Maschera di affinità

Specifica i processori esatti che devono essere usati dai thread di Garbage Collector.
Se l'affinità dei processori GC è disabilitata, questa impostazione viene ignorata.
Si applica solo al processo di Garbage Collection per server.
Il valore è una maschera di bit che definisce i processori disponibili per il processo. Ad esempio, il valore decimale 1023 (o il valore esadecimale 0x3FF o 3FF se si usa la variabile di ambiente) corrisponde a 0011 1111 1111 nella notazione binaria. Specifica che devono essere usati i primi 10 processori. Per specificare i 10 processori successivi, ovvero i processori da 10 a 19, specificare il valore decimale 1047552 (oppure il valore esadecimale 0xFFC00 o FFC00), equivalente al valore binario 1111 1111 1100 0000 0000.

	Nome impostazione	Valori	Versione introdotta
runtimeconfig.json	`System.GC.HeapAffinitizeMask`	valore decimale	.NET Core 3.0
Variabile di ambiente	`COMPlus_GCHeapAffinitizeMask`	valore esadecimale	.NET Core 3.0
Variabile di ambiente	`DOTNET_GCHeapAffinitizeMask`	valore esadecimale	.NET 6
app.config per .NET Framework	GCHeapAffinitizeMask	valore decimale	.NET Framework 4.6.2

Esempi

File runtimeconfig.json:

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

File runtimeconfig.template.json:

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

Intervalli di affinità

Specifica l'elenco dei processori da usare per i thread di Garbage Collector.
Questa impostazione è simile a System.GC.HeapAffinitizeMask, ma consente di specificare più di 64 processori.
Per i sistemi operativi Windows, anteporre il numero o l'intervallo di processori al gruppo di CPU corrispondente, ad esempio "0:1-10,0:12,1:50-52,1:7". Se in realtà non si dispone di più di un gruppo di CPU, non è possibile usare questa impostazione. È necessario usare l'impostazione della maschera di affinità. E i numeri specificati devono essere compresi in tale gruppo, il che significa che il valore non può essere >= 64.
Per i sistemi operativi Linux, in cui il concetto di gruppo di CPU non esiste, è possibile usare sia questa impostazione che l'impostazione della maschera di affinità per specificare gli stessi intervalli. Invece di "0:1-10", specificare quindi "1-10" perché non è necessario specificare un indice di gruppo.
Se l'affinità dei processori GC è disabilitata, questa impostazione viene ignorata.
Si applica solo al processo di Garbage Collection per server.
Per altre informazioni, vedere Making CPU configuration better for GC on machines with > 64 CPUs nel blog di Maoni Stephens.

	Nome impostazione	Valori	Versione introdotta
runtimeconfig.json	`System.GC.HeapAffinitizeRanges`	Elenco delimitato da virgole di numeri di processore o di intervalli di numeri di processore. Esempio Unix: "1-10,12,50-52,70" Esempio Windows: "0:1-10,0:12,1:50-52,1:7"	.NET Core 3.0
Variabile di ambiente	`COMPlus_GCHeapAffinitizeRanges`	Elenco delimitato da virgole di numeri di processore o di intervalli di numeri di processore. Esempio Unix: "1-10,12,50-52,70" Esempio Windows: "0:1-10,0:12,1:50-52,1:7"	.NET Core 3.0
Variabile di ambiente	`DOTNET_GCHeapAffinitizeRanges`	Elenco delimitato da virgole di numeri di processore o di intervalli di numeri di processore. Esempio Unix: "1-10,12,50-52,70" Esempio Windows: "0:1-10,0:12,1:50-52,1:7"	.NET 6

Esempi

File runtimeconfig.json:

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

File runtimeconfig.template.json:

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

Gruppi di CPU

Questa impostazione consente di configurare se il Garbage Collector usa o meno gruppi di CPU.

Quando un computer Windows a 64 bit ha più gruppi di CPU, ovvero sono presenti più di 64 processori, abilitando questo elemento la Garbage Collection viene estesa a tutti i gruppi di CPU. Il Garbage Collector usa tutti i core per creare ed bilanciare gli heap.

Nota

Si tratta di un concetto esclusivo per Windows. Nelle versioni precedenti di Windows i processi erano limitati a un solo gruppo di CPU. Pertanto, GC usava un solo gruppo di CPU, a meno che non venisse usata questa impostazione per abilitare più gruppi di CPU. Questa limitazione del sistema operativo è stata eliminata in Windows 11 e Windows Server 2022. Inoltre, a partire da .NET 7, GC usa per impostazione predefinita tutti i gruppi di CPU durante l'esecuzione in Windows 11 o Windows Server 2022.
Si applica alla Garbage Collection per il server solo nei sistemi operativi Windows a 64 bit.
Impostazione predefinita: il processo GC non viene esteso ai gruppi di CPU. Equivale a impostare il valore su 0.
Per altre informazioni, vedere Making CPU configuration better for GC on machines with > 64 CPUs nel blog di Maoni Stephens.

	Nome impostazione	Valori	Versione introdotta
runtimeconfig.json	`System.GC.CpuGroup`	`false` - disabilitata `true` - abilitato	.NET 5
Variabile di ambiente	`COMPlus_GCCpuGroup`	`0`: disabilitata `1` - abilitato	.NET Core 1.0
Variabile di ambiente	`DOTNET_GCCpuGroup`	`0`: disabilitata `1` - abilitato	.NET 6
app.config per .NET Framework	GCCpuGroup	`false` - disabilitato `true` - abilitato

Nota

Per configurare Common Language Runtime (CLR) per distribuire anche i thread dal pool di thread in tutti i gruppi di CPU, abilitare l'opzione dell'elemento Thread_UseAllCpuGroups. Per le app .NET Core, è possibile abilitare questa opzione impostando il valore della variabile di ambiente DOTNET_Thread_UseAllCpuGroups su 1.

Affinità

Specifica se impostare l'affinità tra i thread di Garbage Collection e i processori. Impostare l'affinità per un thread GC significa poterlo eseguire solo sulla CPU specifica. Viene creato un heap per ogni thread GC.
Si applica solo al processo di Garbage Collection per server.
Impostazione predefinita: impostazione dell'affinità tra i thread di Garbage Collection e i processori. Equivale a impostare il valore su false.

	Nome impostazione	Valori	Versione introdotta
runtimeconfig.json	`System.GC.NoAffinitize`	`false` - impostare l'affinità `true` - non impostare l'affinità	.NET Core 3.0
Variabile di ambiente	`COMPlus_GCNoAffinitize`	`0` - impostare l'affinità `1` - non impostare l'affinità	.NET Core 3.0
Variabile di ambiente	`DOTNET_GCNoAffinitize`	`0` - impostare l'affinità `1` - non impostare l'affinità	.NET 6
app.config per .NET Framework	GCNoAffinitize	`false` - impostare l'affinità `true` - non impostare l'affinità	.NET Framework 4.6.2

Esempi

File runtimeconfig.json:

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

File runtimeconfig.template.json:

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

Limite rigido dell'heap

Il limite rigido dell'heap è definito come dimensione massima del commit, in byte, per l'heap GC e il registro GC.
Questa impostazione si applica solo ai computer a 64 bit.
Se questo limite non è configurato ma il processo è in esecuzione in un ambiente con vincoli di memoria, ovvero all'interno di un contenitore con un limite di memoria specificato, viene impostato un valore predefinito. Questo valore predefinito è maggiore di 20 MB o del 75% del limite di memoria nel contenitore.
Questa impostazione viene ignorata se sono configurati i limiti rigidi per oggetto-heap.

	Nome impostazione	Valori	Versione introdotta
runtimeconfig.json	`System.GC.HeapHardLimit`	valore decimale	.NET Core 3.0
Variabile di ambiente	`COMPlus_GCHeapHardLimit`	valore esadecimale	.NET Core 3.0
Variabile di ambiente	`DOTNET_GCHeapHardLimit`	valore esadecimale	.NET 6

Esempi

File runtimeconfig.json:

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

File runtimeconfig.template.json:

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

Suggerimento

Se si imposta l'opzione in runtimeconfig.json, specificare un valore decimale. Se si imposta l'opzione come variabile di ambiente, specificare un valore esadecimale. Ad esempio, per specificare un limite fisso dell'heap di 200 mebibyte (MiB), i valori saranno 209715200 per il file JSON e 0xC800000 o C800000 per la variabile di ambiente.

Percentuale limite rigido heap

Specifica il limite rigido dell'heap come percentuale della memoria fisica totale. Se il processo è in esecuzione in un ambiente con vincoli di memoria, ovvero all'interno di un contenitore con un limite di memoria specificato, la memoria fisica totale è il limite di memoria; in caso contrario, è ciò che è disponibile nel computer.
Questa impostazione si applica solo ai computer a 64 bit.
Questa impostazione viene ignorata se sono configurati limiti rigidi per oggetto-heap o se è configurato il limite rigido dell'heap.

	Nome impostazione	Valori	Versione introdotta
runtimeconfig.json	`System.GC.HeapHardLimitPercent`	valore decimale	.NET Core 3.0
Variabile di ambiente	`COMPlus_GCHeapHardLimitPercent`	valore esadecimale	.NET Core 3.0
Variabile di ambiente	`DOTNET_GCHeapHardLimitPercent`	valore esadecimale	.NET 6

Esempi

File runtimeconfig.json:

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

File runtimeconfig.template.json:

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

Suggerimento

Se si imposta l'opzione in runtimeconfig.json, specificare un valore decimale. Se si imposta l'opzione come variabile di ambiente, specificare un valore esadecimale. Ad esempio, per limitare l'utilizzo dell'heap al 30%, i valori saranno 30 per il file JSON e 0x1E o 1E per la variabile di ambiente.

Limiti rigidi per oggetto-heap

È possibile specificare il limite rigido dell'heap di GC in base all'heap per oggetto. I diversi heap sono LOH (Large Object Heap), SOH (Small Object Heap) e POH (Pinned Object Heap).

Se si specifica un valore per una delle impostazioni DOTNET_GCHeapHardLimitSOH, DOTNET_GCHeapHardLimitLOH o DOTNET_GCHeapHardLimitPOH, è necessario specificare anche un valore per DOTNET_GCHeapHardLimitSOH e DOTNET_GCHeapHardLimitLOH. In caso contrario, il runtime non verrà inizializzato.
Il valore predefinito per DOTNET_GCHeapHardLimitPOH è 0. DOTNET_GCHeapHardLimitSOH e DOTNET_GCHeapHardLimitLOH non hanno valori predefiniti.

	Nome impostazione	Valori	Versione introdotta
runtimeconfig.json	`System.GC.HeapHardLimitSOH`	valore decimale	.NET 5
Variabile di ambiente	`COMPlus_GCHeapHardLimitSOH`	valore esadecimale	.NET 5
Variabile di ambiente	`DOTNET_GCHeapHardLimitSOH`	valore esadecimale	.NET 6

	Nome impostazione	Valori	Versione introdotta
runtimeconfig.json	`System.GC.HeapHardLimitLOH`	valore decimale	.NET 5
Variabile di ambiente	`COMPlus_GCHeapHardLimitLOH`	valore esadecimale	.NET 5
Variabile di ambiente	`DOTNET_GCHeapHardLimitLOH`	valore esadecimale	.NET 6

	Nome impostazione	Valori	Versione introdotta
runtimeconfig.json	`System.GC.HeapHardLimitPOH`	valore decimale	.NET 5
Variabile di ambiente	`COMPlus_GCHeapHardLimitPOH`	valore esadecimale	.NET 5
Variabile di ambiente	`DOTNET_GCHeapHardLimitPOH`	valore esadecimale	.NET 6

Queste impostazioni di configurazione non hanno proprietà MSBuild specifiche. Tuttavia, è possibile aggiungere un elemento MSBuild RuntimeHostConfigurationOption in alternativa. Usare il nome dell'impostazione runtimeconfig.json come valore dell'attributo Include. Per un esempio, vedere Proprietà di MSBuild.

Suggerimento

Se si imposta l'opzione in runtimeconfig.json, specificare un valore decimale. Se si imposta l'opzione come variabile di ambiente, specificare un valore esadecimale. Ad esempio, per specificare un limite fisso dell'heap di 200 mebibyte (MiB), i valori saranno 209715200 per il file JSON e 0xC800000 o C800000 per la variabile di ambiente.

Percentuali limite rigido per oggetto-heap

È possibile specificare il limite rigido dell'heap di GC in base all'heap per oggetto. I diversi heap sono LOH (Large Object Heap), SOH (Small Object Heap) e POH (Pinned Object Heap).

Se si specifica un valore per una delle impostazioni DOTNET_GCHeapHardLimitSOHPercent, DOTNET_GCHeapHardLimitLOHPercent o DOTNET_GCHeapHardLimitPOHPercent, è necessario specificare anche un valore per DOTNET_GCHeapHardLimitSOHPercent e DOTNET_GCHeapHardLimitLOHPercent. In caso contrario, il runtime non verrà inizializzato.
Queste impostazioni vengono ignorate se si specifica DOTNET_GCHeapHardLimitSOH,DOTNET_GCHeapHardLimitLOH e DOTNET_GCHeapHardLimitPOH.
Il valore 1 indica che GC usa l'1% della memoria fisica totale per l'heap dell'oggetto.
Ogni valore deve essere maggiore di zero e minore o uguale a 100. Inoltre, la somma dei tre valori percentuali deve essere minore di 100. In caso contrario, il runtime non verrà inizializzato.

	Nome impostazione	Valori	Versione introdotta
runtimeconfig.json	`System.GC.HeapHardLimitSOHPercent`	valore decimale	.NET 5
Variabile di ambiente	`COMPlus_GCHeapHardLimitSOHPercent`	valore esadecimale	.NET 5
Variabile di ambiente	`DOTNET_GCHeapHardLimitSOHPercent`	valore esadecimale	.NET 6

	Nome impostazione	Valori	Versione introdotta
runtimeconfig.json	`System.GC.HeapHardLimitLOHPercent`	valore decimale	.NET 5
Variabile di ambiente	`COMPlus_GCHeapHardLimitLOHPercent`	valore esadecimale	.NET 5
Variabile di ambiente	`DOTNET_GCHeapHardLimitLOHPercent`	valore esadecimale	.NET 6

	Nome impostazione	Valori	Versione introdotta
runtimeconfig.json	`System.GC.HeapHardLimitPOHPercent`	valore decimale	.NET 5
Variabile di ambiente	`COMPlus_GCHeapHardLimitPOHPercent`	valore esadecimale	.NET 5
Variabile di ambiente	`DOTNET_GCHeapHardLimitPOHPercent`	valore esadecimale	.NET 6

Suggerimento

Se si imposta l'opzione in runtimeconfig.json, specificare un valore decimale. Se si imposta l'opzione come variabile di ambiente, specificare un valore esadecimale. Ad esempio, per limitare l'utilizzo dell'heap al 30%, i valori saranno 30 per il file JSON e 0x1E o 1E per la variabile di ambiente.

Memoria elevata in percentuale

Il carico di memoria è indicato dalla percentuale di memoria fisica in uso. Per impostazione predefinita, quando il carico di memoria fisica raggiunge il 90%, la Garbage Collection diventa più aggressiva per eseguire operazioni di Garbage Collection complete di compattazione per evitare il paging. Quando il carico di memoria è inferiore al 90%, GC favorisce le raccolte in background per le operazioni di Garbage Collection complete, che hanno pause più brevi, ma non riducono di molto le dimensioni totali dell'heap. Nei computer con una quantità significativa di memoria (80 GB o più), la soglia di carico predefinita è compresa tra il 90% e il 97%.

La soglia di carico elevato della memoria può essere modificata dalla variabile di ambienteDOTNET_GCHighMemPercent o con l'impostazione di configurazione JSONSystem.GC.HighMemoryPercent. Valutare la possibilità di regolare la soglia se si vogliono controllare le dimensioni dell'heap. Ad esempio, per il processo dominante in un computer con 64 GB di memoria, è ragionevole che GC inizi a reagire quando è disponibile il 10% della memoria. Per i processi più piccoli, ad esempio, uno che utilizza solo 1 GB di memoria, il processo di GC può essere eseguito comodamente con meno del 10% della memoria disponibile. Per questi processi più piccoli, è consigliabile impostare una soglia più alta. D'altra parte, se si vuole che processi più grandi abbiano dimensioni dell'heap più piccole (anche quando è disponibile molta memoria fisica), abbassare questa soglia è un modo efficace per fare in modo che GC reagisca prima per compattare l'heap.

Nota

Per i processi in esecuzione in un contenitore, GC considera la memoria fisica in base al limite del contenitore.

	Nome impostazione	Valori	Versione introdotta
runtimeconfig.json	`System.GC.HighMemoryPercent`	valore decimale	.NET 5
Variabile di ambiente	`COMPlus_GCHighMemPercent`	valore esadecimale	.NET Core 3.0 .NET Framework 4.7.2
Variabile di ambiente	`DOTNET_GCHighMemPercent`	valore esadecimale	.NET 6

Suggerimento

Se si imposta l'opzione in runtimeconfig.json, specificare un valore decimale. Se si imposta l'opzione come variabile di ambiente, specificare un valore esadecimale. Ad esempio, per impostare la soglia di memoria elevata sul 75%, i valori saranno 75 per il file JSON e 0x4B o 4B per la variabile di ambiente.

Mantenere la memoria virtuale

Questa impostazione consente di specificare se inserire i segmenti da eliminare in un elenco di standby per un uso futuro o rilasciarli nuovamente al sistema operativo (OS).
Impostazione predefinita: rilasciare i segmenti al sistema operativo. Equivale a impostare il valore su false.

	Nome impostazione	Valori	Versione introdotta
runtimeconfig.json	`System.GC.RetainVM`	`false` - rilasciare al sistema operativo `true` - mettere in standby	.NET Core 1.0
Proprietà MSBuild	`RetainVMGarbageCollection`	`false` - rilasciare al sistema operativo `true` - mettere in standby	.NET Core 1.0
Variabile di ambiente	`COMPlus_GCRetainVM`	`0` - rilasciare al sistema operativo `1` - mettere in standby	.NET Core 1.0
Variabile di ambiente	`DOTNET_GCRetainVM`	`0` - rilasciare al sistema operativo `1` - mettere in standby	.NET 6

Esempi

File runtimeconfig.json:

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

File runtimeconfig.template.json:

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

File di progetto:

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

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

</Project>

Pagine di grandi dimensioni

Specifica se devono essere utilizzate pagine di grandi dimensioni quando viene impostato un limite fisso dell'heap.
Impostazione predefinita: non usare pagine di grandi dimensioni quando viene impostato un limite fisso dell'heap. Equivale a impostare il valore su 0.
Si tratta di un'impostazione sperimentale.

	Nome impostazione	Valori	Versione introdotta
runtimeconfig.json	N/D	N/D	N/D
Variabile di ambiente	`COMPlus_GCLargePages`	`0`: disabilitata `1` - abilitato	.NET Core 3.0
Variabile di ambiente	`DOTNET_GCLargePages`	`0`: disabilitata `1` - abilitato	.NET 6

Consentire oggetti di grandi dimensioni

Questa impostazione consente di configurare il supporto di Garbage Collector su piattaforme a 64 bit per matrici con dimensioni totali superiori a 2 gigabyte (GB).
Impostazione predefinita: GC supporta matrici maggiori di 2 GB. Equivale a impostare il valore su 1.
Questa opzione potrebbe diventare obsoleta in una versione futura di .NET.

	Nome impostazione	Valori	Versione introdotta
runtimeconfig.json	N/D	N/D	N/D
Variabile di ambiente	`COMPlus_gcAllowVeryLargeObjects`	`1` - abilitata `0` - disabilitato	.NET Core 1.0
Variabile di ambiente	`DOTNET_gcAllowVeryLargeObjects`	`1` - abilitata `0` - disabilitato	.NET 6
app.config per .NET Framework	gcAllowVeryLargeObjects	`1` - abilitato `0` - disabilitato	.NET Framework 4.5

Soglia per l'heap degli oggetti grandi

Specifica le dimensioni di soglia, in byte, che determinano lo spostamento degli oggetti nell'heap degli oggetti grandi (LOH).
La soglia predefinita è 85.000 byte.
Il valore specificato deve essere maggiore della soglia predefinita.
Il valore potrebbe essere limitato dal runtime alla dimensione massima possibile per la configurazione corrente. È possibile esaminare il valore in uso in fase di esecuzione tramite l'API GC.GetConfigurationVariables().

	Nome impostazione	Valori	Versione introdotta
runtimeconfig.json	`System.GC.LOHThreshold`	valore decimale	.NET Core 1.0
Variabile di ambiente	`COMPlus_GCLOHThreshold`	valore esadecimale	.NET Core 1.0
Variabile di ambiente	`DOTNET_GCLOHThreshold`	valore esadecimale	.NET 6
app.config per .NET Framework	GCLOHThreshold	valore decimale	.NET Framework 4.8

Esempi

File runtimeconfig.json:

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

File runtimeconfig.template.json:

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

Suggerimento

Se si imposta l'opzione in runtimeconfig.json, specificare un valore decimale. Se si imposta l'opzione come variabile di ambiente, specificare un valore esadecimale. Ad esempio, per impostare una dimensione di soglia di 120.000 byte, i valori saranno 120000 per il file JSON e 0x1D4C0 o 1D4C0 per la variabile di ambiente.

GC autonomo

Per usare un Garbage Collector autonomo anziché l'implementazione GC predefinita, è possibile specificare il percorso (in .NET 9 e versioni successive) o il nome di una libreria nativa GC.

Percorso

Specifica il percorso completo di una libreria nativa GC caricata dal runtime al posto dell'implementazione GC predefinita. Per essere sicuro, questa posizione deve essere protetta da manomissioni potenzialmente dannose.

	Nome impostazione	Valori	Versione introdotta
runtimeconfig.json	`System.GC.Path`	string_path	.NET 9
Variabile di ambiente	`DOTNET_GCPath`	string_path	.NET 9

Nome

Specifica il nome di una libreria nativa GC caricata dal runtime al posto dell'implementazione GC predefinita. Il comportamento è cambiato in .NET 9 con l'introduzione della configurazione del percorso .

In .NET 8 e versioni precedenti:
- Se viene specificato solo un nome della libreria, la libreria deve trovarsi nella stessa directory del runtime .NET (coreclr.dll in Windows, libcoreclr.so in Linux o libcoreclr.dylib in OSX).
- Il valore può anche essere un percorso relativo, ad esempio se si specifica ".. \clrgc.dll" in Windows, clrgc.dll viene caricato dalla directory padre della directory di runtime .NET.
In .NET 9 e versioni successive questo valore specifica solo un nome file (i percorsi non sono consentiti):
- .NET cerca il nome specificato nella directory in cui risiede l'assembly che contiene il metodo dell'app Main .
- Se il file non viene trovato, viene eseguita la ricerca nella directory di runtime .NET.
Questa impostazione di configurazione viene ignorata se viene specificata la configurazione percorso .

	Nome impostazione	Valori	Versione introdotta
runtimeconfig.json	`System.GC.Name`	string_name	.NET 7
Variabile di ambiente	`COMPlus_GCName`	string_name	.NET Core 2.0
Variabile di ambiente	`DOTNET_GCName`	string_name	.NET 6

Conservare la memoria

Questa impostazione configura il Garbage Collector per risparmiare memoria a scapito di Garbage Collection più frequenti e tempi di sospensione possibilmente più lunghi.
Il valore predefinito è 0 e significa nessuna modifica.
Oltre al valore predefinito 0, sono validi i valori compresi tra 1 e 9 (inclusi). Maggiore è il valore, più il Garbage Collector cerca di risparmiare memoria e quindi di contenere le dimensioni dell'heap.
Se il valore è diverso da zero, l'heap degli oggetti grandi verrà compattato automaticamente in presenza di una frammentazione eccessiva.

	Nome impostazione	Valori	Versione introdotta
runtimeconfig.json	`System.GC.ConserveMemory`	`0` - `9`	.NET 6
Variabile di ambiente	`COMPlus_GCConserveMemory`	`0` -`9`	.NET Framework 4.8
Variabile di ambiente	`DOTNET_GCConserveMemory`	`0` -`9`	.NET 6
app.config per .NET Framework	GCConserveMemory	`0` -`9`	.NET Framework 4.8

Esempio di file app.config:


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

Suggerimento

Sperimentare con numeri diversi per individuare il valore ottimale. Iniziare con un valore compreso tra 5 e 7.

Adattamento dinamico alle dimensioni dell'applicazione (DATAS)

Configura il Garbage Collector per l'uso di DATAS. DATAS si adatta ai requisiti di memoria dell'applicazione, ovvero le dimensioni dell'heap dell'app devono essere approssimativamente proporzionali alle dimensioni dei dati di lunga durata.
Abilitato per impostazione predefinita a partire da .NET 9.

	Nome impostazione	Valori	Versione introdotta
Variabile di ambiente	`DOTNET_GCDynamicAdaptationMode`	`1` - abilitata `0` - disabilitata	.NET 8
Proprietà MSBuild	`GarbageCollectionAdaptationMode`	`1`: abilitata `0` - disabilitata	.NET 8
runtimeconfig.json	`System.GC.DynamicAdaptationMode`	`1` - abilitata `0` - disabilitata	.NET 8

Questa impostazione di configurazione non dispone di una proprietà MSBuild specifica. È tuttavia possibile aggiungere un elemento MSBuild RuntimeHostConfigurationOption in alternativa. Usare il nome dell'impostazione runtimeconfig.json come valore dell'attributo Include. Per un esempio, vedere Proprietà di MSBuild.

Condividi tramite

Opzioni di configurazione di runtime per Garbage Collection

Modi per specificare la configurazione

Tipi di Garbage Collection

Per workstation o server

Esempi

GC in background

Esempi

Gestire l'utilizzo delle risorse

Conteggio degli heap

Esempi

Maschera di affinità

Esempi

Intervalli di affinità

Esempi

Gruppi di CPU

Affinità

Esempi

Limite rigido dell'heap

Esempi

Percentuale limite rigido heap

Esempi

Limiti rigidi per oggetto-heap

Percentuali limite rigido per oggetto-heap

Memoria elevata in percentuale

Mantenere la memoria virtuale

Esempi

Pagine di grandi dimensioni

Consentire oggetti di grandi dimensioni

Soglia per l'heap degli oggetti grandi

Esempi

GC autonomo

Percorso

Nome

Conservare la memoria

Adattamento dinamico alle dimensioni dell'applicazione (DATAS)

Risorse aggiuntive