Opções de configuração do runtime para coleta de lixo
Esta página contém informações sobre as configurações do GC (coletor de lixo) do runtime do .NET. Se você estiver tentando alcançar desempenho máximo com 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 normalmente são usadas em conjunto umas com as outras para obter um resultado específico.
Observação
- Essas configurações são lidas somente pelo runtime quando a GC é inicializada (normalmente, 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 no tempo de execução, como o nível de latência, são omitidas dessa página.
- Como a GC é baseada em processos, raramente faz sentido definir essas configurações no nível do computador. Por exemplo, não é recomendável que todos os processos do .NET em um computador usem a GC do servidor ou o mesmo limite rígido de heap.
- No caso de valores numéricos, use a notação decimal para configurações no arquivo runtimeconfig.json ou runtimeconfig.template.json e a notação hexadecimal para configurações de variáveis de ambiente. Para valores hexadecimal, 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 uso do prefixo
DOTNET_em vez deCOMPlus_. No entanto, o prefixoCOMPlus_continuará funcionando. Se você estiver usando uma versão anterior do runtime do .NET, ainda deverá usar o prefixoCOMPlus_, por exemplo,COMPlus_gcServer.
Maneiras de especificar a configuração
Para outras versões do runtime do .NET, há maneiras diferentes de especificar os valores de configuração. A tabela a seguir mostra um resumo.
| Local da configuração | Versões do .NET a que este local se aplica | Formatos | Como ele é interpretado |
|---|---|---|---|
| Arquivo runtimeconfig.json file/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 |
| app.config file | .NET Framework | 0xn | n é interpretado como um valor hexadecimal1 |
1 Você pode especificar um valor sem o prefixo 0x para a configuração de um arquivo app.config, mas isso não é recomendado. No .NET Framework 4.8 (e versões posteriores), devido a um bug, um valor especificado sem o prefixo 0x é interpretado como hexadecimal, mas nas versões anteriores do .NET Framework, ele é interpretado como decimal. Para evitar a necessidade de alterar a configuração, use o prefixo 0x ao especificar um valor no arquivo app.config.
Por exemplo, a fim de especificar 12 heaps para GCHeapCount para um aplicativo do .NET Framework chamado A.exe, adicione o XML a seguir ao arquivo A.exe.config.
<?xml version="1.0" encoding="utf-8" ?>
<configuration>
...
<runtime>
<gcServer enabled="true"/>
<GCHeapCount>0xc</GCHeapCount>
</runtime>
</configuration>
Você pode usar variáveis de ambiente tanto no .NET (Core) quanto no .NET Framework.
No Windows, usando o .NET 6 ou uma versão posterior:
SET DOTNET_gcServer=1
SET DOTNET_GCHeapCount=c
No Windows, usando o .NET 5 ou versão 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 o .NET 5 e versões anteriores:
export COMPlus_gcServer=1
export COMPlus_GCHeapCount=c
Se não estiver usando o .NET Framework, também defina o valor no arquivo runtimeconfig.json ou runtimeconfig.template.json.
Arquivo runtimeconfig.json:
{
"runtimeOptions": {
"configProperties": {
"System.GC.Server": true,
"System.GC.HeapCount": 12
}
}
}
Arquivo runtimeconfig.template.json:
{
"configProperties": {
"System.GC.Server": true,
"System.GC.HeapCount": 12
}
}
Variantes de coleta de lixo
As duas principais variantes de coleta de lixo são o GC da estação de trabalho e o GC do servidor. Para obter mais informações sobre as diferenças entre os dois, confira Coleta de lixo da estação de trabalho e do servidor.
As subvariantes da coleta de lixo são o GC em segundo plano e o GC não simultâneo.
Use as seguintes configurações para selecionar as variantes de coleta de lixo:
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 é equivalente a definir o valor como
false.
| Nome da configuração | Valores | Versão introduzida | |
|---|---|---|---|
| runtimeconfig.json | System.GC.Server |
false – Estação de trabalhotrue – Servidor |
.NET Core 1.0 |
| Propriedade do MSBuild | ServerGarbageCollection |
false – Estação de trabalhotrue – Servidor |
.NET Core 1.0 |
| Variável de ambiente | COMPlus_gcServer |
0 – Estação de trabalho1 – Servidor |
.NET Core 1.0 |
| Variável de ambiente | DOTNET_gcServer |
0 – Estação de trabalho1 – Servidor |
.NET 6 |
| app.config para .NET Framework | GCServer | false – Estação de trabalhotrue – Servidor |
Exemplos
Arquivo runtimeconfig.json:
{
"runtimeOptions": {
"configProperties": {
"System.GC.Server": true
}
}
}
Arquivo runtimeconfig.template.json:
{
"configProperties": {
"System.GC.Server": true
}
}
Arquivo de projeto:
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<ServerGarbageCollection>true</ServerGarbageCollection>
</PropertyGroup>
</Project>
GC em segundo plano
- Configura se a coleta de lixo em segundo plano (simultânea) está habilitada.
- Padrão: usar o GC em segundo plano. Isso é equivalente a definir o valor como
true. - Para obter mais informações, confira Coleta de lixo em segundo plano.
| Nome da configuração | Valores | Versão introduzida | |
|---|---|---|---|
| runtimeconfig.json | System.GC.Concurrent |
true – GC em segundo planofalse – GC não simultâneo |
.NET Core 1.0 |
| Propriedade do MSBuild | ConcurrentGarbageCollection |
true – GC em segundo planofalse – GC não simultâneo |
.NET Core 1.0 |
| Variável de ambiente | COMPlus_gcConcurrent |
1 – GC em segundo plano0 – GC não simultâneo |
.NET Core 1.0 |
| Variável de ambiente | DOTNET_gcConcurrent |
1 – GC em segundo plano0 – GC não simultâneo |
.NET 6 |
| app.config para .NET Framework | gcConcurrent | true – GC em segundo planofalse – GC não simultâneo |
Exemplos
Arquivo runtimeconfig.json:
{
"runtimeOptions": {
"configProperties": {
"System.GC.Concurrent": false
}
}
}
Arquivo runtimeconfig.template.json:
{
"configProperties": {
"System.GC.Concurrent": false
}
}
Arquivo de projeto:
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<ConcurrentGarbageCollection>false</ConcurrentGarbageCollection>
</PropertyGroup>
</Project>
Gerenciar uso de recurso
Use as seguintes configurações para gerenciar a memória do coletor de lixo e o uso do processador:
- Criar afinidade
- Máscara de criar afinidade
- Intervalos de criar afinidade
- Grupos de CPU
- Contagem de heaps
- Limite de heap
- Percentual de limite de heap
- Alto percentual de memória
- Limites de heaps por objeto
- Percentuais limites de heaps por objeto
- Reter VM
Para obter mais informações sobre algumas dessas configurações, confira a entrada de blog Meio termo entre o GC da estação de trabalho e do servidor.
Contagem de heaps
- Limita o número de heaps criados pelo coletor de lixo.
- Aplica-se somente à coleta de lixo do servidor.
- Se a afinidade do processador de GC estiver habilitada, que é o padrão, a configuração de contagem de heaps criará afinidade de
nheaps/threads do GC com osnprimeiros processadores. (Use as configurações de máscara de criar afinidade ou intervalos de criar afinidade a fim de especificar exatamente para quais processadores criar afinidade.) - Se a afinidade do processador de GC estiver desabilitada, essa configuração limitará o número de heaps de GC.
- Para obter mais informações, confira Comentário sobre GCHeapCount.
| Nome da configuraçã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 |
Essa definição de configuração não tem uma propriedade específica do MSBuild. No entanto, você pode adicionar um item RuntimeHostConfigurationOption do MSBuild. Use o nome da configuração runtimeconfig.json como o valor do atributo Include. Para ver um exemplo, confira Propriedades do MSBuild.
Exemplos
Arquivo runtimeconfig.json:
{
"runtimeOptions": {
"configProperties": {
"System.GC.HeapCount": 16
}
}
}
Arquivo runtimeconfig.template.json:
{
"configProperties": {
"System.GC.HeapCount": 16
}
}
Dica
Se você estiver definindo a opção em 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 estabelecer o limite de 16 heaps, os valores a serem preenchidos seriam 16 no arquivo JSON e 0x10 ou 10 na variável de ambiente.
Máscara de criar afinidade
- Especifica os processadores exatos que os threads do coletor de lixo devem usar.
- Se a afinidade do processador de GC estiver desabilitada, essa configuração será ignorada.
- Aplica-se somente à 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, o valor 1023 em decimal (ou 0x3FF ou 3FF em hexadecimal, se você estiver usando a variável de ambiente) corresponde a 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 o valor 1047552 em decimal (ou 0xFFC00 ou FFC00, em hexadecimal), que corresponde ao valor binário 1111 1111 1100 0000 0000.
| Nome da configuraçã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 |
Essa definição de configuração não tem uma propriedade específica do MSBuild. No entanto, você pode adicionar um item RuntimeHostConfigurationOption do MSBuild. Use o nome da configuração runtimeconfig.json como o valor do atributo Include. Para ver um exemplo, confira Propriedades do MSBuild.
Exemplos
Arquivo runtimeconfig.json:
{
"runtimeOptions": {
"configProperties": {
"System.GC.HeapAffinitizeMask": 1023
}
}
}
Arquivo runtimeconfig.template.json:
{
"configProperties": {
"System.GC.HeapAffinitizeMask": 1023
}
}
Intervalos de criar afinidade
- Especifica a lista de processadores a serem usados para os threads do coletor de lixo.
- Essa configuração é semelhante a System.GC.HeapAffinitizeMask, exceto pelo fato de permitir que você especifique mais de 64 processadores.
- No caso de sistemas operacionais Windows, acrescente como prefixo o grupo de CPU correspondente, por exemplo, “0:1-10,0:12,1:50-52,1:7” ao número do processador ou ao intervalo. Se você realmente não tiver mais de um grupo de CPU, não poderá usar essa configuração. É necessário usar a configuração Criar afinidade de máscara. Além disso, os números especificados estão dentro desse grupo, o que significa que ele não pode ser >= 64.
- No caso de sistemas operacionais Linux, em que o conceito de grupo de CPU não existe, você pode usar essa configuração e a configuração Criar afinidade de máscara para especificar os mesmos intervalos. Em vez de “0:1-10”, especifique “1-10”, porque você não precisa especificar um índice de grupo.
- Se a afinidade do processador de GC estiver desabilitada, essa configuração será ignorada.
- Aplica-se somente à coleta de lixo do servidor.
- Para obter mais informações, confira Como melhorar a configuração da CPU para o GC em computadores com > 64 CPUs no blog da Maoni Stephens.
| Nome da configuração | Valores | Versão introduzida | |
|---|---|---|---|
| runtimeconfig.json | System.GC.HeapAffinitizeRanges |
Lista separada por vírgulas de números de processadores ou intervalos de números de processadores. Exemplo do 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 processadores ou intervalos de números de processadores. Exemplo do 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 processadores ou intervalos de números de processadores. Exemplo do Unix: "1-10,12,50-52,70" Exemplo do Windows: “0:1-10,0:12,1:50-52,1:7” |
.NET 6 |
Essa definição de configuração não tem uma propriedade específica do MSBuild. No entanto, você pode adicionar um item RuntimeHostConfigurationOption do MSBuild. Use o nome da configuração runtimeconfig.json como o valor do atributo Include. Para ver um exemplo, confira Propriedades do MSBuild.
Exemplos
Arquivo runtimeconfig.json:
{
"runtimeOptions": {
"configProperties": {
"System.GC.HeapAffinitizeRanges": "0:1-10,0:12,1:50-52,1:7"
}
}
}
Arquivo runtimeconfig.template.json:
{
"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, a permissão desse elemento estende a coleta de lixo para todos os grupos de CPU. O coletor de lixo usa todos os núcleos para criar e equilibrar heaps.
Observação
Esse é um conceito somente do Windows. Nas versões mais antigas do Windows, o Windows limitava um processo a um grupo de CPU. Assim, o GC usava 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 eliminada no Windows 11 e no Server 2022. Além disso, a partir do .NET 7, por padrão, o GC usa todos os grupos de CPU ao ser executado no Windows 11 ou no 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 a todos os grupos de CPU. Isso é equivalente a definir o valor como
0.Para obter mais informações, confira Como melhorar a configuração da CPU para o GC em computadores com > 64 CPUs no blog da Maoni Stephens.
| Nome da configuração | Valores | Versão introduzida | |
|---|---|---|---|
| runtimeconfig.json | System.GC.CpuGroup |
false -desabilitadotrue – Habilitado |
.NET 5 |
| Variável de ambiente | COMPlus_GCCpuGroup |
0 -desabilitado1 – Habilitado |
.NET Core 1.0 |
| Variável de ambiente | DOTNET_GCCpuGroup |
0 -desabilitado1 – Habilitado |
.NET 6 |
| app.config para .NET Framework | GCCpuGroup | false -desabilitadotrue – Habilitado |
Essa definição de configuração não tem uma propriedade específica do MSBuild. No entanto, você pode adicionar um item RuntimeHostConfigurationOption do MSBuild. Use o nome da configuração runtimeconfig.json como o valor do atributo Include. Para ver um exemplo, confira Propriedades do MSBuild.
Observação
Para configurar o CLR (Common Language Runtime) a fim de também distribuir threads do pool de threads para todos os grupos de CPU, habilite a opção do elemento Thread_UseAllCpuGroups. Para aplicativos do .NET Core, você pode habilitar essa opção definindo o valor da variável de ambiente DOTNET_Thread_UseAllCpuGroups como 1.
Criar afinidade
- Especifica se deve criar afinidade dos threads de coleta de lixo com os processadores. Criar afinidade com um thread do GC significa que ele só poderá ser executado em uma CPU específica. É criado um heap para cada thread do GC.
- Aplica-se somente à coleta de lixo do servidor.
- Padrão: criar afinidade dos threads de coleta de lixo com os processadores. Isso é equivalente a definir o valor como
false.
| Nome da configuração | Valores | Versão introduzida | |
|---|---|---|---|
| runtimeconfig.json | System.GC.NoAffinitize |
false – Criar afinidadetrue – Não criar afinidade |
.NET Core 3.0 |
| Variável de ambiente | COMPlus_GCNoAffinitize |
0 – Criar afinidade1 – Não criar afinidade |
.NET Core 3.0 |
| Variável de ambiente | DOTNET_GCNoAffinitize |
0 – Criar afinidade1 – Não criar afinidade |
.NET 6 |
| app.config para .NET Framework | GCNoAffinitize | false – Criar afinidadetrue – Não criar afinidade |
.NET Framework 4.6.2 |
Essa definição de configuração não tem uma propriedade específica do MSBuild. No entanto, você pode adicionar um item RuntimeHostConfigurationOption do MSBuild. Use o nome da configuração runtimeconfig.json como o valor do atributo Include. Para ver um exemplo, confira Propriedades do MSBuild.
Exemplos
Arquivo runtimeconfig.json:
{
"runtimeOptions": {
"configProperties": {
"System.GC.NoAffinitize": true
}
}
}
Arquivo runtimeconfig.template.json:
{
"configProperties": {
"System.GC.NoAffinitize": true
}
}
Limite de heap
Especifica o tamanho máximo de confirmação, em bytes, para o heap e a contabilidade do GC.
Essa configuração só se aplica a computadores de 64 bits.
Essa configuração será ignorada se os Limites de heaps por objeto estiverem configurados.
O valor padrão, que se aplica apenas em determinados casos, é o maior entre 20 MB ou 75% do limite de memória no contêiner. O valor padrão se aplica se:
- O processo está em execução dentro de um contêiner com limite de memória especificado.
- System.GC.HeapHardLimitPercent não está definido.
| Nome da configuraçã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 |
Essa definição de configuração não tem uma propriedade específica do MSBuild. No entanto, você pode adicionar um item RuntimeHostConfigurationOption do MSBuild. Use o nome da configuração runtimeconfig.json como o valor do atributo Include. Para ver um exemplo, confira Propriedades do MSBuild.
Exemplos
Arquivo runtimeconfig.json:
{
"runtimeOptions": {
"configProperties": {
"System.GC.HeapHardLimit": 209715200
}
}
}
Arquivo runtimeconfig.template.json:
{
"configProperties": {
"System.GC.HeapHardLimit": 209715200
}
}
Dica
Se você estiver definindo a opção em 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.
Percentual de limite de heap
Especifica o uso permitido de heap do GC como um percentual do total de memória física.
Se System.GC.HeapHardLimit também estiver definido, essa configuração será ignorada.
Essa configuração só se aplica a computadores de 64 bits.
Se o processo estiver em execução dentro de um contêiner que tenha um limite de memória especificado, o percentual será calculado como uma porção desse limite de memória.
Essa configuração será ignorada se os Limites de heaps por objeto estiverem configurados.
O valor padrão, que se aplica apenas em determinados casos, é o maior entre 20 MB ou 75% do limite de memória no contêiner. O valor padrão se aplica se:
- O processo está em execução dentro de um contêiner com limite de memória especificado.
- System.GC.HeapHardLimit não está definido.
| Nome da configuraçã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 |
Essa definição de configuração não tem uma propriedade específica do MSBuild. No entanto, você pode adicionar um item RuntimeHostConfigurationOption do MSBuild. Use o nome da configuração runtimeconfig.json como o valor do atributo Include. Para ver um exemplo, confira Propriedades do MSBuild.
Exemplos
Arquivo runtimeconfig.json:
{
"runtimeOptions": {
"configProperties": {
"System.GC.HeapHardLimitPercent": 30
}
}
}
Arquivo runtimeconfig.template.json:
{
"configProperties": {
"System.GC.HeapHardLimitPercent": 30
}
}
Dica
Se você estiver definindo a opção em 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 em 30%, os valores a serem preenchidos seriam 30 no arquivo JSON e 0x1E ou 1E na variável de ambiente.
Limites de heaps por objeto
Você pode especificar o uso permitido de heaps no GC com base no número de heaps por objeto. Os diferentes heaps existentes são o LOH (heap de objetos grandes), o SOH (heap de objetos pequenos) e o POH (heap de objetos fixados).
- Se especificar um valor para qualquer uma das configurações
DOTNET_GCHeapHardLimitSOH,DOTNET_GCHeapHardLimitLOHouDOTNET_GCHeapHardLimitPOH, você também deverá especificar um valor paraDOTNET_GCHeapHardLimitSOHeDOTNET_GCHeapHardLimitLOH. Se não o fizer, o runtime não será inicializado. - O valor padrão de
DOTNET_GCHeapHardLimitPOHé 0.DOTNET_GCHeapHardLimitSOHeDOTNET_GCHeapHardLimitLOHnão têm valores padrão.
| Nome da configuraçã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 configuraçã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 configuraçã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 item RuntimeHostConfigurationOption do MSBuild. Use o nome da configuração runtimeconfig.json como o valor do atributo Include. Para ver um exemplo, confira Propriedades do MSBuild.
Dica
Se você estiver definindo a opção em 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.
Percentuais limites de heaps por objeto
Você pode especificar o uso permitido de heaps no GC com base no número de heaps por objeto. Os diferentes heaps existentes são o LOH (heap de objetos grandes), o SOH (heap de objetos pequenos) e o POH (heap de objetos fixados).
- Se especificar um valor para qualquer uma das configurações
DOTNET_GCHeapHardLimitSOHPercent,DOTNET_GCHeapHardLimitLOHPercentouDOTNET_GCHeapHardLimitPOHPercent, você também deverá especificar um valor paraDOTNET_GCHeapHardLimitSOHPercenteDOTNET_GCHeapHardLimitLOHPercent. Se não o fizer, o runtime não será inicializado. - Essas configurações são ignoradas se
DOTNET_GCHeapHardLimitSOH,DOTNET_GCHeapHardLimitLOHeDOTNET_GCHeapHardLimitPOHsão especificados. - O valor 1 indica que o GC usa 1% da memória física total para esse heap de objeto.
- O valor deve ser maior que zero e menor que 100. Além disso, a soma dos três valores percentuais deve ser menor que 100. Caso contrário, o runtime não será inicializado.
| Nome da configuraçã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 configuraçã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 configuraçã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 |
Essas definições de configuração não têm propriedades específicas do MSBuild. No entanto, você pode adicionar um item RuntimeHostConfigurationOption do MSBuild. Use o nome da configuração runtimeconfig.json como o valor do atributo Include. Para ver um exemplo, confira Propriedades do MSBuild.
Dica
Se você estiver definindo a opção em 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 em 30%, os valores a serem preenchidos seriam 30 no arquivo JSON e 0x1E ou 1E na variável de ambiente.
Alto percentual de memória
A carga de memória é indicada pelo percentual 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 realizando coletas de lixo completas e compactadas para evitar a paginação. Quando a carga de memória está abaixo de 90%, ao realizar coletas de lixo completas o GC favorece as coletas em segundo plano, que têm pausas mais curtas, mas não reduzem muito o tamanho total do heap. Em computadores com uma quantidade significativa de memória (80 GB ou mais), o limite de carga padrão fica entre 90% e 97%.
O limite de carga de memória alta pode ser ajustado pela variável de ambiente DOTNET_GCHighMemPercent ou pela configuração JSON System.GC.HighMemoryPercent. Considere ajustar o limite se você quiser controlar o tamanho do heap. Por exemplo, para o processo dominante em um computador 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 1 GB de memória, o GC pode ser executado confortavelmente com menos de 10% de memória disponível. Para esses processos menores, considere definir um 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), a redução desse limite é uma forma eficaz de fazer com que o GC reaja mais cedo a fim de compactar o heap e diminuí-lo.
Observação
Para processos em execução em um contêiner, o GC considera a memória física com base nos limites do contêiner.
| Nome da configuraçã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 |
Essa definição de configuração não tem uma propriedade específica do MSBuild. No entanto, você pode adicionar um item RuntimeHostConfigurationOption do MSBuild. Use o nome da configuração runtimeconfig.json como o valor do atributo Include. Para ver um exemplo, confira Propriedades do MSBuild.
Dica
Se você estiver definindo a opção em 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 alto como 75%, os valores preenchidos seriam 75 no arquivo JSON e 0x4B ou 4B na 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 liberados de volta para o SO (sistema operacional).
- Padrão: liberar segmentos de volta para o sistema operacional. Isso é equivalente a definir o valor como
false.
| Nome da configuração | Valores | Versão introduzida | |
|---|---|---|---|
| runtimeconfig.json | System.GC.RetainVM |
false – Liberar para o SOtrue – Colocar em espera |
.NET Core 1.0 |
| Propriedade do MSBuild | RetainVMGarbageCollection |
false – Liberar para o SOtrue – Colocar em espera |
.NET Core 1.0 |
| Variável de ambiente | COMPlus_GCRetainVM |
0 – Liberar para o SO1 – Colocar em espera |
.NET Core 1.0 |
| Variável de ambiente | DOTNET_GCRetainVM |
0 – Liberar para o SO1 – Colocar em espera |
.NET 6 |
Exemplos
Arquivo runtimeconfig.json:
{
"runtimeOptions": {
"configProperties": {
"System.GC.RetainVM": true
}
}
}
Arquivo runtimeconfig.template.json:
{
"configProperties": {
"System.GC.RetainVM": true
}
}
Arquivo de 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 heap é definido.
- Padrão: não use páginas grandes quando um limite rígido de heap for definido. Isso é equivalente a definir o valor como
0. - Essa é uma configuração experimental.
| Nome da configuração | Valores | Versão introduzida | |
|---|---|---|---|
| runtimeconfig.json | N/D | N/D | N/D |
| Variável de ambiente | COMPlus_GCLargePages |
0 -desabilitado1 – Habilitado |
.NET Core 3.0 |
| Variável de ambiente | DOTNET_GCLargePages |
0 -desabilitado1 – Habilitado |
.NET 6 |
Permitir objetos grandes
- Configura o suporte ao coletor de lixo em plataformas de 64 bits para matrizes maiores que 2 GB (gigabytes) de tamanho.
- Padrão: o GC dá suporte a matrizes maiores que 2 GB. Isso é equivalente a definir o valor como
1. - Essa opção pode se tornar obsoleta em uma versão futura do .NET.
| Nome da configuração | Valores | Versão introduzida | |
|---|---|---|---|
| runtimeconfig.json | N/D | N/D | N/D |
| Variável de ambiente | COMPlus_gcAllowVeryLargeObjects |
1 – Habilitado0 -desabilitado |
.NET Core 1.0 |
| Variável de ambiente | DOTNET_gcAllowVeryLargeObjects |
1 – Habilitado0 -desabilitado |
.NET 6 |
| app.config para .NET Framework | gcAllowVeryLargeObjects | 1 – Habilitado0 -desabilitado |
.NET Framework 4.5 |
Limite de heap de objetos grandes
- Especifica o tamanho do limite, em bytes, que faz com que os objetos acessem o LOH (heap de objetos grandes).
- O limite padrão é de 85.000 bytes.
- O valor especificado deve ser maior 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 API GC.GetConfigurationVariables().
| Nome da configuraçã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 |
Essa definição de configuração não tem uma propriedade específica do MSBuild. No entanto, você pode adicionar um item RuntimeHostConfigurationOption do MSBuild. Use o nome da configuração runtimeconfig.json como o valor do atributo Include. Para ver um exemplo, confira Propriedades do MSBuild.
Exemplos
Arquivo runtimeconfig.json:
{
"runtimeOptions": {
"configProperties": {
"System.GC.LOHThreshold": 120000
}
}
}
Arquivo runtimeconfig.template.json:
{
"configProperties": {
"System.GC.LOHThreshold": 120000
}
}
Dica
Se você estiver definindo a opção em 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 preenchidos seriam 120.000 no arquivo JSON e 0x1D4C0 ou 1D4C0 na variável de ambiente.
GC autônomo
- Especifica o nome de uma biblioteca nativa do GC que o runtime carrega no lugar da implementação padrão do GC. Essa biblioteca nativa precisa residir no mesmo diretório que o runtime do .NET (coreclr.dll no Windows, libcoreclr.so no Linux).
| Nome da configuração | Valores | Versão introduzida | |
|---|---|---|---|
| runtimeconfig.json | N/D | N/D | N/D |
| Variável de ambiente | COMPlus_GCName |
string_path | .NET Core 2.0 |
| Variável de ambiente | DOTNET_GCName |
string_path | .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 não implica nenhuma alteração.
- Além do valor padrão 0, os 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, portanto, manter o heap pequeno.
- Se o valor for diferente de zero, o heap de objetos grandes será compactado automaticamente se tiver muita fragmentação.
| Nome da configuraçã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 |
Essa definição de configuração não tem uma propriedade específica do MSBuild. No entanto, você pode adicionar um item RuntimeHostConfigurationOption do MSBuild. Use o nome da configuração runtimeconfig.json como o valor do atributo Include. Para ver um exemplo, confira Propriedades do MSBuild.
Exemplo de arquivo app.config:
<configuration>
<runtime>
<GCConserveMemory enabled="5"/>
</runtime>
</configuration>
Dica
Experimente com diferentes números a fim de ver qual valor funciona melhor para você. Comece com um valor entre 5 e 7.
Comentários
Em breve: Ao longo de 2024, eliminaremos os problemas do GitHub como o mecanismo de comentários para conteúdo e o substituiremos por um novo sistema de comentários. Para obter mais informações, consulte https://aka.ms/ContentUserFeedback.
Enviar e exibir comentários de