Opções de configuração de tempo de execução para coleta de lixo

Artigo
05/21/2024

Esta página contém informações sobre configurações para o coletor de lixo (GC) de tempo de execução do .NET. Se você estiver tentando atingir o desempenho máximo de um aplicativo em execução, considere usar essas configurações. No entanto, os padrões fornecem um desempenho ideal para a maioria dos aplicativos em situações típicas.

As configurações são organizadas em grupos nesta página. As configurações dentro de cada grupo são comumente usadas em conjunto umas com as outras para alcançar um resultado específico.

Nota

Essas configurações só são lidas pelo tempo de execução quando o GC é inicializado (geralmente isso significa durante o tempo de inicialização do processo). Se você alterar uma variável de ambiente quando um processo já estiver em execução, a alteração não será refletida nesse processo. As configurações que podem ser alteradas por meio de APIs em tempo de execução, como o nível de latência, são omitidas desta página.
Como o GC é por processo, raramente faz sentido definir essas configurações no nível da máquina. Por exemplo, você não gostaria que todos os processos .NET em uma máquina usassem o GC do servidor ou o mesmo limite rígido de heap.
Para valores numéricos, use notação decimal para configurações no arquivo runtimeconfig.json ou runtimeconfig.template.json e notação hexadecimal para configurações de variáveis de ambiente. Para valores hexadecimais, você pode especificá-los com ou sem o prefixo "0x".
Se você estiver usando as variáveis de ambiente, o .NET 6 e versões posteriores padronizarão no prefixo DOTNET_ em vez de COMPlus_. No entanto, o prefixo COMPlus_ continuará a funcionar. Se você estiver usando uma versão anterior do tempo de execução do .NET, ainda deverá usar o prefixo COMPlus_ , por exemplo, COMPlus_gcServer.

Maneiras de especificar a configuração

Para diferentes versões do tempo de execução do .NET, há diferentes maneiras de especificar os valores de configuração. A tabela a seguir mostra um resumo.

Local de configuração	Versões do .NET às quais esse local se aplica	Formatos	Como é interpretado
runtimeconfig.json arquivo/ arquivo runtimeconfig.template.json	.NET (Core)	n	n é interpretado como um valor decimal.
Variável de ambiente	.NET Framework, .NET (Core)	0xn ou n	n é interpretado como um valor hexadecimal em qualquer formato
arquivo app.config	.NET Framework	0xn	n é interpretado como um valor^{hexadecimal 1}

1 Você pode especificar um valor sem o prefixo 0x para uma configuração de arquivo app.config, mas isso não é recomendado. No .NET Framework 4.8+, devido a um bug, um valor especificado sem o prefixo 0x é interpretado como hexadecimal, mas em versões anteriores do .NET Framework, ele é interpretado como decimal. Para evitar ter que alterar sua configuração, use o prefixo 0x ao especificar um valor em seu arquivo app.config.

Por exemplo, para especificar 12 heaps para GCHeapCount um aplicativo .NET Framework chamado A.exe, adicione o seguinte XML ao arquivo A.exe.config .

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

Para .NET (Core) e .NET Framework, você pode usar variáveis de ambiente.

No Windows usando o .NET 6 ou uma versão posterior:

SET DOTNET_gcServer=1
SET DOTNET_GCHeapCount=c

No Windows usando .NET 5 ou anterior:

SET COMPlus_gcServer=1
SET COMPlus_GCHeapCount=c

Em outros sistemas operacionais:

Para .NET 6 ou versões posteriores:

export DOTNET_gcServer=1
export DOTNET_GCHeapCount=c

Para .NET 5 e versões anteriores:

export COMPlus_gcServer=1
export COMPlus_GCHeapCount=c

Se você não estiver usando o .NET Framework, também poderá definir o valor no arquivo runtimeconfig.json ou runtimeconfig.template.json .

runtimeconfig.json ficheiro:

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

runtimeconfig.template.json arquivo:

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

Sabores da coleta de lixo

Os dois principais sabores de coleta de lixo são GC estação de trabalho e GC servidor. Para obter mais informações sobre as diferenças entre os dois, consulte Estação de trabalho e coleta de lixo do servidor.

