9 static bool hists__filter_entry_by_dso(struct hists
*hists
,
10 struct hist_entry
*he
);
11 static bool hists__filter_entry_by_thread(struct hists
*hists
,
12 struct hist_entry
*he
);
13 static bool hists__filter_entry_by_symbol(struct hists
*hists
,
14 struct hist_entry
*he
);
16 struct callchain_param callchain_param
= {
17 .mode
= CHAIN_GRAPH_REL
,
19 .order
= ORDER_CALLEE
,
23 u16
hists__col_len(struct hists
*hists
, enum hist_column col
)
25 return hists
->col_len
[col
];
28 void hists__set_col_len(struct hists
*hists
, enum hist_column col
, u16 len
)
30 hists
->col_len
[col
] = len
;
33 bool hists__new_col_len(struct hists
*hists
, enum hist_column col
, u16 len
)
35 if (len
> hists__col_len(hists
, col
)) {
36 hists__set_col_len(hists
, col
, len
);
42 void hists__reset_col_len(struct hists
*hists
)
46 for (col
= 0; col
< HISTC_NR_COLS
; ++col
)
47 hists__set_col_len(hists
, col
, 0);
50 static void hists__set_unres_dso_col_len(struct hists
*hists
, int dso
)
52 const unsigned int unresolved_col_width
= BITS_PER_LONG
/ 4;
54 if (hists__col_len(hists
, dso
) < unresolved_col_width
&&
55 !symbol_conf
.col_width_list_str
&& !symbol_conf
.field_sep
&&
56 !symbol_conf
.dso_list
)
57 hists__set_col_len(hists
, dso
, unresolved_col_width
);
60 void hists__calc_col_len(struct hists
*hists
, struct hist_entry
*h
)
62 const unsigned int unresolved_col_width
= BITS_PER_LONG
/ 4;
67 * +4 accounts for '[x] ' priv level info
68 * +2 accounts for 0x prefix on raw addresses
69 * +3 accounts for ' y ' symtab origin info
72 symlen
= h
->ms
.sym
->namelen
+ 4;
74 symlen
+= BITS_PER_LONG
/ 4 + 2 + 3;
75 hists__new_col_len(hists
, HISTC_SYMBOL
, symlen
);
77 symlen
= unresolved_col_width
+ 4 + 2;
78 hists__new_col_len(hists
, HISTC_SYMBOL
, symlen
);
79 hists__set_unres_dso_col_len(hists
, HISTC_DSO
);
82 len
= thread__comm_len(h
->thread
);
83 if (hists__new_col_len(hists
, HISTC_COMM
, len
))
84 hists__set_col_len(hists
, HISTC_THREAD
, len
+ 6);
87 len
= dso__name_len(h
->ms
.map
->dso
);
88 hists__new_col_len(hists
, HISTC_DSO
, len
);
92 hists__new_col_len(hists
, HISTC_PARENT
, h
->parent
->namelen
);
95 if (h
->branch_info
->from
.sym
) {
96 symlen
= (int)h
->branch_info
->from
.sym
->namelen
+ 4;
98 symlen
+= BITS_PER_LONG
/ 4 + 2 + 3;
99 hists__new_col_len(hists
, HISTC_SYMBOL_FROM
, symlen
);
101 symlen
= dso__name_len(h
->branch_info
->from
.map
->dso
);
102 hists__new_col_len(hists
, HISTC_DSO_FROM
, symlen
);
104 symlen
= unresolved_col_width
+ 4 + 2;
105 hists__new_col_len(hists
, HISTC_SYMBOL_FROM
, symlen
);
106 hists__set_unres_dso_col_len(hists
, HISTC_DSO_FROM
);
109 if (h
->branch_info
->to
.sym
) {
110 symlen
= (int)h
->branch_info
->to
.sym
->namelen
+ 4;
112 symlen
+= BITS_PER_LONG
/ 4 + 2 + 3;
113 hists__new_col_len(hists
, HISTC_SYMBOL_TO
, symlen
);
115 symlen
= dso__name_len(h
->branch_info
->to
.map
->dso
);
116 hists__new_col_len(hists
, HISTC_DSO_TO
, symlen
);
118 symlen
= unresolved_col_width
+ 4 + 2;
119 hists__new_col_len(hists
, HISTC_SYMBOL_TO
, symlen
);
120 hists__set_unres_dso_col_len(hists
, HISTC_DSO_TO
);
125 if (h
->mem_info
->daddr
.sym
) {
126 symlen
= (int)h
->mem_info
->daddr
.sym
->namelen
+ 4
127 + unresolved_col_width
+ 2;
128 hists__new_col_len(hists
, HISTC_MEM_DADDR_SYMBOL
,
131 symlen
= unresolved_col_width
+ 4 + 2;
132 hists__new_col_len(hists
, HISTC_MEM_DADDR_SYMBOL
,
135 if (h
->mem_info
->daddr
.map
) {
136 symlen
= dso__name_len(h
->mem_info
->daddr
.map
->dso
);
137 hists__new_col_len(hists
, HISTC_MEM_DADDR_DSO
,
140 symlen
= unresolved_col_width
+ 4 + 2;
141 hists__set_unres_dso_col_len(hists
, HISTC_MEM_DADDR_DSO
);
144 symlen
= unresolved_col_width
+ 4 + 2;
145 hists__new_col_len(hists
, HISTC_MEM_DADDR_SYMBOL
, symlen
);
146 hists__set_unres_dso_col_len(hists
, HISTC_MEM_DADDR_DSO
);
149 hists__new_col_len(hists
, HISTC_MEM_LOCKED
, 6);
150 hists__new_col_len(hists
, HISTC_MEM_TLB
, 22);
151 hists__new_col_len(hists
, HISTC_MEM_SNOOP
, 12);
152 hists__new_col_len(hists
, HISTC_MEM_LVL
, 21 + 3);
153 hists__new_col_len(hists
, HISTC_LOCAL_WEIGHT
, 12);
154 hists__new_col_len(hists
, HISTC_GLOBAL_WEIGHT
, 12);
157 hists__new_col_len(hists
, HISTC_TRANSACTION
,
158 hist_entry__transaction_len());
161 void hists__output_recalc_col_len(struct hists
*hists
, int max_rows
)
163 struct rb_node
*next
= rb_first(&hists
->entries
);
164 struct hist_entry
*n
;
167 hists__reset_col_len(hists
);
169 while (next
&& row
++ < max_rows
) {
170 n
= rb_entry(next
, struct hist_entry
, rb_node
);
172 hists__calc_col_len(hists
, n
);
173 next
= rb_next(&n
->rb_node
);
177 static void he_stat__add_cpumode_period(struct he_stat
*he_stat
,
178 unsigned int cpumode
, u64 period
)
181 case PERF_RECORD_MISC_KERNEL
:
182 he_stat
->period_sys
+= period
;
184 case PERF_RECORD_MISC_USER
:
185 he_stat
->period_us
+= period
;
187 case PERF_RECORD_MISC_GUEST_KERNEL
:
188 he_stat
->period_guest_sys
+= period
;
190 case PERF_RECORD_MISC_GUEST_USER
:
191 he_stat
->period_guest_us
+= period
;
198 static void he_stat__add_period(struct he_stat
*he_stat
, u64 period
,
202 he_stat
->period
+= period
;
203 he_stat
->weight
+= weight
;
204 he_stat
->nr_events
+= 1;
207 static void he_stat__add_stat(struct he_stat
*dest
, struct he_stat
*src
)
209 dest
->period
+= src
->period
;
210 dest
->period_sys
+= src
->period_sys
;
211 dest
->period_us
+= src
->period_us
;
212 dest
->period_guest_sys
+= src
->period_guest_sys
;
213 dest
->period_guest_us
+= src
->period_guest_us
;
214 dest
->nr_events
+= src
->nr_events
;
215 dest
->weight
+= src
->weight
;
218 static void he_stat__decay(struct he_stat
*he_stat
)
220 he_stat
->period
= (he_stat
->period
* 7) / 8;
221 he_stat
->nr_events
= (he_stat
->nr_events
* 7) / 8;
222 /* XXX need decay for weight too? */
225 static bool hists__decay_entry(struct hists
*hists
, struct hist_entry
*he
)
227 u64 prev_period
= he
->stat
.period
;
229 if (prev_period
== 0)
232 he_stat__decay(&he
->stat
);
235 hists
->stats
.total_period
-= prev_period
- he
->stat
.period
;
237 return he
->stat
.period
== 0;
240 void hists__decay_entries(struct hists
*hists
, bool zap_user
, bool zap_kernel
)
242 struct rb_node
*next
= rb_first(&hists
->entries
);
243 struct hist_entry
*n
;
246 n
= rb_entry(next
, struct hist_entry
, rb_node
);
247 next
= rb_next(&n
->rb_node
);
249 * We may be annotating this, for instance, so keep it here in
250 * case some it gets new samples, we'll eventually free it when
251 * the user stops browsing and it agains gets fully decayed.
253 if (((zap_user
&& n
->level
== '.') ||
254 (zap_kernel
&& n
->level
!= '.') ||
255 hists__decay_entry(hists
, n
)) &&
257 rb_erase(&n
->rb_node
, &hists
->entries
);
259 if (sort__need_collapse
)
260 rb_erase(&n
->rb_node_in
, &hists
->entries_collapsed
);
269 * histogram, sorted on item, collects periods
272 static struct hist_entry
*hist_entry__new(struct hist_entry
*template)
274 size_t callchain_size
= symbol_conf
.use_callchain
? sizeof(struct callchain_root
) : 0;
275 struct hist_entry
*he
= zalloc(sizeof(*he
) + callchain_size
);
281 he
->ms
.map
->referenced
= true;
283 if (he
->branch_info
) {
285 * This branch info is (a part of) allocated from
286 * sample__resolve_bstack() and will be freed after
287 * adding new entries. So we need to save a copy.
289 he
->branch_info
= malloc(sizeof(*he
->branch_info
));
290 if (he
->branch_info
== NULL
) {
295 memcpy(he
->branch_info
, template->branch_info
,
296 sizeof(*he
->branch_info
));
298 if (he
->branch_info
->from
.map
)
299 he
->branch_info
->from
.map
->referenced
= true;
300 if (he
->branch_info
->to
.map
)
301 he
->branch_info
->to
.map
->referenced
= true;
305 if (he
->mem_info
->iaddr
.map
)
306 he
->mem_info
->iaddr
.map
->referenced
= true;
307 if (he
->mem_info
->daddr
.map
)
308 he
->mem_info
->daddr
.map
->referenced
= true;
311 if (symbol_conf
.use_callchain
)
312 callchain_init(he
->callchain
);
314 INIT_LIST_HEAD(&he
->pairs
.node
);
320 static u8
symbol__parent_filter(const struct symbol
*parent
)
322 if (symbol_conf
.exclude_other
&& parent
== NULL
)
323 return 1 << HIST_FILTER__PARENT
;
327 static struct hist_entry
*add_hist_entry(struct hists
*hists
,
328 struct hist_entry
*entry
,
329 struct addr_location
*al
)
332 struct rb_node
*parent
= NULL
;
333 struct hist_entry
*he
;
335 u64 period
= entry
->stat
.period
;
336 u64 weight
= entry
->stat
.weight
;
338 p
= &hists
->entries_in
->rb_node
;
342 he
= rb_entry(parent
, struct hist_entry
, rb_node_in
);
345 * Make sure that it receives arguments in a same order as
346 * hist_entry__collapse() so that we can use an appropriate
347 * function when searching an entry regardless which sort
350 cmp
= hist_entry__cmp(he
, entry
);
353 he_stat__add_period(&he
->stat
, period
, weight
);
356 * This mem info was allocated from sample__resolve_mem
357 * and will not be used anymore.
359 zfree(&entry
->mem_info
);
361 /* If the map of an existing hist_entry has
362 * become out-of-date due to an exec() or
363 * similar, update it. Otherwise we will
364 * mis-adjust symbol addresses when computing
365 * the history counter to increment.
367 if (he
->ms
.map
!= entry
->ms
.map
) {
368 he
->ms
.map
= entry
->ms
.map
;
370 he
->ms
.map
->referenced
= true;
381 he
= hist_entry__new(entry
);
386 rb_link_node(&he
->rb_node_in
, parent
, p
);
387 rb_insert_color(&he
->rb_node_in
, hists
->entries_in
);
389 he_stat__add_cpumode_period(&he
->stat
, al
->cpumode
, period
);
393 struct hist_entry
*__hists__add_entry(struct hists
*hists
,
394 struct addr_location
*al
,
395 struct symbol
*sym_parent
,
396 struct branch_info
*bi
,
398 u64 period
, u64 weight
, u64 transaction
)
400 struct hist_entry entry
= {
401 .thread
= al
->thread
,
402 .comm
= thread__comm(al
->thread
),
415 .parent
= sym_parent
,
416 .filtered
= symbol__parent_filter(sym_parent
) | al
->filtered
,
420 .transaction
= transaction
,
423 return add_hist_entry(hists
, &entry
, al
);
427 hist_entry__cmp(struct hist_entry
*left
, struct hist_entry
*right
)
429 struct sort_entry
*se
;
432 list_for_each_entry(se
, &hist_entry__sort_list
, list
) {
433 cmp
= se
->se_cmp(left
, right
);
442 hist_entry__collapse(struct hist_entry
*left
, struct hist_entry
*right
)
444 struct sort_entry
*se
;
447 list_for_each_entry(se
, &hist_entry__sort_list
, list
) {
448 int64_t (*f
)(struct hist_entry
*, struct hist_entry
*);
450 f
= se
->se_collapse
?: se
->se_cmp
;
452 cmp
= f(left
, right
);
460 void hist_entry__free(struct hist_entry
*he
)
462 zfree(&he
->branch_info
);
463 zfree(&he
->mem_info
);
464 free_srcline(he
->srcline
);
469 * collapse the histogram
472 static bool hists__collapse_insert_entry(struct hists
*hists __maybe_unused
,
473 struct rb_root
*root
,
474 struct hist_entry
*he
)
476 struct rb_node
**p
= &root
->rb_node
;
477 struct rb_node
*parent
= NULL
;
478 struct hist_entry
*iter
;
483 iter
= rb_entry(parent
, struct hist_entry
, rb_node_in
);
485 cmp
= hist_entry__collapse(iter
, he
);
488 he_stat__add_stat(&iter
->stat
, &he
->stat
);
490 if (symbol_conf
.use_callchain
) {
491 callchain_cursor_reset(&callchain_cursor
);
492 callchain_merge(&callchain_cursor
,
496 hist_entry__free(he
);
506 rb_link_node(&he
->rb_node_in
, parent
, p
);
507 rb_insert_color(&he
->rb_node_in
, root
);
511 static struct rb_root
*hists__get_rotate_entries_in(struct hists
*hists
)
513 struct rb_root
*root
;
515 pthread_mutex_lock(&hists
->lock
);
517 root
= hists
->entries_in
;
518 if (++hists
->entries_in
> &hists
->entries_in_array
[1])
519 hists
->entries_in
= &hists
->entries_in_array
[0];
521 pthread_mutex_unlock(&hists
->lock
);
526 static void hists__apply_filters(struct hists
*hists
, struct hist_entry
*he
)
528 hists__filter_entry_by_dso(hists
, he
);
529 hists__filter_entry_by_thread(hists
, he
);
530 hists__filter_entry_by_symbol(hists
, he
);
533 void hists__collapse_resort(struct hists
*hists
, struct ui_progress
*prog
)
535 struct rb_root
*root
;
536 struct rb_node
*next
;
537 struct hist_entry
*n
;
539 if (!sort__need_collapse
)
542 root
= hists__get_rotate_entries_in(hists
);
543 next
= rb_first(root
);
548 n
= rb_entry(next
, struct hist_entry
, rb_node_in
);
549 next
= rb_next(&n
->rb_node_in
);
551 rb_erase(&n
->rb_node_in
, root
);
552 if (hists__collapse_insert_entry(hists
, &hists
->entries_collapsed
, n
)) {
554 * If it wasn't combined with one of the entries already
555 * collapsed, we need to apply the filters that may have
556 * been set by, say, the hist_browser.
558 hists__apply_filters(hists
, n
);
561 ui_progress__update(prog
, 1);
566 * reverse the map, sort on period.
569 static int period_cmp(u64 period_a
, u64 period_b
)
571 if (period_a
> period_b
)
573 if (period_a
< period_b
)
578 static int hist_entry__sort_on_period(struct hist_entry
*a
,
579 struct hist_entry
*b
)
583 struct perf_evsel
*evsel
;
584 struct hist_entry
*pair
;
585 u64
*periods_a
, *periods_b
;
587 ret
= period_cmp(a
->stat
.period
, b
->stat
.period
);
588 if (ret
|| !symbol_conf
.event_group
)
591 evsel
= hists_to_evsel(a
->hists
);
592 nr_members
= evsel
->nr_members
;
596 periods_a
= zalloc(sizeof(periods_a
) * nr_members
);
597 periods_b
= zalloc(sizeof(periods_b
) * nr_members
);
599 if (!periods_a
|| !periods_b
)
602 list_for_each_entry(pair
, &a
->pairs
.head
, pairs
.node
) {
603 evsel
= hists_to_evsel(pair
->hists
);
604 periods_a
[perf_evsel__group_idx(evsel
)] = pair
->stat
.period
;
607 list_for_each_entry(pair
, &b
->pairs
.head
, pairs
.node
) {
608 evsel
= hists_to_evsel(pair
->hists
);
609 periods_b
[perf_evsel__group_idx(evsel
)] = pair
->stat
.period
;
612 for (i
= 1; i
< nr_members
; i
++) {
613 ret
= period_cmp(periods_a
[i
], periods_b
[i
]);
625 static void hists__reset_filter_stats(struct hists
*hists
)
627 hists
->nr_non_filtered_entries
= 0;
628 hists
->stats
.total_non_filtered_period
= 0;
631 void hists__reset_stats(struct hists
*hists
)
633 hists
->nr_entries
= 0;
634 hists
->stats
.total_period
= 0;
636 hists__reset_filter_stats(hists
);
639 static void hists__inc_filter_stats(struct hists
*hists
, struct hist_entry
*h
)
641 hists
->nr_non_filtered_entries
++;
642 hists
->stats
.total_non_filtered_period
+= h
->stat
.period
;
645 void hists__inc_stats(struct hists
*hists
, struct hist_entry
*h
)
648 hists__inc_filter_stats(hists
, h
);
651 hists
->stats
.total_period
+= h
->stat
.period
;
654 static void __hists__insert_output_entry(struct rb_root
*entries
,
655 struct hist_entry
*he
,
656 u64 min_callchain_hits
)
658 struct rb_node
**p
= &entries
->rb_node
;
659 struct rb_node
*parent
= NULL
;
660 struct hist_entry
*iter
;
662 if (symbol_conf
.use_callchain
)
663 callchain_param
.sort(&he
->sorted_chain
, he
->callchain
,
664 min_callchain_hits
, &callchain_param
);
668 iter
= rb_entry(parent
, struct hist_entry
, rb_node
);
670 if (hist_entry__sort_on_period(he
, iter
) > 0)
676 rb_link_node(&he
->rb_node
, parent
, p
);
677 rb_insert_color(&he
->rb_node
, entries
);
680 void hists__output_resort(struct hists
*hists
)
682 struct rb_root
*root
;
683 struct rb_node
*next
;
684 struct hist_entry
*n
;
685 u64 min_callchain_hits
;
687 min_callchain_hits
= hists
->stats
.total_period
* (callchain_param
.min_percent
/ 100);
689 if (sort__need_collapse
)
690 root
= &hists
->entries_collapsed
;
692 root
= hists
->entries_in
;
694 next
= rb_first(root
);
695 hists
->entries
= RB_ROOT
;
697 hists__reset_stats(hists
);
698 hists__reset_col_len(hists
);
701 n
= rb_entry(next
, struct hist_entry
, rb_node_in
);
702 next
= rb_next(&n
->rb_node_in
);
704 __hists__insert_output_entry(&hists
->entries
, n
, min_callchain_hits
);
705 hists__inc_stats(hists
, n
);
708 hists__calc_col_len(hists
, n
);
712 static void hists__remove_entry_filter(struct hists
*hists
, struct hist_entry
*h
,
713 enum hist_filter filter
)
715 h
->filtered
&= ~(1 << filter
);
720 hists
->nr_non_filtered_entries
+= h
->nr_rows
;
723 hists
->stats
.nr_non_filtered_samples
+= h
->stat
.nr_events
;
725 hists__inc_filter_stats(hists
, h
);
726 hists__calc_col_len(hists
, h
);
730 static bool hists__filter_entry_by_dso(struct hists
*hists
,
731 struct hist_entry
*he
)
733 if (hists
->dso_filter
!= NULL
&&
734 (he
->ms
.map
== NULL
|| he
->ms
.map
->dso
!= hists
->dso_filter
)) {
735 he
->filtered
|= (1 << HIST_FILTER__DSO
);
742 void hists__filter_by_dso(struct hists
*hists
)
746 hists
->stats
.nr_non_filtered_samples
= 0;
748 hists__reset_filter_stats(hists
);
749 hists__reset_col_len(hists
);
751 for (nd
= rb_first(&hists
->entries
); nd
; nd
= rb_next(nd
)) {
752 struct hist_entry
*h
= rb_entry(nd
, struct hist_entry
, rb_node
);
754 if (symbol_conf
.exclude_other
&& !h
->parent
)
757 if (hists__filter_entry_by_dso(hists
, h
))
760 hists__remove_entry_filter(hists
, h
, HIST_FILTER__DSO
);
764 static bool hists__filter_entry_by_thread(struct hists
*hists
,
765 struct hist_entry
*he
)
767 if (hists
->thread_filter
!= NULL
&&
768 he
->thread
!= hists
->thread_filter
) {
769 he
->filtered
|= (1 << HIST_FILTER__THREAD
);
776 void hists__filter_by_thread(struct hists
*hists
)
780 hists
->stats
.nr_non_filtered_samples
= 0;
782 hists__reset_filter_stats(hists
);
783 hists__reset_col_len(hists
);
785 for (nd
= rb_first(&hists
->entries
); nd
; nd
= rb_next(nd
)) {
786 struct hist_entry
*h
= rb_entry(nd
, struct hist_entry
, rb_node
);
788 if (hists__filter_entry_by_thread(hists
, h
))
791 hists__remove_entry_filter(hists
, h
, HIST_FILTER__THREAD
);
795 static bool hists__filter_entry_by_symbol(struct hists
*hists
,
796 struct hist_entry
*he
)
798 if (hists
->symbol_filter_str
!= NULL
&&
799 (!he
->ms
.sym
|| strstr(he
->ms
.sym
->name
,
800 hists
->symbol_filter_str
) == NULL
)) {
801 he
->filtered
|= (1 << HIST_FILTER__SYMBOL
);
808 void hists__filter_by_symbol(struct hists
*hists
)
812 hists
->stats
.nr_non_filtered_samples
= 0;
814 hists__reset_filter_stats(hists
);
815 hists__reset_col_len(hists
);
817 for (nd
= rb_first(&hists
->entries
); nd
; nd
= rb_next(nd
)) {
818 struct hist_entry
*h
= rb_entry(nd
, struct hist_entry
, rb_node
);
820 if (hists__filter_entry_by_symbol(hists
, h
))
823 hists__remove_entry_filter(hists
, h
, HIST_FILTER__SYMBOL
);
827 void events_stats__inc(struct events_stats
*stats
, u32 type
)
829 ++stats
->nr_events
[0];
830 ++stats
->nr_events
[type
];
833 void hists__inc_nr_events(struct hists
*hists
, u32 type
)
835 events_stats__inc(&hists
->stats
, type
);
838 static struct hist_entry
*hists__add_dummy_entry(struct hists
*hists
,
839 struct hist_entry
*pair
)
841 struct rb_root
*root
;
843 struct rb_node
*parent
= NULL
;
844 struct hist_entry
*he
;
847 if (sort__need_collapse
)
848 root
= &hists
->entries_collapsed
;
850 root
= hists
->entries_in
;
856 he
= rb_entry(parent
, struct hist_entry
, rb_node_in
);
858 cmp
= hist_entry__collapse(he
, pair
);
869 he
= hist_entry__new(pair
);
871 memset(&he
->stat
, 0, sizeof(he
->stat
));
873 rb_link_node(&he
->rb_node_in
, parent
, p
);
874 rb_insert_color(&he
->rb_node_in
, root
);
875 hists__inc_stats(hists
, he
);
882 static struct hist_entry
*hists__find_entry(struct hists
*hists
,
883 struct hist_entry
*he
)
887 if (sort__need_collapse
)
888 n
= hists
->entries_collapsed
.rb_node
;
890 n
= hists
->entries_in
->rb_node
;
893 struct hist_entry
*iter
= rb_entry(n
, struct hist_entry
, rb_node_in
);
894 int64_t cmp
= hist_entry__collapse(iter
, he
);
908 * Look for pairs to link to the leader buckets (hist_entries):
910 void hists__match(struct hists
*leader
, struct hists
*other
)
912 struct rb_root
*root
;
914 struct hist_entry
*pos
, *pair
;
916 if (sort__need_collapse
)
917 root
= &leader
->entries_collapsed
;
919 root
= leader
->entries_in
;
921 for (nd
= rb_first(root
); nd
; nd
= rb_next(nd
)) {
922 pos
= rb_entry(nd
, struct hist_entry
, rb_node_in
);
923 pair
= hists__find_entry(other
, pos
);
926 hist_entry__add_pair(pair
, pos
);
931 * Look for entries in the other hists that are not present in the leader, if
932 * we find them, just add a dummy entry on the leader hists, with period=0,
933 * nr_events=0, to serve as the list header.
935 int hists__link(struct hists
*leader
, struct hists
*other
)
937 struct rb_root
*root
;
939 struct hist_entry
*pos
, *pair
;
941 if (sort__need_collapse
)
942 root
= &other
->entries_collapsed
;
944 root
= other
->entries_in
;
946 for (nd
= rb_first(root
); nd
; nd
= rb_next(nd
)) {
947 pos
= rb_entry(nd
, struct hist_entry
, rb_node_in
);
949 if (!hist_entry__has_pairs(pos
)) {
950 pair
= hists__add_dummy_entry(leader
, pos
);
953 hist_entry__add_pair(pos
, pair
);
960 u64
hists__total_period(struct hists
*hists
)
962 return symbol_conf
.filter_relative
? hists
->stats
.total_non_filtered_period
:
963 hists
->stats
.total_period
;
966 int parse_filter_percentage(const struct option
*opt __maybe_unused
,
967 const char *arg
, int unset __maybe_unused
)
969 if (!strcmp(arg
, "relative"))
970 symbol_conf
.filter_relative
= true;
971 else if (!strcmp(arg
, "absolute"))
972 symbol_conf
.filter_relative
= false;
979 int perf_hist_config(const char *var
, const char *value
)
981 if (!strcmp(var
, "hist.percentage"))
982 return parse_filter_percentage(NULL
, value
, 0);