tools/perf/tests/pmu-events.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 #include "math.h"
   3 #include "parse-events.h"
   4 #include "pmu.h"
   5 #include "pmus.h"
   6 #include "tests.h"
   7 #include <errno.h>
   8 #include <stdio.h>
   9 #include <linux/kernel.h>
  10 #include <linux/zalloc.h>
  11 #include "debug.h"
  12 #include "../pmu-events/pmu-events.h"
  13 #include <perf/evlist.h>
  14 #include "util/evlist.h"
  15 #include "util/expr.h"
  16 #include "util/hashmap.h"
  17 #include "util/parse-events.h"
  18 #include "metricgroup.h"
  19 #include "stat.h"
  20
  21 struct perf_pmu_test_event {
  22         /* used for matching against events from generated pmu-events.c */
  23         struct pmu_event event;
  24
  25         /* used for matching against event aliases */
  26         /* extra events for aliases */
  27         const char *alias_str;
  28
  29         /*
  30          * Note: For when PublicDescription does not exist in the JSON, we
  31          * will have no long_desc in pmu_event.long_desc, but long_desc may
  32          * be set in the alias.
  33          */
  34         const char *alias_long_desc;
  35
  36         /* PMU which we should match against */
  37         const char *matching_pmu;
  38 };
  39
  40 struct perf_pmu_test_pmu {
  41         struct perf_pmu pmu;
  42         struct perf_pmu_test_event const *aliases[10];
  43 };
  44
  45 static const struct perf_pmu_test_event bp_l1_btb_correct = {
  46         .event = {
  47                 .pmu = "default_core",
  48                 .name = "bp_l1_btb_correct",
  49                 .event = "event=0x8a",
  50                 .desc = "L1 BTB Correction",
  51                 .topic = "branch",
  52         },
  53         .alias_str = "event=0x8a",
  54         .alias_long_desc = "L1 BTB Correction",
  55 };
  56
  57 static const struct perf_pmu_test_event bp_l2_btb_correct = {
  58         .event = {
  59                 .pmu = "default_core",
  60                 .name = "bp_l2_btb_correct",
  61                 .event = "event=0x8b",
  62                 .desc = "L2 BTB Correction",
  63                 .topic = "branch",
  64         },
  65         .alias_str = "event=0x8b",
  66         .alias_long_desc = "L2 BTB Correction",
  67 };
  68
  69 static const struct perf_pmu_test_event segment_reg_loads_any = {
  70         .event = {
  71                 .pmu = "default_core",
  72                 .name = "segment_reg_loads.any",
  73                 .event = "event=6,period=200000,umask=0x80",
  74                 .desc = "Number of segment register loads",
  75                 .topic = "other",
  76         },
  77         .alias_str = "event=0x6,period=0x30d40,umask=0x80",
  78         .alias_long_desc = "Number of segment register loads",
  79 };
  80
  81 static const struct perf_pmu_test_event dispatch_blocked_any = {
  82         .event = {
  83                 .pmu = "default_core",
  84                 .name = "dispatch_blocked.any",
  85                 .event = "event=9,period=200000,umask=0x20",
  86                 .desc = "Memory cluster signals to block micro-op dispatch for any reason",
  87                 .topic = "other",
  88         },
  89         .alias_str = "event=0x9,period=0x30d40,umask=0x20",
  90         .alias_long_desc = "Memory cluster signals to block micro-op dispatch for any reason",
  91 };
  92
  93 static const struct perf_pmu_test_event eist_trans = {
  94         .event = {
  95                 .pmu = "default_core",
  96                 .name = "eist_trans",
  97                 .event = "event=0x3a,period=200000",
  98                 .desc = "Number of Enhanced Intel SpeedStep(R) Technology (EIST) transitions",
  99                 .topic = "other",
 100         },
 101         .alias_str = "event=0x3a,period=0x30d40",
 102         .alias_long_desc = "Number of Enhanced Intel SpeedStep(R) Technology (EIST) transitions",
 103 };
 104
 105 static const struct perf_pmu_test_event l3_cache_rd = {
 106         .event = {
 107                 .pmu = "default_core",
 108                 .name = "l3_cache_rd",
 109                 .event = "event=0x40",
 110                 .desc = "L3 cache access, read",
 111                 .long_desc = "Attributable Level 3 cache access, read",
 112                 .topic = "cache",
 113         },
 114         .alias_str = "event=0x40",
 115         .alias_long_desc = "Attributable Level 3 cache access, read",
 116 };
 117
 118 static const struct perf_pmu_test_event *core_events[] = {
 119         &bp_l1_btb_correct,
 120         &bp_l2_btb_correct,
 121         &segment_reg_loads_any,
 122         &dispatch_blocked_any,
 123         &eist_trans,
 124         &l3_cache_rd,
 125         NULL
 126 };
 127
 128 static const struct perf_pmu_test_event uncore_hisi_ddrc_flux_wcmd = {
 129         .event = {
 130                 .name = "uncore_hisi_ddrc.flux_wcmd",
 131                 .event = "event=2",
 132                 .desc = "DDRC write commands",
 133                 .topic = "uncore",
 134                 .long_desc = "DDRC write commands",
 135                 .pmu = "hisi_sccl,ddrc",
 136         },
 137         .alias_str = "event=0x2",
 138         .alias_long_desc = "DDRC write commands",
 139         .matching_pmu = "hisi_sccl1_ddrc2",
 140 };
 141
 142 static const struct perf_pmu_test_event unc_cbo_xsnp_response_miss_eviction = {
 143         .event = {
 144                 .name = "unc_cbo_xsnp_response.miss_eviction",
 145                 .event = "event=0x22,umask=0x81",
 146                 .desc = "A cross-core snoop resulted from L3 Eviction which misses in some processor core",
 147                 .topic = "uncore",
 148                 .long_desc = "A cross-core snoop resulted from L3 Eviction which misses in some processor core",
 149                 .pmu = "uncore_cbox",
 150         },
 151         .alias_str = "event=0x22,umask=0x81",
 152         .alias_long_desc = "A cross-core snoop resulted from L3 Eviction which misses in some processor core",
 153         .matching_pmu = "uncore_cbox_0",
 154 };
 155
 156 static const struct perf_pmu_test_event uncore_hyphen = {
 157         .event = {
 158                 .name = "event-hyphen",
 159                 .event = "event=0xe0",
 160                 .desc = "UNC_CBO_HYPHEN",
 161                 .topic = "uncore",
 162                 .long_desc = "UNC_CBO_HYPHEN",
 163                 .pmu = "uncore_cbox",
 164         },
 165         .alias_str = "event=0xe0",
 166         .alias_long_desc = "UNC_CBO_HYPHEN",
 167         .matching_pmu = "uncore_cbox_0",
 168 };
 169
 170 static const struct perf_pmu_test_event uncore_two_hyph = {
 171         .event = {
 172                 .name = "event-two-hyph",
 173                 .event = "event=0xc0",
 174                 .desc = "UNC_CBO_TWO_HYPH",
 175                 .topic = "uncore",
 176                 .long_desc = "UNC_CBO_TWO_HYPH",
 177                 .pmu = "uncore_cbox",
 178         },
 179         .alias_str = "event=0xc0",
 180         .alias_long_desc = "UNC_CBO_TWO_HYPH",
 181         .matching_pmu = "uncore_cbox_0",
 182 };
 183
 184 static const struct perf_pmu_test_event uncore_hisi_l3c_rd_hit_cpipe = {
 185         .event = {
 186                 .name = "uncore_hisi_l3c.rd_hit_cpipe",
 187                 .event = "event=7",
 188                 .desc = "Total read hits",
 189                 .topic = "uncore",
 190                 .long_desc = "Total read hits",
 191                 .pmu = "hisi_sccl,l3c",
 192         },
 193         .alias_str = "event=0x7",
 194         .alias_long_desc = "Total read hits",
 195         .matching_pmu = "hisi_sccl3_l3c7",
 196 };
 197
 198 static const struct perf_pmu_test_event uncore_imc_free_running_cache_miss = {
 199         .event = {
 200                 .name = "uncore_imc_free_running.cache_miss",
 201                 .event = "event=0x12",
 202                 .desc = "Total cache misses",
 203                 .topic = "uncore",
 204                 .long_desc = "Total cache misses",
 205                 .pmu = "uncore_imc_free_running",
 206         },
 207         .alias_str = "event=0x12",
 208         .alias_long_desc = "Total cache misses",
 209         .matching_pmu = "uncore_imc_free_running_0",
 210 };
 211
 212 static const struct perf_pmu_test_event uncore_imc_cache_hits = {
 213         .event = {
 214                 .name = "uncore_imc.cache_hits",
 215                 .event = "event=0x34",
 216                 .desc = "Total cache hits",
 217                 .topic = "uncore",
 218                 .long_desc = "Total cache hits",
 219                 .pmu = "uncore_imc",
 220         },
 221         .alias_str = "event=0x34",
 222         .alias_long_desc = "Total cache hits",
 223         .matching_pmu = "uncore_imc_0",
 224 };
 225
 226 static const struct perf_pmu_test_event *uncore_events[] = {
 227         &uncore_hisi_ddrc_flux_wcmd,
 228         &unc_cbo_xsnp_response_miss_eviction,
 229         &uncore_hyphen,
 230         &uncore_two_hyph,
 231         &uncore_hisi_l3c_rd_hit_cpipe,
 232         &uncore_imc_free_running_cache_miss,
 233         &uncore_imc_cache_hits,
 234         NULL
 235 };
 236
 237 static const struct perf_pmu_test_event sys_ddr_pmu_write_cycles = {
 238         .event = {
 239                 .name = "sys_ddr_pmu.write_cycles",
 240                 .event = "event=0x2b",
 241                 .desc = "ddr write-cycles event",
 242                 .topic = "uncore",
 243                 .pmu = "uncore_sys_ddr_pmu",
 244                 .compat = "v8",
 245         },
 246         .alias_str = "event=0x2b",
 247         .alias_long_desc = "ddr write-cycles event",
 248         .matching_pmu = "uncore_sys_ddr_pmu0",
 249 };
 250
 251 static const struct perf_pmu_test_event sys_ccn_pmu_read_cycles = {
 252         .event = {
 253                 .name = "sys_ccn_pmu.read_cycles",
 254                 .event = "config=0x2c",
 255                 .desc = "ccn read-cycles event",
 256                 .topic = "uncore",
 257                 .pmu = "uncore_sys_ccn_pmu",
 258                 .compat = "0x01",
 259         },
 260         .alias_str = "config=0x2c",
 261         .alias_long_desc = "ccn read-cycles event",
 262         .matching_pmu = "uncore_sys_ccn_pmu4",
 263 };
 264
 265 static const struct perf_pmu_test_event sys_cmn_pmu_hnf_cache_miss = {
 266         .event = {
 267                 .name = "sys_cmn_pmu.hnf_cache_miss",
 268                 .event = "eventid=1,type=5",
 269                 .desc = "Counts total cache misses in first lookup result (high priority)",
 270                 .topic = "uncore",
 271                 .pmu = "uncore_sys_cmn_pmu",
 272                 .compat = "(434|436|43c|43a).*",
 273         },
 274         .alias_str = "eventid=0x1,type=0x5",
 275         .alias_long_desc = "Counts total cache misses in first lookup result (high priority)",
 276         .matching_pmu = "uncore_sys_cmn_pmu0",
 277 };
 278
 279 static const struct perf_pmu_test_event *sys_events[] = {
 280         &sys_ddr_pmu_write_cycles,
 281         &sys_ccn_pmu_read_cycles,
 282         &sys_cmn_pmu_hnf_cache_miss,
 283         NULL
 284 };
 285
 286 static bool is_same(const char *reference, const char *test)
 287 {
 288         if (!reference && !test)
 289                 return true;
 290
 291         if (reference && !test)
 292                 return false;
 293
 294         if (!reference && test)
 295                 return false;
 296
 297         return !strcmp(reference, test);
 298 }
 299
 300 static int compare_pmu_events(const struct pmu_event *e1, const struct pmu_event *e2)
 301 {
 302         if (!is_same(e1->name, e2->name)) {
 303                 pr_debug2("testing event e1 %s: mismatched name string, %s vs %s\n",
 304                           e1->name, e1->name, e2->name);
 305                 return -1;
 306         }
 307
 308         if (!is_same(e1->compat, e2->compat)) {
 309                 pr_debug2("testing event e1 %s: mismatched compat string, %s vs %s\n",
 310                           e1->name, e1->compat, e2->compat);
 311                 return -1;
 312         }
 313
 314         if (!is_same(e1->event, e2->event)) {
 315                 pr_debug2("testing event e1 %s: mismatched event, %s vs %s\n",
 316                           e1->name, e1->event, e2->event);
 317                 return -1;
 318         }
 319
 320         if (!is_same(e1->desc, e2->desc)) {
 321                 pr_debug2("testing event e1 %s: mismatched desc, %s vs %s\n",
 322                           e1->name, e1->desc, e2->desc);
 323                 return -1;
 324         }
 325
 326         if (!is_same(e1->topic, e2->topic)) {
 327                 pr_debug2("testing event e1 %s: mismatched topic, %s vs %s\n",
 328                           e1->name, e1->topic, e2->topic);
 329                 return -1;
 330         }
 331
 332         if (!is_same(e1->long_desc, e2->long_desc)) {
 333                 pr_debug2("testing event e1 %s: mismatched long_desc, %s vs %s\n",
 334                           e1->name, e1->long_desc, e2->long_desc);
 335                 return -1;
 336         }
 337
 338         if (!is_same(e1->pmu, e2->pmu)) {
 339                 pr_debug2("testing event e1 %s: mismatched pmu string, %s vs %s\n",
 340                           e1->name, e1->pmu, e2->pmu);
 341                 return -1;
 342         }
 343
 344         if (!is_same(e1->unit, e2->unit)) {
 345                 pr_debug2("testing event e1 %s: mismatched unit, %s vs %s\n",
 346                           e1->name, e1->unit, e2->unit);
 347                 return -1;
 348         }
 349
 350         if (e1->perpkg != e2->perpkg) {
 351                 pr_debug2("testing event e1 %s: mismatched perpkg, %d vs %d\n",
 352                           e1->name, e1->perpkg, e2->perpkg);
 353                 return -1;
 354         }
 355
 356         if (e1->deprecated != e2->deprecated) {
 357                 pr_debug2("testing event e1 %s: mismatched deprecated, %d vs %d\n",
 358                           e1->name, e1->deprecated, e2->deprecated);
 359                 return -1;
 360         }
 361
 362         return 0;
 363 }
 364
 365 static int compare_alias_to_test_event(struct pmu_event_info *alias,
 366                                 struct perf_pmu_test_event const *test_event,
 367                                 char const *pmu_name)
 368 {
 369         struct pmu_event const *event = &test_event->event;
 370
 371         /* An alias was found, ensure everything is in order */
 372         if (!is_same(alias->name, event->name)) {
 373                 pr_debug("testing aliases PMU %s: mismatched name, %s vs %s\n",
 374                           pmu_name, alias->name, event->name);
 375                 return -1;
 376         }
 377
 378         if (!is_same(alias->desc, event->desc)) {
 379                 pr_debug("testing aliases PMU %s: mismatched desc, %s vs %s\n",
 380                           pmu_name, alias->desc, event->desc);
 381                 return -1;
 382         }
 383
 384         if (!is_same(alias->long_desc, test_event->alias_long_desc)) {
 385                 pr_debug("testing aliases PMU %s: mismatched long_desc, %s vs %s\n",
 386                           pmu_name, alias->long_desc,
 387                           test_event->alias_long_desc);
 388                 return -1;
 389         }
 390
 391         if (!is_same(alias->topic, event->topic)) {
 392                 pr_debug("testing aliases PMU %s: mismatched topic, %s vs %s\n",
 393                           pmu_name, alias->topic, event->topic);
 394                 return -1;
 395         }
 396
 397         if (!is_same(alias->str, test_event->alias_str)) {
 398                 pr_debug("testing aliases PMU %s: mismatched str, %s vs %s\n",
 399                           pmu_name, alias->str, test_event->alias_str);
 400                 return -1;
 401         }
 402
 403         if (!is_same(alias->long_desc, test_event->alias_long_desc)) {
 404                 pr_debug("testing aliases PMU %s: mismatched long desc, %s vs %s\n",
 405                           pmu_name, alias->str, test_event->alias_long_desc);
 406                 return -1;
 407         }
 408
 409         if (!is_same(alias->pmu_name, test_event->event.pmu) &&
 410             !is_same(alias->pmu_name, "default_core")) {
 411                 pr_debug("testing aliases PMU %s: mismatched pmu_name, %s vs %s\n",
 412                           pmu_name, alias->pmu_name, test_event->event.pmu);
 413                 return -1;
 414         }
 415
 416         return 0;
 417 }
 418
 419 static int test__pmu_event_table_core_callback(const struct pmu_event *pe,
 420                                                const struct pmu_events_table *table __maybe_unused,
 421                                                void *data)
 422 {
 423         int *map_events = data;
 424         struct perf_pmu_test_event const **test_event_table;
 425         bool found = false;
 426
 427         if (strcmp(pe->pmu, "default_core"))
 428                 test_event_table = &uncore_events[0];
 429         else
 430                 test_event_table = &core_events[0];
 431
 432         for (; *test_event_table; test_event_table++) {
 433                 struct perf_pmu_test_event const *test_event = *test_event_table;
 434                 struct pmu_event const *event = &test_event->event;
 435
 436                 if (strcmp(pe->name, event->name))
 437                         continue;
 438                 found = true;
 439                 (*map_events)++;
 440
 441                 if (compare_pmu_events(pe, event))
 442                         return -1;
 443
 444                 pr_debug("testing event table %s: pass\n", pe->name);
 445         }
 446         if (!found) {
 447                 pr_err("testing event table: could not find event %s\n", pe->name);
 448                 return -1;
 449         }
 450         return 0;
 451 }
 452
 453 static int test__pmu_event_table_sys_callback(const struct pmu_event *pe,
 454                                               const struct pmu_events_table *table __maybe_unused,
 455                                               void *data)
 456 {
 457         int *map_events = data;
 458         struct perf_pmu_test_event const **test_event_table;
 459         bool found = false;
 460
 461         test_event_table = &sys_events[0];
 462
 463         for (; *test_event_table; test_event_table++) {
 464                 struct perf_pmu_test_event const *test_event = *test_event_table;
 465                 struct pmu_event const *event = &test_event->event;
 466
 467                 if (strcmp(pe->name, event->name))
 468                         continue;
 469                 found = true;
 470                 (*map_events)++;
 471
 472                 if (compare_pmu_events(pe, event))
 473                         return TEST_FAIL;
 474
 475                 pr_debug("testing sys event table %s: pass\n", pe->name);
 476         }
 477         if (!found) {
 478                 pr_debug("testing sys event table: could not find event %s\n", pe->name);
 479                 return TEST_FAIL;
 480         }
 481         return TEST_OK;
 482 }
 483
 484 /* Verify generated events from pmu-events.c are as expected */
 485 static int test__pmu_event_table(struct test_suite *test __maybe_unused,
 486                                  int subtest __maybe_unused)
 487 {
 488         const struct pmu_events_table *sys_event_table =
 489                 find_sys_events_table("pmu_events__test_soc_sys");
 490         const struct pmu_events_table *table = find_core_events_table("testarch", "testcpu");
 491         int map_events = 0, expected_events, err;
 492
 493         /* ignore 3x sentinels */
 494         expected_events = ARRAY_SIZE(core_events) +
 495                           ARRAY_SIZE(uncore_events) +
 496                           ARRAY_SIZE(sys_events) - 3;
 497
 498         if (!table || !sys_event_table)
 499                 return -1;
 500
 501         err = pmu_events_table__for_each_event(table, /*pmu=*/ NULL,
 502                                               test__pmu_event_table_core_callback,
 503                                               &map_events);
 504         if (err)
 505                 return err;
 506
 507         err = pmu_events_table__for_each_event(sys_event_table, /*pmu=*/ NULL,
 508                                               test__pmu_event_table_sys_callback,
 509                                               &map_events);
 510         if (err)
 511                 return err;
 512
 513         if (map_events != expected_events) {
 514                 pr_err("testing event table: found %d, but expected %d\n",
 515                        map_events, expected_events);
 516                 return TEST_FAIL;
 517         }
 518
 519         return 0;
 520 }
 521
 522 struct test_core_pmu_event_aliases_cb_args {
 523         struct perf_pmu_test_event const *test_event;
 524         int *count;
 525 };
 526
 527 static int test_core_pmu_event_aliases_cb(void *state, struct pmu_event_info *alias)
 528 {
 529         struct test_core_pmu_event_aliases_cb_args *args = state;
 530
 531         if (compare_alias_to_test_event(alias, args->test_event, alias->pmu->name))
 532                 return -1;
 533         (*args->count)++;
 534         pr_debug2("testing aliases core PMU %s: matched event %s\n",
 535                 alias->pmu_name, alias->name);
 536         return 0;
 537 }
 538
 539 /* Verify aliases are as expected */
 540 static int __test_core_pmu_event_aliases(const char *pmu_name, int *count)
 541 {
 542         struct perf_pmu_test_event const **test_event_table;
 543         struct perf_pmu *pmu;
 544         int res = 0;
 545         const struct pmu_events_table *table = find_core_events_table("testarch", "testcpu");
 546
 547         if (!table)
 548                 return -1;
 549
 550         test_event_table = &core_events[0];
 551
 552         pmu = zalloc(sizeof(*pmu));
 553         if (!pmu)
 554                 return -1;
 555
 556         INIT_LIST_HEAD(&pmu->format);
 557         INIT_LIST_HEAD(&pmu->aliases);
 558         INIT_LIST_HEAD(&pmu->caps);
 559         INIT_LIST_HEAD(&pmu->list);
 560         pmu->name = strdup(pmu_name);
 561         pmu->is_core = true;
 562
 563         pmu->events_table = table;
 564         pmu_add_cpu_aliases_table(pmu, table);
 565         pmu->cpu_aliases_added = true;
 566         pmu->sysfs_aliases_loaded = true;
 567
 568         res = pmu_events_table__find_event(table, pmu, "bp_l1_btb_correct", NULL, NULL);
 569         if (res != 0) {
 570                 pr_debug("Missing test event in test architecture");
 571                 return res;
 572         }
 573         for (; *test_event_table; test_event_table++) {
 574                 struct perf_pmu_test_event test_event = **test_event_table;
 575                 struct pmu_event const *event = &test_event.event;
 576                 struct test_core_pmu_event_aliases_cb_args args = {
 577                         .test_event = &test_event,
 578                         .count = count,
 579                 };
 580                 int err;
 581
 582                 test_event.event.pmu = pmu_name;
 583                 err = perf_pmu__find_event(pmu, event->name, &args,
 584                                            test_core_pmu_event_aliases_cb);
 585                 if (err)
 586                         res = err;
 587         }
 588         perf_pmu__delete(pmu);
 589
 590         return res;
 591 }
 592
 593 static int __test_uncore_pmu_event_aliases(struct perf_pmu_test_pmu *test_pmu)
 594 {
 595         int alias_count = 0, to_match_count = 0, matched_count = 0;
 596         struct perf_pmu_test_event const **table;
 597         struct perf_pmu *pmu = &test_pmu->pmu;
 598         const char *pmu_name = pmu->name;
 599         const struct pmu_events_table *events_table;
 600         int res = 0;
 601
 602         events_table = find_core_events_table("testarch", "testcpu");
 603         if (!events_table)
 604                 return -1;
 605         pmu->events_table = events_table;
 606         pmu_add_cpu_aliases_table(pmu, events_table);
 607         pmu->cpu_aliases_added = true;
 608         pmu->sysfs_aliases_loaded = true;
 609         pmu_add_sys_aliases(pmu);
 610
 611         /* Count how many aliases we generated */
 612         alias_count = perf_pmu__num_events(pmu);
 613
 614         /* Count how many aliases we expect from the known table */
 615         for (table = &test_pmu->aliases[0]; *table; table++)
 616                 to_match_count++;
 617
 618         if (alias_count != to_match_count) {
 619                 pr_debug("testing aliases uncore PMU %s: mismatch expected aliases (%d) vs found (%d)\n",
 620                          pmu_name, to_match_count, alias_count);
 621                 return -1;
 622         }
 623
 624         for (table = &test_pmu->aliases[0]; *table; table++) {
 625                 struct perf_pmu_test_event test_event = **table;
 626                 struct pmu_event const *event = &test_event.event;
 627                 int err;
 628                 struct test_core_pmu_event_aliases_cb_args args = {
 629                         .test_event = &test_event,
 630                         .count = &matched_count,
 631                 };
 632
 633                 if (strcmp(pmu_name, test_event.matching_pmu)) {
 634                         pr_debug("testing aliases uncore PMU %s: mismatched matching_pmu, %s vs %s\n",
 635                                         pmu_name, test_event.matching_pmu, pmu_name);
 636                         return -1;
 637                 }
 638
 639                 err = perf_pmu__find_event(pmu, event->name, &args,
 640                                            test_core_pmu_event_aliases_cb);
 641                 if (err) {
 642                         res = err;
 643                         pr_debug("testing aliases uncore PMU %s: could not match alias %s\n",
 644                                  pmu_name, event->name);
 645                         return -1;
 646                 }
 647         }
 648
 649         if (alias_count != matched_count) {
 650                 pr_debug("testing aliases uncore PMU %s: mismatch found aliases (%d) vs matched (%d)\n",
 651                          pmu_name, matched_count, alias_count);
 652                 res = -1;
 653         }
 654         return res;
 655 }
 656
 657 static struct perf_pmu_test_pmu test_pmus[] = {
 658         {
 659                 .pmu = {
 660                         .name = "hisi_sccl1_ddrc2",
 661                         .is_uncore = 1,
 662                 },
 663                 .aliases = {
 664                         &uncore_hisi_ddrc_flux_wcmd,
 665                 },
 666         },
 667         {
 668                 .pmu = {
 669                         .name = "uncore_cbox_0",
 670                         .is_uncore = 1,
 671                 },
 672                 .aliases = {
 673                         &unc_cbo_xsnp_response_miss_eviction,
 674                         &uncore_hyphen,
 675                         &uncore_two_hyph,
 676                 },
 677         },
 678         {
 679                 .pmu = {
 680                         .name = "hisi_sccl3_l3c7",
 681                         .is_uncore = 1,
 682                 },
 683                 .aliases = {
 684                         &uncore_hisi_l3c_rd_hit_cpipe,
 685                 },
 686         },
 687         {
 688                 .pmu = {
 689                         .name = "uncore_imc_free_running_0",
 690                         .is_uncore = 1,
 691                 },
 692                 .aliases = {
 693                         &uncore_imc_free_running_cache_miss,
 694                 },
 695         },
 696         {
 697                 .pmu = {
 698                         .name = "uncore_imc_0",
 699                         .is_uncore = 1,
 700                 },
 701                 .aliases = {
 702                         &uncore_imc_cache_hits,
 703                 },
 704         },
 705         {
 706                 .pmu = {
 707                         .name = "uncore_sys_ddr_pmu0",
 708                         .is_uncore = 1,
 709                         .id = "v8",
 710                 },
 711                 .aliases = {
 712                         &sys_ddr_pmu_write_cycles,
 713                 },
 714         },
 715         {
 716                 .pmu = {
 717                         .name = "uncore_sys_ccn_pmu4",
 718                         .is_uncore = 1,
 719                         .id = "0x01",
 720                 },
 721                 .aliases = {
 722                         &sys_ccn_pmu_read_cycles,
 723                 },
 724         },
 725         {
 726                 .pmu = {
 727                         .name = (char *)"uncore_sys_cmn_pmu0",
 728                         .is_uncore = 1,
 729                         .id = (char *)"43401",
 730                 },
 731                 .aliases = {
 732                         &sys_cmn_pmu_hnf_cache_miss,
 733                 },
 734         },
 735         {
 736                 .pmu = {
 737                         .name = (char *)"uncore_sys_cmn_pmu0",
 738                         .is_uncore = 1,
 739                         .id = (char *)"43602",
 740                 },
 741                 .aliases = {
 742                         &sys_cmn_pmu_hnf_cache_miss,
 743                 },
 744         },
 745         {
 746                 .pmu = {
 747                         .name = (char *)"uncore_sys_cmn_pmu0",
 748                         .is_uncore = 1,
 749                         .id = (char *)"43c03",
 750                 },
 751                 .aliases = {
 752                         &sys_cmn_pmu_hnf_cache_miss,
 753                 },
 754         },
 755         {
 756                 .pmu = {
 757                         .name = (char *)"uncore_sys_cmn_pmu0",
 758                         .is_uncore = 1,
 759                         .id = (char *)"43a01",
 760                 },
 761                 .aliases = {
 762                         &sys_cmn_pmu_hnf_cache_miss,
 763                 },
 764         }
 765 };
 766
 767 /* Test that aliases generated are as expected */
 768 static int test__aliases(struct test_suite *test __maybe_unused,
 769                         int subtest __maybe_unused)
 770 {
 771         struct perf_pmu *pmu = NULL;
 772         unsigned long i;
 773
 774         while ((pmu = perf_pmus__scan_core(pmu)) != NULL) {
 775                 int count = 0;
 776
 777                 if (list_empty(&pmu->format)) {
 778                         pr_debug2("skipping testing core PMU %s\n", pmu->name);
 779                         continue;
 780                 }
 781
 782                 if (__test_core_pmu_event_aliases(pmu->name, &count)) {
 783                         pr_debug("testing core PMU %s aliases: failed\n", pmu->name);
 784                         return -1;
 785                 }
 786
 787                 if (count == 0) {
 788                         pr_debug("testing core PMU %s aliases: no events to match\n",
 789                                   pmu->name);
 790                         return -1;
 791                 }
 792
 793                 pr_debug("testing core PMU %s aliases: pass\n", pmu->name);
 794         }
 795
 796         for (i = 0; i < ARRAY_SIZE(test_pmus); i++) {
 797                 int res;
 798
 799                 INIT_LIST_HEAD(&test_pmus[i].pmu.format);
 800                 INIT_LIST_HEAD(&test_pmus[i].pmu.aliases);
 801                 INIT_LIST_HEAD(&test_pmus[i].pmu.caps);
 802
 803                 res = __test_uncore_pmu_event_aliases(&test_pmus[i]);
 804                 if (res)
 805                         return res;
 806         }
 807
 808         return 0;
 809 }
 810
 811 static bool is_number(const char *str)
 812 {
 813         char *end_ptr;
 814         double v;
 815
 816         errno = 0;
 817         v = strtod(str, &end_ptr);
 818         (void)v; // We're not interested in this value, only if it is valid
 819         return errno == 0 && end_ptr != str;
 820 }
 821
 822 static int check_parse_id(const char *id, struct parse_events_error *error)
 823 {
 824         struct evlist *evlist;
 825         int ret;
 826         char *dup, *cur;
 827
 828         /* Numbers are always valid. */
 829         if (is_number(id))
 830                 return 0;
 831
 832         evlist = evlist__new();
 833         if (!evlist)
 834                 return -ENOMEM;
 835
 836         dup = strdup(id);
 837         if (!dup)
 838                 return -ENOMEM;
 839
 840         for (cur = strchr(dup, '@') ; cur; cur = strchr(++cur, '@'))
 841                 *cur = '/';
 842
 843         ret = __parse_events(evlist, dup, /*pmu_filter=*/NULL, error, /*fake_pmu=*/true,
 844                              /*warn_if_reordered=*/true, /*fake_tp=*/false);
 845         free(dup);
 846
 847         evlist__delete(evlist);
 848         return ret;
 849 }
 850
 851 static int check_parse_fake(const char *id)
 852 {
 853         struct parse_events_error error;
 854         int ret;
 855
 856         parse_events_error__init(&error);
 857         ret = check_parse_id(id, &error);
 858         parse_events_error__exit(&error);
 859         return ret;
 860 }
 861
 862 struct metric {
 863         struct list_head list;
 864         struct metric_ref metric_ref;
 865 };
 866
 867 static int test__parsing_callback(const struct pmu_metric *pm,
 868                                   const struct pmu_metrics_table *table,
 869                                   void *data)
 870 {
 871         int *failures = data;
 872         int k;
 873         struct evlist *evlist;
 874         struct perf_cpu_map *cpus;
 875         struct evsel *evsel;
 876         struct rblist metric_events = {
 877                 .nr_entries = 0,
 878         };
 879         int err = 0;
 880
 881         if (!pm->metric_expr)
 882                 return 0;
 883
 884         pr_debug("Found metric '%s'\n", pm->metric_name);
 885         (*failures)++;
 886
 887         /*
 888          * We need to prepare evlist for stat mode running on CPU 0
 889          * because that's where all the stats are going to be created.
 890          */
 891         evlist = evlist__new();
 892         if (!evlist)
 893                 return -ENOMEM;
 894
 895         cpus = perf_cpu_map__new("0");
 896         if (!cpus) {
 897                 evlist__delete(evlist);
 898                 return -ENOMEM;
 899         }
 900
 901         perf_evlist__set_maps(&evlist->core, cpus, NULL);
 902
 903         err = metricgroup__parse_groups_test(evlist, table, pm->metric_name, &metric_events);
 904         if (err) {
 905                 if (!strcmp(pm->metric_name, "M1") || !strcmp(pm->metric_name, "M2") ||
 906                     !strcmp(pm->metric_name, "M3")) {
 907                         (*failures)--;
 908                         pr_debug("Expected broken metric %s skipping\n", pm->metric_name);
 909                         err = 0;
 910                 }
 911                 goto out_err;
 912         }
 913
 914         err = evlist__alloc_stats(/*config=*/NULL, evlist, /*alloc_raw=*/false);
 915         if (err)
 916                 goto out_err;
 917         /*
 918          * Add all ids with a made up value. The value may trigger divide by
 919          * zero when subtracted and so try to make them unique.
 920          */
 921         k = 1;
 922         evlist__alloc_aggr_stats(evlist, 1);
 923         evlist__for_each_entry(evlist, evsel) {
 924                 evsel->stats->aggr->counts.val = k;
 925                 if (evsel__name_is(evsel, "duration_time"))
 926                         update_stats(&walltime_nsecs_stats, k);
 927                 k++;
 928         }
 929         evlist__for_each_entry(evlist, evsel) {
 930                 struct metric_event *me = metricgroup__lookup(&metric_events, evsel, false);
 931
 932                 if (me != NULL) {
 933                         struct metric_expr *mexp;
 934
 935                         list_for_each_entry (mexp, &me->head, nd) {
 936                                 if (strcmp(mexp->metric_name, pm->metric_name))
 937                                         continue;
 938                                 pr_debug("Result %f\n", test_generic_metric(mexp, 0));
 939                                 err = 0;
 940                                 (*failures)--;
 941                                 goto out_err;
 942                         }
 943                 }
 944         }
 945         pr_debug("Didn't find parsed metric %s", pm->metric_name);
 946         err = 1;
 947 out_err:
 948         if (err)
 949                 pr_debug("Broken metric %s\n", pm->metric_name);
 950
 951         /* ... cleanup. */
 952         metricgroup__rblist_exit(&metric_events);
 953         evlist__free_stats(evlist);
 954         perf_cpu_map__put(cpus);
 955         evlist__delete(evlist);
 956         return err;
 957 }
 958
 959 static int test__parsing(struct test_suite *test __maybe_unused,
 960                          int subtest __maybe_unused)
 961 {
 962         int failures = 0;
 963
 964         pmu_for_each_core_metric(test__parsing_callback, &failures);
 965         pmu_for_each_sys_metric(test__parsing_callback, &failures);
 966
 967         return failures == 0 ? TEST_OK : TEST_FAIL;
 968 }
 969
 970 struct test_metric {
 971         const char *str;
 972 };
 973
 974 static struct test_metric metrics[] = {
 975         { "(unc_p_power_state_occupancy.cores_c0 / unc_p_clockticks) * 100." },
 976         { "imx8_ddr0@read\\-cycles@ * 4 * 4", },
 977         { "imx8_ddr0@axid\\-read\\,axi_mask\\=0xffff\\,axi_id\\=0x0000@ * 4", },
 978         { "(cstate_pkg@c2\\-residency@ / msr@tsc@) * 100", },
 979         { "(imx8_ddr0@read\\-cycles@ + imx8_ddr0@write\\-cycles@)", },
 980 };
 981
 982 static int metric_parse_fake(const char *metric_name, const char *str)
 983 {
 984         struct expr_parse_ctx *ctx;
 985         struct hashmap_entry *cur;
 986         double result;
 987         int ret = -1;
 988         size_t bkt;
 989         int i;
 990
 991         pr_debug("parsing '%s': '%s'\n", metric_name, str);
 992
 993         ctx = expr__ctx_new();
 994         if (!ctx) {
 995                 pr_debug("expr__ctx_new failed");
 996                 return TEST_FAIL;
 997         }
 998         ctx->sctx.is_test = true;
 999         if (expr__find_ids(str, NULL, ctx) < 0) {
1000                 pr_err("expr__find_ids failed\n");
1001                 return -1;
1002         }
1003
1004         /*
1005          * Add all ids with a made up value. The value may
1006          * trigger divide by zero when subtracted and so try to
1007          * make them unique.
1008          */
1009         i = 1;
1010         hashmap__for_each_entry(ctx->ids, cur, bkt)
1011                 expr__add_id_val(ctx, strdup(cur->pkey), i++);
1012
1013         hashmap__for_each_entry(ctx->ids, cur, bkt) {
1014                 if (check_parse_fake(cur->pkey)) {
1015                         pr_err("check_parse_fake failed\n");
1016                         goto out;
1017                 }
1018         }
1019
1020         ret = 0;
1021         if (expr__parse(&result, ctx, str)) {
1022                 /*
1023                  * Parsing failed, make numbers go from large to small which can
1024                  * resolve divide by zero issues.
1025                  */
1026                 i = 1024;
1027                 hashmap__for_each_entry(ctx->ids, cur, bkt)
1028                         expr__add_id_val(ctx, strdup(cur->pkey), i--);
1029                 if (expr__parse(&result, ctx, str)) {
1030                         pr_err("expr__parse failed for %s\n", metric_name);
1031                         /* The following have hard to avoid divide by zero. */
1032                         if (!strcmp(metric_name, "tma_clears_resteers") ||
1033                             !strcmp(metric_name, "tma_mispredicts_resteers"))
1034                                 ret = 0;
1035                         else
1036                                 ret = -1;
1037                 }
1038         }
1039
1040 out:
1041         expr__ctx_free(ctx);
1042         return ret;
1043 }
1044
1045 static int test__parsing_fake_callback(const struct pmu_metric *pm,
1046                                        const struct pmu_metrics_table *table __maybe_unused,
1047                                        void *data __maybe_unused)
1048 {
1049         return metric_parse_fake(pm->metric_name, pm->metric_expr);
1050 }
1051
1052 /*
1053  * Parse all the metrics for current architecture, or all defined cpus via the
1054  * 'fake_pmu' in parse_events.
1055  */
1056 static int test__parsing_fake(struct test_suite *test __maybe_unused,
1057                               int subtest __maybe_unused)
1058 {
1059         int err = 0;
1060
1061         for (size_t i = 0; i < ARRAY_SIZE(metrics); i++) {
1062                 err = metric_parse_fake("", metrics[i].str);
1063                 if (err)
1064                         return err;
1065         }
1066
1067         err = pmu_for_each_core_metric(test__parsing_fake_callback, NULL);
1068         if (err)
1069                 return err;
1070
1071         return pmu_for_each_sys_metric(test__parsing_fake_callback, NULL);
1072 }
1073
1074 static int test__parsing_threshold_callback(const struct pmu_metric *pm,
1075                                         const struct pmu_metrics_table *table __maybe_unused,
1076                                         void *data __maybe_unused)
1077 {
1078         if (!pm->metric_threshold)
1079                 return 0;
1080         return metric_parse_fake(pm->metric_name, pm->metric_threshold);
1081 }
1082
1083 static int test__parsing_threshold(struct test_suite *test __maybe_unused,
1084                               int subtest __maybe_unused)
1085 {
1086         int err = 0;
1087
1088         err = pmu_for_each_core_metric(test__parsing_threshold_callback, NULL);
1089         if (err)
1090                 return err;
1091
1092         return pmu_for_each_sys_metric(test__parsing_threshold_callback, NULL);
1093 }
1094
1095 static struct test_case pmu_events_tests[] = {
1096         TEST_CASE("PMU event table sanity", pmu_event_table),
1097         TEST_CASE("PMU event map aliases", aliases),
1098         TEST_CASE_REASON("Parsing of PMU event table metrics", parsing,
1099                          "some metrics failed"),
1100         TEST_CASE("Parsing of PMU event table metrics with fake PMUs", parsing_fake),
1101         TEST_CASE("Parsing of metric thresholds with fake PMUs", parsing_threshold),
1102         { .name = NULL, }
1103 };
1104
1105 struct test_suite suite__pmu_events = {
1106         .desc = "PMU JSON event tests",
1107         .test_cases = pmu_events_tests,
1108 };