Förstå prestanda för mixad verklighet

  • Artikel

Den här artikeln är en introduktion till att förstå prestandans betydelse för din Mixed Reality app. Användarupplevelsen kan försämras avsevärt om programmet inte körs med optimal bildfrekvens. Hologram visas som instabila och huvudspårningen av miljön blir felaktig, vilket leder till en dålig upplevelse för användaren. Prestanda måste betraktas som en förstklassig funktion för utveckling av mixad verklighet och inte en polsk uppgift.

Värdena för performant framerate för varje målplattform visas nedan.

Plattform Målramhastighet
HoloLens 60 FPS
Windows Mixed Reality Ultra datorer 90 FPS
Windows Mixed Reality datorer 60 FPS

Ramverket nedan beskriver metodtips för att nå målramhastigheter. Tips om hur du mäter och förbättrar ramhastigheten i Unity-miljön rekommenderar vi att du läser artikeln om prestandarekommendationer för Unity

Förstå flaskhalsar i prestanda

Om din app har en underpresterande ramhastighet är det första steget att analysera och förstå var ditt program är beräkningsintensivt. Det finns två primära processorer som ansvarar för arbetet med att återge din scen: PROCESSORn och GPU:n, som var och en hanterar olika aspekter av din Mixed Reality app. De tre viktiga platserna där flaskhalsar kan uppstå är:

  1. Apptråd – CPU – Ansvarig för din applogik, inklusive bearbetning av indata, animeringar, fysik och annan applogik.
  2. Render Thread – CPU till GPU – Ansvarar för att skicka dina anrop till GPU:n. När din app vill rendera ett objekt, till exempel en kub eller modell, skickar den här tråden en begäran till GPU:n om att utföra åtgärderna.
  3. GPU – hanterar vanligtvis grafikpipelinen för ditt program för att omvandla 3D-data (modeller, texturer och så vidare) till bildpunkter. I slutändan skapas en 2D-avbildning som ska skickas till enhetens skärm.

Livslängd för en ram

I allmänhet är HoloLens-program GPU-bundna, men inte alltid. Använd verktygen och teknikerna nedan för att förstå var din app är flaskhalsad.

Så här analyserar du ditt program

Det finns många verktyg som gör att du kan förstå prestandaprofilen och potentiella flaskhalsar i ditt mixed reality-program.

Nedan visas några vanliga verktyg som hjälper dig att samla in detaljerad profileringsinformation för ditt program:

Profilera i valfri miljö

Ett sätt att avgöra om din app är GPU eller CPU-bunden är att sänka upplösningen för återgivningens målutdata. Genom att minska antalet pixlar som ska beräknas minskar du GPU-belastningen. Enheten renderas till en mindre struktur och sedan upp-exempel för att visa den slutliga bilden.

När återgivningsupplösningen har sänkts, om:

  1. Programramhastigheten ökar, då är du förmodligen GPU-bunden
  2. Programramhastigheten oförändrad, då är du troligtvis CPU-bunden

Anteckning

Unity ger dig möjlighet att enkelt ändra återgivningsmålmatchningen för ditt program vid körning via egenskapen XRSettings.renderViewportScale . Den slutliga bilden som visas på enheten har en fast upplösning. Plattformen använder utdata med lägre upplösning för att skapa en bild med högre upplösning för återgivning på skärmar.

UnityEngine.XR.XRSettings.renderScale = 0.7f;

Så här förbättrar du ditt program

Rekommendationer för CPU-prestanda

I allmänhet fungerar de flesta i ett mixed reality-program på CPU:en genom att göra "simuleringen" av scenen och bearbeta din programlogik. Följande områden är avsedda för optimering:

  • Animeringar
  • Fysik
  • Minnesallokeringar
  • Komplexa algoritmer (dvs. inverterad kinematik, sökvägssökning)

GPU-prestandarekommendationer

Förstå bandbredd kontra fyllningshastighet

