Runtimeconfiguratieopties voor garbagecollection

Deze pagina bevat informatie over instellingen voor de .NET Runtime garbage collector (GC). Als u probeert piekprestaties van een actieve app te bereiken, kunt u overwegen deze instellingen te gebruiken. De standaardinstellingen bieden echter optimale prestaties voor de meeste toepassingen in typische situaties.

Instellingen zijn gerangschikt in groepen op deze pagina. De instellingen binnen elke groep worden vaak gebruikt in combinatie met elkaar om een specifiek resultaat te bereiken.

Manieren om de configuratie op te geven

Voor verschillende versies van de .NET-runtime zijn er verschillende manieren om de configuratiewaarden op te geven. In de volgende tabel ziet u een samenvatting.

¹ U kunt een waarde opgeven zonder het 0x voorvoegsel voor een app.config-bestandsinstelling, maar dit wordt niet aanbevolen. In .NET Framework 4.8+, vanwege een fout, wordt een waarde die zonder voorvoegsel 0x is opgegeven, geïnterpreteerd als hexadecimaal, maar in eerdere versies van .NET Framework wordt deze geïnterpreteerd als decimaal. Gebruik het voorvoegsel bij het 0x opgeven van een waarde in uw app.config-bestand om te voorkomen dat u de configuratie hoeft te wijzigen.

Als u bijvoorbeeld 12 heaps wilt opgeven voor GCHeapCount een .NET Framework-app met de naam A.exe, voegt u de volgende XML toe aan het bestand A.exe.config .

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

Voor zowel .NET (Core) als .NET Framework kunt u omgevingsvariabelen gebruiken.

In Windows met .NET 6 of een latere versie:

SET DOTNET_gcServer=1
SET DOTNET_GCHeapCount=c

In Windows met .NET 5 of eerder:

SET COMPlus_gcServer=1
SET COMPlus_GCHeapCount=c

Op andere besturingssystemen:

Voor .NET 6 of nieuwere versies:

export DOTNET_gcServer=1
export DOTNET_GCHeapCount=c

Voor .NET 5 en eerdere versies:

export COMPlus_gcServer=1
export COMPlus_GCHeapCount=c

Als u .NET Framework niet gebruikt, kunt u ook de waarde instellen in het bestand runtimeconfig.json of runtimeconfig.template.json .

runtimeconfig.json bestand:

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

runtimeconfig.template.json bestand:

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

Smaken van garbagecollection

De twee belangrijkste smaken van garbagecollection zijn werkstation GC en server GC. Zie Werkstation en server garbagecollection voor meer informatie over verschillen tussen de twee.

De subflavors van garbagecollection zijn achtergrond en niet-gelijktijdig.

Gebruik de volgende instellingen om smaken van garbagecollection te selecteren:

• Werkstation versus server GC
• Achtergrond GC

Werkstation versus server

• Hiermee configureert u of de toepassing gebruikmaakt van garbagecollection voor werkstations of de garbagecollection van de server.
• Standaard: Garbagecollection van werkstation. Dit komt overeen met het instellen van de waarde op false.

Voorbeelden

runtimeconfig.json bestand:

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

runtimeconfig.template.json bestand:

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

Projectbestand:

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

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

</Project>

Achtergrond GC

• Hiermee configureert u of de achtergrond (gelijktijdige) garbagecollection is ingeschakeld.
• Standaard: gebruik achtergrond-GC. Dit komt overeen met het instellen van de waarde op true.
• Zie Achtergrond garbagecollection voor meer informatie.

Voorbeelden

runtimeconfig.json bestand:

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

runtimeconfig.template.json bestand:

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

Projectbestand:

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

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

</Project>

Zelfstandige GC

Als u een zelfstandige garbagecollector wilt gebruiken in plaats van de standaard GC-implementatie, kunt u het pad (in .NET 9 en latere versies) of de naam van een systeemeigen GC-bibliotheek opgeven.

Pad

• Hiermee geeft u het volledige pad van een systeemeigen GC-bibliotheek op die door de runtime wordt geladen in plaats van de standaard GC-implementatie. Om veilig te zijn, moet deze locatie worden beschermd tegen mogelijk schadelijke manipulatie.

Naam

