inspektera CPU aktivitet med CPU Profiler

optimera appens CPU-användning har många fördelar, såsom att ge en snabbare och smidigare användarupplevelse och bevara enhetens batteritid.

Du kan använda CPU-Profiler för att inspektera appens CPU-användning och trådaktiviteti realtid medan du interagerar med din app, eller så kan du inspektera detaljerna iinspelade metodspår, funktionsspår och systemspår.

de specifika typer av information som CPU Profiler registrerar och visar ärbestämd av vilken inspelningskonfiguration du väljer:

• System Trace: fångar finkorniga detaljer som gör att du kan inspektera hurdin app interagerar med systemresurser.

• metod-och funktionsspår: för varje tråd i din appprocess kan du ta reda på vilka metoder (Java) eller funktioner (C / C++) som körs under en tidsperiod och CPU-resurserna som varje metod eller funktion förbrukar under dess genomförande. Du kan också använda metod-och funktionsspår för att identifiera anropareoch callees. En uppringare är en metod eller funktion som åberopar en annan metodor-funktion, och en callee är en som åberopas av en annan metod ellerfunktion. Du kan använda den här informationen för att bestämma vilka metoder eller funktionerär ansvariga för att åberopa särskilda resurstunga uppgifter för ofta ochoptimera appens kod för att undvika onödigt arbete.

  När du registrerar metodspår kan du välja samplad eller instrumentedrecording. Vid inspelning funktion spår, du kan bara använda samplade inspelning.

för detaljer om hur du använder och väljer vart och ett av dessa spårningsalternativ, sevälj en inspelningskonfiguration.

CPU Profiler översikt

för att öppna CPU Profiler, följ dessa steg:

1. Välj Visa >Verktyg Windows >Profiler eller klicka på Profil I verktygsfältet.

   om du uppmanas av dialogrutan Välj Distributionsmål väljer du den enhet som ska distribuera din app för profilering. Om du har anslutit en enhet över Ossmen ser inte den listad, se till att du haraktiverat USB-felsökning.

2. Klicka var som helst i CPU-tidslinjen för att öppna CPU-profilen.

När du öppnar CPU-profilen börjar den omedelbart visa appens CPU-och trådaktivitet. Du bör se något liknande figur 1.

Figur 1. Tidslinjer i CPU Profiler.

som anges i Figur 1 innehåller standardvyn för CPU-Profiler följande tidslinjer:

1. Händelsetidslinje: Visar aktiviteterna i din app när de övergår genom olika tillstånd i deras livscykel och indikerar användarinteraktioner med enheten, inklusive skärmrotationshändelser. Information om hur du aktiverar händelsens tidslinje på enheter som kör Android 7.1 (API-nivå 25) och lägre finns i aktivera avancerad profilering.
2. CPU-tidslinje: visar CPU-användning i realtid av din app – i procent av den totala tillgängliga CPU—tiden-och det totala antalet trådar som din app använder. Tidslinjen visar också CPU-användningen av andra processer (till exempel systemprocesser eller andra appar), så att du kan jämföra den med appens användning. Du kan inspektera historiska CPU – användningsdata genom att flytta musen längs tidslinjens horisontella axel.
3. Trådaktivitetstidslinje: listar varje tråd som tillhör din appprocess och anger deras aktivitet längs en tidslinje med hjälp av färgerna nedan. När du har spelat in ett spår kan du välja en tråd från den här tidslinjen för att inspektera dess data i spårningsfönstret.
   • grön: tråden är aktiv eller är redo att använda CPU. Det vill säga det är i ett löpande eller löpande tillstånd.
   • gul: tråden är aktiv, men den väntar på en I/O-operation, till exempel disk eller nätverks-I / O, innan den kan slutföra sitt arbete.
   • grå: tråden sover och förbrukar ingen CPU-tid. Detta inträffar ibland när tråden kräver åtkomst till en resurs som ännu inte är tillgänglig. Antingen går tråden i frivillig sömn, eller kärnan sätter tråden i vila tills den önskade resursen blir tillgänglig.

   CPU—profilen rapporterar också CPU-användning av trådar som Android Studio och Android-plattformen lägger till i din appprocess-till exempelJDWPProfile SaverStudio:VMStatsStudio:Perfa ochStudio:Heartbeat (även om de exakta Namnen som visas i tidslinjen för trådaktivitet kan variera). Android Studio rapporterar dessa data så att du kan identifiera när trådaktivitet och CPU-användning faktiskt orsakas av appens kod.

