tools/perf/tests/hists_cumulate.c

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