• Hiermee geeft u de naam op van een systeemeigen GC-bibliotheek die door de runtime wordt geladen in plaats van de standaard-GC-implementatie. Het gedrag is gewijzigd in .NET 9 met de introductie van de padconfiguratie .

  In .NET 8 en vorige versies:

  • Als alleen een naam van de bibliotheek is opgegeven, moet de bibliotheek zich in dezelfde map bevinden als de .NET-runtime (coreclr.dll in Windows, libcoreclr.so op Linux of libcoreclr.dylib in OSX).
  • De waarde kan ook een relatief pad zijn, bijvoorbeeld als u '.. \clrgc.dll" in Windows wordt clrgc.dll geladen vanuit de bovenliggende map van de .NET Runtime-directory.

  In .NET 9 en latere versies geeft deze waarde alleen een bestandsnaam op (paden zijn niet toegestaan):

  • .NET zoekt naar de naam die u opgeeft in de map waarin de assembly die de methode van Main uw app bevat zich bevindt.
  • Als het bestand niet wordt gevonden, wordt de .NET-runtimemap doorzocht.

• Deze configuratie-instelling wordt genegeerd als de padconfiguratie is opgegeven.

Specifieke instellingen van LOH

Zeer grote objecten toestaan

• Hiermee configureert u ondersteuning voor garbagecollection op 64-bits platforms voor matrices die groter zijn dan 2 GIGABYTE (GB) in totale grootte.
• Standaard: GC ondersteunt matrices die groter zijn dan 2 GB. Dit komt overeen met het instellen van de waarde op 1.
• Deze optie kan verouderd raken in een toekomstige versie van .NET.

Drempelwaarde voor grote object-heap

• Hiermee geeft u de drempelwaardegrootte in bytes op die ervoor zorgt dat objecten op de grote object heap (LOH) gaan.
• De standaarddrempelwaarde is 85.000 bytes.
• De waarde die u opgeeft, moet groter zijn dan de standaarddrempelwaarde.
• De waarde kan worden beperkt door de runtime tot de maximale grootte voor de huidige configuratie. U kunt de waarde die tijdens runtime wordt gebruikt controleren via de GC.GetConfigurationVariables() API.

Deze configuratie-instelling heeft geen specifieke MSBuild-eigenschap. U kunt echter in plaats daarvan een RuntimeHostConfigurationOption MSBuild-item toevoegen. Gebruik de naam van de instelling runtimeconfig.json als de waarde van het Include kenmerk. Zie MSBuild-eigenschappen voor een voorbeeld.

Voorbeelden

runtimeconfig.json bestand:

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

runtimeconfig.template.json bestand:

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

Resourcegebruik beheren voor alle GC-smaken

De volgende instellingen zijn van toepassing op alle smaken van de GC:

• Harde limiet voor heap
• Heap harde limietpercentage
• Harde limieten per object-heap
• Harde limieten per object-heap
• Grote pagina's
• Regiobereik
• Regiogrootte
• Hoog geheugenpercentage
• VM behouden
• Geheugen besparen

Harde limiet voor heap

• De heap harde limiet wordt gedefinieerd als de maximale doorvoergrootte, in bytes, voor de GC-heap en GC-boekhouding.
• Deze instelling is alleen van toepassing op 64-bits computers.
• Als deze limiet niet is geconfigureerd, maar het proces wordt uitgevoerd in een omgeving met geheugenbeperking, wordt in een container met een opgegeven geheugenlimiet een standaardwaarde ingesteld. Deze standaardwaarde is groter dan 20 MB of 75% van de geheugenlimiet voor de container.
• Deze instelling wordt genegeerd als de vaste limieten per object-heap zijn geconfigureerd.

Deze configuratie-instelling heeft geen specifieke MSBuild-eigenschap. U kunt echter in plaats daarvan een RuntimeHostConfigurationOption MSBuild-item toevoegen. Gebruik de naam van de instelling runtimeconfig.json als de waarde van het Include kenmerk. Zie MSBuild-eigenschappen voor een voorbeeld.

Voorbeelden

runtimeconfig.json bestand:

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

runtimeconfig.template.json bestand:

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

Heap harde limietpercentage

