Inzicht in prestaties voor mixed reality

  • Artikel

Dit artikel is een inleiding tot het begrijpen van het belang van prestaties voor uw Mixed Reality-app. De gebruikerservaring kan aanzienlijk worden verslechterd als uw toepassing niet met de optimale framesnelheid wordt uitgevoerd. Hologrammen lijken instabiel en hoofdtracering van de omgeving is onnauwkeurig, wat leidt tot een slechte ervaring voor de gebruiker. Prestaties moeten worden beschouwd als een eersteklas functie voor mixed reality-ontwikkeling en niet als een polijsttaak.

De performante framerate-waarden voor elk doelplatform worden hieronder vermeld.

Platform Doelframesnelheid
HoloLens 60 FPS
Windows Mixed Reality Ultra pc's 90 FPS
Windows Mixed Reality pc's 60 FPS

Het onderstaande framework bevat aanbevolen procedures voor het bereiken van doelframesnelheden. Voor tips over het meten en verbeteren van framerate in de Unity-omgeving raden we u aan het artikel Prestatieaanbevelingen voor Unity te lezen

Inzicht in prestatieknelpunten

Als uw app een underperforme framerate heeft, is de eerste stap het analyseren en begrijpen waar uw toepassing rekenintensief is. Er zijn twee primaire processors die verantwoordelijk zijn voor het werk om uw scène weer te geven: de CPU en de GPU, die elk verschillende aspecten van uw Mixed Reality-app verwerken. De drie belangrijkste punten waar knelpunten kunnen optreden, zijn:

  1. App-thread - CPU : verantwoordelijk voor uw app-logica, waaronder het verwerken van invoer, animaties, natuurkunde en andere app-logica.
  2. Render Thread - CPU naar GPU - Verantwoordelijk voor het verzenden van uw draw-aanroepen naar de GPU. Wanneer uw app een object zoals een kubus of model wil weergeven, stuurt deze thread een aanvraag naar de GPU om de bewerkingen uit te voeren.
  3. GPU : verwerkt meestal de grafische pijplijn van uw toepassing om 3D-gegevens (modellen, patronen, enzovoort) te transformeren in pixels. Uiteindelijk wordt er een 2D-afbeelding geproduceerd die naar het scherm van uw apparaat moet worden verzonden.

Levensduur van een frame

Over het algemeen zijn HoloLens-toepassingen GPU-gebonden, maar niet altijd. Gebruik de onderstaande hulpprogramma's en technieken om te begrijpen waar uw specifieke app knelpunten bevat.

Uw toepassing analyseren

Er zijn veel hulpprogramma's waarmee u inzicht krijgt in het prestatieprofiel en mogelijke knelpunten in uw mixed reality-toepassing.

Hieronder vindt u enkele algemene hulpprogramma's waarmee u uitgebreide profileringsinformatie voor uw toepassing kunt verzamelen:

Profileer in een omgeving

Een manier om te bepalen of uw app GPU- of CPU-gebonden is, is door de resolutie van de doeluitvoer van de render te verlagen. Door het aantal te berekenen pixels te verminderen, vermindert u de GPU-belasting. Het apparaat wordt weergegeven met een kleinere textuur en vervolgens een up-sample om de uiteindelijke afbeelding weer te geven.

Na het verlagen van de renderingresolutie, indien:

  1. Toepassingsframerate neemt toe, dan bent u waarschijnlijk GPU Gebonden
  2. Toepassingsframerate ongewijzigd, dan bent u waarschijnlijk CPU gebonden

Notitie

Unity biedt de mogelijkheid om de doelresolutie van uw toepassing tijdens runtime eenvoudig te wijzigen via de eigenschap XRSettings.renderViewportScale . De uiteindelijke afbeelding die op het apparaat wordt weergegeven, heeft een vaste resolutie. Het platform bemonstert de uitvoer met een lagere resolutie om een afbeelding met een hogere resolutie te maken voor weergave op beeldschermen.

UnityEngine.XR.XRSettings.renderScale = 0.7f;

Uw toepassing verbeteren

Aanbevelingen voor CPU-prestaties

Over het algemeen omvat het meeste werk in een mixed reality-toepassing op de CPU het uitvoeren van de 'simulatie' van de scène en het verwerken van uw toepassingslogica. De volgende gebieden zijn gericht voor optimalisatie:

  • Animaties
  • Natuurkunde
  • Geheugentoewijzingen
  • Complexe algoritmen (d.w.w.v. inverse kinematica, padzoeken)

Aanbevelingen voor GPU-prestaties

Inzicht in bandbreedte versus doorvoersnelheid

