Prestaties van garbagecollection in WinUI-apps verbeteren

WinUI-apps die zijn gebouwd met Windows App SDK en geschreven in C# krijgen automatisch geheugenbeheer van de .NET garbage collector. In dit artikel vindt u een overzicht van de aanbevolen procedures voor gedrag en prestaties voor de .NET garbage collector in WinUI-apps. Zie Garbagecollection voor meer informatie over hoe de .NET garbagecollection werkt en hulpprogramma's voor foutopsporing en analyse van de prestaties van garbagecollection.

De garbagecollector bepaalt wanneer het moet worden uitgevoerd door het evenwicht te bewaren tussen het geheugenverbruik van de beheerde heap en de hoeveelheid werk die een garbage-collection moet uitvoeren. Een van de manieren waarop de garbage collector dit doet, is door de heap in generaties te verdelen en meestal slechts een deel van de heap op te ruimen. Er zijn drie generaties in de beheerde heap:

• Generatie 0. Deze generatie bevat nieuw toegewezen objecten, tenzij ze 85 kB of groter zijn, in welk geval ze deel uitmaken van de grote object-heap. De grote object-heap wordt verzameld met verzamelingen van de tweede generatie. Verzamelingen van generatie 0 zijn het meest voorkomende type verzameling en ruimen objecten met een korte levensduur op, zoals lokale variabelen.
• Generatie 1. Deze generatie bevat objecten die verzamelingen van de 0e generatie hebben overleefd. Het fungeert als buffer tussen generatie 0 en generatie 2. Verzamelingen van de 1e generatie treden minder vaak op dan verzamelingen van generatie 0, en maken tijdelijke objecten schoon die actief waren tijdens eerdere verzamelingen van generatie 0. Een verzameling van de 1e generatie verzamelt ook generatie 0.
• Generatie 2. Deze generatie bevat langlevende objecten die verzamelingen van generatie 0 en generatie 1 hebben overleefd. Verzamelingen van de tweede generatie zijn het minst frequent en verzamelen de volledige beheerde heap, inclusief de grote object-heap, die objecten bevat die 85 kB of groter zijn.

U kunt de prestaties van de garbage-collector op twee manieren meten: de tijd die nodig is om de garbage-collection uit te voeren en het geheugenverbruik van de beheerde heap. Als u een kleine app hebt met een heapgrootte van minder dan 100 MB, kunt u zich richten op het verminderen van het geheugenverbruik. Als u een app met een beheerde heap hebt die groter is dan 100 MB, richt u zich uitsluitend op het verkorten van de tijd voor de garbageverzameling. U kunt de .NET garbage collector als volgt helpen betere prestaties te bereiken.

Geheugenverbruik verminderen

Releaseverwijzingen

Een verwijzing naar een object in uw app voorkomt dat dat object en alle objecten waarnaar wordt verwezen, worden verzameld. De .NET-compiler doet een goede taak om te detecteren wanneer een variabele niet meer in gebruik is, zodat objecten die door die variabele worden vastgehouden, in aanmerking komen voor verzameling. In sommige gevallen is het echter niet duidelijk dat sommige objecten een verwijzing hebben naar andere objecten, omdat een deel van de objectgrafiek mogelijk eigendom is van bibliotheken die door uw app worden gebruikt. Zie Garbagecollectie en prestaties voor informatie over de tools en technieken om te bepalen welke objecten een garbagecollectie overleven.

Een garbage collection veroorzaken als dat nuttig is

Breng pas een garbage-collection tot stand nadat u de prestaties van uw app hebt gemeten en hebt vastgesteld dat het uitvoeren van een garbage-collection de prestaties ervan zal verbeteren.

U kunt een garbagecollection van een generatie veroorzaken door GC.Collect(n) aan te roepen, waarbij n de generatie is die u wilt verzamelen (0, 1 of 2).

Minder tijd voor garbagecollection

Deze sectie is van toepassing als u uw app hebt geanalyseerd en grote garbage collection-tijden hebt waargenomen. De pauzetijden voor garbage collection omvatten de tijd die nodig is om een enkele run van garbage collection uit te voeren en de totale tijd die uw app besteedt aan het uitvoeren van garbage collections. De hoeveelheid tijd die nodig is om een verzameling uit te voeren, is afhankelijk van hoeveel livegegevens de collector moet analyseren. Generatie 0 en generatie 1 zijn gebonden aan grootte, maar generatie 2 blijft groeien naarmate er meer langlevende objecten actief zijn in uw app. Dit betekent dat de verzamelingstijden voor generatie 0 en generatie 1 zijn gebonden, terwijl verzamelingen van de tweede generatie langer kunnen duren. Hoe vaak garbagecollecties worden uitgevoerd, hangt meestal af van hoeveel geheugen er wordt toegewezen, omdat een garbagecollectie geheugen vrijmaakt om aan verzoeken tot toewijzing te voldoen.