• Hiermee geeft u de heap harde limiet op als percentage van het totale fysieke geheugen. Als het proces wordt uitgevoerd in een omgeving met geheugenbeperking, dat wil gezegd, binnen een container met een opgegeven geheugenlimiet, is het totale fysieke geheugen de geheugenlimiet; anders is het wat er beschikbaar is op de computer.
• Deze instelling is alleen van toepassing op 64-bits computers.
• Deze instelling wordt genegeerd als de harde limieten per object-heap zijn geconfigureerd of als de heap-harde limiet is geconfigureerd.

Deze configuratie-instelling heeft geen specifieke MSBuild-eigenschap. U kunt echter in plaats daarvan een RuntimeHostConfigurationOption MSBuild-item toevoegen. Gebruik de naam van de instelling runtimeconfig.json als de waarde van het Include kenmerk. Zie MSBuild-eigenschappen voor een voorbeeld.

Voorbeelden

runtimeconfig.json bestand:

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

runtimeconfig.template.json bestand:

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

Harde limieten per object-heap

U kunt de heap-limiet van de GC opgeven op basis van een heap per object. De verschillende heaps zijn de grote object heap (LOH), kleine object heap (SOH) en vastgemaakte object heap (POH).

• Als u een waarde opgeeft voor een van de DOTNET_GCHeapHardLimitSOH, DOTNET_GCHeapHardLimitLOHof DOTNET_GCHeapHardLimitPOH instellingen, moet u ook een waarde opgeven voor DOTNET_GCHeapHardLimitSOH en DOTNET_GCHeapHardLimitLOH. Als u dit niet doet, kan de runtime niet worden geïnitialiseerd.
• De standaardwaarde voor DOTNET_GCHeapHardLimitPOH is 0. DOTNET_GCHeapHardLimitSOH en DOTNET_GCHeapHardLimitLOH geen standaardwaarden hebben.

Deze configuratie-instellingen hebben geen specifieke MSBuild-eigenschappen. U kunt echter in plaats daarvan een RuntimeHostConfigurationOption MSBuild-item toevoegen. Gebruik de naam van de instelling runtimeconfig.json als de waarde van het Include kenmerk. Zie MSBuild-eigenschappen voor een voorbeeld.

Harde limieten per object-heap

U kunt de heap-limiet van de GC opgeven op basis van een heap per object. De verschillende heaps zijn de grote object heap (LOH), kleine object heap (SOH) en vastgemaakte object heap (POH).

• Als u een waarde opgeeft voor een van de DOTNET_GCHeapHardLimitSOHPercent, DOTNET_GCHeapHardLimitLOHPercentof DOTNET_GCHeapHardLimitPOHPercent instellingen, moet u ook een waarde opgeven voor DOTNET_GCHeapHardLimitSOHPercent en DOTNET_GCHeapHardLimitLOHPercent. Als u dit niet doet, kan de runtime niet worden geïnitialiseerd.
• Deze instellingen worden genegeerd als DOTNET_GCHeapHardLimitSOH, DOTNET_GCHeapHardLimitLOHen DOTNET_GCHeapHardLimitPOH worden opgegeven.
• Een waarde van 1 betekent dat GC 1% van het totale fysieke geheugen voor dat object heap gebruikt.
• Elke waarde moet groter zijn dan nul en kleiner dan 100. Daarnaast moet de som van de drie percentagewaarden kleiner zijn dan 100. Anders kan de runtime niet worden geïnitialiseerd.

Deze configuratie-instellingen hebben geen specifieke MSBuild-eigenschappen. U kunt echter in plaats daarvan een RuntimeHostConfigurationOption MSBuild-item toevoegen. Gebruik de naam van de instelling runtimeconfig.json als de waarde van het Include kenmerk. Zie MSBuild-eigenschappen voor een voorbeeld.

Grote pagina's

• Hiermee geeft u op of grote pagina's moeten worden gebruikt wanneer een heap harde limiet is ingesteld.
• Standaard: gebruik geen grote pagina's wanneer een heap harde limiet is ingesteld. Dit komt overeen met het instellen van de waarde op 0.
• Dit is een experimentele instelling.

Regiobereik

Vanaf .NET 7 heeft de GC-heap de fysieke weergave gewijzigd van segmenten naar regio's voor 64-bits Windows en Linux. (Zie het blogartikel van Maoni Stephens voor meer informatie.) Met deze wijziging reserveert de GC een bereik van virtueel geheugen tijdens de initialisatie. Houd er rekening mee dat dit alleen geheugen reserveert, niet doorvoert (de grootte van de GC-heap is toegewezen geheugen). Het is slechts een bereik om het maximale bereik te definiëren dat de GC-heap kan doorvoeren. De meeste toepassingen hoeven niet zo veel doorvoeren.