Bij het weergeven van een frame op de GPU is een toepassing afhankelijk van de geheugenbandbreedte of de vulsnelheid.

  • Geheugenbandbreedte is de snelheid van lees- en schrijfbewerkingen die de GPU kan uitvoeren vanuit het geheugen
    • Als u bandbreedtebeperkingen wilt identificeren, vermindert u de textuurkwaliteit en controleert u of de framesnelheid is verbeterd.
    • Als u beperkingen voor de vulsnelheid wilt identificeren, verlaagt u de beeldschermresolutie en kijkt u of de framesnelheid verbetert.

Notitie

Als u met Unity werkt, raadpleegt u onze aanbevelingen voor gpu-prestaties die specifiek zijn voor Unity. - Gebruik in Unity de eigenschap XRSettings.renderViewportScale

Geheugenbandbreedte omvat over het algemeen optimalisaties voor:

  1. Lagere textuurresoluties
  2. Minder patronen gebruiken (normaal, speculair, enzovoort)

De doorvoersnelheid is gericht op het verminderen van het aantal bewerkingen dat moet worden berekend voor een uiteindelijke gerenderde pixel, waaronder:

  1. Aantal objecten dat moet worden weergegeven/verwerkt
  2. Aantal bewerkingen per arcering
  3. Aantal GPU-fasen tot eindresultaat (geometrie-shaders, naverwerkingseffecten, enzovoort)
  4. Aantal pixels dat moet worden weergegeven (beeldschermresolutie)

Aantal veelhoeken verminderen

Hogere aantallen veelhoeken resulteren in meer bewerkingen voor de GPU, dus het verminderen van het aantal veelhoeken in uw scène vermindert de rendertijd. Er zijn andere factoren die arcering van de geometrie duur maken, maar het aantal veelhoeken is de eenvoudigste metrische waarde om te bepalen hoeveel werk het kost om een scène weer te geven.

Limiet voor overschrijding

Hoge overschrijding treedt op wanneer meerdere objecten worden weergegeven, maar niet op het scherm worden weergegeven omdat ze worden verborgen door een occluding-object. Stel je voor dat je kijkt naar een muur met daarachter objecten. Alle geometrie wordt verwerkt voor rendering, maar alleen de ondoorzichtige wand hoeft te worden weergegeven, wat resulteert in onnodige bewerkingen.

Shaders

Shaders zijn kleine programma's die worden uitgevoerd op de GPU en twee belangrijke stappen uitvoeren in de rendering:

  1. Bepalen welke hoekpunten moeten worden getekend en waar ze zich in de schermruimte bevinden (de hoekpuntschaduw)
    • De hoekpunt-shader wordt per hoekpunt uitgevoerd voor elk net.
  2. De kleur van elke pixel bepalen (de Pixel-arcering)
    • De Pixel-shader wordt per pixel uitgevoerd en door de geometrie weergegeven in de doelweergavestructuur.

Normaal gesproken voeren shaders veel transformaties en belichtingsberekeningen uit. Hoewel complexe verlichtingsmodellen, schaduwen en andere bewerkingen fantastische resultaten kunnen genereren, hebben ze ook een prijs. Het verminderen van het aantal bewerkingen dat in shaders wordt berekend, kan het werk dat nodig is voor de GPU per frame aanzienlijk verminderen.

Aanbevelingen voor arceringscodering
  • Gebruik waar mogelijk bilineair filteren
  • Expressies opnieuw rangschikken om mad-intrinsieken te gebruiken om een vermenigvuldiging en een optellen tegelijkertijd uit te voeren
  • Bereken zoveel mogelijk vooraf op de CPU en geef constanten door aan het materiaal
  • De voorkeur geven aan het verplaatsen van bewerkingen van de pixel-arcering naar de hoekpunt-shader
    • Over het algemeen is het aantal hoekpunten veel kleiner dan het aantal pixels (720p is 921.600 pixels, 1080p is 2.073.600 pixels, enzovoort)

GPU-fasen verwijderen

Naverwerkingseffecten kunnen duur zijn en de vulsnelheid van uw toepassing verhogen, inclusief anti-aliasingtechnieken zoals MSAA. Op HoloLens raden we u aan deze technieken en aanvullende arceringsfasen, zoals geometrie, romp en reken-shaders, te vermijden.

Geheugenaanbeveling

Overmatige geheugentoewijzings- en deallocatiebewerkingen kunnen leiden tot inconsistente prestaties, vastgelopen frames en ander schadelijk gedrag. Het is vooral belangrijk om inzicht te hebben in geheugenoverwegingen bij het ontwikkelen in Unity, omdat geheugenbeheer wordt beheerd door de garbagecollection.

Objectgroepering

Objectgroepering is een populaire techniek om de kosten van continue toewijzingen en toewijzingen van objecten te verlagen. Dit wordt gedaan door een grote pool met identieke objecten toe te wijzen en inactieve, beschikbare exemplaren uit deze pool opnieuw te gebruiken in plaats van objecten in de loop van de tijd voortdurend af te spawnen en te vernietigen. Objectgroepen zijn ideaal voor herbruikbare onderdelen met een variabele levensduur tijdens een app.

Zie ook