sched-pipe.c

  1// SPDX-License-Identifier: GPL-2.0
  2/*
  3 *
  4 * sched-pipe.c
  5 *
  6 * pipe: Benchmark for pipe()
  7 *
  8 * Based on pipe-test-1m.c by Ingo Molnar <mingo@redhat.com>
  9 *  http://people.redhat.com/mingo/cfs-scheduler/tools/pipe-test-1m.c
 10 * Ported to perf by Hitoshi Mitake <mitake@dcl.info.waseda.ac.jp>
 11 */
 12#include <subcmd/parse-options.h>
 13#include <api/fs/fs.h>
 14#include "bench.h"
 15#include "util/cgroup.h"
 16
 17#include <unistd.h>
 18#include <stdio.h>
 19#include <stdlib.h>
 20#include <signal.h>
 21#include <sys/wait.h>
 22#include <string.h>
 23#include <errno.h>
 24#include <fcntl.h>
 25#include <assert.h>
 26#include <sys/epoll.h>
 27#include <sys/time.h>
 28#include <sys/types.h>
 29#include <sys/syscall.h>
 30#include <linux/time64.h>
 31
 32#include <pthread.h>
 33
 34struct thread_data {
 35	int			nr;
 36	int			pipe_read;
 37	int			pipe_write;
 38	struct epoll_event      epoll_ev;
 39	int			epoll_fd;
 40	bool			cgroup_failed;
 41	pthread_t		pthread;
 42};
 43
 44#define LOOPS_DEFAULT 1000000
 45static	int			loops = LOOPS_DEFAULT;
 46
 47/* Use processes by default: */
 48static bool			threaded;
 49
 50static bool			nonblocking;
 51static char			*cgrp_names[2];
 52static struct cgroup		*cgrps[2];
 53
 54static int parse_two_cgroups(const struct option *opt __maybe_unused,
 55			     const char *str, int unset __maybe_unused)
 56{
 57	char *p = strdup(str);
 58	char *q;
 59	int ret = -1;
 60
 61	if (p == NULL) {
 62		fprintf(stderr, "memory allocation failure\n");
 63		return -1;
 64	}
 65
 66	q = strchr(p, ',');
 67	if (q == NULL) {
 68		fprintf(stderr, "it should have two cgroup names: %s\n", p);
 69		goto out;
 70	}
 71	*q = '\0';
 72
 73	cgrp_names[0] = strdup(p);
 74	cgrp_names[1] = strdup(q + 1);
 75
 76	if (cgrp_names[0] == NULL || cgrp_names[1] == NULL) {
 77		fprintf(stderr, "memory allocation failure\n");
 78		goto out;
 79	}
 80	ret = 0;
 81
 82out:
 83	free(p);
 84	return ret;
 85}
 86
 87static const struct option options[] = {
 88	OPT_BOOLEAN('n', "nonblocking",	&nonblocking,	"Use non-blocking operations"),
 89	OPT_INTEGER('l', "loop",	&loops,		"Specify number of loops"),
 90	OPT_BOOLEAN('T', "threaded",	&threaded,	"Specify threads/process based task setup"),
 91	OPT_CALLBACK('G', "cgroups", NULL, "SEND,RECV",
 92		     "Put sender and receivers in given cgroups",
 93		     parse_two_cgroups),
 94	OPT_END()
 95};
 96
 97static const char * const bench_sched_pipe_usage[] = {
 98	"perf bench sched pipe <options>",
 99	NULL
100};
101
102static int enter_cgroup(int nr)
103{
104	char buf[32];
105	int fd, len, ret;
106	int saved_errno;
107	struct cgroup *cgrp;
108	pid_t pid;
109
110	if (cgrp_names[nr] == NULL)
111		return 0;
112
113	if (cgrps[nr] == NULL) {
114		cgrps[nr] = cgroup__new(cgrp_names[nr], /*do_open=*/true);
115		if (cgrps[nr] == NULL)
116			goto err;
117	}
118	cgrp = cgrps[nr];
119
120	if (threaded)
121		pid = syscall(__NR_gettid);
122	else
123		pid = getpid();
124
125	snprintf(buf, sizeof(buf), "%d\n", pid);
126	len = strlen(buf);
127
128	/* try cgroup v2 interface first */
129	if (threaded)
130		fd = openat(cgrp->fd, "cgroup.threads", O_WRONLY);
131	else
132		fd = openat(cgrp->fd, "cgroup.procs", O_WRONLY);
133
134	/* try cgroup v1 if failed */
135	if (fd < 0 && errno == ENOENT)
136		fd = openat(cgrp->fd, "tasks", O_WRONLY);
137
138	if (fd < 0)
139		goto err;
140
141	ret = write(fd, buf, len);
142	close(fd);
143
144	if (ret != len) {
145		printf("Cannot enter to cgroup: %s\n", cgrp->name);
146		return -1;
147	}
148	return 0;
149
150err:
151	saved_errno = errno;
152	printf("Failed to open cgroup file in %s\n", cgrp_names[nr]);
153
154	if (saved_errno == ENOENT) {
155		char mnt[PATH_MAX];
156
157		if (cgroupfs_find_mountpoint(mnt, sizeof(mnt), "perf_event") == 0)
158			printf(" Hint: create the cgroup first, like 'mkdir %s/%s'\n",
159			       mnt, cgrp_names[nr]);
160	} else if (saved_errno == EACCES && geteuid() > 0) {
161		printf(" Hint: try to run as root\n");
162	}
163
164	return -1;
165}
166
167static void exit_cgroup(int nr)
168{
169	cgroup__put(cgrps[nr]);
170	free(cgrp_names[nr]);
171}
172
173static inline int read_pipe(struct thread_data *td)
174{
175	int ret, m;
176retry:
177	if (nonblocking) {
178		ret = epoll_wait(td->epoll_fd, &td->epoll_ev, 1, -1);
179		if (ret < 0)
180			return ret;
181	}
182	ret = read(td->pipe_read, &m, sizeof(int));
183	if (nonblocking && ret < 0 && errno == EWOULDBLOCK)
184		goto retry;
185	return ret;
186}
187
188static void *worker_thread(void *__tdata)
189{
190	struct thread_data *td = __tdata;
191	int i, ret, m = 0;
192
193	ret = enter_cgroup(td->nr);
194	if (ret < 0) {
195		td->cgroup_failed = true;
196		return NULL;
197	}
198
199	if (nonblocking) {
200		td->epoll_ev.events = EPOLLIN;
201		td->epoll_fd = epoll_create(1);
202		BUG_ON(td->epoll_fd < 0);
203		BUG_ON(epoll_ctl(td->epoll_fd, EPOLL_CTL_ADD, td->pipe_read, &td->epoll_ev) < 0);
204	}
205
206	for (i = 0; i < loops; i++) {
207		ret = write(td->pipe_write, &m, sizeof(int));
208		BUG_ON(ret != sizeof(int));
209		ret = read_pipe(td);
210		BUG_ON(ret != sizeof(int));
211	}
212
213	return NULL;
214}
215
216int bench_sched_pipe(int argc, const char **argv)
217{
218	struct thread_data threads[2] = {};
219	struct thread_data *td;
220	int pipe_1[2], pipe_2[2];
221	struct timeval start, stop, diff;
222	unsigned long long result_usec = 0;
223	int nr_threads = 2;
224	int t;
225
226	/*
227	 * why does "ret" exist?
228	 * discarding returned value of read(), write()
229	 * causes error in building environment for perf
230	 */
231	int __maybe_unused ret, wait_stat, flags = 0;
232	pid_t pid, retpid __maybe_unused;
233
234	argc = parse_options(argc, argv, options, bench_sched_pipe_usage, 0);
235
236	if (nonblocking)
237		flags |= O_NONBLOCK;
238
239	BUG_ON(pipe2(pipe_1, flags));
240	BUG_ON(pipe2(pipe_2, flags));
241
242	gettimeofday(&start, NULL);
243
244	for (t = 0; t < nr_threads; t++) {
245		td = threads + t;
246
247		td->nr = t;
248
249		if (t == 0) {
250			td->pipe_read = pipe_1[0];
251			td->pipe_write = pipe_2[1];
252		} else {
253			td->pipe_write = pipe_1[1];
254			td->pipe_read = pipe_2[0];
255		}
256	}
257
258	if (threaded) {
259		for (t = 0; t < nr_threads; t++) {
260			td = threads + t;
261
262			ret = pthread_create(&td->pthread, NULL, worker_thread, td);
263			BUG_ON(ret);
264		}
265
266		for (t = 0; t < nr_threads; t++) {
267			td = threads + t;
268
269			ret = pthread_join(td->pthread, NULL);
270			BUG_ON(ret);
271		}
272	} else {
273		pid = fork();
274		assert(pid >= 0);
275
276		if (!pid) {
277			worker_thread(threads + 0);
278			exit(0);
279		} else {
280			worker_thread(threads + 1);
281		}
282
283		retpid = waitpid(pid, &wait_stat, 0);
284		assert((retpid == pid) && WIFEXITED(wait_stat));
285	}
286
287	gettimeofday(&stop, NULL);
288	timersub(&stop, &start, &diff);
289
290	exit_cgroup(0);
291	exit_cgroup(1);
292
293	if (threads[0].cgroup_failed || threads[1].cgroup_failed)
294		return 0;
295
296	switch (bench_format) {
297	case BENCH_FORMAT_DEFAULT:
298		printf("# Executed %d pipe operations between two %s\n\n",
299			loops, threaded ? "threads" : "processes");
300
301		result_usec = diff.tv_sec * USEC_PER_SEC;
302		result_usec += diff.tv_usec;
303
304		printf(" %14s: %lu.%03lu [sec]\n\n", "Total time",
305		       (unsigned long) diff.tv_sec,
306		       (unsigned long) (diff.tv_usec / USEC_PER_MSEC));
307
308		printf(" %14lf usecs/op\n",
309		       (double)result_usec / (double)loops);
310		printf(" %14d ops/sec\n",
311		       (int)((double)loops /
312			     ((double)result_usec / (double)USEC_PER_SEC)));
313		break;
314
315	case BENCH_FORMAT_SIMPLE:
316		printf("%lu.%03lu\n",
317		       (unsigned long) diff.tv_sec,
318		       (unsigned long) (diff.tv_usec / USEC_PER_MSEC));
319		break;
320
321	default:
322		/* reaching here is something disaster */
323		fprintf(stderr, "Unknown format:%d\n", bench_format);
324		exit(1);
325		break;
326	}
327
328	return 0;
329}