Grafici dall'alto verso il basso e dal basso verso l'alto
Mantieni tutto organizzato con le raccolte
Salva e classifica i contenuti in base alle tue preferenze.
La scheda Dall'alto verso il basso mostra un elenco di chiamate in cui l'espansione di un nodo di metodo o
funzione mostra i relativi chiamati. La figura 2 mostra un grafico dall'alto verso il basso per il
seguente grafico delle chiamate. Ogni freccia nel grafico punta da un chiamante a un destinatario della chiamata.
Figura 1. Un esempio di grafico delle chiamate che illustra
il tempo totale per sé, per i figli e per il metodo D.
Come mostrato nella Figura 2, l'espansione del nodo per il metodo A nella scheda Dall'alto verso il basso
mostra i relativi chiamati, i metodi B e D. Dopodiché, espandendo il nodo per il metodo
D vengono visualizzati i relativi chiamanti, ad esempio i metodi B e C. Simile alla scheda
Grafico a fiamma, l'albero
dall'alto verso il basso aggrega le informazioni di traccia per i metodi identici che condividono lo stesso stack di chiamate. ovvero la scheda Grafico a fiamma fornisce una rappresentazione grafica della scheda Dall'alto verso il basso.
La scheda Dall'alto verso il basso fornisce le seguenti informazioni per descrivere il tempo della CPU
trascorso per ogni chiamata (i tempi sono rappresentati anche come percentuale del
tempo totale del thread nell'intervallo selezionato):
- Self:il tempo impiegato dalla chiamata di metodo o funzione per eseguire il proprio codice
e non quello dei chiamati, come illustrato nella Figura 1 per il metodo D.
- Bambini:il tempo che la chiamata di metodo o funzione ha impiegato per eseguire i propri
chiamati e non il proprio codice, come illustrato nella Figura 1 per il metodo D.
- Totale:la somma del tempo trascorso con il metodo Self e Children. Questo
rappresenta il tempo totale trascorso dall'app per eseguire una chiamata, come illustrato nella
Figura 1 per il metodo D.
Figura 2. Un albero dall'alto verso il basso.
Figura 3. Un albero Bottom Up per il metodo C della
Figura 5.
La scheda Dal basso verso l'alto mostra un elenco di chiamate in cui l'espansione del nodo di una funzione o di un metodo mostra i relativi chiamanti. Utilizzando la traccia di esempio mostrata nella Figura 2,
la Figura 3 fornisce un albero dal basso verso l'alto per il metodo C. L'apertura del nodo per il metodo C
nell'albero dal basso verso l'alto mostra ciascuno dei suoi chiamanti unici, i metodi B e D. Tieni presente
che, sebbene B chiami C due volte, B viene visualizzato una sola volta quando espandi il nodo per
il metodo C nell'albero dal basso verso l'alto. Dopodiché, espandendo il nodo per B vengono visualizzati
il chiamante e i metodi A e D.
La scheda Dal basso verso l'alto è utile per ordinare metodi o funzioni in base a quelli che
consumano più (o meno) tempo di CPU. Puoi esaminare ogni nodo per determinare
quali chiamanti utilizzano la maggior parte del tempo di CPU per richiamare questi metodi o funzioni.
Rispetto alla struttura ad albero dall'alto verso il basso, le informazioni sul timing per ogni metodo o funzione in una struttura ad albero dal basso verso l'alto fanno riferimento al metodo nella parte superiore di ogni struttura (nodo principale).
Il tempo CPU è rappresentato anche come percentuale del tempo totale del thread durante
la registrazione. La tabella seguente spiega come interpretare le informazioni
sulla tempistica per il nodo principale e i relativi chiamanti (nodi secondari).
|
Me stesso |
Bambini |
Totale |
Metodo o funzione nella parte superiore dell'albero bottom-up (nodo principale) |
Rappresenta il tempo totale impiegato dal metodo o dalla funzione per eseguire
il proprio codice e non quello dei chiamati. Rispetto all'albero
dall'alto verso il basso, queste informazioni sulle tempistiche rappresentano la somma di tutte le chiamate a questo
metodo o funzione per tutta la durata della registrazione.
|
Rappresenta il tempo totale impiegato dal metodo o dalla funzione per eseguire
i chiamati e non il proprio codice. Rispetto all'albero dall'alto verso il basso,
queste informazioni sul timing rappresentano la somma di tutte le chiamate ai chiamati di questo metodo o funzione per la durata della registrazione.
|
La somma del tempo di utilizzo personale e del tempo di utilizzo degli account secondari.
|
Chiamanti (nodi secondari) |
Rappresenta il tempo totale di esecuzione del codice del destinatario quando viene chiamato
dal chiamante. Utilizzando l'albero dal basso verso l'alto nella Figura 6 come esempio,
il tempo proprio del metodo B sarebbe uguale alla somma dei tempi propri
per ogni esecuzione del metodo C quando viene chiamato da B.
|
Rappresenta il tempo totale dei figli del destinatario quando viene
richiamato dal chiamante. Utilizzando l'albero dal basso verso l'alto nella Figura 6 come esempio, il tempo dei figli per il metodo B sarebbe uguale alla somma dei tempi dei figli per ogni esecuzione del metodo C quando viene chiamato da B.
|
La somma del tempo di utilizzo personale e del tempo di utilizzo degli account secondari.
|
Nota:per una determinata registrazione, Android Studio interrompe la raccolta di nuovi dati
quando il profiler raggiunge il limite di dimensione del file (tuttavia, ciò non interrompe la
registrazione). In genere, questo avviene molto più rapidamente quando vengono eseguite
tracce strumentate, perché questo tipo di tracciamento raccoglie più dati in un periodo di tempo più breve rispetto a una traccia campionata. Se estendi il tempo di ispezione a un periodo della registrazione successivo al raggiungimento del limite, i dati di temporizzazione nel riquadro della traccia non cambiano (perché non sono disponibili nuovi dati). Inoltre,
il riquadro della traccia mostra NaN per le informazioni sul timing quando selezioni solo
la parte di una registrazione per cui non sono disponibili dati.
I campioni di contenuti e codice in questa pagina sono soggetti alle licenze descritte nella Licenza per i contenuti. Java e OpenJDK sono marchi o marchi registrati di Oracle e/o delle sue società consociate.
Ultimo aggiornamento 2025-07-27 UTC.
[[["Facile da capire","easyToUnderstand","thumb-up"],["Il problema è stato risolto","solvedMyProblem","thumb-up"],["Altra","otherUp","thumb-up"]],[["Mancano le informazioni di cui ho bisogno","missingTheInformationINeed","thumb-down"],["Troppo complicato/troppi passaggi","tooComplicatedTooManySteps","thumb-down"],["Obsoleti","outOfDate","thumb-down"],["Problema di traduzione","translationIssue","thumb-down"],["Problema relativo a esempi/codice","samplesCodeIssue","thumb-down"],["Altra","otherDown","thumb-down"]],["Ultimo aggiornamento 2025-07-27 UTC."],[],[],null,["# Top down and bottom up charts\n\nThe **Top Down** tab displays a list of calls in which expanding a method or\nfunction node displays its callees. Figure 2 shows a top down graph for the\nfollowing call chart. Each arrow in the graph points from a caller to a callee.\n\n\n**Figure 1.** An example call chart that illustrates\nself, children, and total time for method D.\n\n\u003cbr /\u003e\n\nAs shown in Figure 2, expanding the node for method A in the **Top Down** tab\ndisplays its callees, methods B and D. After that, expanding the node for method\nD exposes its callees, such as methods B and C. Similar to the\n[**Flame chart**](/studio/profile/chart-glossary/flame-chart) tab, the top down\ntree aggregates trace information for identical methods that share the same call\nstack. That is, the **Flame chart** tab provides a graphical representation of\nthe **Top Down** tab.\n\nThe **Top Down** tab provides the following information to help describe CPU\ntime spent on each call (times are also represented as a percentage of the\nthread's total time over the selected range):\n\n- **Self:** the time the method or function call spent executing its own code and not that of its callees, as illustrated in Figure 1 for method D.\n- **Children:** the time the method or function call spent executing its callees and not its own code, as illustrated in Figure 1 for method D.\n- **Total:** the sum of the method's **Self** and **Children** time. This represents the total time the app spent executing a call, as illustrated in Figure 1 for method D.\n\n**Figure 2.** A Top Down tree.\n\n\u003cbr /\u003e\n\n**Figure 3.** A Bottom Up tree for method C from\nFigure 5.\n\n\u003cbr /\u003e\n\nThe **Bottom Up** tab displays a list of calls in which expanding a function or\nmethod's node displays its callers. Using the example trace shown in Figure 2,\nfigure 3 provides a bottom up tree for method C. Opening the node for method C\nin the bottom up tree displays each of its unique callers, methods B and D. Note\nthat, although B calls C twice, B appears only once when expanding the node for\nmethod C in the bottom up tree. After that, expanding the node for B displays\nits caller, methods A and D.\n\nThe **Bottom Up** tab is useful for sorting methods or functions by those that\nconsume the most (or least) CPU time. You can inspect each node to determine\nwhich callers spend the most CPU time invoking those methods or functions.\nCompared to the top down tree, timing info for each method or function in a\nbottom up tree is in reference to the method at the top of each tree (top node).\nCPU time is also represented as a percentage of the thread's total time during\nthat recording. The following table helps explain how to interpret timing\ninformation for the top node and its callers (sub-nodes).\n\n| | Self | Children | Total |\n| Method or function at the top of the bottom up tree (top node) | Represents the total time the method or function spent executing its own code and not that of its callees. Compared to the top down tree, this timing information represents a sum of all calls to this method or function over the duration of the recording. | Represents the total time the method or function spent executing its callees and not its own code. Compared to the top down tree, this timing information represents the sum of all calls to this method or function's callees over the duration of the recording. | The sum of the self time and children time. |\n| Callers (sub-nodes) | Represents the total self time of the callee when being called by the caller. Using the bottom up tree in Figure 6 as an example, the self time for method B would equal the sum of the self times for each execution of method C when called by B. | Represents the total children time of the callee when being invoked by the caller. Using the bottom up tree in Figure 6 as an example, the children time for method B would equal the sum of the children times for each execution of method C when called by B. | The sum of the self time and children time. |\n|----------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------------------------------------------|\n\n\n**Note:** For a given recording, Android Studio stops collecting new data\nwhen the profiler reaches the file size limit (however, this does not stop the\nrecording). This typically happens much more quickly when performing\ninstrumented traces because this type of tracing collects more data in a shorter\ntime, compared to a sampled trace. If you extend the inspection time into a\nperiod of the recording that occurred after reaching the limit, timing data in\nthe trace pane does not change (because no new data is available). Additionally,\nthe trace pane displays **NaN** for timing information when you select only\nthe portion of a recording that has no data available."]]