| Author | Tokens | Token Proportion | Commits | Commit Proportion |
|---|---|---|---|---|
| Namhyung Kim | 7751 | 38.95% | 96 | 29.54% |
| Andi Kleen | 1485 | 7.46% | 15 | 4.62% |
| Stéphane Eranian | 1437 | 7.22% | 4 | 1.23% |
| Jiri Olsa | 1397 | 7.02% | 54 | 16.62% |
| Arnaldo Carvalho de Melo | 1389 | 6.98% | 56 | 17.23% |
| John Kacur | 1050 | 5.28% | 2 | 0.62% |
| Peter Zijlstra | 1022 | 5.14% | 8 | 2.46% |
| Roberto Agostino Vitillo | 698 | 3.51% | 2 | 0.62% |
| Kan Liang | 631 | 3.17% | 7 | 2.15% |
| Don Zickus | 482 | 2.42% | 2 | 0.62% |
| Ian Rogers | 440 | 2.21% | 13 | 4.00% |
| Athira Rajeev | 290 | 1.46% | 4 | 1.23% |
| Frédéric Weisbecker | 255 | 1.28% | 9 | 2.77% |
| Jin Yao | 242 | 1.22% | 3 | 0.92% |
| German Gomez | 222 | 1.12% | 2 | 0.62% |
| Ingo Molnar | 217 | 1.09% | 8 | 2.46% |
| Kim Phillips | 183 | 0.92% | 1 | 0.31% |
| Charles Baylis | 165 | 0.83% | 1 | 0.31% |
| Hari Bathini | 137 | 0.69% | 1 | 0.31% |
| Arun Sharma | 85 | 0.43% | 1 | 0.31% |
| Milian Wolff | 45 | 0.23% | 4 | 1.23% |
| Changbin Du | 40 | 0.20% | 1 | 0.31% |
| He Kuang | 37 | 0.19% | 1 | 0.31% |
| Ravi Bangoria | 34 | 0.17% | 4 | 1.23% |
| Anton Blanchard | 25 | 0.13% | 2 | 0.62% |
| Yannick Brosseau | 24 | 0.12% | 1 | 0.31% |
| Thomas Richter | 22 | 0.11% | 1 | 0.31% |
| Masami Hiramatsu | 16 | 0.08% | 1 | 0.31% |
| Tzvetomir Stoyanov (VMware) | 16 | 0.08% | 6 | 1.85% |
| Feng Tang | 10 | 0.05% | 1 | 0.31% |
| Tzvetomir Stoyanov | 10 | 0.05% | 1 | 0.31% |
| Greg Price | 8 | 0.04% | 1 | 0.31% |
| Bernhard Rosenkraenzer | 7 | 0.04% | 1 | 0.31% |
| David Carrillo-Cisneros | 4 | 0.02% | 1 | 0.31% |
| Wang Nan | 3 | 0.02% | 1 | 0.31% |
| Steven Rostedt | 3 | 0.02% | 1 | 0.31% |
| Adrian Hunter | 3 | 0.02% | 1 | 0.31% |
| Ian Munsie | 3 | 0.02% | 1 | 0.31% |
| Xie XiuQi | 3 | 0.02% | 1 | 0.31% |
| Alexander Yarygin | 3 | 0.02% | 1 | 0.31% |
| Thomas Jarosch | 3 | 0.02% | 1 | 0.31% |
| Tom Zanussi | 2 | 0.01% | 1 | 0.31% |
| SF Markus Elfring | 1 | 0.01% | 1 | 0.31% |
| Greg Kroah-Hartman | 1 | 0.01% | 1 | 0.31% |
| Total | 19901 | 325 |
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191219221932194219521962197219821992200220122022203220422052206220722082209221022112212221322142215221622172218221922202221222222232224222522262227222822292230223122322233223422352236223722382239224022412242224322442245224622472248224922502251225222532254225522562257225822592260226122622263226422652266226722682269227022712272227322742275227622772278227922802281228222832284228522862287228822892290229122922293229422952296229722982299230023012302230323042305230623072308230923102311231223132314231523162317231823192320232123222323232423252326232723282329233023312332233323342335233623372338233923402341234223432344234523462347234823492350235123522353235423552356235723582359236023612362236323642365236623672368236923702371237223732374237523762377237823792380238123822383238423852386238723882389239023912392239323942395239623972398239924002401240224032404240524062407240824092410241124122413241424152416241724182419242024212422242324242425242624272428242924302431243224332434243524362437243824392440244124422443244424452446244724482449245024512452245324542455245624572458245924602461246224632464246524662467246824692470247124722473247424752476247724782479248024812482248324842485248624872488248924902491249224932494249524962497249824992500250125022503250425052506250725082509251025112512251325142515251625172518251925202521252225232524252525262527252825292530253125322533253425352536253725382539254025412542254325442545254625472548254925502551255225532554255525562557255825592560256125622563256425652566256725682569257025712572257325742575257625772578257925802581258225832584258525862587258825892590259125922593259425952596259725982599260026012602260326042605260626072608260926102611261226132614261526162617261826192620262126222623262426252626262726282629263026312632263326342635263626372638263926402641264226432644264526462647264826492650265126522653265426552656265726582659266026612662266326642665266626672668266926702671267226732674267526762677267826792680268126822683268426852686268726882689269026912692269326942695269626972698269927002701270227032704270527062707270827092710271127122713271427152716271727182719272027212722272327242725272627272728272927302731273227332734273527362737273827392740274127422743274427452746274727482749275027512752275327542755275627572758275927602761276227632764276527662767276827692770277127722773277427752776277727782779278027812782278327842785278627872788278927902791279227932794279527962797279827992800280128022803280428052806280728082809281028112812281328142815281628172818281928202821282228232824282528262827282828292830283128322833283428352836283728382839284028412842284328442845284628472848284928502851285228532854285528562857285828592860286128622863286428652866286728682869287028712872287328742875287628772878287928802881288228832884288528862887288828892890289128922893289428952896289728982899290029012902290329042905290629072908290929102911291229132914291529162917291829192920292129222923292429252926292729282929293029312932293329342935293629372938293929402941294229432944294529462947294829492950295129522953295429552956295729582959296029612962296329642965296629672968296929702971297229732974297529762977297829792980298129822983298429852986298729882989299029912992299329942995299629972998299930003001300230033004300530063007300830093010301130123013301430153016301730183019302030213022302330243025302630273028302930303031303230333034303530363037303830393040304130423043304430453046304730483049305030513052305330543055305630573058305930603061306230633064306530663067306830693070307130723073307430753076307730783079308030813082308330843085308630873088308930903091309230933094309530963097309830993100310131023103310431053106310731083109311031113112311331143115311631173118311931203121312231233124312531263127312831293130313131323133313431353136313731383139314031413142314331443145314631473148314931503151315231533154315531563157315831593160316131623163316431653166316731683169317031713172317331743175317631773178317931803181318231833184318531863187318831893190319131923193319431953196319731983199320032013202320332043205320632073208320932103211321232133214321532163217321832193220322132223223322432253226322732283229323032313232323332343235323632373238323932403241324232433244324532463247324832493250325132523253325432553256325732583259326032613262326332643265326632673268326932703271327232733274327532763277327832793280328132823283328432853286328732883289329032913292329332943295329632973298329933003301330233033304330533063307330833093310331133123313331433153316331733183319332033213322332333243325332633273328332933303331333233333334333533363337333833393340334133423343334433453346334733483349335033513352335333543355335633573358335933603361336233633364336533663367336833693370337133723373337433753376337733783379338033813382338333843385338633873388338933903391339233933394339533963397339833993400340134023403340434053406340734083409341034113412341334143415341634173418341934203421342234233424342534263427342834293430343134323433343434353436343734383439344034413442344334443445344634473448344934503451345234533454345534563457345834593460346134623463346434653466346734683469347034713472347334743475347634773478347934803481348234833484348534863487348834893490349134923493349434953496349734983499350035013502350335043505350635073508350935103511351235133514351535163517351835193520352135223523352435253526352735283529353035313532353335343535353635373538353935403541354235433544354535463547354835493550355135523553355435553556355735583559356035613562356335643565356635673568356935703571357235733574357535763577357835793580358135823583358435853586358735883589359035913592359335943595359635973598359936003601360236033604360536063607360836093610361136123613361436153616361736183619362036213622362336243625362636273628362936303631363236333634363536363637363836393640364136423643364436453646364736483649365036513652365336543655365636573658365936603661366236633664366536663667366836693670367136723673367436753676367736783679368036813682368336843685368636873688368936903691369236933694369536963697369836993700370137023703370437053706370737083709371037113712371337143715371637173718371937203721372237233724372537263727372837293730373137323733373437353736373737383739374037413742374337443745374637473748374937503751375237533754375537563757375837593760376137623763376437653766376737683769377037713772377337743775377637773778377937803781378237833784378537863787378837893790379137923793379437953796379737983799380038013802380338043805380638073808380938103811381238133814381538163817381838193820382138223823382438253826382738283829383038313832383338343835383638373838383938403841384238433844384538463847384838493850385138523853385438553856385738583859386038613862386338643865386638673868386938703871387238733874387538763877387838793880388138823883388438853886388738883889389038913892389338943895389638973898389939003901390239033904390539063907390839093910391139123913391439153916391739183919392039213922392339243925392639273928392939303931393239333934393539363937393839393940394139423943394439453946394739483949395039513952395339543955395639573958395939603961396239633964396539663967396839693970397139723973397439753976397739783979398039813982398339843985398639873988398939903991399239933994399539963997399839994000400140024003400440054006400740084009401040114012401340144015401640174018401940204021402240234024402540264027402840294030403140324033403440354036
// SPDX-License-Identifier: GPL-2.0 #include <errno.h> #include <inttypes.h> #include <regex.h> #include <stdlib.h> #include <linux/mman.h> #include <linux/time64.h> #include "debug.h" #include "dso.h" #include "sort.h" #include "hist.h" #include "cacheline.h" #include "comm.h" #include "map.h" #include "maps.h" #include "symbol.h" #include "map_symbol.h" #include "branch.h" #include "thread.h" #include "evsel.h" #include "evlist.h" #include "srcline.h" #include "strlist.h" #include "strbuf.h" #include "mem-events.h" #include "mem-info.h" #include "annotate.h" #include "annotate-data.h" #include "event.h" #include "time-utils.h" #include "cgroup.h" #include "machine.h" #include "trace-event.h" #include <linux/kernel.h> #include <linux/string.h> #ifdef HAVE_LIBTRACEEVENT #include <traceevent/event-parse.h> #endif regex_t parent_regex; const char default_parent_pattern[] = "^sys_|^do_page_fault"; const char *parent_pattern = default_parent_pattern; const char *default_sort_order = "comm,dso,symbol"; const char default_branch_sort_order[] = "comm,dso_from,symbol_from,symbol_to,cycles"; const char default_mem_sort_order[] = "local_weight,mem,sym,dso,symbol_daddr,dso_daddr,snoop,tlb,locked,blocked,local_ins_lat,local_p_stage_cyc"; const char default_top_sort_order[] = "dso,symbol"; const char default_diff_sort_order[] = "dso,symbol"; const char default_tracepoint_sort_order[] = "trace"; const char *sort_order; const char *field_order; regex_t ignore_callees_regex; int have_ignore_callees = 0; enum sort_mode sort__mode = SORT_MODE__NORMAL; static const char *const dynamic_headers[] = {"local_ins_lat", "ins_lat", "local_p_stage_cyc", "p_stage_cyc"}; static const char *const arch_specific_sort_keys[] = {"local_p_stage_cyc", "p_stage_cyc"}; /* * Some architectures have Adjacent Cacheline Prefetch feature, which * behaves like the cacheline size is doubled. Enable this flag to * check things in double cacheline granularity. */ bool chk_double_cl; /* * Replaces all occurrences of a char used with the: * * -t, --field-separator * * option, that uses a special separator character and don't pad with spaces, * replacing all occurrences of this separator in symbol names (and other * output) with a '.' character, that thus it's the only non valid separator. */ static int repsep_snprintf(char *bf, size_t size, const char *fmt, ...) { int n; va_list ap; va_start(ap, fmt); n = vsnprintf(bf, size, fmt, ap); if (symbol_conf.field_sep && n > 0) { char *sep = bf; while (1) { sep = strchr(sep, *symbol_conf.field_sep); if (sep == NULL) break; *sep = '.'; } } va_end(ap); if (n >= (int)size) return size - 1; return n; } static int64_t cmp_null(const void *l, const void *r) { if (!l && !r) return 0; else if (!l) return -1; else return 1; } /* --sort pid */ static int64_t sort__thread_cmp(struct hist_entry *left, struct hist_entry *right) { return thread__tid(right->thread) - thread__tid(left->thread); } static int hist_entry__thread_snprintf(struct hist_entry *he, char *bf, size_t size, unsigned int width) { const char *comm = thread__comm_str(he->thread); width = max(7U, width) - 8; return repsep_snprintf(bf, size, "%7d:%-*.*s", thread__tid(he->thread), width, width, comm ?: ""); } static int hist_entry__thread_filter(struct hist_entry *he, int type, const void *arg) { const struct thread *th = arg; if (type != HIST_FILTER__THREAD) return -1; return th && !RC_CHK_EQUAL(he->thread, th); } struct sort_entry sort_thread = { .se_header = " Pid:Command", .se_cmp = sort__thread_cmp, .se_snprintf = hist_entry__thread_snprintf, .se_filter = hist_entry__thread_filter, .se_width_idx = HISTC_THREAD, }; /* --sort simd */ static int64_t sort__simd_cmp(struct hist_entry *left, struct hist_entry *right) { if (left->simd_flags.arch != right->simd_flags.arch) return (int64_t) left->simd_flags.arch - right->simd_flags.arch; return (int64_t) left->simd_flags.pred - right->simd_flags.pred; } static const char *hist_entry__get_simd_name(struct simd_flags *simd_flags) { u64 arch = simd_flags->arch; if (arch & SIMD_OP_FLAGS_ARCH_SVE) return "SVE"; else return "n/a"; } static int hist_entry__simd_snprintf(struct hist_entry *he, char *bf, size_t size, unsigned int width __maybe_unused) { const char *name; if (!he->simd_flags.arch) return repsep_snprintf(bf, size, ""); name = hist_entry__get_simd_name(&he->simd_flags); if (he->simd_flags.pred & SIMD_OP_FLAGS_PRED_EMPTY) return repsep_snprintf(bf, size, "[e] %s", name); else if (he->simd_flags.pred & SIMD_OP_FLAGS_PRED_PARTIAL) return repsep_snprintf(bf, size, "[p] %s", name); return repsep_snprintf(bf, size, "[.] %s", name); } struct sort_entry sort_simd = { .se_header = "Simd ", .se_cmp = sort__simd_cmp, .se_snprintf = hist_entry__simd_snprintf, .se_width_idx = HISTC_SIMD, }; /* --sort comm */ /* * We can't use pointer comparison in functions below, * because it gives different results based on pointer * values, which could break some sorting assumptions. */ static int64_t sort__comm_cmp(struct hist_entry *left, struct hist_entry *right) { return strcmp(comm__str(right->comm), comm__str(left->comm)); } static int64_t sort__comm_collapse(struct hist_entry *left, struct hist_entry *right) { return strcmp(comm__str(right->comm), comm__str(left->comm)); } static int64_t sort__comm_sort(struct hist_entry *left, struct hist_entry *right) { return strcmp(comm__str(right->comm), comm__str(left->comm)); } static int hist_entry__comm_snprintf(struct hist_entry *he, char *bf, size_t size, unsigned int width) { return repsep_snprintf(bf, size, "%-*.*s", width, width, comm__str(he->comm)); } struct sort_entry sort_comm = { .se_header = "Command", .se_cmp = sort__comm_cmp, .se_collapse = sort__comm_collapse, .se_sort = sort__comm_sort, .se_snprintf = hist_entry__comm_snprintf, .se_filter = hist_entry__thread_filter, .se_width_idx = HISTC_COMM, }; /* --sort dso */ static int64_t _sort__dso_cmp(struct map *map_l, struct map *map_r) { struct dso *dso_l = map_l ? map__dso(map_l) : NULL; struct dso *dso_r = map_r ? map__dso(map_r) : NULL; const char *dso_name_l, *dso_name_r; if (!dso_l || !dso_r) return cmp_null(dso_r, dso_l); if (verbose > 0) { dso_name_l = dso__long_name(dso_l); dso_name_r = dso__long_name(dso_r); } else { dso_name_l = dso__short_name(dso_l); dso_name_r = dso__short_name(dso_r); } return strcmp(dso_name_l, dso_name_r); } static int64_t sort__dso_cmp(struct hist_entry *left, struct hist_entry *right) { return _sort__dso_cmp(right->ms.map, left->ms.map); } static int _hist_entry__dso_snprintf(struct map *map, char *bf, size_t size, unsigned int width) { const struct dso *dso = map ? map__dso(map) : NULL; const char *dso_name = "[unknown]"; if (dso) dso_name = verbose > 0 ? dso__long_name(dso) : dso__short_name(dso); return repsep_snprintf(bf, size, "%-*.*s", width, width, dso_name); } static int hist_entry__dso_snprintf(struct hist_entry *he, char *bf, size_t size, unsigned int width) { return _hist_entry__dso_snprintf(he->ms.map, bf, size, width); } static int hist_entry__dso_filter(struct hist_entry *he, int type, const void *arg) { const struct dso *dso = arg; if (type != HIST_FILTER__DSO) return -1; return dso && (!he->ms.map || map__dso(he->ms.map) != dso); } struct sort_entry sort_dso = { .se_header = "Shared Object", .se_cmp = sort__dso_cmp, .se_snprintf = hist_entry__dso_snprintf, .se_filter = hist_entry__dso_filter, .se_width_idx = HISTC_DSO, }; /* --sort symbol */ static int64_t _sort__addr_cmp(u64 left_ip, u64 right_ip) { return (int64_t)(right_ip - left_ip); } int64_t _sort__sym_cmp(struct symbol *sym_l, struct symbol *sym_r) { if (!sym_l || !sym_r) return cmp_null(sym_l, sym_r); if (sym_l == sym_r) return 0; if (sym_l->inlined || sym_r->inlined) { int ret = strcmp(sym_l->name, sym_r->name); if (ret) return ret; if ((sym_l->start <= sym_r->end) && (sym_l->end >= sym_r->start)) return 0; } if (sym_l->start != sym_r->start) return (int64_t)(sym_r->start - sym_l->start); return (int64_t)(sym_r->end - sym_l->end); } static int64_t sort__sym_cmp(struct hist_entry *left, struct hist_entry *right) { int64_t ret; if (!left->ms.sym && !right->ms.sym) return _sort__addr_cmp(left->ip, right->ip); /* * comparing symbol address alone is not enough since it's a * relative address within a dso. */ if (!hists__has(left->hists, dso)) { ret = sort__dso_cmp(left, right); if (ret != 0) return ret; } return _sort__sym_cmp(left->ms.sym, right->ms.sym); } static int64_t sort__sym_sort(struct hist_entry *left, struct hist_entry *right) { if (!left->ms.sym || !right->ms.sym) return cmp_null(left->ms.sym, right->ms.sym); return strcmp(right->ms.sym->name, left->ms.sym->name); } static int _hist_entry__sym_snprintf(struct map_symbol *ms, u64 ip, char level, char *bf, size_t size, unsigned int width) { struct symbol *sym = ms->sym; struct map *map = ms->map; size_t ret = 0; if (verbose > 0) { struct dso *dso = map ? map__dso(map) : NULL; char o = dso ? dso__symtab_origin(dso) : '!'; u64 rip = ip; if (dso && dso__kernel(dso) && dso__adjust_symbols(dso)) rip = map__unmap_ip(map, ip); ret += repsep_snprintf(bf, size, "%-#*llx %c ", BITS_PER_LONG / 4 + 2, rip, o); } ret += repsep_snprintf(bf + ret, size - ret, "[%c] ", level); if (sym && map) { if (sym->type == STT_OBJECT) { ret += repsep_snprintf(bf + ret, size - ret, "%s", sym->name); ret += repsep_snprintf(bf + ret, size - ret, "+0x%llx", ip - map__unmap_ip(map, sym->start)); } else { ret += repsep_snprintf(bf + ret, size - ret, "%.*s", width - ret, sym->name); if (sym->inlined) ret += repsep_snprintf(bf + ret, size - ret, " (inlined)"); } } else { size_t len = BITS_PER_LONG / 4; ret += repsep_snprintf(bf + ret, size - ret, "%-#.*llx", len, ip); } return ret; } int hist_entry__sym_snprintf(struct hist_entry *he, char *bf, size_t size, unsigned int width) { return _hist_entry__sym_snprintf(&he->ms, he->ip, he->level, bf, size, width); } static int hist_entry__sym_filter(struct hist_entry *he, int type, const void *arg) { const char *sym = arg; if (type != HIST_FILTER__SYMBOL) return -1; return sym && (!he->ms.sym || !strstr(he->ms.sym->name, sym)); } struct sort_entry sort_sym = { .se_header = "Symbol", .se_cmp = sort__sym_cmp, .se_sort = sort__sym_sort, .se_snprintf = hist_entry__sym_snprintf, .se_filter = hist_entry__sym_filter, .se_width_idx = HISTC_SYMBOL, }; /* --sort symoff */ static int64_t sort__symoff_cmp(struct hist_entry *left, struct hist_entry *right) { int64_t ret; ret = sort__sym_cmp(left, right); if (ret) return ret; return left->ip - right->ip; } static int64_t sort__symoff_sort(struct hist_entry *left, struct hist_entry *right) { int64_t ret; ret = sort__sym_sort(left, right); if (ret) return ret; return left->ip - right->ip; } static int hist_entry__symoff_snprintf(struct hist_entry *he, char *bf, size_t size, unsigned int width) { struct symbol *sym = he->ms.sym; if (sym == NULL) return repsep_snprintf(bf, size, "[%c] %-#.*llx", he->level, width - 4, he->ip); return repsep_snprintf(bf, size, "[%c] %s+0x%llx", he->level, sym->name, he->ip - sym->start); } struct sort_entry sort_sym_offset = { .se_header = "Symbol Offset", .se_cmp = sort__symoff_cmp, .se_sort = sort__symoff_sort, .se_snprintf = hist_entry__symoff_snprintf, .se_filter = hist_entry__sym_filter, .se_width_idx = HISTC_SYMBOL_OFFSET, }; /* --sort srcline */ char *hist_entry__srcline(struct hist_entry *he) { return map__srcline(he->ms.map, he->ip, he->ms.sym); } static int64_t sort__srcline_cmp(struct hist_entry *left, struct hist_entry *right) { int64_t ret; ret = _sort__addr_cmp(left->ip, right->ip); if (ret) return ret; return sort__dso_cmp(left, right); } static int64_t sort__srcline_collapse(struct hist_entry *left, struct hist_entry *right) { if (!left->srcline) left->srcline = hist_entry__srcline(left); if (!right->srcline) right->srcline = hist_entry__srcline(right); return strcmp(right->srcline, left->srcline); } static int64_t sort__srcline_sort(struct hist_entry *left, struct hist_entry *right) { return sort__srcline_collapse(left, right); } static void sort__srcline_init(struct hist_entry *he) { if (!he->srcline) he->srcline = hist_entry__srcline(he); } static int hist_entry__srcline_snprintf(struct hist_entry *he, char *bf, size_t size, unsigned int width) { return repsep_snprintf(bf, size, "%-.*s", width, he->srcline); } struct sort_entry sort_srcline = { .se_header = "Source:Line", .se_cmp = sort__srcline_cmp, .se_collapse = sort__srcline_collapse, .se_sort = sort__srcline_sort, .se_init = sort__srcline_init, .se_snprintf = hist_entry__srcline_snprintf, .se_width_idx = HISTC_SRCLINE, }; /* --sort srcline_from */ static char *addr_map_symbol__srcline(struct addr_map_symbol *ams) { return map__srcline(ams->ms.map, ams->al_addr, ams->ms.sym); } static int64_t sort__srcline_from_cmp(struct hist_entry *left, struct hist_entry *right) { return left->branch_info->from.addr - right->branch_info->from.addr; } static int64_t sort__srcline_from_collapse(struct hist_entry *left, struct hist_entry *right) { if (!left->branch_info->srcline_from) left->branch_info->srcline_from = addr_map_symbol__srcline(&left->branch_info->from); if (!right->branch_info->srcline_from) right->branch_info->srcline_from = addr_map_symbol__srcline(&right->branch_info->from); return strcmp(right->branch_info->srcline_from, left->branch_info->srcline_from); } static int64_t sort__srcline_from_sort(struct hist_entry *left, struct hist_entry *right) { return sort__srcline_from_collapse(left, right); } static void sort__srcline_from_init(struct hist_entry *he) { if (!he->branch_info->srcline_from) he->branch_info->srcline_from = addr_map_symbol__srcline(&he->branch_info->from); } static int hist_entry__srcline_from_snprintf(struct hist_entry *he, char *bf, size_t size, unsigned int width) { return repsep_snprintf(bf, size, "%-*.*s", width, width, he->branch_info->srcline_from); } struct sort_entry sort_srcline_from = { .se_header = "From Source:Line", .se_cmp = sort__srcline_from_cmp, .se_collapse = sort__srcline_from_collapse, .se_sort = sort__srcline_from_sort, .se_init = sort__srcline_from_init, .se_snprintf = hist_entry__srcline_from_snprintf, .se_width_idx = HISTC_SRCLINE_FROM, }; /* --sort srcline_to */ static int64_t sort__srcline_to_cmp(struct hist_entry *left, struct hist_entry *right) { return left->branch_info->to.addr - right->branch_info->to.addr; } static int64_t sort__srcline_to_collapse(struct hist_entry *left, struct hist_entry *right) { if (!left->branch_info->srcline_to) left->branch_info->srcline_to = addr_map_symbol__srcline(&left->branch_info->to); if (!right->branch_info->srcline_to) right->branch_info->srcline_to = addr_map_symbol__srcline(&right->branch_info->to); return strcmp(right->branch_info->srcline_to, left->branch_info->srcline_to); } static int64_t sort__srcline_to_sort(struct hist_entry *left, struct hist_entry *right) { return sort__srcline_to_collapse(left, right); } static void sort__srcline_to_init(struct hist_entry *he) { if (!he->branch_info->srcline_to) he->branch_info->srcline_to = addr_map_symbol__srcline(&he->branch_info->to); } static int hist_entry__srcline_to_snprintf(struct hist_entry *he, char *bf, size_t size, unsigned int width) { return repsep_snprintf(bf, size, "%-*.*s", width, width, he->branch_info->srcline_to); } struct sort_entry sort_srcline_to = { .se_header = "To Source:Line", .se_cmp = sort__srcline_to_cmp, .se_collapse = sort__srcline_to_collapse, .se_sort = sort__srcline_to_sort, .se_init = sort__srcline_to_init, .se_snprintf = hist_entry__srcline_to_snprintf, .se_width_idx = HISTC_SRCLINE_TO, }; static int hist_entry__sym_ipc_snprintf(struct hist_entry *he, char *bf, size_t size, unsigned int width) { struct symbol *sym = he->ms.sym; struct annotated_branch *branch; double ipc = 0.0, coverage = 0.0; char tmp[64]; if (!sym) return repsep_snprintf(bf, size, "%-*s", width, "-"); branch = symbol__annotation(sym)->branch; if (branch && branch->hit_cycles) ipc = branch->hit_insn / ((double)branch->hit_cycles); if (branch && branch->total_insn) { coverage = branch->cover_insn * 100.0 / ((double)branch->total_insn); } snprintf(tmp, sizeof(tmp), "%-5.2f [%5.1f%%]", ipc, coverage); return repsep_snprintf(bf, size, "%-*s", width, tmp); } struct sort_entry sort_sym_ipc = { .se_header = "IPC [IPC Coverage]", .se_cmp = sort__sym_cmp, .se_snprintf = hist_entry__sym_ipc_snprintf, .se_width_idx = HISTC_SYMBOL_IPC, }; static int hist_entry__sym_ipc_null_snprintf(struct hist_entry *he __maybe_unused, char *bf, size_t size, unsigned int width) { char tmp[64]; snprintf(tmp, sizeof(tmp), "%-5s %2s", "-", "-"); return repsep_snprintf(bf, size, "%-*s", width, tmp); } struct sort_entry sort_sym_ipc_null = { .se_header = "IPC [IPC Coverage]", .se_cmp = sort__sym_cmp, .se_snprintf = hist_entry__sym_ipc_null_snprintf, .se_width_idx = HISTC_SYMBOL_IPC, }; /* --sort srcfile */ static char no_srcfile[1]; static char *hist_entry__get_srcfile(struct hist_entry *e) { char *sf, *p; struct map *map = e->ms.map; if (!map) return no_srcfile; sf = __get_srcline(map__dso(map), map__rip_2objdump(map, e->ip), e->ms.sym, false, true, true, e->ip); if (sf == SRCLINE_UNKNOWN) return no_srcfile; p = strchr(sf, ':'); if (p && *sf) { *p = 0; return sf; } free(sf); return no_srcfile; } static int64_t sort__srcfile_cmp(struct hist_entry *left, struct hist_entry *right) { return sort__srcline_cmp(left, right); } static int64_t sort__srcfile_collapse(struct hist_entry *left, struct hist_entry *right) { if (!left->srcfile) left->srcfile = hist_entry__get_srcfile(left); if (!right->srcfile) right->srcfile = hist_entry__get_srcfile(right); return strcmp(right->srcfile, left->srcfile); } static int64_t sort__srcfile_sort(struct hist_entry *left, struct hist_entry *right) { return sort__srcfile_collapse(left, right); } static void sort__srcfile_init(struct hist_entry *he) { if (!he->srcfile) he->srcfile = hist_entry__get_srcfile(he); } static int hist_entry__srcfile_snprintf(struct hist_entry *he, char *bf, size_t size, unsigned int width) { return repsep_snprintf(bf, size, "%-.*s", width, he->srcfile); } struct sort_entry sort_srcfile = { .se_header = "Source File", .se_cmp = sort__srcfile_cmp, .se_collapse = sort__srcfile_collapse, .se_sort = sort__srcfile_sort, .se_init = sort__srcfile_init, .se_snprintf = hist_entry__srcfile_snprintf, .se_width_idx = HISTC_SRCFILE, }; /* --sort parent */ static int64_t sort__parent_cmp(struct hist_entry *left, struct hist_entry *right) { struct symbol *sym_l = left->parent; struct symbol *sym_r = right->parent; if (!sym_l || !sym_r) return cmp_null(sym_l, sym_r); return strcmp(sym_r->name, sym_l->name); } static int hist_entry__parent_snprintf(struct hist_entry *he, char *bf, size_t size, unsigned int width) { return repsep_snprintf(bf, size, "%-*.*s", width, width, he->parent ? he->parent->name : "[other]"); } struct sort_entry sort_parent = { .se_header = "Parent symbol", .se_cmp = sort__parent_cmp, .se_snprintf = hist_entry__parent_snprintf, .se_width_idx = HISTC_PARENT, }; /* --sort cpu */ static int64_t sort__cpu_cmp(struct hist_entry *left, struct hist_entry *right) { return right->cpu - left->cpu; } static int hist_entry__cpu_snprintf(struct hist_entry *he, char *bf, size_t size, unsigned int width) { return repsep_snprintf(bf, size, "%*.*d", width, width, he->cpu); } struct sort_entry sort_cpu = { .se_header = "CPU", .se_cmp = sort__cpu_cmp, .se_snprintf = hist_entry__cpu_snprintf, .se_width_idx = HISTC_CPU, }; /* --sort cgroup_id */ static int64_t _sort__cgroup_dev_cmp(u64 left_dev, u64 right_dev) { return (int64_t)(right_dev - left_dev); } static int64_t _sort__cgroup_inode_cmp(u64 left_ino, u64 right_ino) { return (int64_t)(right_ino - left_ino); } static int64_t sort__cgroup_id_cmp(struct hist_entry *left, struct hist_entry *right) { int64_t ret; ret = _sort__cgroup_dev_cmp(right->cgroup_id.dev, left->cgroup_id.dev); if (ret != 0) return ret; return _sort__cgroup_inode_cmp(right->cgroup_id.ino, left->cgroup_id.ino); } static int hist_entry__cgroup_id_snprintf(struct hist_entry *he, char *bf, size_t size, unsigned int width __maybe_unused) { return repsep_snprintf(bf, size, "%lu/0x%lx", he->cgroup_id.dev, he->cgroup_id.ino); } struct sort_entry sort_cgroup_id = { .se_header = "cgroup id (dev/inode)", .se_cmp = sort__cgroup_id_cmp, .se_snprintf = hist_entry__cgroup_id_snprintf, .se_width_idx = HISTC_CGROUP_ID, }; /* --sort cgroup */ static int64_t sort__cgroup_cmp(struct hist_entry *left, struct hist_entry *right) { return right->cgroup - left->cgroup; } static int hist_entry__cgroup_snprintf(struct hist_entry *he, char *bf, size_t size, unsigned int width __maybe_unused) { const char *cgrp_name = "N/A"; if (he->cgroup) { struct cgroup *cgrp = cgroup__find(maps__machine(he->ms.maps)->env, he->cgroup); if (cgrp != NULL) cgrp_name = cgrp->name; else cgrp_name = "unknown"; } return repsep_snprintf(bf, size, "%s", cgrp_name); } struct sort_entry sort_cgroup = { .se_header = "Cgroup", .se_cmp = sort__cgroup_cmp, .se_snprintf = hist_entry__cgroup_snprintf, .se_width_idx = HISTC_CGROUP, }; /* --sort socket */ static int64_t sort__socket_cmp(struct hist_entry *left, struct hist_entry *right) { return right->socket - left->socket; } static int hist_entry__socket_snprintf(struct hist_entry *he, char *bf, size_t size, unsigned int width) { return repsep_snprintf(bf, size, "%*.*d", width, width-3, he->socket); } static int hist_entry__socket_filter(struct hist_entry *he, int type, const void *arg) { int sk = *(const int *)arg; if (type != HIST_FILTER__SOCKET) return -1; return sk >= 0 && he->socket != sk; } struct sort_entry sort_socket = { .se_header = "Socket", .se_cmp = sort__socket_cmp, .se_snprintf = hist_entry__socket_snprintf, .se_filter = hist_entry__socket_filter, .se_width_idx = HISTC_SOCKET, }; /* --sort time */ static int64_t sort__time_cmp(struct hist_entry *left, struct hist_entry *right) { return right->time - left->time; } static int hist_entry__time_snprintf(struct hist_entry *he, char *bf, size_t size, unsigned int width) { char he_time[32]; if (symbol_conf.nanosecs) timestamp__scnprintf_nsec(he->time, he_time, sizeof(he_time)); else timestamp__scnprintf_usec(he->time, he_time, sizeof(he_time)); return repsep_snprintf(bf, size, "%-.*s", width, he_time); } struct sort_entry sort_time = { .se_header = "Time", .se_cmp = sort__time_cmp, .se_snprintf = hist_entry__time_snprintf, .se_width_idx = HISTC_TIME, }; /* --sort trace */ #ifdef HAVE_LIBTRACEEVENT static char *get_trace_output(struct hist_entry *he) { struct trace_seq seq; struct evsel *evsel; struct tep_record rec = { .data = he->raw_data, .size = he->raw_size, }; evsel = hists_to_evsel(he->hists); trace_seq_init(&seq); if (symbol_conf.raw_trace) { tep_print_fields(&seq, he->raw_data, he->raw_size, evsel->tp_format); } else { tep_print_event(evsel->tp_format->tep, &seq, &rec, "%s", TEP_PRINT_INFO); } /* * Trim the buffer, it starts at 4KB and we're not going to * add anything more to this buffer. */ return realloc(seq.buffer, seq.len + 1); } static int64_t sort__trace_cmp(struct hist_entry *left, struct hist_entry *right) { struct evsel *evsel; evsel = hists_to_evsel(left->hists); if (evsel->core.attr.type != PERF_TYPE_TRACEPOINT) return 0; if (left->trace_output == NULL) left->trace_output = get_trace_output(left); if (right->trace_output == NULL) right->trace_output = get_trace_output(right); return strcmp(right->trace_output, left->trace_output); } static int hist_entry__trace_snprintf(struct hist_entry *he, char *bf, size_t size, unsigned int width) { struct evsel *evsel; evsel = hists_to_evsel(he->hists); if (evsel->core.attr.type != PERF_TYPE_TRACEPOINT) return scnprintf(bf, size, "%-.*s", width, "N/A"); if (he->trace_output == NULL) he->trace_output = get_trace_output(he); return repsep_snprintf(bf, size, "%-.*s", width, he->trace_output); } struct sort_entry sort_trace = { .se_header = "Trace output", .se_cmp = sort__trace_cmp, .se_snprintf = hist_entry__trace_snprintf, .se_width_idx = HISTC_TRACE, }; #endif /* HAVE_LIBTRACEEVENT */ /* sort keys for branch stacks */ static int64_t sort__dso_from_cmp(struct hist_entry *left, struct hist_entry *right) { if (!left->branch_info || !right->branch_info) return cmp_null(left->branch_info, right->branch_info); return _sort__dso_cmp(left->branch_info->from.ms.map, right->branch_info->from.ms.map); } static int hist_entry__dso_from_snprintf(struct hist_entry *he, char *bf, size_t size, unsigned int width) { if (he->branch_info) return _hist_entry__dso_snprintf(he->branch_info->from.ms.map, bf, size, width); else return repsep_snprintf(bf, size, "%-*.*s", width, width, "N/A"); } static int hist_entry__dso_from_filter(struct hist_entry *he, int type, const void *arg) { const struct dso *dso = arg; if (type != HIST_FILTER__DSO) return -1; return dso && (!he->branch_info || !he->branch_info->from.ms.map || map__dso(he->branch_info->from.ms.map) != dso); } static int64_t sort__dso_to_cmp(struct hist_entry *left, struct hist_entry *right) { if (!left->branch_info || !right->branch_info) return cmp_null(left->branch_info, right->branch_info); return _sort__dso_cmp(left->branch_info->to.ms.map, right->branch_info->to.ms.map); } static int hist_entry__dso_to_snprintf(struct hist_entry *he, char *bf, size_t size, unsigned int width) { if (he->branch_info) return _hist_entry__dso_snprintf(he->branch_info->to.ms.map, bf, size, width); else return repsep_snprintf(bf, size, "%-*.*s", width, width, "N/A"); } static int hist_entry__dso_to_filter(struct hist_entry *he, int type, const void *arg) { const struct dso *dso = arg; if (type != HIST_FILTER__DSO) return -1; return dso && (!he->branch_info || !he->branch_info->to.ms.map || map__dso(he->branch_info->to.ms.map) != dso); } static int64_t sort__sym_from_cmp(struct hist_entry *left, struct hist_entry *right) { struct addr_map_symbol *from_l, *from_r; if (!left->branch_info || !right->branch_info) return cmp_null(left->branch_info, right->branch_info); from_l = &left->branch_info->from; from_r = &right->branch_info->from; if (!from_l->ms.sym && !from_r->ms.sym) return _sort__addr_cmp(from_l->addr, from_r->addr); return _sort__sym_cmp(from_l->ms.sym, from_r->ms.sym); } static int64_t sort__sym_to_cmp(struct hist_entry *left, struct hist_entry *right) { struct addr_map_symbol *to_l, *to_r; if (!left->branch_info || !right->branch_info) return cmp_null(left->branch_info, right->branch_info); to_l = &left->branch_info->to; to_r = &right->branch_info->to; if (!to_l->ms.sym && !to_r->ms.sym) return _sort__addr_cmp(to_l->addr, to_r->addr); return _sort__sym_cmp(to_l->ms.sym, to_r->ms.sym); } static int hist_entry__sym_from_snprintf(struct hist_entry *he, char *bf, size_t size, unsigned int width) { if (he->branch_info) { struct addr_map_symbol *from = &he->branch_info->from; return _hist_entry__sym_snprintf(&from->ms, from->al_addr, from->al_level, bf, size, width); } return repsep_snprintf(bf, size, "%-*.*s", width, width, "N/A"); } static int hist_entry__sym_to_snprintf(struct hist_entry *he, char *bf, size_t size, unsigned int width) { if (he->branch_info) { struct addr_map_symbol *to = &he->branch_info->to; return _hist_entry__sym_snprintf(&to->ms, to->al_addr, to->al_level, bf, size, width); } return repsep_snprintf(bf, size, "%-*.*s", width, width, "N/A"); } static int hist_entry__sym_from_filter(struct hist_entry *he, int type, const void *arg) { const char *sym = arg; if (type != HIST_FILTER__SYMBOL) return -1; return sym && !(he->branch_info && he->branch_info->from.ms.sym && strstr(he->branch_info->from.ms.sym->name, sym)); } static int hist_entry__sym_to_filter(struct hist_entry *he, int type, const void *arg) { const char *sym = arg; if (type != HIST_FILTER__SYMBOL) return -1; return sym && !(he->branch_info && he->branch_info->to.ms.sym && strstr(he->branch_info->to.ms.sym->name, sym)); } struct sort_entry sort_dso_from = { .se_header = "Source Shared Object", .se_cmp = sort__dso_from_cmp, .se_snprintf = hist_entry__dso_from_snprintf, .se_filter = hist_entry__dso_from_filter, .se_width_idx = HISTC_DSO_FROM, }; struct sort_entry sort_dso_to = { .se_header = "Target Shared Object", .se_cmp = sort__dso_to_cmp, .se_snprintf = hist_entry__dso_to_snprintf, .se_filter = hist_entry__dso_to_filter, .se_width_idx = HISTC_DSO_TO, }; struct sort_entry sort_sym_from = { .se_header = "Source Symbol", .se_cmp = sort__sym_from_cmp, .se_snprintf = hist_entry__sym_from_snprintf, .se_filter = hist_entry__sym_from_filter, .se_width_idx = HISTC_SYMBOL_FROM, }; struct sort_entry sort_sym_to = { .se_header = "Target Symbol", .se_cmp = sort__sym_to_cmp, .se_snprintf = hist_entry__sym_to_snprintf, .se_filter = hist_entry__sym_to_filter, .se_width_idx = HISTC_SYMBOL_TO, }; static int _hist_entry__addr_snprintf(struct map_symbol *ms, u64 ip, char level, char *bf, size_t size, unsigned int width) { struct symbol *sym = ms->sym; struct map *map = ms->map; size_t ret = 0, offs; ret += repsep_snprintf(bf + ret, size - ret, "[%c] ", level); if (sym && map) { if (sym->type == STT_OBJECT) { ret += repsep_snprintf(bf + ret, size - ret, "%s", sym->name); ret += repsep_snprintf(bf + ret, size - ret, "+0x%llx", ip - map__unmap_ip(map, sym->start)); } else { ret += repsep_snprintf(bf + ret, size - ret, "%.*s", width - ret, sym->name); offs = ip - sym->start; if (offs) ret += repsep_snprintf(bf + ret, size - ret, "+0x%llx", offs); } } else { size_t len = BITS_PER_LONG / 4; ret += repsep_snprintf(bf + ret, size - ret, "%-#.*llx", len, ip); } return ret; } static int hist_entry__addr_from_snprintf(struct hist_entry *he, char *bf, size_t size, unsigned int width) { if (he->branch_info) { struct addr_map_symbol *from = &he->branch_info->from; return _hist_entry__addr_snprintf(&from->ms, from->al_addr, he->level, bf, size, width); } return repsep_snprintf(bf, size, "%-*.*s", width, width, "N/A"); } static int hist_entry__addr_to_snprintf(struct hist_entry *he, char *bf, size_t size, unsigned int width) { if (he->branch_info) { struct addr_map_symbol *to = &he->branch_info->to; return _hist_entry__addr_snprintf(&to->ms, to->al_addr, he->level, bf, size, width); } return repsep_snprintf(bf, size, "%-*.*s", width, width, "N/A"); } static int64_t sort__addr_from_cmp(struct hist_entry *left, struct hist_entry *right) { struct addr_map_symbol *from_l; struct addr_map_symbol *from_r; int64_t ret; if (!left->branch_info || !right->branch_info) return cmp_null(left->branch_info, right->branch_info); from_l = &left->branch_info->from; from_r = &right->branch_info->from; /* * comparing symbol address alone is not enough since it's a * relative address within a dso. */ ret = _sort__dso_cmp(from_l->ms.map, from_r->ms.map); if (ret != 0) return ret; return _sort__addr_cmp(from_l->addr, from_r->addr); } static int64_t sort__addr_to_cmp(struct hist_entry *left, struct hist_entry *right) { struct addr_map_symbol *to_l; struct addr_map_symbol *to_r; int64_t ret; if (!left->branch_info || !right->branch_info) return cmp_null(left->branch_info, right->branch_info); to_l = &left->branch_info->to; to_r = &right->branch_info->to; /* * comparing symbol address alone is not enough since it's a * relative address within a dso. */ ret = _sort__dso_cmp(to_l->ms.map, to_r->ms.map); if (ret != 0) return ret; return _sort__addr_cmp(to_l->addr, to_r->addr); } struct sort_entry sort_addr_from = { .se_header = "Source Address", .se_cmp = sort__addr_from_cmp, .se_snprintf = hist_entry__addr_from_snprintf, .se_filter = hist_entry__sym_from_filter, /* shared with sym_from */ .se_width_idx = HISTC_ADDR_FROM, }; struct sort_entry sort_addr_to = { .se_header = "Target Address", .se_cmp = sort__addr_to_cmp, .se_snprintf = hist_entry__addr_to_snprintf, .se_filter = hist_entry__sym_to_filter, /* shared with sym_to */ .se_width_idx = HISTC_ADDR_TO, }; static int64_t sort__mispredict_cmp(struct hist_entry *left, struct hist_entry *right) { unsigned char mp, p; if (!left->branch_info || !right->branch_info) return cmp_null(left->branch_info, right->branch_info); mp = left->branch_info->flags.mispred != right->branch_info->flags.mispred; p = left->branch_info->flags.predicted != right->branch_info->flags.predicted; return mp || p; } static int hist_entry__mispredict_snprintf(struct hist_entry *he, char *bf, size_t size, unsigned int width){ static const char *out = "N/A"; if (he->branch_info) { if (he->branch_info->flags.predicted) out = "N"; else if (he->branch_info->flags.mispred) out = "Y"; } return repsep_snprintf(bf, size, "%-*.*s", width, width, out); } static int64_t sort__cycles_cmp(struct hist_entry *left, struct hist_entry *right) { if (!left->branch_info || !right->branch_info) return cmp_null(left->branch_info, right->branch_info); return left->branch_info->flags.cycles - right->branch_info->flags.cycles; } static int hist_entry__cycles_snprintf(struct hist_entry *he, char *bf, size_t size, unsigned int width) { if (!he->branch_info) return scnprintf(bf, size, "%-.*s", width, "N/A"); if (he->branch_info->flags.cycles == 0) return repsep_snprintf(bf, size, "%-*s", width, "-"); return repsep_snprintf(bf, size, "%-*hd", width, he->branch_info->flags.cycles); } struct sort_entry sort_cycles = { .se_header = "Basic Block Cycles", .se_cmp = sort__cycles_cmp, .se_snprintf = hist_entry__cycles_snprintf, .se_width_idx = HISTC_CYCLES, }; /* --sort daddr_sym */ int64_t sort__daddr_cmp(struct hist_entry *left, struct hist_entry *right) { uint64_t l = 0, r = 0; if (left->mem_info) l = mem_info__daddr(left->mem_info)->addr; if (right->mem_info) r = mem_info__daddr(right->mem_info)->addr; return (int64_t)(r - l); } static int hist_entry__daddr_snprintf(struct hist_entry *he, char *bf, size_t size, unsigned int width) { uint64_t addr = 0; struct map_symbol *ms = NULL; if (he->mem_info) { addr = mem_info__daddr(he->mem_info)->addr; ms = &mem_info__daddr(he->mem_info)->ms; } return _hist_entry__sym_snprintf(ms, addr, he->level, bf, size, width); } int64_t sort__iaddr_cmp(struct hist_entry *left, struct hist_entry *right) { uint64_t l = 0, r = 0; if (left->mem_info) l = mem_info__iaddr(left->mem_info)->addr; if (right->mem_info) r = mem_info__iaddr(right->mem_info)->addr; return (int64_t)(r - l); } static int hist_entry__iaddr_snprintf(struct hist_entry *he, char *bf, size_t size, unsigned int width) { uint64_t addr = 0; struct map_symbol *ms = NULL; if (he->mem_info) { addr = mem_info__iaddr(he->mem_info)->addr; ms = &mem_info__iaddr(he->mem_info)->ms; } return _hist_entry__sym_snprintf(ms, addr, he->level, bf, size, width); } static int64_t sort__dso_daddr_cmp(struct hist_entry *left, struct hist_entry *right) { struct map *map_l = NULL; struct map *map_r = NULL; if (left->mem_info) map_l = mem_info__daddr(left->mem_info)->ms.map; if (right->mem_info) map_r = mem_info__daddr(right->mem_info)->ms.map; return _sort__dso_cmp(map_l, map_r); } static int hist_entry__dso_daddr_snprintf(struct hist_entry *he, char *bf, size_t size, unsigned int width) { struct map *map = NULL; if (he->mem_info) map = mem_info__daddr(he->mem_info)->ms.map; return _hist_entry__dso_snprintf(map, bf, size, width); } static int64_t sort__locked_cmp(struct hist_entry *left, struct hist_entry *right) { union perf_mem_data_src data_src_l; union perf_mem_data_src data_src_r; if (left->mem_info) data_src_l = *mem_info__data_src(left->mem_info); else data_src_l.mem_lock = PERF_MEM_LOCK_NA; if (right->mem_info) data_src_r = *mem_info__data_src(right->mem_info); else data_src_r.mem_lock = PERF_MEM_LOCK_NA; return (int64_t)(data_src_r.mem_lock - data_src_l.mem_lock); } static int hist_entry__locked_snprintf(struct hist_entry *he, char *bf, size_t size, unsigned int width) { char out[10]; perf_mem__lck_scnprintf(out, sizeof(out), he->mem_info); return repsep_snprintf(bf, size, "%.*s", width, out); } static int64_t sort__tlb_cmp(struct hist_entry *left, struct hist_entry *right) { union perf_mem_data_src data_src_l; union perf_mem_data_src data_src_r; if (left->mem_info) data_src_l = *mem_info__data_src(left->mem_info); else data_src_l.mem_dtlb = PERF_MEM_TLB_NA; if (right->mem_info) data_src_r = *mem_info__data_src(right->mem_info); else data_src_r.mem_dtlb = PERF_MEM_TLB_NA; return (int64_t)(data_src_r.mem_dtlb - data_src_l.mem_dtlb); } static int hist_entry__tlb_snprintf(struct hist_entry *he, char *bf, size_t size, unsigned int width) { char out[64]; perf_mem__tlb_scnprintf(out, sizeof(out), he->mem_info); return repsep_snprintf(bf, size, "%-*s", width, out); } static int64_t sort__lvl_cmp(struct hist_entry *left, struct hist_entry *right) { union perf_mem_data_src data_src_l; union perf_mem_data_src data_src_r; if (left->mem_info) data_src_l = *mem_info__data_src(left->mem_info); else data_src_l.mem_lvl = PERF_MEM_LVL_NA; if (right->mem_info) data_src_r = *mem_info__data_src(right->mem_info); else data_src_r.mem_lvl = PERF_MEM_LVL_NA; return (int64_t)(data_src_r.mem_lvl - data_src_l.mem_lvl); } static int hist_entry__lvl_snprintf(struct hist_entry *he, char *bf, size_t size, unsigned int width) { char out[64]; perf_mem__lvl_scnprintf(out, sizeof(out), he->mem_info); return repsep_snprintf(bf, size, "%-*s", width, out); } static int64_t sort__snoop_cmp(struct hist_entry *left, struct hist_entry *right) { union perf_mem_data_src data_src_l; union perf_mem_data_src data_src_r; if (left->mem_info) data_src_l = *mem_info__data_src(left->mem_info); else data_src_l.mem_snoop = PERF_MEM_SNOOP_NA; if (right->mem_info) data_src_r = *mem_info__data_src(right->mem_info); else data_src_r.mem_snoop = PERF_MEM_SNOOP_NA; return (int64_t)(data_src_r.mem_snoop - data_src_l.mem_snoop); } static int hist_entry__snoop_snprintf(struct hist_entry *he, char *bf, size_t size, unsigned int width) { char out[64]; perf_mem__snp_scnprintf(out, sizeof(out), he->mem_info); return repsep_snprintf(bf, size, "%-*s", width, out); } int64_t sort__dcacheline_cmp(struct hist_entry *left, struct hist_entry *right) { u64 l, r; struct map *l_map, *r_map; struct dso *l_dso, *r_dso; int rc; if (!left->mem_info) return -1; if (!right->mem_info) return 1; /* group event types together */ if (left->cpumode > right->cpumode) return -1; if (left->cpumode < right->cpumode) return 1; l_map = mem_info__daddr(left->mem_info)->ms.map; r_map = mem_info__daddr(right->mem_info)->ms.map; /* if both are NULL, jump to sort on al_addr instead */ if (!l_map && !r_map) goto addr; if (!l_map) return -1; if (!r_map) return 1; l_dso = map__dso(l_map); r_dso = map__dso(r_map); rc = dso__cmp_id(l_dso, r_dso); if (rc) return rc; /* * Addresses with no major/minor numbers are assumed to be * anonymous in userspace. Sort those on pid then address. * * The kernel and non-zero major/minor mapped areas are * assumed to be unity mapped. Sort those on address. */ if ((left->cpumode != PERF_RECORD_MISC_KERNEL) && (!(map__flags(l_map) & MAP_SHARED)) && !dso__id(l_dso)->maj && !dso__id(l_dso)->min && !dso__id(l_dso)->ino && !dso__id(l_dso)->ino_generation) { /* userspace anonymous */ if (thread__pid(left->thread) > thread__pid(right->thread)) return -1; if (thread__pid(left->thread) < thread__pid(right->thread)) return 1; } addr: /* al_addr does all the right addr - start + offset calculations */ l = cl_address(mem_info__daddr(left->mem_info)->al_addr, chk_double_cl); r = cl_address(mem_info__daddr(right->mem_info)->al_addr, chk_double_cl); if (l > r) return -1; if (l < r) return 1; return 0; } static int hist_entry__dcacheline_snprintf(struct hist_entry *he, char *bf, size_t size, unsigned int width) { uint64_t addr = 0; struct map_symbol *ms = NULL; char level = he->level; if (he->mem_info) { struct map *map = mem_info__daddr(he->mem_info)->ms.map; struct dso *dso = map ? map__dso(map) : NULL; addr = cl_address(mem_info__daddr(he->mem_info)->al_addr, chk_double_cl); ms = &mem_info__daddr(he->mem_info)->ms; /* print [s] for shared data mmaps */ if ((he->cpumode != PERF_RECORD_MISC_KERNEL) && map && !(map__prot(map) & PROT_EXEC) && (map__flags(map) & MAP_SHARED) && (dso__id(dso)->maj || dso__id(dso)->min || dso__id(dso)->ino || dso__id(dso)->ino_generation)) level = 's'; else if (!map) level = 'X'; } return _hist_entry__sym_snprintf(ms, addr, level, bf, size, width); } struct sort_entry sort_mispredict = { .se_header = "Branch Mispredicted", .se_cmp = sort__mispredict_cmp, .se_snprintf = hist_entry__mispredict_snprintf, .se_width_idx = HISTC_MISPREDICT, }; static int64_t sort__weight_cmp(struct hist_entry *left, struct hist_entry *right) { return left->weight - right->weight; } static int hist_entry__local_weight_snprintf(struct hist_entry *he, char *bf, size_t size, unsigned int width) { return repsep_snprintf(bf, size, "%-*llu", width, he->weight); } struct sort_entry sort_local_weight = { .se_header = "Local Weight", .se_cmp = sort__weight_cmp, .se_snprintf = hist_entry__local_weight_snprintf, .se_width_idx = HISTC_LOCAL_WEIGHT, }; static int hist_entry__global_weight_snprintf(struct hist_entry *he, char *bf, size_t size, unsigned int width) { return repsep_snprintf(bf, size, "%-*llu", width, he->weight * he->stat.nr_events); } struct sort_entry sort_global_weight = { .se_header = "Weight", .se_cmp = sort__weight_cmp, .se_snprintf = hist_entry__global_weight_snprintf, .se_width_idx = HISTC_GLOBAL_WEIGHT, }; static int64_t sort__ins_lat_cmp(struct hist_entry *left, struct hist_entry *right) { return left->ins_lat - right->ins_lat; } static int hist_entry__local_ins_lat_snprintf(struct hist_entry *he, char *bf, size_t size, unsigned int width) { return repsep_snprintf(bf, size, "%-*u", width, he->ins_lat); } struct sort_entry sort_local_ins_lat = { .se_header = "Local INSTR Latency", .se_cmp = sort__ins_lat_cmp, .se_snprintf = hist_entry__local_ins_lat_snprintf, .se_width_idx = HISTC_LOCAL_INS_LAT, }; static int hist_entry__global_ins_lat_snprintf(struct hist_entry *he, char *bf, size_t size, unsigned int width) { return repsep_snprintf(bf, size, "%-*u", width, he->ins_lat * he->stat.nr_events); } struct sort_entry sort_global_ins_lat = { .se_header = "INSTR Latency", .se_cmp = sort__ins_lat_cmp, .se_snprintf = hist_entry__global_ins_lat_snprintf, .se_width_idx = HISTC_GLOBAL_INS_LAT, }; static int64_t sort__p_stage_cyc_cmp(struct hist_entry *left, struct hist_entry *right) { return left->p_stage_cyc - right->p_stage_cyc; } static int hist_entry__global_p_stage_cyc_snprintf(struct hist_entry *he, char *bf, size_t size, unsigned int width) { return repsep_snprintf(bf, size, "%-*u", width, he->p_stage_cyc * he->stat.nr_events); } static int hist_entry__p_stage_cyc_snprintf(struct hist_entry *he, char *bf, size_t size, unsigned int width) { return repsep_snprintf(bf, size, "%-*u", width, he->p_stage_cyc); } struct sort_entry sort_local_p_stage_cyc = { .se_header = "Local Pipeline Stage Cycle", .se_cmp = sort__p_stage_cyc_cmp, .se_snprintf = hist_entry__p_stage_cyc_snprintf, .se_width_idx = HISTC_LOCAL_P_STAGE_CYC, }; struct sort_entry sort_global_p_stage_cyc = { .se_header = "Pipeline Stage Cycle", .se_cmp = sort__p_stage_cyc_cmp, .se_snprintf = hist_entry__global_p_stage_cyc_snprintf, .se_width_idx = HISTC_GLOBAL_P_STAGE_CYC, }; struct sort_entry sort_mem_daddr_sym = { .se_header = "Data Symbol", .se_cmp = sort__daddr_cmp, .se_snprintf = hist_entry__daddr_snprintf, .se_width_idx = HISTC_MEM_DADDR_SYMBOL, }; struct sort_entry sort_mem_iaddr_sym = { .se_header = "Code Symbol", .se_cmp = sort__iaddr_cmp, .se_snprintf = hist_entry__iaddr_snprintf, .se_width_idx = HISTC_MEM_IADDR_SYMBOL, }; struct sort_entry sort_mem_daddr_dso = { .se_header = "Data Object", .se_cmp = sort__dso_daddr_cmp, .se_snprintf = hist_entry__dso_daddr_snprintf, .se_width_idx = HISTC_MEM_DADDR_DSO, }; struct sort_entry sort_mem_locked = { .se_header = "Locked", .se_cmp = sort__locked_cmp, .se_snprintf = hist_entry__locked_snprintf, .se_width_idx = HISTC_MEM_LOCKED, }; struct sort_entry sort_mem_tlb = { .se_header = "TLB access", .se_cmp = sort__tlb_cmp, .se_snprintf = hist_entry__tlb_snprintf, .se_width_idx = HISTC_MEM_TLB, }; struct sort_entry sort_mem_lvl = { .se_header = "Memory access", .se_cmp = sort__lvl_cmp, .se_snprintf = hist_entry__lvl_snprintf, .se_width_idx = HISTC_MEM_LVL, }; struct sort_entry sort_mem_snoop = { .se_header = "Snoop", .se_cmp = sort__snoop_cmp, .se_snprintf = hist_entry__snoop_snprintf, .se_width_idx = HISTC_MEM_SNOOP, }; struct sort_entry sort_mem_dcacheline = { .se_header = "Data Cacheline", .se_cmp = sort__dcacheline_cmp, .se_snprintf = hist_entry__dcacheline_snprintf, .se_width_idx = HISTC_MEM_DCACHELINE, }; static int64_t sort__blocked_cmp(struct hist_entry *left, struct hist_entry *right) { union perf_mem_data_src data_src_l; union perf_mem_data_src data_src_r; if (left->mem_info) data_src_l = *mem_info__data_src(left->mem_info); else data_src_l.mem_blk = PERF_MEM_BLK_NA; if (right->mem_info) data_src_r = *mem_info__data_src(right->mem_info); else data_src_r.mem_blk = PERF_MEM_BLK_NA; return (int64_t)(data_src_r.mem_blk - data_src_l.mem_blk); } static int hist_entry__blocked_snprintf(struct hist_entry *he, char *bf, size_t size, unsigned int width) { char out[16]; perf_mem__blk_scnprintf(out, sizeof(out), he->mem_info); return repsep_snprintf(bf, size, "%.*s", width, out); } struct sort_entry sort_mem_blocked = { .se_header = "Blocked", .se_cmp = sort__blocked_cmp, .se_snprintf = hist_entry__blocked_snprintf, .se_width_idx = HISTC_MEM_BLOCKED, }; static int64_t sort__phys_daddr_cmp(struct hist_entry *left, struct hist_entry *right) { uint64_t l = 0, r = 0; if (left->mem_info) l = mem_info__daddr(left->mem_info)->phys_addr; if (right->mem_info) r = mem_info__daddr(right->mem_info)->phys_addr; return (int64_t)(r - l); } static int hist_entry__phys_daddr_snprintf(struct hist_entry *he, char *bf, size_t size, unsigned int width) { uint64_t addr = 0; size_t ret = 0; size_t len = BITS_PER_LONG / 4; addr = mem_info__daddr(he->mem_info)->phys_addr; ret += repsep_snprintf(bf + ret, size - ret, "[%c] ", he->level); ret += repsep_snprintf(bf + ret, size - ret, "%-#.*llx", len, addr); ret += repsep_snprintf(bf + ret, size - ret, "%-*s", width - ret, ""); if (ret > width) bf[width] = '\0'; return width; } struct sort_entry sort_mem_phys_daddr = { .se_header = "Data Physical Address", .se_cmp = sort__phys_daddr_cmp, .se_snprintf = hist_entry__phys_daddr_snprintf, .se_width_idx = HISTC_MEM_PHYS_DADDR, }; static int64_t sort__data_page_size_cmp(struct hist_entry *left, struct hist_entry *right) { uint64_t l = 0, r = 0; if (left->mem_info) l = mem_info__daddr(left->mem_info)->data_page_size; if (right->mem_info) r = mem_info__daddr(right->mem_info)->data_page_size; return (int64_t)(r - l); } static int hist_entry__data_page_size_snprintf(struct hist_entry *he, char *bf, size_t size, unsigned int width) { char str[PAGE_SIZE_NAME_LEN]; return repsep_snprintf(bf, size, "%-*s", width, get_page_size_name(mem_info__daddr(he->mem_info)->data_page_size, str)); } struct sort_entry sort_mem_data_page_size = { .se_header = "Data Page Size", .se_cmp = sort__data_page_size_cmp, .se_snprintf = hist_entry__data_page_size_snprintf, .se_width_idx = HISTC_MEM_DATA_PAGE_SIZE, }; static int64_t sort__code_page_size_cmp(struct hist_entry *left, struct hist_entry *right) { uint64_t l = left->code_page_size; uint64_t r = right->code_page_size; return (int64_t)(r - l); } static int hist_entry__code_page_size_snprintf(struct hist_entry *he, char *bf, size_t size, unsigned int width) { char str[PAGE_SIZE_NAME_LEN]; return repsep_snprintf(bf, size, "%-*s", width, get_page_size_name(he->code_page_size, str)); } struct sort_entry sort_code_page_size = { .se_header = "Code Page Size", .se_cmp = sort__code_page_size_cmp, .se_snprintf = hist_entry__code_page_size_snprintf, .se_width_idx = HISTC_CODE_PAGE_SIZE, }; static int64_t sort__abort_cmp(struct hist_entry *left, struct hist_entry *right) { if (!left->branch_info || !right->branch_info) return cmp_null(left->branch_info, right->branch_info); return left->branch_info->flags.abort != right->branch_info->flags.abort; } static int hist_entry__abort_snprintf(struct hist_entry *he, char *bf, size_t size, unsigned int width) { static const char *out = "N/A"; if (he->branch_info) { if (he->branch_info->flags.abort) out = "A"; else out = "."; } return repsep_snprintf(bf, size, "%-*s", width, out); } struct sort_entry sort_abort = { .se_header = "Transaction abort", .se_cmp = sort__abort_cmp, .se_snprintf = hist_entry__abort_snprintf, .se_width_idx = HISTC_ABORT, }; static int64_t sort__in_tx_cmp(struct hist_entry *left, struct hist_entry *right) { if (!left->branch_info || !right->branch_info) return cmp_null(left->branch_info, right->branch_info); return left->branch_info->flags.in_tx != right->branch_info->flags.in_tx; } static int hist_entry__in_tx_snprintf(struct hist_entry *he, char *bf, size_t size, unsigned int width) { static const char *out = "N/A"; if (he->branch_info) { if (he->branch_info->flags.in_tx) out = "T"; else out = "."; } return repsep_snprintf(bf, size, "%-*s", width, out); } struct sort_entry sort_in_tx = { .se_header = "Branch in transaction", .se_cmp = sort__in_tx_cmp, .se_snprintf = hist_entry__in_tx_snprintf, .se_width_idx = HISTC_IN_TX, }; static int64_t sort__transaction_cmp(struct hist_entry *left, struct hist_entry *right) { return left->transaction - right->transaction; } static inline char *add_str(char *p, const char *str) { strcpy(p, str); return p + strlen(str); } static struct txbit { unsigned flag; const char *name; int skip_for_len; } txbits[] = { { PERF_TXN_ELISION, "EL ", 0 }, { PERF_TXN_TRANSACTION, "TX ", 1 }, { PERF_TXN_SYNC, "SYNC ", 1 }, { PERF_TXN_ASYNC, "ASYNC ", 0 }, { PERF_TXN_RETRY, "RETRY ", 0 }, { PERF_TXN_CONFLICT, "CON ", 0 }, { PERF_TXN_CAPACITY_WRITE, "CAP-WRITE ", 1 }, { PERF_TXN_CAPACITY_READ, "CAP-READ ", 0 }, { 0, NULL, 0 } }; int hist_entry__transaction_len(void) { int i; int len = 0; for (i = 0; txbits[i].name; i++) { if (!txbits[i].skip_for_len) len += strlen(txbits[i].name); } len += 4; /* :XX<space> */ return len; } static int hist_entry__transaction_snprintf(struct hist_entry *he, char *bf, size_t size, unsigned int width) { u64 t = he->transaction; char buf[128]; char *p = buf; int i; buf[0] = 0; for (i = 0; txbits[i].name; i++) if (txbits[i].flag & t) p = add_str(p, txbits[i].name); if (t && !(t & (PERF_TXN_SYNC|PERF_TXN_ASYNC))) p = add_str(p, "NEITHER "); if (t & PERF_TXN_ABORT_MASK) { sprintf(p, ":%" PRIx64, (t & PERF_TXN_ABORT_MASK) >> PERF_TXN_ABORT_SHIFT); p += strlen(p); } return repsep_snprintf(bf, size, "%-*s", width, buf); } struct sort_entry sort_transaction = { .se_header = "Transaction ", .se_cmp = sort__transaction_cmp, .se_snprintf = hist_entry__transaction_snprintf, .se_width_idx = HISTC_TRANSACTION, }; /* --sort symbol_size */ static int64_t _sort__sym_size_cmp(struct symbol *sym_l, struct symbol *sym_r) { int64_t size_l = sym_l != NULL ? symbol__size(sym_l) : 0; int64_t size_r = sym_r != NULL ? symbol__size(sym_r) : 0; return size_l < size_r ? -1 : size_l == size_r ? 0 : 1; } static int64_t sort__sym_size_cmp(struct hist_entry *left, struct hist_entry *right) { return _sort__sym_size_cmp(right->ms.sym, left->ms.sym); } static int _hist_entry__sym_size_snprintf(struct symbol *sym, char *bf, size_t bf_size, unsigned int width) { if (sym) return repsep_snprintf(bf, bf_size, "%*d", width, symbol__size(sym)); return repsep_snprintf(bf, bf_size, "%*s", width, "unknown"); } static int hist_entry__sym_size_snprintf(struct hist_entry *he, char *bf, size_t size, unsigned int width) { return _hist_entry__sym_size_snprintf(he->ms.sym, bf, size, width); } struct sort_entry sort_sym_size = { .se_header = "Symbol size", .se_cmp = sort__sym_size_cmp, .se_snprintf = hist_entry__sym_size_snprintf, .se_width_idx = HISTC_SYM_SIZE, }; /* --sort dso_size */ static int64_t _sort__dso_size_cmp(struct map *map_l, struct map *map_r) { int64_t size_l = map_l != NULL ? map__size(map_l) : 0; int64_t size_r = map_r != NULL ? map__size(map_r) : 0; return size_l < size_r ? -1 : size_l == size_r ? 0 : 1; } static int64_t sort__dso_size_cmp(struct hist_entry *left, struct hist_entry *right) { return _sort__dso_size_cmp(right->ms.map, left->ms.map); } static int _hist_entry__dso_size_snprintf(struct map *map, char *bf, size_t bf_size, unsigned int width) { if (map && map__dso(map)) return repsep_snprintf(bf, bf_size, "%*d", width, map__size(map)); return repsep_snprintf(bf, bf_size, "%*s", width, "unknown"); } static int hist_entry__dso_size_snprintf(struct hist_entry *he, char *bf, size_t size, unsigned int width) { return _hist_entry__dso_size_snprintf(he->ms.map, bf, size, width); } struct sort_entry sort_dso_size = { .se_header = "DSO size", .se_cmp = sort__dso_size_cmp, .se_snprintf = hist_entry__dso_size_snprintf, .se_width_idx = HISTC_DSO_SIZE, }; /* --sort addr */ static int64_t sort__addr_cmp(struct hist_entry *left, struct hist_entry *right) { u64 left_ip = left->ip; u64 right_ip = right->ip; struct map *left_map = left->ms.map; struct map *right_map = right->ms.map; if (left_map) left_ip = map__unmap_ip(left_map, left_ip); if (right_map) right_ip = map__unmap_ip(right_map, right_ip); return _sort__addr_cmp(left_ip, right_ip); } static int hist_entry__addr_snprintf(struct hist_entry *he, char *bf, size_t size, unsigned int width) { u64 ip = he->ip; struct map *map = he->ms.map; if (map) ip = map__unmap_ip(map, ip); return repsep_snprintf(bf, size, "%-#*llx", width, ip); } struct sort_entry sort_addr = { .se_header = "Address", .se_cmp = sort__addr_cmp, .se_snprintf = hist_entry__addr_snprintf, .se_width_idx = HISTC_ADDR, }; /* --sort type */ struct annotated_data_type unknown_type = { .self = { .type_name = (char *)"(unknown)", .children = LIST_HEAD_INIT(unknown_type.self.children), }, }; static int64_t sort__type_cmp(struct hist_entry *left, struct hist_entry *right) { return sort__addr_cmp(left, right); } static void sort__type_init(struct hist_entry *he) { if (he->mem_type) return; he->mem_type = hist_entry__get_data_type(he); if (he->mem_type == NULL) { he->mem_type = &unknown_type; he->mem_type_off = 0; } } static int64_t sort__type_collapse(struct hist_entry *left, struct hist_entry *right) { struct annotated_data_type *left_type = left->mem_type; struct annotated_data_type *right_type = right->mem_type; if (!left_type) { sort__type_init(left); left_type = left->mem_type; } if (!right_type) { sort__type_init(right); right_type = right->mem_type; } return strcmp(left_type->self.type_name, right_type->self.type_name); } static int64_t sort__type_sort(struct hist_entry *left, struct hist_entry *right) { return sort__type_collapse(left, right); } static int hist_entry__type_snprintf(struct hist_entry *he, char *bf, size_t size, unsigned int width) { return repsep_snprintf(bf, size, "%-*s", width, he->mem_type->self.type_name); } struct sort_entry sort_type = { .se_header = "Data Type", .se_cmp = sort__type_cmp, .se_collapse = sort__type_collapse, .se_sort = sort__type_sort, .se_init = sort__type_init, .se_snprintf = hist_entry__type_snprintf, .se_width_idx = HISTC_TYPE, }; /* --sort typeoff */ static int64_t sort__typeoff_sort(struct hist_entry *left, struct hist_entry *right) { struct annotated_data_type *left_type = left->mem_type; struct annotated_data_type *right_type = right->mem_type; int64_t ret; if (!left_type) { sort__type_init(left); left_type = left->mem_type; } if (!right_type) { sort__type_init(right); right_type = right->mem_type; } ret = strcmp(left_type->self.type_name, right_type->self.type_name); if (ret) return ret; return left->mem_type_off - right->mem_type_off; } static void fill_member_name(char *buf, size_t sz, struct annotated_member *m, int offset, bool first) { struct annotated_member *child; if (list_empty(&m->children)) return; list_for_each_entry(child, &m->children, node) { if (child->offset <= offset && offset < child->offset + child->size) { int len = 0; /* It can have anonymous struct/union members */ if (child->var_name) { len = scnprintf(buf, sz, "%s%s", first ? "" : ".", child->var_name); first = false; } fill_member_name(buf + len, sz - len, child, offset, first); return; } } } static int hist_entry__typeoff_snprintf(struct hist_entry *he, char *bf, size_t size, unsigned int width __maybe_unused) { struct annotated_data_type *he_type = he->mem_type; char buf[4096]; buf[0] = '\0'; if (list_empty(&he_type->self.children)) snprintf(buf, sizeof(buf), "no field"); else fill_member_name(buf, sizeof(buf), &he_type->self, he->mem_type_off, true); buf[4095] = '\0'; return repsep_snprintf(bf, size, "%s +%#x (%s)", he_type->self.type_name, he->mem_type_off, buf); } struct sort_entry sort_type_offset = { .se_header = "Data Type Offset", .se_cmp = sort__type_cmp, .se_collapse = sort__typeoff_sort, .se_sort = sort__typeoff_sort, .se_init = sort__type_init, .se_snprintf = hist_entry__typeoff_snprintf, .se_width_idx = HISTC_TYPE_OFFSET, }; /* --sort typecln */ /* TODO: use actual value in the system */ #define TYPE_CACHELINE_SIZE 64 static int64_t sort__typecln_sort(struct hist_entry *left, struct hist_entry *right) { struct annotated_data_type *left_type = left->mem_type; struct annotated_data_type *right_type = right->mem_type; int64_t left_cln, right_cln; int64_t ret; if (!left_type) { sort__type_init(left); left_type = left->mem_type; } if (!right_type) { sort__type_init(right); right_type = right->mem_type; } ret = strcmp(left_type->self.type_name, right_type->self.type_name); if (ret) return ret; left_cln = left->mem_type_off / TYPE_CACHELINE_SIZE; right_cln = right->mem_type_off / TYPE_CACHELINE_SIZE; return left_cln - right_cln; } static int hist_entry__typecln_snprintf(struct hist_entry *he, char *bf, size_t size, unsigned int width __maybe_unused) { struct annotated_data_type *he_type = he->mem_type; return repsep_snprintf(bf, size, "%s: cache-line %d", he_type->self.type_name, he->mem_type_off / TYPE_CACHELINE_SIZE); } struct sort_entry sort_type_cacheline = { .se_header = "Data Type Cacheline", .se_cmp = sort__type_cmp, .se_collapse = sort__typecln_sort, .se_sort = sort__typecln_sort, .se_init = sort__type_init, .se_snprintf = hist_entry__typecln_snprintf, .se_width_idx = HISTC_TYPE_CACHELINE, }; struct sort_dimension { const char *name; struct sort_entry *entry; int taken; }; int __weak arch_support_sort_key(const char *sort_key __maybe_unused) { return 0; } const char * __weak arch_perf_header_entry(const char *se_header) { return se_header; } static void sort_dimension_add_dynamic_header(struct sort_dimension *sd) { sd->entry->se_header = arch_perf_header_entry(sd->entry->se_header); } #define DIM(d, n, func) [d] = { .name = n, .entry = &(func) } static struct sort_dimension common_sort_dimensions[] = { DIM(SORT_PID, "pid", sort_thread), DIM(SORT_COMM, "comm", sort_comm), DIM(SORT_DSO, "dso", sort_dso), DIM(SORT_SYM, "symbol", sort_sym), DIM(SORT_PARENT, "parent", sort_parent), DIM(SORT_CPU, "cpu", sort_cpu), DIM(SORT_SOCKET, "socket", sort_socket), DIM(SORT_SRCLINE, "srcline", sort_srcline), DIM(SORT_SRCFILE, "srcfile", sort_srcfile), DIM(SORT_LOCAL_WEIGHT, "local_weight", sort_local_weight), DIM(SORT_GLOBAL_WEIGHT, "weight", sort_global_weight), DIM(SORT_TRANSACTION, "transaction", sort_transaction), #ifdef HAVE_LIBTRACEEVENT DIM(SORT_TRACE, "trace", sort_trace), #endif DIM(SORT_SYM_SIZE, "symbol_size", sort_sym_size), DIM(SORT_DSO_SIZE, "dso_size", sort_dso_size), DIM(SORT_CGROUP, "cgroup", sort_cgroup), DIM(SORT_CGROUP_ID, "cgroup_id", sort_cgroup_id), DIM(SORT_SYM_IPC_NULL, "ipc_null", sort_sym_ipc_null), DIM(SORT_TIME, "time", sort_time), DIM(SORT_CODE_PAGE_SIZE, "code_page_size", sort_code_page_size), DIM(SORT_LOCAL_INS_LAT, "local_ins_lat", sort_local_ins_lat), DIM(SORT_GLOBAL_INS_LAT, "ins_lat", sort_global_ins_lat), DIM(SORT_LOCAL_PIPELINE_STAGE_CYC, "local_p_stage_cyc", sort_local_p_stage_cyc), DIM(SORT_GLOBAL_PIPELINE_STAGE_CYC, "p_stage_cyc", sort_global_p_stage_cyc), DIM(SORT_ADDR, "addr", sort_addr), DIM(SORT_LOCAL_RETIRE_LAT, "local_retire_lat", sort_local_p_stage_cyc), DIM(SORT_GLOBAL_RETIRE_LAT, "retire_lat", sort_global_p_stage_cyc), DIM(SORT_SIMD, "simd", sort_simd), DIM(SORT_ANNOTATE_DATA_TYPE, "type", sort_type), DIM(SORT_ANNOTATE_DATA_TYPE_OFFSET, "typeoff", sort_type_offset), DIM(SORT_SYM_OFFSET, "symoff", sort_sym_offset), DIM(SORT_ANNOTATE_DATA_TYPE_CACHELINE, "typecln", sort_type_cacheline), }; #undef DIM #define DIM(d, n, func) [d - __SORT_BRANCH_STACK] = { .name = n, .entry = &(func) } static struct sort_dimension bstack_sort_dimensions[] = { DIM(SORT_DSO_FROM, "dso_from", sort_dso_from), DIM(SORT_DSO_TO, "dso_to", sort_dso_to), DIM(SORT_SYM_FROM, "symbol_from", sort_sym_from), DIM(SORT_SYM_TO, "symbol_to", sort_sym_to), DIM(SORT_MISPREDICT, "mispredict", sort_mispredict), DIM(SORT_IN_TX, "in_tx", sort_in_tx), DIM(SORT_ABORT, "abort", sort_abort), DIM(SORT_CYCLES, "cycles", sort_cycles), DIM(SORT_SRCLINE_FROM, "srcline_from", sort_srcline_from), DIM(SORT_SRCLINE_TO, "srcline_to", sort_srcline_to), DIM(SORT_SYM_IPC, "ipc_lbr", sort_sym_ipc), DIM(SORT_ADDR_FROM, "addr_from", sort_addr_from), DIM(SORT_ADDR_TO, "addr_to", sort_addr_to), }; #undef DIM #define DIM(d, n, func) [d - __SORT_MEMORY_MODE] = { .name = n, .entry = &(func) } static struct sort_dimension memory_sort_dimensions[] = { DIM(SORT_MEM_DADDR_SYMBOL, "symbol_daddr", sort_mem_daddr_sym), DIM(SORT_MEM_IADDR_SYMBOL, "symbol_iaddr", sort_mem_iaddr_sym), DIM(SORT_MEM_DADDR_DSO, "dso_daddr", sort_mem_daddr_dso), DIM(SORT_MEM_LOCKED, "locked", sort_mem_locked), DIM(SORT_MEM_TLB, "tlb", sort_mem_tlb), DIM(SORT_MEM_LVL, "mem", sort_mem_lvl), DIM(SORT_MEM_SNOOP, "snoop", sort_mem_snoop), DIM(SORT_MEM_DCACHELINE, "dcacheline", sort_mem_dcacheline), DIM(SORT_MEM_PHYS_DADDR, "phys_daddr", sort_mem_phys_daddr), DIM(SORT_MEM_DATA_PAGE_SIZE, "data_page_size", sort_mem_data_page_size), DIM(SORT_MEM_BLOCKED, "blocked", sort_mem_blocked), }; #undef DIM struct hpp_dimension { const char *name; struct perf_hpp_fmt *fmt; int taken; }; #define DIM(d, n) { .name = n, .fmt = &perf_hpp__format[d], } static struct hpp_dimension hpp_sort_dimensions[] = { DIM(PERF_HPP__OVERHEAD, "overhead"), DIM(PERF_HPP__OVERHEAD_SYS, "overhead_sys"), DIM(PERF_HPP__OVERHEAD_US, "overhead_us"), DIM(PERF_HPP__OVERHEAD_GUEST_SYS, "overhead_guest_sys"), DIM(PERF_HPP__OVERHEAD_GUEST_US, "overhead_guest_us"), DIM(PERF_HPP__OVERHEAD_ACC, "overhead_children"), DIM(PERF_HPP__SAMPLES, "sample"), DIM(PERF_HPP__PERIOD, "period"), DIM(PERF_HPP__WEIGHT1, "weight1"), DIM(PERF_HPP__WEIGHT2, "weight2"), DIM(PERF_HPP__WEIGHT3, "weight3"), /* aliases for weight_struct */ DIM(PERF_HPP__WEIGHT2, "ins_lat"), DIM(PERF_HPP__WEIGHT3, "retire_lat"), DIM(PERF_HPP__WEIGHT3, "p_stage_cyc"), }; #undef DIM struct hpp_sort_entry { struct perf_hpp_fmt hpp; struct sort_entry *se; }; void perf_hpp__reset_sort_width(struct perf_hpp_fmt *fmt, struct hists *hists) { struct hpp_sort_entry *hse; if (!perf_hpp__is_sort_entry(fmt)) return; hse = container_of(fmt, struct hpp_sort_entry, hpp); hists__new_col_len(hists, hse->se->se_width_idx, strlen(fmt->name)); } static int __sort__hpp_header(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp, struct hists *hists, int line __maybe_unused, int *span __maybe_unused) { struct hpp_sort_entry *hse; size_t len = fmt->user_len; hse = container_of(fmt, struct hpp_sort_entry, hpp); if (!len) len = hists__col_len(hists, hse->se->se_width_idx); return scnprintf(hpp->buf, hpp->size, "%-*.*s", len, len, fmt->name); } static int __sort__hpp_width(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp __maybe_unused, struct hists *hists) { struct hpp_sort_entry *hse; size_t len = fmt->user_len; hse = container_of(fmt, struct hpp_sort_entry, hpp); if (!len) len = hists__col_len(hists, hse->se->se_width_idx); return len; } static int __sort__hpp_entry(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp, struct hist_entry *he) { struct hpp_sort_entry *hse; size_t len = fmt->user_len; hse = container_of(fmt, struct hpp_sort_entry, hpp); if (!len) len = hists__col_len(he->hists, hse->se->se_width_idx); return hse->se->se_snprintf(he, hpp->buf, hpp->size, len); } static int64_t __sort__hpp_cmp(struct perf_hpp_fmt *fmt, struct hist_entry *a, struct hist_entry *b) { struct hpp_sort_entry *hse; hse = container_of(fmt, struct hpp_sort_entry, hpp); return hse->se->se_cmp(a, b); } static int64_t __sort__hpp_collapse(struct perf_hpp_fmt *fmt, struct hist_entry *a, struct hist_entry *b) { struct hpp_sort_entry *hse; int64_t (*collapse_fn)(struct hist_entry *, struct hist_entry *); hse = container_of(fmt, struct hpp_sort_entry, hpp); collapse_fn = hse->se->se_collapse ?: hse->se->se_cmp; return collapse_fn(a, b); } static int64_t __sort__hpp_sort(struct perf_hpp_fmt *fmt, struct hist_entry *a, struct hist_entry *b) { struct hpp_sort_entry *hse; int64_t (*sort_fn)(struct hist_entry *, struct hist_entry *); hse = container_of(fmt, struct hpp_sort_entry, hpp); sort_fn = hse->se->se_sort ?: hse->se->se_cmp; return sort_fn(a, b); } bool perf_hpp__is_sort_entry(struct perf_hpp_fmt *format) { return format->header == __sort__hpp_header; } #define MK_SORT_ENTRY_CHK(key) \ bool perf_hpp__is_ ## key ## _entry(struct perf_hpp_fmt *fmt) \ { \ struct hpp_sort_entry *hse; \ \ if (!perf_hpp__is_sort_entry(fmt)) \ return false; \ \ hse = container_of(fmt, struct hpp_sort_entry, hpp); \ return hse->se == &sort_ ## key ; \ } #ifdef HAVE_LIBTRACEEVENT MK_SORT_ENTRY_CHK(trace) #else bool perf_hpp__is_trace_entry(struct perf_hpp_fmt *fmt __maybe_unused) { return false; } #endif MK_SORT_ENTRY_CHK(srcline) MK_SORT_ENTRY_CHK(srcfile) MK_SORT_ENTRY_CHK(thread) MK_SORT_ENTRY_CHK(comm) MK_SORT_ENTRY_CHK(dso) MK_SORT_ENTRY_CHK(sym) static bool __sort__hpp_equal(struct perf_hpp_fmt *a, struct perf_hpp_fmt *b) { struct hpp_sort_entry *hse_a; struct hpp_sort_entry *hse_b; if (!perf_hpp__is_sort_entry(a) || !perf_hpp__is_sort_entry(b)) return false; hse_a = container_of(a, struct hpp_sort_entry, hpp); hse_b = container_of(b, struct hpp_sort_entry, hpp); return hse_a->se == hse_b->se; } static void hse_free(struct perf_hpp_fmt *fmt) { struct hpp_sort_entry *hse; hse = container_of(fmt, struct hpp_sort_entry, hpp); free(hse); } static void hse_init(struct perf_hpp_fmt *fmt, struct hist_entry *he) { struct hpp_sort_entry *hse; if (!perf_hpp__is_sort_entry(fmt)) return; hse = container_of(fmt, struct hpp_sort_entry, hpp); if (hse->se->se_init) hse->se->se_init(he); } static struct hpp_sort_entry * __sort_dimension__alloc_hpp(struct sort_dimension *sd, int level) { struct hpp_sort_entry *hse; hse = malloc(sizeof(*hse)); if (hse == NULL) { pr_err("Memory allocation failed\n"); return NULL; } hse->se = sd->entry; hse->hpp.name = sd->entry->se_header; hse->hpp.header = __sort__hpp_header; hse->hpp.width = __sort__hpp_width; hse->hpp.entry = __sort__hpp_entry; hse->hpp.color = NULL; hse->hpp.cmp = __sort__hpp_cmp; hse->hpp.collapse = __sort__hpp_collapse; hse->hpp.sort = __sort__hpp_sort; hse->hpp.equal = __sort__hpp_equal; hse->hpp.free = hse_free; hse->hpp.init = hse_init; INIT_LIST_HEAD(&hse->hpp.list); INIT_LIST_HEAD(&hse->hpp.sort_list); hse->hpp.elide = false; hse->hpp.len = 0; hse->hpp.user_len = 0; hse->hpp.level = level; return hse; } static void hpp_free(struct perf_hpp_fmt *fmt) { free(fmt); } static struct perf_hpp_fmt *__hpp_dimension__alloc_hpp(struct hpp_dimension *hd, int level) { struct perf_hpp_fmt *fmt; fmt = memdup(hd->fmt, sizeof(*fmt)); if (fmt) { INIT_LIST_HEAD(&fmt->list); INIT_LIST_HEAD(&fmt->sort_list); fmt->free = hpp_free; fmt->level = level; } return fmt; } int hist_entry__filter(struct hist_entry *he, int type, const void *arg) { struct perf_hpp_fmt *fmt; struct hpp_sort_entry *hse; int ret = -1; int r; perf_hpp_list__for_each_format(he->hpp_list, fmt) { if (!perf_hpp__is_sort_entry(fmt)) continue; hse = container_of(fmt, struct hpp_sort_entry, hpp); if (hse->se->se_filter == NULL) continue; /* * hist entry is filtered if any of sort key in the hpp list * is applied. But it should skip non-matched filter types. */ r = hse->se->se_filter(he, type, arg); if (r >= 0) { if (ret < 0) ret = 0; ret |= r; } } return ret; } static int __sort_dimension__add_hpp_sort(struct sort_dimension *sd, struct perf_hpp_list *list, int level) { struct hpp_sort_entry *hse = __sort_dimension__alloc_hpp(sd, level); if (hse == NULL) return -1; perf_hpp_list__register_sort_field(list, &hse->hpp); return 0; } static int __sort_dimension__add_hpp_output(struct sort_dimension *sd, struct perf_hpp_list *list) { struct hpp_sort_entry *hse = __sort_dimension__alloc_hpp(sd, 0); if (hse == NULL) return -1; perf_hpp_list__column_register(list, &hse->hpp); return 0; } #ifndef HAVE_LIBTRACEEVENT bool perf_hpp__is_dynamic_entry(struct perf_hpp_fmt *fmt __maybe_unused) { return false; } bool perf_hpp__defined_dynamic_entry(struct perf_hpp_fmt *fmt __maybe_unused, struct hists *hists __maybe_unused) { return false; } #else struct hpp_dynamic_entry { struct perf_hpp_fmt hpp; struct evsel *evsel; struct tep_format_field *field; unsigned dynamic_len; bool raw_trace; }; static int hde_width(struct hpp_dynamic_entry *hde) { if (!hde->hpp.len) { int len = hde->dynamic_len; int namelen = strlen(hde->field->name); int fieldlen = hde->field->size; if (namelen > len) len = namelen; if (!(hde->field->flags & TEP_FIELD_IS_STRING)) { /* length for print hex numbers */ fieldlen = hde->field->size * 2 + 2; } if (fieldlen > len) len = fieldlen; hde->hpp.len = len; } return hde->hpp.len; } static void update_dynamic_len(struct hpp_dynamic_entry *hde, struct hist_entry *he) { char *str, *pos; struct tep_format_field *field = hde->field; size_t namelen; bool last = false; if (hde->raw_trace) return; /* parse pretty print result and update max length */ if (!he->trace_output) he->trace_output = get_trace_output(he); namelen = strlen(field->name); str = he->trace_output; while (str) { pos = strchr(str, ' '); if (pos == NULL) { last = true; pos = str + strlen(str); } if (!strncmp(str, field->name, namelen)) { size_t len; str += namelen + 1; len = pos - str; if (len > hde->dynamic_len) hde->dynamic_len = len; break; } if (last) str = NULL; else str = pos + 1; } } static int __sort__hde_header(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp, struct hists *hists __maybe_unused, int line __maybe_unused, int *span __maybe_unused) { struct hpp_dynamic_entry *hde; size_t len = fmt->user_len; hde = container_of(fmt, struct hpp_dynamic_entry, hpp); if (!len) len = hde_width(hde); return scnprintf(hpp->buf, hpp->size, "%*.*s", len, len, hde->field->name); } static int __sort__hde_width(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp __maybe_unused, struct hists *hists __maybe_unused) { struct hpp_dynamic_entry *hde; size_t len = fmt->user_len; hde = container_of(fmt, struct hpp_dynamic_entry, hpp); if (!len) len = hde_width(hde); return len; } bool perf_hpp__defined_dynamic_entry(struct perf_hpp_fmt *fmt, struct hists *hists) { struct hpp_dynamic_entry *hde; hde = container_of(fmt, struct hpp_dynamic_entry, hpp); return hists_to_evsel(hists) == hde->evsel; } static int __sort__hde_entry(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp, struct hist_entry *he) { struct hpp_dynamic_entry *hde; size_t len = fmt->user_len; char *str, *pos; struct tep_format_field *field; size_t namelen; bool last = false; int ret; hde = container_of(fmt, struct hpp_dynamic_entry, hpp); if (!len) len = hde_width(hde); if (hde->raw_trace) goto raw_field; if (!he->trace_output) he->trace_output = get_trace_output(he); field = hde->field; namelen = strlen(field->name); str = he->trace_output; while (str) { pos = strchr(str, ' '); if (pos == NULL) { last = true; pos = str + strlen(str); } if (!strncmp(str, field->name, namelen)) { str += namelen + 1; str = strndup(str, pos - str); if (str == NULL) return scnprintf(hpp->buf, hpp->size, "%*.*s", len, len, "ERROR"); break; } if (last) str = NULL; else str = pos + 1; } if (str == NULL) { struct trace_seq seq; raw_field: trace_seq_init(&seq); tep_print_field(&seq, he->raw_data, hde->field); str = seq.buffer; } ret = scnprintf(hpp->buf, hpp->size, "%*.*s", len, len, str); free(str); return ret; } static int64_t __sort__hde_cmp(struct perf_hpp_fmt *fmt, struct hist_entry *a, struct hist_entry *b) { struct hpp_dynamic_entry *hde; struct tep_format_field *field; unsigned offset, size; hde = container_of(fmt, struct hpp_dynamic_entry, hpp); field = hde->field; if (field->flags & TEP_FIELD_IS_DYNAMIC) { unsigned long long dyn; tep_read_number_field(field, a->raw_data, &dyn); offset = dyn & 0xffff; size = (dyn >> 16) & 0xffff; if (tep_field_is_relative(field->flags)) offset += field->offset + field->size; /* record max width for output */ if (size > hde->dynamic_len) hde->dynamic_len = size; } else { offset = field->offset; size = field->size; } return memcmp(a->raw_data + offset, b->raw_data + offset, size); } bool perf_hpp__is_dynamic_entry(struct perf_hpp_fmt *fmt) { return fmt->cmp == __sort__hde_cmp; } static bool __sort__hde_equal(struct perf_hpp_fmt *a, struct perf_hpp_fmt *b) { struct hpp_dynamic_entry *hde_a; struct hpp_dynamic_entry *hde_b; if (!perf_hpp__is_dynamic_entry(a) || !perf_hpp__is_dynamic_entry(b)) return false; hde_a = container_of(a, struct hpp_dynamic_entry, hpp); hde_b = container_of(b, struct hpp_dynamic_entry, hpp); return hde_a->field == hde_b->field; } static void hde_free(struct perf_hpp_fmt *fmt) { struct hpp_dynamic_entry *hde; hde = container_of(fmt, struct hpp_dynamic_entry, hpp); free(hde); } static void __sort__hde_init(struct perf_hpp_fmt *fmt, struct hist_entry *he) { struct hpp_dynamic_entry *hde; if (!perf_hpp__is_dynamic_entry(fmt)) return; hde = container_of(fmt, struct hpp_dynamic_entry, hpp); update_dynamic_len(hde, he); } static struct hpp_dynamic_entry * __alloc_dynamic_entry(struct evsel *evsel, struct tep_format_field *field, int level) { struct hpp_dynamic_entry *hde; hde = malloc(sizeof(*hde)); if (hde == NULL) { pr_debug("Memory allocation failed\n"); return NULL; } hde->evsel = evsel; hde->field = field; hde->dynamic_len = 0; hde->hpp.name = field->name; hde->hpp.header = __sort__hde_header; hde->hpp.width = __sort__hde_width; hde->hpp.entry = __sort__hde_entry; hde->hpp.color = NULL; hde->hpp.init = __sort__hde_init; hde->hpp.cmp = __sort__hde_cmp; hde->hpp.collapse = __sort__hde_cmp; hde->hpp.sort = __sort__hde_cmp; hde->hpp.equal = __sort__hde_equal; hde->hpp.free = hde_free; INIT_LIST_HEAD(&hde->hpp.list); INIT_LIST_HEAD(&hde->hpp.sort_list); hde->hpp.elide = false; hde->hpp.len = 0; hde->hpp.user_len = 0; hde->hpp.level = level; return hde; } #endif /* HAVE_LIBTRACEEVENT */ struct perf_hpp_fmt *perf_hpp_fmt__dup(struct perf_hpp_fmt *fmt) { struct perf_hpp_fmt *new_fmt = NULL; if (perf_hpp__is_sort_entry(fmt)) { struct hpp_sort_entry *hse, *new_hse; hse = container_of(fmt, struct hpp_sort_entry, hpp); new_hse = memdup(hse, sizeof(*hse)); if (new_hse) new_fmt = &new_hse->hpp; #ifdef HAVE_LIBTRACEEVENT } else if (perf_hpp__is_dynamic_entry(fmt)) { struct hpp_dynamic_entry *hde, *new_hde; hde = container_of(fmt, struct hpp_dynamic_entry, hpp); new_hde = memdup(hde, sizeof(*hde)); if (new_hde) new_fmt = &new_hde->hpp; #endif } else { new_fmt = memdup(fmt, sizeof(*fmt)); } INIT_LIST_HEAD(&new_fmt->list); INIT_LIST_HEAD(&new_fmt->sort_list); return new_fmt; } static int parse_field_name(char *str, char **event, char **field, char **opt) { char *event_name, *field_name, *opt_name; event_name = str; field_name = strchr(str, '.'); if (field_name) { *field_name++ = '\0'; } else { event_name = NULL; field_name = str; } opt_name = strchr(field_name, '/'); if (opt_name) *opt_name++ = '\0'; *event = event_name; *field = field_name; *opt = opt_name; return 0; } /* find match evsel using a given event name. The event name can be: * 1. '%' + event index (e.g. '%1' for first event) * 2. full event name (e.g. sched:sched_switch) * 3. partial event name (should not contain ':') */ static struct evsel *find_evsel(struct evlist *evlist, char *event_name) { struct evsel *evsel = NULL; struct evsel *pos; bool full_name; /* case 1 */ if (event_name[0] == '%') { int nr = strtol(event_name+1, NULL, 0); if (nr > evlist->core.nr_entries) return NULL; evsel = evlist__first(evlist); while (--nr > 0) evsel = evsel__next(evsel); return evsel; } full_name = !!strchr(event_name, ':'); evlist__for_each_entry(evlist, pos) { /* case 2 */ if (full_name && evsel__name_is(pos, event_name)) return pos; /* case 3 */ if (!full_name && strstr(pos->name, event_name)) { if (evsel) { pr_debug("'%s' event is ambiguous: it can be %s or %s\n", event_name, evsel->name, pos->name); return NULL; } evsel = pos; } } return evsel; } #ifdef HAVE_LIBTRACEEVENT static int __dynamic_dimension__add(struct evsel *evsel, struct tep_format_field *field, bool raw_trace, int level) { struct hpp_dynamic_entry *hde; hde = __alloc_dynamic_entry(evsel, field, level); if (hde == NULL) return -ENOMEM; hde->raw_trace = raw_trace; perf_hpp__register_sort_field(&hde->hpp); return 0; } static int add_evsel_fields(struct evsel *evsel, bool raw_trace, int level) { int ret; struct tep_format_field *field; field = evsel->tp_format->format.fields; while (field) { ret = __dynamic_dimension__add(evsel, field, raw_trace, level); if (ret < 0) return ret; field = field->next; } return 0; } static int add_all_dynamic_fields(struct evlist *evlist, bool raw_trace, int level) { int ret; struct evsel *evsel; evlist__for_each_entry(evlist, evsel) { if (evsel->core.attr.type != PERF_TYPE_TRACEPOINT) continue; ret = add_evsel_fields(evsel, raw_trace, level); if (ret < 0) return ret; } return 0; } static int add_all_matching_fields(struct evlist *evlist, char *field_name, bool raw_trace, int level) { int ret = -ESRCH; struct evsel *evsel; struct tep_format_field *field; evlist__for_each_entry(evlist, evsel) { if (evsel->core.attr.type != PERF_TYPE_TRACEPOINT) continue; field = tep_find_any_field(evsel->tp_format, field_name); if (field == NULL) continue; ret = __dynamic_dimension__add(evsel, field, raw_trace, level); if (ret < 0) break; } return ret; } #endif /* HAVE_LIBTRACEEVENT */ static int add_dynamic_entry(struct evlist *evlist, const char *tok, int level) { char *str, *event_name, *field_name, *opt_name; struct evsel *evsel; bool raw_trace = symbol_conf.raw_trace; int ret = 0; if (evlist == NULL) return -ENOENT; str = strdup(tok); if (str == NULL) return -ENOMEM; if (parse_field_name(str, &event_name, &field_name, &opt_name) < 0) { ret = -EINVAL; goto out; } if (opt_name) { if (strcmp(opt_name, "raw")) { pr_debug("unsupported field option %s\n", opt_name); ret = -EINVAL; goto out; } raw_trace = true; } #ifdef HAVE_LIBTRACEEVENT if (!strcmp(field_name, "trace_fields")) { ret = add_all_dynamic_fields(evlist, raw_trace, level); goto out; } if (event_name == NULL) { ret = add_all_matching_fields(evlist, field_name, raw_trace, level); goto out; } #else evlist__for_each_entry(evlist, evsel) { if (evsel->core.attr.type == PERF_TYPE_TRACEPOINT) { pr_err("%s %s", ret ? "," : "This perf binary isn't linked with libtraceevent, can't process", evsel__name(evsel)); ret = -ENOTSUP; } } if (ret) { pr_err("\n"); goto out; } #endif evsel = find_evsel(evlist, event_name); if (evsel == NULL) { pr_debug("Cannot find event: %s\n", event_name); ret = -ENOENT; goto out; } if (evsel->core.attr.type != PERF_TYPE_TRACEPOINT) { pr_debug("%s is not a tracepoint event\n", event_name); ret = -EINVAL; goto out; } #ifdef HAVE_LIBTRACEEVENT if (!strcmp(field_name, "*")) { ret = add_evsel_fields(evsel, raw_trace, level); } else { struct tep_format_field *field = tep_find_any_field(evsel->tp_format, field_name); if (field == NULL) { pr_debug("Cannot find event field for %s.%s\n", event_name, field_name); return -ENOENT; } ret = __dynamic_dimension__add(evsel, field, raw_trace, level); } #else (void)level; (void)raw_trace; #endif /* HAVE_LIBTRACEEVENT */ out: free(str); return ret; } static int __sort_dimension__add(struct sort_dimension *sd, struct perf_hpp_list *list, int level) { if (sd->taken) return 0; if (__sort_dimension__add_hpp_sort(sd, list, level) < 0) return -1; if (sd->entry->se_collapse) list->need_collapse = 1; sd->taken = 1; return 0; } static int __hpp_dimension__add(struct hpp_dimension *hd, struct perf_hpp_list *list, int level) { struct perf_hpp_fmt *fmt; if (hd->taken) return 0; fmt = __hpp_dimension__alloc_hpp(hd, level); if (!fmt) return -1; hd->taken = 1; perf_hpp_list__register_sort_field(list, fmt); return 0; } static int __sort_dimension__add_output(struct perf_hpp_list *list, struct sort_dimension *sd) { if (sd->taken) return 0; if (__sort_dimension__add_hpp_output(sd, list) < 0) return -1; sd->taken = 1; return 0; } static int __hpp_dimension__add_output(struct perf_hpp_list *list, struct hpp_dimension *hd) { struct perf_hpp_fmt *fmt; if (hd->taken) return 0; fmt = __hpp_dimension__alloc_hpp(hd, 0); if (!fmt) return -1; hd->taken = 1; perf_hpp_list__column_register(list, fmt); return 0; } int hpp_dimension__add_output(unsigned col) { BUG_ON(col >= PERF_HPP__MAX_INDEX); return __hpp_dimension__add_output(&perf_hpp_list, &hpp_sort_dimensions[col]); } int sort_dimension__add(struct perf_hpp_list *list, const char *tok, struct evlist *evlist, int level) { unsigned int i, j; /* * Check to see if there are any arch specific * sort dimensions not applicable for the current * architecture. If so, Skip that sort key since * we don't want to display it in the output fields. */ for (j = 0; j < ARRAY_SIZE(arch_specific_sort_keys); j++) { if (!strcmp(arch_specific_sort_keys[j], tok) && !arch_support_sort_key(tok)) { return 0; } } for (i = 0; i < ARRAY_SIZE(common_sort_dimensions); i++) { struct sort_dimension *sd = &common_sort_dimensions[i]; if (!sd->name || strncasecmp(tok, sd->name, strlen(tok))) continue; for (j = 0; j < ARRAY_SIZE(dynamic_headers); j++) { if (sd->name && !strcmp(dynamic_headers[j], sd->name)) sort_dimension_add_dynamic_header(sd); } if (sd->entry == &sort_parent && parent_pattern) { int ret = regcomp(&parent_regex, parent_pattern, REG_EXTENDED); if (ret) { char err[BUFSIZ]; regerror(ret, &parent_regex, err, sizeof(err)); pr_err("Invalid regex: %s\n%s", parent_pattern, err); return -EINVAL; } list->parent = 1; } else if (sd->entry == &sort_sym) { list->sym = 1; /* * perf diff displays the performance difference amongst * two or more perf.data files. Those files could come * from different binaries. So we should not compare * their ips, but the name of symbol. */ if (sort__mode == SORT_MODE__DIFF) sd->entry->se_collapse = sort__sym_sort; } else if (sd->entry == &sort_dso) { list->dso = 1; } else if (sd->entry == &sort_socket) { list->socket = 1; } else if (sd->entry == &sort_thread) { list->thread = 1; } else if (sd->entry == &sort_comm) { list->comm = 1; } else if (sd->entry == &sort_type_offset) { symbol_conf.annotate_data_member = true; } return __sort_dimension__add(sd, list, level); } for (i = 0; i < ARRAY_SIZE(hpp_sort_dimensions); i++) { struct hpp_dimension *hd = &hpp_sort_dimensions[i]; if (strncasecmp(tok, hd->name, strlen(tok))) continue; return __hpp_dimension__add(hd, list, level); } for (i = 0; i < ARRAY_SIZE(bstack_sort_dimensions); i++) { struct sort_dimension *sd = &bstack_sort_dimensions[i]; if (!sd->name || strncasecmp(tok, sd->name, strlen(tok))) continue; if (sort__mode != SORT_MODE__BRANCH) return -EINVAL; if (sd->entry == &sort_sym_from || sd->entry == &sort_sym_to) list->sym = 1; __sort_dimension__add(sd, list, level); return 0; } for (i = 0; i < ARRAY_SIZE(memory_sort_dimensions); i++) { struct sort_dimension *sd = &memory_sort_dimensions[i]; if (!sd->name || strncasecmp(tok, sd->name, strlen(tok))) continue; if (sort__mode != SORT_MODE__MEMORY) return -EINVAL; if (sd->entry == &sort_mem_dcacheline && cacheline_size() == 0) return -EINVAL; if (sd->entry == &sort_mem_daddr_sym) list->sym = 1; __sort_dimension__add(sd, list, level); return 0; } if (!add_dynamic_entry(evlist, tok, level)) return 0; return -ESRCH; } static int setup_sort_list(struct perf_hpp_list *list, char *str, struct evlist *evlist) { char *tmp, *tok; int ret = 0; int level = 0; int next_level = 1; bool in_group = false; do { tok = str; tmp = strpbrk(str, "{}, "); if (tmp) { if (in_group) next_level = level; else next_level = level + 1; if (*tmp == '{') in_group = true; else if (*tmp == '}') in_group = false; *tmp = '\0'; str = tmp + 1; } if (*tok) { ret = sort_dimension__add(list, tok, evlist, level); if (ret == -EINVAL) { if (!cacheline_size() && !strncasecmp(tok, "dcacheline", strlen(tok))) ui__error("The \"dcacheline\" --sort key needs to know the cacheline size and it couldn't be determined on this system"); else ui__error("Invalid --sort key: `%s'", tok); break; } else if (ret == -ESRCH) { ui__error("Unknown --sort key: `%s'", tok); break; } } level = next_level; } while (tmp); return ret; } static const char *get_default_sort_order(struct evlist *evlist) { const char *default_sort_orders[] = { default_sort_order, default_branch_sort_order, default_mem_sort_order, default_top_sort_order, default_diff_sort_order, default_tracepoint_sort_order, }; bool use_trace = true; struct evsel *evsel; BUG_ON(sort__mode >= ARRAY_SIZE(default_sort_orders)); if (evlist == NULL || evlist__empty(evlist)) goto out_no_evlist; evlist__for_each_entry(evlist, evsel) { if (evsel->core.attr.type != PERF_TYPE_TRACEPOINT) { use_trace = false; break; } } if (use_trace) { sort__mode = SORT_MODE__TRACEPOINT; if (symbol_conf.raw_trace) return "trace_fields"; } out_no_evlist: return default_sort_orders[sort__mode]; } static int setup_sort_order(struct evlist *evlist) { char *new_sort_order; /* * Append '+'-prefixed sort order to the default sort * order string. */ if (!sort_order || is_strict_order(sort_order)) return 0; if (sort_order[1] == '\0') { ui__error("Invalid --sort key: `+'"); return -EINVAL; } /* * We allocate new sort_order string, but we never free it, * because it's checked over the rest of the code. */ if (asprintf(&new_sort_order, "%s,%s", get_default_sort_order(evlist), sort_order + 1) < 0) { pr_err("Not enough memory to set up --sort"); return -ENOMEM; } sort_order = new_sort_order; return 0; } /* * Adds 'pre,' prefix into 'str' is 'pre' is * not already part of 'str'. */ static char *prefix_if_not_in(const char *pre, char *str) { char *n; if (!str || strstr(str, pre)) return str; if (asprintf(&n, "%s,%s", pre, str) < 0) n = NULL; free(str); return n; } static char *setup_overhead(char *keys) { if (sort__mode == SORT_MODE__DIFF) return keys; keys = prefix_if_not_in("overhead", keys); if (symbol_conf.cumulate_callchain) keys = prefix_if_not_in("overhead_children", keys); return keys; } static int __setup_sorting(struct evlist *evlist) { char *str; const char *sort_keys; int ret = 0; ret = setup_sort_order(evlist); if (ret) return ret; sort_keys = sort_order; if (sort_keys == NULL) { if (is_strict_order(field_order)) { /* * If user specified field order but no sort order, * we'll honor it and not add default sort orders. */ return 0; } sort_keys = get_default_sort_order(evlist); } str = strdup(sort_keys); if (str == NULL) { pr_err("Not enough memory to setup sort keys"); return -ENOMEM; } /* * Prepend overhead fields for backward compatibility. */ if (!is_strict_order(field_order)) { str = setup_overhead(str); if (str == NULL) { pr_err("Not enough memory to setup overhead keys"); return -ENOMEM; } } ret = setup_sort_list(&perf_hpp_list, str, evlist); free(str); return ret; } void perf_hpp__set_elide(int idx, bool elide) { struct perf_hpp_fmt *fmt; struct hpp_sort_entry *hse; perf_hpp_list__for_each_format(&perf_hpp_list, fmt) { if (!perf_hpp__is_sort_entry(fmt)) continue; hse = container_of(fmt, struct hpp_sort_entry, hpp); if (hse->se->se_width_idx == idx) { fmt->elide = elide; break; } } } static bool __get_elide(struct strlist *list, const char *list_name, FILE *fp) { if (list && strlist__nr_entries(list) == 1) { if (fp != NULL) fprintf(fp, "# %s: %s\n", list_name, strlist__entry(list, 0)->s); return true; } return false; } static bool get_elide(int idx, FILE *output) { switch (idx) { case HISTC_SYMBOL: return __get_elide(symbol_conf.sym_list, "symbol", output); case HISTC_DSO: return __get_elide(symbol_conf.dso_list, "dso", output); case HISTC_COMM: return __get_elide(symbol_conf.comm_list, "comm", output); default: break; } if (sort__mode != SORT_MODE__BRANCH) return false; switch (idx) { case HISTC_SYMBOL_FROM: return __get_elide(symbol_conf.sym_from_list, "sym_from", output); case HISTC_SYMBOL_TO: return __get_elide(symbol_conf.sym_to_list, "sym_to", output); case HISTC_DSO_FROM: return __get_elide(symbol_conf.dso_from_list, "dso_from", output); case HISTC_DSO_TO: return __get_elide(symbol_conf.dso_to_list, "dso_to", output); case HISTC_ADDR_FROM: return __get_elide(symbol_conf.sym_from_list, "addr_from", output); case HISTC_ADDR_TO: return __get_elide(symbol_conf.sym_to_list, "addr_to", output); default: break; } return false; } void sort__setup_elide(FILE *output) { struct perf_hpp_fmt *fmt; struct hpp_sort_entry *hse; perf_hpp_list__for_each_format(&perf_hpp_list, fmt) { if (!perf_hpp__is_sort_entry(fmt)) continue; hse = container_of(fmt, struct hpp_sort_entry, hpp); fmt->elide = get_elide(hse->se->se_width_idx, output); } /* * It makes no sense to elide all of sort entries. * Just revert them to show up again. */ perf_hpp_list__for_each_format(&perf_hpp_list, fmt) { if (!perf_hpp__is_sort_entry(fmt)) continue; if (!fmt->elide) return; } perf_hpp_list__for_each_format(&perf_hpp_list, fmt) { if (!perf_hpp__is_sort_entry(fmt)) continue; fmt->elide = false; } } int output_field_add(struct perf_hpp_list *list, const char *tok) { unsigned int i; for (i = 0; i < ARRAY_SIZE(hpp_sort_dimensions); i++) { struct hpp_dimension *hd = &hpp_sort_dimensions[i]; if (strncasecmp(tok, hd->name, strlen(tok))) continue; if (!strcasecmp(tok, "weight")) ui__warning("--fields weight shows the average value unlike in the --sort key.\n"); return __hpp_dimension__add_output(list, hd); } for (i = 0; i < ARRAY_SIZE(common_sort_dimensions); i++) { struct sort_dimension *sd = &common_sort_dimensions[i]; if (!sd->name || strncasecmp(tok, sd->name, strlen(tok))) continue; return __sort_dimension__add_output(list, sd); } for (i = 0; i < ARRAY_SIZE(bstack_sort_dimensions); i++) { struct sort_dimension *sd = &bstack_sort_dimensions[i]; if (!sd->name || strncasecmp(tok, sd->name, strlen(tok))) continue; if (sort__mode != SORT_MODE__BRANCH) return -EINVAL; return __sort_dimension__add_output(list, sd); } for (i = 0; i < ARRAY_SIZE(memory_sort_dimensions); i++) { struct sort_dimension *sd = &memory_sort_dimensions[i]; if (!sd->name || strncasecmp(tok, sd->name, strlen(tok))) continue; if (sort__mode != SORT_MODE__MEMORY) return -EINVAL; return __sort_dimension__add_output(list, sd); } return -ESRCH; } static int setup_output_list(struct perf_hpp_list *list, char *str) { char *tmp, *tok; int ret = 0; for (tok = strtok_r(str, ", ", &tmp); tok; tok = strtok_r(NULL, ", ", &tmp)) { ret = output_field_add(list, tok); if (ret == -EINVAL) { ui__error("Invalid --fields key: `%s'", tok); break; } else if (ret == -ESRCH) { ui__error("Unknown --fields key: `%s'", tok); break; } } return ret; } void reset_dimensions(void) { unsigned int i; for (i = 0; i < ARRAY_SIZE(common_sort_dimensions); i++) common_sort_dimensions[i].taken = 0; for (i = 0; i < ARRAY_SIZE(hpp_sort_dimensions); i++) hpp_sort_dimensions[i].taken = 0; for (i = 0; i < ARRAY_SIZE(bstack_sort_dimensions); i++) bstack_sort_dimensions[i].taken = 0; for (i = 0; i < ARRAY_SIZE(memory_sort_dimensions); i++) memory_sort_dimensions[i].taken = 0; } bool is_strict_order(const char *order) { return order && (*order != '+'); } static int __setup_output_field(void) { char *str, *strp; int ret = -EINVAL; if (field_order == NULL) return 0; strp = str = strdup(field_order); if (str == NULL) { pr_err("Not enough memory to setup output fields"); return -ENOMEM; } if (!is_strict_order(field_order)) strp++; if (!strlen(strp)) { ui__error("Invalid --fields key: `+'"); goto out; } ret = setup_output_list(&perf_hpp_list, strp); out: free(str); return ret; } int setup_sorting(struct evlist *evlist) { int err; err = __setup_sorting(evlist); if (err < 0) return err; if (parent_pattern != default_parent_pattern) { err = sort_dimension__add(&perf_hpp_list, "parent", evlist, -1); if (err < 0) return err; } reset_dimensions(); /* * perf diff doesn't use default hpp output fields. */ if (sort__mode != SORT_MODE__DIFF) perf_hpp__init(); err = __setup_output_field(); if (err < 0) return err; /* copy sort keys to output fields */ perf_hpp__setup_output_field(&perf_hpp_list); /* and then copy output fields to sort keys */ perf_hpp__append_sort_keys(&perf_hpp_list); /* setup hists-specific output fields */ if (perf_hpp__setup_hists_formats(&perf_hpp_list, evlist) < 0) return -1; return 0; } void reset_output_field(void) { perf_hpp_list.need_collapse = 0; perf_hpp_list.parent = 0; perf_hpp_list.sym = 0; perf_hpp_list.dso = 0; field_order = NULL; sort_order = NULL; reset_dimensions(); perf_hpp__reset_output_field(&perf_hpp_list); } #define INDENT (3*8 + 1) static void add_key(struct strbuf *sb, const char *str, int *llen) { if (!str) return; if (*llen >= 75) { strbuf_addstr(sb, "\n\t\t\t "); *llen = INDENT; } strbuf_addf(sb, " %s", str); *llen += strlen(str) + 1; } static void add_sort_string(struct strbuf *sb, struct sort_dimension *s, int n, int *llen) { int i; for (i = 0; i < n; i++) add_key(sb, s[i].name, llen); } static void add_hpp_sort_string(struct strbuf *sb, struct hpp_dimension *s, int n, int *llen) { int i; for (i = 0; i < n; i++) add_key(sb, s[i].name, llen); } char *sort_help(const char *prefix, enum sort_mode mode) { struct strbuf sb; char *s; int len = strlen(prefix) + INDENT; strbuf_init(&sb, 300); strbuf_addstr(&sb, prefix); add_hpp_sort_string(&sb, hpp_sort_dimensions, ARRAY_SIZE(hpp_sort_dimensions), &len); add_sort_string(&sb, common_sort_dimensions, ARRAY_SIZE(common_sort_dimensions), &len); if (mode == SORT_MODE__NORMAL || mode == SORT_MODE__BRANCH) add_sort_string(&sb, bstack_sort_dimensions, ARRAY_SIZE(bstack_sort_dimensions), &len); if (mode == SORT_MODE__NORMAL || mode == SORT_MODE__MEMORY) add_sort_string(&sb, memory_sort_dimensions, ARRAY_SIZE(memory_sort_dimensions), &len); s = strbuf_detach(&sb, NULL); strbuf_release(&sb); return s; }
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with Cregit http://github.com/cregit/cregit
Version 2.0-RC1