github-mirror/linux
1
0
Fork 0
mirror of https://github.com/torvalds/linux.git synced 2026-05-25 07:33:19 +02:00
Code Issues Actions Packages Projects Releases Wiki Activity Graph

perf tool_pmu: Rename enum perf_tool_event to tool_pmu_event

Browse Source 
To better reflect the events listed are from the tool PMU. Rename the
enum values from PERF_TOOL_* to TOOL_PMU__EVENT_*.

Signed-off-by: Ian Rogers <irogers@google.com>
Acked-by: Namhyung Kim <namhyung@kernel.org>
Link: https://lore.kernel.org/r/20241002032016.333748-6-irogers@google.com
Signed-off-by: Namhyung Kim <namhyung@kernel.org>
This commit is contained in:
Ian Rogers 2024-10-01 20:20:08 -07:00 committed by Namhyung Kim
parent 240505b2d0
commit 0709a82c10
7 changed files with 50 additions and 50 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
tools/perf/builtin-stat.c
View File

@ -295,14 +295,14 @@ static int read_single_counter(struct evsel *counter, int cpu_map_idx, int threa
* terminates. Use the wait4 values in that case.
*/
if (err && cpu_map_idx == 0 &&
(evsel__tool_event(counter) == PERF_TOOL_USER_TIME ||
evsel__tool_event(counter) == PERF_TOOL_SYSTEM_TIME)) {
(evsel__tool_event(counter) == TOOL_PMU__EVENT_USER_TIME ||
evsel__tool_event(counter) == TOOL_PMU__EVENT_SYSTEM_TIME)) {
u64 val, *start_time;
struct perf_counts_values *count =
perf_counts(counter->counts, cpu_map_idx, thread);
start_time = xyarray__entry(counter->start_times, cpu_map_idx, thread);
if (evsel__tool_event(counter) == PERF_TOOL_USER_TIME)
if (evsel__tool_event(counter) == TOOL_PMU__EVENT_USER_TIME)
val = ru_stats.ru_utime_usec_stat.mean;
else
val = ru_stats.ru_stime_usec_stat.mean;

4
tools/perf/util/evsel.c
View File

@ -1476,8 +1476,8 @@ void evsel__exit(struct evsel *evsel)
evsel->per_pkg_mask = NULL;
zfree(&evsel->metric_events);
perf_evsel__object.fini(evsel);
if (evsel__tool_event(evsel) == PERF_TOOL_SYSTEM_TIME ||
evsel__tool_event(evsel) == PERF_TOOL_USER_TIME)
if (evsel__tool_event(evsel) == TOOL_PMU__EVENT_SYSTEM_TIME ||
evsel__tool_event(evsel) == TOOL_PMU__EVENT_USER_TIME)
xyarray__delete(evsel->start_times);
}

12
tools/perf/util/metricgroup.c
View File

@ -674,20 +674,20 @@ static int metricgroup__build_event_string(struct strbuf *events,
struct hashmap_entry *cur;
size_t bkt;
bool no_group = true, has_tool_events = false;
bool tool_events[PERF_TOOL_MAX] = {false};
bool tool_events[TOOL_PMU__EVENT_MAX] = {false};
int ret = 0;
#define RETURN_IF_NON_ZERO(x) do { if (x) return x; } while (0)
hashmap__for_each_entry(ctx->ids, cur, bkt) {
const char *sep, *rsep, *id = cur->pkey;
enum perf_tool_event ev;
enum tool_pmu_event ev;
pr_debug("found event %s\n", id);
/* Always move tool events outside of the group. */
ev = perf_tool_event__from_str(id);
if (ev != PERF_TOOL_NONE) {
if (ev != TOOL_PMU__EVENT_NONE) {
has_tool_events = true;
tool_events[ev] = true;
continue;
@ -1375,7 +1375,7 @@ static void metricgroup__free_metrics(struct list_head *metric_list)
* to true if tool event is found.
*/
static void find_tool_events(const struct list_head *metric_list,
bool tool_events[PERF_TOOL_MAX])
bool tool_events[TOOL_PMU__EVENT_MAX])
{
struct metric *m;
@ -1447,7 +1447,7 @@ static int build_combined_expr_ctx(const struct list_head *metric_list,
*/
static int parse_ids(bool metric_no_merge, bool fake_pmu,
struct expr_parse_ctx *ids, const char *modifier,
bool group_events, const bool tool_events[PERF_TOOL_MAX],
bool group_events, const bool tool_events[TOOL_PMU__EVENT_MAX],
struct evlist **out_evlist)
{
struct parse_events_error parse_error;
@ -1536,7 +1536,7 @@ static int parse_groups(struct evlist *perf_evlist,
struct evlist *combined_evlist = NULL;
LIST_HEAD(metric_list);
struct metric *m;
bool tool_events[PERF_TOOL_MAX] = {false};
bool tool_events[TOOL_PMU__EVENT_MAX] = {false};
bool is_default = !strcmp(str, "Default");
int ret;

2
tools/perf/util/pmu.c
View File

@ -1836,7 +1836,7 @@ bool perf_pmu__have_event(struct perf_pmu *pmu, const char *name)
if (!name)
return false;
if (perf_pmu__is_tool(pmu))
return perf_tool_event__from_str(name) != PERF_TOOL_NONE;
return perf_tool_event__from_str(name) != TOOL_PMU__EVENT_NONE;
if (perf_pmu__find_alias(pmu, name, /*load=*/ true) != NULL)
return true;
if (pmu->cpu_aliases_added || !pmu->events_table)

10
tools/perf/util/stat-shadow.c
View File

@ -382,22 +382,22 @@ static int prepare_metric(const struct metric_expr *mexp,
double scale;
switch (evsel__tool_event(metric_events[i])) {
case PERF_TOOL_DURATION_TIME:
case TOOL_PMU__EVENT_DURATION_TIME:
stats = &walltime_nsecs_stats;
scale = 1e-9;
break;
case PERF_TOOL_USER_TIME:
case TOOL_PMU__EVENT_USER_TIME:
stats = &ru_stats.ru_utime_usec_stat;
scale = 1e-6;
break;
case PERF_TOOL_SYSTEM_TIME:
case TOOL_PMU__EVENT_SYSTEM_TIME:
stats = &ru_stats.ru_stime_usec_stat;
scale = 1e-6;
break;
case PERF_TOOL_NONE:
case TOOL_PMU__EVENT_NONE:
pr_err("Invalid tool event 'none'");
abort();
case PERF_TOOL_MAX:
case TOOL_PMU__EVENT_MAX:
pr_err("Invalid tool event 'max'");
abort();
default:

44
tools/perf/util/tool_pmu.c
View File

@ -12,7 +12,7 @@
#include <fcntl.h>
#include <strings.h>
static const char *const tool_pmu__event_names[PERF_TOOL_MAX] = {
static const char *const tool_pmu__event_names[TOOL_PMU__EVENT_MAX] = {
NULL,
"duration_time",
"user_time",
@ -20,15 +20,15 @@ static const char *const tool_pmu__event_names[PERF_TOOL_MAX] = {
};
const char *perf_tool_event__to_str(enum perf_tool_event ev)
const char *perf_tool_event__to_str(enum tool_pmu_event ev)
{
if (ev > PERF_TOOL_NONE && ev < PERF_TOOL_MAX)
if (ev > TOOL_PMU__EVENT_NONE && ev < TOOL_PMU__EVENT_MAX)
return tool_pmu__event_names[ev];
return NULL;
}
enum perf_tool_event perf_tool_event__from_str(const char *str)
enum tool_pmu_event perf_tool_event__from_str(const char *str)
{
int i;
@ -36,7 +36,7 @@ enum perf_tool_event perf_tool_event__from_str(const char *str)
if (!strcasecmp(str, tool_pmu__event_names[i]))
return i;
}
return PERF_TOOL_NONE;
return TOOL_PMU__EVENT_NONE;
}
static int tool_pmu__config_term(struct perf_event_attr *attr,
@ -44,9 +44,9 @@ static int tool_pmu__config_term(struct perf_event_attr *attr,
struct parse_events_error *err)
{
if (term->type_term == PARSE_EVENTS__TERM_TYPE_USER) {
enum perf_tool_event ev = perf_tool_event__from_str(term->config);
enum tool_pmu_event ev = perf_tool_event__from_str(term->config);
if (ev == PERF_TOOL_NONE)
if (ev == TOOL_PMU__EVENT_NONE)
goto err_out;
attr->config = ev;
@ -120,12 +120,12 @@ bool evsel__is_tool(const struct evsel *evsel)
return perf_pmu__is_tool(evsel->pmu);
}
enum perf_tool_event evsel__tool_event(const struct evsel *evsel)
enum tool_pmu_event evsel__tool_event(const struct evsel *evsel)
{
if (!evsel__is_tool(evsel))
return PERF_TOOL_NONE;
return TOOL_PMU__EVENT_NONE;
return (enum perf_tool_event)evsel->core.attr.config;
return (enum tool_pmu_event)evsel->core.attr.config;
}
const char *evsel__tool_pmu_event_name(const struct evsel *evsel)
@ -229,8 +229,8 @@ int evsel__tool_pmu_prepare_open(struct evsel *evsel,
struct perf_cpu_map *cpus,
int nthreads)
{
if ((evsel__tool_event(evsel) == PERF_TOOL_SYSTEM_TIME ||
evsel__tool_event(evsel) == PERF_TOOL_USER_TIME) &&
if ((evsel__tool_event(evsel) == TOOL_PMU__EVENT_SYSTEM_TIME ||
evsel__tool_event(evsel) == TOOL_PMU__EVENT_USER_TIME) &&
!evsel->start_times) {
evsel->start_times = xyarray__new(perf_cpu_map__nr(cpus),
nthreads,
@ -247,10 +247,10 @@ int evsel__tool_pmu_open(struct evsel *evsel,
struct perf_thread_map *threads,
int start_cpu_map_idx, int end_cpu_map_idx)
{
enum perf_tool_event ev = evsel__tool_event(evsel);
enum tool_pmu_event ev = evsel__tool_event(evsel);
int pid = -1, idx = 0, thread = 0, nthreads, err = 0, old_errno;
if (ev == PERF_TOOL_DURATION_TIME) {
if (ev == TOOL_PMU__EVENT_DURATION_TIME) {
if (evsel->core.attr.sample_period) /* no sampling */
return -EINVAL;
evsel->start_time = rdclock();
@ -269,8 +269,8 @@ int evsel__tool_pmu_open(struct evsel *evsel,
if (!evsel->cgrp && !evsel->core.system_wide)
pid = perf_thread_map__pid(threads, thread);
if (ev == PERF_TOOL_USER_TIME || ev == PERF_TOOL_SYSTEM_TIME) {
bool system = ev == PERF_TOOL_SYSTEM_TIME;
if (ev == TOOL_PMU__EVENT_USER_TIME || ev == TOOL_PMU__EVENT_SYSTEM_TIME) {
bool system = ev == TOOL_PMU__EVENT_SYSTEM_TIME;
__u64 *start_time = NULL;
int fd;
@ -338,7 +338,7 @@ int evsel__read_tool(struct evsel *evsel, int cpu_map_idx, int thread)
count = perf_counts(evsel->counts, cpu_map_idx, thread);
switch (evsel__tool_event(evsel)) {
case PERF_TOOL_DURATION_TIME:
case TOOL_PMU__EVENT_DURATION_TIME:
/*
* Pretend duration_time is only on the first CPU and thread, or
* else aggregation will scale duration_time by the number of
@ -350,9 +350,9 @@ int evsel__read_tool(struct evsel *evsel, int cpu_map_idx, int thread)
else
cur_time = *start_time;
break;
case PERF_TOOL_USER_TIME:
case PERF_TOOL_SYSTEM_TIME: {
bool system = evsel__tool_event(evsel) == PERF_TOOL_SYSTEM_TIME;
case TOOL_PMU__EVENT_USER_TIME:
case TOOL_PMU__EVENT_SYSTEM_TIME: {
bool system = evsel__tool_event(evsel) == TOOL_PMU__EVENT_SYSTEM_TIME;
start_time = xyarray__entry(evsel->start_times, cpu_map_idx, thread);
fd = FD(evsel, cpu_map_idx, thread);
@ -377,8 +377,8 @@ int evsel__read_tool(struct evsel *evsel, int cpu_map_idx, int thread)
adjust = true;
break;
}
case PERF_TOOL_NONE:
case PERF_TOOL_MAX:
case TOOL_PMU__EVENT_NONE:
case TOOL_PMU__EVENT_MAX:
default:
err = -EINVAL;
}

22
tools/perf/util/tool_pmu.h
View File

@ -8,25 +8,25 @@ struct evsel;
struct perf_thread_map;
struct print_callbacks;
enum perf_tool_event {
PERF_TOOL_NONE = 0,
PERF_TOOL_DURATION_TIME = 1,
PERF_TOOL_USER_TIME = 2,
PERF_TOOL_SYSTEM_TIME = 3,
enum tool_pmu_event {
TOOL_PMU__EVENT_NONE = 0,
TOOL_PMU__EVENT_DURATION_TIME = 1,
TOOL_PMU__EVENT_USER_TIME = 2,
TOOL_PMU__EVENT_SYSTEM_TIME = 3,
PERF_TOOL_MAX,
TOOL_PMU__EVENT_MAX,
};
#define perf_tool_event__for_each_event(ev) \
for ((ev) = PERF_TOOL_DURATION_TIME; (ev) < PERF_TOOL_MAX; ev++)
for ((ev) = TOOL_PMU__EVENT_DURATION_TIME; (ev) < TOOL_PMU__EVENT_MAX; ev++)
static inline size_t tool_pmu__num_events(void)
{
return PERF_TOOL_MAX - 1;
return TOOL_PMU__EVENT_MAX - 1;
}
const char *perf_tool_event__to_str(enum perf_tool_event ev);
enum perf_tool_event perf_tool_event__from_str(const char *str);
const char *perf_tool_event__to_str(enum tool_pmu_event ev);
enum tool_pmu_event perf_tool_event__from_str(const char *str);
int tool_pmu__config_terms(struct perf_event_attr *attr,
struct parse_events_terms *terms,
struct parse_events_error *err);
@ -36,7 +36,7 @@ bool perf_pmu__is_tool(const struct perf_pmu *pmu);
bool evsel__is_tool(const struct evsel *evsel);
enum perf_tool_event evsel__tool_event(const struct evsel *evsel);
enum tool_pmu_event evsel__tool_event(const struct evsel *evsel);
const char *evsel__tool_pmu_event_name(const struct evsel *evsel);
int evsel__tool_pmu_prepare_open(struct evsel *evsel,
struct perf_cpu_map *cpus,