projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
perf sort: Reorder HISTC_SRCLINE index
[deliverable/linux.git] / tools / perf / util / hist.c
1 #include "annotate.h"
2 #include "util.h"
3 #include "build-id.h"
4 #include "hist.h"
5 #include "session.h"
6 #include "sort.h"
7 #include "evsel.h"
8 #include <math.h>
9
10 static bool hists__filter_entry_by_dso(struct hists *hists,
11 struct hist_entry *he);
12 static bool hists__filter_entry_by_thread(struct hists *hists,
13 struct hist_entry *he);
14 static bool hists__filter_entry_by_symbol(struct hists *hists,
15 struct hist_entry *he);
16
17 enum hist_filter {
18 HIST_FILTER__DSO,
19 HIST_FILTER__THREAD,
20 HIST_FILTER__PARENT,
21 HIST_FILTER__SYMBOL,
22 };
23
24 struct callchain_param callchain_param = {
25 .mode = CHAIN_GRAPH_REL,
26 .min_percent = 0.5,
27 .order = ORDER_CALLEE
28 };
29
30 u16 hists__col_len(struct hists *hists, enum hist_column col)
31 {
32 return hists->col_len[col];
33 }
34
35 void hists__set_col_len(struct hists *hists, enum hist_column col, u16 len)
36 {
37 hists->col_len[col] = len;
38 }
39
40 bool hists__new_col_len(struct hists *hists, enum hist_column col, u16 len)
41 {
42 if (len > hists__col_len(hists, col)) {
43 hists__set_col_len(hists, col, len);
44 return true;
45 }
46 return false;
47 }
48
49 void hists__reset_col_len(struct hists *hists)
50 {
51 enum hist_column col;
52
53 for (col = 0; col < HISTC_NR_COLS; ++col)
54 hists__set_col_len(hists, col, 0);
55 }
56
57 static void hists__set_unres_dso_col_len(struct hists *hists, int dso)
58 {
59 const unsigned int unresolved_col_width = BITS_PER_LONG / 4;
60
61 if (hists__col_len(hists, dso) < unresolved_col_width &&
62 !symbol_conf.col_width_list_str && !symbol_conf.field_sep &&
63 !symbol_conf.dso_list)
64 hists__set_col_len(hists, dso, unresolved_col_width);
65 }
66
67 void hists__calc_col_len(struct hists *hists, struct hist_entry *h)
68 {
69 const unsigned int unresolved_col_width = BITS_PER_LONG / 4;
70 int symlen;
71 u16 len;
72
73 /*
74 * +4 accounts for '[x] ' priv level info
75 * +2 accounts for 0x prefix on raw addresses
76 * +3 accounts for ' y ' symtab origin info
77 */
78 if (h->ms.sym) {
79 symlen = h->ms.sym->namelen + 4;
80 if (verbose)
81 symlen += BITS_PER_LONG / 4 + 2 + 3;
82 hists__new_col_len(hists, HISTC_SYMBOL, symlen);
83 } else {
84 symlen = unresolved_col_width + 4 + 2;
85 hists__new_col_len(hists, HISTC_SYMBOL, symlen);
86 hists__set_unres_dso_col_len(hists, HISTC_DSO);
87 }
88
89 len = thread__comm_len(h->thread);
90 if (hists__new_col_len(hists, HISTC_COMM, len))
91 hists__set_col_len(hists, HISTC_THREAD, len + 6);
92
93 if (h->ms.map) {
94 len = dso__name_len(h->ms.map->dso);
95 hists__new_col_len(hists, HISTC_DSO, len);
96 }
97
98 if (h->parent)
99 hists__new_col_len(hists, HISTC_PARENT, h->parent->namelen);
100
101 if (h->branch_info) {
102 if (h->branch_info->from.sym) {
103 symlen = (int)h->branch_info->from.sym->namelen + 4;
104 if (verbose)
105 symlen += BITS_PER_LONG / 4 + 2 + 3;
106 hists__new_col_len(hists, HISTC_SYMBOL_FROM, symlen);
107
108 symlen = dso__name_len(h->branch_info->from.map->dso);
109 hists__new_col_len(hists, HISTC_DSO_FROM, symlen);
110 } else {
111 symlen = unresolved_col_width + 4 + 2;
112 hists__new_col_len(hists, HISTC_SYMBOL_FROM, symlen);
113 hists__set_unres_dso_col_len(hists, HISTC_DSO_FROM);
114 }
115
116 if (h->branch_info->to.sym) {
117 symlen = (int)h->branch_info->to.sym->namelen + 4;
118 if (verbose)
119 symlen += BITS_PER_LONG / 4 + 2 + 3;
120 hists__new_col_len(hists, HISTC_SYMBOL_TO, symlen);
121
122 symlen = dso__name_len(h->branch_info->to.map->dso);
123 hists__new_col_len(hists, HISTC_DSO_TO, symlen);
124 } else {
125 symlen = unresolved_col_width + 4 + 2;
126 hists__new_col_len(hists, HISTC_SYMBOL_TO, symlen);
127 hists__set_unres_dso_col_len(hists, HISTC_DSO_TO);
128 }
129 }
130
131 if (h->mem_info) {
132 if (h->mem_info->daddr.sym) {
133 symlen = (int)h->mem_info->daddr.sym->namelen + 4
134 + unresolved_col_width + 2;
135 hists__new_col_len(hists, HISTC_MEM_DADDR_SYMBOL,
136 symlen);
137 } else {
138 symlen = unresolved_col_width + 4 + 2;
139 hists__new_col_len(hists, HISTC_MEM_DADDR_SYMBOL,
140 symlen);
141 }
142 if (h->mem_info->daddr.map) {
143 symlen = dso__name_len(h->mem_info->daddr.map->dso);
144 hists__new_col_len(hists, HISTC_MEM_DADDR_DSO,
145 symlen);
146 } else {
147 symlen = unresolved_col_width + 4 + 2;
148 hists__set_unres_dso_col_len(hists, HISTC_MEM_DADDR_DSO);
149 }
150 } else {
151 symlen = unresolved_col_width + 4 + 2;
152 hists__new_col_len(hists, HISTC_MEM_DADDR_SYMBOL, symlen);
153 hists__set_unres_dso_col_len(hists, HISTC_MEM_DADDR_DSO);
154 }
155
156 hists__new_col_len(hists, HISTC_MEM_LOCKED, 6);
157 hists__new_col_len(hists, HISTC_MEM_TLB, 22);
158 hists__new_col_len(hists, HISTC_MEM_SNOOP, 12);
159 hists__new_col_len(hists, HISTC_MEM_LVL, 21 + 3);
160 hists__new_col_len(hists, HISTC_LOCAL_WEIGHT, 12);
161 hists__new_col_len(hists, HISTC_GLOBAL_WEIGHT, 12);
162 }
163
164 void hists__output_recalc_col_len(struct hists *hists, int max_rows)
165 {
166 struct rb_node *next = rb_first(&hists->entries);
167 struct hist_entry *n;
168 int row = 0;
169
170 hists__reset_col_len(hists);
171
172 while (next && row++ < max_rows) {
173 n = rb_entry(next, struct hist_entry, rb_node);
174 if (!n->filtered)
175 hists__calc_col_len(hists, n);
176 next = rb_next(&n->rb_node);
177 }
178 }
179
180 static void hist_entry__add_cpumode_period(struct hist_entry *he,
181 unsigned int cpumode, u64 period)
182 {
183 switch (cpumode) {
184 case PERF_RECORD_MISC_KERNEL:
185 he->stat.period_sys += period;
186 break;
187 case PERF_RECORD_MISC_USER:
188 he->stat.period_us += period;
189 break;
190 case PERF_RECORD_MISC_GUEST_KERNEL:
191 he->stat.period_guest_sys += period;
192 break;
193 case PERF_RECORD_MISC_GUEST_USER:
194 he->stat.period_guest_us += period;
195 break;
196 default:
197 break;
198 }
199 }
200
201 static void he_stat__add_period(struct he_stat *he_stat, u64 period,
202 u64 weight)
203 {
204
205 he_stat->period += period;
206 he_stat->weight += weight;
207 he_stat->nr_events += 1;
208 }
209
210 static void he_stat__add_stat(struct he_stat *dest, struct he_stat *src)
211 {
212 dest->period += src->period;
213 dest->period_sys += src->period_sys;
214 dest->period_us += src->period_us;
215 dest->period_guest_sys += src->period_guest_sys;
216 dest->period_guest_us += src->period_guest_us;
217 dest->nr_events += src->nr_events;
218 dest->weight += src->weight;
219 }
220
221 static void hist_entry__decay(struct hist_entry *he)
222 {
223 he->stat.period = (he->stat.period * 7) / 8;
224 he->stat.nr_events = (he->stat.nr_events * 7) / 8;
225 /* XXX need decay for weight too? */
226 }
227
228 static bool hists__decay_entry(struct hists *hists, struct hist_entry *he)
229 {
230 u64 prev_period = he->stat.period;
231
232 if (prev_period == 0)
233 return true;
234
235 hist_entry__decay(he);
236
237 if (!he->filtered)
238 hists->stats.total_period -= prev_period - he->stat.period;
239
240 return he->stat.period == 0;
241 }
242
243 static void __hists__decay_entries(struct hists *hists, bool zap_user,
244 bool zap_kernel, bool threaded)
245 {
246 struct rb_node *next = rb_first(&hists->entries);
247 struct hist_entry *n;
248
249 while (next) {
250 n = rb_entry(next, struct hist_entry, rb_node);
251 next = rb_next(&n->rb_node);
252 /*
253 * We may be annotating this, for instance, so keep it here in
254 * case some it gets new samples, we'll eventually free it when
255 * the user stops browsing and it agains gets fully decayed.
256 */
257 if (((zap_user && n->level == '.') ||
258 (zap_kernel && n->level != '.') ||
259 hists__decay_entry(hists, n)) &&
260 !n->used) {
261 rb_erase(&n->rb_node, &hists->entries);
262
263 if (sort__need_collapse || threaded)
264 rb_erase(&n->rb_node_in, &hists->entries_collapsed);
265
266 hist_entry__free(n);
267 --hists->nr_entries;
268 }
269 }
270 }
271
272 void hists__decay_entries(struct hists *hists, bool zap_user, bool zap_kernel)
273 {
274 return __hists__decay_entries(hists, zap_user, zap_kernel, false);
275 }
276
277 void hists__decay_entries_threaded(struct hists *hists,
278 bool zap_user, bool zap_kernel)
279 {
280 return __hists__decay_entries(hists, zap_user, zap_kernel, true);
281 }
282
283 /*
284 * histogram, sorted on item, collects periods
285 */
286
287 static struct hist_entry *hist_entry__new(struct hist_entry *template)
288 {
289 size_t callchain_size = symbol_conf.use_callchain ? sizeof(struct callchain_root) : 0;
290 struct hist_entry *he = zalloc(sizeof(*he) + callchain_size);
291
292 if (he != NULL) {
293 *he = *template;
294
295 if (he->ms.map)
296 he->ms.map->referenced = true;
297
298 if (he->branch_info) {
299 /*
300 * This branch info is (a part of) allocated from
301 * machine__resolve_bstack() and will be freed after
302 * adding new entries. So we need to save a copy.
303 */
304 he->branch_info = malloc(sizeof(*he->branch_info));
305 if (he->branch_info == NULL) {
306 free(he);
307 return NULL;
308 }
309
310 memcpy(he->branch_info, template->branch_info,
311 sizeof(*he->branch_info));
312
313 if (he->branch_info->from.map)
314 he->branch_info->from.map->referenced = true;
315 if (he->branch_info->to.map)
316 he->branch_info->to.map->referenced = true;
317 }
318
319 if (he->mem_info) {
320 if (he->mem_info->iaddr.map)
321 he->mem_info->iaddr.map->referenced = true;
322 if (he->mem_info->daddr.map)
323 he->mem_info->daddr.map->referenced = true;
324 }
325
326 if (symbol_conf.use_callchain)
327 callchain_init(he->callchain);
328
329 INIT_LIST_HEAD(&he->pairs.node);
330 }
331
332 return he;
333 }
334
335 void hists__inc_nr_entries(struct hists *hists, struct hist_entry *h)
336 {
337 if (!h->filtered) {
338 hists__calc_col_len(hists, h);
339 ++hists->nr_entries;
340 hists->stats.total_period += h->stat.period;
341 }
342 }
343
344 static u8 symbol__parent_filter(const struct symbol *parent)
345 {
346 if (symbol_conf.exclude_other && parent == NULL)
347 return 1 << HIST_FILTER__PARENT;
348 return 0;
349 }
350
351 static struct hist_entry *add_hist_entry(struct hists *hists,
352 struct hist_entry *entry,
353 struct addr_location *al,
354 u64 period,
355 u64 weight)
356 {
357 struct rb_node **p;
358 struct rb_node *parent = NULL;
359 struct hist_entry *he;
360 int cmp;
361
362 pthread_mutex_lock(&hists->lock);
363
364 p = &hists->entries_in->rb_node;
365
366 while (*p != NULL) {
367 parent = *p;
368 he = rb_entry(parent, struct hist_entry, rb_node_in);
369
370 /*
371 * Make sure that it receives arguments in a same order as
372 * hist_entry__collapse() so that we can use an appropriate
373 * function when searching an entry regardless which sort
374 * keys were used.
375 */
376 cmp = hist_entry__cmp(he, entry);
377
378 if (!cmp) {
379 he_stat__add_period(&he->stat, period, weight);
380
381 /*
382 * This mem info was allocated from machine__resolve_mem
383 * and will not be used anymore.
384 */
385 free(entry->mem_info);
386
387 /* If the map of an existing hist_entry has
388 * become out-of-date due to an exec() or
389 * similar, update it. Otherwise we will
390 * mis-adjust symbol addresses when computing
391 * the history counter to increment.
392 */
393 if (he->ms.map != entry->ms.map) {
394 he->ms.map = entry->ms.map;
395 if (he->ms.map)
396 he->ms.map->referenced = true;
397 }
398 goto out;
399 }
400
401 if (cmp < 0)
402 p = &(*p)->rb_left;
403 else
404 p = &(*p)->rb_right;
405 }
406
407 he = hist_entry__new(entry);
408 if (!he)
409 goto out_unlock;
410
411 rb_link_node(&he->rb_node_in, parent, p);
412 rb_insert_color(&he->rb_node_in, hists->entries_in);
413 out:
414 hist_entry__add_cpumode_period(he, al->cpumode, period);
415 out_unlock:
416 pthread_mutex_unlock(&hists->lock);
417 return he;
418 }
419
420 struct hist_entry *__hists__add_mem_entry(struct hists *self,
421 struct addr_location *al,
422 struct symbol *sym_parent,
423 struct mem_info *mi,
424 u64 period,
425 u64 weight)
426 {
427 struct hist_entry entry = {
428 .thread = al->thread,
429 .ms = {
430 .map = al->map,
431 .sym = al->sym,
432 },
433 .stat = {
434 .period = period,
435 .weight = weight,
436 .nr_events = 1,
437 },
438 .cpu = al->cpu,
439 .ip = al->addr,
440 .level = al->level,
441 .parent = sym_parent,
442 .filtered = symbol__parent_filter(sym_parent),
443 .hists = self,
444 .mem_info = mi,
445 .branch_info = NULL,
446 };
447 return add_hist_entry(self, &entry, al, period, weight);
448 }
449
450 struct hist_entry *__hists__add_branch_entry(struct hists *self,
451 struct addr_location *al,
452 struct symbol *sym_parent,
453 struct branch_info *bi,
454 u64 period,
455 u64 weight)
456 {
457 struct hist_entry entry = {
458 .thread = al->thread,
459 .ms = {
460 .map = bi->to.map,
461 .sym = bi->to.sym,
462 },
463 .cpu = al->cpu,
464 .ip = bi->to.addr,
465 .level = al->level,
466 .stat = {
467 .period = period,
468 .nr_events = 1,
469 .weight = weight,
470 },
471 .parent = sym_parent,
472 .filtered = symbol__parent_filter(sym_parent),
473 .branch_info = bi,
474 .hists = self,
475 .mem_info = NULL,
476 };
477
478 return add_hist_entry(self, &entry, al, period, weight);
479 }
480
481 struct hist_entry *__hists__add_entry(struct hists *self,
482 struct addr_location *al,
483 struct symbol *sym_parent, u64 period,
484 u64 weight)
485 {
486 struct hist_entry entry = {
487 .thread = al->thread,
488 .ms = {
489 .map = al->map,
490 .sym = al->sym,
491 },
492 .cpu = al->cpu,
493 .ip = al->addr,
494 .level = al->level,
495 .stat = {
496 .period = period,
497 .nr_events = 1,
498 .weight = weight,
499 },
500 .parent = sym_parent,
501 .filtered = symbol__parent_filter(sym_parent),
502 .hists = self,
503 .branch_info = NULL,
504 .mem_info = NULL,
505 };
506
507 return add_hist_entry(self, &entry, al, period, weight);
508 }
509
510 int64_t
511 hist_entry__cmp(struct hist_entry *left, struct hist_entry *right)
512 {
513 struct sort_entry *se;
514 int64_t cmp = 0;
515
516 list_for_each_entry(se, &hist_entry__sort_list, list) {
517 cmp = se->se_cmp(left, right);
518 if (cmp)
519 break;
520 }
521
522 return cmp;
523 }
524
525 int64_t
526 hist_entry__collapse(struct hist_entry *left, struct hist_entry *right)
527 {
528 struct sort_entry *se;
529 int64_t cmp = 0;
530
531 list_for_each_entry(se, &hist_entry__sort_list, list) {
532 int64_t (*f)(struct hist_entry *, struct hist_entry *);
533
534 f = se->se_collapse ?: se->se_cmp;
535
536 cmp = f(left, right);
537 if (cmp)
538 break;
539 }
540
541 return cmp;
542 }
543
544 void hist_entry__free(struct hist_entry *he)
545 {
546 free(he->branch_info);
547 free(he->mem_info);
548 free(he);
549 }
550
551 /*
552 * collapse the histogram
553 */
554
555 static bool hists__collapse_insert_entry(struct hists *hists __maybe_unused,
556 struct rb_root *root,
557 struct hist_entry *he)
558 {
559 struct rb_node **p = &root->rb_node;
560 struct rb_node *parent = NULL;
561 struct hist_entry *iter;
562 int64_t cmp;
563
564 while (*p != NULL) {
565 parent = *p;
566 iter = rb_entry(parent, struct hist_entry, rb_node_in);
567
568 cmp = hist_entry__collapse(iter, he);
569
570 if (!cmp) {
571 he_stat__add_stat(&iter->stat, &he->stat);
572
573 if (symbol_conf.use_callchain) {
574 callchain_cursor_reset(&callchain_cursor);
575 callchain_merge(&callchain_cursor,
576 iter->callchain,
577 he->callchain);
578 }
579 hist_entry__free(he);
580 return false;
581 }
582
583 if (cmp < 0)
584 p = &(*p)->rb_left;
585 else
586 p = &(*p)->rb_right;
587 }
588
589 rb_link_node(&he->rb_node_in, parent, p);
590 rb_insert_color(&he->rb_node_in, root);
591 return true;
592 }
593
594 static struct rb_root *hists__get_rotate_entries_in(struct hists *hists)
595 {
596 struct rb_root *root;
597
598 pthread_mutex_lock(&hists->lock);
599
600 root = hists->entries_in;
601 if (++hists->entries_in > &hists->entries_in_array[1])
602 hists->entries_in = &hists->entries_in_array[0];
603
604 pthread_mutex_unlock(&hists->lock);
605
606 return root;
607 }
608
609 static void hists__apply_filters(struct hists *hists, struct hist_entry *he)
610 {
611 hists__filter_entry_by_dso(hists, he);
612 hists__filter_entry_by_thread(hists, he);
613 hists__filter_entry_by_symbol(hists, he);
614 }
615
616 static void __hists__collapse_resort(struct hists *hists, bool threaded)
617 {
618 struct rb_root *root;
619 struct rb_node *next;
620 struct hist_entry *n;
621
622 if (!sort__need_collapse && !threaded)
623 return;
624
625 root = hists__get_rotate_entries_in(hists);
626 next = rb_first(root);
627
628 while (next) {
629 n = rb_entry(next, struct hist_entry, rb_node_in);
630 next = rb_next(&n->rb_node_in);
631
632 rb_erase(&n->rb_node_in, root);
633 if (hists__collapse_insert_entry(hists, &hists->entries_collapsed, n)) {
634 /*
635 * If it wasn't combined with one of the entries already
636 * collapsed, we need to apply the filters that may have
637 * been set by, say, the hist_browser.
638 */
639 hists__apply_filters(hists, n);
640 }
641 }
642 }
643
644 void hists__collapse_resort(struct hists *hists)
645 {
646 return __hists__collapse_resort(hists, false);
647 }
648
649 void hists__collapse_resort_threaded(struct hists *hists)
650 {
651 return __hists__collapse_resort(hists, true);
652 }
653
654 /*
655 * reverse the map, sort on period.
656 */
657
658 static int period_cmp(u64 period_a, u64 period_b)
659 {
660 if (period_a > period_b)
661 return 1;
662 if (period_a < period_b)
663 return -1;
664 return 0;
665 }
666
667 static int hist_entry__sort_on_period(struct hist_entry *a,
668 struct hist_entry *b)
669 {
670 int ret;
671 int i, nr_members;
672 struct perf_evsel *evsel;
673 struct hist_entry *pair;
674 u64 *periods_a, *periods_b;
675
676 ret = period_cmp(a->stat.period, b->stat.period);
677 if (ret || !symbol_conf.event_group)
678 return ret;
679
680 evsel = hists_to_evsel(a->hists);
681 nr_members = evsel->nr_members;
682 if (nr_members <= 1)
683 return ret;
684
685 periods_a = zalloc(sizeof(periods_a) * nr_members);
686 periods_b = zalloc(sizeof(periods_b) * nr_members);
687
688 if (!periods_a || !periods_b)
689 goto out;
690
691 list_for_each_entry(pair, &a->pairs.head, pairs.node) {
692 evsel = hists_to_evsel(pair->hists);
693 periods_a[perf_evsel__group_idx(evsel)] = pair->stat.period;
694 }
695
696 list_for_each_entry(pair, &b->pairs.head, pairs.node) {
697 evsel = hists_to_evsel(pair->hists);
698 periods_b[perf_evsel__group_idx(evsel)] = pair->stat.period;
699 }
700
701 for (i = 1; i < nr_members; i++) {
702 ret = period_cmp(periods_a[i], periods_b[i]);
703 if (ret)
704 break;
705 }
706
707 out:
708 free(periods_a);
709 free(periods_b);
710
711 return ret;
712 }
713
714 static void __hists__insert_output_entry(struct rb_root *entries,
715 struct hist_entry *he,
716 u64 min_callchain_hits)
717 {
718 struct rb_node **p = &entries->rb_node;
719 struct rb_node *parent = NULL;
720 struct hist_entry *iter;
721
722 if (symbol_conf.use_callchain)
723 callchain_param.sort(&he->sorted_chain, he->callchain,
724 min_callchain_hits, &callchain_param);
725
726 while (*p != NULL) {
727 parent = *p;
728 iter = rb_entry(parent, struct hist_entry, rb_node);
729
730 if (hist_entry__sort_on_period(he, iter) > 0)
731 p = &(*p)->rb_left;
732 else
733 p = &(*p)->rb_right;
734 }
735
736 rb_link_node(&he->rb_node, parent, p);
737 rb_insert_color(&he->rb_node, entries);
738 }
739
740 static void __hists__output_resort(struct hists *hists, bool threaded)
741 {
742 struct rb_root *root;
743 struct rb_node *next;
744 struct hist_entry *n;
745 u64 min_callchain_hits;
746
747 min_callchain_hits = hists->stats.total_period * (callchain_param.min_percent / 100);
748
749 if (sort__need_collapse || threaded)
750 root = &hists->entries_collapsed;
751 else
752 root = hists->entries_in;
753
754 next = rb_first(root);
755 hists->entries = RB_ROOT;
756
757 hists->nr_entries = 0;
758 hists->stats.total_period = 0;
759 hists__reset_col_len(hists);
760
761 while (next) {
762 n = rb_entry(next, struct hist_entry, rb_node_in);
763 next = rb_next(&n->rb_node_in);
764
765 __hists__insert_output_entry(&hists->entries, n, min_callchain_hits);
766 hists__inc_nr_entries(hists, n);
767 }
768 }
769
770 void hists__output_resort(struct hists *hists)
771 {
772 return __hists__output_resort(hists, false);
773 }
774
775 void hists__output_resort_threaded(struct hists *hists)
776 {
777 return __hists__output_resort(hists, true);
778 }
779
780 static void hists__remove_entry_filter(struct hists *hists, struct hist_entry *h,
781 enum hist_filter filter)
782 {
783 h->filtered &= ~(1 << filter);
784 if (h->filtered)
785 return;
786
787 ++hists->nr_entries;
788 if (h->ms.unfolded)
789 hists->nr_entries += h->nr_rows;
790 h->row_offset = 0;
791 hists->stats.total_period += h->stat.period;
792 hists->stats.nr_events[PERF_RECORD_SAMPLE] += h->stat.nr_events;
793
794 hists__calc_col_len(hists, h);
795 }
796
797
798 static bool hists__filter_entry_by_dso(struct hists *hists,
799 struct hist_entry *he)
800 {
801 if (hists->dso_filter != NULL &&
802 (he->ms.map == NULL || he->ms.map->dso != hists->dso_filter)) {
803 he->filtered |= (1 << HIST_FILTER__DSO);
804 return true;
805 }
806
807 return false;
808 }
809
810 void hists__filter_by_dso(struct hists *hists)
811 {
812 struct rb_node *nd;
813
814 hists->nr_entries = hists->stats.total_period = 0;
815 hists->stats.nr_events[PERF_RECORD_SAMPLE] = 0;
816 hists__reset_col_len(hists);
817
818 for (nd = rb_first(&hists->entries); nd; nd = rb_next(nd)) {
819 struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
820
821 if (symbol_conf.exclude_other && !h->parent)
822 continue;
823
824 if (hists__filter_entry_by_dso(hists, h))
825 continue;
826
827 hists__remove_entry_filter(hists, h, HIST_FILTER__DSO);
828 }
829 }
830
831 static bool hists__filter_entry_by_thread(struct hists *hists,
832 struct hist_entry *he)
833 {
834 if (hists->thread_filter != NULL &&
835 he->thread != hists->thread_filter) {
836 he->filtered |= (1 << HIST_FILTER__THREAD);
837 return true;
838 }
839
840 return false;
841 }
842
843 void hists__filter_by_thread(struct hists *hists)
844 {
845 struct rb_node *nd;
846
847 hists->nr_entries = hists->stats.total_period = 0;
848 hists->stats.nr_events[PERF_RECORD_SAMPLE] = 0;
849 hists__reset_col_len(hists);
850
851 for (nd = rb_first(&hists->entries); nd; nd = rb_next(nd)) {
852 struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
853
854 if (hists__filter_entry_by_thread(hists, h))
855 continue;
856
857 hists__remove_entry_filter(hists, h, HIST_FILTER__THREAD);
858 }
859 }
860
861 static bool hists__filter_entry_by_symbol(struct hists *hists,
862 struct hist_entry *he)
863 {
864 if (hists->symbol_filter_str != NULL &&
865 (!he->ms.sym || strstr(he->ms.sym->name,
866 hists->symbol_filter_str) == NULL)) {
867 he->filtered |= (1 << HIST_FILTER__SYMBOL);
868 return true;
869 }
870
871 return false;
872 }
873
874 void hists__filter_by_symbol(struct hists *hists)
875 {
876 struct rb_node *nd;
877
878 hists->nr_entries = hists->stats.total_period = 0;
879 hists->stats.nr_events[PERF_RECORD_SAMPLE] = 0;
880 hists__reset_col_len(hists);
881
882 for (nd = rb_first(&hists->entries); nd; nd = rb_next(nd)) {
883 struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
884
885 if (hists__filter_entry_by_symbol(hists, h))
886 continue;
887
888 hists__remove_entry_filter(hists, h, HIST_FILTER__SYMBOL);
889 }
890 }
891
892 int hist_entry__inc_addr_samples(struct hist_entry *he, int evidx, u64 ip)
893 {
894 return symbol__inc_addr_samples(he->ms.sym, he->ms.map, evidx, ip);
895 }
896
897 int hist_entry__annotate(struct hist_entry *he, size_t privsize)
898 {
899 return symbol__annotate(he->ms.sym, he->ms.map, privsize);
900 }
901
902 void events_stats__inc(struct events_stats *stats, u32 type)
903 {
904 ++stats->nr_events[0];
905 ++stats->nr_events[type];
906 }
907
908 void hists__inc_nr_events(struct hists *hists, u32 type)
909 {
910 events_stats__inc(&hists->stats, type);
911 }
912
913 static struct hist_entry *hists__add_dummy_entry(struct hists *hists,
914 struct hist_entry *pair)
915 {
916 struct rb_root *root;
917 struct rb_node **p;
918 struct rb_node *parent = NULL;
919 struct hist_entry *he;
920 int cmp;
921
922 if (sort__need_collapse)
923 root = &hists->entries_collapsed;
924 else
925 root = hists->entries_in;
926
927 p = &root->rb_node;
928
929 while (*p != NULL) {
930 parent = *p;
931 he = rb_entry(parent, struct hist_entry, rb_node_in);
932
933 cmp = hist_entry__collapse(he, pair);
934
935 if (!cmp)
936 goto out;
937
938 if (cmp < 0)
939 p = &(*p)->rb_left;
940 else
941 p = &(*p)->rb_right;
942 }
943
944 he = hist_entry__new(pair);
945 if (he) {
946 memset(&he->stat, 0, sizeof(he->stat));
947 he->hists = hists;
948 rb_link_node(&he->rb_node_in, parent, p);
949 rb_insert_color(&he->rb_node_in, root);
950 hists__inc_nr_entries(hists, he);
951 }
952 out:
953 return he;
954 }
955
956 static struct hist_entry *hists__find_entry(struct hists *hists,
957 struct hist_entry *he)
958 {
959 struct rb_node *n;
960
961 if (sort__need_collapse)
962 n = hists->entries_collapsed.rb_node;
963 else
964 n = hists->entries_in->rb_node;
965
966 while (n) {
967 struct hist_entry *iter = rb_entry(n, struct hist_entry, rb_node_in);
968 int64_t cmp = hist_entry__collapse(iter, he);
969
970 if (cmp < 0)
971 n = n->rb_left;
972 else if (cmp > 0)
973 n = n->rb_right;
974 else
975 return iter;
976 }
977
978 return NULL;
979 }
980
981 /*
982 * Look for pairs to link to the leader buckets (hist_entries):
983 */
984 void hists__match(struct hists *leader, struct hists *other)
985 {
986 struct rb_root *root;
987 struct rb_node *nd;
988 struct hist_entry *pos, *pair;
989
990 if (sort__need_collapse)
991 root = &leader->entries_collapsed;
992 else
993 root = leader->entries_in;
994
995 for (nd = rb_first(root); nd; nd = rb_next(nd)) {
996 pos = rb_entry(nd, struct hist_entry, rb_node_in);
997 pair = hists__find_entry(other, pos);
998
999 if (pair)
1000 hist_entry__add_pair(pair, pos);
1001 }
1002 }
1003
1004 /*
1005 * Look for entries in the other hists that are not present in the leader, if
1006 * we find them, just add a dummy entry on the leader hists, with period=0,
1007 * nr_events=0, to serve as the list header.
1008 */
1009 int hists__link(struct hists *leader, struct hists *other)
1010 {
1011 struct rb_root *root;
1012 struct rb_node *nd;
1013 struct hist_entry *pos, *pair;
1014
1015 if (sort__need_collapse)
1016 root = &other->entries_collapsed;
1017 else
1018 root = other->entries_in;
1019
1020 for (nd = rb_first(root); nd; nd = rb_next(nd)) {
1021 pos = rb_entry(nd, struct hist_entry, rb_node_in);
1022
1023 if (!hist_entry__has_pairs(pos)) {
1024 pair = hists__add_dummy_entry(leader, pos);
1025 if (pair == NULL)
1026 return -1;
1027 hist_entry__add_pair(pos, pair);
1028 }
1029 }
1030
1031 return 0;
1032 }
Linux kernel - Deliverables
This page took 0.070292 seconds and 5 git commands to generate.