Os subsabores da coleta de lixo são de fundo e não concorrentes.

Use as seguintes configurações para selecionar os tipos de coleta de lixo:

GC da estação de trabalho versus servidor
GC de fundo

Estação de trabalho vs. servidor

Configura se o aplicativo usa a coleta de lixo da estação de trabalho ou a coleta de lixo do servidor.
Padrão: coleta de lixo da estação de trabalho. Isso equivale a definir o valor como false.

	Nome da definição	Valores	Versão introduzida
runtimeconfig.json	`System.GC.Server`	`false` - estação de trabalho `true` - servidor	.NET Core 1.0
Propriedade MSBuild	`ServerGarbageCollection`	`false` - estação de trabalho `true` - servidor	.NET Core 1.0
Variável de ambiente	`COMPlus_gcServer`	`0` - estação de trabalho `1` - servidor	.NET Core 1.0
Variável de ambiente	`DOTNET_gcServer`	`0` - estação de trabalho `1` - servidor	.NET 6
app.config para .NET Framework	GCServer	`false` - estação de trabalho `true` - servidor

Exemplos

runtimeconfig.json ficheiro:

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

runtimeconfig.template.json arquivo:

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

Ficheiro do projeto:

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

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

</Project>

GC de fundo

Configura se a coleta de lixo em segundo plano (simultânea) está habilitada.
Padrão: Use GC em segundo plano. Isso equivale a definir o valor como true.
Para obter mais informações, consulte Coleta de lixo em segundo plano.

	Nome da definição	Valores	Versão introduzida
runtimeconfig.json	`System.GC.Concurrent`	`true` - GC de fundo `false` - GC não concorrente	.NET Core 1.0
Propriedade MSBuild	`ConcurrentGarbageCollection`	`true` - GC de fundo `false` - GC não concorrente	.NET Core 1.0
Variável de ambiente	`COMPlus_gcConcurrent`	`1` - GC de fundo `0` - GC não concorrente	.NET Core 1.0
Variável de ambiente	`DOTNET_gcConcurrent`	`1` - GC de fundo `0` - GC não concorrente	.NET 6
app.config para .NET Framework	gcSimultâneo	`true` - GC de fundo `false` - GC não concorrente

Exemplos

runtimeconfig.json ficheiro:

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

runtimeconfig.template.json arquivo:

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

Ficheiro do projeto:

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

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

</Project>

Gerenciar o uso de recursos

Use as seguintes configurações para gerenciar a memória do coletor de lixo e o uso do processador:

Afinitizar
Máscara Affinitize
Gamas de afinitização
Grupos de CPU
Contagem de pilha
Limite de pilha
Percentagem de limite de heap
Alta porcentagem de memória
Limites por heap de objeto
Percentagens de limite por heap de objeto
Reter VM

Para obter mais informações sobre algumas dessas configurações, consulte a entrada de blog Meio termo entre a estação de trabalho e o servidor GC .

Contagem de pilha

Limita o número de pilhas criadas pelo coletor de lixo.
Aplica-se apenas à coleta de lixo do servidor.
Se a afinidade do processador GC estiver habilitada, que é o padrão, a configuração de contagem de heap afiliará n heaps/threads GC aos primeiros n processadores. (Use as configurações affinitize mask ou affinitize ranges para especificar exatamente quais processadores afinitizar.)
Se a afinidade do processador GC estiver desativada, essa configuração limitará o número de heaps GC.
Para obter mais informações, consulte as observações do GCHeapCount.

	Nome da definição	Valores	Versão introduzida
runtimeconfig.json	`System.GC.HeapCount`	valor decimal	.NET Core 3.0
Variável de ambiente	`COMPlus_GCHeapCount`	valor hexadecimal	.NET Core 3.0
Variável de ambiente	`DOTNET_GCHeapCount`	valor hexadecimal	.NET 6
app.config para .NET Framework	GCHeapCount	valor decimal	.NET Framework 4.6.2

Esta definição de configuração não tem uma propriedade MSBuild específica. No entanto, você pode adicionar um RuntimeHostConfigurationOption item MSBuild em vez disso. Use o nome da configuração runtimeconfig.json como o valor do Include atributo. Para obter um exemplo, consulte Propriedades do MSBuild.

