root/tools/perf/tests/evsel-roundtrip-name.c

DEFINITIONS

1. perf_evsel__roundtrip_cache_name_test
2. __perf_evsel__name_array_test
3. test__perf_evsel__roundtrip_name_test

   1 // SPDX-License-Identifier: GPL-2.0
   2 #include "evlist.h"
   3 #include "evsel.h"
   4 #include "parse-events.h"
   5 #include "tests.h"
   6 #include "debug.h"
   7 #include <errno.h>
   8 #include <linux/kernel.h>
   9 
  10 static int perf_evsel__roundtrip_cache_name_test(void)
  11 {
  12         char name[128];
  13         int type, op, err = 0, ret = 0, i, idx;
  14         struct evsel *evsel;
  15         struct evlist *evlist = evlist__new();
  16 
  17         if (evlist == NULL)
  18                 return -ENOMEM;
  19 
  20         for (type = 0; type < PERF_COUNT_HW_CACHE_MAX; type++) {
  21                 for (op = 0; op < PERF_COUNT_HW_CACHE_OP_MAX; op++) {
  22                         /* skip invalid cache type */
  23                         if (!perf_evsel__is_cache_op_valid(type, op))
  24                                 continue;
  25 
  26                         for (i = 0; i < PERF_COUNT_HW_CACHE_RESULT_MAX; i++) {
  27                                 __perf_evsel__hw_cache_type_op_res_name(type, op, i,
  28                                                                         name, sizeof(name));
  29                                 err = parse_events(evlist, name, NULL);
  30                                 if (err)
  31                                         ret = err;
  32                         }
  33                 }
  34         }
  35 
  36         idx = 0;
  37         evsel = evlist__first(evlist);
  38 
  39         for (type = 0; type < PERF_COUNT_HW_CACHE_MAX; type++) {
  40                 for (op = 0; op < PERF_COUNT_HW_CACHE_OP_MAX; op++) {
  41                         /* skip invalid cache type */
  42                         if (!perf_evsel__is_cache_op_valid(type, op))
  43                                 continue;
  44 
  45                         for (i = 0; i < PERF_COUNT_HW_CACHE_RESULT_MAX; i++) {
  46                                 __perf_evsel__hw_cache_type_op_res_name(type, op, i,
  47                                                                         name, sizeof(name));
  48                                 if (evsel->idx != idx)
  49                                         continue;
  50 
  51                                 ++idx;
  52 
  53                                 if (strcmp(perf_evsel__name(evsel), name)) {
  54                                         pr_debug("%s != %s\n", perf_evsel__name(evsel), name);
  55                                         ret = -1;
  56                                 }
  57 
  58                                 evsel = perf_evsel__next(evsel);
  59                         }
  60                 }
  61         }
  62 
  63         evlist__delete(evlist);
  64         return ret;
  65 }
  66 
  67 static int __perf_evsel__name_array_test(const char *names[], int nr_names)
  68 {
  69         int i, err;
  70         struct evsel *evsel;
  71         struct evlist *evlist = evlist__new();
  72 
  73         if (evlist == NULL)
  74                 return -ENOMEM;
  75 
  76         for (i = 0; i < nr_names; ++i) {
  77                 err = parse_events(evlist, names[i], NULL);
  78                 if (err) {
  79                         pr_debug("failed to parse event '%s', err %d\n",
  80                                  names[i], err);
  81                         goto out_delete_evlist;
  82                 }
  83         }
  84 
  85         err = 0;
  86         evlist__for_each_entry(evlist, evsel) {
  87                 if (strcmp(perf_evsel__name(evsel), names[evsel->idx])) {
  88                         --err;
  89                         pr_debug("%s != %s\n", perf_evsel__name(evsel), names[evsel->idx]);
  90                 }
  91         }
  92 
  93 out_delete_evlist:
  94         evlist__delete(evlist);
  95         return err;
  96 }
  97 
  98 #define perf_evsel__name_array_test(names) \
  99         __perf_evsel__name_array_test(names, ARRAY_SIZE(names))
 100 
 101 int test__perf_evsel__roundtrip_name_test(struct test *test __maybe_unused, int subtest __maybe_unused)
 102 {
 103         int err = 0, ret = 0;
 104 
 105         err = perf_evsel__name_array_test(perf_evsel__hw_names);
 106         if (err)
 107                 ret = err;
 108 
 109         err = __perf_evsel__name_array_test(perf_evsel__sw_names,
 110                                             PERF_COUNT_SW_DUMMY + 1);
 111         if (err)
 112                 ret = err;
 113 
 114         err = perf_evsel__roundtrip_cache_name_test();
 115         if (err)
 116                 ret = err;
 117 
 118         return ret;
 119 }