Als u geen andere configuraties hebt en niet wordt uitgevoerd in een omgeving met geheugenbeperkingen (waardoor sommige GC-configuraties worden ingesteld), is standaard 256 GB gereserveerd. Als er meer dan 256 GB fysiek geheugen beschikbaar is, is dit twee keer zo groot.

Als de vaste limieten per heap worden ingesteld, is het reservebereik gelijk aan de totale vaste limiet. Als één vaste limietconfiguratie is ingesteld, is dit bereik vijf keer zo groot.

Dit bereik wordt beperkt door de hoeveelheid virtueel geheugen. Normaal gesproken op de 64-bits is dit nooit een probleem, maar er kan een virtuele geheugenlimiet zijn ingesteld voor een proces. Dit bereik is beperkt tot de helft van dat bedrag. Als u de HeapHardLimit configuratie bijvoorbeeld instelt op 1 GB en een limiet van 4 GB voor virtueel geheugen hebt ingesteld voor het proces, is min (5x1GB, 4GB/2)dit bereik , namelijk 2 GB.

U kunt de GC.GetConfigurationVariables() API gebruiken om de waarde van dit bereik onder de naam GCRegionRangete zien. Als u tijdens de initialisatie van de runtime krijgt E_OUTOFMEMORY en wilt zien of dit bereik moet worden hersteld, bekijkt u de VirtualAlloc aanroep in MEM_RESERVE Windows of de aanroep met mmap Linux, tijdens de PROT_NONE initialisatie van GC en kijkt u of de OOM afkomstig is van die aanroep. Als deze reserve-aanroep mislukt, kunt u deze wijzigen via de volgende configuratie-instellingen. De aanbeveling voor het reserveringsbedrag is twee tot vijf keer de vastgelegde grootte voor uw GC-heap. Als uw scenario niet veel grote toewijzingen maakt (dit kunnen eventuele toewijzingen zijn op UOH of groter dan de grootte van de UOH-regio), moet twee keer de vastgelegde grootte veilig zijn. Anders wilt u deze groter maken, zodat u geen te frequente volledig comprimerende GCs krijgt om ruimte te maken voor deze grotere regio's. Als u de vastgelegde grootte van uw GC-heap niet weet, kunt u dit twee keer instellen op de hoeveelheid fysiek geheugen die beschikbaar is voor uw proces.

Deze configuratie-instelling heeft geen specifieke MSBuild-eigenschap. U kunt echter in plaats daarvan een RuntimeHostConfigurationOption MSBuild-item toevoegen. Gebruik de naam van de instelling runtimeconfig.json als de waarde van het Include kenmerk. Zie MSBuild-eigenschappen voor een voorbeeld.

Regiogrootte

Vanaf .NET 7 heeft de GC-heap de fysieke weergave gewijzigd van segmenten naar regio's voor 64-bits Windows en Linux. (Zie het blogartikel van Maoni Stephens voor meer informatie.) Standaard is elke regio 4 MB voor SOH. Voor UOH (LOH en POH) is het acht keer de grootte van de SOH-regio. U kunt deze configuratie gebruiken om de grootte van de SOH-regio te wijzigen en de UOH-regio's worden dienovereenkomstig aangepast.

Regio's worden alleen toegewezen wanneer dat nodig is, dus in het algemeen hoeft u zich geen zorgen te maken over de regiogrootte. Er zijn echter twee gevallen waarin u deze grootte mogelijk wilt aanpassen:

• Voor processen die zeer kleine GC-heaps hebben, is het wijzigen van de regiogrootte in kleinere staat gunstig voor systeemeigen geheugengebruik van de eigen boekhouding van GC. De aanbeveling is 1 MB.
• Als u in Linux het aantal geheugentoewijzingen wilt verminderen, kunt u de regiogrootte wijzigen in groter, bijvoorbeeld 32 MB.

Deze configuratie-instelling heeft geen specifieke MSBuild-eigenschap. U kunt echter in plaats daarvan een RuntimeHostConfigurationOption MSBuild-item toevoegen. Gebruik de naam van de instelling runtimeconfig.json als de waarde van het Include kenmerk. Zie MSBuild-eigenschappen voor een voorbeeld.

