natgillin/translations-raw huggingface dataset:
Most known is the GCC profiling tool gprof: one needs to compile the program with option -pg; running the program generates a file gmon. out, which can be transformed into human-readable form with gprof. One disadvantage is the required re-compilation step to prepare the executable, which has to be statically linked. The method used here is compiler-generated instrumentation, which measures call arcs happening among functions and corresponding call counts, in conjunction with & TBS;, which gives a histogram of time distribution over the code. Using both pieces of information, it is possible to heuristically calculate inclusive time of functions, & ie; time spent in a function together with all functions called from it.
Tuntuim sellistest tööriistadest on GCC profileerimistööriist gprof. Selle kasutamiseks tuleb programm kompileerida võtmega - pg, misjärel programmi käivitamine tekitab faili gmon. out, mille käsuga gprof saab muuta inimsilmale arusaadavale kujule. Puuduseks on aga vajadus kasutada kompileerimist, et ette valmistada käivitatav fail, mis peab olema staatiliselt lingitud. Meie kasutame kompilaatori genereeritud instrumentatsiooni, mis mõõdab funktsioonides esinevaid väljakutseteid ja arvestab vastavalt väljakutseid, koos TBS- iga, mis tagab koodi ajajaotuse histogrammi. Nende kahe infokogumi põhjal saab heuristiliselt arvutada funktsioonide kumulatiivset aega, & ie; aega, mis veedetakse funktsioonis koos kõigi sellest välja kutsutud funktsioonidega.
For exact measurement of events happening, libraries exist with functions able to read out hardware performance counters. Most known here is the PerfCtr patch for & Linux;, and the architecture independent libraries PAPI and PCL. Still, exact measurement needs instrumentation of code, as stated above. Either one uses the libraries itself or uses automatic instrumentation systems like ADAPTOR (for FORTRAN source instrumentation) or DynaProf (code injection via DynInst).
Sündmuste toimumise täppismõõtmiseks on olemas selliste funktsioonidega teegid, mis suudavad lugeda riistvaraliste loendurite andmeid. Tuntumad neist on PerfCtr & Linux; jaoks ja arhitektuurist sõltumatud PAPI ning PCL teegid. Täppismõõtmine vajab siiski koodi instrumentatsiooni, nagu juba eespool märgitud. Teekide puhta kasutamise asemel võib kasutada ka automaatse instrumentatsiooni süsteeme, nagu ADAPTOR (FORTRAN- i lähtekoodi instrumentatsioon) või DynaProf (koodi sisestamine DynInst' i vahendusel).
& oprofile; is a system-wide profiling tool for & Linux; using Sampling.
& oprofile; on diskreetimist kasutav & Linux; süsteemse profileerimise tööriist.
In many aspects, a comfortable way of Profiling is using & cachegrind; or & callgrind;, which are simulators using the runtime instrumentation framework & valgrind;. Because there is no need to access hardware counters (often difficult with today's & Linux; installations), and binaries to be profiled can be left unmodified, it is a good alternative to other profiling tools. The disadvantage of simulation - slowdown - can be reduced by doing the simulation on only the interesting program parts, and perhaps only on a few iterations of a loop. Without measurement/ simulation instrumentation, & valgrind; 's usage only has a slowdown factor in the range of 3 to 5. Also, when only the call graph and call counts are of interest, the cache simulator can be switched off.
Mitmes mõttes on profileerimiseks väga mugav kasutada & cachegrind; i või & callgrind; i, mis on käitusinstrumentatsiooni raamistikku & valgrind; kasutavad simulaatorid. Et nende puhul pole vaja ligipääsu riistvaralistele loenduritele (see on tänapäeva & Linux; distributsioonide puhul sageli keeruline) ning profileeritavad binaarfailid saab jätta muutmata, on need heaks alternatiiviks muudele profileerimistööriistadele. Simulatsiooni miinuspoole - aegluse - saab osaliselt kompenseerida simulatsiooni ainult huvipakkuvates programmide osades ning isegi võib- olla ainult silmuste mõningates kordustes ette võttes. Mõõtmis/ simulatsiooniinstrumentatsioonita on Valgrindi aegluskoefitsient kõigest vahemikus 3 kuni 5. Pealegi võib juhul, kui sulle pakub huvi ainult väljakutsete graafik ja väljakutsete loendamine, lülitada välja vahemälu simulaatori.
Cache simulation is the first step in approximating real times, since runtime is very sensitive to the exploitation of so-called caches, small and fast buffers which accelerate repeated accesses to the same main memory cells, on modern systems. & cachegrind; does cache simulation by catching memory accesses. The data produced includes the number of instruction/ data memory accesses and first- and second-level cache misses, and relates it to source lines and functions of the run program. By combining these miss counts, using miss latencies from typical processors, an estimation of spent time can be given.
Vahemälu simulatsioon on esimene samm reaalaja hindamisel, kuivõrd tänapäevaste süsteemide korral on käitus äärmiselt tundlik niinimetatud vahemälu (väikesed ja kiired puhvrid, mis kiirendavad korduvaid pöördumisi ühtede ja samade mälupesade poole) kasutamisele. & cachegrind; simuleerib vahemälu mällupöördumisi jälitades. Saadud andmed hõlmavad instruktsioonide ja andmete mällupöördumiste ning 1. ja 2. taseme vahemälu vajakute arvu ja seondavad need käivitatava programmi lähteridade ja funktsioonidega. Tüüpiliste protsessorite vajakute latentsusaega kasutades saab vajakuid kombineerides hinnata kulunud aega.
& callgrind; is an extension of & cachegrind; that builds up the call graph of a program on-the-fly, & ie; how the functions call each other and how many events happen while running a function. Also, the profile data to be collected can separated by threads and call chain contexts. It can provide profiling data on an instruction level to allow for annotation of disassembled code.
& callgrind; on & cachegrind; i laiend, mis loob käigult programmi väljakutsete graafiku, & ie; näitab, millised funktsioonid milliseid välja kutsuvad ja kui palju sündmusi funktsiooni töö ajal ette tuleb. Lisaks saab profileerimisandmeid koondada eraldi lõimedesse ja väljakutsete ahelatesse. See pakub profileerimisandmeid instruktsiooni tasemel, mis lubab dissambleeritud koodi annoteerimist.
Visualization
Kuvamine
Profiling tools typically produce a large amount of data. The wish to easily browse down and up the call graph, together with fast switching of the sorting mode of functions and display of different event types, motivates a & GUI; application to accomplish this task.
Profileerimistööriistad loovad tüüpiliselt päris palju andmeid. Soov võimalikult vähese vaevaga väljakutsete graafikus liikuda ning kiiresti lülituda funktsioonide sorteerimise režiimide ja erinevate sündmusetüüpide näitamise vahel ongi motiveerinud selleks kõige paremini sobivate graafiliste kasutajaliideste loomist.
& kappname; is a visualization tool for profile data fulfilling these wishes. Despite being programmed first with browsing the data from & cachegrind; and & calltree; in mind, there are converters available to be able to display profile data produced by other tools. In the appendix, a description of the & cachegrind; /callgrind; file format is given.
& kappname; on nende soovide täitja, võimaldades kuvada profileerimisandmeid. Kuigi algselt loodi see & cachegrind; i ja & calltree; andmete võimalikult hõlpsat sirvimist silmas pidades, on olemas konverterid, mis suudavad näidata ka muude tööriistade profileerimisandmeid. Lisas kirjeldame ka & cachegrind; i/ callgrind; i failivormingut.
Besides a list of functions sorted according exclusive or inclusive cost metrics, and optionally grouped by source file, shared library or C++ class, & kappname; features various views for a selected function, namely:
Lisaks funktsioonide nimekirjale, mida saab sorteerida kas tavalise või kumulatiivse kulu järgi ning rühmitada ka lähtefaili, jagatud teegi või C++- klassi järgi, pakub & kappname; valitud funktsiooni korral veel mitmeid vaateid, nimelt
a tree-map view, which allows nested-call relations to be visualized, together with inclusive cost metric for fast visual detection of problematic functions,
puukaardivaade, mis näitab pesastatud väljakutsete seoseid, samuti kumulatiivset kulu, mis võimaldab kiiresti visuaalselt tuvastada problemaatilised funktsioonid,
Generate Data to Visualize
Kuvatavate andmete tekitamine
First, one wants to generate performance data by measuring aspects of the runtime characteristics of an application, using a profiling tool. & kcachegrind; itself does not include any profiling tool, but is good in being used together with & callgrind;, and by using a converter, also can be used to visualize data produced with & oprofile;. Although the scope of this manual is not to document profiling with these tools, the next section provides short quickstart tutorials to get you started.
Kõik, kes jõudlust hinnata soovivad, tahavad mõistagi näha vastavaid andmeid, mõõtes profileerimistööriistaga rakenduse käituskarakteristika aspekte. & kcachegrind; ei paku omalt poolt ühtki profileerimistööriista, kuid tuleb sellega ometi hästi toime koostöös & callgrind; iga ning suudab konverteri vahendusel kuvada ka & oprofile; 'i loodud andmeid. Kuigi käesolev käsiraamat ei ole pühendatud nende tööriistade põhjalikule tutvustamisele, räägime järgnevalt siiski neist lühidalt.
& callgrind; is a part of valgrind;. Note that it previously was called & calltree;, but that name was misleading.
& callgrind; kuulub valgrind; i koosseisu. Pane tähele, et varem nimetati seda & calltree; 'ks, aga see nimi oli eksitav.
The most common use is to prefix the command line to start your application with valgrind --tool=callgrind, as in: valgrind --tool=callgrind myprogram myargs At program termination, a file callgrind. out. pid will be generated, which can be loaded into & kcachegrind;.
Kõige levinum on selle kasutamiseks käivitada rakendus käsurealt käsuga valgrind -- tool=callgrind, näiteks valgrind -- tool=callgrind myprogram myargs Programmi töö lõppemisel luuakse fail callgrind. out. pid, mille saab laadida & kcachegrind; i.
More advanced use is to dump out profile data whenever a given function of your application is called. E. g. for & konqueror;, to see profile data only for the rendering of a Web page, you could decide to dump the data whenever you select the menu item View Reload. This corresponds to a call to KonqMainWindow: :slotReload. Use: valgrind --tool=callgrind --dump-before=KonqMainWindow: :slotReload konqueror This will produce multiple profile data files with an additional sequential number at the end of the filename. A file without such an number at the end (only ending in the process PID) will also be produced; by loading this file into & kcachegrind;, all others are loaded too, and can be seen in the Parts Overview and Parts list.
Veidi täiustatum viis on salvestada välja profileerimisandmed rakenduste määratud funktsiooni väljakutsumisel. Näiteks & konqueror; i korral ainult veebilehekülje renderdamise profileerimisandmete nägemiseks võib lasta andmed salvestada ainult siis, kui valitakse menüükäsk Vaade Laadi uuesti. See vastab väljakutsele KonqMainWindow:: slotReload, milleks kasuta käsku valgrind -- tool=callgrind -- dump- before=KonqMainWindow:: slotReload konqueror See loob rea profileerimisandmete faile, mille nimele lisatakse lõppu järjestikku kasvavad numbrid. Luuakse ka ilma sellise numbrita fail, mille nime lõpus on ainult protsessi PID - selle faili avamisel & kcachegrind; is avatakse ka teised ning neid võib näha osade ülevaates ja osade nimekirjas.
& oprofile; is available from its home page. Follow the installation instructions on the Web site, but, before you do, check whether your distribution does not already provide it as package (like & SuSE;).
& oprofile; 'i leiab selle koduleheküljelt. Järgi paigaldamiseks veebileheküljel toodud juhiseid, aga enne seda võiksid kontrollida, ega sinu distributsioon juba seda valmispakituna ei paku (nagu teeb näiteks & SuSE;).
System-wide profiling is only permitted to the root user, as all actions on the system can be observed; therefore, the following has to be done as root. First, configure the profiling process, using the & GUI; oprof_start or the command-line tool opcontrol. Standard configuration should be timer mode (TBS;, see introduction). To start the measurement, run opcontrol -s. Then run the application you are interested in and, afterwards, do a opcontrol -d. This will write out the measurement results into files under folder / var/ lib/ oprofile/ samples/. To be able to visualize the data in & kcachegrind;, do in an empty directory: opreport -gdf _BAR_ op2callgrind This will produce a lot of files, one for every program which was running on the system. Each one can be loaded into & kcachegrind; on its own.
Süsteemne profileerimine on lubatud ainult administraatorile (root), kes ainsana saab jälgida kogu süsteemis toimuvat. Seepärast tuleb kõike järgnevat sooritada administraatori õigustes. Esmalt seadista profileerimisprotsess, kasutades graafilist kasutajaliidest oprof_ start või käsureatööriista opcontrol. Standardseadistus peaks olema taimerirežiim (TBS, vaata selle kohta sissejuhatust). Mõõtmise käivitamiseks anna käsk opcontrol - s. Seejärel käivita vajalik rakendus ning anna hiljem käsk opcontrol - d. See kirjutab mõõtmistulemused failidena kataloogi / var/ lib/ oprofile/ samples /. Andmete kuvamiseks & kcachegrind; is anna tühjas kataloogis käsk: opreport - gdf _BAR_ op2callgrind See tekitab hulga faile - üks iga süsteemis töötava programmi kohta. Kõik need saab ükshaaval & kcachegrind; is avada.
When starting & kcachegrind; with a profile data file as argument, or after loading one with File Open, you will see a navigation panel containing the function list at the left; and, on the right the main part, an area with views for a selected function. This view area can be arbitrarily configured to show multiple views at once.
Kui käivitada & kcachegrind; käsurealt profiiliandmetega või avada need menüükäsuga Fail Ava..., näed vasakul külgriba funktsioonide nimekirjaga ning paremal, põhiosas, kuvatakse valitud funktsiooni. Vaateala on jagatud mitmeks, et näidata korraga mitut erinevat vaadet.
At first start, this area will be divided into a top and a bottom part, each with different tab-selectable views. To move views, use the tabs' context menu, and adjust the splitters between views. To switch quickly between different viewing layouts, use Ctrl; → View Layout Go to Next and Ctrl; ← View Layout Go to Previous.
Algul on ala jagatud ülemiseks ja alumiseks pooleks, mõlemas omad sakkidega valitavad vaated. Vaadete liigutamiseks kasuta sakkide kontekstimenüüd ning kohenda vaadetevahelisi eraldajaid. Kiireks lülitumiseks vaadete vahel kasuta Ctrl; → Vaade Paigutus Liigu järgmisele ja Ctrl; ← Vaade Paigutus Liigu eelmisele.
The active event type is important for visualization: for & callgrind;, this is, for example, cache misses or cycle estimation; for & oprofile;, this is Timer in the simplest case. You can change the event type via a combobox in the toolbar or in the Event Type view. A first overview of the runtime characteristics should be given when you select function main in the left list; look then at the call graph view. There, you see the calls occurring in your program. Note that the call graph view only shows functions with high event count. By double-clicking a function in the graph, it will change to show the called functions around the selected one.
Kuvamisel on oluline aktiivne sündmuse tüüp: & callgrind; i korral on need näiteks vahemälu vajakud või tsükli hinnang, & oprofile; 'i korral lihtsaimal juhul taimer. Sündmuse tüüpi saab muuta liitkastis tööriistaribal või sündmuse tüübbi vaates. Esimese ülevaate käituskarakteristikast saab vasakul nimekirjas funktsiooni main valides ning väljakutsete graafiku kuva uurides: nii näed, mis sinu programmis tegelikult toimub. Pane tähele, et väljakutsete graafiku vaates näidatakse ainult suurte sündmuste arvuga funktsioone. Graafikus mõnel funktsioonil topeltklõpsu tehes see muutub ning näitab väljakutsutud funktsioone valitud funktsiooni lähikonnas.
To explore the & GUI; further, in addition to this manual, also have a look at the documentation section on the Web site. Also, every widget in & kcachegrind; has What's this help.
Graafilise kasutajaliidese põhjalikumaks tundmaõppimiseks tasuks lisaks käesolevale käsiraamatule tutvuda dokumentatsiooniga veebileheküljel. Lisaks sellele pakub iga & kcachegrind; i element abivõimalust Mis see on?
Cost counts of event types (like L2 Misses) are attributed to cost entities, which are items with relationship to source code or data structures of a given program. Cost entities not only can be simple code or data positions, but also position tuples. For example, a call has a source and a target, or a data address can have a data type and a code position where its allocation happened.
Sündmuste tüüpide (näiteks L2 vajakute) kuluarvestus omistatakse kuluolemitele, mis on seotud antud programmi lähtekoodi või andmestruktuuridega. Kuluolemid ei pruugi olla lihtsalt koodi - või andmepositsioonid, need võivad olla ka positsioonijärjendid. Nii on näiteks väljakutsel allikas ja sihtmärk, andmeaadressil aga andmetüüp ja koodipositsioon, kus eraldus aset leiab.
Positions tuples: Call from instruction address to target function. Call from source line to target function. Call from source function to target function. (Un)conditional jump from source to target instruction. (Un)conditional jump from source to target line. Jumps between functions are not allowed, as this makes no sense in a call graph; thus, constructs like exception handling and long jumps in C have to be translated to popping the call stack as needed.
Positsioonijärjendid: Väljakutse instruktsiooniaadressilt sihtfunktsioonile. Väljakutse lähtekoodi realt sihtfunktsioonile. Väljakutse lähtekoodi funktsioonilt sihtfunktsioonile. Tingimuslik/ tingimusteta hüpe lähtekoodist sihtinstruktsioonile. Tingimuslik/ tingimusteta hüpe lähtekoodist sihtreale. Hüpped funktsioonide vahel ei ole lubatud, sest neil ei ole ka väljakutsete graafikul mingit mõtet. Sestap tuleb sellised konstruktsioonid, nagu eranditöötlus ja C- keelele omased pikad hüpped vajaduse korral transleerida väljakutsete pinus.
Event types whose costs are specified in a profile data file are called real events. Additionally, one can specify formulas for event types calculated from real events, which are called inherited events.
Sündmuste tüüpe, mille kulu on määratletud profileerimisandmete failis, nimetatakse reaalseteks sündmusteks. Lisaks võib määrata viisi, kuidas tuletatakse reaalsetest sündmustest muid sündmuste tüüpe. Viimaseid nimetatakse järglassündmusteks.
Visualization State
Kuvamisolek
The visualization state of a & kcachegrind; window includes: the primary and secondary event type chosen for display, the function grouping (used in the Function Profile list and entity coloring), the profile parts whose costs are to be included in visualization, an active cost entity (eg; a function selected from the function profile sidedock), a selected cost entity. This state influences the views.
& kcachegrind; i akna kuvamisolek näitab: esmast ja sekundaarset sündmuse tüüpi, funktsiooni rühmitust (kasutusel funktsiooni profiili nimekirjas ja olemi värvimisel), profiili osasid, mille kulu kuva arvestab, aktiivset kuluolemit (eg; funktsiooni profiili külgdokilt valitud funktsiooni), valitud kuluolemit. See olek mõjutab kuva.
Views are always shown for one cost entity, the active one. When a given view is inappropriate for a cost entity, it is disabled: when selecting & eg; an & ELF; object in the group list, source annotation makes no sense.
Vaade näitab alati üht, aktiivset kuluolemit. Kui kuluolemi korral ei ole kuvamine võimalik, siis seda ka ei näidata (eg; kui valid rühmituse nimekirjas topeltklõpsuga & ELF; - objekti, ei ole & ELF; - objekti korral kuidagi võimalik lähtekoodi annotatsioon).
For example, for an active function, the callee list shows all the functions called from the active one: one can select one of these functions without making it active. Also, if the call graph is shown beside, it will automatically select the same function.
Nii näitab aktiivse funktsiooni korral väljakutsutute nimekiri kõiki funktsioone, mida aktiivne funktsioon välja kutsub. Nende seast võib valida mõne seda aktiivseks muutmata. Kui väljakutsete graafikut näidatakse selle kõrval, valib see automaatselt sama funktsiooni.
Parts of the & GUI;
Graafilise kasutajaliidese komponendid
Sidedocks are side windows which can be placed at any border of a & kcachegrind; window. They always contain a list of cost entities sorted in some way.
Külgdokid ehk külgribad on aknad, mida võib seada mis tahes & kcachegrind; i peaakna serva. Need näitavad alati mingi reegli kohaselt sorteeritud kuluolemite nimekirja.
The Function Profile is a list of functions showing inclusive and exclusive cost, call count, name and position of functions.
Funktsiooni profiil on funktsioonide nimekiri, mis näitab kumulatiivset ja omakulu, väljakutsete arvu, funktsioonide nime ja asukohta.
View Area
Vaateala
The view area, typically the right part of a & kcachegrind; main window, is made up of one (default) or more tabs, lined up either horizontally or vertically. Each tab holds different views of only one cost entity at a time. The name of this entity is given at the top of the tab. If there are multiple tabs, only one is active. The entity name in the active tab is shown in bold, and determines the active cost entity of the & kcachegrind; window.
Vaateala, mis tavaliselt moodustab & kcachegrind; i peaakna parempoolse osa, koosneb ühest (vaikimisi) või enamast kaardist, mis on korraldatud kas rõhtsalt või püstiselt. Iga kaart näitab korraga ainult ühe kuluolemi vaadet. Olemi nime näeb kaardi ülaosas. Kui kaarte on palju, saab korraga ometi olla neist aktiivne ainult üks. Aktiivse kaardi olemi nime näidatakse rasvases kirjas ning see määrab ka & kcachegrind; i akna aktiivse kuluolemi.
Areas of a Tab
Kaardi alad
Each tab can hold up to four view areas, namely Top, Right, Left, and Bottom. Each area can hold multiple stacked views. The visible part of an area is selected by a tab bar. The tab bars of the top and right area are at the top; the tab bars of the left and bottom area are at the bottom. You can specify which kind of view should go into which area by using the tabs' context menus.
Igal kaardil võib olla kuni neli vaateala, nimelt üleval, paremal, vasakul ja all. Igas alas võib olla mitu kaartidele eraldatud vaadet. Nähtava vaate saab valida kaardirealt. Ülemise ja parempoolse ala kaardiribad asuvad üleval, vasakpoolse ja alumise ala omad all. Selle, milline vaade on millisel alal, saab määrata kaartide kontekstimenüüst.
Synchronized View with Selected Entity in a Tab
Vaate sünkroniseerimine kaardil olemi valimisega
Besides an active entity, each tab has a selected entity. As most view types show multiple entities with the active one somehow centered, you can change the selected item by navigating inside a view (by clicking with the mouse or using the keyboard). Typically, selected items are shown in a highlighted state. By changing the selected entity in one of the views of a tab, all other views highlight the new selected entity accordingly.
Aktiivse olemi kõrval on igal kaardil ka valitud olem. Kuna enamik vaatetüüpe näitab mitmeid olemeid, seades mingil moel keskmesse aktiivse, saab valitud elementi vahetada vaate sees liikudes (hiireklõpsuga või klaviatuuri abil). Tavaliselt on valitud elemendid ka esile tõstetud. Valitud olemi muutmisel mõnes kaardi vaates tõstavad sama kaardi muud vaated samuti automaatselt esile uue valitud olemi.
Synchronization between Tabs
Sünkroniseerimine kaartide vahel
If there are multiple tabs, a selection change in one tab leads to an activation change in the next tab, be it right of the former or under it. This kind of linkage should, for example, allow for fast browsing in call graphs.
Mitme kaardi korral toob valiku muutmine ühel kaardil kaasa muutuse järgmisel kaardil (suunaga paremale/ alla). Selline sidumine võimaldab näiteks kiiresti lehitseda väljakutsete graafikuid.