Skip to contentSkip to conversation

perf bench: add --write-size option to sched pipe

PATCH Superseded Breno Leitao 3 participants 7 messages May 21 – May 27 perf events

v2 of 4 Superseded Latest is v4 →

lore
Share & tools
lore
#0 lore raw

PATCH v2 1/1 perf bench: add --write-size option to sched pipe

The default ping-pong uses sizeof(int) (4 bytes) per iteration, which exercises only the pipe-buffer merge path and keeps allocation entirely out of the picture. That makes the bench a useful scheduler / context- switch latency probe but unable to surface anything from the pipe page-allocation hot path.

Add a -s/--write-size option that sets the bytes written and read per ping-pong iteration. The buffer is allocated for each side via struct thread_data and replaces the on-stack int previously used. The default remains sizeof(int) so existing invocations are unchanged.

With --write-size set above PAGE_SIZE the bench drives anon_pipe_write() through alloc_page() (or the bulk pre-alloc, if the relevant patch is applied), which is what we want when measuring pipe locking and page allocation work.

The bench is a ping-pong: both sides call write() before read(), so a single write_size payload must fit entirely in the pipe buffer or both sides deadlock waiting for the other to drain. Resize the pipe via F_SETPIPE_SZ to match write_size (skipped at the sizeof(int) default), and error out cleanly when the request exceeds /proc/sys/fs/pipe-max-size.

---
This patch has been valuable for testing and verifying the pipe
enhancements currently under discussion at
https://lore.kernel.org/all/[email protected]/
---
Changes in v2:
- Reject --write-size == 0 to avoid a zero-byte ping-pong that spins (blocking mode) or hangs on epoll_wait (non-blocking mode).
- Validate --write-size <= INT_MAX and drop the (int) casts in the
read/write BUG_ON and fcntl(F_SETPIPE_SZ) checks, so the comparisons
are unambiguous regardless of the requested size.
- Fix "acommodate" typo in the pipe-resize comment.
- Link to v1: https://patch.msgid.link/[email protected]

To: Peter Zijlstra <[email protected]>
To: Ingo Molnar <[email protected]>
To: Arnaldo Carvalho de Melo <[email protected]>
To: Namhyung Kim <[email protected]>
To: Mark Rutland <[email protected]>
To: Alexander Shishkin <[email protected]>
To: Jiri Olsa <[email protected]>
To: Ian Rogers <[email protected]>
To: Adrian Hunter <[email protected]>
To: James Clark <[email protected]>
Cc: [email protected]
Cc: [email protected]

---
 tools/perf/bench/sched-pipe.c | 47 +++++++++++++++++++++++++++++++++++++------
 1 file changed, 41 insertions(+), 6 deletions(-)
tools/perf/bench/sched-pipe.c +41 -6
index 70139036d68f0..216d3121d438d 100644
@@ -22,6 +22,7 @@
 #include <string.h>
 #include <errno.h>
 #include <fcntl.h>
+#include <limits.h>
 #include <assert.h>
 #include <sys/epoll.h>
 #include <sys/time.h>
@@ -39,6 +40,7 @@ struct thread_data {
 	int			epoll_fd;
 	bool			cgroup_failed;
 	pthread_t		pthread;
+	char			*buf;
 };
 
 #define LOOPS_DEFAULT 1000000
@@ -48,6 +50,7 @@ static	int			loops = LOOPS_DEFAULT;
 static bool			threaded;
 
 static bool			nonblocking;
+static unsigned int		write_size = sizeof(int);
 static char			*cgrp_names[2];
 static struct cgroup		*cgrps[2];
 