Hoog geheugenpercentage

Geheugenbelasting wordt aangegeven door het percentage van het fysieke geheugen dat wordt gebruikt. Wanneer de fysieke geheugenbelasting 90% bereikt, wordt garbagecollection standaard agressiever over het uitvoeren van volledige, comprimeren van garbagecollection's om paginering te voorkomen. Wanneer de geheugenbelasting lager is dan 90%, geeft GC de voorkeur aan achtergrondverzamelingen voor volledige garbagecollecties, die kortere pauzes hebben, maar de totale heapgrootte niet veel verminderen. Op computers met een aanzienlijke hoeveelheid geheugen (80 GB of meer) is de standaardbelastingsdrempel tussen 90% en 97%.

De drempelwaarde voor hoge geheugenbelasting kan worden aangepast door de DOTNET_GCHighMemPercent omgevingsvariabele of System.GC.HighMemoryPercent JSON-configuratie-instelling. Overweeg de drempelwaarde aan te passen als u de heapgrootte wilt beheren. Voor het dominante proces op een machine met 64 GB geheugen is het bijvoorbeeld redelijk dat GC reageert wanneer er 10% van het geheugen beschikbaar is. Maar voor kleinere processen, bijvoorbeeld een proces dat slechts 1 GB geheugen verbruikt, kan GC comfortabel worden uitgevoerd met minder dan 10% van het beschikbare geheugen. Voor deze kleinere processen kunt u overwegen om de drempelwaarde hoger in te stellen. Als u echter wilt dat grotere processen kleinere heapgrootten hebben (zelfs wanneer er voldoende fysiek geheugen beschikbaar is), is het verlagen van deze drempelwaarde een effectieve manier om GC sneller te laten reageren om de heap te comprimeren.

Deze configuratie-instelling heeft geen specifieke MSBuild-eigenschap. U kunt echter in plaats daarvan een RuntimeHostConfigurationOption MSBuild-item toevoegen. Gebruik de naam van de instelling runtimeconfig.json als de waarde van het Include kenmerk. Zie MSBuild-eigenschappen voor een voorbeeld.

VM behouden

• Hiermee configureert u of segmenten die moeten worden verwijderd, worden geplaatst op een stand-bylijst voor toekomstig gebruik of worden vrijgegeven aan het besturingssysteem (OS).
• Standaard: Releasesegmenten terug naar het besturingssysteem. Dit komt overeen met het instellen van de waarde op false.

Voorbeelden

runtimeconfig.json bestand:

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

runtimeconfig.template.json bestand:

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

Projectbestand:

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

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

</Project>

Geheugen besparen

• Hiermee configureert u de garbagecollector om geheugen te besparen ten koste van frequentere garbageverzamelingen en mogelijk langere onderbrekingstijden.
• De standaardwaarde is 0. Dit impliceert geen wijziging.
• Naast de standaardwaarde 0 zijn waarden tussen 1 en 9 (inclusief) geldig. Hoe hoger de waarde, hoe meer de garbagecollector probeert geheugen te besparen en zo de heap klein te houden.
• Als de waarde niet nul is, wordt de grote object-heap automatisch gecomprimeerd als deze te veel fragmentatie heeft.

Deze configuratie-instelling heeft geen specifieke MSBuild-eigenschap. U kunt echter in plaats daarvan een RuntimeHostConfigurationOption MSBuild-item toevoegen. Gebruik de naam van de instelling runtimeconfig.json als de waarde van het Include kenmerk. Zie MSBuild-eigenschappen voor een voorbeeld.

Voorbeeld van app.config-bestand :

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

Resourcegebruik voor Server GC beheren

De volgende instellingen zijn van invloed op het aantal Server GC-threads en of/hoe ze zijn geaffineerd naar kernen. Ze hebben geen effect op Werkstation GC.

• Heap count
• Affiniteit
• Affiniteitsmasker
• Affiniteitsbereiken
• CPU-groepen
• GEGEVENS

Zie de middle ground between workstation and server GC blog entry voor meer informatie over de eerste 3 instellingen.

Heap count

