Merge tag 'perf-tools-for-v5.17-2022-01-16' of git://git.kernel.org/pub/scm/linux/kernel/git/acme/linux
Pull perf tool updates from Arnaldo Carvalho de Melo:
"New features:
- Add 'trace' subcommand for 'perf ftrace', setting the stage for
more 'perf ftrace' subcommands. Not using a subcommand yields the
previous behaviour of 'perf ftrace'.
- Add 'latency' subcommand to 'perf ftrace', that can use the
function graph tracer or a BPF optimized one, via the -b/--use-bpf
option.
E.g.:
$ sudo perf ftrace latency -a -T mutex_lock sleep 1
# DURATION | COUNT | GRAPH |
0 - 1 us | 4596 | ######################## |
1 - 2 us | 1680 | ######### |
2 - 4 us | 1106 | ##### |
4 - 8 us | 546 | ## |
8 - 16 us | 562 | ### |
16 - 32 us | 1 | |
32 - 64 us | 0 | |
64 - 128 us | 0 | |
128 - 256 us | 0 | |
256 - 512 us | 0 | |
512 - 1024 us | 0 | |
1 - 2 ms | 0 | |
2 - 4 ms | 0 | |
4 - 8 ms | 0 | |
8 - 16 ms | 0 | |
16 - 32 ms | 0 | |
32 - 64 ms | 0 | |
64 - 128 ms | 0 | |
128 - 256 ms | 0 | |
256 - 512 ms | 0 | |
512 - 1024 ms | 0 | |
1 - ... s | 0 | |
The original implementation of this command was in the bcc tool.
- Support --cputype option for hybrid events in 'perf stat'.
Improvements:
- Call chain improvements for ARM64.
- No need to do any affinity setup when profiling pids.
- Reduce multiplexing with duration_time in 'perf stat' metrics.
- Improve error message for uncore events, stating that some event
groups are can only be used in system wide (-a) mode.
- perf stat metric group leader fixes/improvements, including arch
specific changes to better support Intel topdown events.
- Probe non-deprecated sysfs path first, i.e. try the path
/sys/devices/system/cpu/cpuN/topology/thread_siblings first, then
the old /sys/devices/system/cpu/cpuN/topology/core_cpus.
- Disable debuginfod by default in 'perf record', to avoid stalls on
distros such as Fedora 35.
- Use unbuffered output in 'perf bench' when pipe/tee'ing to a file.
- Enable ignore_missing_thread in 'perf trace'
Fixes:
- Avoid TUI crash when navigating in the annotation of recursive
functions.
- Fix hex dump character output in 'perf script'.
- Fix JSON indentation to 4 spaces standard in the ARM vendor event
files.
- Fix use after free in metric__new().
- Fix IS_ERR_OR_NULL() usage in the perf BPF loader.
- Fix up cross-arch register support, i.e. when printing register
names take into account the architecture where the perf.data file
was collected.
- Fix SMT fallback with large core counts.
- Don't lower case MetricExpr when parsing JSON files so as not to
lose info such as the ":G" event modifier in metrics.
perf test:
- Add basic stress test for sigtrap handling to 'perf test'.
- Fix 'perf test' failures on s/390
- Enable system wide for metricgroups test in 'perf test´.
- Use 3 digits for test numbering now we can have more tests.
Arch specific:
- Add events for Arm Neoverse N2 in the ARM JSON vendor event files
- Support PERF_MEM_LVLNUM encodings in powerpc, that came from a
single patch series, where I incorrectly merged the kernel bits,
that were then reverted after coordination with Michael Ellerman
and Stephen Rothwell.
- Add ARM SPE total latency as PERF_SAMPLE_WEIGHT.
- Update AMD documentation, with info on raw event encoding.
- Add support for global and local variants of the "p_stage_cyc" sort
key, applicable to perf.data files collected on powerpc.
- Remove duplicate and incorrect aux size checks in the ARM CoreSight
ETM code.
Refactorings:
- Add a perf_cpu abstraction to disambiguate CPUs and CPU map
indexes, fixing problems along the way.
- Document CPU map methods.
UAPI sync:
- Update arch/x86/lib/mem{cpy,set}_64.S copies used in 'perf bench
mem memcpy'
- Sync UAPI files with the kernel sources: drm, msr-index,
cpufeatures.
Build system
- Enable warnings through HOSTCFLAGS.
- Drop requirement for libstdc++.so for libopencsd check
libperf:
- Make libperf adopt perf_counts_values__scale() from tools/perf/util/.
- Add a stat multiplexing test to libperf"
* tag 'perf-tools-for-v5.17-2022-01-16' of git://git.kernel.org/pub/scm/linux/kernel/git/acme/linux: (115 commits)
perf record: Disable debuginfod by default
perf evlist: No need to do any affinity setup when profiling pids
perf cpumap: Add is_dummy() method
perf metric: Fix metric_leader
perf cputopo: Fix CPU topology reading on s/390
perf metricgroup: Fix use after free in metric__new()
libperf tests: Update a use of the new cpumap API
perf arm: Fix off-by-one directory path
tools arch x86: Sync the msr-index.h copy with the kernel sources
tools headers cpufeatures: Sync with the kernel sources
tools headers UAPI: Update tools's copy of drm.h header
tools arch: Update arch/x86/lib/mem{cpy,set}_64.S copies used in 'perf bench mem memcpy'
perf pmu-events: Don't lower case MetricExpr
perf expr: Add debug logging for literals
perf tools: Probe non-deprecated sysfs path 1st
perf tools: Fix SMT fallback with large core counts
perf cpumap: Give CPUs their own type
perf stat: Correct first_shadow_cpu to return index
perf script: Fix flipped index and cpu
perf c2c: Use more intention revealing iterator
...
This commit is contained in:
Linus Torvalds
@@ -1372,9 +1372,9 @@ int evsel__append_addr_filter(struct evsel *evsel, const char *filter)
|
||||
}
|
||||
|
||||
/* Caller has to clear disabled after going through all CPUs. */
|
||||
int evsel__enable_cpu(struct evsel *evsel, int cpu)
|
||||
int evsel__enable_cpu(struct evsel *evsel, int cpu_map_idx)
|
||||
{
|
||||
return perf_evsel__enable_cpu(&evsel->core, cpu);
|
||||
return perf_evsel__enable_cpu(&evsel->core, cpu_map_idx);
|
||||
}
|
||||
|
||||
int evsel__enable(struct evsel *evsel)
|
||||
@@ -1387,9 +1387,9 @@ int evsel__enable(struct evsel *evsel)
|
||||
}
|
||||
|
||||
/* Caller has to set disabled after going through all CPUs. */
|
||||
int evsel__disable_cpu(struct evsel *evsel, int cpu)
|
||||
int evsel__disable_cpu(struct evsel *evsel, int cpu_map_idx)
|
||||
{
|
||||
return perf_evsel__disable_cpu(&evsel->core, cpu);
|
||||
return perf_evsel__disable_cpu(&evsel->core, cpu_map_idx);
|
||||
}
|
||||
|
||||
int evsel__disable(struct evsel *evsel)
|
||||
@@ -1455,7 +1455,7 @@ void evsel__delete(struct evsel *evsel)
|
||||
free(evsel);
|
||||
}
|
||||
|
||||
void evsel__compute_deltas(struct evsel *evsel, int cpu, int thread,
|
||||
void evsel__compute_deltas(struct evsel *evsel, int cpu_map_idx, int thread,
|
||||
struct perf_counts_values *count)
|
||||
{
|
||||
struct perf_counts_values tmp;
|
||||
@@ -1463,12 +1463,12 @@ void evsel__compute_deltas(struct evsel *evsel, int cpu, int thread,
|
||||
if (!evsel->prev_raw_counts)
|
||||
return;
|
||||
|
||||
if (cpu == -1) {
|
||||
if (cpu_map_idx == -1) {
|
||||
tmp = evsel->prev_raw_counts->aggr;
|
||||
evsel->prev_raw_counts->aggr = *count;
|
||||
} else {
|
||||
tmp = *perf_counts(evsel->prev_raw_counts, cpu, thread);
|
||||
*perf_counts(evsel->prev_raw_counts, cpu, thread) = *count;
|
||||
tmp = *perf_counts(evsel->prev_raw_counts, cpu_map_idx, thread);
|
||||
*perf_counts(evsel->prev_raw_counts, cpu_map_idx, thread) = *count;
|
||||
}
|
||||
|
||||
count->val = count->val - tmp.val;
|
||||
@@ -1476,46 +1476,28 @@ void evsel__compute_deltas(struct evsel *evsel, int cpu, int thread,
|
||||
count->run = count->run - tmp.run;
|
||||
}
|
||||
|
||||
void perf_counts_values__scale(struct perf_counts_values *count,
|
||||
bool scale, s8 *pscaled)
|
||||
static int evsel__read_one(struct evsel *evsel, int cpu_map_idx, int thread)
|
||||
{
|
||||
s8 scaled = 0;
|
||||
struct perf_counts_values *count = perf_counts(evsel->counts, cpu_map_idx, thread);
|
||||
|
||||
if (scale) {
|
||||
if (count->run == 0) {
|
||||
scaled = -1;
|
||||
count->val = 0;
|
||||
} else if (count->run < count->ena) {
|
||||
scaled = 1;
|
||||
count->val = (u64)((double) count->val * count->ena / count->run);
|
||||
}
|
||||
}
|
||||
|
||||
if (pscaled)
|
||||
*pscaled = scaled;
|
||||
return perf_evsel__read(&evsel->core, cpu_map_idx, thread, count);
|
||||
}
|
||||
|
||||
static int evsel__read_one(struct evsel *evsel, int cpu, int thread)
|
||||
{
|
||||
struct perf_counts_values *count = perf_counts(evsel->counts, cpu, thread);
|
||||
|
||||
return perf_evsel__read(&evsel->core, cpu, thread, count);
|
||||
}
|
||||
|
||||
static void evsel__set_count(struct evsel *counter, int cpu, int thread, u64 val, u64 ena, u64 run)
|
||||
static void evsel__set_count(struct evsel *counter, int cpu_map_idx, int thread,
|
||||
u64 val, u64 ena, u64 run)
|
||||
{
|
||||
struct perf_counts_values *count;
|
||||
|
||||
count = perf_counts(counter->counts, cpu, thread);
|
||||
count = perf_counts(counter->counts, cpu_map_idx, thread);
|
||||
|
||||
count->val = val;
|
||||
count->ena = ena;
|
||||
count->run = run;
|
||||
|
||||
perf_counts__set_loaded(counter->counts, cpu, thread, true);
|
||||
perf_counts__set_loaded(counter->counts, cpu_map_idx, thread, true);
|
||||
}
|
||||
|
||||
static int evsel__process_group_data(struct evsel *leader, int cpu, int thread, u64 *data)
|
||||
static int evsel__process_group_data(struct evsel *leader, int cpu_map_idx, int thread, u64 *data)
|
||||
{
|
||||
u64 read_format = leader->core.attr.read_format;
|
||||
struct sample_read_value *v;
|
||||
@@ -1534,7 +1516,7 @@ static int evsel__process_group_data(struct evsel *leader, int cpu, int thread,
|
||||
|
||||
v = (struct sample_read_value *) data;
|
||||
|
||||
evsel__set_count(leader, cpu, thread, v[0].value, ena, run);
|
||||
evsel__set_count(leader, cpu_map_idx, thread, v[0].value, ena, run);
|
||||
|
||||
for (i = 1; i < nr; i++) {
|
||||
struct evsel *counter;
|
||||
@@ -1543,13 +1525,13 @@ static int evsel__process_group_data(struct evsel *leader, int cpu, int thread,
|
||||
if (!counter)
|
||||
return -EINVAL;
|
||||
|
||||
evsel__set_count(counter, cpu, thread, v[i].value, ena, run);
|
||||
evsel__set_count(counter, cpu_map_idx, thread, v[i].value, ena, run);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int evsel__read_group(struct evsel *leader, int cpu, int thread)
|
||||
static int evsel__read_group(struct evsel *leader, int cpu_map_idx, int thread)
|
||||
{
|
||||
struct perf_stat_evsel *ps = leader->stats;
|
||||
u64 read_format = leader->core.attr.read_format;
|
||||
@@ -1570,67 +1552,67 @@ static int evsel__read_group(struct evsel *leader, int cpu, int thread)
|
||||
ps->group_data = data;
|
||||
}
|
||||
|
||||
if (FD(leader, cpu, thread) < 0)
|
||||
if (FD(leader, cpu_map_idx, thread) < 0)
|
||||
return -EINVAL;
|
||||
|
||||
if (readn(FD(leader, cpu, thread), data, size) <= 0)
|
||||
if (readn(FD(leader, cpu_map_idx, thread), data, size) <= 0)
|
||||
return -errno;
|
||||
|
||||
return evsel__process_group_data(leader, cpu, thread, data);
|
||||
return evsel__process_group_data(leader, cpu_map_idx, thread, data);
|
||||
}
|
||||
|
||||
int evsel__read_counter(struct evsel *evsel, int cpu, int thread)
|
||||
int evsel__read_counter(struct evsel *evsel, int cpu_map_idx, int thread)
|
||||
{
|
||||
u64 read_format = evsel->core.attr.read_format;
|
||||
|
||||
if (read_format & PERF_FORMAT_GROUP)
|
||||
return evsel__read_group(evsel, cpu, thread);
|
||||
return evsel__read_group(evsel, cpu_map_idx, thread);
|
||||
|
||||
return evsel__read_one(evsel, cpu, thread);
|
||||
return evsel__read_one(evsel, cpu_map_idx, thread);
|
||||
}
|
||||
|
||||
int __evsel__read_on_cpu(struct evsel *evsel, int cpu, int thread, bool scale)
|
||||
int __evsel__read_on_cpu(struct evsel *evsel, int cpu_map_idx, int thread, bool scale)
|
||||
{
|
||||
struct perf_counts_values count;
|
||||
size_t nv = scale ? 3 : 1;
|
||||
|
||||
if (FD(evsel, cpu, thread) < 0)
|
||||
if (FD(evsel, cpu_map_idx, thread) < 0)
|
||||
return -EINVAL;
|
||||
|
||||
if (evsel->counts == NULL && evsel__alloc_counts(evsel, cpu + 1, thread + 1) < 0)
|
||||
if (evsel->counts == NULL && evsel__alloc_counts(evsel) < 0)
|
||||
return -ENOMEM;
|
||||
|
||||
if (readn(FD(evsel, cpu, thread), &count, nv * sizeof(u64)) <= 0)
|
||||
if (readn(FD(evsel, cpu_map_idx, thread), &count, nv * sizeof(u64)) <= 0)
|
||||
return -errno;
|
||||
|
||||
evsel__compute_deltas(evsel, cpu, thread, &count);
|
||||
evsel__compute_deltas(evsel, cpu_map_idx, thread, &count);
|
||||
perf_counts_values__scale(&count, scale, NULL);
|
||||
*perf_counts(evsel->counts, cpu, thread) = count;
|
||||
*perf_counts(evsel->counts, cpu_map_idx, thread) = count;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int evsel__match_other_cpu(struct evsel *evsel, struct evsel *other,
|
||||
int cpu)
|
||||
int cpu_map_idx)
|
||||
{
|
||||
int cpuid;
|
||||
struct perf_cpu cpu;
|
||||
|
||||
cpuid = perf_cpu_map__cpu(evsel->core.cpus, cpu);
|
||||
return perf_cpu_map__idx(other->core.cpus, cpuid);
|
||||
cpu = perf_cpu_map__cpu(evsel->core.cpus, cpu_map_idx);
|
||||
return perf_cpu_map__idx(other->core.cpus, cpu);
|
||||
}
|
||||
|
||||
static int evsel__hybrid_group_cpu(struct evsel *evsel, int cpu)
|
||||
static int evsel__hybrid_group_cpu_map_idx(struct evsel *evsel, int cpu_map_idx)
|
||||
{
|
||||
struct evsel *leader = evsel__leader(evsel);
|
||||
|
||||
if ((evsel__is_hybrid(evsel) && !evsel__is_hybrid(leader)) ||
|
||||
(!evsel__is_hybrid(evsel) && evsel__is_hybrid(leader))) {
|
||||
return evsel__match_other_cpu(evsel, leader, cpu);
|
||||
return evsel__match_other_cpu(evsel, leader, cpu_map_idx);
|
||||
}
|
||||
|
||||
return cpu;
|
||||
return cpu_map_idx;
|
||||
}
|
||||
|
||||
static int get_group_fd(struct evsel *evsel, int cpu, int thread)
|
||||
static int get_group_fd(struct evsel *evsel, int cpu_map_idx, int thread)
|
||||
{
|
||||
struct evsel *leader = evsel__leader(evsel);
|
||||
int fd;
|
||||
@@ -1644,11 +1626,11 @@ static int get_group_fd(struct evsel *evsel, int cpu, int thread)
|
||||
*/
|
||||
BUG_ON(!leader->core.fd);
|
||||
|
||||
cpu = evsel__hybrid_group_cpu(evsel, cpu);
|
||||
if (cpu == -1)
|
||||
cpu_map_idx = evsel__hybrid_group_cpu_map_idx(evsel, cpu_map_idx);
|
||||
if (cpu_map_idx == -1)
|
||||
return -1;
|
||||
|
||||
fd = FD(leader, cpu, thread);
|
||||
fd = FD(leader, cpu_map_idx, thread);
|
||||
BUG_ON(fd == -1);
|
||||
|
||||
return fd;
|
||||
@@ -1662,16 +1644,16 @@ static void evsel__remove_fd(struct evsel *pos, int nr_cpus, int nr_threads, int
|
||||
}
|
||||
|
||||
static int update_fds(struct evsel *evsel,
|
||||
int nr_cpus, int cpu_idx,
|
||||
int nr_cpus, int cpu_map_idx,
|
||||
int nr_threads, int thread_idx)
|
||||
{
|
||||
struct evsel *pos;
|
||||
|
||||
if (cpu_idx >= nr_cpus || thread_idx >= nr_threads)
|
||||
if (cpu_map_idx >= nr_cpus || thread_idx >= nr_threads)
|
||||
return -EINVAL;
|
||||
|
||||
evlist__for_each_entry(evsel->evlist, pos) {
|
||||
nr_cpus = pos != evsel ? nr_cpus : cpu_idx;
|
||||
nr_cpus = pos != evsel ? nr_cpus : cpu_map_idx;
|
||||
|
||||
evsel__remove_fd(pos, nr_cpus, nr_threads, thread_idx);
|
||||
|
||||
@@ -1685,10 +1667,10 @@ static int update_fds(struct evsel *evsel,
|
||||
return 0;
|
||||
}
|
||||
|
||||
bool evsel__ignore_missing_thread(struct evsel *evsel,
|
||||
int nr_cpus, int cpu,
|
||||
struct perf_thread_map *threads,
|
||||
int thread, int err)
|
||||
static bool evsel__ignore_missing_thread(struct evsel *evsel,
|
||||
int nr_cpus, int cpu_map_idx,
|
||||
struct perf_thread_map *threads,
|
||||
int thread, int err)
|
||||
{
|
||||
pid_t ignore_pid = perf_thread_map__pid(threads, thread);
|
||||
|
||||
@@ -1711,7 +1693,7 @@ bool evsel__ignore_missing_thread(struct evsel *evsel,
|
||||
* We should remove fd for missing_thread first
|
||||
* because thread_map__remove() will decrease threads->nr.
|
||||
*/
|
||||
if (update_fds(evsel, nr_cpus, cpu, threads->nr, thread))
|
||||
if (update_fds(evsel, nr_cpus, cpu_map_idx, threads->nr, thread))
|
||||
return false;
|
||||
|
||||
if (thread_map__remove(threads, thread))
|
||||
@@ -1993,9 +1975,9 @@ bool evsel__increase_rlimit(enum rlimit_action *set_rlimit)
|
||||
|
||||
static int evsel__open_cpu(struct evsel *evsel, struct perf_cpu_map *cpus,
|
||||
struct perf_thread_map *threads,
|
||||
int start_cpu, int end_cpu)
|
||||
int start_cpu_map_idx, int end_cpu_map_idx)
|
||||
{
|
||||
int cpu, thread, nthreads;
|
||||
int idx, thread, nthreads;
|
||||
int pid = -1, err, old_errno;
|
||||
enum rlimit_action set_rlimit = NO_CHANGE;
|
||||
|
||||
@@ -2022,7 +2004,7 @@ fallback_missing_features:
|
||||
|
||||
display_attr(&evsel->core.attr);
|
||||
|
||||
for (cpu = start_cpu; cpu < end_cpu; cpu++) {
|
||||
for (idx = start_cpu_map_idx; idx < end_cpu_map_idx; idx++) {
|
||||
|
||||
for (thread = 0; thread < nthreads; thread++) {
|
||||
int fd, group_fd;
|
||||
@@ -2033,17 +2015,17 @@ retry_open:
|
||||
if (!evsel->cgrp && !evsel->core.system_wide)
|
||||
pid = perf_thread_map__pid(threads, thread);
|
||||
|
||||
group_fd = get_group_fd(evsel, cpu, thread);
|
||||
group_fd = get_group_fd(evsel, idx, thread);
|
||||
|
||||
test_attr__ready();
|
||||
|
||||
pr_debug2_peo("sys_perf_event_open: pid %d cpu %d group_fd %d flags %#lx",
|
||||
pid, cpus->map[cpu], group_fd, evsel->open_flags);
|
||||
pid, cpus->map[idx].cpu, group_fd, evsel->open_flags);
|
||||
|
||||
fd = sys_perf_event_open(&evsel->core.attr, pid, cpus->map[cpu],
|
||||
fd = sys_perf_event_open(&evsel->core.attr, pid, cpus->map[idx].cpu,
|
||||
group_fd, evsel->open_flags);
|
||||
|
||||
FD(evsel, cpu, thread) = fd;
|
||||
FD(evsel, idx, thread) = fd;
|
||||
|
||||
if (fd < 0) {
|
||||
err = -errno;
|
||||
@@ -2053,10 +2035,10 @@ retry_open:
|
||||
goto try_fallback;
|
||||
}
|
||||
|
||||
bpf_counter__install_pe(evsel, cpu, fd);
|
||||
bpf_counter__install_pe(evsel, idx, fd);
|
||||
|
||||
if (unlikely(test_attr__enabled)) {
|
||||
test_attr__open(&evsel->core.attr, pid, cpus->map[cpu],
|
||||
test_attr__open(&evsel->core.attr, pid, cpus->map[idx],
|
||||
fd, group_fd, evsel->open_flags);
|
||||
}
|
||||
|
||||
@@ -2097,7 +2079,7 @@ try_fallback:
|
||||
if (evsel__precise_ip_fallback(evsel))
|
||||
goto retry_open;
|
||||
|
||||
if (evsel__ignore_missing_thread(evsel, cpus->nr, cpu, threads, thread, err)) {
|
||||
if (evsel__ignore_missing_thread(evsel, cpus->nr, idx, threads, thread, err)) {
|
||||
/* We just removed 1 thread, so lower the upper nthreads limit. */
|
||||
nthreads--;
|
||||
|
||||
@@ -2112,7 +2094,7 @@ try_fallback:
|
||||
if (err == -EMFILE && evsel__increase_rlimit(&set_rlimit))
|
||||
goto retry_open;
|
||||
|
||||
if (err != -EINVAL || cpu > 0 || thread > 0)
|
||||
if (err != -EINVAL || idx > 0 || thread > 0)
|
||||
goto out_close;
|
||||
|
||||
if (evsel__detect_missing_features(evsel))
|
||||
@@ -2124,12 +2106,12 @@ out_close:
|
||||
old_errno = errno;
|
||||
do {
|
||||
while (--thread >= 0) {
|
||||
if (FD(evsel, cpu, thread) >= 0)
|
||||
close(FD(evsel, cpu, thread));
|
||||
FD(evsel, cpu, thread) = -1;
|
||||
if (FD(evsel, idx, thread) >= 0)
|
||||
close(FD(evsel, idx, thread));
|
||||
FD(evsel, idx, thread) = -1;
|
||||
}
|
||||
thread = nthreads;
|
||||
} while (--cpu >= 0);
|
||||
} while (--idx >= 0);
|
||||
errno = old_errno;
|
||||
return err;
|
||||
}
|
||||
@@ -2146,13 +2128,13 @@ void evsel__close(struct evsel *evsel)
|
||||
perf_evsel__free_id(&evsel->core);
|
||||
}
|
||||
|
||||
int evsel__open_per_cpu(struct evsel *evsel, struct perf_cpu_map *cpus, int cpu)
|
||||
int evsel__open_per_cpu(struct evsel *evsel, struct perf_cpu_map *cpus, int cpu_map_idx)
|
||||
{
|
||||
if (cpu == -1)
|
||||
if (cpu_map_idx == -1)
|
||||
return evsel__open_cpu(evsel, cpus, NULL, 0,
|
||||
cpus ? cpus->nr : 1);
|
||||
|
||||
return evsel__open_cpu(evsel, cpus, NULL, cpu, cpu + 1);
|
||||
return evsel__open_cpu(evsel, cpus, NULL, cpu_map_idx, cpu_map_idx + 1);
|
||||
}
|
||||
|
||||
int evsel__open_per_thread(struct evsel *evsel, struct perf_thread_map *threads)
|
||||
@@ -2952,6 +2934,10 @@ int evsel__open_strerror(struct evsel *evsel, struct target *target,
|
||||
return scnprintf(msg, size, "wrong clockid (%d).", clockid);
|
||||
if (perf_missing_features.aux_output)
|
||||
return scnprintf(msg, size, "The 'aux_output' feature is not supported, update the kernel.");
|
||||
if (!target__has_cpu(target))
|
||||
return scnprintf(msg, size,
|
||||
"Invalid event (%s) in per-thread mode, enable system wide with '-a'.",
|
||||
evsel__name(evsel));
|
||||
break;
|
||||
case ENODATA:
|
||||
return scnprintf(msg, size, "Cannot collect data source with the load latency event alone. "
|
||||
@@ -2975,15 +2961,15 @@ struct perf_env *evsel__env(struct evsel *evsel)
|
||||
|
||||
static int store_evsel_ids(struct evsel *evsel, struct evlist *evlist)
|
||||
{
|
||||
int cpu, thread;
|
||||
int cpu_map_idx, thread;
|
||||
|
||||
for (cpu = 0; cpu < xyarray__max_x(evsel->core.fd); cpu++) {
|
||||
for (cpu_map_idx = 0; cpu_map_idx < xyarray__max_x(evsel->core.fd); cpu_map_idx++) {
|
||||
for (thread = 0; thread < xyarray__max_y(evsel->core.fd);
|
||||
thread++) {
|
||||
int fd = FD(evsel, cpu, thread);
|
||||
int fd = FD(evsel, cpu_map_idx, thread);
|
||||
|
||||
if (perf_evlist__id_add_fd(&evlist->core, &evsel->core,
|
||||
cpu, thread, fd) < 0)
|
||||
cpu_map_idx, thread, fd) < 0)
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user