Optimize perf stat for large number of events/cpus
PATCH v7 1/12 perf pmu: Use file system cache to optimize sysfs access
In reply to Andi KleenFrom: Andi Kleen <[email protected]>
pmu.c does a lot of redundant /sys accesses while parsing aliases and probing for PMUs. On large systems with a lot of PMUs this can get expensive (>2s):
% time seconds usecs/call calls errors syscall
------ ----------- ----------- --------- --------- ----------------
27.25 1.227847 8 160888 16976 openat 26.42 1.190481 7 164224 164077 stat
Add a cache to remember if specific file names exist or don't exist, which eliminates most of this overhead.
Also optimize some stat() calls to be slightly cheaper access()
Resulting in:
0.18 0.004166 2 1851 305 open 0.08 0.001970 2 829 622 access
---
v2: Use single lookup function as API (Jiri)
--- tools/perf/util/Build | 1 + tools/perf/util/fncache.c | 63 +++++++++++++++++++++++++++++++++++++++ tools/perf/util/fncache.h | 7 +++++ tools/perf/util/pmu.c | 34 +++++++-------------- tools/perf/util/srccode.c | 9 +----- 5 files changed, 83 insertions(+), 31 deletions(-) create mode 100644 tools/perf/util/fncache.c create mode 100644 tools/perf/util/fncache.h
tools/perf/util/Build +1 -0
@@ -49,6 +49,7 @@ perf-y += header.o perf-y += callchain.o perf-y += values.o perf-y += debug.o +perf-y += fncache.o perf-y += machine.o perf-y += map.o perf-y += pstack.o
tools/perf/util/fncache.c new file +63 -0
63 lines not on this page · raw message
tools/perf/util/fncache.h new file +7 -0
@@ -0,0 +1,7 @@ +#ifndef _FCACHE_H +#define _FCACHE_H 1 + +unsigned shash (const unsigned char *s); +bool file_available (const char *name); + +#endif
tools/perf/util/pmu.c +11 -23
@@ -24,6 +24,7 @@#include "pmu-events/pmu-events.h" #include "string2.h" #include "strbuf.h" +#include "fncache.h" struct perf_pmu_format {char *name;
@@ -82,7 +83,6 @@ int perf_pmu__format_parse(char *dir, struct list_head *head)*/ static int pmu_format (const char *name,struct list_head *format) { -struct stat st;char path[PATH_MAX ];const char *sysfs =sysfs__mountpoint ();
@@ -92,8 +92,8 @@ static int pmu_format(const char *name, struct list_head *format)snprintf (path,PATH_MAX ,"%s" EVENT_SOURCE_DEVICE_PATH "%s/format" , sysfs, name); -if (stat (path, &st) <0 ) -return 0 ;/* no error if format does not exist */ +if (!file_available (path)) +return 0 ;if (perf_pmu__format_parse (path, format))return -1 ;
@@ -475,7 +475,6 @@ static int pmu_aliases_parse(char *dir, struct list_head *head)*/ static int pmu_aliases (const char *name,struct list_head *head) { -struct stat st;char path[PATH_MAX ];const char *sysfs =sysfs__mountpoint ();
@@ -485,8 +484,8 @@ static int pmu_aliases(const char *name, struct list_head *head)snprintf (path,PATH_MAX ,"%s/bus/event_source/devices/%s/events" , sysfs, name); -if (stat (path, &st) <0 ) -return 0 ;/* no error if 'events' does not exist */ +if (!file_available (path)) +return 0 ;if (pmu_aliases_parse (path, head))return -1 ;
@@ -525,7 +524,6 @@ static int pmu_alias_terms(struct perf_pmu_alias *alias,*/ static int pmu_type (const char *name,__u32 *type) { -struct stat st;char path[PATH_MAX ];FILE *file;int ret =0 ;
@@ -537,7 +535,7 @@ static int pmu_type(const char *name, __u32 *type)snprintf (path,PATH_MAX ,"%s" EVENT_SOURCE_DEVICE_PATH "%s/type" , sysfs, name); -if (stat (path, &st) <0 ) +if (access (path,R_OK ) <0 )return -1 ; file =fopen (path,"r" );
@@ -628,14 +626,11 @@ static struct perf_cpu_map *pmu_cpumask(const char *name)static bool pmu_is_uncore (const char *name) {char path[PATH_MAX ]; -struct perf_cpu_map *cpus; -const char *sysfs =sysfs__mountpoint (); +const char *sysfs; + sysfs =sysfs__mountpoint ();snprintf (path,PATH_MAX ,CPUS_TEMPLATE_UNCORE , sysfs, name); - cpus =__pmu_cpumask (path); -perf_cpu_map__put (cpus); - -return !!cpus; +return file_available (path); }/*
@@ -645,7 +640,6 @@ static bool pmu_is_uncore(const char *name)*/ static int is_arm_pmu_core (const char *name) { -struct stat st;char path[PATH_MAX ];const char *sysfs =sysfs__mountpoint ();
@@ -655,10 +649,7 @@ static int is_arm_pmu_core(const char *name)/* Look for cpu sysfs (specific to arm) */ scnprintf (path,PATH_MAX ,"%s/bus/event_source/devices/%s/cpus" , sysfs, name); -if (stat (path, &st) ==0 ) -return 1 ; - -return 0 ; +return file_available (path); }static char *perf_pmu__getcpuid (struct perf_pmu *pmu)
@@ -1534,7 +1525,6 @@ bool pmu_have_event(const char *pname, const char *name)static FILE *perf_pmu__open_file (struct perf_pmu *pmu,const char *name) { -struct stat st;char path[PATH_MAX ];const char *sysfs;
@@ -1544,10 +1534,8 @@ static FILE *perf_pmu__open_file(struct perf_pmu *pmu, const char *name)snprintf (path,PATH_MAX ,"%s" EVENT_SOURCE_DEVICE_PATH "%s/%s" , sysfs, pmu->name, name); - -if (stat (path, &st) <0 ) +if (!file_available (path))return NULL ; -return fopen (path,"r" ); }
tools/perf/util/srccode.c +1 -8
@@ -16,6 +16,7 @@#include "srccode.h" #include "debug.h" #include <internal/lib.h> // page_size +#include "fncache.h" #define MAXSRCCACHE (32*1024*1024)#define MAXSRCFILES 64
@@ -36,14 +37,6 @@ static LIST_HEAD(srcfile_list);static long map_total_sz;static int num_srcfiles; -static unsigned shash (unsigned char *s) -{ -unsigned h =0 ; -while (*s) - h =65599 * h + *s++; -return h ^ (h >>16 ); -} -static int countlines (char *map,int maplen) {int numl;
Signature · 1 line
2.23.0
PATCH v7 11/12 perf evsel: Add functions to enable/disable for a specific CPU
In reply to Andi KleenFrom: Andi Kleen <[email protected]>
Refactor the existing functions to use these functions internally.
Used in the next patch
---
v2: Use NULL instead of 0
--- tools/perf/lib/evsel.c | 49 +++++++++++++++++++++-------- tools/perf/lib/include/perf/evsel.h | 2 ++ tools/perf/util/evsel.c | 13 +++++++- tools/perf/util/evsel.h | 2 ++ 4 files changed, 52 insertions(+), 14 deletions(-)
tools/perf/lib/evsel.c +36 -13
@@ -198,38 +198,61 @@ int perf_evsel__read(struct perf_evsel *evsel, int cpu, int thread, }static int perf_evsel__run_ioctl (struct perf_evsel *evsel, -int ioc,void *arg) +int ioc,void *arg, +int cpu) { -int cpu, thread; +int thread; -for (cpu =0 ; cpu <xyarray__max_x (evsel->fd); cpu++) { -for (thread =0 ; thread <xyarray__max_y (evsel->fd); thread++) { -int fd =FD (evsel, cpu, thread), - err =ioctl (fd, ioc, arg); +for (thread =0 ; thread <xyarray__max_y (evsel->fd); thread++) { +int fd =FD (evsel, cpu, thread), + err =ioctl (fd, ioc, arg); -if (err) -return err; - } +if (err) +return err; }return 0 ; } +int perf_evsel__enable_cpu (struct perf_evsel *evsel,int cpu) +{ +return perf_evsel__run_ioctl (evsel,PERF_EVENT_IOC_ENABLE ,NULL , cpu); +} +int perf_evsel__enable (struct perf_evsel *evsel) { -return perf_evsel__run_ioctl (evsel,PERF_EVENT_IOC_ENABLE ,0 ); +int i; +int err =0 ; + +for (i =0 ; i < evsel->cpus->nr && !err; i++) + err =perf_evsel__run_ioctl (evsel,PERF_EVENT_IOC_ENABLE ,NULL , i); +return err; +} + +int perf_evsel__disable_cpu (struct perf_evsel *evsel,int cpu) +{ +return perf_evsel__run_ioctl (evsel,PERF_EVENT_IOC_DISABLE ,NULL , cpu); }int perf_evsel__disable (struct perf_evsel *evsel) { -return perf_evsel__run_ioctl (evsel,PERF_EVENT_IOC_DISABLE ,0 ); +int i; +int err =0 ; + +for (i =0 ; i < evsel->cpus->nr && !err; i++) + err =perf_evsel__run_ioctl (evsel,PERF_EVENT_IOC_DISABLE ,NULL , i); +return err; }int perf_evsel__apply_filter (struct perf_evsel *evsel,const char *filter) { -return perf_evsel__run_ioctl (evsel, +int err =0 , i; + +for (i =0 ; i < evsel->cpus->nr && !err; i++) + err =perf_evsel__run_ioctl (evsel,PERF_EVENT_IOC_SET_FILTER , - (void *)filter); + (void *)filter, i); +return err; }struct perf_cpu_map *perf_evsel__cpus (struct perf_evsel *evsel)
tools/perf/lib/include/perf/evsel.h +2 -0
@@ -30,7 +30,9 @@ LIBPERF_API void perf_evsel__close_cpu(struct perf_evsel *evsel, int cpu); LIBPERF_API int perf_evsel__read(struct perf_evsel *evsel, int cpu, int thread,struct perf_counts_values *count); LIBPERF_API int perf_evsel__enable(struct perf_evsel *evsel); +LIBPERF_API int perf_evsel__enable_cpu(struct perf_evsel *evsel, int cpu); LIBPERF_API int perf_evsel__disable(struct perf_evsel *evsel); +LIBPERF_API int perf_evsel__disable_cpu(struct perf_evsel *evsel, int cpu); LIBPERF_API struct perf_cpu_map *perf_evsel__cpus(struct perf_evsel *evsel); LIBPERF_API struct perf_thread_map *perf_evsel__threads(struct perf_evsel *evsel); LIBPERF_API struct perf_event_attr *perf_evsel__attr(struct perf_evsel *evsel);
tools/perf/util/evsel.c +12 -1
@@ -1205,16 +1205,27 @@ int perf_evsel__append_addr_filter(struct evsel *evsel, const char *filter)return perf_evsel__append_filter (evsel,"%s,%s" , filter); } +/* Caller has to clear disabled after going through all CPUs. */ +int evsel__enable_cpu (struct evsel *evsel,int cpu) +{ +return perf_evsel__enable_cpu (&evsel->core, cpu); +} +int evsel__enable (struct evsel *evsel) {int err =perf_evsel__enable (&evsel->core);if (!err) evsel->disabled = false; -return err; } +/* Caller has to set disabled after going through all CPUs. */ +int evsel__disable_cpu (struct evsel *evsel,int cpu) +{ +return perf_evsel__disable_cpu (&evsel->core, cpu); +} +int evsel__disable (struct evsel *evsel) {int err =perf_evsel__disable (&evsel->core);
tools/perf/util/evsel.h +2 -0
@@ -222,8 +222,10 @@ int perf_evsel__set_filter(struct evsel *evsel, const char *filter);int perf_evsel__append_tp_filter (struct evsel *evsel,const char *filter);int perf_evsel__append_addr_filter (struct evsel *evsel,const char *filter); +int evsel__enable_cpu (struct evsel *evsel,int cpu);int evsel__enable (struct evsel *evsel);int evsel__disable (struct evsel *evsel); +int evsel__disable_cpu (struct evsel *evsel,int cpu); int perf_evsel__open_per_cpu(struct evsel *evsel, struct perf_cpu_map *cpus,
Signature · 1 line
2.23.0
PATCH v7 8/12 perf stat: Factor out open error handling
In reply to Andi KleenFrom: Andi Kleen <[email protected]>
Factor out the open error handling into a separate function. This is useful for followon patches who need to duplicate this.
No behavior change intended.
--- tools/perf/builtin-stat.c | 100 +++++++++++++++++++++++--------------- 1 file changed, 60 insertions(+), 40 deletions(-)
tools/perf/builtin-stat.c +60 -40
@@ -420,6 +420,57 @@ static bool is_target_alive(struct target *_target,return false; } +enum counter_recovery { +COUNTER_SKIP , +COUNTER_RETRY , +COUNTER_FATAL , +}; + +static enum counter_recovery stat_handle_error (struct evsel *counter) +{ +char msg[BUFSIZ ]; +/* +* PPC returns ENXIO for HW counters until 2.6.37 +* (behavior changed with commit b0a873e). +*/ +if (errno ==EINVAL || errno ==ENOSYS || + errno ==ENOENT || errno ==EOPNOTSUPP || + errno ==ENXIO ) { +if (verbose >0 ) +ui__warning ("%s event is not supported by the kernel.\n" , +perf_evsel__name (counter)); + counter->supported = false; + +if ((counter->leader != counter) || + !(counter->leader->core.nr_members >1 )) +return COUNTER_SKIP ; + }else if (perf_evsel__fallback (counter, errno, msg,sizeof (msg))) { +if (verbose >0 ) +ui__warning ("%s\n" , msg); +return COUNTER_RETRY ; + }else if (target__has_per_thread (&target) && + evsel_list->core.threads && + evsel_list->core.threads->err_thread !=-1 ) { +/* +* For global --per-thread case, skip current +* error thread. +*/ +if (!thread_map__remove (evsel_list->core.threads, + evsel_list->core.threads->err_thread)) { + evsel_list->core.threads->err_thread =-1 ; +return COUNTER_RETRY ; + } + } + +perf_evsel__open_strerror (counter, &target, + errno, msg,sizeof (msg)); +ui__error ("%s\n" , msg); + +if (child_pid !=-1 ) +kill (child_pid,SIGTERM ); +return COUNTER_FATAL ; +} +static int __run_perf_stat (int argc,const char **argv,int run_idx) {int interval = stat_config.interval;
@@ -469,47 +520,16 @@ static int __run_perf_stat(int argc, const char **argv, int run_idx) goto try_again; } -/* -* PPC returns ENXIO for HW counters until 2.6.37 -* (behavior changed with commit b0a873e). -*/ -if (errno ==EINVAL || errno ==ENOSYS || - errno ==ENOENT || errno ==EOPNOTSUPP || - errno ==ENXIO ) { -if (verbose >0 ) -ui__warning ("%s event is not supported by the kernel.\n" , -perf_evsel__name (counter)); - counter->supported = false; - -if ((counter->leader != counter) || - !(counter->leader->core.nr_members >1 )) -continue ; - }else if (perf_evsel__fallback (counter, errno, msg,sizeof (msg))) { -if (verbose >0 ) -ui__warning ("%s\n" , msg); - goto try_again; - }else if (target__has_per_thread (&target) && - evsel_list->core.threads && - evsel_list->core.threads->err_thread !=-1 ) { -/* -* For global --per-thread case, skip current -* error thread. -*/ -if (!thread_map__remove (evsel_list->core.threads, - evsel_list->core.threads->err_thread)) { - evsel_list->core.threads->err_thread =-1 ; - goto try_again; - } +switch (stat_handle_error (counter)) { +case COUNTER_FATAL : +return -1 ; +case COUNTER_RETRY : + goto try_again; +case COUNTER_SKIP : +continue ; +default : +break ; } - -perf_evsel__open_strerror (counter, &target, - errno, msg,sizeof (msg)); -ui__error ("%s\n" , msg); - -if (child_pid !=-1 ) -kill (child_pid,SIGTERM ); - -return -1 ; } counter->supported = true;
Signature · 1 line
2.23.0
[v7: Address review feedback. Fix python script problem reported by 0day. Drop merged patches.]
This patch kit optimizes perf stat for a large number of events on systems with many CPUs and PMUs.
Some profiling shows that the most overhead is doing IPIs to all the target CPUs. We can optimize this by using sched_setaffinity to set the affinity to a target CPU once and then doing the perf operation for all events on that CPU. This requires some restructuring, but cuts the set up time quite a bit.
In theory we could go further by parallelizing these setups too, but that would be much more complicated and for now just batching it per CPU seems to be sufficient. At some point with many more cores parallelization or a better bulk perf setup API might be needed though.
In addition perf does a lot of redundant /sys accesses with many PMUs, which can be also expensve. This is also optimized.
On a large test case (>700 events with many weak groups) on a 94 CPU system I go from
real 0m8.607s
user 0m0.550s
sys 0m8.041s
to
real 0m3.269s
user 0m0.760s
sys 0m1.694s
so shaving ~6 seconds of system time, at slightly more cost in perf stat itself. On a 4 socket system with the savings are more dramatic:
real 0m15.641s
user 0m0.873s
sys 0m14.729s
to
real 0m4.493s
user 0m1.578s
sys 0m2.444s
so 11s difference in the user visible set up time.
Also available in
git://git.kernel.org/pub/scm/linux/kernel/git/ak/linux-misc perf/stat-scale-10
v1: Initial post.
v2: Rebase. Fix some minor issues.
v3: Rebase. Address review feedback. Fix one minor issue
v4: Modified based on review feedback. Now it maintains all_cpus per evlist. There is still a need for cpu_index iteration to get the correct index for indexing the file descriptors. Fix bug with unsorted cpu maps, now they are always sorted. Some cleanups and refactoring.
v5: Split patches. Redo loop iteration again. Fix cpu map merging for uncore. Remove duplicates from cpumaps. Add unit tests.
v6: Address review feedback. Fix some bugs. Add more comments. Merge one invalid patch split.
v7: Address review feedback. Fix python scripting (thanks 0day) Minor updates.
-Andi
PATCH v7 10/12 perf stat: Use affinity for reading
From: Andi Kleen <[email protected]>
Restructure event reading to use affinity to minimize the number of IPIs needed.
Before on a large test case with 94 CPUs:
% time seconds usecs/call calls errors syscall
------ ----------- ----------- --------- --------- ----------------
3.16 0.106079 4 22082 read
After:
3.43 0.081295 3 22082 read
---
v2: Use new iterator macros
v3: Use new iterator macros
v4: Change iterator macros even more
v5: Preserve counter->err in all cases
v6: Rename read_counter -> read_counter_cpu
--- tools/perf/builtin-stat.c | 96 ++++++++++++++++++++++----------------- tools/perf/util/evsel.h | 1 + 2 files changed, 56 insertions(+), 41 deletions(-)
tools/perf/builtin-stat.c +55 -41
@@ -266,15 +266,10 @@ static int read_single_counter(struct evsel *counter, int cpu,* Read out the results of a single counter: * do not aggregate counts across CPUs in system-wide mode */ -static int read_counter (struct evsel *counter,struct timespec *rs) +static int read_counter_cpu (struct evsel *counter,struct timespec *rs,int cpu) {int nthreads =perf_thread_map__nr (evsel_list->core.threads); -int ncpus, cpu, thread; - -if (target__has_cpu (&target) && !target__has_per_thread (&target)) - ncpus =perf_evsel__nr_cpus (counter); -else - ncpus =1 ; +int thread;if (!counter->supported)return -ENOENT ;
@@ -283,40 +278,38 @@ static int read_counter(struct evsel *counter, struct timespec *rs) nthreads =1 ;for (thread =0 ; thread < nthreads; thread++) { -for (cpu =0 ; cpu < ncpus; cpu++) { -struct perf_counts_values *count; - - count =perf_counts (counter->counts, cpu, thread); - -/* -* The leader's group read loads data into its group members -* (via perf_evsel__read_counter) and sets threir count->loaded. -*/ -if (!perf_counts__is_loaded (counter->counts, cpu, thread) && -read_single_counter (counter, cpu, thread, rs)) { - counter->counts->scaled =-1 ; -perf_counts (counter->counts, cpu, thread)->ena =0 ; -perf_counts (counter->counts, cpu, thread)->run =0 ; -return -1 ; - } +struct perf_counts_values *count; -perf_counts__set_loaded (counter->counts, cpu, thread, false); + count =perf_counts (counter->counts, cpu, thread); -if (STAT_RECORD ) { -if (perf_evsel__write_stat_event (counter, cpu, thread, count)) { -pr_err ("failed to write stat event\n" ); -return -1 ; - } - } +/* +* The leader's group read loads data into its group members +* (via perf_evsel__read_counter) and sets threir count->loaded. +*/ +if (!perf_counts__is_loaded (counter->counts, cpu, thread) && +read_single_counter (counter, cpu, thread, rs)) { + counter->counts->scaled =-1 ; +perf_counts (counter->counts, cpu, thread)->ena =0 ; +perf_counts (counter->counts, cpu, thread)->run =0 ; +return -1 ; + } + +perf_counts__set_loaded (counter->counts, cpu, thread, false); -if (verbose >1 ) { -fprintf (stat_config.output, -"%s: %d: %" PRIu64" %" PRIu64" %" PRIu64"\n" , -perf_evsel__name (counter), - cpu, - count->val, count->ena, count->run); +if (STAT_RECORD ) { +if (perf_evsel__write_stat_event (counter, cpu, thread, count)) { +pr_err ("failed to write stat event\n" ); +return -1 ; } } + +if (verbose >1 ) { +fprintf (stat_config.output, +"%s: %d: %" PRIu64" %" PRIu64" %" PRIu64"\n" , +perf_evsel__name (counter), + cpu, + count->val, count->ena, count->run); + } }return 0 ;
@@ -325,15 +318,36 @@ static int read_counter(struct evsel *counter, struct timespec *rs)static void read_counters (struct timespec *rs) {struct evsel *counter; -int ret; +struct affinity affinity; +int i, ncpus, cpu; + +if (affinity__setup (&affinity) <0 ) +return ; + + ncpus = evsel_list->core.all_cpus->nr; +if (!target__has_cpu (&target) ||target__has_per_thread (&target)) + ncpus =1 ; + evlist__for_each_cpu (evsel_list, i, cpu) { +if (i >= ncpus) +break ; +affinity__set (&affinity, cpu); + +evlist__for_each_entry (evsel_list, counter) { +if (evsel__cpu_iter_skip (counter, cpu)) +continue ; +if (!counter->err) + counter->err =read_counter_cpu (counter, rs, + counter->cpu_iter -1 ); + } + } +affinity__cleanup (&affinity);evlist__for_each_entry (evsel_list, counter) { - ret =read_counter (counter, rs); -if (ret) +if (counter->err)pr_debug ("failed to read counter %s\n" , counter->name); - -if (ret ==0 &&perf_stat_process_counter (&stat_config, counter)) +if (counter->err ==0 &&perf_stat_process_counter (&stat_config, counter))pr_warning ("failed to process counter %s\n" , counter->name); + counter->err =0 ; } }
tools/perf/util/evsel.h +1 -0
@@ -86,6 +86,7 @@ struct evsel {struct list_head config_terms;struct bpf_object *bpf_obj;int bpf_fd; +int err;bool auto_merge_stats;bool merged_stat;const char * metric_expr;
Signature · 1 line
2.23.0
PATCH v7 9/12 perf stat: Use affinity for opening events
In reply to Andi KleenFrom: Andi Kleen <[email protected]>
Restructure the event opening in perf stat to cycle through the events by CPU after setting affinity to that CPU. This eliminates IPI overhead in the perf API.
We have to loop through the CPU in the outter builtin-stat code instead of leaving that to low level functions.
It has to change the weak group fallback strategy slightly. Since we cannot easily undo the opens for other CPUs move the weak group retry to a separate loop.
Before with a large test case with 94 CPUs:
% time seconds usecs/call calls errors syscall
------ ----------- ----------- --------- --------- ----------------
42.75 4.050910 67 60046 110 perf_event_open
After:
26.86 0.944396 16 58069 110 perf_event_open
(the number changes slightly because the weak group retries work differently and the test case relies on weak groups)
---
v2: Use new iterator macros.
Fix bug that caused unnecessary retry for errored events. Add extra assert to check assumption that cpumaps are always subsets v3:
Use new iterator macros
Factored out code movement for error handling.
v4:
Update iterator macros again
Fix minor bug with errored events
v5:
Add comments. Remove redundant iterator start.
Merge evsel open patch into this one again to avoid broke immediate.
--- tools/perf/builtin-record.c | 2 +- tools/perf/builtin-stat.c | 121 +++++++++++++++++++++++++++------ tools/perf/tests/event-times.c | 4 +- tools/perf/util/evlist.c | 10 ++- tools/perf/util/evlist.h | 3 +- tools/perf/util/evsel.c | 18 +++-- tools/perf/util/evsel.h | 5 +- tools/perf/util/stat.c | 5 +- tools/perf/util/stat.h | 3 +- 9 files changed, 137 insertions(+), 34 deletions(-)
tools/perf/builtin-record.c +1 -1
@@ -825,7 +825,7 @@ static int record__open(struct record *rec)if ((errno ==EINVAL || errno ==EBADF ) && pos->leader != pos && pos->weak_group) { - pos =perf_evlist__reset_weak_group (evlist, pos); + pos =perf_evlist__reset_weak_group (evlist, pos, true); goto try_again; } rc = -errno;
tools/perf/builtin-stat.c +102 -19
150 lines not on this page · raw message
tools/perf/tests/event-times.c +2 -2
@@ -125,7 +125,7 @@ static int attach__cpu_disabled(struct evlist *evlist) evsel->core.attr.disabled =1 ; - err =perf_evsel__open_per_cpu (evsel, cpus); + err =perf_evsel__open_per_cpu (evsel, cpus,-1 );if (err) {if (err == -EACCES )return TEST_SKIP ;
@@ -152,7 +152,7 @@ static int attach__cpu_enabled(struct evlist *evlist)return -1 ; } - err =perf_evsel__open_per_cpu (evsel, cpus); + err =perf_evsel__open_per_cpu (evsel, cpus,-1 );if (err == -EACCES )return TEST_SKIP ;
tools/perf/util/evlist.c +8 -2
@@ -1636,7 +1636,8 @@ void perf_evlist__force_leader(struct evlist *evlist) }struct evsel *perf_evlist__reset_weak_group (struct evlist *evsel_list, -struct evsel *evsel) +struct evsel *evsel, +bool close) {struct evsel *c2, *leader;bool is_open = true;
@@ -1653,10 +1654,15 @@ struct evsel *perf_evlist__reset_weak_group(struct evlist *evsel_list,if (c2 == evsel) is_open = false;if (c2->leader == leader) { -if (is_open) +if (is_open && close)perf_evsel__close (&c2->core); c2->leader = c2; c2->core.nr_members =0 ; +/* +* Set this for all former members of the group +* to indicate they get reopened. +*/ + c2->reset_group = true; } }return leader;
tools/perf/util/evlist.h +2 -1
@@ -355,5 +355,6 @@ bool perf_evlist__exclude_kernel(struct evlist *evlist);void perf_evlist__force_leader (struct evlist *evlist);struct evsel *perf_evlist__reset_weak_group (struct evlist *evlist, -struct evsel *evsel); +struct evsel *evsel, +bool close);#endif /* __PERF_EVLIST_H */
tools/perf/util/evsel.c +13 -5
@@ -1569,8 +1569,9 @@ static int perf_event_open(struct evsel *evsel,return fd; } -int evsel__open (struct evsel *evsel,struct perf_cpu_map *cpus, -struct perf_thread_map *threads) +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 cpu, thread, nthreads;unsigned long flags =PERF_FLAG_FD_CLOEXEC ;
@@ -1647,7 +1648,7 @@ int evsel__open(struct evsel *evsel, struct perf_cpu_map *cpus,display_attr (&evsel->core.attr); -for (cpu =0 ; cpu < cpus->nr; cpu++) { +for (cpu = start_cpu; cpu < end_cpu; cpu++) {for (thread =0 ; thread < nthreads; thread++) {int fd, group_fd;
@@ -1825,6 +1826,12 @@ int evsel__open(struct evsel *evsel, struct perf_cpu_map *cpus,return err; } +int evsel__open (struct evsel *evsel,struct perf_cpu_map *cpus, +struct perf_thread_map *threads) +{ +return evsel__open_cpu (evsel, cpus, threads,0 , cpus ? cpus->nr :1 ); +} +void evsel__close (struct evsel *evsel) {perf_evsel__close (&evsel->core);
@@ -1832,9 +1839,10 @@ void evsel__close(struct evsel *evsel) }int perf_evsel__open_per_cpu (struct evsel *evsel, -struct perf_cpu_map *cpus) +struct perf_cpu_map *cpus, +int cpu) { -return evsel__open (evsel, cpus,NULL ); +return evsel__open_cpu (evsel, cpus,NULL , cpu, cpu +1 ); } int perf_evsel__open_per_thread(struct evsel *evsel,
tools/perf/util/evsel.h +4 -1
@@ -94,6 +94,8 @@ struct evsel {struct evsel *metric_leader;bool collect_stat;bool weak_group; +bool reset_group; +bool errored;bool percore;int cpu_iter;const char *pmu_name;
@@ -223,7 +225,8 @@ int evsel__enable(struct evsel *evsel);int evsel__disable (struct evsel *evsel);int perf_evsel__open_per_cpu (struct evsel *evsel, -struct perf_cpu_map *cpus); +struct perf_cpu_map *cpus, +int cpu);int perf_evsel__open_per_thread (struct evsel *evsel,struct perf_thread_map *threads); int evsel__open(struct evsel *evsel, struct perf_cpu_map *cpus,
tools/perf/util/stat.c +3 -2
@@ -464,7 +464,8 @@ size_t perf_event__fprintf_stat_config(union perf_event *event, FILE *fp)int create_perf_stat_counter (struct evsel *evsel,struct perf_stat_config *config, -struct target *target) +struct target *target, +int cpu) {struct perf_event_attr *attr = &evsel->core.attr;struct evsel *leader = evsel->leader;
@@ -518,7 +519,7 @@ int create_perf_stat_counter(struct evsel *evsel, }if (target__has_cpu (target) && !target__has_per_thread (target)) -return perf_evsel__open_per_cpu (evsel,evsel__cpus (evsel)); +return perf_evsel__open_per_cpu (evsel,evsel__cpus (evsel), cpu);return perf_evsel__open_per_thread (evsel, evsel->core.threads); }
tools/perf/util/stat.h +2 -1
@@ -214,7 +214,8 @@ size_t perf_event__fprintf_stat_config(union perf_event *event, FILE *fp);int create_perf_stat_counter (struct evsel *evsel,struct perf_stat_config *config, -struct target *target); +struct target *target, +int cpu); void perf_evlist__print_counters(struct evlist *evlist, struct perf_stat_config *config,
Signature · 1 line
2.23.0
PATCH v7 7/12 perf stat: Use affinity for closing file descriptors
In reply to Andi KleenFrom: Andi Kleen <[email protected]>
Closing a perf fd can also trigger an IPI to the target CPU. Use the same affinity technique as we use for reading/enabling events to closing to optimize the CPU transitions.
Before on a large test case with 94 CPUs:
% time seconds usecs/call calls errors syscall
------ ----------- ----------- --------- --------- ----------------
32.56 3.085463 50 61483 close
After:
10.54 0.735704 11 61485 close
---
v2: Use new iterator macros
v3: Use new iterator macros
Add missing affinity__cleanup
v4:
Update iterators again
v5:
Add comments
--- tools/perf/util/evlist.c | 31 +++++++++++++++++++++++++++++-- 1 file changed, 29 insertions(+), 2 deletions(-)
tools/perf/util/evlist.c +29 -2
@@ -18,6 +18,7 @@#include "debug.h" #include "units.h" #include <internal/lib.h> // page_size +#include "affinity.h" #include "../perf.h" #include "asm/bug.h" #include "bpf-event.h"
@@ -1169,9 +1170,35 @@ void perf_evlist__set_selected(struct evlist *evlist,void evlist__close (struct evlist *evlist) {struct evsel *evsel; +struct affinity affinity; +int cpu, i; -evlist__for_each_entry_reverse (evlist, evsel) -evsel__close (evsel); +/* +* With perf record core.cpus is usually NULL. +* Use the old method to handle this for now. +*/ +if (!evlist->core.cpus) { +evlist__for_each_entry_reverse (evlist, evsel) +evsel__close (evsel); +return ; + } + +if (affinity__setup (&affinity) <0 ) +return ; + evlist__for_each_cpu (evlist, i, cpu) { +affinity__set (&affinity, cpu); + +evlist__for_each_entry_reverse (evlist, evsel) { +if (evsel__cpu_iter_skip (evsel, cpu)) +continue ; +perf_evsel__close_cpu (&evsel->core, evsel->cpu_iter -1 ); + } + } +affinity__cleanup (&affinity); +evlist__for_each_entry_reverse (evlist, evsel) { +perf_evsel__free_fd (&evsel->core); +perf_evsel__free_id (&evsel->core); + } }static int perf_evlist__create_syswide_maps (struct evlist *evlist)
Signature · 1 line
2.23.0
PATCH v7 6/12 perf evsel: Add functions to close evsel on a CPU
In reply to Andi KleenFrom: Andi Kleen <[email protected]>
Refactor the existing all CPU function to use the per CPU close internally.
Export APIs to close per CPU.
--- tools/perf/lib/evsel.c | 27 +++++++++++++++++++++------ tools/perf/lib/include/perf/evsel.h | 1 + 2 files changed, 22 insertions(+), 6 deletions(-)
tools/perf/lib/evsel.c +21 -6
@@ -114,16 +114,23 @@ int perf_evsel__open(struct perf_evsel *evsel, struct perf_cpu_map *cpus,return err; } +static void perf_evsel__close_fd_cpu (struct perf_evsel *evsel,int cpu) +{ +int thread; + +for (thread =0 ; thread <xyarray__max_y (evsel->fd); ++thread) { +if (FD (evsel, cpu, thread) >=0 ) +close (FD (evsel, cpu, thread)); +FD (evsel, cpu, thread) =-1 ; + } +} +void perf_evsel__close_fd (struct perf_evsel *evsel) { -int cpu, thread; +int cpu;for (cpu =0 ; cpu <xyarray__max_x (evsel->fd); cpu++) -for (thread =0 ; thread <xyarray__max_y (evsel->fd); ++thread) { -if (FD (evsel, cpu, thread) >=0 ) -close (FD (evsel, cpu, thread)); -FD (evsel, cpu, thread) =-1 ; - } +perf_evsel__close_fd_cpu (evsel, cpu); }void perf_evsel__free_fd (struct perf_evsel *evsel)
@@ -141,6 +148,14 @@ void perf_evsel__close(struct perf_evsel *evsel)perf_evsel__free_fd (evsel); } +void perf_evsel__close_cpu (struct perf_evsel *evsel,int cpu) +{ +if (evsel->fd ==NULL ) +return ; + +perf_evsel__close_fd_cpu (evsel, cpu); +} +int perf_evsel__read_size (struct perf_evsel *evsel) {u64 read_format = evsel->attr.read_format;
tools/perf/lib/include/perf/evsel.h +1 -0
@@ -26,6 +26,7 @@ LIBPERF_API void perf_evsel__delete(struct perf_evsel *evsel); LIBPERF_API int perf_evsel__open(struct perf_evsel *evsel, struct perf_cpu_map *cpus,struct perf_thread_map *threads); LIBPERF_API void perf_evsel__close(struct perf_evsel *evsel); +LIBPERF_API void perf_evsel__close_cpu(struct perf_evsel *evsel, int cpu); LIBPERF_API int perf_evsel__read(struct perf_evsel *evsel, int cpu, int thread,struct perf_counts_values *count); LIBPERF_API int perf_evsel__enable(struct perf_evsel *evsel);
Signature · 1 line
2.23.0
PATCH v7 12/12 perf stat: Use affinity for enabling/disabling events
In reply to Andi KleenFrom: Andi Kleen <[email protected]>
Restructure event enabling/disabling to use affinity, which minimizes the number of IPIs needed.
Before on a large test case with 94 CPUs:
% time seconds usecs/call calls errors syscall
------ ----------- ----------- --------- --------- ----------------
54.65 1.899986 22 84812 660 ioctl
after:
39.21 0.930451 10 84796 644 ioctl
---
v2: Use new iterator macros
v3: Use new iterator macros
v4: Update iterators again
--- tools/perf/util/evlist.c | 40 +++++++++++++++++++++++++++++++++++++--- 1 file changed, 37 insertions(+), 3 deletions(-)
tools/perf/util/evlist.c +37 -3
@@ -378,11 +378,28 @@ bool evsel__cpu_iter_skip(struct evsel *ev, int cpu)void evlist__disable (struct evlist *evlist) {struct evsel *pos; +struct affinity affinity; +int cpu, i; + +if (affinity__setup (&affinity) <0 ) +return ; + + evlist__for_each_cpu (evlist, i, cpu) { +affinity__set (&affinity, cpu); +evlist__for_each_entry (evlist, pos) { +if (evsel__cpu_iter_skip (pos, cpu)) +continue ; +if (pos->disabled || !perf_evsel__is_group_leader (pos) || !pos->core.fd) +continue ; +evsel__disable_cpu (pos, pos->cpu_iter -1 ); + } + } +affinity__cleanup (&affinity);evlist__for_each_entry (evlist, pos) { -if (pos->disabled || !perf_evsel__is_group_leader (pos) || !pos->core.fd) +if (!perf_evsel__is_group_leader (pos) || !pos->core.fd)continue ; -evsel__disable (pos); + pos->disabled = true; } evlist->enabled = false;
@@ -391,11 +408,28 @@ void evlist__disable(struct evlist *evlist)void evlist__enable (struct evlist *evlist) {struct evsel *pos; +struct affinity affinity; +int cpu, i; +if (affinity__setup (&affinity) <0 ) +return ; + + evlist__for_each_cpu (evlist, i, cpu) { +affinity__set (&affinity, cpu); + +evlist__for_each_entry (evlist, pos) { +if (evsel__cpu_iter_skip (pos, cpu)) +continue ; +if (!perf_evsel__is_group_leader (pos) || !pos->core.fd) +continue ; +evsel__enable_cpu (pos, pos->cpu_iter -1 ); + } + } +affinity__cleanup (&affinity);evlist__for_each_entry (evlist, pos) {if (!perf_evsel__is_group_leader (pos) || !pos->core.fd)continue ; -evsel__enable (pos); + pos->disabled = false; } evlist->enabled = true;
Signature · 1 line
2.23.0
PATCH v7 3/12 perf cpumap: Maintain cpumaps ordered and without dups
In reply to Andi KleenFrom: Andi Kleen <[email protected]>
Enforce this in _trim()
Needed for followon change.
--- tools/perf/lib/cpumap.c | 16 +++++++++++++++- 1 file changed, 15 insertions(+), 1 deletion(-)
tools/perf/lib/cpumap.c +15 -1
@@ -68,14 +68,28 @@ static struct perf_cpu_map *cpu_map__default_new(void)return cpus; } +static int cmp_int (const void *a,const void *b) +{ +return *(const int *)a - *(const int *)b; +} +static struct perf_cpu_map *cpu_map__trim_new (int nr_cpus,int *tmp_cpus) {size_t payload_size = nr_cpus *sizeof (int );struct perf_cpu_map *cpus =malloc (sizeof (*cpus) + payload_size); +int i, j;if (cpus !=NULL ) { - cpus->nr = nr_cpus;memcpy (cpus->map, tmp_cpus, payload_size); +qsort (cpus->map, nr_cpus,sizeof (int ), cmp_int); +/* Remove dups */ + j =0 ; +for (i =0 ; i < nr_cpus; i++) { +if (i ==0 || cpus->map[i] != cpus->map[i -1 ]) + cpus->map[j++] = cpus->map[i]; + } + cpus->nr = j; +assert (j <= nr_cpus);refcount_set (&cpus->refcnt,1 ); }
Signature · 1 line
2.23.0
PATCH v7 5/12 perf evsel: Add iterator to iterate over events ordered by CPU
In reply to Andi KleenFrom: Andi Kleen <[email protected]>
Add some common code that is needed to iterate over all events in CPU order. Used in followon patches
---
v2: Add cpumap__for_each_cpu macro to factor out some common code
v3: Drop cpumap__for_each_cpu macro again, replace with evlist__for_each_cpu Add new evlist__for_each_cpu
Don't compute cpus nr in cpu_index iterator init, just use all_cpus v4:
Remove __next, move into skip
Add _no_inc
Move initialization into iterator macro
Rename cpu_index to cpu_iter
--- tools/perf/util/cpumap.h | 1 + tools/perf/util/evlist.c | 32 ++++++++++++++++++++++++++++++++ tools/perf/util/evlist.h | 8 ++++++++ tools/perf/util/evsel.h | 1 + 4 files changed, 42 insertions(+)
tools/perf/util/cpumap.h +1 -0
@@ -63,4 +63,5 @@ int cpu_map__build_map(struct perf_cpu_map *cpus, struct perf_cpu_map **res,int cpu_map__cpu (struct perf_cpu_map *cpus,int idx);bool cpu_map__has (struct perf_cpu_map *cpus,int cpu); +#endif /* __PERF_CPUMAP_H */
tools/perf/util/evlist.c +32 -0
@@ -342,6 +342,38 @@ static int perf_evlist__nr_threads(struct evlist *evlist,return perf_thread_map__nr (evlist->core.threads); } +void evlist__cpu_iter_start (struct evlist *evlist) +{ +struct evsel *pos; + +/* +* Reset the per evsel cpu_iter. This is needed because +* each evsel's cpumap may have a different index space, +* and some operations need the index to modify +* the FD xyarray (e.g. open, close) +*/ +evlist__for_each_entry (evlist, pos) + pos->cpu_iter =0 ; +} + +bool evsel__cpu_iter_skip_no_inc (struct evsel *ev,int cpu) +{ +if (ev->cpu_iter >= ev->core.cpus->nr) +return true; +if (cpu >=0 && ev->core.cpus->map[ev->cpu_iter] != cpu) +return true; +return false; +} + +bool evsel__cpu_iter_skip (struct evsel *ev,int cpu) +{ +if (!evsel__cpu_iter_skip_no_inc (ev, cpu)) { + ev->cpu_iter++; +return false; + } +return true; +} +void evlist__disable (struct evlist *evlist) {struct evsel *pos;
tools/perf/util/evlist.h +8 -0
@@ -333,9 +333,17 @@ void perf_evlist__to_front(struct evlist *evlist,#define evlist__for_each_entry_safe (evlist, tmp, evsel) \ __evlist__for_each_entry_safe(&(evlist)->core.entries, tmp, evsel) +#define evlist__for_each_cpu (evlist, index, cpu) \ + evlist__cpu_iter_start(evlist); \ + perf_cpu_map__for_each_cpu (cpu, index, (evlist)->core.all_cpus) +void perf_evlist__set_tracking_event (struct evlist *evlist,struct evsel *tracking_evsel); +void evlist__cpu_iter_start (struct evlist *evlist); +bool evsel__cpu_iter_skip (struct evsel *ev,int cpu); +bool evsel__cpu_iter_skip_no_inc (struct evsel *ev,int cpu); +struct evsel *perf_evlist__find_evsel_by_str (struct evlist *evlist,const char *str);
tools/perf/util/evsel.h +1 -0
@@ -95,6 +95,7 @@ struct evsel {bool collect_stat;bool weak_group;bool percore; +int cpu_iter;const char *pmu_name;struct {perf_evsel__sb_cb_t *cb;
Signature · 1 line
2.23.0
PATCH v7 2/12 perf affinity: Add infrastructure to save/restore affinity
In reply to Andi KleenFrom: Andi Kleen <[email protected]>
The kernel perf subsystem has to IPI to the target CPU for many operations. On systems with many CPUs and when managing many events the overhead can be dominated by lots of IPIs.
An alternative is to set up CPU affinity in the perf tool, then set up all the events for that CPU, and then move on to the next CPU.
Add some affinity management infrastructure to enable such a model. Used in followon patches.
---
v2: Use linux/bitmap.h functions.
v3: Add affinity.c to the python-ext-sources to fix the python interface. Thanks 0day!
--- tools/perf/util/Build | 1 + tools/perf/util/affinity.c | 72 ++++++++++++++++++++++++++++++ tools/perf/util/affinity.h | 15 +++++++ tools/perf/util/python-ext-sources | 1 + 4 files changed, 89 insertions(+) create mode 100644 tools/perf/util/affinity.c create mode 100644 tools/perf/util/affinity.h
tools/perf/util/Build +1 -0
@@ -77,6 +77,7 @@ perf-y += sort.o perf-y += hist.o perf-y += util.o perf-y += cpumap.o +perf-y += affinity.o perf-y += cputopo.o perf-y += cgroup.o perf-y += target.o
tools/perf/util/affinity.c new file +72 -0
72 lines not on this page · raw message
tools/perf/util/affinity.h new file +15 -0
@@ -0,0 +1,15 @@ +// SPDX-License-Identifier: GPL-2.0 +#ifndef AFFINITY_H +#define AFFINITY_H 1 + +struct affinity { +unsigned long *orig_cpus; +unsigned long *sched_cpus; +bool changed; +}; + +void affinity__cleanup (struct affinity *a); +void affinity__set (struct affinity *a,int cpu); +int affinity__setup (struct affinity *a); + +#endif
tools/perf/util/python-ext-sources +1 -0
@@ -33,3 +33,4 @@ util/trace-event.c util/string.c util/symbol_fprintf.c util/units.c +util/affinity.c
Signature · 1 line
2.23.0
PATCH v7 4/12 perf evlist: Maintain evlist->all_cpus
In reply to Andi KleenFrom: Andi Kleen <[email protected]>
Maintain a cpumap in the evlist that is the union of all the cpus of the events.
This needs a cpumap merge operation, which is added together with tests.
v2:
Add tests for cpu map merge
Fix handling of duplicates
Rename _update to _merge
Factor out sorting.
Fix handling of NULL maps in merge
v3:
Add comments and empty lines to _merge
--- tools/perf/lib/cpumap.c | 57 ++++++++++++++++++++++++ tools/perf/lib/evlist.c | 1 + tools/perf/lib/include/internal/evlist.h | 1 + tools/perf/lib/include/perf/cpumap.h | 2 + tools/perf/tests/builtin-test.c | 5 +++ tools/perf/tests/cpumap.c | 16 +++++++ tools/perf/tests/tests.h | 1 + 7 files changed, 83 insertions(+)
tools/perf/lib/cpumap.c +57 -0
@@ -286,3 +286,60 @@ int perf_cpu_map__max(struct perf_cpu_map *map)return max; } + +/* +* Merge two cpumaps +* +* orig either gets freed and replaced with a new map, or reused +* with no reference count change (similar to "realloc") +* other has its reference count increased. +*/ + +struct perf_cpu_map *perf_cpu_map__merge (struct perf_cpu_map *orig, +struct perf_cpu_map *other) +{ +int *tmp_cpus; +int tmp_len; +int i, j, k; +struct perf_cpu_map *merged; + +if (!orig && !other) +return NULL ; +if (!orig) { +perf_cpu_map__get (other); +return other; + } +if (!other) +return orig; +if (orig->nr == other->nr && + !memcmp (orig->map, other->map, orig->nr *sizeof (int ))) +return orig; + + tmp_len = orig->nr + other->nr; + tmp_cpus =malloc (tmp_len *sizeof (int )); +if (!tmp_cpus) +return NULL ; + +/* Standard merge algorithm from wikipedia */ + i = j = k =0 ; +while (i < orig->nr && j < other->nr) { +if (orig->map[i] <= other->map[j]) { +if (orig->map[i] == other->map[j]) + j++; + tmp_cpus[k++] = orig->map[i++]; + }else + tmp_cpus[k++] = other->map[j++]; + } + +while (i < orig->nr) + tmp_cpus[k++] = orig->map[i++]; + +while (j < other->nr) + tmp_cpus[k++] = other->map[j++]; +assert (k <= tmp_len); + + merged =cpu_map__trim_new (k, tmp_cpus); +free (tmp_cpus); +perf_cpu_map__put (orig); +return merged; +}
tools/perf/lib/evlist.c +1 -0
@@ -54,6 +54,7 @@ static void __perf_evlist__propagate_maps(struct perf_evlist *evlist,perf_thread_map__put (evsel->threads); evsel->threads =perf_thread_map__get (evlist->threads); + evlist->all_cpus =perf_cpu_map__merge (evlist->all_cpus, evsel->cpus); }static void perf_evlist__propagate_maps (struct perf_evlist *evlist)
tools/perf/lib/include/internal/evlist.h +1 -0
@@ -18,6 +18,7 @@ struct perf_evlist {int nr_entries;bool has_user_cpus;struct perf_cpu_map *cpus; +struct perf_cpu_map *all_cpus;struct perf_thread_map *threads;int nr_mmaps;size_t mmap_len;
tools/perf/lib/include/perf/cpumap.h +2 -0
@@ -12,6 +12,8 @@ LIBPERF_API struct perf_cpu_map *perf_cpu_map__dummy_new(void); LIBPERF_API struct perf_cpu_map *perf_cpu_map__new(const char *cpu_list); LIBPERF_API struct perf_cpu_map *perf_cpu_map__read(FILE *file); LIBPERF_API struct perf_cpu_map *perf_cpu_map__get(struct perf_cpu_map *map); +LIBPERF_API struct perf_cpu_map *perf_cpu_map__merge(struct perf_cpu_map *orig, +struct perf_cpu_map *other); LIBPERF_API void perf_cpu_map__put(struct perf_cpu_map *map); LIBPERF_API int perf_cpu_map__cpu(const struct perf_cpu_map *cpus, int idx); LIBPERF_API int perf_cpu_map__nr(const struct perf_cpu_map *cpus);
tools/perf/tests/builtin-test.c +5 -0
@@ -259,6 +259,11 @@ static struct test generic_tests[] = { .desc = "Print cpu map", .func = test__cpu_map_print, }, + { + .desc = "Merge cpu map", + .func = test__cpu_map_merge, + }, + { .desc = "Probe SDT events", .func = test__sdt_event,
tools/perf/tests/cpumap.c +16 -0
@@ -120,3 +120,19 @@ int test__cpu_map_print(struct test *test __maybe_unused, int subtest __maybe_unTEST_ASSERT_VAL ("failed to convert map" ,cpu_map_print ("1-10,12-20,22-30,32-40" ));return 0 ; } + +int test__cpu_map_merge (struct test *test__maybe_unused ,int subtest__maybe_unused ) +{ +struct perf_cpu_map *a =perf_cpu_map__new ("4,2,1" ); +struct perf_cpu_map *b =perf_cpu_map__new ("4,5,7" ); +struct perf_cpu_map *c =perf_cpu_map__merge (a, b); +char buf[100 ]; + +TEST_ASSERT_VAL ("failed to merge map: bad nr" , c->nr ==5 ); +cpu_map__snprint (c, buf,sizeof (buf)); +TEST_ASSERT_VAL ("failed to merge map: bad result" , !strcmp (buf,"1-2,4-5,7" )); +perf_cpu_map__put (a); +perf_cpu_map__put (b); +perf_cpu_map__put (c); +return 0 ; +}
tools/perf/tests/tests.h +1 -0
@@ -98,6 +98,7 @@ int test__event_update(struct test *test, int subtest);int test__event_times (struct test *test,int subtest);int test__backward_ring_buffer (struct test *test,int subtest);int test__cpu_map_print (struct test *test,int subtest); +int test__cpu_map_merge (struct test *test,int subtest);int test__sdt_event (struct test *test,int subtest);int test__is_printable_array (struct test *test,int subtest);int test__bitmap_print (struct test *test,int subtest);
Signature · 1 line
2.23.0
Re: [PATCH v7 09/12] perf stat: Use affinity for opening events
In reply to Andi KleenOn Fri, Nov 15, 2019 at 09:52:26PM -0800, Andi Kleen wrote:
SNIP
Quoted 12 lines
tools/perf/builtin-stat.c +12
-0+if (second_pass) { +/* +* Now redo all the weak group after closing them, +* and also close errored counters. +*/ + + evlist__for_each_cpu (evsel_list, i, cpu) { +affinity__set (&affinity, cpu); +/* First close errored or weak retry */ +evlist__for_each_entry (evsel_list, counter) { +if (!counter->reset_group && !counter->errored) +continue ;
tools/perf/builtin-stat.c static int __run_perf_stat(int argc, const char **argv, int run_idx) · line 588
Quoted 10 lines
tools/perf/builtin-stat.c +10
-0+if (evsel__cpu_iter_skip_no_inc (counter, cpu)) +continue ; +perf_evsel__close_cpu (&counter->core, counter->cpu_iter); + } +/* Now reopen weak */ +evlist__for_each_entry (evsel_list, counter) { +if (!counter->reset_group && !counter->errored) +continue ; +if (evsel__cpu_iter_skip (counter, cpu)) +continue ;
why staring at this I wonder why can't we call perf_evsel__close_cpu in here and remove the above loop? together with evsel__cpu_iter_skip_no_inc function
jirka
Quoted 23 lines
tools/perf/builtin-stat.c +20
-1+if (!counter->reset_group) +continue ; +try_again_reset: +pr_debug2 ("reopening weak %s\n" ,perf_evsel__name (counter)); +if (create_perf_stat_counter (counter, &stat_config, &target, + counter->cpu_iter -1 ) <0 ) { + +switch (stat_handle_error (counter)) { +case COUNTER_FATAL : +return -1 ; +case COUNTER_RETRY : + goto try_again_reset; +case COUNTER_SKIP : +continue ; +default : +break ; + } + } + counter->supported = true; } } - counter->supported = true; + }
SNIP
Re: [PATCH v7 10/12] perf stat: Use affinity for reading
In reply to Andi KleenOn Fri, Nov 15, 2019 at 09:52:27PM -0800, Andi Kleen wrote:
SNIP
Quoted 9 lines
tools/perf/builtin-stat.c +4
-0+perf_evsel__name (counter), + cpu, + count->val, count->ena, count->run); + } }return 0 ;@@ -325,15 +318,36 @@ static int read_counter(struct evsel *counter, struct timespec *rs)static void read_counters (struct timespec *rs)
tools/perf/builtin-stat.c static int read_counter(struct evsel *counter, struct timespec *rs) · line 327
Quoted 10 lines
tools/perf/builtin-stat.c +7
-1{struct evsel *counter; -int ret; +struct affinity affinity; +int i, ncpus, cpu; + +if (affinity__setup (&affinity) <0 ) +return ; + + ncpus = evsel_list->core.all_cpus->nr;
please use perf_cpu_map__nr
tools/perf/builtin-stat.c static int read_counter(struct evsel *counter, struct timespec *rs) · line 340
Quoted 13 lines
tools/perf/builtin-stat.c +13
-0+if (!target__has_cpu (&target) ||target__has_per_thread (&target)) + ncpus =1 ; + evlist__for_each_cpu (evsel_list, i, cpu) { +if (i >= ncpus) +break ; +affinity__set (&affinity, cpu); + +evlist__for_each_entry (evsel_list, counter) { +if (evsel__cpu_iter_skip (counter, cpu)) +continue ; +if (!counter->err) + counter->err =read_counter_cpu (counter, rs, + counter->cpu_iter -1 );
please use { } to enclose multiline if legs
thanks,
jirka
Quoted 53 lines · Andi Kleen
[v7: Address review feedback. Fix python script problem reported by 0day. Drop merged patches.]
This patch kit optimizes perf stat for a large number of events on systems with many CPUs and PMUs.
Some profiling shows that the most overhead is doing IPIs to all the target CPUs. We can optimize this by using
sched_setaffinityto set the affinity to a target CPU once and then doing the perf operation for all events on that CPU. This requires some restructuring, but cuts the set up time quite a bit.In theory we could go further by parallelizing these setups too, but that would be much more complicated and for now just batching it per CPU seems to be sufficient. At some point with many more cores parallelization or a better bulk perf setup API might be needed though.
In addition perf does a lot of redundant /sys accesses with many PMUs, which can be also expensve. This is also optimized.
On a large test case (>700 events with many weak groups) on a 94 CPU system I go from
real 0m8.607s
user 0m0.550s
sys 0m8.041sto
real 0m3.269s
user 0m0.760s
sys 0m1.694sso shaving ~6 seconds of system time, at slightly more cost in perf stat itself. On a 4 socket system with the savings are more dramatic:
real 0m15.641s
user 0m0.873s
sys 0m14.729sto
real 0m4.493s
user 0m1.578s
sys 0m2.444sso 11s difference in the user visible set up time.
Also available in
git://git.kernel.org/pub/scm/linux/kernel/git/ak/linux-miscperf/stat-scale-10
Quoted 15 lines
v1: Initial post.
v2: Rebase. Fix some minor issues.
v3: Rebase. Address review feedback. Fix one minor issue
v4: Modified based on review feedback. Now it maintainsall_cpusper evlist. There is still a need forcpu_indexiteration to get the correct index for indexing the file descriptors. Fix bug with unsorted cpu maps, now they are always sorted. Some cleanups and refactoring.
v5: Split patches. Redo loop iteration again. Fix cpu map merging for uncore. Remove duplicates from cpumaps. Add unit tests.
v6: Address review feedback. Fix some bugs. Add more comments. Merge one invalid patch split.
v7: Address review feedback. Fix python scripting (thanks 0day) Minor updates.
I posted another 2 comments, but other than that I think it's ok
I don't like it, but can't see a better way ;-) and the speedup is really impressive
thanks,
jirka
Re: [PATCH v7 09/12] perf stat: Use affinity for opening events
In reply to Jiri OlsaQuoted 12 lines
Quoted 12 lines
tools/perf/builtin-stat.c +12
-0+ evlist__for_each_cpu (evsel_list, i, cpu) { +affinity__set (&affinity, cpu); +/* First close errored or weak retry */ +evlist__for_each_entry (evsel_list, counter) { +if (!counter->reset_group && !counter->errored) +continue ; +if (evsel__cpu_iter_skip_no_inc (counter, cpu)) +continue ; +perf_evsel__close_cpu (&counter->core, counter->cpu_iter); + } +/* Now reopen weak */ +evlist__for_each_entry (evsel_list, counter) {
Quoted 8 lines
tools/perf/builtin-stat.c static int __run_perf_stat(int argc, const char **argv, int run_idx) · line 588
Quoted 4 lines
tools/perf/builtin-stat.c +4
-0+if (!counter->reset_group && !counter->errored) +continue ; +if (evsel__cpu_iter_skip (counter, cpu)) +continue ;why staring at this I wonder why can't we call
perf_evsel__close_cpuin here and remove the above loop? together withevsel__cpu_iter_skip_no_incfunction
We only want to close events which errored or need a weak entry. The others can stay open. perf_evsel__close_cpu closes all unconditionally.
-Andi
Re: [PATCH v7 09/12] perf stat: Use affinity for opening events
Quoted 21 lines · Andi Kleen
Quoted 12 lines
Quoted 12 lines
tools/perf/builtin-stat.c +12
-0+ evlist__for_each_cpu (evsel_list, i, cpu) { +affinity__set (&affinity, cpu); +/* First close errored or weak retry */ +evlist__for_each_entry (evsel_list, counter) { +if (!counter->reset_group && !counter->errored) +continue ; +if (evsel__cpu_iter_skip_no_inc (counter, cpu)) +continue ; +perf_evsel__close_cpu (&counter->core, counter->cpu_iter); + } +/* Now reopen weak */ +evlist__for_each_entry (evsel_list, counter) {Quoted 8 lines
tools/perf/builtin-stat.c static int __run_perf_stat(int argc, const char **argv, int run_idx) · line 588
Quoted 4 lines
tools/perf/builtin-stat.c +4
-0+if (!counter->reset_group && !counter->errored) +continue ; +if (evsel__cpu_iter_skip (counter, cpu)) +continue ;why staring at this I wonder why can't we call
perf_evsel__close_cpuin here and remove the above loop? together withevsel__cpu_iter_skip_no_incfunction
Quoted 2 lines
We only want to close events which errored or need a weak entry. The others can stay open.
perf_evsel__close_cpucloses all unconditionally.
but the first loops checks fir !counter->errored, same as the second one, so you could scratch the first loop and move perf_evsel__close_cpu in the second one
jirka