• Beperkt het aantal heaps dat door de garbagecollector is gemaakt.
• Alleen van toepassing op de garbagecollection van de server.
• Als GC-processoraffiniteit is ingeschakeld, wat de standaardinstelling is, n worden GC-heaps/threads ingesteld op de eerste n processors. (Gebruik de instellingen voor affiniteitsmasker of affiniteitsbereiken om precies op te geven welke processors moeten worden geaffineerd.)
• Als GC-processoraffiniteit is uitgeschakeld, beperkt deze instelling het aantal GC-heaps.
• Zie de opmerkingen van GCHeapCount voor meer informatie.

Deze configuratie-instelling heeft geen specifieke MSBuild-eigenschap. U kunt echter in plaats daarvan een RuntimeHostConfigurationOption MSBuild-item toevoegen. Gebruik de naam van de instelling runtimeconfig.json als de waarde van het Include kenmerk. Zie MSBuild-eigenschappen voor een voorbeeld.

Voorbeelden

runtimeconfig.json bestand:

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

runtimeconfig.template.json bestand:

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

Affiniteit

• Hiermee geeft u op of u threads voor garbagecollection wilt affinitiseren met processors. Als u een GC-thread wilt affinitiseren, betekent dit dat deze alleen kan worden uitgevoerd op de specifieke CPU. Er wordt een heap gemaakt voor elke GC-thread.
• Alleen van toepassing op de garbagecollection van de server.
• Standaard: Affiniteit met threads voor garbagecollection met processors. Dit komt overeen met het instellen van de waarde op false.

Deze configuratie-instelling heeft geen specifieke MSBuild-eigenschap. U kunt echter in plaats daarvan een RuntimeHostConfigurationOption MSBuild-item toevoegen. Gebruik de naam van de instelling runtimeconfig.json als de waarde van het Include kenmerk. Zie MSBuild-eigenschappen voor een voorbeeld.

Voorbeelden

runtimeconfig.json bestand:

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

runtimeconfig.template.json bestand:

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

Affiniteitsmasker

• Hiermee geeft u de exacte processors die garbagecollection threads moeten gebruiken.
• Als GC-processoraffiniteit is uitgeschakeld, wordt deze instelling genegeerd.
• Alleen van toepassing op de garbagecollection van de server.
• De waarde is een bitmasker dat de processors definieert die beschikbaar zijn voor het proces. Een decimale waarde van 1023 (of een hexadecimale waarde van 0x3FF of 3FF als u de omgevingsvariabele gebruikt) is bijvoorbeeld 0011 1111 1111 in binaire notatie. Hiermee geeft u op dat de eerste 10 processors moeten worden gebruikt. Als u de volgende 10 processors wilt opgeven, dat wil gezegd: processors 10-19, geeft u een decimale waarde van 1047552 (of een hexadecimale waarde van 0xFFC00 of FFC00), die gelijk is aan een binaire waarde van 1111 1111 1100 0000 0000.

Deze configuratie-instelling heeft geen specifieke MSBuild-eigenschap. U kunt echter in plaats daarvan een RuntimeHostConfigurationOption MSBuild-item toevoegen. Gebruik de naam van de instelling runtimeconfig.json als de waarde van het Include kenmerk. Zie MSBuild-eigenschappen voor een voorbeeld.

Voorbeelden

runtimeconfig.json bestand:

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

runtimeconfig.template.json bestand:

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

Affiniteitsbereiken

• Hiermee geeft u de lijst met processors te gebruiken voor garbagecollection threads.
• Deze instelling is vergelijkbaar met System.GC.HeapAffinitizeMask, behalve dat u meer dan 64 processors kunt opgeven.
• Voor Windows-besturingssystemen moet u het processornummer of bereik vooraf laten gaan aan de bijbehorende CPU-groep, bijvoorbeeld '0:1-10,0:12,1:50-52,1:7'. Als u niet meer dan 1 CPU-groep hebt, kunt u deze instelling niet gebruiken. U moet de instelling Affinitize-masker gebruiken. En de getallen die u opgeeft, bevinden zich binnen die groep, wat betekent dat het niet = 64 kan zijn >.
• Voor Linux-besturingssystemen, waarbij het concept van de CPU-groep niet bestaat, kunt u deze instelling en de instelling Affinitize-masker gebruiken om dezelfde bereiken op te geven. En in plaats van '0:1-10' geeft u '1-10' op omdat u geen groepsindex hoeft op te geven.
• Als GC-processoraffiniteit is uitgeschakeld, wordt deze instelling genegeerd.
• Alleen van toepassing op de garbagecollection van de server.
• Zie Cpu-configuratie verbeteren voor GC op machines met > 64 CPU's op de blog van Maoni Stephens voor meer informatie.

