tools/lib/perf/tests/test-evlist.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 #define _GNU_SOURCE // needed for sched.h to get sched_[gs]etaffinity and CPU_(ZERO,SET)
   3 #include <inttypes.h>
   4 #include <sched.h>
   5 #include <stdio.h>
   6 #include <stdarg.h>
   7 #include <unistd.h>
   8 #include <stdlib.h>
   9 #include <linux/perf_event.h>
  10 #include <linux/limits.h>
  11 #include <sys/types.h>
  12 #include <sys/wait.h>
  13 #include <sys/prctl.h>
  14 #include <perf/cpumap.h>
  15 #include <perf/threadmap.h>
  16 #include <perf/evlist.h>
  17 #include <perf/evsel.h>
  18 #include <perf/mmap.h>
  19 #include <perf/event.h>
  20 #include <internal/tests.h>
  21 #include <api/fs/fs.h>
  22 #include "tests.h"
  23 #include <internal/evsel.h>
  24
  25 #define EVENT_NUM 15
  26 #define WAIT_COUNT 100000000UL
  27
  28 static int libperf_print(enum libperf_print_level level,
  29                          const char *fmt, va_list ap)
  30 {
  31         return vfprintf(stderr, fmt, ap);
  32 }
  33
  34 static int test_stat_cpu(void)
  35 {
  36         struct perf_cpu_map *cpus;
  37         struct perf_evlist *evlist;
  38         struct perf_evsel *evsel, *leader;
  39         struct perf_event_attr attr1 = {
  40                 .type   = PERF_TYPE_SOFTWARE,
  41                 .config = PERF_COUNT_SW_CPU_CLOCK,
  42         };
  43         struct perf_event_attr attr2 = {
  44                 .type   = PERF_TYPE_SOFTWARE,
  45                 .config = PERF_COUNT_SW_TASK_CLOCK,
  46         };
  47         int err, idx;
  48
  49         cpus = perf_cpu_map__new_online_cpus();
  50         __T("failed to create cpus", cpus);
  51
  52         evlist = perf_evlist__new();
  53         __T("failed to create evlist", evlist);
  54
  55         evsel = leader = perf_evsel__new(&attr1);
  56         __T("failed to create evsel1", evsel);
  57
  58         perf_evlist__add(evlist, evsel);
  59
  60         evsel = perf_evsel__new(&attr2);
  61         __T("failed to create evsel2", evsel);
  62
  63         perf_evlist__add(evlist, evsel);
  64
  65         perf_evlist__set_leader(evlist);
  66         __T("failed to set leader", leader->leader == leader);
  67         __T("failed to set leader", evsel->leader  == leader);
  68
  69         perf_evlist__set_maps(evlist, cpus, NULL);
  70
  71         err = perf_evlist__open(evlist);
  72         __T("failed to open evlist", err == 0);
  73
  74         perf_evlist__for_each_evsel(evlist, evsel) {
  75                 cpus = perf_evsel__cpus(evsel);
  76
  77                 for (idx = 0; idx < perf_cpu_map__nr(cpus); idx++) {
  78                         struct perf_counts_values counts = { .val = 0 };
  79
  80                         perf_evsel__read(evsel, idx, 0, &counts);
  81                         __T("failed to read value for evsel", counts.val != 0);
  82                 }
  83         }
  84
  85         perf_evlist__close(evlist);
  86         perf_evlist__delete(evlist);
  87
  88         perf_cpu_map__put(cpus);
  89         return 0;
  90 }
  91
  92 static int test_stat_thread(void)
  93 {
  94         struct perf_counts_values counts = { .val = 0 };
  95         struct perf_thread_map *threads;
  96         struct perf_evlist *evlist;
  97         struct perf_evsel *evsel, *leader;
  98         struct perf_event_attr attr1 = {
  99                 .type   = PERF_TYPE_SOFTWARE,
 100                 .config = PERF_COUNT_SW_CPU_CLOCK,
 101         };
 102         struct perf_event_attr attr2 = {
 103                 .type   = PERF_TYPE_SOFTWARE,
 104                 .config = PERF_COUNT_SW_TASK_CLOCK,
 105         };
 106         int err;
 107
 108         threads = perf_thread_map__new_dummy();
 109         __T("failed to create threads", threads);
 110
 111         perf_thread_map__set_pid(threads, 0, 0);
 112
 113         evlist = perf_evlist__new();
 114         __T("failed to create evlist", evlist);
 115
 116         evsel = leader = perf_evsel__new(&attr1);
 117         __T("failed to create evsel1", evsel);
 118
 119         perf_evlist__add(evlist, evsel);
 120
 121         evsel = perf_evsel__new(&attr2);
 122         __T("failed to create evsel2", evsel);
 123
 124         perf_evlist__add(evlist, evsel);
 125
 126         perf_evlist__set_leader(evlist);
 127         __T("failed to set leader", leader->leader == leader);
 128         __T("failed to set leader", evsel->leader  == leader);
 129
 130         perf_evlist__set_maps(evlist, NULL, threads);
 131
 132         err = perf_evlist__open(evlist);
 133         __T("failed to open evlist", err == 0);
 134
 135         perf_evlist__for_each_evsel(evlist, evsel) {
 136                 perf_evsel__read(evsel, 0, 0, &counts);
 137                 __T("failed to read value for evsel", counts.val != 0);
 138         }
 139
 140         perf_evlist__close(evlist);
 141         perf_evlist__delete(evlist);
 142
 143         perf_thread_map__put(threads);
 144         return 0;
 145 }
 146
 147 static int test_stat_thread_enable(void)
 148 {
 149         struct perf_counts_values counts = { .val = 0 };
 150         struct perf_thread_map *threads;
 151         struct perf_evlist *evlist;
 152         struct perf_evsel *evsel, *leader;
 153         struct perf_event_attr attr1 = {
 154                 .type     = PERF_TYPE_SOFTWARE,
 155                 .config   = PERF_COUNT_SW_CPU_CLOCK,
 156                 .disabled = 1,
 157         };
 158         struct perf_event_attr attr2 = {
 159                 .type     = PERF_TYPE_SOFTWARE,
 160                 .config   = PERF_COUNT_SW_TASK_CLOCK,
 161                 .disabled = 1,
 162         };
 163         int err;
 164
 165         threads = perf_thread_map__new_dummy();
 166         __T("failed to create threads", threads);
 167
 168         perf_thread_map__set_pid(threads, 0, 0);
 169
 170         evlist = perf_evlist__new();
 171         __T("failed to create evlist", evlist);
 172
 173         evsel = leader = perf_evsel__new(&attr1);
 174         __T("failed to create evsel1", evsel);
 175
 176         perf_evlist__add(evlist, evsel);
 177
 178         evsel = perf_evsel__new(&attr2);
 179         __T("failed to create evsel2", evsel);
 180
 181         perf_evlist__add(evlist, evsel);
 182
 183         perf_evlist__set_leader(evlist);
 184         __T("failed to set leader", leader->leader == leader);
 185         __T("failed to set leader", evsel->leader  == leader);
 186
 187         perf_evlist__set_maps(evlist, NULL, threads);
 188
 189         err = perf_evlist__open(evlist);
 190         __T("failed to open evlist", err == 0);
 191
 192         perf_evlist__for_each_evsel(evlist, evsel) {
 193                 perf_evsel__read(evsel, 0, 0, &counts);
 194                 __T("failed to read value for evsel", counts.val == 0);
 195         }
 196
 197         perf_evlist__enable(evlist);
 198
 199         perf_evlist__for_each_evsel(evlist, evsel) {
 200                 perf_evsel__read(evsel, 0, 0, &counts);
 201                 __T("failed to read value for evsel", counts.val != 0);
 202         }
 203
 204         perf_evlist__disable(evlist);
 205
 206         perf_evlist__close(evlist);
 207         perf_evlist__delete(evlist);
 208
 209         perf_thread_map__put(threads);
 210         return 0;
 211 }
 212
 213 static int test_mmap_thread(void)
 214 {
 215         struct perf_evlist *evlist;
 216         struct perf_evsel *evsel;
 217         struct perf_mmap *map;
 218         struct perf_cpu_map *cpus;
 219         struct perf_thread_map *threads;
 220         struct perf_event_attr attr = {
 221                 .type             = PERF_TYPE_TRACEPOINT,
 222                 .sample_period    = 1,
 223                 .wakeup_watermark = 1,
 224                 .disabled         = 1,
 225         };
 226         char path[PATH_MAX];
 227         int id, err, pid, go_pipe[2];
 228         union perf_event *event;
 229         int count = 0;
 230
 231         snprintf(path, PATH_MAX, "%s/kernel/debug/tracing/events/syscalls/sys_enter_prctl/id",
 232                  sysfs__mountpoint());
 233
 234         if (filename__read_int(path, &id)) {
 235                 tests_failed++;
 236                 fprintf(stderr, "error: failed to get tracepoint id: %s\n", path);
 237                 return -1;
 238         }
 239
 240         attr.config = id;
 241
 242         err = pipe(go_pipe);
 243         __T("failed to create pipe", err == 0);
 244
 245         fflush(NULL);
 246
 247         pid = fork();
 248         if (!pid) {
 249                 int i;
 250                 char bf;
 251
 252                 read(go_pipe[0], &bf, 1);
 253
 254                 /* Generate 100 prctl calls. */
 255                 for (i = 0; i < 100; i++)
 256                         prctl(0, 0, 0, 0, 0);
 257
 258                 exit(0);
 259         }
 260
 261         threads = perf_thread_map__new_dummy();
 262         __T("failed to create threads", threads);
 263
 264         cpus = perf_cpu_map__new_any_cpu();
 265         __T("failed to create cpus", cpus);
 266
 267         perf_thread_map__set_pid(threads, 0, pid);
 268
 269         evlist = perf_evlist__new();
 270         __T("failed to create evlist", evlist);
 271
 272         evsel = perf_evsel__new(&attr);
 273         __T("failed to create evsel1", evsel);
 274         __T("failed to set leader", evsel->leader == evsel);
 275
 276         perf_evlist__add(evlist, evsel);
 277
 278         perf_evlist__set_maps(evlist, cpus, threads);
 279
 280         err = perf_evlist__open(evlist);
 281         __T("failed to open evlist", err == 0);
 282
 283         err = perf_evlist__mmap(evlist, 4);
 284         __T("failed to mmap evlist", err == 0);
 285
 286         perf_evlist__enable(evlist);
 287
 288         /* kick the child and wait for it to finish */
 289         write(go_pipe[1], "A", 1);
 290         waitpid(pid, NULL, 0);
 291
 292         /*
 293          * There's no need to call perf_evlist__disable,
 294          * monitored process is dead now.
 295          */
 296
 297         perf_evlist__for_each_mmap(evlist, map, false) {
 298                 if (perf_mmap__read_init(map) < 0)
 299                         continue;
 300
 301                 while ((event = perf_mmap__read_event(map)) != NULL) {
 302                         count++;
 303                         perf_mmap__consume(map);
 304                 }
 305
 306                 perf_mmap__read_done(map);
 307         }
 308
 309         /* calls perf_evlist__munmap/perf_evlist__close */
 310         perf_evlist__delete(evlist);
 311
 312         perf_thread_map__put(threads);
 313         perf_cpu_map__put(cpus);
 314
 315         /*
 316          * The generated prctl calls should match the
 317          * number of events in the buffer.
 318          */
 319         __T("failed count", count == 100);
 320
 321         return 0;
 322 }
 323
 324 static int test_mmap_cpus(void)
 325 {
 326         struct perf_evlist *evlist;
 327         struct perf_evsel *evsel;
 328         struct perf_mmap *map;
 329         struct perf_cpu_map *cpus;
 330         struct perf_event_attr attr = {
 331                 .type             = PERF_TYPE_TRACEPOINT,
 332                 .sample_period    = 1,
 333                 .wakeup_watermark = 1,
 334                 .disabled         = 1,
 335         };
 336         cpu_set_t saved_mask;
 337         char path[PATH_MAX];
 338         int id, err, tmp;
 339         struct perf_cpu cpu;
 340         union perf_event *event;
 341         int count = 0;
 342
 343         snprintf(path, PATH_MAX, "%s/kernel/debug/tracing/events/syscalls/sys_enter_prctl/id",
 344                  sysfs__mountpoint());
 345
 346         if (filename__read_int(path, &id)) {
 347                 fprintf(stderr, "error: failed to get tracepoint id: %s\n", path);
 348                 return -1;
 349         }
 350
 351         attr.config = id;
 352
 353         cpus = perf_cpu_map__new_online_cpus();
 354         __T("failed to create cpus", cpus);
 355
 356         evlist = perf_evlist__new();
 357         __T("failed to create evlist", evlist);
 358
 359         evsel = perf_evsel__new(&attr);
 360         __T("failed to create evsel1", evsel);
 361         __T("failed to set leader", evsel->leader == evsel);
 362
 363         perf_evlist__add(evlist, evsel);
 364
 365         perf_evlist__set_maps(evlist, cpus, NULL);
 366
 367         err = perf_evlist__open(evlist);
 368         __T("failed to open evlist", err == 0);
 369
 370         err = perf_evlist__mmap(evlist, 4);
 371         __T("failed to mmap evlist", err == 0);
 372
 373         perf_evlist__enable(evlist);
 374
 375         err = sched_getaffinity(0, sizeof(saved_mask), &saved_mask);
 376         __T("sched_getaffinity failed", err == 0);
 377
 378         perf_cpu_map__for_each_cpu(cpu, tmp, cpus) {
 379                 cpu_set_t mask;
 380
 381                 CPU_ZERO(&mask);
 382                 CPU_SET(cpu.cpu, &mask);
 383
 384                 err = sched_setaffinity(0, sizeof(mask), &mask);
 385                 __T("sched_setaffinity failed", err == 0);
 386
 387                 prctl(0, 0, 0, 0, 0);
 388         }
 389
 390         err = sched_setaffinity(0, sizeof(saved_mask), &saved_mask);
 391         __T("sched_setaffinity failed", err == 0);
 392
 393         perf_evlist__disable(evlist);
 394
 395         perf_evlist__for_each_mmap(evlist, map, false) {
 396                 if (perf_mmap__read_init(map) < 0)
 397                         continue;
 398
 399                 while ((event = perf_mmap__read_event(map)) != NULL) {
 400                         count++;
 401                         perf_mmap__consume(map);
 402                 }
 403
 404                 perf_mmap__read_done(map);
 405         }
 406
 407         /* calls perf_evlist__munmap/perf_evlist__close */
 408         perf_evlist__delete(evlist);
 409
 410         /*
 411          * The generated prctl events should match the
 412          * number of cpus or be bigger (we are system-wide).
 413          */
 414         __T("failed count", count >= perf_cpu_map__nr(cpus));
 415
 416         perf_cpu_map__put(cpus);
 417
 418         return 0;
 419 }
 420
 421 static double display_error(long long average,
 422                             long long high,
 423                             long long low,
 424                             long long expected)
 425 {
 426         double error;
 427
 428         error = (((double)average - expected) / expected) * 100.0;
 429
 430         __T_VERBOSE("   Expected: %lld\n", expected);
 431         __T_VERBOSE("   High: %lld   Low:  %lld   Average:  %lld\n",
 432                     high, low, average);
 433
 434         __T_VERBOSE("   Average Error = %.2f%%\n", error);
 435
 436         return error;
 437 }
 438
 439 static int test_stat_multiplexing(void)
 440 {
 441         struct perf_counts_values expected_counts = { .val = 0 };
 442         struct perf_counts_values counts[EVENT_NUM] = {{ .val = 0 },};
 443         struct perf_thread_map *threads;
 444         struct perf_evlist *evlist;
 445         struct perf_evsel *evsel;
 446         struct perf_event_attr attr = {
 447                 .type        = PERF_TYPE_HARDWARE,
 448                 .config      = PERF_COUNT_HW_INSTRUCTIONS,
 449                 .read_format = PERF_FORMAT_TOTAL_TIME_ENABLED |
 450                                PERF_FORMAT_TOTAL_TIME_RUNNING,
 451                 .disabled    = 1,
 452         };
 453         int err, i, nonzero = 0;
 454         unsigned long count;
 455         long long max = 0, min = 0, avg = 0;
 456         double error = 0.0;
 457         s8 scaled = 0;
 458
 459         /* read for non-multiplexing event count */
 460         threads = perf_thread_map__new_dummy();
 461         __T("failed to create threads", threads);
 462
 463         perf_thread_map__set_pid(threads, 0, 0);
 464
 465         evsel = perf_evsel__new(&attr);
 466         __T("failed to create evsel", evsel);
 467
 468         err = perf_evsel__open(evsel, NULL, threads);
 469         __T("failed to open evsel", err == 0);
 470
 471         err = perf_evsel__enable(evsel);
 472         __T("failed to enable evsel", err == 0);
 473
 474         /* wait loop */
 475         count = WAIT_COUNT;
 476         while (count--)
 477                 ;
 478
 479         perf_evsel__read(evsel, 0, 0, &expected_counts);
 480         __T("failed to read value for evsel", expected_counts.val != 0);
 481         __T("failed to read non-multiplexing event count",
 482             expected_counts.ena == expected_counts.run);
 483
 484         err = perf_evsel__disable(evsel);
 485         __T("failed to enable evsel", err == 0);
 486
 487         perf_evsel__close(evsel);
 488         perf_evsel__delete(evsel);
 489
 490         perf_thread_map__put(threads);
 491
 492         /* read for multiplexing event count */
 493         threads = perf_thread_map__new_dummy();
 494         __T("failed to create threads", threads);
 495
 496         perf_thread_map__set_pid(threads, 0, 0);
 497
 498         evlist = perf_evlist__new();
 499         __T("failed to create evlist", evlist);
 500
 501         for (i = 0; i < EVENT_NUM; i++) {
 502                 evsel = perf_evsel__new(&attr);
 503                 __T("failed to create evsel", evsel);
 504
 505                 perf_evlist__add(evlist, evsel);
 506         }
 507         perf_evlist__set_maps(evlist, NULL, threads);
 508
 509         err = perf_evlist__open(evlist);
 510         __T("failed to open evlist", err == 0);
 511
 512         perf_evlist__enable(evlist);
 513
 514         /* wait loop */
 515         count = WAIT_COUNT;
 516         while (count--)
 517                 ;
 518
 519         i = 0;
 520         perf_evlist__for_each_evsel(evlist, evsel) {
 521                 perf_evsel__read(evsel, 0, 0, &counts[i]);
 522                 __T("failed to read value for evsel", counts[i].val != 0);
 523                 i++;
 524         }
 525
 526         perf_evlist__disable(evlist);
 527
 528         min = counts[0].val;
 529         for (i = 0; i < EVENT_NUM; i++) {
 530                 __T_VERBOSE("Event %2d -- Raw count = %" PRIu64 ", run = %" PRIu64 ", enable = %" PRIu64 "\n",
 531                             i, counts[i].val, counts[i].run, counts[i].ena);
 532
 533                 perf_counts_values__scale(&counts[i], true, &scaled);
 534                 if (scaled == 1) {
 535                         __T_VERBOSE("\t Scaled count = %" PRIu64 " (%.2lf%%, %" PRIu64 "/%" PRIu64 ")\n",
 536                                     counts[i].val,
 537                                     (double)counts[i].run / (double)counts[i].ena * 100.0,
 538                                     counts[i].run, counts[i].ena);
 539                 } else if (scaled == -1) {
 540                         __T_VERBOSE("\t Not Running\n");
 541                 } else {
 542                         __T_VERBOSE("\t Not Scaling\n");
 543                 }
 544
 545                 if (counts[i].val > max)
 546                         max = counts[i].val;
 547
 548                 if (counts[i].val < min)
 549                         min = counts[i].val;
 550
 551                 avg += counts[i].val;
 552
 553                 if (counts[i].val != 0)
 554                         nonzero++;
 555         }
 556
 557         if (nonzero != 0)
 558                 avg = avg / nonzero;
 559         else
 560                 avg = 0;
 561
 562         error = display_error(avg, max, min, expected_counts.val);
 563
 564         __T("Error out of range!", ((error <= 1.0) && (error >= -1.0)));
 565
 566         perf_evlist__close(evlist);
 567         perf_evlist__delete(evlist);
 568
 569         perf_thread_map__put(threads);
 570
 571         return 0;
 572 }
 573
 574 int test_evlist(int argc, char **argv)
 575 {
 576         __T_START;
 577
 578         libperf_init(libperf_print);
 579
 580         test_stat_cpu();
 581         test_stat_thread();
 582         test_stat_thread_enable();
 583         test_mmap_thread();
 584         test_mmap_cpus();
 585         test_stat_multiplexing();
 586
 587         __T_END;
 588         return tests_failed == 0 ? 0 : -1;
 589 }