tools/perf: add breakpoint benchmarks
PATCH 1/1 tools/perf: add breakpoint benchmarks
Add 2 benchmarks:
1. Performance of thread creation/exiting in presence of breakpoints.
2. Performance of breakpoint modification in presence of threads.
The benchmarks capture use cases that we are interested in:
using inheritable breakpoints in large highly-threaded applications. The benchmarks show significant slowdown imposed by breakpoints (even when they don't fire).
Testing on Intel 8173M with 112 HW threads show:
perf bench --repeat=56 breakpoint thread --breakpoints=0 --parallelism=56 --threads=20
78.675000 usecs/op
perf bench --repeat=56 breakpoint thread --breakpoints=4 --parallelism=56 --threads=20
12967.135714 usecs/op
That's 165x slowdown due to presence of the breakpoints.
perf bench --repeat=20000 breakpoint enable --passive=0 --active=0
1.433250 usecs/op
perf bench --repeat=20000 breakpoint enable --passive=224 --active=0
585.318400 usecs/op
perf bench --repeat=20000 breakpoint enable --passive=0 --active=111
635.953000 usecs/opThat's 408x and 444x slowdown due to presence of threads.
Profiles show some overhead in toggle_bp_slot,
but also very high contention:
90.83% breakpoint-thre [kernel.kallsyms] [k] osq_lock
4.69% breakpoint-thre [kernel.kallsyms] [k] mutex_spin_on_owner
2.06% breakpoint-thre [kernel.kallsyms] [k] __reserve_bp_slot
2.04% breakpoint-thre [kernel.kallsyms] [k] toggle_bp_slot 79.01% breakpoint-enab [kernel.kallsyms] [k] smp_call_function_single
9.94% breakpoint-enab [kernel.kallsyms] [k] llist_add_batch
5.70% breakpoint-enab [kernel.kallsyms] [k] _raw_spin_lock_irq
1.84% breakpoint-enab [kernel.kallsyms] [k] event_function_call
1.12% breakpoint-enab [kernel.kallsyms] [k] send_call_function_single_ipi
0.37% breakpoint-enab [kernel.kallsyms] [k] generic_exec_single
0.24% breakpoint-enab [kernel.kallsyms] [k] __perf_event_disable
0.20% breakpoint-enab [kernel.kallsyms] [k] _perf_event_enable
0.18% breakpoint-enab [kernel.kallsyms] [k] toggle_bp_slot--- tools/perf/bench/Build | 1 + tools/perf/bench/bench.h | 2 + tools/perf/bench/breakpoint.c | 235 ++++++++++++++++++++++++++++++++++ tools/perf/builtin-bench.c | 8 ++ 4 files changed, 246 insertions(+) create mode 100644 tools/perf/bench/breakpoint.c
tools/perf/bench/Build +1 -0
@@ -14,6 +14,7 @@ perf-y += kallsyms-parse.o perf-y += find-bit-bench.o perf-y += inject-buildid.o perf-y += evlist-open-close.o +perf-y += breakpoint.o perf-$(CONFIG_X86_64) += mem-memcpy-x86-64-asm.o perf-$(CONFIG_X86_64) += mem-memset-x86-64-asm.o
tools/perf/bench/bench.h +2 -0
@@ -49,6 +49,8 @@ int bench_synthesize(int argc, const char **argv);int bench_kallsyms_parse (int argc,const char **argv);int bench_inject_build_id (int argc,const char **argv);int bench_evlist_open_close (int argc,const char **argv); +int bench_breakpoint_thread (int argc,const char **argv); +int bench_breakpoint_enable (int argc,const char **argv);#define BENCH_FORMAT_DEFAULT_STR "default"#define BENCH_FORMAT_DEFAULT 0
tools/perf/bench/breakpoint.c new file +235 -0
235 lines not on this page · raw message
tools/perf/builtin-bench.c +8 -0
@@ -92,6 +92,13 @@ static struct bench internals_benchmarks[] = { { NULL, NULL, NULL } }; +static struct bench breakpoint_benchmarks[] = { + {"thread" ,"Benchmark thread start/finish with breakpoints" , bench_breakpoint_thread}, + {"enable" ,"Benchmark breakpoint enable/disable" , bench_breakpoint_enable}, + {"all" ,"Run all breakpoint benchmarks" ,NULL }, + {NULL ,NULL ,NULL }, +}; +struct collection {const char *name;const char *summary;
@@ -110,6 +117,7 @@ static struct collection collections[] = { {"epoll", "Epoll stressing benchmarks", epoll_benchmarks }, #endif { "internals", "Perf-internals benchmarks", internals_benchmarks }, + { "breakpoint", "Breakpoint benchmarks", breakpoint_benchmarks }, { "all", "All benchmarks", NULL }, { NULL, NULL, NULL } };
base-commit: bd24325684029a48f20a188b899eb84900d0bc9c
Signature · 1 line
2.36.0.464.gb9c8b46e94-goog
Quoted 9 lines · Dmitry Vyukov
Add 2 benchmarks:
1. Performance of thread creation/exiting in presence of breakpoints.
2. Performance of breakpoint modification in presence of threads.The benchmarks capture use cases that we are interested in:
using inheritable breakpoints in large highly-threaded applications. The benchmarks show significant slowdown imposed by breakpoints (even when they don't fire).
Question to perf maintainers:
Do you know any low-hanging fruits re breakpoint performance? Or did you want to improve something, but never got to actually implementing it?
Do you know what would be a good way to remove the global nr_bp_mutex? Do you know of any opportunities to reduce the number of IPIs on breakpoint modifications?
Thanks in advance
Quoted 342 lines
Testing on Intel 8173M with 112 HW threads show:
perf bench --repeat=56 breakpoint thread --breakpoints=0 --parallelism=56 --threads=20
78.675000 usecs/opperf bench --repeat=56 breakpoint thread --breakpoints=4 --parallelism=56 --threads=20
12967.135714 usecs/op
That's 165x slowdown due to presence of the breakpoints.perf bench --repeat=20000 breakpoint enable --passive=0 --active=0
1.433250 usecs/op perf bench --repeat=20000 breakpoint enable --passive=224 --active=0 585.318400 usecs/op perf bench --repeat=20000 breakpoint enable --passive=0 --active=111 635.953000 usecs/opThat's 408x and 444x slowdown due to presence of threads.
Profiles show some overhead in
toggle_bp_slot,
but also very high contention:90.83% breakpoint-thre [kernel.kallsyms] [k] osq_lock 4.69% breakpoint-thre [kernel.kallsyms] [k] mutex_spin_on_owner 2.06% breakpoint-thre [kernel.kallsyms] [k] __reserve_bp_slot 2.04% breakpoint-thre [kernel.kallsyms] [k] toggle_bp_slot79.01% breakpoint-enab [kernel.kallsyms] [k] smp_call_function_single 9.94% breakpoint-enab [kernel.kallsyms] [k] llist_add_batch 5.70% breakpoint-enab [kernel.kallsyms] [k] _raw_spin_lock_irq 1.84% breakpoint-enab [kernel.kallsyms] [k] event_function_call 1.12% breakpoint-enab [kernel.kallsyms] [k] send_call_function_single_ipi 0.37% breakpoint-enab [kernel.kallsyms] [k] generic_exec_single 0.24% breakpoint-enab [kernel.kallsyms] [k] __perf_event_disable 0.20% breakpoint-enab [kernel.kallsyms] [k] _perf_event_enable 0.18% breakpoint-enab [kernel.kallsyms] [k] toggle_bp_slot--- tools/perf/bench/Build | 1 + tools/perf/bench/bench.h | 2 + tools/perf/bench/breakpoint.c | 235 ++++++++++++++++++++++++++++++++++ tools/perf/builtin-bench.c | 8 ++ 4 files changed, 246 insertions(+) create mode 100644 tools/perf/bench/breakpoint.ctools/perf/bench/Build +1
-0@@ -14,6 +14,7 @@ perf-y += kallsyms-parse.o perf-y += find-bit-bench.o perf-y += inject-buildid.o perf-y += evlist-open-close.o +perf-y += breakpoint.o perf-$(CONFIG_X86_64) += mem-memcpy-x86-64-asm.o perf-$(CONFIG_X86_64) += mem-memset-x86-64-asm.otools/perf/bench/bench.h +2
-0@@ -49,6 +49,8 @@ int bench_synthesize(int argc, const char **argv);int bench_kallsyms_parse (int argc,const char **argv);int bench_inject_build_id (int argc,const char **argv);int bench_evlist_open_close (int argc,const char **argv); +int bench_breakpoint_thread (int argc,const char **argv); +int bench_breakpoint_enable (int argc,const char **argv);#define BENCH_FORMAT_DEFAULT_STR "default"#define BENCH_FORMAT_DEFAULT 0tools/perf/bench/breakpoint.c new file +235
-0@@ -0,0 +1,235 @@ +// SPDX-License-Identifier: GPL-2.0 + +#include <subcmd/parse-options.h> +#include <linux/hw_breakpoint.h> +#include <linux/perf_event.h> +#include <linux/time64.h> +#include <sys/syscall.h> +#include <sys/ioctl.h> +#include <sys/time.h> +#include <pthread.h> +#include <stddef.h> +#include <stdlib.h> +#include <unistd.h> +#include <stdio.h> +#include <errno.h> +#include "bench.h" +#include "futex.h" + +struct { +unsigned int nbreakpoints; +unsigned int nparallel; +unsigned int nthreads; +} thread_params = { + .nbreakpoints =1 , + .nparallel =1 , + .nthreads =1 , +}; + +static const struct option thread_options[] = { +OPT_UINTEGER ('b' ,"breakpoints" , &thread_params.nbreakpoints, +"Specify amount of breakpoints" ), +OPT_UINTEGER ('p' ,"parallelism" , &thread_params.nparallel,"Specify amount of parallelism" ), +OPT_UINTEGER ('t' ,"threads" , &thread_params.nthreads,"Specify amount of threads" ), +OPT_END () +}; + +static const char *const thread_usage[] = { +"perf bench breakpoint thread <options>" , +NULL +}; + +struct breakpoint { +int fd; +char watched; +}; + +static int breakpoint_setup (void *addr) +{ +struct perf_event_attr attr = {0 }; + + attr.type =PERF_TYPE_BREAKPOINT ; + attr.size =sizeof (attr); + attr.inherit =1 ; + attr.exclude_kernel =1 ; + attr.exclude_hv =1 ; + attr.bp_addr = (uint64_t )addr; + attr.bp_type =HW_BREAKPOINT_RW ; + attr.bp_len =HW_BREAKPOINT_LEN_1 ; +return syscall (SYS_perf_event_open, &attr,0 ,-1 ,-1 ,0 ); +} + +static void *passive_thread (void *arg) +{ +unsigned int *done = (unsigned int *)arg; + +while (!__atomic_load_n (done, __ATOMIC_RELAXED)) +futex_wait (done,0 ,NULL ,0 ); +return NULL ; +} + +static void *active_thread (void *arg) +{ +unsigned int *done = (unsigned int *)arg; + +while (!__atomic_load_n (done, __ATOMIC_RELAXED)); +return NULL ; +} + +static void *breakpoint_thread (void *arg) +{ +unsigned int i, done; +int *repeat = (int *)arg; +pthread_t *threads; + + threads =calloc (thread_params.nthreads,sizeof (threads[0 ])); +while (__atomic_fetch_sub (repeat,1 , __ATOMIC_RELAXED) >0 ) { + done =0 ; +for (i =0 ; i < thread_params.nthreads; i++) { +if (pthread_create (&threads[i],NULL , passive_thread, &done)) +exit ((perror ("pthread_create" ),EXIT_FAILURE )); + } +__atomic_store_n (&done,1 , __ATOMIC_RELAXED); +futex_wake (&done, thread_params.nthreads,0 ); +for (i =0 ; i < thread_params.nthreads; i++) +pthread_join (threads[i],NULL ); + } +free (threads); +return NULL ; +} + +// The benchmark creates nbreakpoints inheritable breakpoints, +// then starts nparallel threads which create and join bench_repeat batches of nthreads threads. +int bench_breakpoint_thread (int argc,const char **argv) +{ +unsigned int i, result_usec; +int repeat = bench_repeat; +struct breakpoint *breakpoints; +pthread_t *parallel; +struct timeval start, stop, diff; + +if (parse_options (argc, argv, thread_options, thread_usage,0 )) { +usage_with_options (thread_usage, thread_options); +exit (EXIT_FAILURE ); + } + breakpoints =calloc (thread_params.nbreakpoints,sizeof (breakpoints[0 ])); + parallel =calloc (thread_params.nparallel,sizeof (parallel[0 ])); +for (i =0 ; i < thread_params.nbreakpoints; i++) { + breakpoints[i].fd =breakpoint_setup (&breakpoints[i].watched); +if (breakpoints[i].fd ==-1 ) +exit ((perror ("perf_event_open" ),EXIT_FAILURE )); + } +gettimeofday (&start,NULL ); +for (i =0 ; i < thread_params.nparallel; i++) { +if (pthread_create (¶llel[i],NULL , breakpoint_thread, &repeat)) +exit ((perror ("pthread_create" ),EXIT_FAILURE )); + } +for (i =0 ; i < thread_params.nparallel; i++) +pthread_join (parallel[i],NULL ); +gettimeofday (&stop,NULL ); +timersub (&stop, &start, &diff); +for (i =0 ; i < thread_params.nbreakpoints; i++) +close (breakpoints[i].fd); +free (parallel); +free (breakpoints); +switch (bench_format) { +case BENCH_FORMAT_DEFAULT : +printf ("# Created/joined %d threads with %d breakpoints and %d parallelism\n" , + bench_repeat, thread_params.nbreakpoints, thread_params.nparallel); +printf (" %14s: %lu.%03lu [sec]\n\n" ,"Total time" , + (long )diff.tv_sec, (long )(diff.tv_usec /USEC_PER_MSEC )); + result_usec = diff.tv_sec *USEC_PER_SEC + diff.tv_usec; +printf (" %14lf usecs/op\n" , + (double )result_usec / bench_repeat / thread_params.nthreads); +printf (" %14lf usecs/op/cpu\n" , + (double )result_usec / bench_repeat / + thread_params.nthreads * thread_params.nparallel); +break ; +case BENCH_FORMAT_SIMPLE : +printf ("%lu.%03lu\n" , (long )diff.tv_sec, (long )(diff.tv_usec /USEC_PER_MSEC )); +break ; +default : +fprintf (stderr,"Unknown format: %d\n" , bench_format); +exit (EXIT_FAILURE ); + } +return 0 ; +} + +struct { +unsigned int npassive; +unsigned int nactive; +} enable_params = { + .nactive =0 , + .npassive =0 , +}; + +static const struct option enable_options[] = { +OPT_UINTEGER ('p' ,"passive" , &enable_params.npassive,"Specify amount of passive threads" ), +OPT_UINTEGER ('a' ,"active" , &enable_params.nactive,"Specify amount of active threads" ), +OPT_END () +}; + +static const char *const enable_usage[] = { +"perf bench breakpoint enable <options>" , +NULL +}; + +// The benchmark creates an inheritable breakpoint, +// then starts npassive threads that block and nactive threads that actively spin +// and then disables and enables the breakpoint bench_repeat times. +int bench_breakpoint_enable (int argc,const char **argv) +{ +unsigned int i, nthreads, result_usec, done =0 ; +char watched; +int fd; +pthread_t *threads; +struct timeval start, stop, diff; + +if (parse_options (argc, argv, enable_options, enable_usage,0 )) { +usage_with_options (enable_usage, enable_options); +exit (EXIT_FAILURE ); + } + fd =breakpoint_setup (&watched); +if (fd ==-1 ) +exit ((perror ("perf_event_open" ),EXIT_FAILURE )); + nthreads = enable_params.npassive + enable_params.nactive; + threads =calloc (nthreads,sizeof (threads[0 ])); +for (i =0 ; i < nthreads; i++) { +if (pthread_create (&threads[i],NULL , + i < enable_params.npassive ? passive_thread : active_thread, &done)) +exit ((perror ("pthread_create" ),EXIT_FAILURE )); + } +usleep (10000 );// let the threads block +gettimeofday (&start,NULL ); +for (i =0 ; i < bench_repeat; i++) { +if (ioctl (fd,PERF_EVENT_IOC_DISABLE ,0 )) +exit ((perror ("ioctl(PERF_EVENT_IOC_DISABLE)" ),EXIT_FAILURE )); +if (ioctl (fd,PERF_EVENT_IOC_ENABLE ,0 )) +exit ((perror ("ioctl(PERF_EVENT_IOC_ENABLE)" ),EXIT_FAILURE )); + } +gettimeofday (&stop,NULL ); +timersub (&stop, &start, &diff); +__atomic_store_n (&done,1 , __ATOMIC_RELAXED); +futex_wake (&done, enable_params.npassive,0 ); +for (i =0 ; i < nthreads; i++) +pthread_join (threads[i],NULL ); +free (threads); +close (fd); +switch (bench_format) { +case BENCH_FORMAT_DEFAULT : +printf ("# Enabled/disabled breakpoint %d time with %d passive and %d active threads\n" , + bench_repeat, enable_params.npassive, enable_params.nactive); +printf (" %14s: %lu.%03lu [sec]\n\n" ,"Total time" , + (long )diff.tv_sec, (long )(diff.tv_usec /USEC_PER_MSEC )); + result_usec = diff.tv_sec *USEC_PER_SEC + diff.tv_usec; +printf (" %14lf usecs/op\n" , (double )result_usec / bench_repeat); +break ; +case BENCH_FORMAT_SIMPLE : +printf ("%lu.%03lu\n" , (long )diff.tv_sec, (long )(diff.tv_usec /USEC_PER_MSEC )); +break ; +default : +fprintf (stderr,"Unknown format: %d\n" , bench_format); +exit (EXIT_FAILURE ); + } +return 0 ; +}tools/perf/builtin-bench.c +8
-0@@ -92,6 +92,13 @@ static struct bench internals_benchmarks[] = { { NULL, NULL, NULL } }; +static struct bench breakpoint_benchmarks[] = { + {"thread" ,"Benchmark thread start/finish with breakpoints" , bench_breakpoint_thread}, + {"enable" ,"Benchmark breakpoint enable/disable" , bench_breakpoint_enable}, + {"all" ,"Run all breakpoint benchmarks" ,NULL }, + {NULL ,NULL ,NULL }, +}; +struct collection {const char *name;const char *summary;@@ -110,6 +117,7 @@ static struct collection collections[] = { {"epoll", "Epoll stressing benchmarks", epoll_benchmarks }, #endif { "internals", "Perf-internals benchmarks", internals_benchmarks }, + { "breakpoint", "Breakpoint benchmarks", breakpoint_benchmarks }, { "all", "All benchmarks", NULL }, { NULL, NULL, NULL } };base-commit:
bd24325684029a48f20a188b899eb84900d0bc9c--
2.36.0.464.gb9c8b46e94-goog
Quoted 44 lines · Dmitry Vyukov
Add 2 benchmarks:
1. Performance of thread creation/exiting in presence of breakpoints.
2. Performance of breakpoint modification in presence of threads.The benchmarks capture use cases that we are interested in:
using inheritable breakpoints in large highly-threaded applications. The benchmarks show significant slowdown imposed by breakpoints (even when they don't fire).Testing on Intel 8173M with 112 HW threads show:
perf bench --repeat=56 breakpoint thread --breakpoints=0 --parallelism=56 --threads=20
78.675000 usecs/opperf bench --repeat=56 breakpoint thread --breakpoints=4 --parallelism=56 --threads=20
12967.135714 usecs/op
That's 165x slowdown due to presence of the breakpoints.perf bench --repeat=20000 breakpoint enable --passive=0 --active=0
1.433250 usecs/op perf bench --repeat=20000 breakpoint enable --passive=224 --active=0 585.318400 usecs/op perf bench --repeat=20000 breakpoint enable --passive=0 --active=111 635.953000 usecs/opThat's 408x and 444x slowdown due to presence of threads.
Profiles show some overhead in
toggle_bp_slot,
but also very high contention:90.83% breakpoint-thre [kernel.kallsyms] [k] osq_lock 4.69% breakpoint-thre [kernel.kallsyms] [k] mutex_spin_on_owner 2.06% breakpoint-thre [kernel.kallsyms] [k] __reserve_bp_slot 2.04% breakpoint-thre [kernel.kallsyms] [k] toggle_bp_slot79.01% breakpoint-enab [kernel.kallsyms] [k] smp_call_function_single 9.94% breakpoint-enab [kernel.kallsyms] [k] llist_add_batch 5.70% breakpoint-enab [kernel.kallsyms] [k] _raw_spin_lock_irq 1.84% breakpoint-enab [kernel.kallsyms] [k] event_function_call 1.12% breakpoint-enab [kernel.kallsyms] [k] send_call_function_single_ipi 0.37% breakpoint-enab [kernel.kallsyms] [k] generic_exec_single 0.24% breakpoint-enab [kernel.kallsyms] [k] __perf_event_disable 0.20% breakpoint-enab [kernel.kallsyms] [k] _perf_event_enable 0.18% breakpoint-enab [kernel.kallsyms] [k] toggle_bp_slot
Quoted 1 line
Signed-off-by Dmitry Vyukov <[email protected]>
Quoted 97 lines
--- tools/perf/bench/Build | 1 + tools/perf/bench/bench.h | 2 + tools/perf/bench/breakpoint.c | 235 ++++++++++++++++++++++++++++++++++ tools/perf/builtin-bench.c | 8 ++ 4 files changed, 246 insertions(+) create mode 100644 tools/perf/bench/breakpoint.ctools/perf/bench/Build +1
-0@@ -14,6 +14,7 @@ perf-y += kallsyms-parse.o perf-y += find-bit-bench.o perf-y += inject-buildid.o perf-y += evlist-open-close.o +perf-y += breakpoint.o perf-$(CONFIG_X86_64) += mem-memcpy-x86-64-asm.o perf-$(CONFIG_X86_64) += mem-memset-x86-64-asm.otools/perf/bench/bench.h +2
-0@@ -49,6 +49,8 @@ int bench_synthesize(int argc, const char **argv);int bench_kallsyms_parse (int argc,const char **argv);int bench_inject_build_id (int argc,const char **argv);int bench_evlist_open_close (int argc,const char **argv); +int bench_breakpoint_thread (int argc,const char **argv); +int bench_breakpoint_enable (int argc,const char **argv);#define BENCH_FORMAT_DEFAULT_STR "default"#define BENCH_FORMAT_DEFAULT 0tools/perf/bench/breakpoint.c new file +56
-0@@ -0,0 +1,235 @@ +// SPDX-License-Identifier: GPL-2.0 + +#include <subcmd/parse-options.h> +#include <linux/hw_breakpoint.h> +#include <linux/perf_event.h> +#include <linux/time64.h> +#include <sys/syscall.h> +#include <sys/ioctl.h> +#include <sys/time.h> +#include <pthread.h> +#include <stddef.h> +#include <stdlib.h> +#include <unistd.h> +#include <stdio.h> +#include <errno.h> +#include "bench.h" +#include "futex.h" + +struct { +unsigned int nbreakpoints; +unsigned int nparallel; +unsigned int nthreads; +} thread_params = { + .nbreakpoints =1 , + .nparallel =1 , + .nthreads =1 , +}; + +static const struct option thread_options[] = { +OPT_UINTEGER ('b' ,"breakpoints" , &thread_params.nbreakpoints, +"Specify amount of breakpoints" ), +OPT_UINTEGER ('p' ,"parallelism" , &thread_params.nparallel,"Specify amount of parallelism" ), +OPT_UINTEGER ('t' ,"threads" , &thread_params.nthreads,"Specify amount of threads" ), +OPT_END () +}; + +static const char *const thread_usage[] = { +"perf bench breakpoint thread <options>" , +NULL +}; + +struct breakpoint { +int fd; +char watched; +}; + +static int breakpoint_setup (void *addr) +{ +struct perf_event_attr attr = {0 }; + + attr.type =PERF_TYPE_BREAKPOINT ; + attr.size =sizeof (attr); + attr.inherit =1 ; + attr.exclude_kernel =1 ; + attr.exclude_hv =1 ; + attr.bp_addr = (uint64_t )addr;
tools/perf/bench/breakpoint.c line 66
Quoted 10 lines
tools/perf/bench/breakpoint.c new file +10
-0+ attr.bp_type =HW_BREAKPOINT_RW ; + attr.bp_len =HW_BREAKPOINT_LEN_1 ; +return syscall (SYS_perf_event_open, &attr,0 ,-1 ,-1 ,0 ); +} + +static void *passive_thread (void *arg) +{ +unsigned int *done = (unsigned int *)arg; + +while (!__atomic_load_n (done, __ATOMIC_RELAXED))
Note, this may be the first change with atomics since Linux moved to C11 which may make the use of stdatomic.h more idiomatic. Just flagging for potential future cleanup.
Thanks,
Ian
Quoted 200 lines
tools/perf/bench/breakpoint.c new file +169
-0+futex_wait (done,0 ,NULL ,0 ); +return NULL ; +} + +static void *active_thread (void *arg) +{ +unsigned int *done = (unsigned int *)arg; + +while (!__atomic_load_n (done, __ATOMIC_RELAXED)); +return NULL ; +} + +static void *breakpoint_thread (void *arg) +{ +unsigned int i, done; +int *repeat = (int *)arg; +pthread_t *threads; + + threads =calloc (thread_params.nthreads,sizeof (threads[0 ])); +while (__atomic_fetch_sub (repeat,1 , __ATOMIC_RELAXED) >0 ) { + done =0 ; +for (i =0 ; i < thread_params.nthreads; i++) { +if (pthread_create (&threads[i],NULL , passive_thread, &done)) +exit ((perror ("pthread_create" ),EXIT_FAILURE )); + } +__atomic_store_n (&done,1 , __ATOMIC_RELAXED); +futex_wake (&done, thread_params.nthreads,0 ); +for (i =0 ; i < thread_params.nthreads; i++) +pthread_join (threads[i],NULL ); + } +free (threads); +return NULL ; +} + +// The benchmark creates nbreakpoints inheritable breakpoints, +// then starts nparallel threads which create and join bench_repeat batches of nthreads threads. +int bench_breakpoint_thread (int argc,const char **argv) +{ +unsigned int i, result_usec; +int repeat = bench_repeat; +struct breakpoint *breakpoints; +pthread_t *parallel; +struct timeval start, stop, diff; + +if (parse_options (argc, argv, thread_options, thread_usage,0 )) { +usage_with_options (thread_usage, thread_options); +exit (EXIT_FAILURE ); + } + breakpoints =calloc (thread_params.nbreakpoints,sizeof (breakpoints[0 ])); + parallel =calloc (thread_params.nparallel,sizeof (parallel[0 ])); +for (i =0 ; i < thread_params.nbreakpoints; i++) { + breakpoints[i].fd =breakpoint_setup (&breakpoints[i].watched); +if (breakpoints[i].fd ==-1 ) +exit ((perror ("perf_event_open" ),EXIT_FAILURE )); + } +gettimeofday (&start,NULL ); +for (i =0 ; i < thread_params.nparallel; i++) { +if (pthread_create (¶llel[i],NULL , breakpoint_thread, &repeat)) +exit ((perror ("pthread_create" ),EXIT_FAILURE )); + } +for (i =0 ; i < thread_params.nparallel; i++) +pthread_join (parallel[i],NULL ); +gettimeofday (&stop,NULL ); +timersub (&stop, &start, &diff); +for (i =0 ; i < thread_params.nbreakpoints; i++) +close (breakpoints[i].fd); +free (parallel); +free (breakpoints); +switch (bench_format) { +case BENCH_FORMAT_DEFAULT : +printf ("# Created/joined %d threads with %d breakpoints and %d parallelism\n" , + bench_repeat, thread_params.nbreakpoints, thread_params.nparallel); +printf (" %14s: %lu.%03lu [sec]\n\n" ,"Total time" , + (long )diff.tv_sec, (long )(diff.tv_usec /USEC_PER_MSEC )); + result_usec = diff.tv_sec *USEC_PER_SEC + diff.tv_usec; +printf (" %14lf usecs/op\n" , + (double )result_usec / bench_repeat / thread_params.nthreads); +printf (" %14lf usecs/op/cpu\n" , + (double )result_usec / bench_repeat / + thread_params.nthreads * thread_params.nparallel); +break ; +case BENCH_FORMAT_SIMPLE : +printf ("%lu.%03lu\n" , (long )diff.tv_sec, (long )(diff.tv_usec /USEC_PER_MSEC )); +break ; +default : +fprintf (stderr,"Unknown format: %d\n" , bench_format); +exit (EXIT_FAILURE ); + } +return 0 ; +} + +struct { +unsigned int npassive; +unsigned int nactive; +} enable_params = { + .nactive =0 , + .npassive =0 , +}; + +static const struct option enable_options[] = { +OPT_UINTEGER ('p' ,"passive" , &enable_params.npassive,"Specify amount of passive threads" ), +OPT_UINTEGER ('a' ,"active" , &enable_params.nactive,"Specify amount of active threads" ), +OPT_END () +}; + +static const char *const enable_usage[] = { +"perf bench breakpoint enable <options>" , +NULL +}; + +// The benchmark creates an inheritable breakpoint, +// then starts npassive threads that block and nactive threads that actively spin +// and then disables and enables the breakpoint bench_repeat times. +int bench_breakpoint_enable (int argc,const char **argv) +{ +unsigned int i, nthreads, result_usec, done =0 ; +char watched; +int fd; +pthread_t *threads; +struct timeval start, stop, diff; + +if (parse_options (argc, argv, enable_options, enable_usage,0 )) { +usage_with_options (enable_usage, enable_options); +exit (EXIT_FAILURE ); + } + fd =breakpoint_setup (&watched); +if (fd ==-1 ) +exit ((perror ("perf_event_open" ),EXIT_FAILURE )); + nthreads = enable_params.npassive + enable_params.nactive; + threads =calloc (nthreads,sizeof (threads[0 ])); +for (i =0 ; i < nthreads; i++) { +if (pthread_create (&threads[i],NULL , + i < enable_params.npassive ? passive_thread : active_thread, &done)) +exit ((perror ("pthread_create" ),EXIT_FAILURE )); + } +usleep (10000 );// let the threads block +gettimeofday (&start,NULL ); +for (i =0 ; i < bench_repeat; i++) { +if (ioctl (fd,PERF_EVENT_IOC_DISABLE ,0 )) +exit ((perror ("ioctl(PERF_EVENT_IOC_DISABLE)" ),EXIT_FAILURE )); +if (ioctl (fd,PERF_EVENT_IOC_ENABLE ,0 )) +exit ((perror ("ioctl(PERF_EVENT_IOC_ENABLE)" ),EXIT_FAILURE )); + } +gettimeofday (&stop,NULL ); +timersub (&stop, &start, &diff); +__atomic_store_n (&done,1 , __ATOMIC_RELAXED); +futex_wake (&done, enable_params.npassive,0 ); +for (i =0 ; i < nthreads; i++) +pthread_join (threads[i],NULL ); +free (threads); +close (fd); +switch (bench_format) { +case BENCH_FORMAT_DEFAULT : +printf ("# Enabled/disabled breakpoint %d time with %d passive and %d active threads\n" , + bench_repeat, enable_params.npassive, enable_params.nactive); +printf (" %14s: %lu.%03lu [sec]\n\n" ,"Total time" , + (long )diff.tv_sec, (long )(diff.tv_usec /USEC_PER_MSEC )); + result_usec = diff.tv_sec *USEC_PER_SEC + diff.tv_usec; +printf (" %14lf usecs/op\n" , (double )result_usec / bench_repeat); +break ; +case BENCH_FORMAT_SIMPLE : +printf ("%lu.%03lu\n" , (long )diff.tv_sec, (long )(diff.tv_usec /USEC_PER_MSEC )); +break ; +default : +fprintf (stderr,"Unknown format: %d\n" , bench_format); +exit (EXIT_FAILURE ); + } +return 0 ; +}tools/perf/builtin-bench.c +8
-0@@ -92,6 +92,13 @@ static struct bench internals_benchmarks[] = { { NULL, NULL, NULL } }; +static struct bench breakpoint_benchmarks[] = { + {"thread" ,"Benchmark thread start/finish with breakpoints" , bench_breakpoint_thread}, + {"enable" ,"Benchmark breakpoint enable/disable" , bench_breakpoint_enable}, + {"all" ,"Run all breakpoint benchmarks" ,NULL }, + {NULL ,NULL ,NULL }, +}; +struct collection {const char *name;const char *summary;@@ -110,6 +117,7 @@ static struct collection collections[] = { {"epoll", "Epoll stressing benchmarks", epoll_benchmarks }, #endif { "internals", "Perf-internals benchmarks", internals_benchmarks }, + { "breakpoint", "Breakpoint benchmarks", breakpoint_benchmarks }, { "all", "All benchmarks", NULL }, { NULL, NULL, NULL } };base-commit:
bd24325684029a48f20a188b899eb84900d0bc9c--
2.36.0.464.gb9c8b46e94-goog
Em Wed, May 11, 2022 at 08:34:58AM -0700, Ian Rogers escreveu:
Quoted 45 lines · Dmitry Vyukov
Quoted 44 lines
Add 2 benchmarks:
1. Performance of thread creation/exiting in presence of breakpoints.
2. Performance of breakpoint modification in presence of threads.The benchmarks capture use cases that we are interested in:
using inheritable breakpoints in large highly-threaded applications. The benchmarks show significant slowdown imposed by breakpoints (even when they don't fire).Testing on Intel 8173M with 112 HW threads show:
perf bench --repeat=56 breakpoint thread --breakpoints=0 --parallelism=56 --threads=20
78.675000 usecs/opperf bench --repeat=56 breakpoint thread --breakpoints=4 --parallelism=56 --threads=20
12967.135714 usecs/op
That's 165x slowdown due to presence of the breakpoints.perf bench --repeat=20000 breakpoint enable --passive=0 --active=0
1.433250 usecs/op perf bench --repeat=20000 breakpoint enable --passive=224 --active=0 585.318400 usecs/op perf bench --repeat=20000 breakpoint enable --passive=0 --active=111 635.953000 usecs/opThat's 408x and 444x slowdown due to presence of threads.
Profiles show some overhead in
toggle_bp_slot,
but also very high contention:90.83% breakpoint-thre [kernel.kallsyms] [k] osq_lock 4.69% breakpoint-thre [kernel.kallsyms] [k] mutex_spin_on_owner 2.06% breakpoint-thre [kernel.kallsyms] [k] __reserve_bp_slot 2.04% breakpoint-thre [kernel.kallsyms] [k] toggle_bp_slot79.01% breakpoint-enab [kernel.kallsyms] [k] smp_call_function_single 9.94% breakpoint-enab [kernel.kallsyms] [k] llist_add_batch 5.70% breakpoint-enab [kernel.kallsyms] [k] _raw_spin_lock_irq 1.84% breakpoint-enab [kernel.kallsyms] [k] event_function_call 1.12% breakpoint-enab [kernel.kallsyms] [k] send_call_function_single_ipi 0.37% breakpoint-enab [kernel.kallsyms] [k] generic_exec_single 0.24% breakpoint-enab [kernel.kallsyms] [k] __perf_event_disable 0.20% breakpoint-enab [kernel.kallsyms] [k] _perf_event_enable 0.18% breakpoint-enab [kernel.kallsyms] [k] toggle_bp_slot
Quoted 3 lines
Quoted 1 line
Signed-off-by Dmitry Vyukov <[email protected]>Acked-by Ian Rogers <[email protected]>
Thanks, applied.
- Arnaldo
Quoted 315 lines
Quoted 97 lines
--- tools/perf/bench/Build | 1 + tools/perf/bench/bench.h | 2 + tools/perf/bench/breakpoint.c | 235 ++++++++++++++++++++++++++++++++++ tools/perf/builtin-bench.c | 8 ++ 4 files changed, 246 insertions(+) create mode 100644 tools/perf/bench/breakpoint.ctools/perf/bench/Build +1
-0@@ -14,6 +14,7 @@ perf-y += kallsyms-parse.o perf-y += find-bit-bench.o perf-y += inject-buildid.o perf-y += evlist-open-close.o +perf-y += breakpoint.o perf-$(CONFIG_X86_64) += mem-memcpy-x86-64-asm.o perf-$(CONFIG_X86_64) += mem-memset-x86-64-asm.otools/perf/bench/bench.h +2
-0@@ -49,6 +49,8 @@ int bench_synthesize(int argc, const char **argv);int bench_kallsyms_parse (int argc,const char **argv);int bench_inject_build_id (int argc,const char **argv);int bench_evlist_open_close (int argc,const char **argv); +int bench_breakpoint_thread (int argc,const char **argv); +int bench_breakpoint_enable (int argc,const char **argv);#define BENCH_FORMAT_DEFAULT_STR "default"#define BENCH_FORMAT_DEFAULT 0tools/perf/bench/breakpoint.c new file +56
-0@@ -0,0 +1,235 @@ +// SPDX-License-Identifier: GPL-2.0 + +#include <subcmd/parse-options.h> +#include <linux/hw_breakpoint.h> +#include <linux/perf_event.h> +#include <linux/time64.h> +#include <sys/syscall.h> +#include <sys/ioctl.h> +#include <sys/time.h> +#include <pthread.h> +#include <stddef.h> +#include <stdlib.h> +#include <unistd.h> +#include <stdio.h> +#include <errno.h> +#include "bench.h" +#include "futex.h" + +struct { +unsigned int nbreakpoints; +unsigned int nparallel; +unsigned int nthreads; +} thread_params = { + .nbreakpoints =1 , + .nparallel =1 , + .nthreads =1 , +}; + +static const struct option thread_options[] = { +OPT_UINTEGER ('b' ,"breakpoints" , &thread_params.nbreakpoints, +"Specify amount of breakpoints" ), +OPT_UINTEGER ('p' ,"parallelism" , &thread_params.nparallel,"Specify amount of parallelism" ), +OPT_UINTEGER ('t' ,"threads" , &thread_params.nthreads,"Specify amount of threads" ), +OPT_END () +}; + +static const char *const thread_usage[] = { +"perf bench breakpoint thread <options>" , +NULL +}; + +struct breakpoint { +int fd; +char watched; +}; + +static int breakpoint_setup (void *addr) +{ +struct perf_event_attr attr = {0 }; + + attr.type =PERF_TYPE_BREAKPOINT ; + attr.size =sizeof (attr); + attr.inherit =1 ; + attr.exclude_kernel =1 ; + attr.exclude_hv =1 ; + attr.bp_addr = (uint64_t )addr;tools/perf/bench/breakpoint.c line 66
Quoted 10 lines
tools/perf/bench/breakpoint.c new file +10
-0+ attr.bp_type =HW_BREAKPOINT_RW ; + attr.bp_len =HW_BREAKPOINT_LEN_1 ; +return syscall (SYS_perf_event_open, &attr,0 ,-1 ,-1 ,0 ); +} + +static void *passive_thread (void *arg) +{ +unsigned int *done = (unsigned int *)arg; + +while (!__atomic_load_n (done, __ATOMIC_RELAXED))Note, this may be the first change with atomics since Linux moved to C11 which may make the use of
stdatomic.hmore idiomatic. Just flagging for potential future cleanup.Thanks,
IanQuoted 200 lines
tools/perf/bench/breakpoint.c new file +169
-0+futex_wait (done,0 ,NULL ,0 ); +return NULL ; +} + +static void *active_thread (void *arg) +{ +unsigned int *done = (unsigned int *)arg; + +while (!__atomic_load_n (done, __ATOMIC_RELAXED)); +return NULL ; +} + +static void *breakpoint_thread (void *arg) +{ +unsigned int i, done; +int *repeat = (int *)arg; +pthread_t *threads; + + threads =calloc (thread_params.nthreads,sizeof (threads[0 ])); +while (__atomic_fetch_sub (repeat,1 , __ATOMIC_RELAXED) >0 ) { + done =0 ; +for (i =0 ; i < thread_params.nthreads; i++) { +if (pthread_create (&threads[i],NULL , passive_thread, &done)) +exit ((perror ("pthread_create" ),EXIT_FAILURE )); + } +__atomic_store_n (&done,1 , __ATOMIC_RELAXED); +futex_wake (&done, thread_params.nthreads,0 ); +for (i =0 ; i < thread_params.nthreads; i++) +pthread_join (threads[i],NULL ); + } +free (threads); +return NULL ; +} + +// The benchmark creates nbreakpoints inheritable breakpoints, +// then starts nparallel threads which create and join bench_repeat batches of nthreads threads. +int bench_breakpoint_thread (int argc,const char **argv) +{ +unsigned int i, result_usec; +int repeat = bench_repeat; +struct breakpoint *breakpoints; +pthread_t *parallel; +struct timeval start, stop, diff; + +if (parse_options (argc, argv, thread_options, thread_usage,0 )) { +usage_with_options (thread_usage, thread_options); +exit (EXIT_FAILURE ); + } + breakpoints =calloc (thread_params.nbreakpoints,sizeof (breakpoints[0 ])); + parallel =calloc (thread_params.nparallel,sizeof (parallel[0 ])); +for (i =0 ; i < thread_params.nbreakpoints; i++) { + breakpoints[i].fd =breakpoint_setup (&breakpoints[i].watched); +if (breakpoints[i].fd ==-1 ) +exit ((perror ("perf_event_open" ),EXIT_FAILURE )); + } +gettimeofday (&start,NULL ); +for (i =0 ; i < thread_params.nparallel; i++) { +if (pthread_create (¶llel[i],NULL , breakpoint_thread, &repeat)) +exit ((perror ("pthread_create" ),EXIT_FAILURE )); + } +for (i =0 ; i < thread_params.nparallel; i++) +pthread_join (parallel[i],NULL ); +gettimeofday (&stop,NULL ); +timersub (&stop, &start, &diff); +for (i =0 ; i < thread_params.nbreakpoints; i++) +close (breakpoints[i].fd); +free (parallel); +free (breakpoints); +switch (bench_format) { +case BENCH_FORMAT_DEFAULT : +printf ("# Created/joined %d threads with %d breakpoints and %d parallelism\n" , + bench_repeat, thread_params.nbreakpoints, thread_params.nparallel); +printf (" %14s: %lu.%03lu [sec]\n\n" ,"Total time" , + (long )diff.tv_sec, (long )(diff.tv_usec /USEC_PER_MSEC )); + result_usec = diff.tv_sec *USEC_PER_SEC + diff.tv_usec; +printf (" %14lf usecs/op\n" , + (double )result_usec / bench_repeat / thread_params.nthreads); +printf (" %14lf usecs/op/cpu\n" , + (double )result_usec / bench_repeat / + thread_params.nthreads * thread_params.nparallel); +break ; +case BENCH_FORMAT_SIMPLE : +printf ("%lu.%03lu\n" , (long )diff.tv_sec, (long )(diff.tv_usec /USEC_PER_MSEC )); +break ; +default : +fprintf (stderr,"Unknown format: %d\n" , bench_format); +exit (EXIT_FAILURE ); + } +return 0 ; +} + +struct { +unsigned int npassive; +unsigned int nactive; +} enable_params = { + .nactive =0 , + .npassive =0 , +}; + +static const struct option enable_options[] = { +OPT_UINTEGER ('p' ,"passive" , &enable_params.npassive,"Specify amount of passive threads" ), +OPT_UINTEGER ('a' ,"active" , &enable_params.nactive,"Specify amount of active threads" ), +OPT_END () +}; + +static const char *const enable_usage[] = { +"perf bench breakpoint enable <options>" , +NULL +}; + +// The benchmark creates an inheritable breakpoint, +// then starts npassive threads that block and nactive threads that actively spin +// and then disables and enables the breakpoint bench_repeat times. +int bench_breakpoint_enable (int argc,const char **argv) +{ +unsigned int i, nthreads, result_usec, done =0 ; +char watched; +int fd; +pthread_t *threads; +struct timeval start, stop, diff; + +if (parse_options (argc, argv, enable_options, enable_usage,0 )) { +usage_with_options (enable_usage, enable_options); +exit (EXIT_FAILURE ); + } + fd =breakpoint_setup (&watched); +if (fd ==-1 ) +exit ((perror ("perf_event_open" ),EXIT_FAILURE )); + nthreads = enable_params.npassive + enable_params.nactive; + threads =calloc (nthreads,sizeof (threads[0 ])); +for (i =0 ; i < nthreads; i++) { +if (pthread_create (&threads[i],NULL , + i < enable_params.npassive ? passive_thread : active_thread, &done)) +exit ((perror ("pthread_create" ),EXIT_FAILURE )); + } +usleep (10000 );// let the threads block +gettimeofday (&start,NULL ); +for (i =0 ; i < bench_repeat; i++) { +if (ioctl (fd,PERF_EVENT_IOC_DISABLE ,0 )) +exit ((perror ("ioctl(PERF_EVENT_IOC_DISABLE)" ),EXIT_FAILURE )); +if (ioctl (fd,PERF_EVENT_IOC_ENABLE ,0 )) +exit ((perror ("ioctl(PERF_EVENT_IOC_ENABLE)" ),EXIT_FAILURE )); + } +gettimeofday (&stop,NULL ); +timersub (&stop, &start, &diff); +__atomic_store_n (&done,1 , __ATOMIC_RELAXED); +futex_wake (&done, enable_params.npassive,0 ); +for (i =0 ; i < nthreads; i++) +pthread_join (threads[i],NULL ); +free (threads); +close (fd); +switch (bench_format) { +case BENCH_FORMAT_DEFAULT : +printf ("# Enabled/disabled breakpoint %d time with %d passive and %d active threads\n" , + bench_repeat, enable_params.npassive, enable_params.nactive); +printf (" %14s: %lu.%03lu [sec]\n\n" ,"Total time" , + (long )diff.tv_sec, (long )(diff.tv_usec /USEC_PER_MSEC )); + result_usec = diff.tv_sec *USEC_PER_SEC + diff.tv_usec; +printf (" %14lf usecs/op\n" , (double )result_usec / bench_repeat); +break ; +case BENCH_FORMAT_SIMPLE : +printf ("%lu.%03lu\n" , (long )diff.tv_sec, (long )(diff.tv_usec /USEC_PER_MSEC )); +break ; +default : +fprintf (stderr,"Unknown format: %d\n" , bench_format); +exit (EXIT_FAILURE ); + } +return 0 ; +}tools/perf/builtin-bench.c +8
-0@@ -92,6 +92,13 @@ static struct bench internals_benchmarks[] = { { NULL, NULL, NULL } }; +static struct bench breakpoint_benchmarks[] = { + {"thread" ,"Benchmark thread start/finish with breakpoints" , bench_breakpoint_thread}, + {"enable" ,"Benchmark breakpoint enable/disable" , bench_breakpoint_enable}, + {"all" ,"Run all breakpoint benchmarks" ,NULL }, + {NULL ,NULL ,NULL }, +}; +struct collection {const char *name;const char *summary;@@ -110,6 +117,7 @@ static struct collection collections[] = { {"epoll", "Epoll stressing benchmarks", epoll_benchmarks }, #endif { "internals", "Perf-internals benchmarks", internals_benchmarks }, + { "breakpoint", "Breakpoint benchmarks", breakpoint_benchmarks }, { "all", "All benchmarks", NULL }, { NULL, NULL, NULL } };base-commit:
bd24325684029a48f20a188b899eb84900d0bc9c--
2.36.0.464.gb9c8b46e94-goog
Signature · 1 line
- Arnaldo
Arnaldo Carvalho de Melo
maintainerEm Wed, May 11, 2022 at 03:08:02PM -0300, Arnaldo Carvalho de Melo escreveu:
Quoted 46 lines
Em Wed, May 11, 2022 at 08:34:58AM -0700, Ian Rogers escreveu:
Quoted 45 lines · Dmitry Vyukov
Quoted 44 lines
Add 2 benchmarks:
1. Performance of thread creation/exiting in presence of breakpoints.
2. Performance of breakpoint modification in presence of threads.The benchmarks capture use cases that we are interested in:
using inheritable breakpoints in large highly-threaded applications. The benchmarks show significant slowdown imposed by breakpoints (even when they don't fire).Testing on Intel 8173M with 112 HW threads show:
perf bench --repeat=56 breakpoint thread --breakpoints=0 --parallelism=56 --threads=20
78.675000 usecs/opperf bench --repeat=56 breakpoint thread --breakpoints=4 --parallelism=56 --threads=20
12967.135714 usecs/op
That's 165x slowdown due to presence of the breakpoints.perf bench --repeat=20000 breakpoint enable --passive=0 --active=0
1.433250 usecs/op perf bench --repeat=20000 breakpoint enable --passive=224 --active=0 585.318400 usecs/op perf bench --repeat=20000 breakpoint enable --passive=0 --active=111 635.953000 usecs/opThat's 408x and 444x slowdown due to presence of threads.
Profiles show some overhead in
toggle_bp_slot,
but also very high contention:90.83% breakpoint-thre [kernel.kallsyms] [k] osq_lock 4.69% breakpoint-thre [kernel.kallsyms] [k] mutex_spin_on_owner 2.06% breakpoint-thre [kernel.kallsyms] [k] __reserve_bp_slot 2.04% breakpoint-thre [kernel.kallsyms] [k] toggle_bp_slot79.01% breakpoint-enab [kernel.kallsyms] [k] smp_call_function_single 9.94% breakpoint-enab [kernel.kallsyms] [k] llist_add_batch 5.70% breakpoint-enab [kernel.kallsyms] [k] _raw_spin_lock_irq 1.84% breakpoint-enab [kernel.kallsyms] [k] event_function_call 1.12% breakpoint-enab [kernel.kallsyms] [k] send_call_function_single_ipi 0.37% breakpoint-enab [kernel.kallsyms] [k] generic_exec_single 0.24% breakpoint-enab [kernel.kallsyms] [k] __perf_event_disable 0.20% breakpoint-enab [kernel.kallsyms] [k] _perf_event_enable 0.18% breakpoint-enab [kernel.kallsyms] [k] toggle_bp_slot
Quoted 5 lines
Quoted 3 lines
Quoted 1 line
Signed-off-by Dmitry Vyukov <[email protected]>Acked-by Ian Rogers <[email protected]>Thanks, applied.
But I'll add some error checks, etc, running as !root, in a toolbox in Fedora Silverblue produces:
⬢[acme@toolbox perf]$ perf bench breakpoint all
# Running breakpoint/thread benchmark...
# Created/joined 10 threads with 1 breakpoints and 1 parallelism
Total time: 0.000 [sec]
54.600000 usecs/op
54.600000 usecs/op/cpu# Running breakpoint/enable benchmark...
# Enabled/disabled breakpoint 10 time with 0 passive and 0 active threads
Total time: 0.000 [sec]
1.100000 usecs/op⬢[acme@toolbox perf]$
⬢[acme@toolbox perf]$ perf bench --repeat=20000 breakpoint enable --passive=224 --active=0 # Running 'breakpoint/enable' benchmark:
# Enabled/disabled breakpoint 20000 time with 224 passive and 0 active threads
Total time: 8.933 [sec]
446.674950 usecs/op⬢[acme@toolbox perf]$
$ grep -m1 "model name" /proc/cpuinfo model name : AMD Ryzen 9 5950X 16-Core Processor
Diff:
tools/perf/bench/breakpoint.c +9 -0
@@ -83,6 +83,9 @@ static void *breakpoint_thread(void *arg)pthread_t *threads; threads =calloc (thread_params.nthreads,sizeof (threads[0 ])); +if (!threads) +exit ((perror ("calloc" ),EXIT_FAILURE )); +while (__atomic_fetch_sub (repeat,1 , __ATOMIC_RELAXED) >0 ) { done =0 ;for (i =0 ; i < thread_params.nthreads; i++) {
@@ -114,6 +117,9 @@ int bench_breakpoint_thread(int argc, const char **argv) } breakpoints =calloc (thread_params.nbreakpoints,sizeof (breakpoints[0 ])); parallel =calloc (thread_params.nparallel,sizeof (parallel[0 ])); +if (!breakpoints || !parallel) +exit ((perror ("calloc" ),EXIT_FAILURE )); +for (i =0 ; i < thread_params.nbreakpoints; i++) { breakpoints[i].fd =breakpoint_setup (&breakpoints[i].watched);if (breakpoints[i].fd ==-1 )
@@ -194,6 +200,9 @@ int bench_breakpoint_enable(int argc, const char **argv)exit ((perror ("perf_event_open" ),EXIT_FAILURE )); nthreads = enable_params.npassive + enable_params.nactive; threads =calloc (nthreads,sizeof (threads[0 ])); +if (!threads) +exit ((perror ("calloc" ),EXIT_FAILURE )); +for (i =0 ; i < nthreads; i++) {if (pthread_create (&threads[i],NULL , i < enable_params.npassive ? passive_thread : active_thread, &done))
Quoted 7 lines · Arnaldo Carvalho de Melo
Quoted 4 lines
Quoted 2 lines
Acked-by Ian Rogers <[email protected]>Thanks, applied.
But I'll add some error checks, etc, running as !root, in a toolbox in Fedora Silverblue produces:
Thanks!
Quoted 63 lines
⬢[acme@toolbox perf]$ perf bench breakpoint all
# Running breakpoint/thread benchmark...
# Created/joined 10 threads with 1 breakpoints and 1 parallelismTotal time: 0.000 [sec] 54.600000 usecs/op 54.600000 usecs/op/cpu# Running breakpoint/enable benchmark...
# Enabled/disabled breakpoint 10 time with 0 passive and 0 active threadsTotal time: 0.000 [sec] 1.100000 usecs/op⬢[acme@toolbox perf]$
⬢[acme@toolbox perf]$ perf bench --repeat=20000 breakpoint enable --passive=224 --active=0 # Running 'breakpoint/enable' benchmark:
# Enabled/disabled breakpoint 20000 time with 224 passive and 0 active threadsTotal time: 8.933 [sec] 446.674950 usecs/op⬢[acme@toolbox perf]$
$ grep -m1 "model name" /proc/cpuinfo model name : AMD Ryzen 9 5950X 16-Core ProcessorDiff:
tools/perf/bench/breakpoint.c +9
-0@@ -83,6 +83,9 @@ static void *breakpoint_thread(void *arg)pthread_t *threads; threads =calloc (thread_params.nthreads,sizeof (threads[0 ])); +if (!threads) +exit ((perror ("calloc" ),EXIT_FAILURE )); +while (__atomic_fetch_sub (repeat,1 , __ATOMIC_RELAXED) >0 ) { done =0 ;for (i =0 ; i < thread_params.nthreads; i++) {@@ -114,6 +117,9 @@ int bench_breakpoint_thread(int argc, const char **argv) } breakpoints =calloc (thread_params.nbreakpoints,sizeof (breakpoints[0 ])); parallel =calloc (thread_params.nparallel,sizeof (parallel[0 ])); +if (!breakpoints || !parallel) +exit ((perror ("calloc" ),EXIT_FAILURE )); +for (i =0 ; i < thread_params.nbreakpoints; i++) { breakpoints[i].fd =breakpoint_setup (&breakpoints[i].watched);if (breakpoints[i].fd ==-1 )@@ -194,6 +200,9 @@ int bench_breakpoint_enable(int argc, const char **argv)exit ((perror ("perf_event_open" ),EXIT_FAILURE )); nthreads = enable_params.npassive + enable_params.nactive; threads =calloc (nthreads,sizeof (threads[0 ])); +if (!threads) +exit ((perror ("calloc" ),EXIT_FAILURE )); +for (i =0 ; i < nthreads; i++) {if (pthread_create (&threads[i],NULL , i < enable_params.npassive ? passive_thread : active_thread, &done))
Quoted 153 lines · Ian Rogers
Quoted 44 lines · Dmitry Vyukov
Add 2 benchmarks:
1. Performance of thread creation/exiting in presence of breakpoints.
2. Performance of breakpoint modification in presence of threads.The benchmarks capture use cases that we are interested in:
using inheritable breakpoints in large highly-threaded applications. The benchmarks show significant slowdown imposed by breakpoints (even when they don't fire).Testing on Intel 8173M with 112 HW threads show:
perf bench --repeat=56 breakpoint thread --breakpoints=0 --parallelism=56 --threads=20
78.675000 usecs/opperf bench --repeat=56 breakpoint thread --breakpoints=4 --parallelism=56 --threads=20
12967.135714 usecs/op
That's 165x slowdown due to presence of the breakpoints.perf bench --repeat=20000 breakpoint enable --passive=0 --active=0
1.433250 usecs/op perf bench --repeat=20000 breakpoint enable --passive=224 --active=0 585.318400 usecs/op perf bench --repeat=20000 breakpoint enable --passive=0 --active=111 635.953000 usecs/opThat's 408x and 444x slowdown due to presence of threads.
Profiles show some overhead in
toggle_bp_slot,
but also very high contention:90.83% breakpoint-thre [kernel.kallsyms] [k] osq_lock 4.69% breakpoint-thre [kernel.kallsyms] [k] mutex_spin_on_owner 2.06% breakpoint-thre [kernel.kallsyms] [k] __reserve_bp_slot 2.04% breakpoint-thre [kernel.kallsyms] [k] toggle_bp_slot79.01% breakpoint-enab [kernel.kallsyms] [k] smp_call_function_single 9.94% breakpoint-enab [kernel.kallsyms] [k] llist_add_batch 5.70% breakpoint-enab [kernel.kallsyms] [k] _raw_spin_lock_irq 1.84% breakpoint-enab [kernel.kallsyms] [k] event_function_call 1.12% breakpoint-enab [kernel.kallsyms] [k] send_call_function_single_ipi 0.37% breakpoint-enab [kernel.kallsyms] [k] generic_exec_single 0.24% breakpoint-enab [kernel.kallsyms] [k] __perf_event_disable 0.20% breakpoint-enab [kernel.kallsyms] [k] _perf_event_enable 0.18% breakpoint-enab [kernel.kallsyms] [k] toggle_bp_slotQuoted 1 line
Signed-off-by Dmitry Vyukov <[email protected]>Acked-by Ian Rogers <[email protected]>Quoted 103 lines
--- tools/perf/bench/Build | 1 + tools/perf/bench/bench.h | 2 + tools/perf/bench/breakpoint.c | 235 ++++++++++++++++++++++++++++++++++ tools/perf/builtin-bench.c | 8 ++ 4 files changed, 246 insertions(+) create mode 100644 tools/perf/bench/breakpoint.ctools/perf/bench/Build +1
-0@@ -14,6 +14,7 @@ perf-y += kallsyms-parse.o perf-y += find-bit-bench.o perf-y += inject-buildid.o perf-y += evlist-open-close.o +perf-y += breakpoint.o perf-$(CONFIG_X86_64) += mem-memcpy-x86-64-asm.o perf-$(CONFIG_X86_64) += mem-memset-x86-64-asm.otools/perf/bench/bench.h +2
-0@@ -49,6 +49,8 @@ int bench_synthesize(int argc, const char **argv);int bench_kallsyms_parse (int argc,const char **argv);int bench_inject_build_id (int argc,const char **argv);int bench_evlist_open_close (int argc,const char **argv); +int bench_breakpoint_thread (int argc,const char **argv); +int bench_breakpoint_enable (int argc,const char **argv);#define BENCH_FORMAT_DEFAULT_STR "default"#define BENCH_FORMAT_DEFAULT 0tools/perf/bench/breakpoint.c new file +62
-0@@ -0,0 +1,235 @@ +// SPDX-License-Identifier: GPL-2.0 + +#include <subcmd/parse-options.h> +#include <linux/hw_breakpoint.h> +#include <linux/perf_event.h> +#include <linux/time64.h> +#include <sys/syscall.h> +#include <sys/ioctl.h> +#include <sys/time.h> +#include <pthread.h> +#include <stddef.h> +#include <stdlib.h> +#include <unistd.h> +#include <stdio.h> +#include <errno.h> +#include "bench.h" +#include "futex.h" + +struct { +unsigned int nbreakpoints; +unsigned int nparallel; +unsigned int nthreads; +} thread_params = { + .nbreakpoints =1 , + .nparallel =1 , + .nthreads =1 , +}; + +static const struct option thread_options[] = { +OPT_UINTEGER ('b' ,"breakpoints" , &thread_params.nbreakpoints, +"Specify amount of breakpoints" ), +OPT_UINTEGER ('p' ,"parallelism" , &thread_params.nparallel,"Specify amount of parallelism" ), +OPT_UINTEGER ('t' ,"threads" , &thread_params.nthreads,"Specify amount of threads" ), +OPT_END () +}; + +static const char *const thread_usage[] = { +"perf bench breakpoint thread <options>" , +NULL +}; + +struct breakpoint { +int fd; +char watched; +}; + +static int breakpoint_setup (void *addr) +{ +struct perf_event_attr attr = {0 }; + + attr.type =PERF_TYPE_BREAKPOINT ; + attr.size =sizeof (attr); + attr.inherit =1 ; + attr.exclude_kernel =1 ; + attr.exclude_hv =1 ; + attr.bp_addr = (uint64_t )addr; + attr.bp_type =HW_BREAKPOINT_RW ; + attr.bp_len =HW_BREAKPOINT_LEN_1 ; +return syscall (SYS_perf_event_open, &attr,0 ,-1 ,-1 ,0 ); +} + +static void *passive_thread (void *arg)
Quoted 8 lines
tools/perf/bench/breakpoint.c line 66
Quoted 4 lines
tools/perf/bench/breakpoint.c new file +4
-0+{ +unsigned int *done = (unsigned int *)arg; + +while (!__atomic_load_n (done, __ATOMIC_RELAXED))Note, this may be the first change with atomics since Linux moved to C11 which may make the use of
stdatomic.hmore idiomatic. Just flagging for potential future cleanup.
I am ready to send a follow up with stdatomic.h if that's considered a better option.