perf evsel: Rename perf_evsel__[hs]w_cache* to evsel__[hs]w_cache*

As those are 'struct evsel' methods, not part of tools/lib/perf/, aka
libperf, to whom the perf_ prefix belongs.

Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: Jiri Olsa <jolsa@kernel.org>
Cc: Namhyung Kim <namhyung@kernel.org>
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>

diff --git a/tools/perf/tests/evsel-roundtrip-name.c b/tools/perf/tests/evsel-roundtrip-name.c
index 61ecd8e33a017bde3e2ea17f026eb9196c45375a..f7f3e5b4c1800738d90bb9fe20664466ba1ea7d4 100644 (file)
--- a/tools/perf/tests/evsel-roundtrip-name.c
+++ b/tools/perf/tests/evsel-roundtrip-name.c
@@ -100,12 +100,11 @@ int test__perf_evsel__roundtrip_name_test(struct test *test __maybe_unused, int
 {
        int err = 0, ret = 0;
 
-       err = perf_evsel__name_array_test(perf_evsel__hw_names);
+       err = perf_evsel__name_array_test(evsel__hw_names);
        if (err)
                ret = err;
 
-       err = __perf_evsel__name_array_test(perf_evsel__sw_names,
-                                           PERF_COUNT_SW_DUMMY + 1);
+       err = __perf_evsel__name_array_test(evsel__sw_names, PERF_COUNT_SW_DUMMY + 1);
        if (err)
                ret = err;
 

diff --git a/tools/perf/util/evsel.c b/tools/perf/util/evsel.c
index 648d034dec0fb3088a9bb027c362101e08d2e11c..320f3a292d3566747a67441692394aab35fe84ed 100644 (file)
--- a/tools/perf/util/evsel.c
+++ b/tools/perf/util/evsel.c
@@ -371,7 +371,7 @@ out_err:
        return ERR_PTR(err);
 }
 
-const char *perf_evsel__hw_names[PERF_COUNT_HW_MAX] = {
+const char *evsel__hw_names[PERF_COUNT_HW_MAX] = {
        "cycles",
        "instructions",
        "cache-references",
@@ -386,8 +386,8 @@ const char *perf_evsel__hw_names[PERF_COUNT_HW_MAX] = {
 
 static const char *__evsel__hw_name(u64 config)
 {
-       if (config < PERF_COUNT_HW_MAX && perf_evsel__hw_names[config])
-               return perf_evsel__hw_names[config];
+       if (config < PERF_COUNT_HW_MAX && evsel__hw_names[config])
+               return evsel__hw_names[config];
 
        return "unknown-hardware";
 }
@@ -434,7 +434,7 @@ static int evsel__hw_name(struct evsel *evsel, char *bf, size_t size)
        return r + perf_evsel__add_modifiers(evsel, bf + r, size - r);
 }
 
-const char *perf_evsel__sw_names[PERF_COUNT_SW_MAX] = {
+const char *evsel__sw_names[PERF_COUNT_SW_MAX] = {
        "cpu-clock",
        "task-clock",
        "page-faults",
@@ -449,8 +449,8 @@ const char *perf_evsel__sw_names[PERF_COUNT_SW_MAX] = {
 
 static const char *__evsel__sw_name(u64 config)
 {
-       if (config < PERF_COUNT_SW_MAX && perf_evsel__sw_names[config])
-               return perf_evsel__sw_names[config];
+       if (config < PERF_COUNT_SW_MAX && evsel__sw_names[config])
+               return evsel__sw_names[config];
        return "unknown-software";
 }
 
@@ -485,8 +485,7 @@ static int evsel__bp_name(struct evsel *evsel, char *bf, size_t size)
        return r + perf_evsel__add_modifiers(evsel, bf + r, size - r);
 }
 
-const char *perf_evsel__hw_cache[PERF_COUNT_HW_CACHE_MAX]
-                               [PERF_EVSEL__MAX_ALIASES] = {
+const char *evsel__hw_cache[PERF_COUNT_HW_CACHE_MAX][EVSEL__MAX_ALIASES] = {
  { "L1-dcache",        "l1-d",         "l1d",          "L1-data",              },
  { "L1-icache",        "l1-i",         "l1i",          "L1-instruction",       },
  { "LLC",      "L2",                                                   },
@@ -496,15 +495,13 @@ const char *perf_evsel__hw_cache[PERF_COUNT_HW_CACHE_MAX]
  { "node",                                                             },
 };
 
-const char *perf_evsel__hw_cache_op[PERF_COUNT_HW_CACHE_OP_MAX]
-                                  [PERF_EVSEL__MAX_ALIASES] = {
+const char *evsel__hw_cache_op[PERF_COUNT_HW_CACHE_OP_MAX][EVSEL__MAX_ALIASES] = {
  { "load",     "loads",        "read",                                 },
  { "store",    "stores",       "write",                                },
  { "prefetch", "prefetches",   "speculative-read", "speculative-load", },
 };
 
-const char *perf_evsel__hw_cache_result[PERF_COUNT_HW_CACHE_RESULT_MAX]
-                                      [PERF_EVSEL__MAX_ALIASES] = {
+const char *evsel__hw_cache_result[PERF_COUNT_HW_CACHE_RESULT_MAX][EVSEL__MAX_ALIASES] = {
  { "refs",     "Reference",    "ops",          "access",               },
  { "misses",   "miss",                                                 },
 };
@@ -520,7 +517,7 @@ const char *perf_evsel__hw_cache_result[PERF_COUNT_HW_CACHE_RESULT_MAX]
  * L1I : Read and prefetch only
  * ITLB and BPU : Read-only
  */
-static unsigned long perf_evsel__hw_cache_stat[C(MAX)] = {
+static unsigned long evsel__hw_cache_stat[C(MAX)] = {
  [C(L1D)]      = (CACHE_READ | CACHE_WRITE | CACHE_PREFETCH),
  [C(L1I)]      = (CACHE_READ | CACHE_PREFETCH),
  [C(LL)]       = (CACHE_READ | CACHE_WRITE | CACHE_PREFETCH),
@@ -532,7 +529,7 @@ static unsigned long perf_evsel__hw_cache_stat[C(MAX)] = {
 
 bool evsel__is_cache_op_valid(u8 type, u8 op)
 {
-       if (perf_evsel__hw_cache_stat[type] & COP(op))
+       if (evsel__hw_cache_stat[type] & COP(op))
                return true;    /* valid */
        else
                return false;   /* invalid */
@@ -541,13 +538,13 @@ bool evsel__is_cache_op_valid(u8 type, u8 op)
 int __evsel__hw_cache_type_op_res_name(u8 type, u8 op, u8 result, char *bf, size_t size)
 {
        if (result) {
-               return scnprintf(bf, size, "%s-%s-%s", perf_evsel__hw_cache[type][0],
-                                perf_evsel__hw_cache_op[op][0],
-                                perf_evsel__hw_cache_result[result][0]);
+               return scnprintf(bf, size, "%s-%s-%s", evsel__hw_cache[type][0],
+                                evsel__hw_cache_op[op][0],
+                                evsel__hw_cache_result[result][0]);
        }
 
-       return scnprintf(bf, size, "%s-%s", perf_evsel__hw_cache[type][0],
-                        perf_evsel__hw_cache_op[op][1]);
+       return scnprintf(bf, size, "%s-%s", evsel__hw_cache[type][0],
+                        evsel__hw_cache_op[op][1]);
 }
 
 static int __evsel__hw_cache_name(u64 config, char *bf, size_t size)

diff --git a/tools/perf/util/evsel.h b/tools/perf/util/evsel.h
index a3707f1beffd2302ec221fcfa5d6be8bf52bdeff..3a1a814a03196ca00fb9e6c0818f3fc2b632caa6 100644 (file)
--- a/tools/perf/util/evsel.h
+++ b/tools/perf/util/evsel.h
@@ -198,16 +198,13 @@ void evsel__calc_id_pos(struct evsel *evsel);
 
 bool evsel__is_cache_op_valid(u8 type, u8 op);
 
-#define PERF_EVSEL__MAX_ALIASES 8
-
-extern const char *perf_evsel__hw_cache[PERF_COUNT_HW_CACHE_MAX]
-                                      [PERF_EVSEL__MAX_ALIASES];
-extern const char *perf_evsel__hw_cache_op[PERF_COUNT_HW_CACHE_OP_MAX]
-                                         [PERF_EVSEL__MAX_ALIASES];
-extern const char *perf_evsel__hw_cache_result[PERF_COUNT_HW_CACHE_RESULT_MAX]
-                                             [PERF_EVSEL__MAX_ALIASES];
-extern const char *perf_evsel__hw_names[PERF_COUNT_HW_MAX];
-extern const char *perf_evsel__sw_names[PERF_COUNT_SW_MAX];
+#define EVSEL__MAX_ALIASES 8
+
+extern const char *evsel__hw_cache[PERF_COUNT_HW_CACHE_MAX][EVSEL__MAX_ALIASES];
+extern const char *evsel__hw_cache_op[PERF_COUNT_HW_CACHE_OP_MAX][EVSEL__MAX_ALIASES];
+extern const char *evsel__hw_cache_result[PERF_COUNT_HW_CACHE_RESULT_MAX][EVSEL__MAX_ALIASES];
+extern const char *evsel__hw_names[PERF_COUNT_HW_MAX];
+extern const char *evsel__sw_names[PERF_COUNT_SW_MAX];
 int __evsel__hw_cache_type_op_res_name(u8 type, u8 op, u8 result, char *bf, size_t size);
 const char *evsel__name(struct evsel *evsel);
 

diff --git a/tools/perf/util/parse-events.c b/tools/perf/util/parse-events.c
index 3d5707a4557895a6b18c2c9087039bbb2d26a1cd..df1bf762807ffa6fdeb32b65ed5b0115e9ff2584 100644 (file)
--- a/tools/perf/util/parse-events.c
+++ b/tools/perf/util/parse-events.c
@@ -399,13 +399,13 @@ static int add_event_tool(struct list_head *list, int *idx,
        return 0;
 }
 
-static int parse_aliases(char *str, const char *names[][PERF_EVSEL__MAX_ALIASES], int size)
+static int parse_aliases(char *str, const char *names[][EVSEL__MAX_ALIASES], int size)
 {
        int i, j;
        int n, longest = -1;
 
        for (i = 0; i < size; i++) {
-               for (j = 0; j < PERF_EVSEL__MAX_ALIASES && names[i][j]; j++) {
+               for (j = 0; j < EVSEL__MAX_ALIASES && names[i][j]; j++) {
                        n = strlen(names[i][j]);
                        if (n > longest && !strncasecmp(str, names[i][j], n))
                                longest = n;
@@ -444,8 +444,7 @@ int parse_events_add_cache(struct list_head *list, int *idx,
         * No fallback - if we cannot get a clear cache type
         * then bail out:
         */
-       cache_type = parse_aliases(type, perf_evsel__hw_cache,
-                                  PERF_COUNT_HW_CACHE_MAX);
+       cache_type = parse_aliases(type, evsel__hw_cache, PERF_COUNT_HW_CACHE_MAX);
        if (cache_type == -1)
                return -EINVAL;
 
@@ -458,7 +457,7 @@ int parse_events_add_cache(struct list_head *list, int *idx,
                n += snprintf(name + n, MAX_NAME_LEN - n, "-%s", str);
 
                if (cache_op == -1) {
-                       cache_op = parse_aliases(str, perf_evsel__hw_cache_op,
+                       cache_op = parse_aliases(str, evsel__hw_cache_op,
                                                 PERF_COUNT_HW_CACHE_OP_MAX);
                        if (cache_op >= 0) {
                                if (!evsel__is_cache_op_valid(cache_type, cache_op))
@@ -468,7 +467,7 @@ int parse_events_add_cache(struct list_head *list, int *idx,
                }
 
                if (cache_result == -1) {
-                       cache_result = parse_aliases(str, perf_evsel__hw_cache_result,
+                       cache_result = parse_aliases(str, evsel__hw_cache_result,
                                                     PERF_COUNT_HW_CACHE_RESULT_MAX);
                        if (cache_result >= 0)
                                continue;