Exemplos

runtimeconfig.json ficheiro:

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

runtimeconfig.template.json arquivo:

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

Gorjeta

Se você estiver definindo a opção no runtimeconfig.json, especifique um valor decimal. Se você estiver definindo a opção como uma variável de ambiente, especifique um valor hexadecimal. Por exemplo, para limitar o número de heaps a 16, os valores seriam 16 para o arquivo JSON e 0x10 ou 10 para a variável de ambiente.

Máscara Affinitize

Especifica os processadores exatos que os threads do coletor de lixo devem usar.
Se a afinidade do processador GC estiver desativada, essa configuração será ignorada.
Aplica-se apenas à coleta de lixo do servidor.
O valor é uma máscara de bits que define os processadores que estão disponíveis para o processo. Por exemplo, um valor decimal de 1023 (ou um valor hexadecimal de 0x3FF ou 3FF se você estiver usando a variável de ambiente) é 0011 1111 1111 em notação binária. Isso especifica que os primeiros 10 processadores devem ser usados. Para especificar os próximos 10 processadores, ou seja, processadores 10-19, especifique um valor decimal de 1047552 (ou um valor hexadecimal de 0xFFC00 ou FFC00), que é equivalente a um valor binário de 1111 1111 1100 0000 0000.

	Nome da definição	Valores	Versão introduzida
runtimeconfig.json	`System.GC.HeapAffinitizeMask`	valor decimal	.NET Core 3.0
Variável de ambiente	`COMPlus_GCHeapAffinitizeMask`	valor hexadecimal	.NET Core 3.0
Variável de ambiente	`DOTNET_GCHeapAffinitizeMask`	valor hexadecimal	.NET 6
app.config para .NET Framework	GCHeapAffinitizeMask	valor decimal	.NET Framework 4.6.2

Exemplos

runtimeconfig.json ficheiro:

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

runtimeconfig.template.json arquivo:

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

Gamas de afinitização

Especifica a lista de processadores a serem usados para threads de coletor de lixo.
Essa configuração é semelhante a System.GC.HeapAffinitizeMask, exceto que permite especificar mais de 64 processadores.
Para sistemas operacionais Windows, prefixe o número ou intervalo do processador com o grupo de CPU correspondente, por exemplo, "0:1-10,0:12,1:50-52,1:7". Se você não tiver mais de 1 grupo de CPU, não poderá usar essa configuração. Você deve usar a configuração de máscara Affinitize. E os números especificados estão dentro desse grupo, o que significa que não pode ser >= 64.
Para sistemas operacionais Linux, onde o conceito de grupo de CPU não existe, você pode usar essa configuração e a configuração de máscara Affinitize para especificar os mesmos intervalos. E em vez de "0:1-10", especifique "1-10" porque você não precisa especificar um índice de grupo.
Se a afinidade do processador GC estiver desativada, essa configuração será ignorada.
Aplica-se apenas à coleta de lixo do servidor.
Para obter mais informações, consulte Tornando a configuração da CPU melhor para GC em máquinas com > 64 CPUs no blog de Maoni Stephens.

	Nome da definição	Valores	Versão introduzida
runtimeconfig.json	`System.GC.HeapAffinitizeRanges`	Lista separada por vírgulas de números de processador ou intervalos de números de processador. Exemplo Unix: "1-10,12,50-52,70" Exemplo do Windows: "0:1-10,0:12,1:50-52,1:7"	.NET Core 3.0
Variável de ambiente	`COMPlus_GCHeapAffinitizeRanges`	Lista separada por vírgulas de números de processador ou intervalos de números de processador. Exemplo Unix: "1-10,12,50-52,70" Exemplo do Windows: "0:1-10,0:12,1:50-52,1:7"	.NET Core 3.0
Variável de ambiente	`DOTNET_GCHeapAffinitizeRanges`	Lista separada por vírgulas de números de processador ou intervalos de números de processador. Exemplo Unix: "1-10,12,50-52,70" Exemplo do Windows: "0:1-10,0:12,1:50-52,1:7"	.NET 6

Exemplos

runtimeconfig.json ficheiro:

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

runtimeconfig.template.json arquivo:

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

Grupos de CPU

