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