@@ -88,6 +91,8 @@ static const struct option options[] = {
 	OPT_BOOLEAN('n', "nonblocking",	&nonblocking,	"Use non-blocking operations"),
 	OPT_INTEGER('l', "loop",	&loops,		"Specify number of loops"),
 	OPT_BOOLEAN('T', "threaded",	&threaded,	"Specify threads/process based task setup"),
+	OPT_UINTEGER('s', "write-size", &write_size,
+		     "Bytes per ping-pong write (default 4-bytes). Use larger values to exercise the pipe page-allocation path."),
 	OPT_CALLBACK('G', "cgroups", NULL, "SEND,RECV",
 		     "Put sender and receivers in given cgroups",
 		     parse_two_cgroups),
@@ -172,14 +177,14 @@ static void exit_cgroup(int nr)
 
 static inline int read_pipe(struct thread_data *td)
 {
-	int ret, m;
+	int ret;
 retry:
 	if (nonblocking) {
 		ret = epoll_wait(td->epoll_fd, &td->epoll_ev, 1, -1);
 		if (ret < 0)
 			return ret;
 	}
-	ret = read(td->pipe_read, &m, sizeof(int));
+	ret = read(td->pipe_read, td->buf, write_size);
 	if (nonblocking && ret < 0 && errno == EWOULDBLOCK)
 		goto retry;
 	return ret;
@@ -188,7 +193,7 @@ static inline int read_pipe(struct thread_data *td)
 static void *worker_thread(void *__tdata)
 {
 	struct thread_data *td = __tdata;
-	int i, ret, m = 0;
+	int i, ret;
 
 	ret = enter_cgroup(td->nr);
 	if (ret < 0) {
@@ -204,10 +209,10 @@ static void *worker_thread(void *__tdata)
 	}
 
 	for (i = 0; i < loops; i++) {
-		ret = write(td->pipe_write, &m, sizeof(int));
-		BUG_ON(ret != sizeof(int));
+		ret = write(td->pipe_write, td->buf, write_size);
+		BUG_ON(ret < 0 || (unsigned int)ret != write_size);
 		ret = read_pipe(td);
-		BUG_ON(ret != sizeof(int));
+		BUG_ON(ret < 0 || (unsigned int)ret != write_size);
 	}
 
 	return NULL;
@@ -233,12 +238,39 @@ int bench_sched_pipe(int argc, const char **argv)
 
 	argc = parse_options(argc, argv, options, bench_sched_pipe_usage, 0);
 
+	if (write_size == 0 || write_size > INT_MAX) {
+		fprintf(stderr, "--write-size must be in 1..%d\n", INT_MAX);
+		return -1;
+	}
+
 	if (nonblocking)
 		flags |= O_NONBLOCK;
 
 	BUG_ON(pipe2(pipe_1, flags));
 	BUG_ON(pipe2(pipe_2, flags));
 
+	/*
+	 * On a custom write_size, resize the pipes so a single payload fits.
+	 */
+	if (write_size > sizeof(int)) {
+		int r1 = fcntl(pipe_1[1], F_SETPIPE_SZ, write_size);
+		int r2 = fcntl(pipe_2[1], F_SETPIPE_SZ, write_size);
+
+		if (r1 < 0 || r2 < 0 ||
+		    (unsigned int)r1 < write_size ||
+		    (unsigned int)r2 < write_size) {
+			fprintf(stderr,
+				"--write-size %u exceeds /proc/sys/fs/pipe-max-size\n",
+				write_size);
+			return -1;
+		}
+	}
+
+	for (t = 0; t < nr_threads; t++) {
+		threads[t].buf = calloc(1, write_size);
+		BUG_ON(!threads[t].buf);
+	}
+
 	gettimeofday(&start, NULL);
 
 	for (t = 0; t < nr_threads; t++) {
@@ -287,6 +319,9 @@ int bench_sched_pipe(int argc, const char **argv)
 	gettimeofday(&stop, NULL);
 	timersub(&stop, &start, &diff);
 
+	for (t = 0; t < nr_threads; t++)
+		free(threads[t].buf);
+
 	exit_cgroup(0);
 	exit_cgroup(1);
 

---
base-commit: e98d21c170b01ddef366f023bbfcf6b31509fa83
change-id: 20260515-perf_bench_pipe-bae2ec777c4b

Best regards,

Signature · 1 line
Breno Leitao <[email protected]>
#1 lore raw
Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider: - [Medium] File descriptors allocated for pipes are leaked when returning early due to an fcntl() failure. --

Thank you for your contribution! Sashiko AI review found 1 potential issue(s) to consider:
- [Medium] File descriptors allocated for pipes are leaked when returning early due to an fcntl() failure. --

commit a15da46bb7bbcff2fe4b600fd4cd1fdf6d6d3ff0
Author: Breno Leitao <[email protected]>

perf bench: add --write-size option to sched pipe

This commit adds a --write-size option to the sched pipe benchmark in perf to allow testing the pipe page-allocation path. It updates the benchmark to allocate a buffer per thread and resize the pipe capacity via fcntl() when a larger write size is specified.

Quoted 4 lines
tools/perf/bench/sched-pipe.c +0 -0
index 70139036d68f0..216d3121d438d 100644

[ ... ]

Quoted 1 line
tools/perf/bench/sched-pipe.c +0 -0
@@ -233,12 +238,39 @@ int bench_sched_pipe(int argc, const char **argv)

[ ... ]

Quoted 7 lines
tools/perf/bench/sched-pipe.c +4 -0
 	BUG_ON(pipe2(pipe_1, flags));
 	BUG_ON(pipe2(pipe_2, flags));
 
+	/*
+	 * On a custom write_size, resize the pipes so a single payload fits.
+	 */
+	if (write_size > sizeof(int)) {

tools/perf/bench/sched-pipe.c int bench_sched_pipe(int argc, const char **argv) · line 265

Quoted 10 lines
tools/perf/bench/sched-pipe.c +10 -0
+		int r1 = fcntl(pipe_1[1], F_SETPIPE_SZ, write_size);
+		int r2 = fcntl(pipe_2[1], F_SETPIPE_SZ, write_size);
+
+		if (r1 < 0 || r2 < 0 ||
+		    (unsigned int)r1 < write_size ||
+		    (unsigned int)r2 < write_size) {
+			fprintf(stderr,
+				"--write-size %u exceeds /proc/sys/fs/pipe-max-size\n",
+				write_size);
+			return -1;

[Severity: Medium]
Are the file descriptors allocated for pipe_1 and pipe_2 leaked on this error path?

The pipe2() calls just above this block allocate four file descriptors. If the fcntl() operations fail and this path returns -1, those descriptors appear to be left open.

Quoted 2 lines
tools/perf/bench/sched-pipe.c +2 -0
+		}
+	}
Signature · 1 line
Sashiko AI review · https://sashiko.dev/#/patchset/[email protected]?part=1
#2 lore raw
Quoted 7 lines · On Thu, May 21, 2026 at 04:39:50PM +0000, [email protected] wrote:

[Severity: Medium]
Are the file descriptors allocated for pipe_1 and pipe_2 leaked on this error path?

The pipe2() calls just above this block allocate four file descriptors. If the fcntl() operations fail and this path returns -1, those descriptors appear to be left open.

Technically true, but not a problem in practice: bench_sched_pipe() returning -1 bubbles up to perf bench and the process exits, so the kernel reclaims the fds, and there is no real leak.

There's no actual leak in the running program; it's purely a static-analysis nit.

The rest of the function follows the same pattern — pipes are never explicitly closed on the success path either, they're released at exit.

Not planning to fix in v3 unless a maintainer prefers otherwise.

maintainer
#3 lore raw
In reply to Breno Leitao
Quoted 118 lines · Breno Leitao

The default ping-pong uses sizeof(int) (4 bytes) per iteration, which exercises only the pipe-buffer merge path and keeps allocation entirely out of the picture. That makes the bench a useful scheduler / context- switch latency probe but unable to surface anything from the pipe page-allocation hot path.

Add a -s/--write-size option that sets the bytes written and read per ping-pong iteration. The buffer is allocated for each side via struct thread_data and replaces the on-stack int previously used. The default remains sizeof(int) so existing invocations are unchanged.

With --write-size set above PAGE_SIZE the bench drives anon_pipe_write() through alloc_page() (or the bulk pre-alloc, if the relevant patch is applied), which is what we want when measuring pipe locking and page allocation work.

The bench is a ping-pong: both sides call write() before read(), so a single write_size payload must fit entirely in the pipe buffer or both sides deadlock waiting for the other to drain. Resize the pipe via F_SETPIPE_SZ to match write_size (skipped at the sizeof(int) default), and error out cleanly when the request exceeds /proc/sys/fs/pipe-max-size.

---
This patch has been valuable for testing and verifying the pipe
enhancements currently under discussion at
https://lore.kernel.org/all/[email protected]/
---
Changes in v2:
- Reject --write-size == 0 to avoid a zero-byte ping-pong that spins (blocking mode) or hangs on epoll_wait (non-blocking mode).
- Validate --write-size <= INT_MAX and drop the (int) casts in the
read/write BUG_ON and fcntl(F_SETPIPE_SZ) checks, so the comparisons
are unambiguous regardless of the requested size.
- Fix "acommodate" typo in the pipe-resize comment.
- Link to v1: https://patch.msgid.link/[email protected]

To: Peter Zijlstra <[email protected]>
To: Ingo Molnar <[email protected]>
To: Arnaldo Carvalho de Melo <[email protected]>
To: Namhyung Kim <[email protected]>
To: Mark Rutland <[email protected]>
To: Alexander Shishkin <[email protected]>
To: Jiri Olsa <[email protected]>
To: Ian Rogers <[email protected]>
To: Adrian Hunter <[email protected]>
To: James Clark <[email protected]>
Cc: [email protected]
Cc: [email protected]

---
 tools/perf/bench/sched-pipe.c | 47 +++++++++++++++++++++++++++++++++++++------
 1 file changed, 41 insertions(+), 6 deletions(-)
tools/perf/bench/sched-pipe.c +8 -3
index 70139036d68f0..216d3121d438d 100644
@@ -22,6 +22,7 @@
 #include <string.h>
 #include <errno.h>
 #include <fcntl.h>
+#include <limits.h>
 #include <assert.h>
 #include <sys/epoll.h>
 #include <sys/time.h>
@@ -39,6 +40,7 @@ struct thread_data {
 	int			epoll_fd;
 	bool			cgroup_failed;
 	pthread_t		pthread;
+	char			*buf;
 };
 
 #define LOOPS_DEFAULT 1000000
@@ -48,6 +50,7 @@ static	int			loops = LOOPS_DEFAULT;
 static bool			threaded;
 
 static bool			nonblocking;
+static unsigned int		write_size = sizeof(int);
 static char			*cgrp_names[2];
 static struct cgroup		*cgrps[2];
 
@@ -88,6 +91,8 @@ static const struct option options[] = {
 	OPT_BOOLEAN('n', "nonblocking",	&nonblocking,	"Use non-blocking operations"),
 	OPT_INTEGER('l', "loop",	&loops,		"Specify number of loops"),
 	OPT_BOOLEAN('T', "threaded",	&threaded,	"Specify threads/process based task setup"),
+	OPT_UINTEGER('s', "write-size", &write_size,
+		     "Bytes per ping-pong write (default 4-bytes). Use larger values to exercise the pipe page-allocation path."),
 	OPT_CALLBACK('G', "cgroups", NULL, "SEND,RECV",
 		     "Put sender and receivers in given cgroups",
 		     parse_two_cgroups),
@@ -172,14 +177,14 @@ static void exit_cgroup(int nr)
 
 static inline int read_pipe(struct thread_data *td)
 {
-	int ret, m;
+	int ret;
 retry:
 	if (nonblocking) {
 		ret = epoll_wait(td->epoll_fd, &td->epoll_ev, 1, -1);
 		if (ret < 0)
 			return ret;
 	}
-	ret = read(td->pipe_read, &m, sizeof(int));
+	ret = read(td->pipe_read, td->buf, write_size);
 	if (nonblocking && ret < 0 && errno == EWOULDBLOCK)
 		goto retry;
 	return ret;
@@ -188,7 +193,7 @@ static inline int read_pipe(struct thread_data *td)
 static void *worker_thread(void *__tdata)
 {
 	struct thread_data *td = __tdata;
-	int i, ret, m = 0;
+	int i, ret;
 
 	ret = enter_cgroup(td->nr);
 	if (ret < 0) {

tools/perf/bench/sched-pipe.c static void *worker_thread(void *__tdata) · line 215

Quoted 10 lines
tools/perf/bench/sched-pipe.c +3 -3
@@ -204,10 +209,10 @@ static void *worker_thread(void *__tdata)
 	}
 
 	for (i = 0; i < loops; i++) {
-		ret = write(td->pipe_write, &m, sizeof(int));
-		BUG_ON(ret != sizeof(int));
+		ret = write(td->pipe_write, td->buf, write_size);
+		BUG_ON(ret < 0 || (unsigned int)ret != write_size);
 		ret = read_pipe(td);
-		BUG_ON(ret != sizeof(int));
+		BUG_ON(ret < 0 || (unsigned int)ret != write_size);

Is it possible to return smaller values than required due to signal or something?

Thanks,
Namhyung

Quoted 62 lines
tools/perf/bench/sched-pipe.c +30 -1
 	}
 
 	return NULL;
@@ -233,12 +238,39 @@ int bench_sched_pipe(int argc, const char **argv)
 
 	argc = parse_options(argc, argv, options, bench_sched_pipe_usage, 0);
 
+	if (write_size == 0 || write_size > INT_MAX) {
+		fprintf(stderr, "--write-size must be in 1..%d\n", INT_MAX);
+		return -1;
+	}
+
 	if (nonblocking)
 		flags |= O_NONBLOCK;
 
 	BUG_ON(pipe2(pipe_1, flags));
 	BUG_ON(pipe2(pipe_2, flags));
 
+	/*
+	 * On a custom write_size, resize the pipes so a single payload fits.
+	 */
+	if (write_size > sizeof(int)) {
+		int r1 = fcntl(pipe_1[1], F_SETPIPE_SZ, write_size);
+		int r2 = fcntl(pipe_2[1], F_SETPIPE_SZ, write_size);
+
+		if (r1 < 0 || r2 < 0 ||
+		    (unsigned int)r1 < write_size ||
+		    (unsigned int)r2 < write_size) {
+			fprintf(stderr,
+				"--write-size %u exceeds /proc/sys/fs/pipe-max-size\n",
+				write_size);
+			return -1;
+		}
+	}
+
+	for (t = 0; t < nr_threads; t++) {
+		threads[t].buf = calloc(1, write_size);
+		BUG_ON(!threads[t].buf);
+	}
+
 	gettimeofday(&start, NULL);
 
 	for (t = 0; t < nr_threads; t++) {
@@ -287,6 +319,9 @@ int bench_sched_pipe(int argc, const char **argv)
 	gettimeofday(&stop, NULL);
 	timersub(&stop, &start, &diff);
 
+	for (t = 0; t < nr_threads; t++)
+		free(threads[t].buf);
+
 	exit_cgroup(0);
 	exit_cgroup(1);
 
 
---

base-commit: e98d21c170b01ddef366f023bbfcf6b31509fa83
change-id: 20260515-perf_bench_pipe-bae2ec777c4b

Best regards,

Signature · 1 line
Breno Leitao <[email protected]>
#4 lore raw

hello Namhyung,

Quoted 9 lines · Namhyung Kim

tools/perf/bench/sched-pipe.c static void *worker_thread(void *__tdata) · line 215

Quoted 5 lines · Breno Leitao
tools/perf/bench/sched-pipe.c +3 -1
+		ret = write(td->pipe_write, td->buf, write_size);
+		BUG_ON(ret < 0 || (unsigned int)ret != write_size);
 		ret = read_pipe(td);
-		BUG_ON(ret != sizeof(int));
+		BUG_ON(ret < 0 || (unsigned int)ret != write_size);

Is it possible to return smaller values than required due to signal or something?

I tested this on a VM with the patch applied, running the ping-pong with write_size from 4 B up to 1 MiB, including multi-process and single-CPU contention runs (millions of iterations). I observed zero short reads or short writes.

Looking at fs/pipe.c, this matches the kernel behavior for this access pattern:
the bench has a single writer per pipe and the pipe capacity is set to write_size, so the writer never has to sleep mid-write, and the kernel does a sync wake of the reader only after the full payload is queued.

EINTR is also not reachable today because the bench installs no signal handlers and nothing in the call chain delivers signals to the workers

At the same time, I understand the concern and If you'd still prefer defensive handling (short-return loop + EINTR retry) I can add it in v3 — happy to either way.

Thanks for the review,
--breno

maintainer
#5 lore raw
Quoted 23 lines · Breno Leitao

hello Namhyung,

Quoted 9 lines · Namhyung Kim

tools/perf/bench/sched-pipe.c static void *worker_thread(void *__tdata) · line 215

Quoted 5 lines · Breno Leitao
tools/perf/bench/sched-pipe.c +3 -1
+		ret = write(td->pipe_write, td->buf, write_size);
+		BUG_ON(ret < 0 || (unsigned int)ret != write_size);
 		ret = read_pipe(td);
-		BUG_ON(ret != sizeof(int));
+		BUG_ON(ret < 0 || (unsigned int)ret != write_size);

Is it possible to return smaller values than required due to signal or something?

I tested this on a VM with the patch applied, running the ping-pong with write_size from 4 B up to 1 MiB, including multi-process and single-CPU contention runs (millions of iterations). I observed zero short reads or short writes.

Looking at fs/pipe.c, this matches the kernel behavior for this access pattern:
the bench has a single writer per pipe and the pipe capacity is set to write_size, so the writer never has to sleep mid-write, and the kernel does a sync wake of the reader only after the full payload is queued.

Quoted 6 lines

EINTR is also not reachable today because the bench installs no signal handlers and nothing in the call chain delivers signals to the workers

At the same time, I understand the concern and If you'd still prefer defensive handling (short-return loop + EINTR retry) I can add it in v3 — happy to either way.

Thanks for looking into it. I think it's better to go defensive for any unexpected behavior or changes.

Thanks,
Namhyung

#6 lore raw
Quoted 27 lines · Namhyung Kim
Quoted 26 lines · Breno Leitao

hello Namhyung,

Quoted 9 lines · Namhyung Kim

tools/perf/bench/sched-pipe.c static void *worker_thread(void *__tdata) · line 215

Quoted 5 lines · Breno Leitao
tools/perf/bench/sched-pipe.c +3 -1
+		ret = write(td->pipe_write, td->buf, write_size);
+		BUG_ON(ret < 0 || (unsigned int)ret != write_size);
 		ret = read_pipe(td);
-		BUG_ON(ret != sizeof(int));
+		BUG_ON(ret < 0 || (unsigned int)ret != write_size);

Is it possible to return smaller values than required due to signal or something?

I tested this on a VM with the patch applied, running the ping-pong with write_size from 4 B up to 1 MiB, including multi-process and single-CPU contention runs (millions of iterations). I observed zero short reads or short writes.

Looking at fs/pipe.c, this matches the kernel behavior for this access pattern:
the bench has a single writer per pipe and the pipe capacity is set to write_size, so the writer never has to sleep mid-write, and the kernel does a sync wake of the reader only after the full payload is queued.

EINTR is also not reachable today because the bench installs no signal handlers and nothing in the call chain delivers signals to the workers

Quoted 6 lines
Quoted 3 lines

At the same time, I understand the concern and If you'd still prefer defensive handling (short-return loop + EINTR retry) I can add it in v3 — happy to either way.

Thanks for looking into it. I think it's better to go defensive for any unexpected behavior or changes.

Ack, I will respin it, then.

Thanks for the suggestion,
--breno