perf record --off-cpu: Dump off-cpu samples directly
v9 cover perf record --off-cpu: Dump off-cpu samples directly
Changes in v9:
- Add documentation for the new option '--off-cpu-thresh', and include an example of its usage in the commit message
- Set inherit in evsel__config() to prevent future modifications
- Support off-cpu sample data collected by perf before this patch series
Changes in v8:
- Make this series bisectable
- Rename off_cpu_thresh to off_cpu_thresh_us and offcpu_thresh (in BPF) to offcpu_thresh_ns for clarity
- Add commit messages to 'perf evsel: Expose evsel__is_offcpu_event() for future use' commit
- Correct spelling mistakes in the commit message (s/is should be/should be/)
- Add kernel-doc comments to off_cpu_dump(), and comments to the empty if block
- Add some comments to off-cpu test
- Delete an unused variable 'timestamp' in off_cpu_dump()
Changes in v7:
- Make off-cpu event system-wide
- Use strtoull instead of strtoul
- Delete unused variable such as sample_id, and sample_type
- Use i as index to update BPF perf_event map
- MAX_OFFCPU_LEN 128 is too big, make it smaller.
- Delete some bound check as it's always guaranteed
- Do not set ip_pos in BPF
- Add a new field for storing stack traces in the tstamp map
- Dump the off-cpu sample directly or save it in the off_cpu map, not both
- Delete the sample_type_off_cpu check
- Use __set_off_cpu_sample() to parse samples instead of a two-pass parsing
Changes in v6:
- Make patches bisectable
Changes in v5:
- Delete unnecessary copy in BPF program
- Remove sample_embed from perf header, hard code off-cpu stuff instead
- Move evsel__is_offcpu_event() to evsel.h
- Minor changes to the test
- Edit some comments
Changes in v4:
- Minimize the size of data output by perf_event_output()
- Keep only one off-cpu event
- Change off-cpu threshold's unit to microseconds
- Set a default off-cpu threshold
- Print the correct error message for the field 'embed' in perf data header
Changes in v3:
- Add off-cpu-thresh argument
- Process direct off-cpu samples in post
Changes in v2:
- Remove unnecessary comments.
- Rename function off_cpu_change_type to off_cpu_prepare_parse
v1:
As mentioned in: https://bugzilla.kernel.org/show_bug.cgi?id=207323
Currently, off-cpu samples are dumped when perf record is exiting. This results in off-cpu samples being after the regular samples. This patch series makes possible dumping off-cpu samples on-the-fly, directly into perf ring buffer. And it dispatches those samples to the correct format for perf.data consumers.
Before:
```
migration/0 21 [000] 27981.041319: 2944637851 cycles:P: ffffffff90d2e8aa record_times+0xa ([kernel.kallsyms])
perf 770116 [001] 27981.041375: 1 cycles:P: ffffffff90ee4960 event_function+0xf0 ([kernel.kallsyms])
perf 770116 [001] 27981.041377: 1 cycles:P: ffffffff90c184b1 intel_bts_enable_local+0x31 ([kernel.kallsyms])
perf 770116 [001] 27981.041379: 51611 cycles:P: ffffffff91a160b0 native_sched_clock+0x30 ([kernel.kallsyms])
migration/1 26 [001] 27981.041400: 4227682775 cycles:P: ffffffff90d06a74 wakeup_preempt+0x44 ([kernel.kallsyms])
migration/2 32 [002] 27981.041477: 4159401534 cycles:P: ffffffff90d11993 update_load_avg+0x63 ([kernel.kallsyms])
sshd 708098 [000] 18446744069.414584: 286392 offcpu-time:
79a864f1c8bb ppoll+0x4b (/usr/lib/libc.so.6)
585690935cca [unknown] (/usr/bin/sshd)
```After:
```
perf 774767 [003] 28178.033444: 497 cycles:P: ffffffff91a160c3 native_sched_clock+0x43 ([kernel.kallsyms])
perf 774767 [003] 28178.033445: 399440 cycles:P: ffffffff91c01f8d nmi_restore+0x25 ([kernel.kallsyms])
swapper 0 [001] 28178.036639: 376650973 cycles:P: ffffffff91a1ae99 intel_idle+0x59 ([kernel.kallsyms])
swapper 0 [003] 28178.182921: 348779378 cycles:P: ffffffff91a1ae99 intel_idle+0x59 ([kernel.kallsyms])
blueman-tray 1355 [000] 28178.627906: 100184571 offcpu-time:
7528eef1c39d __poll+0x4d (/usr/lib/libc.so.6)
7528edf7d8fd [unknown] (/usr/lib/libglib-2.0.so.0.8000.2)
7528edf1af95 g_main_context_iteration+0x35 (/usr/lib/libglib-2.0.so.0.8000.2)
7528eda4ab86 g_application_run+0x1f6 (/usr/lib/libgio-2.0.so.0.8000.2)
7528ee6aa596 [unknown] (/usr/lib/libffi.so.8.1.4)
7fff24e862d8 [unknown] ([unknown])
blueman-tray 1355 [000] 28178.728137: 100187539 offcpu-time:
7528eef1c39d __poll+0x4d (/usr/lib/libc.so.6)
7528edf7d8fd [unknown] (/usr/lib/libglib-2.0.so.0.8000.2)
7528edf1af95 g_main_context_iteration+0x35 (/usr/lib/libglib-2.0.so.0.8000.2)
7528eda4ab86 g_application_run+0x1f6 (/usr/lib/libgio-2.0.so.0.8000.2)
7528ee6aa596 [unknown] (/usr/lib/libffi.so.8.1.4)
7fff24e862d8 [unknown] ([unknown])
swapper 0 [000] 28178.463253: 195945410 cycles:P: ffffffff91a1ae99 intel_idle+0x59 ([kernel.kallsyms])
dbus-broker 412 [002] 28178.464855: 376737008 cycles:P: ffffffff91c000a0 entry_SYSCALL_64+0x20 ([kernel.kallsyms])
```Howard Chu (10):
perf record --off-cpu: Add --off-cpu-thresh option
perf evsel: Expose evsel__is_offcpu_event() for future use perf record --off-cpu: Parse off-cpu event
perf record --off-cpu: Preparation of off-cpu BPF program perf record --off-cpu: Dump off-cpu samples in BPF
perf evsel: Assemble offcpu samples
perf record --off-cpu: Disable perf_event's callchain collection perf script: Display off-cpu samples correctly
perf record --off-cpu: Dump the remaining samples in BPF's stack trace
map
perf test: Add direct off-cpu test
tools/perf/Documentation/perf-record.txt | 9 ++ tools/perf/builtin-record.c | 26 +++++ tools/perf/builtin-script.c | 4 +- tools/perf/tests/builtin-test.c | 1 + tools/perf/tests/shell/record_offcpu.sh | 35 ++++++- tools/perf/tests/tests.h | 1 + tools/perf/tests/workloads/Build | 1 + tools/perf/tests/workloads/offcpu.c | 16 ++++ tools/perf/util/bpf_off_cpu.c | 117 ++++++++++++++--------- tools/perf/util/bpf_skel/off_cpu.bpf.c | 97 ++++++++++++++++++- tools/perf/util/evsel.c | 41 +++++++- tools/perf/util/evsel.h | 2 + tools/perf/util/off_cpu.h | 3 +- tools/perf/util/record.h | 1 + 14 files changed, 296 insertions(+), 58 deletions(-) create mode 100644 tools/perf/tests/workloads/offcpu.c
Signature · 1 line
2.43.0
PATCH v9 1/10 perf record --off-cpu: Add --off-cpu-thresh option
Specify the threshold for dumping offcpu samples with --off-cpu-thresh, the unit is us (microsecond). Default value is 500,000us (500ms, 0.5s).
Example:
perf record --off-cpu --off-cpu-thresh 400000
The example above collects off-cpu samples whose off-cpu time is longer than 400,000us
--- tools/perf/Documentation/perf-record.txt | 9 ++++++++ tools/perf/builtin-record.c | 26 ++++++++++++++++++++++++ tools/perf/util/off_cpu.h | 1 + tools/perf/util/record.h | 1 + 4 files changed, 37 insertions(+)
tools/perf/Documentation/perf-record.txt +9 -0
@@ -829,6 +829,15 @@ filtered through the mask provided by -C option. only, as of now. So the applications built without the frame pointer might see bogus addresses. + off-cpu profiling consists two types of samples: direct samples, which + share the same behavior as regular samples, and the accumulated + samples, stored in BPF stack trace map, presented after all the regular + samples. + +--off-cpu-thresh:: + Once a task's off-cpu time reaches this threshold, it generates a + direct off-cpu sample. + --setup-filter=<action>:: Prepare BPF filter to be used by regular users. The action should be either "pin" or "unpin". The filter can be used after it's pinned.
tools/perf/builtin-record.c +26 -0
@@ -3149,6 +3149,28 @@ static int record__parse_mmap_pages(const struct option *opt,return ret; } +static int record__parse_off_cpu_thresh (const struct option *opt, +const char *str, +int unset__maybe_unused ) +{ +struct record_opts *opts = opt->value; +char *endptr; +u64 off_cpu_thresh_us; + +if (!str) +return -EINVAL ; + + off_cpu_thresh_us =strtoull (str, &endptr,10 ); + +/* threshold isn't string "0", yet strtoull() returns 0, parsing failed */ +if (*endptr || (off_cpu_thresh_us ==0 &&strcmp (str,"0" ))) +return -EINVAL ; +else + opts->off_cpu_thresh_us = off_cpu_thresh_us; + +return 0 ; +} +void __weak arch__add_leaf_frame_record_opts (struct record_opts *opts__maybe_unused ) { }
@@ -3342,6 +3364,7 @@ static struct record record = { .ctl_fd = -1, .ctl_fd_ack = -1, .synth = PERF_SYNTH_ALL, + .off_cpu_thresh_us = OFFCPU_THRESH, }, };
@@ -3564,6 +3587,9 @@ static struct option __record_options[] = {OPT_BOOLEAN (0 ,"off-cpu" , &record.off_cpu,"Enable off-cpu analysis" ),OPT_STRING (0 ,"setup-filter" , &record.filter_action,"pin|unpin" ,"BPF filter action" ), +OPT_CALLBACK (0 ,"off-cpu-thresh" , &record.opts,"us" , +"Dump off-cpu samples if off-cpu time reaches this threshold. The unit is microsecond (default: 500000)" , + record__parse_off_cpu_thresh), OPT_END() };
tools/perf/util/off_cpu.h +1 -0
@@ -16,6 +16,7 @@ struct record_opts; PERF_SAMPLE_PERIOD | PERF_SAMPLE_CALLCHAIN | \ PERF_SAMPLE_CGROUP) +#define OFFCPU_THRESH 500000ull#ifdef HAVE_BPF_SKEL int off_cpu_prepare(struct evlist *evlist, struct target *target,
tools/perf/util/record.h +1 -0
@@ -79,6 +79,7 @@ struct record_opts {int synth;int threads_spec;const char *threads_user_spec; +u64 off_cpu_thresh_us; };extern const char *const *record_usage;
Signature · 1 line
2.43.0
Namhyung Kim
maintainerRe: [PATCH v9 01/10] perf record --off-cpu: Add --off-cpu-thresh option
Hi Howard,
Sorry for the late review.
Quoted 2 lines · Howard Chu
Specify the threshold for dumping offcpu samples with --off-cpu-thresh, the unit is us (microsecond). Default value is 500,000us (500ms, 0.5s).
I guess we mostly care about more than milli-seconds of off-cpu times. Can we change the unit to msec?
Also I think this commit can be moved to later in this series - like after implementing direct offcpu samples. If I see the commit in history later, I'd think it works. But it's not at this point.
Otherwise, looks all good to me. :)
Thanks,
Namhyung
Quoted 129 lines
Example:
perf record --off-cpu --off-cpu-thresh 400000The example above collects off-cpu samples whose off-cpu time is longer than 400,000us
Suggested-by Ian Rogers <[email protected]>Suggested-by Namhyung Kim <[email protected]>Suggested-by Arnaldo Carvalho de Melo <[email protected]>Reviewed-by Ian Rogers <[email protected]>Signed-off-by Howard Chu <[email protected]>Cc Adrian Hunter <[email protected]>Cc Alexander Shishkin <[email protected]>Cc Ingo Molnar <[email protected]>Cc James Clark <[email protected]>Cc Jiri Olsa <[email protected]>Cc Kan Liang <[email protected]>Cc Mark Rutland <[email protected]>Cc Namhyung Kim <[email protected]>Cc Peter Zijlstra <[email protected]>Signed-off-by Arnaldo Carvalho de Melo <[email protected]>--- tools/perf/Documentation/perf-record.txt | 9 ++++++++ tools/perf/builtin-record.c | 26 ++++++++++++++++++++++++ tools/perf/util/off_cpu.h | 1 + tools/perf/util/record.h | 1 + 4 files changed, 37 insertions(+)tools/perf/Documentation/perf-record.txt +9
-0@@ -829,6 +829,15 @@ filtered through the mask provided by -C option. only, as of now. So the applications built without the frame pointer might see bogus addresses. + off-cpu profiling consists two types of samples: direct samples, which + share the same behavior as regular samples, and the accumulated + samples, stored in BPF stack trace map, presented after all the regular + samples. + +--off-cpu-thresh:: + Once a task's off-cpu time reaches this threshold, it generates a + direct off-cpu sample. + --setup-filter=<action>:: Prepare BPF filter to be used by regular users. The action should be either "pin" or "unpin". The filter can be used after it's pinned.tools/perf/builtin-record.c +26
-0@@ -3149,6 +3149,28 @@ static int record__parse_mmap_pages(const struct option *opt,return ret; } +static int record__parse_off_cpu_thresh (const struct option *opt, +const char *str, +int unset__maybe_unused ) +{ +struct record_opts *opts = opt->value; +char *endptr; +u64 off_cpu_thresh_us; + +if (!str) +return -EINVAL ; + + off_cpu_thresh_us =strtoull (str, &endptr,10 ); + +/* threshold isn't string "0", yet strtoull() returns 0, parsing failed */ +if (*endptr || (off_cpu_thresh_us ==0 &&strcmp (str,"0" ))) +return -EINVAL ; +else + opts->off_cpu_thresh_us = off_cpu_thresh_us; + +return 0 ; +} +void __weak arch__add_leaf_frame_record_opts (struct record_opts *opts__maybe_unused ) { }@@ -3342,6 +3364,7 @@ static struct record record = { .ctl_fd = -1, .ctl_fd_ack = -1, .synth = PERF_SYNTH_ALL, + .off_cpu_thresh_us = OFFCPU_THRESH, }, };@@ -3564,6 +3587,9 @@ static struct option __record_options[] = {OPT_BOOLEAN (0 ,"off-cpu" , &record.off_cpu,"Enable off-cpu analysis" ),OPT_STRING (0 ,"setup-filter" , &record.filter_action,"pin|unpin" ,"BPF filter action" ), +OPT_CALLBACK (0 ,"off-cpu-thresh" , &record.opts,"us" , +"Dump off-cpu samples if off-cpu time reaches this threshold. The unit is microsecond (default: 500000)" , + record__parse_off_cpu_thresh), OPT_END() };tools/perf/util/off_cpu.h +1
-0@@ -16,6 +16,7 @@ struct record_opts; PERF_SAMPLE_PERIOD | PERF_SAMPLE_CALLCHAIN | \ PERF_SAMPLE_CGROUP) +#define OFFCPU_THRESH 500000ull#ifdef HAVE_BPF_SKEL int off_cpu_prepare(struct evlist *evlist, struct target *target,tools/perf/util/record.h +1
-0@@ -79,6 +79,7 @@ struct record_opts {int synth;int threads_spec;const char *threads_user_spec; +u64 off_cpu_thresh_us; };extern const char *const *record_usage;Signature · 1 line
2.43.0
Ian Rogers
reviewerRe: [PATCH v9 01/10] perf record --off-cpu: Add --off-cpu-thresh option
Quoted 11 lines · Namhyung Kim
Hi Howard,
Sorry for the late review.
Quoted 2 lines · Howard Chu
Specify the threshold for dumping offcpu samples with --off-cpu-thresh, the unit is us (microsecond). Default value is 500,000us (500ms, 0.5s).
I guess we mostly care about more than milli-seconds of off-cpu times. Can we change the unit to msec?
I wonder if there should be two values, one for the command line and one in the code. I think microseconds make most sense in the code, 1ms being roughly 1000 context switches. On the command line millisecond would align with perf stat's -I option, and as you point out, users aren't usually working at the granularity of a microsecond. Having the code be microsecond oriented allows the option to have a more precise command line option in the future, autotuning, etc.
Thanks,
Ian
Quoted 138 lines
Also I think this commit can be moved to later in this series - like after implementing direct offcpu samples. If I see the commit in history later, I'd think it works. But it's not at this point.
Otherwise, looks all good to me. :)
Thanks,
NamhyungQuoted 129 lines
Example:
perf record --off-cpu --off-cpu-thresh 400000The example above collects off-cpu samples whose off-cpu time is longer than 400,000us
Suggested-by Ian Rogers <[email protected]>Suggested-by Namhyung Kim <[email protected]>Suggested-by Arnaldo Carvalho de Melo <[email protected]>Reviewed-by Ian Rogers <[email protected]>Signed-off-by Howard Chu <[email protected]>Cc Adrian Hunter <[email protected]>Cc Alexander Shishkin <[email protected]>Cc Ingo Molnar <[email protected]>Cc James Clark <[email protected]>Cc Jiri Olsa <[email protected]>Cc Kan Liang <[email protected]>Cc Mark Rutland <[email protected]>Cc Namhyung Kim <[email protected]>Cc Peter Zijlstra <[email protected]>Signed-off-by Arnaldo Carvalho de Melo <[email protected]>--- tools/perf/Documentation/perf-record.txt | 9 ++++++++ tools/perf/builtin-record.c | 26 ++++++++++++++++++++++++ tools/perf/util/off_cpu.h | 1 + tools/perf/util/record.h | 1 + 4 files changed, 37 insertions(+)tools/perf/Documentation/perf-record.txt +9
-0@@ -829,6 +829,15 @@ filtered through the mask provided by -C option. only, as of now. So the applications built without the frame pointer might see bogus addresses. + off-cpu profiling consists two types of samples: direct samples, which + share the same behavior as regular samples, and the accumulated + samples, stored in BPF stack trace map, presented after all the regular + samples. + +--off-cpu-thresh:: + Once a task's off-cpu time reaches this threshold, it generates a + direct off-cpu sample. + --setup-filter=<action>:: Prepare BPF filter to be used by regular users. The action should be either "pin" or "unpin". The filter can be used after it's pinned.tools/perf/builtin-record.c +26
-0@@ -3149,6 +3149,28 @@ static int record__parse_mmap_pages(const struct option *opt,return ret; } +static int record__parse_off_cpu_thresh (const struct option *opt, +const char *str, +int unset__maybe_unused ) +{ +struct record_opts *opts = opt->value; +char *endptr; +u64 off_cpu_thresh_us; + +if (!str) +return -EINVAL ; + + off_cpu_thresh_us =strtoull (str, &endptr,10 ); + +/* threshold isn't string "0", yet strtoull() returns 0, parsing failed */ +if (*endptr || (off_cpu_thresh_us ==0 &&strcmp (str,"0" ))) +return -EINVAL ; +else + opts->off_cpu_thresh_us = off_cpu_thresh_us; + +return 0 ; +} +void __weak arch__add_leaf_frame_record_opts (struct record_opts *opts__maybe_unused ) { }@@ -3342,6 +3364,7 @@ static struct record record = { .ctl_fd = -1, .ctl_fd_ack = -1, .synth = PERF_SYNTH_ALL, + .off_cpu_thresh_us = OFFCPU_THRESH, }, };@@ -3564,6 +3587,9 @@ static struct option __record_options[] = {OPT_BOOLEAN (0 ,"off-cpu" , &record.off_cpu,"Enable off-cpu analysis" ),OPT_STRING (0 ,"setup-filter" , &record.filter_action,"pin|unpin" ,"BPF filter action" ), +OPT_CALLBACK (0 ,"off-cpu-thresh" , &record.opts,"us" , +"Dump off-cpu samples if off-cpu time reaches this threshold. The unit is microsecond (default: 500000)" , + record__parse_off_cpu_thresh), OPT_END() };tools/perf/util/off_cpu.h +1
-0@@ -16,6 +16,7 @@ struct record_opts; PERF_SAMPLE_PERIOD | PERF_SAMPLE_CALLCHAIN | \ PERF_SAMPLE_CGROUP) +#define OFFCPU_THRESH 500000ull#ifdef HAVE_BPF_SKEL int off_cpu_prepare(struct evlist *evlist, struct target *target,tools/perf/util/record.h +1
-1@@ -79,6 +79,7 @@ struct record_opts {int synth;int threads_spec;const char *threads_user_spec; +u64 off_cpu_thresh_us; };extern const char *const *record_usage; --2.43.0
Namhyung Kim
maintainerRe: [PATCH v9 01/10] perf record --off-cpu: Add --off-cpu-thresh option
Quoted 13 lines · Ian Rogers
Quoted 11 lines · Namhyung Kim
Hi Howard,
Sorry for the late review.
Quoted 2 lines · Howard Chu
Specify the threshold for dumping offcpu samples with --off-cpu-thresh, the unit is us (microsecond). Default value is 500,000us (500ms, 0.5s).
I guess we mostly care about more than milli-seconds of off-cpu times. Can we change the unit to msec?
Quoted 7 lines
I wonder if there should be two values, one for the command line and one in the code. I think microseconds make most sense in the code, 1ms being roughly 1000 context switches. On the command line millisecond would align with perf stat's -I option, and as you point out, users aren't usually working at the granularity of a microsecond. Having the code be microsecond oriented allows the option to have a more precise command line option in the future, autotuning, etc.
I'm fine as long as it has a proper suffix for the unit. :)
Thanks,
Namhyung
PATCH v9 2/10 perf evsel: Expose evsel__is_offcpu_event() for future use
In reply to Howard ChuExpose evsel__is_offcpu_event() so it can be used in off_cpu_config(), evsel__parse_sample(), and perf script.
--- tools/perf/util/evsel.c | 2 +- tools/perf/util/evsel.h | 2 ++ 2 files changed, 3 insertions(+), 1 deletion(-)
tools/perf/util/evsel.c +1 -1
@@ -1194,7 +1194,7 @@ static void evsel__set_default_freq_period(struct record_opts *opts, } } -static bool evsel__is_offcpu_event (struct evsel *evsel) +bool evsel__is_offcpu_event (struct evsel *evsel) {return evsel__is_bpf_output (evsel) &&evsel__name_is (evsel,OFFCPU_EVENT ); }
tools/perf/util/evsel.h +2 -0
@@ -554,4 +554,6 @@ u64 evsel__bitfield_swap_branch_flags(u64 value);void evsel__set_config_if_unset (struct perf_pmu *pmu,struct evsel *evsel,const char *config_name,u64 val); +bool evsel__is_offcpu_event (struct evsel *evsel); +#endif /* __PERF_EVSEL_H */
Signature · 1 line
2.43.0
PATCH v9 3/10 perf record --off-cpu: Parse off-cpu event
In reply to Howard ChuParse the off-cpu event using parse_event(), as bpf-output.
no-inherit should be set to 1, here's the reason:
We update the BPF perf_event map for direct off-cpu sample dumping (in following patches), it executes as follows:
bpf_map_update_value()
bpf_fd_array_map_update_elem()
perf_event_fd_array_get_ptr()
perf_event_read_local()
In perf_event_read_local(), there is:
int perf_event_read_local(struct perf_event *event, u64 *value,
u64 *enabled, u64 *running)
{
...
/*
* It must not be an event with inherit set, we cannot read
* all child counters from atomic context.
*/
if (event->attr.inherit) {
ret = -EOPNOTSUPP;
goto out;
}Which means no-inherit has to be true for updating the BPF perf_event map.
Moreover, for bpf-output events, we primarily want a system-wide event instead of a per-task event.
The reason is that in BPF's bpf_perf_event_output(), BPF uses the CPU index to retrieve the perf_event file descriptor it outputs to.
Making a bpf-output event system-wide naturally satisfies this requirement by mapping CPU appropriately.
--- tools/perf/util/bpf_off_cpu.c | 33 +++++++++++---------------------- tools/perf/util/evsel.c | 4 +++- 2 files changed, 14 insertions(+), 23 deletions(-)
tools/perf/util/bpf_off_cpu.c +11 -22
@@ -38,32 +38,21 @@ union off_cpu_data {static int off_cpu_config (struct evlist *evlist) { +char off_cpu_event[64 ];struct evsel *evsel; -struct perf_event_attr attr = { - .type =PERF_TYPE_SOFTWARE , - .config =PERF_COUNT_SW_BPF_OUTPUT , - .size =sizeof (attr),/* to capture ABI version */ - }; -char *evname =strdup (OFFCPU_EVENT ); - -if (evname ==NULL ) -return -ENOMEM ; - evsel =evsel__new (&attr); -if (!evsel) { -free (evname); -return -ENOMEM ; +scnprintf (off_cpu_event,sizeof (off_cpu_event),"bpf-output/name=%s/" ,OFFCPU_EVENT ); +if (parse_event (evlist, off_cpu_event)) { +pr_err ("Failed to open off-cpu event\n" ); +return -1 ; } - evsel->core.attr.freq =1 ; - evsel->core.attr.sample_period =1 ; -/* off-cpu analysis depends on stack trace */ - evsel->core.attr.sample_type =PERF_SAMPLE_CALLCHAIN ; - -evlist__add (evlist, evsel); - -free (evsel->name); - evsel->name = evname; +evlist__for_each_entry (evlist, evsel) { +if (evsel__is_offcpu_event (evsel)) { + evsel->core.system_wide = true; +break ; + } + }return 0 ; }
tools/perf/util/evsel.c +3 -1
@@ -1473,8 +1473,10 @@ void evsel__config(struct evsel *evsel, struct record_opts *opts,if (evsel__is_dummy_event (evsel))evsel__reset_sample_bit (evsel,BRANCH_STACK ); -if (evsel__is_offcpu_event (evsel)) +if (evsel__is_offcpu_event (evsel)) { evsel->core.attr.sample_type &=OFFCPU_SAMPLE_TYPES ; + attr->inherit =0 ; + }arch__post_evsel_config (evsel, attr); }
Signature · 1 line
2.43.0
PATCH v9 4/10 perf record --off-cpu: Preparation of off-cpu BPF program
In reply to Howard ChuSet the perf_event map in BPF for dumping off-cpu samples.
Set the offcpu_thresh to specify the threshold.
[ Added some missing iteration variables to off_cpu_config() and fixed up
a manually edited patch hunk line boundary line ]
--- tools/perf/util/bpf_off_cpu.c | 25 +++++++++++++++++++++++++ tools/perf/util/bpf_skel/off_cpu.bpf.c | 11 +++++++++++ 2 files changed, 36 insertions(+)
tools/perf/util/bpf_off_cpu.c +25 -0
@@ -13,6 +13,7 @@#include "util/cgroup.h" #include "util/strlist.h" #include <bpf/bpf.h> +#include <internal/xyarray.h> #include "bpf_skel/off_cpu.skel.h"
@@ -60,6 +61,9 @@ static int off_cpu_config(struct evlist *evlist)static void off_cpu_start (void *arg) {struct evlist *evlist = arg; +struct evsel *evsel; +struct perf_cpu pcpu; +int i;/* update task filter for the given workload */ if (skel->rodata->has_task && skel->rodata->uses_tgid &&
@@ -73,6 +77,25 @@ static void off_cpu_start(void *arg)bpf_map_update_elem (fd, &pid, &val,BPF_ANY ); } +/* update BPF perf_event map */ + evsel =evlist__find_evsel_by_str (evlist,OFFCPU_EVENT ); +if (evsel ==NULL ) { +pr_err ("%s evsel not found\n" ,OFFCPU_EVENT ); +return ; + } + +perf_cpu_map__for_each_cpu (pcpu, i, evsel->core.cpus) { +int err; + + err =bpf_map__update_elem (skel->maps.offcpu_output, &pcpu.cpu,sizeof (__u32), +xyarray__entry (evsel->core.fd, i,0 ), +sizeof (__u32),BPF_ANY ); +if (err) { +pr_err ("Failed to update perf event map for direct off-cpu dumping\n" ); +return ; + } + } + skel->bss->enabled =1 ; }
@@ -261,6 +284,8 @@ int off_cpu_prepare(struct evlist *evlist, struct target *target, } } + skel->bss->offcpu_thresh_ns = opts->off_cpu_thresh_us *1000 ; + err =off_cpu_bpf__attach (skel);if (err) {pr_err ("Failed to attach off-cpu BPF skeleton\n" );
tools/perf/util/bpf_skel/off_cpu.bpf.c +11 -0
@@ -18,6 +18,8 @@#define MAX_STACKS 32#define MAX_ENTRIES 102400 +#define MAX_CPUS 4096 +struct tstamp_data {__u32 stack_id;__u32 state;
@@ -39,6 +41,13 @@ struct {__uint (max_entries,MAX_ENTRIES ); } stacks SEC(".maps"); +struct { + __uint(type, BPF_MAP_TYPE_PERF_EVENT_ARRAY); + __uint(key_size, sizeof(__u32)); + __uint(value_size, sizeof(__u32)); + __uint(max_entries, MAX_CPUS); +} offcpu_output SEC(".maps"); +struct { __uint(type, BPF_MAP_TYPE_TASK_STORAGE); __uint(map_flags, BPF_F_NO_PREALLOC);
@@ -97,6 +106,8 @@ const volatile bool uses_cgroup_v1 = false;int perf_subsys_id =-1 ; +__u64 offcpu_thresh_ns; +/* * Old kernel used to call it task_struct->state and now it's '__state'. * Use BPF CO-RE "ignored suffix rule" to deal with it like below:
Signature · 1 line
2.43.0
PATCH v9 5/10 perf record --off-cpu: Dump off-cpu samples in BPF
In reply to Howard ChuCollect tid, period, callchain, and cgroup id and dump them when off-cpu time threshold is reached.
We don't collect the off-cpu time twice (the delta), it's either in direct samples, or accumulated samples that are dumped at the end of perf.data.
--- tools/perf/util/bpf_skel/off_cpu.bpf.c | 86 ++++++++++++++++++++++++-- 1 file changed, 81 insertions(+), 5 deletions(-)
tools/perf/util/bpf_skel/off_cpu.bpf.c +81 -5
@@ -19,11 +19,17 @@#define MAX_ENTRIES 102400#define MAX_CPUS 4096 +#define MAX_OFFCPU_LEN 37 + +struct stack { +u64 array[MAX_STACKS ]; +};struct tstamp_data {__u32 stack_id;__u32 state;__u64 timestamp; +struct stack stack; };struct offcpu_key {
@@ -41,6 +47,10 @@ struct {__uint (max_entries,MAX_ENTRIES ); } stacks SEC(".maps"); +struct offcpu_data { +u64 array[MAX_OFFCPU_LEN ]; +}; +struct { __uint(type, BPF_MAP_TYPE_PERF_EVENT_ARRAY); __uint(key_size, sizeof(__u32));
@@ -48,6 +58,13 @@ struct {__uint (max_entries,MAX_CPUS ); } offcpu_output SEC(".maps"); +struct { + __uint(type, BPF_MAP_TYPE_PERCPU_ARRAY); + __uint(key_size, sizeof(__u32)); + __uint(value_size, sizeof(struct offcpu_data)); + __uint(max_entries, 1); +} offcpu_payload SEC(".maps"); +struct { __uint(type, BPF_MAP_TYPE_TASK_STORAGE); __uint(map_flags, BPF_F_NO_PREALLOC);
@@ -194,6 +211,47 @@ static inline int can_record(struct task_struct *t, int state)return 1 ; } +static inline int copy_stack (struct stack *from,struct offcpu_data *to,int n) +{ +int len =0 ; + +for (int i =0 ; i <MAX_STACKS && from->array[i]; ++i, ++len) + to->array[n +2 + i] = from->array[i]; + +return len; +} + +/** +* off_cpu_dump - dump off-cpu samples to ring buffer +* @data: payload for dumping off-cpu samples +* @key: off-cpu data +* @stack: stack trace of the task before being scheduled out +* +* If the threshold of off-cpu time is reached, acquire tid, period, callchain, and cgroup id +* information of the task, and dump it as a raw sample to perf ring buffer +*/ +static int off_cpu_dump (void *ctx,struct offcpu_data *data,struct offcpu_key *key, +struct stack *stack,__u64 delta) +{ +int n =0 , len =0 ; + + data->array[n++] = (u64 )key->tgid <<32 | key->pid; + data->array[n++] = delta; + +/* data->array[n] is callchain->nr (updated later) */ + data->array[n +1 ] =PERF_CONTEXT_USER ; + data->array[n +2 ] =0 ; + len =copy_stack (stack, data, n); + +/* update length of callchain */ + data->array[n] = len +1 ; + n += len +2 ; + + data->array[n++] = key->cgroup_id; + +return bpf_perf_event_output (ctx, &offcpu_output,BPF_F_CURRENT_CPU , data, n *sizeof (u64)); +} +static int off_cpu_stat (u64 *ctx,struct task_struct *prev,struct task_struct *next,int state) {
@@ -218,6 +276,16 @@ static int off_cpu_stat(u64 *ctx, struct task_struct *prev, pelem->state = state; pelem->stack_id = stack_id; +/* +* If stacks are successfully collected by bpf_get_stackid(), collect them once more +* in task_storage for direct off-cpu sample dumping +*/ +if (stack_id >0 &&bpf_get_stack (ctx, &pelem->stack,MAX_STACKS *sizeof (u64),BPF_F_USER_STACK )) { +/* +* This empty if block is used to avoid 'result unused warning' from bpf_get_stack(). +* If the collection fails, continue with the logic for the next task. +*/ + } next: pelem =bpf_task_storage_get (&tstamp, next,NULL ,0 );
@@ -232,11 +300,19 @@ static int off_cpu_stat(u64 *ctx, struct task_struct *prev,__u64 delta = ts - pelem->timestamp;__u64 *total; - total =bpf_map_lookup_elem (&off_cpu, &key); -if (total) - *total += delta; -else -bpf_map_update_elem (&off_cpu, &key, &delta,BPF_ANY ); +if (delta >= offcpu_thresh_ns) { +int zero =0 ; +struct offcpu_data *data =bpf_map_lookup_elem (&offcpu_payload, &zero); + +if (data) +off_cpu_dump (ctx, data, &key, &pelem->stack, delta); + }else { + total =bpf_map_lookup_elem (&off_cpu, &key); +if (total) + *total += delta; +else +bpf_map_update_elem (&off_cpu, &key, &delta,BPF_ANY ); + }/* prevent to reuse the timestamp later */ pelem->timestamp =0 ;
Signature · 1 line
2.43.0
PATCH v9 6/10 perf evsel: Assemble offcpu samples
In reply to Howard ChuUse the data in bpf-output samples, to assemble offcpu samples. In evsel__is_offcpu_event(), Check if sample_type is PERF_SAMPLE_RAW to support off-cpu sample data created by an older version of perf.
Testing compatibility on offcpu samples collected by perf before this patch series:
See below, the sample_type still uses PERF_SAMPLE_CALLCHAIN
$ perf script --header -i ./perf.data.ptn | grep "event : name = offcpu-time"
# event : name = offcpu-time, , id = { 237917, 237918, 237919, 237920 }, type = 1 (software), size = 136, config = 0xa (PERF_COUNT_SW_BPF_OUTPUT), { sample_period, sample_freq } = 1, sample_type = IP|TID|TIME|CALLCHAIN|CPU|PERIOD|IDENTIFIER, read_format = ID|LOST, disabled = 1, freq = 1, sample_id_all = 1The output is correct.
$ perf script -i ./perf.data.ptn | grep offcpu-time gmain 2173 [000] 18446744069.414584: 100102015 offcpu-time: NetworkManager 901 [000] 18446744069.414584: 5603579 offcpu-time: Web Content 1183550 [000] 18446744069.414584: 46278 offcpu-time: gnome-control-c 2200559 [000] 18446744069.414584: 11998247014 offcpu-time:
And after this patch series:
$ perf script --header -i ./perf.data.off-cpu-v9 | grep "event : name = offcpu-time"
# event : name = offcpu-time, , id = { 237959, 237960, 237961, 237962 }, type = 1 (software), size = 136, config = 0xa (PERF_COUNT_SW_BPF_OUTPUT), { sample_period, sample_freq } = 1, sample_type = IP|TID|TIME|CPU|PERIOD|RAW|IDENTIFIER, read_format = ID|LOST, disabled = 1, freq = 1, sample_id_all = 1perf $ ./perf script -i ./perf.data.off-cpu-v9 | grep offcpu-time
gnome-shell 1875 [001] 4789616.361225: 100097057 offcpu-time:
gnome-shell 1875 [001] 4789616.461419: 100107463 offcpu-time:
firefox 2206821 [002] 4789616.475690: 255257245 offcpu-time:--- tools/perf/util/evsel.c | 35 ++++++++++++++++++++++++++++++++++- 1 file changed, 34 insertions(+), 1 deletion(-)
tools/perf/util/evsel.c +34 -1
@@ -1196,7 +1196,8 @@ static void evsel__set_default_freq_period(struct record_opts *opts,bool evsel__is_offcpu_event (struct evsel *evsel) { -return evsel__is_bpf_output (evsel) &&evsel__name_is (evsel,OFFCPU_EVENT ); +return evsel__is_bpf_output (evsel) &&evsel__name_is (evsel,OFFCPU_EVENT ) && + evsel->core.attr.sample_type &PERF_SAMPLE_RAW ; }/*
@@ -2794,6 +2795,35 @@ static inline bool evsel__has_branch_counters(const struct evsel *evsel)return false; } +static int __set_offcpu_sample (struct perf_sample *data) +{ +u64 *array = data->raw_data; +u32 max_size = data->raw_size, *p32; +const void *endp = (void *)array + max_size; + +if (array ==NULL ) +return -EFAULT ; + +OVERFLOW_CHECK_u64 (array); + p32 = (void *)array++; + data->pid = p32[0 ]; + data->tid = p32[1 ]; + +OVERFLOW_CHECK_u64 (array); + data->period = *array++; + +OVERFLOW_CHECK_u64 (array); + data->callchain = (struct ip_callchain *)array++; +OVERFLOW_CHECK (array, data->callchain->nr *sizeof (u64), max_size); + data->ip = data->callchain->ips[1 ]; + array += data->callchain->nr; + +OVERFLOW_CHECK_u64 (array); + data->cgroup = *array; + +return 0 ; +} +int evsel__parse_sample (struct evsel *evsel,union perf_event *event,struct perf_sample *data) {
@@ -3145,6 +3175,9 @@ int evsel__parse_sample(struct evsel *evsel, union perf_event *event, array = (void *)array + sz; } +if (evsel__is_offcpu_event (evsel)) +return __set_offcpu_sample (data); +return 0 ; }
Signature · 1 line
2.43.0
PATCH v9 7/10 perf record --off-cpu: Disable perf_event's callchain collection
In reply to Howard ChuThere is a check in evsel.c that does this:
if (evsel__is_offcpu_event(evsel))
evsel->core.attr.sample_type &= OFFCPU_SAMPLE_TYPES;
This along with:
#define OFFCPU_SAMPLE_TYPES (PERF_SAMPLE_IDENTIFIER | PERF_SAMPLE_IP | \ PERF_SAMPLE_TID | PERF_SAMPLE_TIME | \ PERF_SAMPLE_ID | PERF_SAMPLE_CPU | \ PERF_SAMPLE_PERIOD | PERF_SAMPLE_CALLCHAIN | \ PERF_SAMPLE_CGROUP)
will tell perf_event to collect callchain.
We don't need the callchain from perf_event when collecting off-cpu samples, because it's prev's callchain, not next's callchain.
(perf_event) (task_storage) (needed)
prev next
| |
---sched_switch---->
--- tools/perf/util/off_cpu.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
tools/perf/util/off_cpu.h +1 -1
@@ -13,7 +13,7 @@ struct record_opts;#define OFFCPU_SAMPLE_TYPES (PERF_SAMPLE_IDENTIFIER | PERF_SAMPLE_IP | \ PERF_SAMPLE_TID | PERF_SAMPLE_TIME | \ PERF_SAMPLE_ID | PERF_SAMPLE_CPU | \ - PERF_SAMPLE_PERIOD | PERF_SAMPLE_CALLCHAIN | \ + PERF_SAMPLE_PERIOD | PERF_SAMPLE_RAW | \ PERF_SAMPLE_CGROUP)#define OFFCPU_THRESH 500000ull
Signature · 1 line
2.43.0
PATCH v9 8/10 perf script: Display off-cpu samples correctly
In reply to Howard ChuNo PERF_SAMPLE_CALLCHAIN in sample_type, but I need perf script to display a callchain, have to specify manually.
Also, prefer displaying a callchain:
gvfs-afc-volume 2267 [001] 3829232.955656: 1001115340 offcpu-time:
77f05292603f __pselect+0xbf (/usr/lib/x86_64-linux-gnu/libc.so.6)
77f052a1801c [unknown] (/usr/lib/x86_64-linux-gnu/libusbmuxd-2.0.so.6.0.0)
77f052a18d45 [unknown] (/usr/lib/x86_64-linux-gnu/libusbmuxd-2.0.so.6.0.0)
77f05289ca94 start_thread+0x384 (/usr/lib/x86_64-linux-gnu/libc.so.6)
77f052929c3c clone3+0x2c (/usr/lib/x86_64-linux-gnu/libc.so.6)to a raw binary BPF output:
BPF output: 0000: dd 08 00 00 db 08 00 00 <DD>...<DB>...
0008: cc ce ab 3b 00 00 00 00 <CC>Ϋ;.... 0010: 06 00 00 00 00 00 00 00 ........ 0018: 00 fe ff ff ff ff ff ff .<FE><FF><FF><FF><FF><FF><FF> 0020: 3f 60 92 52 f0 77 00 00 ?`.R<F0>w.. 0028: 1c 80 a1 52 f0 77 00 00 ..<A1>R<F0>w.. 0030: 45 8d a1 52 f0 77 00 00 E.<A1>R<F0>w.. 0038: 94 ca 89 52 f0 77 00 00 .<CA>.R<F0>w.. 0040: 3c 9c 92 52 f0 77 00 00 <..R<F0>w.. 0048: 00 00 00 00 00 00 00 00 ........ 0050: 00 00 00 00 ....
--- tools/perf/builtin-script.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
tools/perf/builtin-script.c +2 -2
@@ -662,7 +662,7 @@ static int perf_session__check_output_opt(struct perf_session *session)evlist__for_each_entry (session->evlist, evsel) { not_pipe = true; -if (evsel__has_callchain (evsel)) { +if (evsel__has_callchain (evsel) ||evsel__is_offcpu_event (evsel)) { use_callchain = true;break ; }
@@ -2353,7 +2353,7 @@ static void process_event(struct perf_script *script,else if (PRINT_FIELD (BRSTACKOFF ))perf_sample__fprintf_brstackoff (sample, thread, attr, fp); -if (evsel__is_bpf_output (evsel) &&PRINT_FIELD (BPF_OUTPUT )) +if (evsel__is_bpf_output (evsel) && !evsel__is_offcpu_event (evsel) &&PRINT_FIELD (BPF_OUTPUT ))perf_sample__fprintf_bpf_output (sample, fp);perf_sample__fprintf_insn (sample, evsel, attr, thread, machine, fp, al);
Signature · 1 line
2.43.0
PATCH v9 9/10 perf record --off-cpu: Dump the remaining samples in BPF's stack trace map
In reply to Howard ChuDump the remaining samples, as if it is dumping a direct sample.
Put the stack trace, tid, off-cpu time and cgroup id into the raw_data section, just like a direct off-cpu sample coming from BPF's bpf_perf_event_output().
This ensures that evsel__parse_sample() correctly parses both direct samples and accumulated samples.
--- tools/perf/util/bpf_off_cpu.c | 59 +++++++++++++++++++++-------------- 1 file changed, 35 insertions(+), 24 deletions(-)
tools/perf/util/bpf_off_cpu.c +35 -24
@@ -37,6 +37,8 @@ union off_cpu_data {u64 array[1024 /sizeof (u64)]; }; +u64 off_cpu_raw[MAX_STACKS +5 ]; +static int off_cpu_config (struct evlist *evlist) {char off_cpu_event[64 ];
@@ -309,6 +311,7 @@ int off_cpu_write(struct perf_session *session) {int bytes =0 , size;int fd, stack; +u32 raw_size;u64 sample_type, val, sid =0 ;struct evsel *evsel;struct perf_data_file *file = &session->data->file;
@@ -348,46 +351,54 @@ int off_cpu_write(struct perf_session *session)while (!bpf_map_get_next_key (fd, &prev, &key)) {int n =1 ;/* start from perf_event_header */ -int ip_pos =-1 ;bpf_map_lookup_elem (fd, &key, &val); +/* zero-fill some of the fields, will be overwritten by raw_data when parsing */ if (sample_type &PERF_SAMPLE_IDENTIFIER ) data.array[n++] = sid; -if (sample_type &PERF_SAMPLE_IP ) { - ip_pos = n; +if (sample_type &PERF_SAMPLE_IP ) data.array[n++] =0 ;/* will be updated */ - }if (sample_type &PERF_SAMPLE_TID ) - data.array[n++] = (u64 )key.pid <<32 | key.tgid; + data.array[n++] =0 ;if (sample_type &PERF_SAMPLE_TIME ) data.array[n++] = tstamp; -if (sample_type &PERF_SAMPLE_ID ) - data.array[n++] = sid;if (sample_type &PERF_SAMPLE_CPU ) data.array[n++] =0 ;if (sample_type &PERF_SAMPLE_PERIOD ) - data.array[n++] = val; -if (sample_type &PERF_SAMPLE_CALLCHAIN ) { -int len =0 ; - -/* data.array[n] is callchain->nr (updated later) */ - data.array[n +1 ] =PERF_CONTEXT_USER ; - data.array[n +2 ] =0 ; - -bpf_map_lookup_elem (stack, &key.stack_id, &data.array[n +2 ]); -while (data.array[n +2 + len]) + data.array[n++] =0 ; +if (sample_type &PERF_SAMPLE_RAW ) { +/* +* [ size ][ data ] +* [ data ] +* [ data ] +* [ data ] +* [ data ][ empty] +*/ +int len =0 , i =0 ; +void *raw_data = (void *)data.array + n *sizeof (u64); + + off_cpu_raw[i++] = (u64 )key.pid <<32 | key.tgid; + off_cpu_raw[i++] = val; + +/* off_cpu_raw[i] is callchain->nr (updated later) */ + off_cpu_raw[i +1 ] =PERF_CONTEXT_USER ; + off_cpu_raw[i +2 ] =0 ; + +bpf_map_lookup_elem (stack, &key.stack_id, &off_cpu_raw[i +2 ]); +while (off_cpu_raw[i +2 + len]) len++; -/* update length of callchain */ - data.array[n] = len +1 ; + off_cpu_raw[i] = len +1 ; + i += len +2 ; + + off_cpu_raw[i++] = key.cgroup_id; -/* update sample ip with the first callchain entry */ -if (ip_pos >=0 ) - data.array[ip_pos] = data.array[n +2 ]; + raw_size = i *sizeof (u64) +sizeof (u32);/* 4 bytes for alignment */ +memcpy (raw_data, &raw_size,sizeof (raw_size)); +memcpy (raw_data +sizeof (u32), off_cpu_raw, i *sizeof (u64)); -/* calculate sample callchain data array length */ - n += len +2 ; + n += i +1 ; }if (sample_type &PERF_SAMPLE_CGROUP ) data.array[n++] = key.cgroup_id;
Signature · 1 line
2.43.0
PATCH v9 10/10 perf test: Add direct off-cpu test
In reply to Howard ChuWhy is there a --off-cpu-thresh 2000000?
We collect an off-cpu period __ONLY ONCE__, either in direct sample form, or in accumulated form (in BPF stack trace map).
If I don't add --off-cpu-thresh 200000, the sample in the original test goes into the ring buffer instead of the BPF stack trace map.
Additionally, when using -e dummy, the ring buffer is not open, causing us to lose a sample.
--- tools/perf/tests/builtin-test.c | 1 + tools/perf/tests/shell/record_offcpu.sh | 35 ++++++++++++++++++++++++- tools/perf/tests/tests.h | 1 + tools/perf/tests/workloads/Build | 1 + tools/perf/tests/workloads/offcpu.c | 16 +++++++++++ 5 files changed, 53 insertions(+), 1 deletion(-) create mode 100644 tools/perf/tests/workloads/offcpu.c
tools/perf/tests/builtin-test.c +1 -0
@@ -146,6 +146,7 @@ static struct test_workload *workloads[] = { &workload__brstack, &workload__datasym, &workload__landlock, + &workload__offcpu, };#define workloads__for_each (workload) \
tools/perf/tests/shell/record_offcpu.sh +34 -1
@@ -6,6 +6,10 @@ set -e err=0 perfdata=$(mktemp /tmp/__perf_test.perf.data.XXXXX) +TEST_PROGRAM="perf test -w offcpu" + +ts=$(printf "%u" $((~0 << 32))) # OFF_CPU_TIMESTAMP +dummy_timestamp=${ts%???} # remove the last 3 digits to match perf script cleanup() { rm -f ${perfdata}
@@ -39,7 +43,11 @@ test_offcpu_priv() { test_offcpu_basic() { echo "Basic off-cpu test" - if ! perf record --off-cpu -e dummy -o ${perfdata} sleep 1 2> /dev/null + # We collect an off-cpu period __ONLY ONCE__, either in direct sample form, or in accumulated form + # (in BPF stack trace map). Without the --off-cpu-thresh 200000 below, the sample will go into the + # ring buffer instead of the BPF stack trace map. Additionally, when using -e dummy, the ring + # buffer is not enabled, resulting in a lost sample. + if ! perf record --off-cpu --off-cpu-thresh 2000000 -e dummy -o ${perfdata} sleep 1 2> /dev/null then echo "Basic off-cpu test [Failed record]" err=1
@@ -88,6 +96,27 @@ test_offcpu_child() { echo "Child task off-cpu test [Success]" } +test_offcpu_direct() { + echo "Direct off-cpu test" + + # dump off-cpu samples for task blocked for more than 1.999999s + # -D for initial delay, to enable evlist + if ! perf record -e dummy -D 500 --off-cpu --off-cpu-thresh 1999999 -o ${perfdata} ${TEST_PROGRAM} 2> /dev/null + then + echo "Direct off-cpu test [Failed record]" + err=1 + return + fi + # Direct sample's timestamp should be lower than the dummy_timestamp of the at-the-end sample. + if ! perf script -i ${perfdata} -F time,period | sed "s/[\.:]//g" | \ + awk "{ if (\$1 < ${dummy_timestamp} && \$2 > 1999999999) exit 0; else exit 1; }" + then + echo "Direct off-cpu test [Failed missing direct sample]" + err=1 + return + fi + echo "Direct off-cpu test [Success]" +} test_offcpu_priv
@@ -99,5 +128,9 @@ if [ $err = 0 ]; then test_offcpu_child fi +if [ $err = 0 ]; then + test_offcpu_direct +fi + cleanup exit $err
tools/perf/tests/tests.h +1 -0
@@ -217,6 +217,7 @@ DECLARE_WORKLOAD(sqrtloop);DECLARE_WORKLOAD (brstack);DECLARE_WORKLOAD (datasym);DECLARE_WORKLOAD (landlock); +DECLARE_WORKLOAD (offcpu);extern const char *dso_to_test;extern const char *test_objdump_path;
tools/perf/tests/workloads/Build +1 -0
@@ -7,6 +7,7 @@ perf-test-y += sqrtloop.o perf-test-y += brstack.o perf-test-y += datasym.o perf-test-y += landlock.o +perf-test-y += offcpu.o CFLAGS_sqrtloop.o = -g -O0 -fno-inline -U_FORTIFY_SOURCE CFLAGS_leafloop.o = -g -O0 -fno-inline -fno-omit-frame-pointer -U_FORTIFY_SOURCE
tools/perf/tests/workloads/offcpu.c new file +16 -0
@@ -0,0 +1,16 @@ +#include <linux/compiler.h> +#include <unistd.h> +#include "../tests.h" + +static int offcpu (int argc__maybe_unused ,const char **argv__maybe_unused ) +{ +/* get past the initial delay */ +sleep (1 ); + +/* what we want to collect as a direct sample */ +sleep (2 ); + +return 0 ; +} + +DEFINE_WORKLOAD (offcpu);
Signature · 1 line
2.43.0