1 #include "perf.h" 2 #include "util/debug.h" 3 #include "util/symbol.h" 4 #include "util/sort.h" 5 #include "util/evsel.h" 6 #include "util/evlist.h" 7 #include "util/machine.h" 8 #include "util/thread.h" 9 #include "util/parse-events.h" 10 #include "tests/tests.h" 11 #include "tests/hists_common.h" 12 13 struct sample { 14 u32 cpu; 15 u32 pid; 16 u64 ip; 17 struct thread *thread; 18 struct map *map; 19 struct symbol *sym; 20 }; 21 22 /* For the numbers, see hists_common.c */ 23 static struct sample fake_samples[] = { 24 /* perf [kernel] schedule() */ 25 { .cpu = 0, .pid = FAKE_PID_PERF1, .ip = FAKE_IP_KERNEL_SCHEDULE, }, 26 /* perf [perf] main() */ 27 { .cpu = 1, .pid = FAKE_PID_PERF1, .ip = FAKE_IP_PERF_MAIN, }, 28 /* perf [perf] cmd_record() */ 29 { .cpu = 1, .pid = FAKE_PID_PERF1, .ip = FAKE_IP_PERF_CMD_RECORD, }, 30 /* perf [libc] malloc() */ 31 { .cpu = 1, .pid = FAKE_PID_PERF1, .ip = FAKE_IP_LIBC_MALLOC, }, 32 /* perf [libc] free() */ 33 { .cpu = 2, .pid = FAKE_PID_PERF1, .ip = FAKE_IP_LIBC_FREE, }, 34 /* perf [perf] main() */ 35 { .cpu = 2, .pid = FAKE_PID_PERF2, .ip = FAKE_IP_PERF_MAIN, }, 36 /* perf [kernel] page_fault() */ 37 { .cpu = 2, .pid = FAKE_PID_PERF2, .ip = FAKE_IP_KERNEL_PAGE_FAULT, }, 38 /* bash [bash] main() */ 39 { .cpu = 3, .pid = FAKE_PID_BASH, .ip = FAKE_IP_BASH_MAIN, }, 40 /* bash [bash] xmalloc() */ 41 { .cpu = 0, .pid = FAKE_PID_BASH, .ip = FAKE_IP_BASH_XMALLOC, }, 42 /* bash [kernel] page_fault() */ 43 { .cpu = 1, .pid = FAKE_PID_BASH, .ip = FAKE_IP_KERNEL_PAGE_FAULT, }, 44 }; 45 46 static int add_hist_entries(struct hists *hists, struct machine *machine) 47 { 48 struct addr_location al; 49 struct perf_evsel *evsel = hists_to_evsel(hists); 50 struct perf_sample sample = { .period = 100, }; 51 size_t i; 52 53 for (i = 0; i < ARRAY_SIZE(fake_samples); i++) { 54 const union perf_event event = { 55 .header = { 56 .misc = PERF_RECORD_MISC_USER, 57 }, 58 }; 59 struct hist_entry_iter iter = { 60 .ops = &hist_iter_normal, 61 .hide_unresolved = false, 62 }; 63 64 sample.cpu = fake_samples[i].cpu; 65 sample.pid = fake_samples[i].pid; 66 sample.tid = fake_samples[i].pid; 67 sample.ip = fake_samples[i].ip; 68 69 if (perf_event__preprocess_sample(&event, machine, &al, 70 &sample) < 0) 71 goto out; 72 73 if (hist_entry_iter__add(&iter, &al, evsel, &sample, 74 PERF_MAX_STACK_DEPTH, NULL) < 0) 75 goto out; 76 77 fake_samples[i].thread = al.thread; 78 fake_samples[i].map = al.map; 79 fake_samples[i].sym = al.sym; 80 } 81 82 return TEST_OK; 83 84 out: 85 pr_debug("Not enough memory for adding a hist entry\n"); 86 return TEST_FAIL; 87 } 88 89 static void del_hist_entries(struct hists *hists) 90 { 91 struct hist_entry *he; 92 struct rb_root *root_in; 93 struct rb_root *root_out; 94 struct rb_node *node; 95 96 if (sort__need_collapse) 97 root_in = &hists->entries_collapsed; 98 else 99 root_in = hists->entries_in; 100 101 root_out = &hists->entries; 102 103 while (!RB_EMPTY_ROOT(root_out)) { 104 node = rb_first(root_out); 105 106 he = rb_entry(node, struct hist_entry, rb_node); 107 rb_erase(node, root_out); 108 rb_erase(&he->rb_node_in, root_in); 109 hist_entry__free(he); 110 } 111 } 112 113 typedef int (*test_fn_t)(struct perf_evsel *, struct machine *); 114 115 #define COMM(he) (thread__comm_str(he->thread)) 116 #define DSO(he) (he->ms.map->dso->short_name) 117 #define SYM(he) (he->ms.sym->name) 118 #define CPU(he) (he->cpu) 119 #define PID(he) (he->thread->tid) 120 121 /* default sort keys (no field) */ 122 static int test1(struct perf_evsel *evsel, struct machine *machine) 123 { 124 int err; 125 struct hists *hists = evsel__hists(evsel); 126 struct hist_entry *he; 127 struct rb_root *root; 128 struct rb_node *node; 129 130 field_order = NULL; 131 sort_order = NULL; /* equivalent to sort_order = "comm,dso,sym" */ 132 133 setup_sorting(); 134 135 /* 136 * expected output: 137 * 138 * Overhead Command Shared Object Symbol 139 * ======== ======= ============= ============== 140 * 20.00% perf perf [.] main 141 * 10.00% bash [kernel] [k] page_fault 142 * 10.00% bash bash [.] main 143 * 10.00% bash bash [.] xmalloc 144 * 10.00% perf [kernel] [k] page_fault 145 * 10.00% perf [kernel] [k] schedule 146 * 10.00% perf libc [.] free 147 * 10.00% perf libc [.] malloc 148 * 10.00% perf perf [.] cmd_record 149 */ 150 err = add_hist_entries(hists, machine); 151 if (err < 0) 152 goto out; 153 154 hists__collapse_resort(hists, NULL); 155 hists__output_resort(hists); 156 157 if (verbose > 2) { 158 pr_info("[fields = %s, sort = %s]\n", field_order, sort_order); 159 print_hists_out(hists); 160 } 161 162 root = &hists->entries; 163 node = rb_first(root); 164 he = rb_entry(node, struct hist_entry, rb_node); 165 TEST_ASSERT_VAL("Invalid hist entry", 166 !strcmp(COMM(he), "perf") && !strcmp(DSO(he), "perf") && 167 !strcmp(SYM(he), "main") && he->stat.period == 200); 168 169 node = rb_next(node); 170 he = rb_entry(node, struct hist_entry, rb_node); 171 TEST_ASSERT_VAL("Invalid hist entry", 172 !strcmp(COMM(he), "bash") && !strcmp(DSO(he), "[kernel]") && 173 !strcmp(SYM(he), "page_fault") && he->stat.period == 100); 174 175 node = rb_next(node); 176 he = rb_entry(node, struct hist_entry, rb_node); 177 TEST_ASSERT_VAL("Invalid hist entry", 178 !strcmp(COMM(he), "bash") && !strcmp(DSO(he), "bash") && 179 !strcmp(SYM(he), "main") && he->stat.period == 100); 180 181 node = rb_next(node); 182 he = rb_entry(node, struct hist_entry, rb_node); 183 TEST_ASSERT_VAL("Invalid hist entry", 184 !strcmp(COMM(he), "bash") && !strcmp(DSO(he), "bash") && 185 !strcmp(SYM(he), "xmalloc") && he->stat.period == 100); 186 187 node = rb_next(node); 188 he = rb_entry(node, struct hist_entry, rb_node); 189 TEST_ASSERT_VAL("Invalid hist entry", 190 !strcmp(COMM(he), "perf") && !strcmp(DSO(he), "[kernel]") && 191 !strcmp(SYM(he), "page_fault") && he->stat.period == 100); 192 193 node = rb_next(node); 194 he = rb_entry(node, struct hist_entry, rb_node); 195 TEST_ASSERT_VAL("Invalid hist entry", 196 !strcmp(COMM(he), "perf") && !strcmp(DSO(he), "[kernel]") && 197 !strcmp(SYM(he), "schedule") && he->stat.period == 100); 198 199 node = rb_next(node); 200 he = rb_entry(node, struct hist_entry, rb_node); 201 TEST_ASSERT_VAL("Invalid hist entry", 202 !strcmp(COMM(he), "perf") && !strcmp(DSO(he), "libc") && 203 !strcmp(SYM(he), "free") && he->stat.period == 100); 204 205 node = rb_next(node); 206 he = rb_entry(node, struct hist_entry, rb_node); 207 TEST_ASSERT_VAL("Invalid hist entry", 208 !strcmp(COMM(he), "perf") && !strcmp(DSO(he), "libc") && 209 !strcmp(SYM(he), "malloc") && he->stat.period == 100); 210 211 node = rb_next(node); 212 he = rb_entry(node, struct hist_entry, rb_node); 213 TEST_ASSERT_VAL("Invalid hist entry", 214 !strcmp(COMM(he), "perf") && !strcmp(DSO(he), "perf") && 215 !strcmp(SYM(he), "cmd_record") && he->stat.period == 100); 216 217 out: 218 del_hist_entries(hists); 219 reset_output_field(); 220 return err; 221 } 222 223 /* mixed fields and sort keys */ 224 static int test2(struct perf_evsel *evsel, struct machine *machine) 225 { 226 int err; 227 struct hists *hists = evsel__hists(evsel); 228 struct hist_entry *he; 229 struct rb_root *root; 230 struct rb_node *node; 231 232 field_order = "overhead,cpu"; 233 sort_order = "pid"; 234 235 setup_sorting(); 236 237 /* 238 * expected output: 239 * 240 * Overhead CPU Command: Pid 241 * ======== === ============= 242 * 30.00% 1 perf : 100 243 * 10.00% 0 perf : 100 244 * 10.00% 2 perf : 100 245 * 20.00% 2 perf : 200 246 * 10.00% 0 bash : 300 247 * 10.00% 1 bash : 300 248 * 10.00% 3 bash : 300 249 */ 250 err = add_hist_entries(hists, machine); 251 if (err < 0) 252 goto out; 253 254 hists__collapse_resort(hists, NULL); 255 hists__output_resort(hists); 256 257 if (verbose > 2) { 258 pr_info("[fields = %s, sort = %s]\n", field_order, sort_order); 259 print_hists_out(hists); 260 } 261 262 root = &hists->entries; 263 node = rb_first(root); 264 he = rb_entry(node, struct hist_entry, rb_node); 265 TEST_ASSERT_VAL("Invalid hist entry", 266 CPU(he) == 1 && PID(he) == 100 && he->stat.period == 300); 267 268 node = rb_next(node); 269 he = rb_entry(node, struct hist_entry, rb_node); 270 TEST_ASSERT_VAL("Invalid hist entry", 271 CPU(he) == 0 && PID(he) == 100 && he->stat.period == 100); 272 273 out: 274 del_hist_entries(hists); 275 reset_output_field(); 276 return err; 277 } 278 279 /* fields only (no sort key) */ 280 static int test3(struct perf_evsel *evsel, struct machine *machine) 281 { 282 int err; 283 struct hists *hists = evsel__hists(evsel); 284 struct hist_entry *he; 285 struct rb_root *root; 286 struct rb_node *node; 287 288 field_order = "comm,overhead,dso"; 289 sort_order = NULL; 290 291 setup_sorting(); 292 293 /* 294 * expected output: 295 * 296 * Command Overhead Shared Object 297 * ======= ======== ============= 298 * bash 20.00% bash 299 * bash 10.00% [kernel] 300 * perf 30.00% perf 301 * perf 20.00% [kernel] 302 * perf 20.00% libc 303 */ 304 err = add_hist_entries(hists, machine); 305 if (err < 0) 306 goto out; 307 308 hists__collapse_resort(hists, NULL); 309 hists__output_resort(hists); 310 311 if (verbose > 2) { 312 pr_info("[fields = %s, sort = %s]\n", field_order, sort_order); 313 print_hists_out(hists); 314 } 315 316 root = &hists->entries; 317 node = rb_first(root); 318 he = rb_entry(node, struct hist_entry, rb_node); 319 TEST_ASSERT_VAL("Invalid hist entry", 320 !strcmp(COMM(he), "bash") && !strcmp(DSO(he), "bash") && 321 he->stat.period == 200); 322 323 node = rb_next(node); 324 he = rb_entry(node, struct hist_entry, rb_node); 325 TEST_ASSERT_VAL("Invalid hist entry", 326 !strcmp(COMM(he), "bash") && !strcmp(DSO(he), "[kernel]") && 327 he->stat.period == 100); 328 329 node = rb_next(node); 330 he = rb_entry(node, struct hist_entry, rb_node); 331 TEST_ASSERT_VAL("Invalid hist entry", 332 !strcmp(COMM(he), "perf") && !strcmp(DSO(he), "perf") && 333 he->stat.period == 300); 334 335 node = rb_next(node); 336 he = rb_entry(node, struct hist_entry, rb_node); 337 TEST_ASSERT_VAL("Invalid hist entry", 338 !strcmp(COMM(he), "perf") && !strcmp(DSO(he), "[kernel]") && 339 he->stat.period == 200); 340 341 node = rb_next(node); 342 he = rb_entry(node, struct hist_entry, rb_node); 343 TEST_ASSERT_VAL("Invalid hist entry", 344 !strcmp(COMM(he), "perf") && !strcmp(DSO(he), "libc") && 345 he->stat.period == 200); 346 347 out: 348 del_hist_entries(hists); 349 reset_output_field(); 350 return err; 351 } 352 353 /* handle duplicate 'dso' field */ 354 static int test4(struct perf_evsel *evsel, struct machine *machine) 355 { 356 int err; 357 struct hists *hists = evsel__hists(evsel); 358 struct hist_entry *he; 359 struct rb_root *root; 360 struct rb_node *node; 361 362 field_order = "dso,sym,comm,overhead,dso"; 363 sort_order = "sym"; 364 365 setup_sorting(); 366 367 /* 368 * expected output: 369 * 370 * Shared Object Symbol Command Overhead 371 * ============= ============== ======= ======== 372 * perf [.] cmd_record perf 10.00% 373 * libc [.] free perf 10.00% 374 * bash [.] main bash 10.00% 375 * perf [.] main perf 20.00% 376 * libc [.] malloc perf 10.00% 377 * [kernel] [k] page_fault bash 10.00% 378 * [kernel] [k] page_fault perf 10.00% 379 * [kernel] [k] schedule perf 10.00% 380 * bash [.] xmalloc bash 10.00% 381 */ 382 err = add_hist_entries(hists, machine); 383 if (err < 0) 384 goto out; 385 386 hists__collapse_resort(hists, NULL); 387 hists__output_resort(hists); 388 389 if (verbose > 2) { 390 pr_info("[fields = %s, sort = %s]\n", field_order, sort_order); 391 print_hists_out(hists); 392 } 393 394 root = &hists->entries; 395 node = rb_first(root); 396 he = rb_entry(node, struct hist_entry, rb_node); 397 TEST_ASSERT_VAL("Invalid hist entry", 398 !strcmp(DSO(he), "perf") && !strcmp(SYM(he), "cmd_record") && 399 !strcmp(COMM(he), "perf") && he->stat.period == 100); 400 401 node = rb_next(node); 402 he = rb_entry(node, struct hist_entry, rb_node); 403 TEST_ASSERT_VAL("Invalid hist entry", 404 !strcmp(DSO(he), "libc") && !strcmp(SYM(he), "free") && 405 !strcmp(COMM(he), "perf") && he->stat.period == 100); 406 407 node = rb_next(node); 408 he = rb_entry(node, struct hist_entry, rb_node); 409 TEST_ASSERT_VAL("Invalid hist entry", 410 !strcmp(DSO(he), "bash") && !strcmp(SYM(he), "main") && 411 !strcmp(COMM(he), "bash") && he->stat.period == 100); 412 413 node = rb_next(node); 414 he = rb_entry(node, struct hist_entry, rb_node); 415 TEST_ASSERT_VAL("Invalid hist entry", 416 !strcmp(DSO(he), "perf") && !strcmp(SYM(he), "main") && 417 !strcmp(COMM(he), "perf") && he->stat.period == 200); 418 419 node = rb_next(node); 420 he = rb_entry(node, struct hist_entry, rb_node); 421 TEST_ASSERT_VAL("Invalid hist entry", 422 !strcmp(DSO(he), "libc") && !strcmp(SYM(he), "malloc") && 423 !strcmp(COMM(he), "perf") && he->stat.period == 100); 424 425 node = rb_next(node); 426 he = rb_entry(node, struct hist_entry, rb_node); 427 TEST_ASSERT_VAL("Invalid hist entry", 428 !strcmp(DSO(he), "[kernel]") && !strcmp(SYM(he), "page_fault") && 429 !strcmp(COMM(he), "bash") && he->stat.period == 100); 430 431 node = rb_next(node); 432 he = rb_entry(node, struct hist_entry, rb_node); 433 TEST_ASSERT_VAL("Invalid hist entry", 434 !strcmp(DSO(he), "[kernel]") && !strcmp(SYM(he), "page_fault") && 435 !strcmp(COMM(he), "perf") && he->stat.period == 100); 436 437 node = rb_next(node); 438 he = rb_entry(node, struct hist_entry, rb_node); 439 TEST_ASSERT_VAL("Invalid hist entry", 440 !strcmp(DSO(he), "[kernel]") && !strcmp(SYM(he), "schedule") && 441 !strcmp(COMM(he), "perf") && he->stat.period == 100); 442 443 node = rb_next(node); 444 he = rb_entry(node, struct hist_entry, rb_node); 445 TEST_ASSERT_VAL("Invalid hist entry", 446 !strcmp(DSO(he), "bash") && !strcmp(SYM(he), "xmalloc") && 447 !strcmp(COMM(he), "bash") && he->stat.period == 100); 448 449 out: 450 del_hist_entries(hists); 451 reset_output_field(); 452 return err; 453 } 454 455 /* full sort keys w/o overhead field */ 456 static int test5(struct perf_evsel *evsel, struct machine *machine) 457 { 458 int err; 459 struct hists *hists = evsel__hists(evsel); 460 struct hist_entry *he; 461 struct rb_root *root; 462 struct rb_node *node; 463 464 field_order = "cpu,pid,comm,dso,sym"; 465 sort_order = "dso,pid"; 466 467 setup_sorting(); 468 469 /* 470 * expected output: 471 * 472 * CPU Command: Pid Command Shared Object Symbol 473 * === ============= ======= ============= ============== 474 * 0 perf: 100 perf [kernel] [k] schedule 475 * 2 perf: 200 perf [kernel] [k] page_fault 476 * 1 bash: 300 bash [kernel] [k] page_fault 477 * 0 bash: 300 bash bash [.] xmalloc 478 * 3 bash: 300 bash bash [.] main 479 * 1 perf: 100 perf libc [.] malloc 480 * 2 perf: 100 perf libc [.] free 481 * 1 perf: 100 perf perf [.] cmd_record 482 * 1 perf: 100 perf perf [.] main 483 * 2 perf: 200 perf perf [.] main 484 */ 485 err = add_hist_entries(hists, machine); 486 if (err < 0) 487 goto out; 488 489 hists__collapse_resort(hists, NULL); 490 hists__output_resort(hists); 491 492 if (verbose > 2) { 493 pr_info("[fields = %s, sort = %s]\n", field_order, sort_order); 494 print_hists_out(hists); 495 } 496 497 root = &hists->entries; 498 node = rb_first(root); 499 he = rb_entry(node, struct hist_entry, rb_node); 500 501 TEST_ASSERT_VAL("Invalid hist entry", 502 CPU(he) == 0 && PID(he) == 100 && 503 !strcmp(COMM(he), "perf") && !strcmp(DSO(he), "[kernel]") && 504 !strcmp(SYM(he), "schedule") && he->stat.period == 100); 505 506 node = rb_next(node); 507 he = rb_entry(node, struct hist_entry, rb_node); 508 TEST_ASSERT_VAL("Invalid hist entry", 509 CPU(he) == 2 && PID(he) == 200 && 510 !strcmp(COMM(he), "perf") && !strcmp(DSO(he), "[kernel]") && 511 !strcmp(SYM(he), "page_fault") && he->stat.period == 100); 512 513 node = rb_next(node); 514 he = rb_entry(node, struct hist_entry, rb_node); 515 TEST_ASSERT_VAL("Invalid hist entry", 516 CPU(he) == 1 && PID(he) == 300 && 517 !strcmp(COMM(he), "bash") && !strcmp(DSO(he), "[kernel]") && 518 !strcmp(SYM(he), "page_fault") && he->stat.period == 100); 519 520 node = rb_next(node); 521 he = rb_entry(node, struct hist_entry, rb_node); 522 TEST_ASSERT_VAL("Invalid hist entry", 523 CPU(he) == 0 && PID(he) == 300 && 524 !strcmp(COMM(he), "bash") && !strcmp(DSO(he), "bash") && 525 !strcmp(SYM(he), "xmalloc") && he->stat.period == 100); 526 527 node = rb_next(node); 528 he = rb_entry(node, struct hist_entry, rb_node); 529 TEST_ASSERT_VAL("Invalid hist entry", 530 CPU(he) == 3 && PID(he) == 300 && 531 !strcmp(COMM(he), "bash") && !strcmp(DSO(he), "bash") && 532 !strcmp(SYM(he), "main") && he->stat.period == 100); 533 534 node = rb_next(node); 535 he = rb_entry(node, struct hist_entry, rb_node); 536 TEST_ASSERT_VAL("Invalid hist entry", 537 CPU(he) == 1 && PID(he) == 100 && 538 !strcmp(COMM(he), "perf") && !strcmp(DSO(he), "libc") && 539 !strcmp(SYM(he), "malloc") && he->stat.period == 100); 540 541 node = rb_next(node); 542 he = rb_entry(node, struct hist_entry, rb_node); 543 TEST_ASSERT_VAL("Invalid hist entry", 544 CPU(he) == 2 && PID(he) == 100 && 545 !strcmp(COMM(he), "perf") && !strcmp(DSO(he), "libc") && 546 !strcmp(SYM(he), "free") && he->stat.period == 100); 547 548 node = rb_next(node); 549 he = rb_entry(node, struct hist_entry, rb_node); 550 TEST_ASSERT_VAL("Invalid hist entry", 551 CPU(he) == 1 && PID(he) == 100 && 552 !strcmp(COMM(he), "perf") && !strcmp(DSO(he), "perf") && 553 !strcmp(SYM(he), "cmd_record") && he->stat.period == 100); 554 555 node = rb_next(node); 556 he = rb_entry(node, struct hist_entry, rb_node); 557 TEST_ASSERT_VAL("Invalid hist entry", 558 CPU(he) == 1 && PID(he) == 100 && 559 !strcmp(COMM(he), "perf") && !strcmp(DSO(he), "perf") && 560 !strcmp(SYM(he), "main") && he->stat.period == 100); 561 562 node = rb_next(node); 563 he = rb_entry(node, struct hist_entry, rb_node); 564 TEST_ASSERT_VAL("Invalid hist entry", 565 CPU(he) == 2 && PID(he) == 200 && 566 !strcmp(COMM(he), "perf") && !strcmp(DSO(he), "perf") && 567 !strcmp(SYM(he), "main") && he->stat.period == 100); 568 569 out: 570 del_hist_entries(hists); 571 reset_output_field(); 572 return err; 573 } 574 575 int test__hists_output(void) 576 { 577 int err = TEST_FAIL; 578 struct machines machines; 579 struct machine *machine; 580 struct perf_evsel *evsel; 581 struct perf_evlist *evlist = perf_evlist__new(); 582 size_t i; 583 test_fn_t testcases[] = { 584 test1, 585 test2, 586 test3, 587 test4, 588 test5, 589 }; 590 591 TEST_ASSERT_VAL("No memory", evlist); 592 593 err = parse_events(evlist, "cpu-clock"); 594 if (err) 595 goto out; 596 597 machines__init(&machines); 598 599 /* setup threads/dso/map/symbols also */ 600 machine = setup_fake_machine(&machines); 601 if (!machine) 602 goto out; 603 604 if (verbose > 1) 605 machine__fprintf(machine, stderr); 606 607 evsel = perf_evlist__first(evlist); 608 609 for (i = 0; i < ARRAY_SIZE(testcases); i++) { 610 err = testcases[i](evsel, machine); 611 if (err < 0) 612 break; 613 } 614 615 out: 616 /* tear down everything */ 617 perf_evlist__delete(evlist); 618 machines__exit(&machines); 619 620 return err; 621 } 622