Configura se o coletor de lixo usa grupos de CPU ou não.

Quando um computador Windows de 64 bits tem vários grupos de CPU, ou seja, há mais de 64 processadores, habilitar esse elemento estende a coleta de lixo em todos os grupos de CPU. O coletor de lixo usa todos os núcleos para criar e equilibrar pilhas.

Nota

Este é um conceito apenas para Windows. Em versões mais antigas do Windows, o Windows limitava um processo a um grupo de CPU. Assim, o GC usou apenas um grupo de CPU, a menos que você tenha usado essa configuração para habilitar vários grupos de CPU. Essa limitação do sistema operacional foi suspensa no Windows 11 e no Server 2022. Além disso, a partir do .NET 7, o GC por padrão usa todos os grupos de CPU quando executado no Windows 11 ou Server 2022.
Aplica-se à coleta de lixo do servidor somente em sistemas operacionais Windows de 64 bits.
Padrão: o GC não se estende entre grupos de CPU. Isso equivale a definir o valor como 0.
Para obter mais informações, consulte Tornando a configuração da CPU melhor para GC em máquinas com > 64 CPUs no blog de Maoni Stephens.

	Nome da definição	Valores	Versão introduzida
runtimeconfig.json	`System.GC.CpuGroup`	`false` - deficientes `true` - ativado	.NET 5
Variável de ambiente	`COMPlus_GCCpuGroup`	`0` - deficientes `1` - ativado	.NET Core 1.0
Variável de ambiente	`DOTNET_GCCpuGroup`	`0` - deficientes `1` - ativado	.NET 6
app.config para .NET Framework	GCCpuGroup	`false` - deficientes `true` - ativado

Nota

Para configurar o Common Language Runtime (CLR) para também distribuir threads do pool de threads em todos os grupos de CPU, habilite a opção Thread_UseAllCpuGroups elemento . Para aplicativos .NET Core, você pode habilitar essa opção definindo o DOTNET_Thread_UseAllCpuGroups valor da variável de ambiente como 1.

Afinitizar

Especifica se os threads de coleta de lixo devem ser afinizados com processadores. Para afinitizar um thread GC significa que ele só pode ser executado em sua CPU específica. Uma pilha é criada para cada thread GC.
Aplica-se apenas à coleta de lixo do servidor.
Padrão: affinitize threads de coleta de lixo com processadores. Isso equivale a definir o valor como false.

	Nome da definição	Valores	Versão introduzida
runtimeconfig.json	`System.GC.NoAffinitize`	`false` - afinitizar `true` - não afinar	.NET Core 3.0
Variável de ambiente	`COMPlus_GCNoAffinitize`	`0` - afinitizar `1` - não afinar	.NET Core 3.0
Variável de ambiente	`DOTNET_GCNoAffinitize`	`0` - afinitizar `1` - não afinar	.NET 6
app.config para .NET Framework	GCNoAffinitize	`false` - afinitizar `true` - não afinar	.NET Framework 4.6.2

Exemplos

runtimeconfig.json ficheiro:

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

runtimeconfig.template.json arquivo:

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

Limite de pilha

Especifica o tamanho máximo de confirmação, em bytes, para o heap GC e a contabilidade GC.
Esta definição aplica-se apenas a computadores de 64 bits.
Essa configuração será ignorada se os limites de heap por objeto estiverem configurados.
O valor padrão, que só se aplica em certos casos, é o maior de 20 MB ou 75% do limite de memória no contêiner. O valor padrão se aplica se:
- O processo está sendo executado dentro de um contêiner que tem um limite de memória especificado.
- System.GC.HeapHardLimitPercent não está definido.

	Nome da definição	Valores	Versão introduzida
runtimeconfig.json	`System.GC.HeapHardLimit`	valor decimal	.NET Core 3.0
Variável de ambiente	`COMPlus_GCHeapHardLimit`	valor hexadecimal	.NET Core 3.0
Variável de ambiente	`DOTNET_GCHeapHardLimit`	valor hexadecimal	.NET 6

Exemplos

runtimeconfig.json ficheiro:

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

runtimeconfig.template.json arquivo:

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

Gorjeta

