Linux Perf
hists_cumulate.c
Go to the documentation of this file.
1 // SPDX-License-Identifier: GPL-2.0
2 #include "perf.h"
3 #include "util/debug.h"
4 #include "util/event.h"
5 #include "util/symbol.h"
6 #include "util/sort.h"
7 #include "util/evsel.h"
8 #include "util/evlist.h"
9 #include "util/machine.h"
10 #include "util/thread.h"
11 #include "util/parse-events.h"
12 #include "tests/tests.h"
13 #include "tests/hists_common.h"
14 #include <linux/kernel.h>
15 
16 struct sample {
17  u32 pid;
18  u64 ip;
19  struct thread *thread;
20  struct map *map;
21  struct symbol *sym;
22 };
23 
24 /* For the numbers, see hists_common.c */
25 static struct sample fake_samples[] = {
26  /* perf [kernel] schedule() */
28  /* perf [perf] main() */
29  { .pid = FAKE_PID_PERF1, .ip = FAKE_IP_PERF_MAIN, },
30  /* perf [perf] cmd_record() */
31  { .pid = FAKE_PID_PERF1, .ip = FAKE_IP_PERF_CMD_RECORD, },
32  /* perf [libc] malloc() */
33  { .pid = FAKE_PID_PERF1, .ip = FAKE_IP_LIBC_MALLOC, },
34  /* perf [libc] free() */
35  { .pid = FAKE_PID_PERF1, .ip = FAKE_IP_LIBC_FREE, },
36  /* perf [perf] main() */
37  { .pid = FAKE_PID_PERF2, .ip = FAKE_IP_PERF_MAIN, },
38  /* perf [kernel] page_fault() */
39  { .pid = FAKE_PID_PERF2, .ip = FAKE_IP_KERNEL_PAGE_FAULT, },
40  /* bash [bash] main() */
41  { .pid = FAKE_PID_BASH, .ip = FAKE_IP_BASH_MAIN, },
42  /* bash [bash] xmalloc() */
43  { .pid = FAKE_PID_BASH, .ip = FAKE_IP_BASH_XMALLOC, },
44  /* bash [kernel] page_fault() */
45  { .pid = FAKE_PID_BASH, .ip = FAKE_IP_KERNEL_PAGE_FAULT, },
46 };
47 
48 /*
49  * Will be casted to struct ip_callchain which has all 64 bit entries
50  * of nr and ips[].
51  */
52 static u64 fake_callchains[][10] = {
53  /* schedule => run_command => main */
55  /* main */
56  { 1, FAKE_IP_PERF_MAIN, },
57  /* cmd_record => run_command => main */
59  /* malloc => cmd_record => run_command => main */
62  /* free => cmd_record => run_command => main */
65  /* main */
66  { 1, FAKE_IP_PERF_MAIN, },
67  /* page_fault => sys_perf_event_open => run_command => main */
70  /* main */
71  { 1, FAKE_IP_BASH_MAIN, },
72  /* xmalloc => malloc => xmalloc => malloc => xmalloc => main */
75  /* page_fault => malloc => main */
77 };
78 
79 static int add_hist_entries(struct hists *hists, struct machine *machine)
80 {
81  struct addr_location al;
82  struct perf_evsel *evsel = hists_to_evsel(hists);
83  struct perf_sample sample = { .period = 1000, };
84  size_t i;
85 
86  for (i = 0; i < ARRAY_SIZE(fake_samples); i++) {
87  struct hist_entry_iter iter = {
88  .evsel = evsel,
89  .sample = &sample,
90  .hide_unresolved = false,
91  };
92 
94  iter.ops = &hist_iter_cumulative;
95  else
96  iter.ops = &hist_iter_normal;
97 
98  sample.cpumode = PERF_RECORD_MISC_USER;
99  sample.pid = fake_samples[i].pid;
100  sample.tid = fake_samples[i].pid;
101  sample.ip = fake_samples[i].ip;
102  sample.callchain = (struct ip_callchain *)fake_callchains[i];
103 
104  if (machine__resolve(machine, &al, &sample) < 0)
105  goto out;
106 
108  NULL) < 0) {
109  addr_location__put(&al);
110  goto out;
111  }
112 
113  fake_samples[i].thread = al.thread;
114  fake_samples[i].map = al.map;
115  fake_samples[i].sym = al.sym;
116  }
117 
118  return TEST_OK;
119 
120 out:
121  pr_debug("Not enough memory for adding a hist entry\n");
122  return TEST_FAIL;
123 }
124 
125 static void del_hist_entries(struct hists *hists)
126 {
127  struct hist_entry *he;
128  struct rb_root *root_in;
129  struct rb_root *root_out;
130  struct rb_node *node;
131 
132  if (hists__has(hists, need_collapse))
133  root_in = &hists->entries_collapsed;
134  else
135  root_in = hists->entries_in;
136 
137  root_out = &hists->entries;
138 
139  while (!RB_EMPTY_ROOT(root_out)) {
140  node = rb_first(root_out);
141 
142  he = rb_entry(node, struct hist_entry, rb_node);
143  rb_erase(node, root_out);
144  rb_erase(&he->rb_node_in, root_in);
145  hist_entry__delete(he);
146  }
147 }
148 
149 typedef int (*test_fn_t)(struct perf_evsel *, struct machine *);
150 
151 #define COMM(he) (thread__comm_str(he->thread))
152 #define DSO(he) (he->ms.map->dso->short_name)
153 #define SYM(he) (he->ms.sym->name)
154 #define CPU(he) (he->cpu)
155 #define PID(he) (he->thread->tid)
156 #define DEPTH(he) (he->callchain->max_depth)
157 #define CDSO(cl) (cl->ms.map->dso->short_name)
158 #define CSYM(cl) (cl->ms.sym->name)
159 
160 struct result {
161  u64 children;
162  u64 self;
163  const char *comm;
164  const char *dso;
165  const char *sym;
166 };
167 
169  u64 nr;
170  struct {
171  const char *dso;
172  const char *sym;
173  } node[10];
174 };
175 
176 static int do_test(struct hists *hists, struct result *expected, size_t nr_expected,
177  struct callchain_result *expected_callchain, size_t nr_callchain)
178 {
179  char buf[32];
180  size_t i, c;
181  struct hist_entry *he;
182  struct rb_root *root;
183  struct rb_node *node;
184  struct callchain_node *cnode;
185  struct callchain_list *clist;
186 
187  /*
188  * adding and deleting hist entries must be done outside of this
189  * function since TEST_ASSERT_VAL() returns in case of failure.
190  */
191  hists__collapse_resort(hists, NULL);
193 
194  if (verbose > 2) {
195  pr_info("use callchain: %d, cumulate callchain: %d\n",
198  print_hists_out(hists);
199  }
200 
201  root = &hists->entries;
202  for (node = rb_first(root), i = 0;
203  node && (he = rb_entry(node, struct hist_entry, rb_node));
204  node = rb_next(node), i++) {
205  scnprintf(buf, sizeof(buf), "Invalid hist entry #%zd", i);
206 
207  TEST_ASSERT_VAL("Incorrect number of hist entry",
208  i < nr_expected);
209  TEST_ASSERT_VAL(buf, he->stat.period == expected[i].self &&
210  !strcmp(COMM(he), expected[i].comm) &&
211  !strcmp(DSO(he), expected[i].dso) &&
212  !strcmp(SYM(he), expected[i].sym));
213 
215  TEST_ASSERT_VAL(buf, he->stat_acc->period == expected[i].children);
216 
218  continue;
219 
220  /* check callchain entries */
221  root = &he->callchain->node.rb_root;
222 
223  TEST_ASSERT_VAL("callchains expected", !RB_EMPTY_ROOT(root));
224  cnode = rb_entry(rb_first(root), struct callchain_node, rb_node);
225 
226  c = 0;
227  list_for_each_entry(clist, &cnode->val, list) {
228  scnprintf(buf, sizeof(buf), "Invalid callchain entry #%zd/%zd", i, c);
229 
230  TEST_ASSERT_VAL("Incorrect number of callchain entry",
231  c < expected_callchain[i].nr);
232  TEST_ASSERT_VAL(buf,
233  !strcmp(CDSO(clist), expected_callchain[i].node[c].dso) &&
234  !strcmp(CSYM(clist), expected_callchain[i].node[c].sym));
235  c++;
236  }
237  /* TODO: handle multiple child nodes properly */
238  TEST_ASSERT_VAL("Incorrect number of callchain entry",
239  c <= expected_callchain[i].nr);
240  }
241  TEST_ASSERT_VAL("Incorrect number of hist entry",
242  i == nr_expected);
243  TEST_ASSERT_VAL("Incorrect number of callchain entry",
244  !symbol_conf.use_callchain || nr_expected == nr_callchain);
245  return 0;
246 }
247 
248 /* NO callchain + NO children */
249 static int test1(struct perf_evsel *evsel, struct machine *machine)
250 {
251  int err;
252  struct hists *hists = evsel__hists(evsel);
253  /*
254  * expected output:
255  *
256  * Overhead Command Shared Object Symbol
257  * ======== ======= ============= ==============
258  * 20.00% perf perf [.] main
259  * 10.00% bash [kernel] [k] page_fault
260  * 10.00% bash bash [.] main
261  * 10.00% bash bash [.] xmalloc
262  * 10.00% perf [kernel] [k] page_fault
263  * 10.00% perf [kernel] [k] schedule
264  * 10.00% perf libc [.] free
265  * 10.00% perf libc [.] malloc
266  * 10.00% perf perf [.] cmd_record
267  */
268  struct result expected[] = {
269  { 0, 2000, "perf", "perf", "main" },
270  { 0, 1000, "bash", "[kernel]", "page_fault" },
271  { 0, 1000, "bash", "bash", "main" },
272  { 0, 1000, "bash", "bash", "xmalloc" },
273  { 0, 1000, "perf", "[kernel]", "page_fault" },
274  { 0, 1000, "perf", "[kernel]", "schedule" },
275  { 0, 1000, "perf", "libc", "free" },
276  { 0, 1000, "perf", "libc", "malloc" },
277  { 0, 1000, "perf", "perf", "cmd_record" },
278  };
279 
280  symbol_conf.use_callchain = false;
282  perf_evsel__reset_sample_bit(evsel, CALLCHAIN);
283 
284  setup_sorting(NULL);
286 
287  err = add_hist_entries(hists, machine);
288  if (err < 0)
289  goto out;
290 
291  err = do_test(hists, expected, ARRAY_SIZE(expected), NULL, 0);
292 
293 out:
294  del_hist_entries(hists);
296  return err;
297 }
298 
299 /* callcain + NO children */
300 static int test2(struct perf_evsel *evsel, struct machine *machine)
301 {
302  int err;
303  struct hists *hists = evsel__hists(evsel);
304  /*
305  * expected output:
306  *
307  * Overhead Command Shared Object Symbol
308  * ======== ======= ============= ==============
309  * 20.00% perf perf [.] main
310  * |
311  * --- main
312  *
313  * 10.00% bash [kernel] [k] page_fault
314  * |
315  * --- page_fault
316  * malloc
317  * main
318  *
319  * 10.00% bash bash [.] main
320  * |
321  * --- main
322  *
323  * 10.00% bash bash [.] xmalloc
324  * |
325  * --- xmalloc
326  * malloc
327  * xmalloc <--- NOTE: there's a cycle
328  * malloc
329  * xmalloc
330  * main
331  *
332  * 10.00% perf [kernel] [k] page_fault
333  * |
334  * --- page_fault
335  * sys_perf_event_open
336  * run_command
337  * main
338  *
339  * 10.00% perf [kernel] [k] schedule
340  * |
341  * --- schedule
342  * run_command
343  * main
344  *
345  * 10.00% perf libc [.] free
346  * |
347  * --- free
348  * cmd_record
349  * run_command
350  * main
351  *
352  * 10.00% perf libc [.] malloc
353  * |
354  * --- malloc
355  * cmd_record
356  * run_command
357  * main
358  *
359  * 10.00% perf perf [.] cmd_record
360  * |
361  * --- cmd_record
362  * run_command
363  * main
364  *
365  */
366  struct result expected[] = {
367  { 0, 2000, "perf", "perf", "main" },
368  { 0, 1000, "bash", "[kernel]", "page_fault" },
369  { 0, 1000, "bash", "bash", "main" },
370  { 0, 1000, "bash", "bash", "xmalloc" },
371  { 0, 1000, "perf", "[kernel]", "page_fault" },
372  { 0, 1000, "perf", "[kernel]", "schedule" },
373  { 0, 1000, "perf", "libc", "free" },
374  { 0, 1000, "perf", "libc", "malloc" },
375  { 0, 1000, "perf", "perf", "cmd_record" },
376  };
377  struct callchain_result expected_callchain[] = {
378  {
379  1, { { "perf", "main" }, },
380  },
381  {
382  3, { { "[kernel]", "page_fault" },
383  { "libc", "malloc" },
384  { "bash", "main" }, },
385  },
386  {
387  1, { { "bash", "main" }, },
388  },
389  {
390  6, { { "bash", "xmalloc" },
391  { "libc", "malloc" },
392  { "bash", "xmalloc" },
393  { "libc", "malloc" },
394  { "bash", "xmalloc" },
395  { "bash", "main" }, },
396  },
397  {
398  4, { { "[kernel]", "page_fault" },
399  { "[kernel]", "sys_perf_event_open" },
400  { "perf", "run_command" },
401  { "perf", "main" }, },
402  },
403  {
404  3, { { "[kernel]", "schedule" },
405  { "perf", "run_command" },
406  { "perf", "main" }, },
407  },
408  {
409  4, { { "libc", "free" },
410  { "perf", "cmd_record" },
411  { "perf", "run_command" },
412  { "perf", "main" }, },
413  },
414  {
415  4, { { "libc", "malloc" },
416  { "perf", "cmd_record" },
417  { "perf", "run_command" },
418  { "perf", "main" }, },
419  },
420  {
421  3, { { "perf", "cmd_record" },
422  { "perf", "run_command" },
423  { "perf", "main" }, },
424  },
425  };
426 
427  symbol_conf.use_callchain = true;
429  perf_evsel__set_sample_bit(evsel, CALLCHAIN);
430 
431  setup_sorting(NULL);
433 
434  err = add_hist_entries(hists, machine);
435  if (err < 0)
436  goto out;
437 
438  err = do_test(hists, expected, ARRAY_SIZE(expected),
439  expected_callchain, ARRAY_SIZE(expected_callchain));
440 
441 out:
442  del_hist_entries(hists);
444  return err;
445 }
446 
447 /* NO callchain + children */
448 static int test3(struct perf_evsel *evsel, struct machine *machine)
449 {
450  int err;
451  struct hists *hists = evsel__hists(evsel);
452  /*
453  * expected output:
454  *
455  * Children Self Command Shared Object Symbol
456  * ======== ======== ======= ============= =======================
457  * 70.00% 20.00% perf perf [.] main
458  * 50.00% 0.00% perf perf [.] run_command
459  * 30.00% 10.00% bash bash [.] main
460  * 30.00% 10.00% perf perf [.] cmd_record
461  * 20.00% 0.00% bash libc [.] malloc
462  * 10.00% 10.00% bash [kernel] [k] page_fault
463  * 10.00% 10.00% bash bash [.] xmalloc
464  * 10.00% 10.00% perf [kernel] [k] page_fault
465  * 10.00% 10.00% perf libc [.] malloc
466  * 10.00% 10.00% perf [kernel] [k] schedule
467  * 10.00% 10.00% perf libc [.] free
468  * 10.00% 0.00% perf [kernel] [k] sys_perf_event_open
469  */
470  struct result expected[] = {
471  { 7000, 2000, "perf", "perf", "main" },
472  { 5000, 0, "perf", "perf", "run_command" },
473  { 3000, 1000, "bash", "bash", "main" },
474  { 3000, 1000, "perf", "perf", "cmd_record" },
475  { 2000, 0, "bash", "libc", "malloc" },
476  { 1000, 1000, "bash", "[kernel]", "page_fault" },
477  { 1000, 1000, "bash", "bash", "xmalloc" },
478  { 1000, 1000, "perf", "[kernel]", "page_fault" },
479  { 1000, 1000, "perf", "[kernel]", "schedule" },
480  { 1000, 1000, "perf", "libc", "free" },
481  { 1000, 1000, "perf", "libc", "malloc" },
482  { 1000, 0, "perf", "[kernel]", "sys_perf_event_open" },
483  };
484 
485  symbol_conf.use_callchain = false;
487  perf_evsel__reset_sample_bit(evsel, CALLCHAIN);
488 
489  setup_sorting(NULL);
491 
492  err = add_hist_entries(hists, machine);
493  if (err < 0)
494  goto out;
495 
496  err = do_test(hists, expected, ARRAY_SIZE(expected), NULL, 0);
497 
498 out:
499  del_hist_entries(hists);
501  return err;
502 }
503 
504 /* callchain + children */
505 static int test4(struct perf_evsel *evsel, struct machine *machine)
506 {
507  int err;
508  struct hists *hists = evsel__hists(evsel);
509  /*
510  * expected output:
511  *
512  * Children Self Command Shared Object Symbol
513  * ======== ======== ======= ============= =======================
514  * 70.00% 20.00% perf perf [.] main
515  * |
516  * --- main
517  *
518  * 50.00% 0.00% perf perf [.] run_command
519  * |
520  * --- run_command
521  * main
522  *
523  * 30.00% 10.00% bash bash [.] main
524  * |
525  * --- main
526  *
527  * 30.00% 10.00% perf perf [.] cmd_record
528  * |
529  * --- cmd_record
530  * run_command
531  * main
532  *
533  * 20.00% 0.00% bash libc [.] malloc
534  * |
535  * --- malloc
536  * |
537  * |--50.00%-- xmalloc
538  * | main
539  * --50.00%-- main
540  *
541  * 10.00% 10.00% bash [kernel] [k] page_fault
542  * |
543  * --- page_fault
544  * malloc
545  * main
546  *
547  * 10.00% 10.00% bash bash [.] xmalloc
548  * |
549  * --- xmalloc
550  * malloc
551  * xmalloc <--- NOTE: there's a cycle
552  * malloc
553  * xmalloc
554  * main
555  *
556  * 10.00% 0.00% perf [kernel] [k] sys_perf_event_open
557  * |
558  * --- sys_perf_event_open
559  * run_command
560  * main
561  *
562  * 10.00% 10.00% perf [kernel] [k] page_fault
563  * |
564  * --- page_fault
565  * sys_perf_event_open
566  * run_command
567  * main
568  *
569  * 10.00% 10.00% perf [kernel] [k] schedule
570  * |
571  * --- schedule
572  * run_command
573  * main
574  *
575  * 10.00% 10.00% perf libc [.] free
576  * |
577  * --- free
578  * cmd_record
579  * run_command
580  * main
581  *
582  * 10.00% 10.00% perf libc [.] malloc
583  * |
584  * --- malloc
585  * cmd_record
586  * run_command
587  * main
588  *
589  */
590  struct result expected[] = {
591  { 7000, 2000, "perf", "perf", "main" },
592  { 5000, 0, "perf", "perf", "run_command" },
593  { 3000, 1000, "bash", "bash", "main" },
594  { 3000, 1000, "perf", "perf", "cmd_record" },
595  { 2000, 0, "bash", "libc", "malloc" },
596  { 1000, 1000, "bash", "[kernel]", "page_fault" },
597  { 1000, 1000, "bash", "bash", "xmalloc" },
598  { 1000, 0, "perf", "[kernel]", "sys_perf_event_open" },
599  { 1000, 1000, "perf", "[kernel]", "page_fault" },
600  { 1000, 1000, "perf", "[kernel]", "schedule" },
601  { 1000, 1000, "perf", "libc", "free" },
602  { 1000, 1000, "perf", "libc", "malloc" },
603  };
604  struct callchain_result expected_callchain[] = {
605  {
606  1, { { "perf", "main" }, },
607  },
608  {
609  2, { { "perf", "run_command" },
610  { "perf", "main" }, },
611  },
612  {
613  1, { { "bash", "main" }, },
614  },
615  {
616  3, { { "perf", "cmd_record" },
617  { "perf", "run_command" },
618  { "perf", "main" }, },
619  },
620  {
621  4, { { "libc", "malloc" },
622  { "bash", "xmalloc" },
623  { "bash", "main" },
624  { "bash", "main" }, },
625  },
626  {
627  3, { { "[kernel]", "page_fault" },
628  { "libc", "malloc" },
629  { "bash", "main" }, },
630  },
631  {
632  6, { { "bash", "xmalloc" },
633  { "libc", "malloc" },
634  { "bash", "xmalloc" },
635  { "libc", "malloc" },
636  { "bash", "xmalloc" },
637  { "bash", "main" }, },
638  },
639  {
640  3, { { "[kernel]", "sys_perf_event_open" },
641  { "perf", "run_command" },
642  { "perf", "main" }, },
643  },
644  {
645  4, { { "[kernel]", "page_fault" },
646  { "[kernel]", "sys_perf_event_open" },
647  { "perf", "run_command" },
648  { "perf", "main" }, },
649  },
650  {
651  3, { { "[kernel]", "schedule" },
652  { "perf", "run_command" },
653  { "perf", "main" }, },
654  },
655  {
656  4, { { "libc", "free" },
657  { "perf", "cmd_record" },
658  { "perf", "run_command" },
659  { "perf", "main" }, },
660  },
661  {
662  4, { { "libc", "malloc" },
663  { "perf", "cmd_record" },
664  { "perf", "run_command" },
665  { "perf", "main" }, },
666  },
667  };
668 
669  symbol_conf.use_callchain = true;
671  perf_evsel__set_sample_bit(evsel, CALLCHAIN);
672 
673  setup_sorting(NULL);
674 
677 
678  err = add_hist_entries(hists, machine);
679  if (err < 0)
680  goto out;
681 
682  err = do_test(hists, expected, ARRAY_SIZE(expected),
683  expected_callchain, ARRAY_SIZE(expected_callchain));
684 
685 out:
686  del_hist_entries(hists);
688  return err;
689 }
690 
691 int test__hists_cumulate(struct test *test __maybe_unused, int subtest __maybe_unused)
692 {
693  int err = TEST_FAIL;
694  struct machines machines;
695  struct machine *machine;
696  struct perf_evsel *evsel;
697  struct perf_evlist *evlist = perf_evlist__new();
698  size_t i;
699  test_fn_t testcases[] = {
700  test1,
701  test2,
702  test3,
703  test4,
704  };
705 
706  TEST_ASSERT_VAL("No memory", evlist);
707 
708  err = parse_events(evlist, "cpu-clock", NULL);
709  if (err)
710  goto out;
711  err = TEST_FAIL;
712 
713  machines__init(&machines);
714 
715  /* setup threads/dso/map/symbols also */
716  machine = setup_fake_machine(&machines);
717  if (!machine)
718  goto out;
719 
720  if (verbose > 1)
721  machine__fprintf(machine, stderr);
722 
723  evsel = perf_evlist__first(evlist);
724 
725  for (i = 0; i < ARRAY_SIZE(testcases); i++) {
726  err = testcases[i](evsel, machine);
727  if (err < 0)
728  break;
729  }
730 
731 out:
732  /* tear down everything */
733  perf_evlist__delete(evlist);
734  machines__exit(&machines);
735 
736  return err;
737 }
#define FAKE_IP_BASH_XMALLOC
Definition: hists_common.h:27
static void setup_sorting(struct perf_sched *sched, const struct option *options, const char *const usage_msg[])
struct rb_root * entries_in
Definition: hist.h:73
struct list_head val
Definition: callchain.h:57
struct list_head list
Definition: callchain.h:128
struct perf_sample * sample
Definition: hist.h:113
Definition: mem2node.c:7
void machines__exit(struct machines *machines)
Definition: machine.c:228
#define FAKE_IP_KERNEL_SYS_PERF_EVENT_OPEN
Definition: hists_common.h:34
const char * comm
int machine__resolve(struct machine *machine, struct addr_location *al, struct perf_sample *sample)
Definition: event.c:1601
bool cumulate_callchain
Definition: symbol.h:93
void reset_output_field(void)
Definition: sort.c:2997
Definition: hist.h:106
struct ip_callchain * callchain
Definition: event.h:211
int int err
Definition: 5sec.c:44
int hists__collapse_resort(struct hists *hists, struct ui_progress *prog)
Definition: hist.c:1464
struct rb_root root
Definition: block-range.c:6
#define FAKE_IP_LIBC_MALLOC
Definition: hists_common.h:29
#define TEST_ASSERT_VAL(text, cond)
Definition: tests.h:7
#define CSYM(cl)
static int add_hist_entries(struct hists *hists, struct machine *machine)
u64 children
void perf_evlist__delete(struct perf_evlist *evlist)
Definition: evlist.c:133
#define perf_evsel__set_sample_bit(evsel, bit)
Definition: evsel.h:260
static struct hists * evsel__hists(struct perf_evsel *evsel)
Definition: hist.h:217
#define COMM(he)
struct map * map
u64 ip
Definition: event.h:192
Definition: comm.h:11
Definition: sort.h:89
struct callchain_param callchain_param_default
Definition: callchain.c:49
int parse_events(struct perf_evlist *evlist, const char *str, struct parse_events_error *err)
const char * dso
static int test2(struct perf_evsel *evsel, struct machine *machine)
void addr_location__put(struct addr_location *al)
Definition: event.c:1661
const char * sym
struct map * map
Definition: symbol.h:210
Definition: thread.h:18
static int do_test(struct hists *hists, struct result *expected, size_t nr_expected, struct callchain_result *expected_callchain, size_t nr_callchain)
struct symbol * sym
static struct perf_evsel * hists_to_evsel(struct hists *hists)
Definition: hist.h:211
#define pr_debug(fmt,...)
Definition: json.h:27
#define FAKE_IP_PERF_MAIN
Definition: hists_common.h:23
#define FAKE_IP_KERNEL_SCHEDULE
Definition: hists_common.h:32
#define CDSO(cl)
int test__hists_cumulate(struct test *test __maybe_unused, int subtest __maybe_unused)
#define FAKE_PID_PERF2
Definition: hists_common.h:9
u64 period
Definition: event.h:198
u32 pid
Definition: event.h:193
u32 tid
Definition: event.h:193
static int test1(struct perf_evsel *evsel, struct machine *machine)
const char * sym
#define hists__has(__h, __f)
Definition: hist.h:94
static void del_hist_entries(struct hists *hists)
#define DSO(he)
struct symbol * sym
Definition: symbol.h:211
Definition: dso.h:138
static u64 fake_callchains[][10]
void hist_entry__delete(struct hist_entry *he)
Definition: hist.c:1126
#define FAKE_IP_PERF_CMD_RECORD
Definition: hists_common.h:25
struct thread * thread
Definition: symbol.h:209
struct rb_node rb_node_in
Definition: sort.h:90
static int test4(struct perf_evsel *evsel, struct machine *machine)
int node
Definition: mem2node.c:8
const struct hist_iter_ops hist_iter_normal
Definition: hist.c:1020
#define FAKE_PID_PERF1
Definition: hists_common.h:8
static struct sample fake_samples[]
static struct perf_evsel * perf_evlist__first(struct perf_evlist *evlist)
Definition: evlist.h:215
Definition: jevents.c:228
bool use_callchain
Definition: symbol.h:93
void machines__init(struct machines *machines)
Definition: machine.c:222
int(* test_fn_t)(struct perf_evsel *, struct machine *)
void print_hists_out(struct hists *hists)
Definition: hists_common.c:191
Definition: tests.h:30
#define FAKE_IP_BASH_MAIN
Definition: hists_common.h:26
struct perf_evsel * evsel
Definition: hist.h:112
#define FAKE_IP_PERF_RUN_COMMAND
Definition: hists_common.h:24
const char * dso
#define SYM(he)
#define pr_info(fmt,...)
Definition: json.h:24
const struct hist_iter_ops hist_iter_cumulative
Definition: hist.c:1028
#define FAKE_IP_KERNEL_PAGE_FAULT
Definition: hists_common.h:33
struct rb_root entries
Definition: hist.h:74
#define perf_evsel__reset_sample_bit(evsel, bit)
Definition: evsel.h:263
void perf_evsel__output_resort(struct perf_evsel *evsel, struct ui_progress *prog)
Definition: hist.c:1756
int verbose
Definition: jevents.c:53
Definition: symbol.h:55
const struct hist_iter_ops * ops
Definition: hist.h:118
static int test3(struct perf_evsel *evsel, struct machine *machine)
struct machine * setup_fake_machine(struct machines *machines)
Definition: hists_common.c:83
#define FAKE_PID_BASH
Definition: hists_common.h:10
Definition: hist.h:71
struct rb_root entries_collapsed
Definition: hist.h:75
int sysctl_perf_event_max_stack
Definition: util.c:62
struct thread * thread
#define FAKE_IP_LIBC_FREE
Definition: hists_common.h:30
int callchain_register_param(struct callchain_param *param)
Definition: callchain.c:494
u8 cpumode
Definition: event.h:207
size_t machine__fprintf(struct machine *machine, FILE *fp)
Definition: machine.c:756
struct perf_evlist * perf_evlist__new(void)
Definition: evlist.c:54
int hist_entry_iter__add(struct hist_entry_iter *iter, struct addr_location *al, int max_stack_depth, void *arg)
Definition: hist.c:1036
Definition: tests.h:25