traceview - Online sa Cloud

PROGRAMA:

NAME

traceview - isang graphical viewer para sa mga execution log na na-save ng Android application.

SINOPSIS

traceview [-r] bakas

DESCRIPTION

Ang Traceview ay isang graphical na viewer para sa mga execution log na ginawa mo sa pamamagitan ng paggamit ng Debug
klase upang mag-log ng impormasyon sa pagsubaybay sa iyong code. Matutulungan ka ng Traceview na i-debug ang iyong
application at profile ang pagganap nito.

Opsyon

-r regression lamang

TRACEVIEW Layout

Kapag mayroon kang trace log file (binuo sa pamamagitan ng pagdaragdag ng tracing code sa iyong application o ni
DDMS), maaari mong i-load sa Traceview ang mga log file at ipakita ang kanilang data sa isang window
nakikita ang iyong aplikasyon sa dalawang panel:

Isang panel ng timeline - naglalarawan kung kailan nagsimula at huminto ang bawat thread at pamamaraan.

Isang profile panel - nagbibigay ng buod ng nangyari sa loob ng isang paraan.

Ang mga seksyon sa ibaba ay nagbibigay ng karagdagang impormasyon tungkol sa mga pane ng output ng traceview.

timeline Panel
Ang execution ng bawat thread ay ipinapakita sa sarili nitong row, na may pagtaas ng oras sa kanan. Bawat isa
Ang pamamaraan ay ipinapakita sa ibang kulay (ang mga kulay ay muling ginagamit sa isang round-robin na paraan na nagsisimula sa
ang mga pamamaraan na may pinakamaraming oras). Ang mga manipis na linya sa ilalim ng unang hilera
ipakita ang lawak (pagpasok upang lumabas) ng lahat ng mga tawag sa napiling paraan. Ang pamamaraan sa
ang kasong ito ay LoadListener.nativeFinished() at ito ay pinili sa view ng profile.

Profile Panel
Ang view na ito ay nagpapakita ng buod ng lahat ng oras na ginugol sa isang paraan. Ipinapakita ng talahanayan ang parehong
inklusibo at eksklusibong mga oras (pati na rin ang porsyento ng kabuuang oras). Eksklusibo
ang oras ay ang oras na ginugol sa pamamaraan. Ang inclusive time ay ang oras na ginugol sa method plus
ang oras na ginugol sa anumang tinatawag na function. Tinutukoy namin ang mga paraan ng pagtawag bilang "mga magulang" at
tinatawag na mga pamamaraan bilang "mga bata." Kapag napili ang isang paraan (sa pamamagitan ng pag-click dito), lumalawak ito sa
ipakita sa mga magulang at mga anak. Ang mga magulang ay ipinapakita na may lilang background at mga bata
may dilaw na background. Ipinapakita ng huling column sa talahanayan ang bilang ng mga tawag dito
paraan kasama ang bilang ng mga recursive na tawag. Ipinapakita ng huling column ang bilang ng mga call out
ng kabuuang bilang ng mga tawag na ginawa sa paraang iyon. Sa ganitong pananaw, makikita natin na mayroon
14 na tawag sa LoadListener.nativeFinished(); ang pagtingin sa panel ng timeline ay nagpapakita na ang isa sa
ang mga tawag na iyon ay tumagal ng hindi karaniwang mahabang panahon.

TRACEVIEW FILE FORMAT

Ang pagsubaybay ay lumilikha ng dalawang natatanging piraso ng output: isang data file, na nagtataglay ng trace data,
at isang pangunahing file, na nagbibigay ng pagmamapa mula sa mga binary identifier hanggang sa thread at pamamaraan
mga pangalan. Ang mga file ay pinagsama kapag nakumpleto ang pagsubaybay, sa isang solong .trace file.

tandaan: Ang nakaraang bersyon ng Traceview ay hindi pinagsama-sama ang mga file na ito para sa iyo. kung ikaw
may mga lumang key at data file na gusto mo pa ring i-trace, maaari mong pagsamahin ang mga ito
ang iyong sarili sa pusa mytrace.key mytrace.data > mytrace.trace.

data talaksan format
Ang file ng data ay binary, nakaayos tulad ng sumusunod (lahat ng mga halaga ay naka-imbak sa maliit na endian
order):

* Format ng file:
* header
* record 0
* record 1
* ...
*
* Format ng header:
* u4 magic 0x574f4c53 ('SLOW')
* u2 na bersyon
* u2 offset sa data
* u8 petsa/oras ng pagsisimula sa usec
*
* Format ng record:
* u1 thread ID
* u4 method ID | pagkilos ng pamamaraan
* u4 time delta mula noong simula, sa usec