Se você estiver definindo a opção no runtimeconfig.json, especifique um valor decimal. Se você estiver definindo a opção como uma variável de ambiente, especifique um valor hexadecimal. Por exemplo, para especificar um limite rígido de heap de 200 mebibytes (MiB), os valores seriam 209715200 para o arquivo JSON e 0xC800000 ou C800000 para a variável de ambiente.

Percentagem de limite de heap

Especifica o uso permitido de heap GC como uma porcentagem da memória física total.
Se System.GC.HeapHardLimit também estiver definido, essa configuração será ignorada.
Esta definição aplica-se apenas a computadores de 64 bits.
Se o processo estiver sendo executado dentro de um contêiner que tenha um limite de memória especificado, a porcentagem será calculada como uma porcentagem desse limite de memória.
Essa configuração será ignorada se os limites de heap por objeto estiverem configurados.
O valor padrão, que só se aplica em certos casos, é o maior de 20 MB ou 75% do limite de memória no contêiner. O valor padrão se aplica se:
- O processo está sendo executado dentro de um contêiner que tem um limite de memória especificado.
- System.GC.HeapHardLimit não está definido.

	Nome da definição	Valores	Versão introduzida
runtimeconfig.json	`System.GC.HeapHardLimitPercent`	valor decimal	.NET Core 3.0
Variável de ambiente	`COMPlus_GCHeapHardLimitPercent`	valor hexadecimal	.NET Core 3.0
Variável de ambiente	`DOTNET_GCHeapHardLimitPercent`	valor hexadecimal	.NET 6

Exemplos

runtimeconfig.json ficheiro:

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

runtimeconfig.template.json arquivo:

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

Gorjeta

Se você estiver definindo a opção no runtimeconfig.json, especifique um valor decimal. Se você estiver definindo a opção como uma variável de ambiente, especifique um valor hexadecimal. Por exemplo, para limitar o uso de heap a 30%, os valores seriam 30 para o arquivo JSON e 0x1E ou 1E para a variável de ambiente.

Limites por heap de objeto

Você pode especificar o uso de heap permitido do GC em uma base por heap de objeto. As diferentes pilhas são a pilha de objeto grande (LOH), a pilha de objeto pequeno (SOH) e a pilha de objeto fixo (POH).

Se você especificar um valor para qualquer uma das DOTNET_GCHeapHardLimitSOHconfigurações , DOTNET_GCHeapHardLimitLOH, ou DOTNET_GCHeapHardLimitPOH , também deverá especificar um valor para DOTNET_GCHeapHardLimitSOH e DOTNET_GCHeapHardLimitLOH. Se você não fizer isso, o tempo de execução falhará ao inicializar.
O valor padrão para DOTNET_GCHeapHardLimitPOH é 0. DOTNET_GCHeapHardLimitSOH e DOTNET_GCHeapHardLimitLOH não têm valores padrão.

	Nome da definição	Valores	Versão introduzida
runtimeconfig.json	`System.GC.HeapHardLimitSOH`	valor decimal	.NET 5
Variável de ambiente	`COMPlus_GCHeapHardLimitSOH`	valor hexadecimal	.NET 5
Variável de ambiente	`DOTNET_GCHeapHardLimitSOH`	valor hexadecimal	.NET 6

	Nome da definição	Valores	Versão introduzida
runtimeconfig.json	`System.GC.HeapHardLimitLOH`	valor decimal	.NET 5
Variável de ambiente	`COMPlus_GCHeapHardLimitLOH`	valor hexadecimal	.NET 5
Variável de ambiente	`DOTNET_GCHeapHardLimitLOH`	valor hexadecimal	.NET 6

	Nome da definição	Valores	Versão introduzida
runtimeconfig.json	`System.GC.HeapHardLimitPOH`	valor decimal	.NET 5
Variável de ambiente	`COMPlus_GCHeapHardLimitPOH`	valor hexadecimal	.NET 5
Variável de ambiente	`DOTNET_GCHeapHardLimitPOH`	valor hexadecimal	.NET 6

Essas definições de configuração não têm propriedades específicas do MSBuild. No entanto, você pode adicionar um RuntimeHostConfigurationOption item MSBuild em vez disso. Use o nome da configuração runtimeconfig.json como o valor do Include atributo. Para obter um exemplo, consulte Propriedades do MSBuild.

