* [PATCH bpf-next v4 2/3] bpftool: Group profile events by CPU
2026-09-16 19:26 [PATCH bpf-next v4 0/3] bpftool: Improve perf counter reporting Mykyta Yatsenko
2026-09-16 19:26 ` [PATCH bpf-next v4 1/3] bpftool: Accept zero perf counter snapshots Mykyta Yatsenko
@ 2026-09-16 19:26 ` Mykyta Yatsenko
2026-09-16 19:26 ` [PATCH bpf-next v4 3/3] bpftool: Scale counters and report cycles per run Mykyta Yatsenko
2026-09-17 22:30 ` [PATCH bpf-next v4 0/3] bpftool: Improve perf counter reporting patchwork-bot+netdevbpf
3 siblings, 0 replies; 6+ messages in thread
From: Mykyta Yatsenko @ 2026-09-16 19:26 UTC (permalink / raw)
To: bpf, ast, andrii, daniel, kernel-team, eddyz87, memxor; +Cc: Mykyta Yatsenko
From: Mykyta Yatsenko <yatsenko@meta.com>
Independently scheduled perf events can cover different intervals,
making derived ratios inconsistent.
Open one event group per CPU and enable it only after all selected
metrics have joined.
Fail the profile setup when a selected event cannot join its group.
Signed-off-by: Mykyta Yatsenko <yatsenko@meta.com>
---
tools/bpf/bpftool/prog.c | 87 +++++++++++++++++++++++++++++-------------------
1 file changed, 52 insertions(+), 35 deletions(-)
diff --git a/tools/bpf/bpftool/prog.c b/tools/bpf/bpftool/prog.c
index 6ab911e82155..a14a1a9601bd 100644
--- a/tools/bpf/bpftool/prog.c
+++ b/tools/bpf/bpftool/prog.c
@@ -2350,7 +2350,7 @@ static char *profile_tgt_name;
static int *profile_perf_events;
static int profile_perf_event_cnt;
-static void profile_close_perf_events(struct profiler_bpf *obj)
+static void profile_close_perf_events(void)
{
int i;
@@ -2361,61 +2361,78 @@ static void profile_close_perf_events(struct profiler_bpf *obj)
profile_perf_event_cnt = 0;
}
-static int profile_open_perf_event(int mid, int cpu, int map_fd)
+static int profile_open_perf_event(int mid, int cpu,
+ int map_fd, int group_fd, __u32 map_key)
{
+ struct perf_event_attr attr = metrics[mid].attr;
+ bool group_leader = group_fd < 0;
int pmu_fd;
+ int err;
- pmu_fd = syscall(__NR_perf_event_open, &metrics[mid].attr,
- -1 /*pid*/, cpu, -1 /*group_fd*/, 0);
+ attr.disabled = group_leader;
+ pmu_fd = syscall(__NR_perf_event_open, &attr, -1 /* pid */, cpu,
+ group_fd, 0);
if (pmu_fd < 0) {
- if (errno == ENODEV) {
- p_info("cpu %d may be offline, skip %s profiling.",
- cpu, metrics[mid].name);
- profile_perf_event_cnt++;
- return 0;
- }
- return -1;
+ err = -errno;
+ if (errno == ENODEV && group_leader)
+ p_info("cpu %d may be offline, skip profiling.", cpu);
+ return err;
}
- if (bpf_map_update_elem(map_fd,
- &profile_perf_event_cnt,
- &pmu_fd, BPF_ANY) ||
- ioctl(pmu_fd, PERF_EVENT_IOC_ENABLE, 0)) {
+ if (bpf_map_update_elem(map_fd, &map_key, &pmu_fd, BPF_ANY)) {
+ err = -errno;
close(pmu_fd);
- return -1;
+ return err;
}
profile_perf_events[profile_perf_event_cnt++] = pmu_fd;
- return 0;
+ return pmu_fd;
}
static int profile_open_perf_events(struct profiler_bpf *obj)
{
+ __u32 num_cpu = obj->rodata->num_cpu;
+ __u32 map_key;
unsigned int cpu, m;
- int map_fd;
+ int group_fd, map_fd, pmu_fd;
+ int err;
- profile_perf_events = calloc(
- obj->rodata->num_cpu * obj->rodata->num_metric, sizeof(int));
+ profile_perf_events = calloc(num_cpu * obj->rodata->num_metric,
+ sizeof(*profile_perf_events));
if (!profile_perf_events) {
p_err("failed to allocate memory for perf_event array: %s",
strerror(errno));
- return -1;
+ return -ENOMEM;
}
+
map_fd = bpf_map__fd(obj->maps.events);
- if (map_fd < 0) {
- p_err("failed to get fd for events map");
- return -1;
- }
+ for (cpu = 0; cpu < num_cpu; cpu++) {
+ group_fd = -1;
+ map_key = cpu;
+ for (m = 0; m < ARRAY_SIZE(metrics); m++) {
+ if (!metrics[m].selected)
+ continue;
- for (m = 0; m < ARRAY_SIZE(metrics); m++) {
- if (!metrics[m].selected)
- continue;
- for (cpu = 0; cpu < obj->rodata->num_cpu; cpu++) {
- if (profile_open_perf_event(m, cpu, map_fd)) {
- p_err("failed to create event %s on cpu %u",
- metrics[m].name, cpu);
- return -1;
+ pmu_fd = profile_open_perf_event(m, cpu, map_fd, group_fd,
+ map_key);
+ if (pmu_fd == -ENODEV && group_fd < 0)
+ break;
+ if (pmu_fd < 0) {
+ p_err("failed to add event %s to group on CPU %u: %s",
+ metrics[m].name, cpu, strerror(-pmu_fd));
+ return pmu_fd;
}
+ if (group_fd < 0)
+ group_fd = pmu_fd;
+ map_key += num_cpu;
+ }
+ if (group_fd < 0)
+ continue;
+ if (ioctl(group_fd, PERF_EVENT_IOC_ENABLE, PERF_IOC_FLAG_GROUP)) {
+ err = -errno;
+ p_err("failed to enable perf event group on CPU %u: %s",
+ cpu, strerror(-err));
+ return err;
}
}
return 0;
@@ -2423,7 +2440,7 @@ static int profile_open_perf_events(struct profiler_bpf *obj)
static void profile_print_and_cleanup(void)
{
- profile_close_perf_events(profile_obj);
+ profile_close_perf_events();
profile_read_values(profile_obj);
profile_print_readings();
profiler_bpf__destroy(profile_obj);
@@ -2529,7 +2546,7 @@ static int do_profile(int argc, char **argv)
return 0;
out:
- profile_close_perf_events(profile_obj);
+ profile_close_perf_events();
if (profile_obj)
profiler_bpf__destroy(profile_obj);
close(profile_tgt_fd);
--
2.53.0-Meta
^ permalink raw reply related [flat|nested] 6+ messages in thread* [PATCH bpf-next v4 3/3] bpftool: Scale counters and report cycles per run
2026-09-16 19:26 [PATCH bpf-next v4 0/3] bpftool: Improve perf counter reporting Mykyta Yatsenko
2026-09-16 19:26 ` [PATCH bpf-next v4 1/3] bpftool: Accept zero perf counter snapshots Mykyta Yatsenko
2026-09-16 19:26 ` [PATCH bpf-next v4 2/3] bpftool: Group profile events by CPU Mykyta Yatsenko
@ 2026-09-16 19:26 ` Mykyta Yatsenko
2026-09-17 22:30 ` [PATCH bpf-next v4 0/3] bpftool: Improve perf counter reporting patchwork-bot+netdevbpf
3 siblings, 0 replies; 6+ messages in thread
From: Mykyta Yatsenko @ 2026-09-16 19:26 UTC (permalink / raw)
To: bpf, ast, andrii, daniel, kernel-team, eddyz87, memxor; +Cc: Mykyta Yatsenko
From: Mykyta Yatsenko <yatsenko@meta.com>
Perf counters undercount when the PMU multiplexes them. Scale each
per-CPU value before aggregation. Per-CPU event groups make PMU ratios
use matching scheduling intervals.
Keep run_cnt as the total number of program executions, independent of
counter scheduling.
Keep JSON value raw, report the scaled value in value_scaled, and
document the output.
Signed-off-by: Mykyta Yatsenko <yatsenko@meta.com>
---
tools/bpf/bpftool/Documentation/bpftool-prog.rst | 11 +-
tools/bpf/bpftool/prog.c | 122 +++++++++++++++--------
2 files changed, 89 insertions(+), 44 deletions(-)
diff --git a/tools/bpf/bpftool/Documentation/bpftool-prog.rst b/tools/bpf/bpftool/Documentation/bpftool-prog.rst
index 90fa2a48cc26..90fe8c61bf42 100644
--- a/tools/bpf/bpftool/Documentation/bpftool-prog.rst
+++ b/tools/bpf/bpftool/Documentation/bpftool-prog.rst
@@ -217,7 +217,14 @@ bpftool prog run *PROG* data_in *FILE* [data_out *FILE* [data_size_out *L*]] [ct
bpftool prog profile *PROG* [duration *DURATION*] *METRICs*
Profile *METRICs* for bpf program *PROG* for *DURATION* seconds or until
user hits <Ctrl+C>. *DURATION* is optional. If *DURATION* is not specified,
- the profiling will run up to **UINT_MAX** seconds.
+ the profiling will run up to **UINT_MAX** seconds. Selected metrics form a
+ perf event group on each CPU so that ratios use counters scheduled over the
+ same intervals. Plain output scales each per-CPU metric value to correct
+ for perf event multiplexing. When **cycles** is selected, it also reports
+ cycles per program run.
+
+ In JSON output, **value** is raw, **value_scaled** is scaled, and
+ **run_cnt** is the total number of program runs.
bpftool prog help
Print short help message.
@@ -360,7 +367,7 @@ EXAMPLES
::
51397 run_cnt
- 40176203 cycles (83.05%)
+ 40176203 cycles # 781.68 cycles per run (83.05%)
42518139 instructions # 1.06 insns per cycle (83.39%)
123 llc_misses # 2.89 LLC misses per million insns (83.15%)
diff --git a/tools/bpf/bpftool/prog.c b/tools/bpf/bpftool/prog.c
index a14a1a9601bd..000774835b10 100644
--- a/tools/bpf/bpftool/prog.c
+++ b/tools/bpf/bpftool/prog.c
@@ -2062,37 +2062,52 @@ static int do_profile(int argc, char **argv)
#include "profiler.skel.h"
+enum ratio_metric {
+ METRIC_NONE = -2,
+ METRIC_RUN_CNT = -1,
+ METRIC_CYCLES = 0,
+ METRIC_INSTRUCTIONS = 1,
+ METRIC_L1D_LOADS = 2,
+ METRIC_LLC_MISSES = 3,
+ METRIC_ITLB_MISSES = 4,
+ METRIC_DTLB_MISSES = 5,
+};
+
struct profile_metric {
const char *name;
struct bpf_perf_event_value val;
+ __u64 scaled_val;
struct perf_event_attr attr;
bool selected;
/* calculate ratios like instructions per cycle */
- const int ratio_metric; /* 0 for N/A, 1 for index 0 (cycles) */
+ const enum ratio_metric ratio_metric;
const char *ratio_desc;
const float ratio_mul;
} metrics[] = {
- {
+ [METRIC_CYCLES] = {
.name = "cycles",
.attr = {
.type = PERF_TYPE_HARDWARE,
.config = PERF_COUNT_HW_CPU_CYCLES,
.exclude_user = 1,
},
+ .ratio_metric = METRIC_RUN_CNT,
+ .ratio_desc = "cycles per run",
+ .ratio_mul = 1.0,
},
- {
+ [METRIC_INSTRUCTIONS] = {
.name = "instructions",
.attr = {
.type = PERF_TYPE_HARDWARE,
.config = PERF_COUNT_HW_INSTRUCTIONS,
.exclude_user = 1,
},
- .ratio_metric = 1,
+ .ratio_metric = METRIC_CYCLES,
.ratio_desc = "insns per cycle",
.ratio_mul = 1.0,
},
- {
+ [METRIC_L1D_LOADS] = {
.name = "l1d_loads",
.attr = {
.type = PERF_TYPE_HW_CACHE,
@@ -2102,8 +2117,9 @@ struct profile_metric {
(PERF_COUNT_HW_CACHE_RESULT_ACCESS << 16),
.exclude_user = 1,
},
+ .ratio_metric = METRIC_NONE,
},
- {
+ [METRIC_LLC_MISSES] = {
.name = "llc_misses",
.attr = {
.type = PERF_TYPE_HW_CACHE,
@@ -2113,11 +2129,11 @@ struct profile_metric {
(PERF_COUNT_HW_CACHE_RESULT_MISS << 16),
.exclude_user = 1
},
- .ratio_metric = 2,
+ .ratio_metric = METRIC_INSTRUCTIONS,
.ratio_desc = "LLC misses per million insns",
.ratio_mul = 1e6,
},
- {
+ [METRIC_ITLB_MISSES] = {
.name = "itlb_misses",
.attr = {
.type = PERF_TYPE_HW_CACHE,
@@ -2127,11 +2143,11 @@ struct profile_metric {
(PERF_COUNT_HW_CACHE_RESULT_MISS << 16),
.exclude_user = 1
},
- .ratio_metric = 2,
+ .ratio_metric = METRIC_INSTRUCTIONS,
.ratio_desc = "itlb misses per million insns",
.ratio_mul = 1e6,
},
- {
+ [METRIC_DTLB_MISSES] = {
.name = "dtlb_misses",
.attr = {
.type = PERF_TYPE_HW_CACHE,
@@ -2141,7 +2157,7 @@ struct profile_metric {
(PERF_COUNT_HW_CACHE_RESULT_MISS << 16),
.exclude_user = 1
},
- .ratio_metric = 2,
+ .ratio_metric = METRIC_INSTRUCTIONS,
.ratio_desc = "dtlb misses per million insns",
.ratio_mul = 1e6,
},
@@ -2182,7 +2198,7 @@ static int profile_parse_metrics(int argc, char **argv)
return selected_cnt;
}
-static void profile_read_values(struct profiler_bpf *obj)
+static int profile_read_values(struct profiler_bpf *obj)
{
__u32 m, cpu, num_cpu = obj->rodata->num_cpu;
int reading_map_fd, count_map_fd;
@@ -2192,15 +2208,11 @@ static void profile_read_values(struct profiler_bpf *obj)
reading_map_fd = bpf_map__fd(obj->maps.accum_readings);
count_map_fd = bpf_map__fd(obj->maps.counts);
- if (reading_map_fd < 0 || count_map_fd < 0) {
- p_err("failed to get fd for map");
- return;
- }
err = bpf_map_lookup_elem(count_map_fd, &key, counts);
if (err) {
p_err("failed to read count_map: %s", strerror(errno));
- return;
+ return err;
}
profile_total_count = 0;
@@ -2208,24 +2220,37 @@ static void profile_read_values(struct profiler_bpf *obj)
profile_total_count += counts[cpu];
for (m = 0; m < ARRAY_SIZE(metrics); m++) {
- struct bpf_perf_event_value values[num_cpu];
+ struct bpf_perf_event_value values[num_cpu], *val;
+ double scale;
if (!metrics[m].selected)
continue;
err = bpf_map_lookup_elem(reading_map_fd, &key, values);
if (err) {
- p_err("failed to read reading_map: %s",
- strerror(errno));
- return;
+ p_err("failed to read reading_map: %s", strerror(errno));
+ return err;
}
+
for (cpu = 0; cpu < num_cpu; cpu++) {
- metrics[m].val.counter += values[cpu].counter;
- metrics[m].val.enabled += values[cpu].enabled;
- metrics[m].val.running += values[cpu].running;
+ val = &values[cpu];
+ if (counts[cpu] && !val->running) {
+ p_err("perf event %s was not counted on CPU %u",
+ metrics[m].name, cpu);
+ return -EAGAIN;
+ }
+ metrics[m].val.enabled += val->enabled;
+ metrics[m].val.running += val->running;
+ metrics[m].val.counter += val->counter;
+ if (val->running) {
+ /* Scale values to account for perf event multiplexing. */
+ scale = (double)val->enabled / val->running;
+ metrics[m].scaled_val += val->counter * scale;
+ }
}
key++;
}
+ return 0;
}
static void profile_print_readings_json(void)
@@ -2242,6 +2267,7 @@ static void profile_print_readings_json(void)
jsonw_lluint_field(json_wtr, "value", metrics[m].val.counter);
jsonw_lluint_field(json_wtr, "enabled", metrics[m].val.enabled);
jsonw_lluint_field(json_wtr, "running", metrics[m].val.running);
+ jsonw_lluint_field(json_wtr, "value_scaled", metrics[m].scaled_val);
jsonw_end_object(json_wtr);
}
@@ -2250,24 +2276,34 @@ static void profile_print_readings_json(void)
static void profile_print_readings_plain(void)
{
- __u32 m;
+ __u32 i;
printf("\n%18llu %-20s\n", profile_total_count, "run_cnt");
- for (m = 0; m < ARRAY_SIZE(metrics); m++) {
- struct bpf_perf_event_value *val = &metrics[m].val;
+ for (i = 0; i < ARRAY_SIZE(metrics); i++) {
+ struct profile_metric *m = &metrics[i];
+ struct bpf_perf_event_value *val = &m->val;
int r;
+ __u64 ratio;
- if (!metrics[m].selected)
+ if (!m->selected)
continue;
- printf("%18llu %-20s", val->counter, metrics[m].name);
+ printf("%18llu %-20s", m->scaled_val, m->name);
- r = metrics[m].ratio_metric - 1;
- if (r >= 0 && metrics[r].selected &&
- metrics[r].val.counter > 0) {
+ r = m->ratio_metric;
+ switch (r) {
+ case METRIC_RUN_CNT:
+ ratio = profile_total_count;
+ break;
+ case METRIC_NONE:
+ ratio = 0;
+ break;
+ default:
+ ratio = metrics[r].scaled_val;
+ }
+ if (ratio) {
printf("# %8.2f %-30s",
- val->counter * metrics[m].ratio_mul /
- metrics[r].val.counter,
- metrics[m].ratio_desc);
+ m->scaled_val * m->ratio_mul / ratio,
+ m->ratio_desc);
} else {
printf("%-41s", "");
}
@@ -2438,21 +2474,24 @@ static int profile_open_perf_events(struct profiler_bpf *obj)
return 0;
}
-static void profile_print_and_cleanup(void)
+static int profile_print_and_cleanup(void)
{
+ int err;
+
profile_close_perf_events();
- profile_read_values(profile_obj);
- profile_print_readings();
+ err = profile_read_values(profile_obj);
+ if (!err)
+ profile_print_readings();
profiler_bpf__destroy(profile_obj);
close(profile_tgt_fd);
free(profile_tgt_name);
+ return err;
}
static void int_exit(int signo)
{
- profile_print_and_cleanup();
- exit(0);
+ exit(!!profile_print_and_cleanup());
}
static int do_profile(int argc, char **argv)
@@ -2542,8 +2581,7 @@ static int do_profile(int argc, char **argv)
signal(SIGINT, int_exit);
sleep(duration);
- profile_print_and_cleanup();
- return 0;
+ return profile_print_and_cleanup();
out:
profile_close_perf_events();
--
2.53.0-Meta
^ permalink raw reply related [flat|nested] 6+ messages in thread