spela in spår

för att börja spela in ett spår, välj en inspelningskonfiguration från någon av rullgardinsmenyerna ovanför eller under CPU-profilen och klicka på Spela in.

Figur 2. CPU Profiler visar status, varaktighet och typ av inspelning som görs.

interagera med din app och klicka sedan på Stopp när du är klar. Profilen visar automatiskt sin spårningsinformation i spårningsfönstret, som visas i Figur 3:

Figur 3. CPU Profiler efter inspelning amethod spår.

1. valt område: bestämmer den del av den inspelade tiden som ska inspekteras i spårningsfönstret. När du först spelar in ett spår väljer CPU-profilen automatiskt hela längden på din inspelning i CPU-tidslinjen. Om du vill inspektera spårningsdata för endast en del av det inspelade tidsintervallet drar du kanterna i det markerade området.
2. Interaktionssektion: visar användarinteraktion och applivscykelhändelser längs en tidslinje.
3. Trådavsnitt: visar trådtillståndsaktivitet (som att springa, sova, etc.) och Samtalsdiagram (eller spåra händelsediagram i Systemspårning) för varje tråd längs en tidslinje.
   • använd mus-och tangentbordsgenvägar för att navigera i tidslinjen.
   • dubbelklicka på trådnamnet eller tryck på Enter medan en tråd är markerad för att expandera eller komprimera en tråd.
   • välj en tråd för att se ytterligare information i Analysfönstret. Håll Shift eller Ctrl (kommando på Mac) för att välja flera trådar.
   • Välj ett metodanrop (eller spårningshändelse i Systemspårning) för att se ytterligare information i Analysfönstret.
4. analyspanel: Visar spårningsdata för det tidsintervall och det tråd-eller metodsamtal du har valt. I den här rutan kan du välja hur du vill visa varje stackspårning (med hjälp av analysflikarna) och hur du mäter exekveringstid (med hjälp av rullgardinsmenyn tidsreferens).
5. analyspanelflikar: Välj hur spårningsdetaljer ska visas. För mer information om varje alternativ, se inspektera spår.
6. tidsreferensmeny: välj något av följande för att bestämma hur tidsinformation för varje samtal mäts (stöds endast i prov / spår Java-metoder):
   • Väggklocktid: Tidsinformation representerar faktisk förfluten tid.
   • Trådtid: tidsinformation representerar faktisk förfluten tid minus någon del av den tiden när tråden inte förbrukar CPU-resurser. För ett visst samtal är dess trådtid alltid mindre än eller lika med dess väggklocktid. Att använda trådtid ger dig en bättre förståelse för hur mycket av en tråds faktiska CPU-användning som konsumeras av en viss metod eller funktion.
7. Filter: Filter spårar data efter funktion, metod, klass eller Paketnamn. Om du till exempel snabbt vill identifiera spårningsdata relaterade till ett specifikt samtal skriver du namnet i sökfältet. På fliken Flame chart betonas samtalstaplar som innehåller ett samtal, ett paket eller en klass som matchar sökfrågan. I flikarna Top down och Bottom up prioriteras dessa anropsstackar framför andra spårresultat. Du kan också aktivera följande alternativ genom att markera lämplig ruta bredvid sökfältet:
   • Regex: för att inkludera reguljära uttryck i din sökning, använd det här alternativet.
   • match case: om din sökning är skiftlägeskänslig, använd det här alternativet.

välj en inspelningskonfiguration

innan du börjar spela in spårningsinformation, välj lämplig inspelningskonfiguration för profileringsinformationen som du vill fånga:

• exempel på Java-metoder: fångar appens samtalsstack med jämna mellanrum under appens Java-baserade kodkörning. Profilen jämför uppsättningar av fångade data för att härleda timing och resursanvändningsinformation om appens Java-baserade kodkörning.

  en inneboende fråga om samplad-baserad spårning är att om din app går in i en metod efter en fångst av samtalsstacken och avslutar metoden före nästa fångst, loggas inte det metodsamtalet av profilen. Om du är intresserad av spårningsmetoder med så korta livscykler bör du använda instrumenterad spårning.

• spåra Java-metoder: instrument din app vid körning för att spela in en tidsstämpel i början och slutet av varje metodsamtal. Tidsstämplar samlas in och jämförs för att generera metodspårningsdata, inklusive tidsinformation och CPU-användning.

  Observera att overhead i samband med instrumentering varje metod påverkar runtime prestanda och kan påverka profileringsdata; detta är ännu mer märkbar för metoder med relativt korta livscykler. Dessutom, om din app kör ett stort antal metoder på kort tid, kan profilen snabbt överskrida sin filstorleksgräns och kanske inte kan spela in ytterligare spårningsdata.

• Sample C / C++ funktioner: fångar samplade spår av appens infödda trådar. Om du vill använda den här konfigurationen måste du distribuera appen till en enhet som kör Android 8.0 (API-nivå 26) eller högre.

  Internt använder denna konfiguration simpleperf för att spåra din apps ursprungliga kod. Om du vill ange ytterligare alternativ försimpleperf, till exempel samplingsspecifika Enhetsprocessorer eller specificering av samplingstider med hög noggrannhet, kan du användasimpleperf från kommandoraden.

• spåra systemanrop: fångar finkorniga detaljer som gör att du kan inspektera hur din app interagerar med systemresurser. Du kan inspektera exakta tidpunkter och varaktigheter för dina trådtillstånd, visualisera var dina CPU-flaskhalsar finns i alla kärnor och lägga till anpassade spårhändelser för att analysera. Sådan information kan vara avgörande när du felsöker prestandaproblem. Om du vill använda den här konfigurationen måste du distribuera appen till en enhet som kör Android 7.0 (API-nivå 24) eller högre.

  När du använder denna spårningskonfiguration kan du visuellt markera viktiga kodrutiner i profileringstidslinjen genom att instrumentera din kod. För att instrumentera C / C++ – kod, använd det inbyggda spårnings-API som tillhandahålls av trace.h. För att instruera Java-kod, använd klassenTrace. För mer information, se Instrument din app kod.

  denna spårkonfiguration är byggd på systrace. Du kan använda kommandoradsverktyget systrace för att ange alternativ utöver de som finns i CPU-profilen. De ytterligare systemnivådata som tillhandahålls av systrace kan hjälpa dig att inspektera inbyggda systemprocesser och felsöka tappade eller försenade ramar.

  på enheter som kör Android 9 (API-nivå 28) eller högre kan du använda en systemapp som heter System Tracing för att spela in systemspår på en enhet.

Skapa, redigera eller visa en inspelningskonfiguration

du skapar, redigerar och visar inspelningskonfigurationer i dialogrutan CPU RecordingConfigurations, som du öppnar genom att välja Redigera konfigurationerfrån rullgardinsmenyn inspelningskonfigurationer högst upp i CPU-profilen.

om du vill visa inställningarna för en befintlig inspelningskonfiguration markerar du den i den vänstra rutan i dialogrutan CPU-Inspelningskonfigurationer.

för att skapa en ny inspelningskonfiguration, gör följande:

1. Klicka på Lägg till längst upp till vänster i dialogrutan. Detta skapar en ny konfiguration med någrastandardinställningar.
2. namnge din konfiguration.
3. välj en spårningsteknik.
4. för samplade inspelningskonfigurationer anger du Samplingsintervallet imikrosekunder (aug). Detta värde representerar tiden mellan varje prov ofyour app ’ s call stack. Ju kortare intervallet du anger desto snabbare dinnå filstorleksgränsen för inspelade data.
5. ange Filstorleksgränsen, i megabyte (MB), för den inspelade datasom skrivs till den anslutna enheten. När du slutar spela in analyserar AndroidStudio dessa data och visar dem i profileringsfönstret. Så, om duöka gränsen och spela in en stor mängd data, tar Android Studio mycket längre tid att analysera filen och kan inte svara.

   Obs: Om du använder en ansluten enhet som kör Android 8.0 (API nivå 26)eller högre, Det finns ingen gräns för filstorleken av spårningsdata, och dettavalue ignoreras. Men du måste fortfarande vara försiktig med hur mycket dataenheten samlar efter varje inspelning—Android Studio kan ha svårigheterparsa stora spårfiler. Om du till exempel spelar in antingen ett sampledtrace med ett kort samplingsintervall eller ett instrumenterat spår medan din appcalls många metoder på kort tid, genererar du snabbt stora spårfiler.

6. Om du vill godkänna ändringarna och fortsätta göra ändringar i andra konfigurationer klickar du på Verkställ. Klicka på för att acceptera alla tillämpade ändringar och stäng dialogrutanväl.

spela in CPU-aktivitet med Debug API

Du kan använda Debug API för att ge din app möjlighet att starta och stoppa inspelningen av CPU-aktivitet i CPU-Profiler.

CPU-profilen börjar spela in när din app ringerstartMethodTracing(String tracePath),och CPU-profilen slutar spela in när din app ringerstopMethodTracing(). Whilerecording CPU aktivitet som utlöses med hjälp av detta API, CPU profiler showsDebug API som den aktiva CPU inspelningskonfiguration.

för att styra inspelningen av CPU-aktivitet medDebug API, distribuera yourinstrumented app till en enhet som kör Android 8.0 (API nivå 26) eller högre.

För mer information, segenerera spårloggar genom att instrumentera din app.

spela in CPU-aktivitet under appstart

för att börja spela in CPU-aktivitet automatiskt under appstart, gör följande:

1. välj Kör > redigera konfigurationer.
2. på fliken profilering markerar du rutan bredvid börja spela in en metodtrace vid start.
3. välj en CPU-inspelningskonfiguration från menyn.
4. Klicka på Verkställ.
5. distribuera din app till en enhet som kör Android 8.0 (API-nivå 26) eller högre genom att välja Kör > profil.

exportera spår

När du har spelat in CPU-aktivitet med CPU-profiler kan du exportera filen ASA .trace för att dela med andra eller inspektera senare.

om du vill exportera en spårningsfil från CPU-tidslinjen gör du följande:

1. högerklicka på den inspelade metoden trace eller system tracesom du vill exportera i CPU-tidslinjen.
2. välj Exportera spår från menyn.
3. Bläddra till var du vill spara filen, ange filnamnet och klickaok.

om du vill exportera en spårningsfil från fönstret sessioner gör du följande:

1. i fönstret sessioner högerklickar du på det inspelade spår som du villexportera.
2. Klicka på knappen Exportera metodspårning eller exportera systemspårning vid höger om sessionsposten.
3. Bläddra till var du vill spara filen, ange filnamnet och klickaok.

importera spår

Du kan importera.trace filer som skapats medDebug API eller CPU Profiler.

importera din spårningsfil genom att klicka på Starta ny profiler session I profilers Sessions-fönster och välj sedan ladda Från fil.

Du kan inspektera en importerad spår i CPU Profiler mycket som du gör withtraces fångas direkt i CPU Profiler, med följande undantag:

• CPU-aktivitet representeras inte längs CPU-tidslinjen (utom i Systemspårning).
• tidslinjen i avsnittet trådar visar inte trådtillstånd somkör, väntar eller sover (utom i Systemspårning).

inspektera spår

spårvyn i CPU-profilen ger flera sätt att visa information från inspelade spår.

för metodspår och funktionsspår kan du se Samtalschematdirekt i trådens tidslinje och Flame-diagrammet, uppifrån och ner och längst ner i Analysfönstret. För systemspår kan du se Spårningshändelserna direkt i trådens tidslinje och Flame-diagrammet, uppifrån och ner och upp från Analyspanelen.

Mus-och tangentbordsgenvägar är tillgängliga för att underlätta navigering av Samtalsdiagram eller Spårningshändelser.

