natgillin/translations-raw huggingface dataset:
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; as, on modern systems, 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.) & cachegrind; does cache simulation by catching memory accesses. The data produced includes the number of instruction/ data memory accesses and 1st/ 2nd 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.
Visualisation
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 an visualisation 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 visualisation 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 call-graph view, which shows a section of the call graph around the selected function,
väljakutsete graafiku vaade, mis näitab väljakutsete graafiku osa valitud funktsiooni piirkonnas,
a tree-map view, which allows nested-call relations to be visualised, 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,
source code and disassembler annotation views, allowing to see details of cost related to source lines and assembler instructions.
lähtekoodi ja disassembleri annotatsioonivaade, mis võimaldab näha kuludetaile lähtekoodi ridade ja assembleri instruktsioonide suhtes.
Using & kcachegrind;
& kcachegrind; i kasutamine
Generate Data to Visualise
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 visualise 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 available from http: / /kcachegrind. sf. net. 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.
Most common use is to prefix the command line to start your application with callgrind, like in 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 rendering 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 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 http: / /oprofile. sf. net. Follow the installation instructions on the web site; but, before you do, check if 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 directory / var/ lib/ oprofile/ samples/. To be able to visualise 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.
User Interface Basics
Kasutajaliidese põhitõed
When starting & kcachegrind; with a profile data file as argument, or after loading one with File/ Open, you will see a sidebar containing the function list at the left; and, on the right the main part, an area with visualisations for a selected function. This visualisation area can be arbitrarily configured to show multiple visualisations 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.
The active event type is important for visualisation: 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, and look at the call graph visualisation; there, you see calls happening 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 http: / /kcachegrind. sf. net. 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?
Basic Concepts
Peamised kontseptsioonid
This chapter explains some concepts of the & kcachegrind;, and introduces terms used in the interface.
Selles peatükis seletame mõningaid & kcachegrind; i kontseptsioone ja tutvustame liideses kasutatavaid mõisteid.
The Data Model for Profile Data
Profileerimisandmete andmemudel
Cost Entities
Kuluolemid
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 an 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
Sündmuste tüübid
Arbitrary event types can be specified in the profile data by giving them a name. Their cost related to a cost entity is a 64-bit integer.
Profileerimisandmetes saab määrata igasuguseid sündmuste tüüpe neile nime andes. Nende kulu kuluolemi suhtes on 64- bitine täisarv.
Event types whose costs are specified in a profile data file are called real events. Additionally, one can specify formulae 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.
Visualisation State
Kuvamisolek
The Visualisation 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 colouring), the profile parts whose costs are to be included in visualisation, an active cost entity (e. g. a function selected from the function profile dockable), a selected cost entity. This state influences visualisations.
& 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.
Visualisations always are shown for one, the active, cost entity. When a given visualisation is not appropriate for a cost entity, it is disabled (e. g. when selecting an ELF object in the group list by double-clicking, source annotation for an ELF object make 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 nearside, 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
Külgdokid
Sidedocks (Dockables) are side windows which can be placed at any border of an KCachegrind window. They always contain a list of cost entities sorted in some manner.
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.
Function Profile. 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.
Parts Overview
Osade ülevaade
Call Stack
Väljakutsete pinu
The visualisation area, typically the right part of a KCachegrind main window, is made up of one (default) or more Tab Views, either lined up horizontally or vertically. Each tab view holds different visualisation views of only one cost entity at a time. The name of this entity is given at the top of the tab view. If there are multiple tab views, only one is active. The entity name in the active tab view 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 View
Kaardi alad
Each tab view can hold up to four view areas, namely Top, Right, Left, and Bottom. Each area can hold multiple stacked visualisation views. The visible view 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 visualisation should go into which area by using the context menus of the tabs.
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.
Synchronised Visualisation via Selected Entity in a Tab View
Vaate sünkroniseerimine kaardil olemi valimisega
Besides an active entity, each tab view has an selected entity. As most visualisation types show multiple entities with the active one somehow centred, you can change the selected item by navigating inside a visualisation (by clicking with the mouse or using the keyboard). Typically, selected items are shown in an highlighted state. By changing the selected entity in one of the visualisations of a tab view, all other visualisations in the tab view accordingly highlight the new selected entity.
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.
Synchronisation between Tab Views
Sünkroniseerimine kaartide vahel
If there are multiple tab views, a selection change in one tab view leads to an activation change in the next (to right/ to bottom) tab view. 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.