De garbagecollector onderbreekt af en toe uw app om werk uit te voeren, maar onderbreekt uw app niet noodzakelijkerwijs de hele tijd dat deze een verzameling uitvoert. Onderbrekingstijden zijn meestal niet zichtbaar voor gebruikers in uw app, met name voor verzamelingen van generatie 0 en generatie 1. Met de functie achtergrondgarbagecollection van de .NET garbagecollector kunnen verzamelingen van generatie 2 gelijktijdig worden uitgevoerd terwijl uw app actief is en wordt uw app slechts korte tijd onderbroken. Maar het is niet altijd mogelijk om een verzameling van de tweede generatie als achtergrondverzameling uit te voeren. In dat geval kan de pauze door de gebruiker worden gedetecteerd als u een groot genoeg heap hebt (meer dan 100 MB).

Frequente garbage-collecties kunnen bijdragen aan een hogere CPU-belasting, een verhoogd energieverbruik, langere laadtijden of een lagere beeldsnelheid in uw toepassing. Hieronder vindt u enkele technieken die u kunt gebruiken om de tijd van garbagecollection en verzamelinggerelateerde pauzes in uw beheerde WinUI-app te verminderen.

Verminder geheugentoewijzingen

Als u geen objecten toewijst, wordt de afvalverzamelaar niet uitgevoerd, tenzij zich een situatie voordoet waarbij het systeem weinig geheugen heeft. Het verminderen van de hoeveelheid geheugen die u direct toewijst, leidt tot minder frequente garbage collections.

Als in sommige secties van uw app pauzes volledig ongewenst zijn, kunt u vooraf de benodigde objecten vooraf toewijzen tijdens een minder kritieke tijd voor prestaties. Een game kan bijvoorbeeld alle objecten toewijzen die nodig zijn voor gameplay tijdens het laden van het scherm van een niveau en geen toewijzingen maken tijdens de gameplay. Dit voorkomt pauzes terwijl de gebruiker het spel speelt en kan resulteren in een hogere en consistentere framesnelheid.

Verzamelingen van de tweede generatie verminderen door objecten met een gemiddelde levensduur te vermijden

Generational garbage collections presteren het beste wanneer u echt kortlevende en/of echt langlevende objecten in uw app hebt. Kortlevende objecten worden verzameld in de goedkopere verzamelingen van de 0e en 1e generatie, en objecten die lang leven worden gepromoveerd tot generatie 2, die zelden worden verzameld. Objecten met een lange levensduur zijn objecten die gedurende de hele duur van uw app worden gebruikt, of gedurende een aanzienlijke periode van uw app, zoals tijdens een specifieke pagina of gameniveau.

Als u vaak objecten maakt die een tijdelijke levensduur hebben, maar lang genoeg leven om naar generatie 2 te worden gepromoveerd, gebeuren er meer dure verzamelingen van de tweede generatie. Mogelijk kunt u verzamelingen van de tweede generatie verminderen door bestaande objecten te recyclen of objecten sneller vrij te geven.

Een veelvoorkomend voorbeeld van objecten met een levensduur op middellange termijn is objecten die worden gebruikt voor het weergeven van items in een lijst waar een gebruiker doorheen schuift. Als objecten worden gecreëerd wanneer items in de lijst in beeld worden gescrold en niet langer worden verwezen wanneer items uit beeld worden gescrold, heeft uw app meestal een groot aantal generatie 2-verzamelingen. In dergelijke situaties kunt u een set objecten vooraf toewijzen en opnieuw gebruiken voor de gegevens die actief worden weergegeven aan de gebruiker en objecten met korte levensduur gebruiken om informatie te laden als items in de lijst in beeld komen.

Verzamelingen van de tweede generatie verminderen door grote objecten met korte levensduur te vermijden

Elk object dat 85 kB of groter is, wordt toegewezen aan de grote object heap (LOH) en wordt verzameld als onderdeel van generatie 2. Als u tijdelijke variabelen hebt, zoals buffers, die groter zijn dan 85 kB, worden deze door een verzameling van de tweede generatie opgeschoond. Als u tijdelijke variabelen beperkt tot minder dan 85 kB, vermindert u het aantal verzamelingen van de tweede generatie in uw app. Een veelvoorkomende techniek is het maken van een buffergroep en het hergebruiken van objecten uit de pool om grote tijdelijke toewijzingen te voorkomen.

Vermijd objecten met verwijzingsfuncties

De vuilniscollector bepaalt welke objecten actief zijn door verwijzingen tussen objecten te volgen die beginnen bij de wortels van uw app. Zie Wat er gebeurt tijdens een garbagecollection voor meer informatie. Als een object veel verwijzingen bevat, is er meer werk voor de garbagecollector. Een veelgebruikte techniek, met name bij grote objecten, is het converteren van objecten met veel verwijzing naar objecten zonder verwijzingen. Sla bijvoorbeeld een index op in plaats van een verwijzing op te slaan. Natuurlijk werkt deze techniek alleen als het logisch is om dit te doen.

Het vervangen van objectverwijzingen met indexen kan een verstorende en gecompliceerde wijziging in uw app zijn en is het meest effectief voor grote objecten met een groot aantal verwijzingen. Doe dit alleen als u in uw app grote perioden ziet van garbage collection die betrekking hebben op objecten met veel verwijzingen.