inspektera spår med Anropsdiagrammet

Anropsdiagrammet ger en grafisk representation av ett metodspår eller funktionsspår, där perioden och tidpunkten för ett samtal representeras påhorisontal axel, och dess kallelser visas längs den vertikala axeln. Samtal till System-API: er visas i orange, samtal till appens egna metoder visas i grönt och samtal till tredje parts API: er (inklusive Java-språk-API: er) visas iBlue. Figur 4 visar ett exempel på samtalsdiagram och illustrerar begreppet självtid, barntid och total tid för en given metod eller funktion. Du kan lära dig mer om dessa begrepp i avsnittet om hur man skainspektera spår med hjälp av Top Down och Bottom Up.

Figur 4. Ett exempel på samtalsdiagram som illustrerarsjälv, barn och total tid för metod D.

tips: Om du vill hoppa över källkoden för en metod eller funktion högerklickar du på den och väljer Hoppa till källa. Detta fungerar från någon av flikarna i Analysfönstret.

inspektera spår med fliken Flame Chart

fliken Flame Chart ger ett inverterat samtalsdiagram som aggregatesidentical call stacks. Det vill säga identiska metoder eller funktioner som delar samma sekvens av uppringare samlas in och representeras som en längre stapel i aflame-diagram (snarare än att visa dem som flera kortare staplar, som visas i acall-diagram). Detta gör det lättare att se vilka metoder eller funktioner som förbrukarmest tid. Detta betyder emellertid också att den horisontella axeln inte representerar atimeline; istället indikerar den den relativa tid som varje metod eller funktion tar att utföra.

för att illustrera detta koncept, överväga samtalsdiagrammet i Figur 5. Notera att metod D ringer flera samtal till B (B1, B2 ochb3), och några av dessa samtal till B ringer ett samtal till C (C1 och 3).

Figur 5. Ett samtalsdiagram med flera metodsamtalsom delar en gemensam sekvens av uppringare.

Eftersom B1, B2, och B3 delar samma sequenceof ringer (A → D → B) de är samlade, som visas i figur 6. På samma sätt aggregeras C1 och C3, eftersom de delar samma sekvens av uppringare (A.C. D. C. B. C. C.). Observera att C2 inte ingår eftersom det har en annan sekvens av uppringare (A. C. D. C. C.).

Figur 6. Aggregera identiska metoder som delassamma samtalsstack.

de aggregerade samtalen används för att skapa flame-diagrammet, som visas i Figur 7.Observera att för varje givet samtal i ett flamdiagram visas de callees som förbrukar mest CPU-tid först.

Figur 7. En flamma diagram representation av callchart visas i Figur 5.

inspektera spår med Top Down och Bottom Up

fliken Top Down visar en lista över samtal där expanderar en metod orfunction nod visar sina calles. Figur 8 visar en uppifrån och ned graf för callchart i Figur 4. Varje pil i diagrammet pekar från en uppringare till en callee.

som visas i Figur 8, expanderar noden för metod a i fliken uppifrån och nervisar dess kallelser, metoder B och D. Därefter expanderar noden för metodd dess kallelser, metoder B och C, och så vidare. I likhet med Flame charttab samlar top down-trädet spårinformation för identiska metoder somdela samma samtalsstack. Det vill säga, fliken Flame chart ger en grafiskrepresentation av fliken Top down.

fliken uppifrån och ned ger följande information för att beskriva Cputid som spenderas på varje samtal (tider representeras också som en procentandel av trådens totala tid över det valda intervallet):

• Self: den tid metoden eller funktionsanropet tillbringade med att utföra sin egen kod och inte den för dess kallelser, som illustreras i Figur 4 För metod D.
• barn: den tid metoden eller funktionsanropet spenderade med att utföra sina kallelser och inte sin egen kod, som illustreras i Figur 4 för D.
• total: summan av metodens själv-och barntid. Detta representerar den totala tiden som appen spenderade ett samtal, som illustrerad figur 4 För metod D.