Deze configuratie-instelling heeft geen specifieke MSBuild-eigenschap. U kunt echter in plaats daarvan een RuntimeHostConfigurationOption MSBuild-item toevoegen. Gebruik de naam van de instelling runtimeconfig.json als de waarde van het Include kenmerk. Zie MSBuild-eigenschappen voor een voorbeeld.

Voorbeelden

runtimeconfig.json bestand:

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

runtimeconfig.template.json bestand:

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

CPU-groepen

• Hiermee configureert u of de garbagecollector CPU-groepen gebruikt of niet.

  Wanneer een 64-bits Windows-computer meerdere CPU-groepen heeft, zijn er meer dan 64 processors, waardoor dit element de garbagecollection voor alle CPU-groepen uitbreidt. De garbagecollector gebruikt alle kernen om heaps te maken en te verdelen.

  Notitie

  Dit is een windows-only concept. In oudere Windows-versies beperkt Windows een proces tot één CPU-groep. GC heeft dus slechts één CPU-groep gebruikt, tenzij u deze instelling hebt gebruikt om meerdere CPU-groepen in te schakelen. Deze beperking van het besturingssysteem is opgeheven in Windows 11 en Server 2022. Vanaf .NET 7 gebruikt GC standaard alle CPU-groepen wanneer ze worden uitgevoerd op Windows 11 of Server 2022.

• Alleen van toepassing op de garbagecollection van de server op 64-bits Windows-besturingssystemen.

• Standaard: GC wordt niet uitgebreid tussen CPU-groepen. Dit komt overeen met het instellen van de waarde op 0.

• Zie Cpu-configuratie verbeteren voor GC op machines met > 64 CPU's op de blog van Maoni Stephens voor meer informatie.

Deze configuratie-instelling heeft geen specifieke MSBuild-eigenschap. U kunt echter in plaats daarvan een RuntimeHostConfigurationOption MSBuild-item toevoegen. Gebruik de naam van de instelling runtimeconfig.json als de waarde van het Include kenmerk. Zie MSBuild-eigenschappen voor een voorbeeld.

Dynamische aanpassing van toepassingsgrootten (DATAS)

DATAS in- of uitschakelen

• Hiermee configureert u de garbagecollector voor het gebruik van DATAS. DATAS past zich aan de vereisten voor toepassingsgeheugen aan, wat betekent dat de grootte van de app heap ongeveer evenredig moet zijn met de gegevensgrootte met een lange levensduur.
• Standaard ingeschakeld vanaf .NET 9.

Deze configuratie-instelling heeft geen specifieke MSBuild-eigenschap. U kunt echter in plaats daarvan een RuntimeHostConfigurationOption MSBuild-item toevoegen. Gebruik de naam van de instelling runtimeconfig.json als de waarde van het Include kenmerk. Zie MSBuild-eigenschappen voor een voorbeeld.

Doel-TCP

DATAS gebruikt het percentage doorvoerkosten (TCP) als de meting van de geheugenkosten voor doorvoer. Er wordt rekening gehouden met zowel GC-pauzes als hoeveel toewijzingen moeten worden gewacht. Normaal gesproken overheerst de GC-pauzes, zodat u de "% onderbrekingstijd in GC" kunt gebruiken om deze kosten bij benadering te bepalen. Er zijn twee tijdelijke gevallen waarin de toewijzingswachttijd kan overheersten:

• Wanneer een proces wordt gestart, begint DATAS altijd met één heap. Dus als er voldoende threads zijn die worden toegestaan, ervaren ze wachttijden.
• Wanneer de werkbelasting verandert van lichter naar zwaarder, bijvoorbeeld wanneer piekuren beginnen, kan het toewijzen van threads tijdens die periode wachttijden ervaren. Dat komt doordat het een paar GCs kost voordat het aantal heaps wordt verhoogd.

DATAS maakt gebruik van 2% als standaard-TCP, die u met deze instelling kunt aanpassen. Het is een geheel getal dat wordt geïnterpreteerd als een percentage, bijvoorbeeld 5 betekent dat het doel-TCP 5%is.