Gorjeta

Se você estiver definindo a opção no runtimeconfig.json, especifique um valor decimal. Se você estiver definindo a opção como uma variável de ambiente, especifique um valor hexadecimal. Por exemplo, para especificar um limite rígido de heap de 200 mebibytes (MiB), os valores seriam 209715200 para o arquivo JSON e 0xC800000 ou C800000 para a variável de ambiente.

Percentagens de limite por heap de objeto

Se você especificar um valor para qualquer uma das DOTNET_GCHeapHardLimitSOHPercentconfigurações , DOTNET_GCHeapHardLimitLOHPercent, ou DOTNET_GCHeapHardLimitPOHPercent , também deverá especificar um valor para DOTNET_GCHeapHardLimitSOHPercent e DOTNET_GCHeapHardLimitLOHPercent. Se você não fizer isso, o tempo de execução falhará ao inicializar.
Essas configurações são ignoradas se DOTNET_GCHeapHardLimitSOH, DOTNET_GCHeapHardLimitLOHe DOTNET_GCHeapHardLimitPOH são especificadas.
Um valor de 1 significa que GC usa 1% da memória física total para esse heap de objeto.
Cada valor deve ser maior que zero e menor que 100. Além disso, a soma dos três valores percentuais deve ser inferior a 100. Caso contrário, o tempo de execução falhará ao inicializar.

	Nome da definição	Valores	Versão introduzida
runtimeconfig.json	`System.GC.HeapHardLimitSOHPercent`	valor decimal	.NET 5
Variável de ambiente	`COMPlus_GCHeapHardLimitSOHPercent`	valor hexadecimal	.NET 5
Variável de ambiente	`DOTNET_GCHeapHardLimitSOHPercent`	valor hexadecimal	.NET 6

	Nome da definição	Valores	Versão introduzida
runtimeconfig.json	`System.GC.HeapHardLimitLOHPercent`	valor decimal	.NET 5
Variável de ambiente	`COMPlus_GCHeapHardLimitLOHPercent`	valor hexadecimal	.NET 5
Variável de ambiente	`DOTNET_GCHeapHardLimitLOHPercent`	valor hexadecimal	.NET 6

	Nome da definição	Valores	Versão introduzida
runtimeconfig.json	`System.GC.HeapHardLimitPOHPercent`	valor decimal	.NET 5
Variável de ambiente	`COMPlus_GCHeapHardLimitPOHPercent`	valor hexadecimal	.NET 5
Variável de ambiente	`DOTNET_GCHeapHardLimitPOHPercent`	valor hexadecimal	.NET 6

Gorjeta

Se você estiver definindo a opção no runtimeconfig.json, especifique um valor decimal. Se você estiver definindo a opção como uma variável de ambiente, especifique um valor hexadecimal. Por exemplo, para limitar o uso de heap a 30%, os valores seriam 30 para o arquivo JSON e 0x1E ou 1E para a variável de ambiente.

Alta porcentagem de memória

A carga de memória é indicada pela percentagem de memória física em uso. Por padrão, quando a carga de memória física atinge 90%, a coleta de lixo se torna mais agressiva ao fazer coletas de lixo completas e compactadas para evitar a paginação. Quando a carga de memória está abaixo de 90%, o GC favorece as coletas em segundo plano para coletas de lixo completas, que têm pausas mais curtas, mas não reduzem muito o tamanho total da pilha. Em máquinas com uma quantidade significativa de memória (80GB ou mais), o limite de carga padrão está entre 90% e 97%.

O limite de alta carga de memória pode ser ajustado pela variável de ambiente ou System.GC.HighMemoryPercent pela definição de DOTNET_GCHighMemPercent configuração JSON. Considere ajustar o limite se quiser controlar o tamanho da pilha. Por exemplo, para o processo dominante em uma máquina com 64 GB de memória, é razoável que o GC comece a reagir quando há 10% de memória disponível. Mas para processos menores, por exemplo, um processo que consome apenas 1GB de memória, o GC pode ser executado confortavelmente com menos de 10% da memória disponível. Para esses processos menores, considere definir o limite mais alto. Por outro lado, se você quiser que processos maiores tenham tamanhos de heap menores (mesmo quando há muita memória física disponível), reduzir esse limite é uma maneira eficaz de o GC reagir mais cedo para compactar o heap para baixo.