fliken nedifrån och upp visar en lista över samtal där utökning av en funktion ellermethods nod visar sina uppringare. Med hjälp av exemplet spår som visas i Figur 8, figur 9 ger en botten upp träd för metod C. Öppna noden för metod ci botten upp trädet visar var och en av sina unika uppringare, metoder B och D. Noteraatt även om B kallar C två gånger visas B bara en gång när du expanderar noden förmetod C i botten upp trädet. Därefter expanderar noden för B-displayerdess uppringare, metoder A och D.

fliken botten upp är användbar för sortering av metoder eller funktioner av de somkonsumera mest (eller minst) CPU-tid. Du kan inspektera varje nod för att bestämmavilka uppringare spenderar mest CPU-tid på att åberopa dessa metoder eller funktioner.Jämfört med top down träd, timing info för varje metod eller funktion i abottom up träd är i hänvisning till metoden på toppen av varje träd (top node).CPU-tid representeras också som en procentandel av trådens totala tid underden inspelningen. Följande tabell hjälper till att förklara hur man tolkar timinginformation för den övre noden och dess uppringare (undernoder).

totalt

	själv	barn
metod eller funktion längst upp i botten upp trädet (toppnod)	representerar den totala tiden metoden eller funktionen tillbringade exekvera sin egen kod och inte att dess callees. Jämfört med top down-trädet representerar denna tidsinformation en summa av alla samtal till den här metoden eller funktionen under inspelningens varaktighet.	representerar den totala tiden som metoden eller funktionen använde för att utföra sina callees och inte sin egen kod. Jämfört med top down-trädet representerar denna tidsinformation summan av alla samtal till den här metoden eller funktionens callees under inspelningens varaktighet.	summan av själv tid och Barn tid.
uppringare (undernoder)	representerar den totala självtiden för callee när den anropas av den som ringer. Med hjälp av bottom up-trädet i Figur 9 som ett exempel skulle självtiden för Metod B motsvara summan av självtiderna för varje utförande av metod C när den anropas av B.	representerar den totala barntiden för callee när den anropas av den som ringer. Med hjälp av botten upp trädet i Figur 9 som ett exempel skulle barntiden för Metod B motsvara summan av barntiderna för varje utförande av metod C när den anropas av B.	summan av självtiden och barntiden.

Obs: För en given inspelning slutar Android Studio samla in nya datanär profilen når filstorleksgränsen (detta stoppar dock inteinspelning). Detta händer vanligtvis mycket snabbare när du utförinstrumenterade spår eftersom denna typ av spårning samlar in mer data under en kortare tid jämfört med ett samplat spår. Om du förlänger inspektionstiden till en period av inspelningen som inträffade efter att ha nått gränsen ändras inte tidsdata ispårrutan (eftersom inga nya data är tillgängliga). Dessutom visar spårningsfönstret nan för tidsinformation när du bara väljer den del av en inspelning som inte har några data tillgängliga.

inspektera systemspårningar

När du inspekterar ett systemspårning kan du undersöka Spårningshändelser i threads tidslinje för att se detaljerna om händelserna som inträffar på varje tråd.Håll muspekaren över en händelse för att se namnet på händelsen och den tid som spenderas i varje stat. Klicka på en händelse för att se mer information i analysfönstret.

rutan CPU-kärnor (som visas i Figur 10) visar trådaktivitetsplanerad på varje kärna. Håll muspekaren över en trådaktivitet för att se vilken tråd den här kärnan körs på vid den aktuella tiden.

Figur 10. Visa CPU-aktivitet och spåra händelser för render-tråden.

För ytterligare information om kontroll av systemspårningsinformation, seutred UI performance problemsavsnittet försystrace dokumentation.

inspektera frame rendering data

Du kan inspektera hur lång tid det tar din app att göra varje ram på mainthread och RenderThread för att undersöka flaskhalsar som orsakar UI jank och lowframerates.

för att se bildåtergivningsdata,spela in ett spår med aconfiguration som låter dig spåra systemanrop. Efter inspelning av banan, leta efter information om varje ram under ramens tidslinje i Visningsavsnittet, som visas i Figur 11.

Figur 11. Varje ram som tar längre tid än 16mvisas i rött.