Deze configuratie-instelling heeft geen specifieke MSBuild-eigenschap. U kunt echter in plaats daarvan een RuntimeHostConfigurationOption MSBuild-item toevoegen. Gebruik de naam van de instelling runtimeconfig.json als de waarde van het Include kenmerk. Zie MSBuild-eigenschappen voor een voorbeeld.

Maximale budgetinstellingen gen0

Het aanpassen van het gen0-budget is een van de belangrijkste elementen die DATAS gebruikt om zich aan te passen aan de grootte van toepassingen. DATAS definieert een bovendrempel met de naam BCD (budget berekend via DATAS) voor het totale gen0-budget als functie van de grootte van de toepassing. De formule voor het berekenen van een vermenigvuldiger is als volgt:

$$ f(\text{application_size_in_MB}) = \frac{20 - \text{conserve_memory}}{\sqrt{\text{application_size_in_MB}}} $$

De formule wordt vervolgens geklemd met een maximum- en minimumwaarde voordat deze wordt toegepast op de toepassingsgrootte in MB. Als de instelling voor het besparen van geheugen niet is opgegeven, gebruikt DATAS standaard 5. De maximum- en minimumwaarde zijn respectievelijk 10 en 0,1.

Als de grootte van de toepassing bijvoorbeeld 1 GB is, wordt de formule berekend (20 - 5) / sqrt (1000) = 0.474. Omdat het tussen de 10 en 0,1 is, heeft het klemmen geen effect. Dit betekent dat het totale gen0-budget 47,4% van 1 GB is, 474 MB. Als de toepassingsgrootte 1 MB is, berekent de formule 15 die vervolgens wordt aangepast aan 10, wat betekent dat het toegestane totale gen0-budget 10 MB is.

Er zijn drie instellingen beschikbaar om aan te passen wat de formule berekent en wijzigt de klemwaarden:

• Het percentage dat wordt toegepast op wat f er wordt berekend.

  	Naam instelling	Waarden	Versie geïntroduceerd
  runtimeconfig.json	System.GC.DGen0GrowthPercent	decimale waarde	.NET 10
  Omgevingsvariabele	DOTNET_GCDGen0GrowthPercent	hexadecimale waarde	.NET 10

  Deze configuratie-instelling heeft geen specifieke MSBuild-eigenschap. U kunt echter in plaats daarvan een RuntimeHostConfigurationOption MSBuild-item toevoegen. Gebruik de naam van de instelling runtimeconfig.json als de waarde van het Include kenmerk. Zie MSBuild-eigenschappen voor een voorbeeld.

  Dus als f 0,474 wordt berekend en deze instelling 200 is, wordt 0.474 * 200% = 0.948 de vermenigvuldiger voordat de klem wordt toegepast.

• De maximale klemwaarde in permil.

  	Naam instelling	Waarden	Versie geïntroduceerd
  runtimeconfig.json	System.GC.DGen0GrowthMaxFactor	decimale waarde	.NET 10
  Omgevingsvariabele	DOTNET_GCDGen0GrowthMaxFactor	hexadecimale waarde	.NET 10

  Deze configuratie-instelling heeft geen specifieke MSBuild-eigenschap. U kunt echter in plaats daarvan een RuntimeHostConfigurationOption MSBuild-item toevoegen. Gebruik de naam van de instelling runtimeconfig.json als de waarde van het Include kenmerk. Zie MSBuild-eigenschappen voor een voorbeeld.

  Als deze waarde 20000 is, betekent dit dat de maximale klemwaarde is 20000 * 0.001 = 20.

• De minimale klemwaarde in eenmil.

  	Naam instelling	Waarden	Versie geïntroduceerd
  runtimeconfig.json	System.GC.DGen0GrowthMinFactor	decimale waarde	.NET 10
  Omgevingsvariabele	DOTNET_GCDGen0GrowthMinFactor	hexadecimale waarde	.NET 10

  Deze configuratie-instelling heeft geen specifieke MSBuild-eigenschap. U kunt echter in plaats daarvan een RuntimeHostConfigurationOption MSBuild-item toevoegen. Gebruik de naam van de instelling runtimeconfig.json als de waarde van het Include kenmerk. Zie MSBuild-eigenschappen voor een voorbeeld.

  Als deze waarde 200 is, is 200 * 0.001 = 0.2de minimum klemwaarde .