Nota

Para processos executados em um contêiner, o GC considera a memória física com base no limite do contêiner.

	Nome da definição	Valores	Versão introduzida
runtimeconfig.json	`System.GC.HighMemoryPercent`	valor decimal	.NET 5
Variável de ambiente	`COMPlus_GCHighMemPercent`	valor hexadecimal	.NET Core 3.0 .NET Framework 4.7.2
Variável de ambiente	`DOTNET_GCHighMemPercent`	valor hexadecimal	.NET 6

Gorjeta

Se você estiver definindo a opção no runtimeconfig.json, especifique um valor decimal. Se você estiver definindo a opção como uma variável de ambiente, especifique um valor hexadecimal. Por exemplo, para definir o limite de memória alta para 75%, os valores seriam 75 para o arquivo JSON e 0x4B ou 4B para a variável de ambiente.

Reter VM

Configura se os segmentos que devem ser excluídos são colocados em uma lista de espera para uso futuro ou são liberados de volta para o sistema operacional (SO).
Padrão: Liberar segmentos de volta para o sistema operacional. Isso equivale a definir o valor como false.

	Nome da definição	Valores	Versão introduzida
runtimeconfig.json	`System.GC.RetainVM`	`false` - lançamento para SO `true` - colocar em standby	.NET Core 1.0
Propriedade MSBuild	`RetainVMGarbageCollection`	`false` - lançamento para SO `true` - colocar em standby	.NET Core 1.0
Variável de ambiente	`COMPlus_GCRetainVM`	`0` - lançamento para SO `1` - colocar em standby	.NET Core 1.0
Variável de ambiente	`DOTNET_GCRetainVM`	`0` - lançamento para SO `1` - colocar em standby	.NET 6

Exemplos

runtimeconfig.json ficheiro:

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

runtimeconfig.template.json arquivo:

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

Ficheiro do projeto:

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

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

</Project>

Páginas grandes

Especifica se páginas grandes devem ser usadas quando um limite rígido de pilha é definido.
Padrão: não use páginas grandes quando um limite rígido de pilha estiver definido. Isso equivale a definir o valor como 0.
Este é um cenário experimental.

	Nome da definição	Valores	Versão introduzida
runtimeconfig.json	N/A	N/D	N/A
Variável de ambiente	`COMPlus_GCLargePages`	`0` - deficientes `1` - ativado	.NET Core 3.0
Variável de ambiente	`DOTNET_GCLargePages`	`0` - deficientes `1` - ativado	.NET 6

Permitir objetos grandes

Configura o suporte ao coletor de lixo em plataformas de 64 bits para matrizes com mais de 2 gigabytes (GB) de tamanho total.
Padrão: GC suporta matrizes maiores que 2 GB. Isso equivale a definir o valor como 1.
Esta opção pode tornar-se obsoleta numa versão futura do .NET.

	Nome da definição	Valores	Versão introduzida
runtimeconfig.json	N/A	N/D	N/A
Variável de ambiente	`COMPlus_gcAllowVeryLargeObjects`	`1` - ativado `0` - deficientes	.NET Core 1.0
Variável de ambiente	`DOTNET_gcAllowVeryLargeObjects`	`1` - ativado `0` - deficientes	.NET 6
app.config para .NET Framework	gcAllowVeryLargeObjects	`1` - ativado `0` - deficientes	.NET Framework 4.5

Limite de heap de objeto grande

Especifica o tamanho do limite, em bytes, que faz com que os objetos fiquem no heap de objeto grande (LOH).
O limite padrão é de 85.000 bytes.
O valor especificado deve ser maior do que o limite padrão.
O valor pode ser limitado pelo tempo de execução ao tamanho máximo possível para a configuração atual. Você pode inspecionar o valor em uso em tempo de execução por meio da GC.GetConfigurationVariables() API.

	Nome da definição	Valores	Versão introduzida