Inaasahang i-parse ng application ang lahat ng mga field ng header, pagkatapos ay hanapin na "i-offset sa
data" mula sa simula ng file. Mula doon ay nagbabasa lamang ito ng 9-byte na mga tala hanggang sa EOF ay
inabot

Ang petsa/oras ng pagsisimula ng u8 sa usec ay ang output mula sa gettimeofday(). Ito ay higit sa lahat kaya iyon
maaari mong malaman kung ang output ay nabuo kahapon o tatlong buwan na ang nakakaraan.

Ang pagkilos ng pamamaraan ay nasa dalawang pinakamaliit na bahagi ng salita ng pamamaraan. Ang kasalukuyang
ang mga tinukoy na kahulugan ay:

0 - pagpasok ng pamamaraan
1 - paraan ng paglabas
2 - paraan "lumabas" kapag na-unroll sa pamamagitan ng paghawak ng exception
3 - (nakareserba)

Ang isang unsigned na 32-bit integer ay maaaring tumagal ng humigit-kumulang 70 minuto ng oras sa microseconds.

Key talaksan format
Ang pangunahing file ay isang plain text file na nahahati sa tatlong seksyon. Ang bawat seksyon ay nagsisimula sa a
keyword na nagsisimula sa '*'. Kung makakita ka ng '*' sa simula ng isang linya, nakita mo ang
simula ng isang bagong seksyon.

Maaaring ganito ang hitsura ng isang halimbawang file:

*bersyon
1
orasan=global
* mga thread
1 pangunahing
6 JDWP Handler
5 Async GC
4 Tagapangasiwa ng Sanggunian
3 Finalizer
2 Tagapangasiwa ng Signal
*paraan
0x080f23f8 java/io/PrintStream write ([BII)V
0x080f25d4 java/io/PrintStream print (Ljava/lang/String;)V
0x080f27f4 java/io/PrintStream println (Ljava/lang/String;)V
0x080da620 java/lang/RuntimeException ()V
[...]
0x080f630c android/os/Debug startMethodTracing ()V
0x080f6350 android/os/Debug startMethodTracing (Ljava/lang/String;Ljava/lang/String;I)V
*tapos

Ang sumusunod na listahan ay naglalarawan sa mga pangunahing seksyon ng isang pangunahing file:

seksyon ng bersyon
Ang unang linya ay ang numero ng bersyon ng file, kasalukuyang 1. Ang pangalawang linya, clock=global,
ay nagpapahiwatig na gumagamit kami ng isang karaniwang orasan sa lahat ng mga thread. Ang isang bersyon sa hinaharap ay maaaring gumamit ng per-
thread CPU time counter na independyente para sa bawat thread.

seksyon ng mga thread
Isang linya bawat thread. Ang bawat linya ay binubuo ng dalawang bahagi: ang thread ID, na sinusundan ng a
tab, na sinusundan ng pangalan ng thread. Mayroong ilang mga paghihigpit sa kung ano ang isang wastong thread
pangalan ay, kaya isama ang lahat sa dulo ng linya.

seksyon ng mga pamamaraan
Isang linya sa bawat paraan ng pagpasok o paglabas. Ang isang linya ay binubuo ng apat na piraso, na pinaghihiwalay ng tab
mga marka: method-ID [TAB] class-name [TAB] method-name [TAB] signature. Tanging ang mga pamamaraan
na aktwal na ipinasok o lumabas ay kasama sa listahan. Tandaan na ang lahat ng tatlo
ang mga identifier ay kinakailangan upang natatanging makilala ang isang paraan.

Ang mga seksyon ng thread o pamamaraan ay hindi pinagsunod-sunod.

PAGLIKHA TRACE MGA FILE

Upang magamit ang Traceview, kailangan mong bumuo ng mga log file na naglalaman ng bakas na impormasyon na gusto mo
suriin.

Mayroong dalawang paraan upang makabuo ng mga trace log:

Isama ang Debug class sa iyong code at tawagan ang mga pamamaraan nito para simulan at ihinto ang pag-log ng
bakas ang impormasyon sa disk. Ang pamamaraang ito ay napaka-tumpak dahil maaari mong tukuyin sa iyong
eksaktong code kung saan magsisimula at huminto sa pag-log ng trace data.

Gamitin ang paraan ng pag-profile ng feature ng DDMS para makabuo ng mga trace log. Ang pamamaraang ito ay mas mababa
tumpak dahil hindi mo binabago ang code, ngunit sa halip ay tukuyin kung kailan magsisimula at huminto
pag-log sa isang DDMS. Bagama't mas kaunti ang iyong kontrol sa eksakto kung nasaan ang data
naka-log, ang paraang ito ay kapaki-pakinabang kung wala kang access sa code ng application, o
kung hindi mo kailangan ang katumpakan ng unang paraan.

Bago ka magsimulang bumuo ng mga trace log, magkaroon ng kamalayan sa mga sumusunod na paghihigpit:

Kung gumagamit ka ng Debug class, ang iyong device o emulator ay dapat may SD card at
ang iyong aplikasyon ay dapat may pahintulot na sumulat sa SD card.

Kung gumagamit ka ng DDMS, hindi sinusuportahan ang mga Android 1.5 na device.

Kung gumagamit ka ng DDMS, ang Android 2.1 at ang mga naunang device ay dapat na mayroong SD card
at ang iyong aplikasyon ay dapat may pahintulot na sumulat sa SD card.

Kung gumagamit ka ng DDMS, ang mga Android 2.2 at mas bagong device ay hindi nangangailangan ng SD card. Ang
Ang mga trace log file ay direktang ini-stream sa iyong development machine.

Upang gawin ang mga trace file, isama ang Debug class at tawagan ang isa sa
startMethodTracing() paraan. Sa tawag, tumukoy ka ng base na pangalan para sa mga trace file
na nabuo ng system. Upang ihinto ang pagsubaybay, tumawag stopMethodTracing(). Nagsisimula ang mga pamamaraang ito
at itigil ang paraan ng pagsubaybay sa buong virtual machine. Halimbawa, maaari kang tumawag
startMethodTracing() sa iyong aktibidad onCreate () paraan, at tawag stopMethodTracing() in
ang aktibidad na iyon onDestroy () pamamaraan.

// simulan ang pagsubaybay sa "/sdcard/calc.trace"
Debug.startMethodTracing("calc");
// ...
// itigil ang pagsubaybay
Debug.stopMethodTracing();

Kapag tumawag ang iyong aplikasyon startMethodTracing(), lumilikha ang system ng isang file na tinatawag na
.bakas. Naglalaman ito ng binary method na trace data at isang mapping table
na may mga pangalan ng thread at pamamaraan.

Pagkatapos ay magsisimulang i-buffer ng system ang nabuong trace data, hanggang sa tumawag ang iyong application
stopMethodTracing(), kung kailan isinusulat nito ang buffered data sa output file. Kung ang
naabot ng system ang maximum na laki ng buffer bago stopMethodTracing() ay tinatawag na, ang sistema
huminto sa pagsubaybay at nagpapadala ng notification sa console.

Ang na-interpret na code ay tatakbo nang mas mabagal kapag pinagana ang pag-profile. Huwag subukang bumuo
ganap na timing mula sa mga resulta ng profiler (ibig sabihin, "ang function X ay tumatagal ng 2.5 segundo upang tumakbo").
Ang mga oras ay kapaki-pakinabang lamang na may kaugnayan sa iba pang output ng profile, upang makita mo kung nagbabago
ginawang mas mabilis o mas mabagal ang code.

Kapag gumagamit ng Android emulator, dapat kang tumukoy ng SD card kapag ginawa mo ang iyong AVD
dahil ang mga trace file ay nakasulat sa SD card. Dapat may pahintulot ang iyong aplikasyon
para magsulat din sa SD card.

PAGKOPYA TRACE MGA FILE SA A HOST MACHINE

Matapos tumakbo ang iyong application at nilikha ng system ang iyong mga trace file
.trace sa isang device o emulator, dapat mong kopyahin ang mga file na iyon sa iyong
pagpapaunlad ng kompyuter. Maaari mong gamitin ang adb pull upang kopyahin ang mga file. Narito ang isang halimbawa na nagpapakita
kung paano kopyahin ang isang halimbawang file, calc.trace, mula sa default na lokasyon sa emulator hanggang sa
/ Tmp direktoryo sa emulator host machine:

adb pull /sdcard/calc.trace / Tmp

COPYRIGHT

Ang manu-manong page na ito ay lisensyado sa ilalim ng Apache License, Bersyon 2.0.

Copyright (C) 2013 Android Open Source Project

Copyright (C) 2013 Jakub Adamjakub.adam@ktknet.cz>

Gamitin ang traceview online gamit ang mga serbisyo ng onworks.net