När du återger en bildruta på GPU:n är ett program antingen bundet av minnesbandbredd eller fyllningshastighet.

  • Minnesbandbredd är frekvensen för läsningar och skrivningar som GPU:n kan göra från minnet
    • För att identifiera bandbreddsbegränsningar kan du minska texturkvaliteten och kontrollera om framerate har förbättrats.
    • Om du vill identifiera begränsningar för fyllningshastigheten sänker du visningsupplösningen och ser om framerate förbättras.

Anteckning

Om du arbetar med Unity kan du läsa våra Unity-specifika GPU-prestandarekommendationer. – I Unity använder du egenskapen XRSettings.renderViewportScale

Minnesbandbredd omfattar vanligtvis optimeringar för att antingen:

  1. Lägre texturupplösningar
  2. Använd färre texturer (normala, spekulativa och så vidare)

Fyllningshastigheten fokuserar på att minska antalet åtgärder som behöver beräknas för en slutlig renderad pixel, inklusive:

  1. Antal objekt som ska återges/bearbetas
  2. Antal åtgärder per skuggning
  3. Antal GPU-steg till slutresultatet (geometriskuggare, efterbearbetningseffekter och så vidare)
  4. Antal pixlar som ska återges (visningsupplösning)

Minska antalet polygoner

Högre polygonantal resulterar i fler åtgärder för GPU:n, så att minska antalet polygoner i scenen minskar återgivningstiden. Det finns andra faktorer som gör det dyrt att skugga geometrin, men antalet polygoner är det enklaste måttet för att avgöra hur mycket arbete som krävs för att återge en scen.

Begränsa övertrassering

Hög övertrassering inträffar när flera objekt återges men inte visas på skärmen eftersom de döljs av ett occluding-objekt. Tänk dig att titta på en vägg som har föremål bakom sig. All geometri skulle bearbetas för återgivning, men endast den täckande väggen måste återges, vilket resulterar i onödiga operationer.

Shaders

Skuggningsprogram är små program som körs på GPU:n och utför två viktiga steg i renderingen:

  1. Avgöra vilka hörn som ska ritas och var de finns i skärmutrymmet (hörnskuggaren)
    • Hörnskuggningen körs per hörn för varje nät.
  2. Fastställa färgen på varje bildpunkt (Pixel-skuggningen)
    • Pixel-skuggningen körs per bildpunkt och renderas av geometrin till målåtergivningens struktur.

Vanligtvis utför skuggor många transformeringar och belysningsberäkningar. Även om komplexa belysningsmodeller, skuggor och andra åtgärder kan generera fantastiska resultat, har de också ett pris. Om du minskar antalet åtgärder som beräknas i skuggor kan du avsevärt minska det arbete som krävs för GPU:n per bildruta.

Rekommendationer för skuggningskodning
  • Använd bilinearfiltrering när det är möjligt
  • Ordna om uttryck för att använda MAD-inbyggda objekt för att multiplicera och lägga till samtidigt
  • Förberäkna så mycket som möjligt på processorn och skicka som konstanter till materialet
  • Prioritera flytt av åtgärder från pixelskuggningen till hörnskuggaren
    • I allmänhet är antalet hörn mycket mindre än antalet pixlar (720p är 921 600 bildpunkter, 1 080p är 2 073 600 bildpunkter och så vidare)

Ta bort GPU-faser

Efterbearbetningseffekter kan vara dyra och öka fyllningshastigheten för ditt program, inklusive tekniker för aliasskydd som MSAA. På HoloLens rekommenderar vi att du undviker dessa tekniker och ytterligare skuggningssteg, till exempel geometri, skrov och beräkningsskuggor.

Minnesrekommendationer

Överdriven minnesallokering och frigöringsåtgärder kan resultera i inkonsekventa prestanda, låsta ramar och annat skadligt beteende. Det är särskilt viktigt att förstå minnesöverväganden när du utvecklar i Unity, eftersom minneshantering styrs av skräpinsamlaren.

Objektpooler

Objektpooler är en populär teknik för att minska kostnaden för kontinuerliga allokeringar och frigöring av objekt. Detta görs genom att allokera en stor pool med identiska objekt och återanvända inaktiva, tillgängliga instanser från den här poolen i stället för att ständigt skapa och förstöra objekt över tid. Objektpooler är bra för återanvändbara komponenter som har variabel livslängd under en app.

Se även