runtimeconfig.json	`System.GC.LOHThreshold`	valor decimal	.NET Core 1.0
Variável de ambiente	`COMPlus_GCLOHThreshold`	valor hexadecimal	.NET Core 1.0
Variável de ambiente	`DOTNET_GCLOHThreshold`	valor hexadecimal	.NET 6
app.config para .NET Framework	GCLOHThreshold	valor decimal	.NET Framework 4.8

Exemplos

runtimeconfig.json ficheiro:

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

runtimeconfig.template.json arquivo:

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

Gorjeta

Se você estiver definindo a opção no runtimeconfig.json, especifique um valor decimal. Se você estiver definindo a opção como uma variável de ambiente, especifique um valor hexadecimal. Por exemplo, para definir um tamanho limite de 120.000 bytes, os valores seriam 120000 para o arquivo JSON e 0x1D4C0 ou 1D4C0 para a variável de ambiente.

GC independente

Para usar um coletor de lixo autônomo em vez da implementação padrão do GC, você pode especificar o caminho (no .NET 9 e versões posteriores) ou o nome de uma biblioteca nativa do GC.

Especifica o caminho completo de uma biblioteca nativa do GC que o tempo de execução carrega no lugar da implementação padrão do GC. Para ser seguro, este local deve ser protegido contra adulterações potencialmente maliciosas.

	Nome da definição	Valores	Versão introduzida
runtimeconfig.json	`System.GC.Path`	string_name	.NET 9
Variável de ambiente	`DOTNET_GCPath`	string_path	.NET 9

Especifica o nome de uma biblioteca nativa do GC que o tempo de execução carrega no lugar da implementação padrão do GC. Essa biblioteca nativa precisa residir no mesmo diretório que o assembly que contém o método do Main seu aplicativo. Se o módulo nativo não for encontrado lá, ele deverá residir no mesmo diretório que o tempo de execução do .NET (coreclr.dll no Windows, libcoreclr.so no Linux ou libcoreclr.dylib no OSX).
Esta definição de configuração será ignorada se DOTNET_GCPath for especificada.

	Nome da definição	Valores	Versão introduzida
runtimeconfig.json	`System.GC.Name`	string_name	.NET 7
Variável de ambiente	`COMPlus_GCName`	string_name	.NET Core 2.0
Variável de ambiente	`DOTNET_GCName`	string_name	.NET 6

Conservar memória

Configura o coletor de lixo para conservar a memória às custas de coletas de lixo mais frequentes e, possivelmente, tempos de pausa mais longos.
O valor padrão é 0 - isso implica nenhuma alteração.
Além do valor padrão 0, valores entre 1 e 9 (inclusive) são válidos. Quanto maior o valor, mais o coletor de lixo tenta conservar a memória e, assim, manter a pilha pequena.
Se o valor for diferente de zero, a pilha de objeto grande será compactada automaticamente se tiver muita fragmentação.

	Nome da definição	Valores	Versão introduzida
runtimeconfig.json	`System.GC.ConserveMemory`	`0` - `9`	.NET 6
Variável de ambiente	`COMPlus_GCConserveMemory`	`0` -`9`	.NET Framework 4.8
Variável de ambiente	`DOTNET_GCConserveMemory`	`0` -`9`	.NET 6
app.config para .NET Framework	GCConserveMemory	`0` -`9`	.NET Framework 4.8

Exemplo de arquivo app.config :


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

Gorjeta

Experimente números diferentes para ver qual valor funciona melhor para você. Comece com um valor entre 5 e 7.

Partilhar via

Opções de configuração de tempo de execução para coleta de lixo

Maneiras de especificar a configuração

Sabores da coleta de lixo

Estação de trabalho vs. servidor

Exemplos

GC de fundo

Exemplos

Gerenciar o uso de recursos

Contagem de pilha

Exemplos

Máscara Affinitize

Exemplos

Gamas de afinitização

Exemplos

Grupos de CPU

Afinitizar

Exemplos

Limite de pilha

Exemplos

Percentagem de limite de heap

Exemplos

Limites por heap de objeto

Percentagens de limite por heap de objeto

Alta porcentagem de memória

Reter VM

Exemplos

Páginas grandes

Permitir objetos grandes

Limite de heap de objeto grande

Exemplos

GC independente

Conservar memória

Comentários

Recursos adicionais