1 // SPDX-License-Identifier: GPL-2.0
3 * Copyright (C) 2018 Davidlohr Bueso.
5 * Benchmark the various operations allowed for epoll_ctl(2).
6 * The idea is to concurrently stress a single epoll instance
8 #ifdef HAVE_EVENTFD_SUPPORT
9 /* For the CLR_() macros */
18 #include <linux/compiler.h>
19 #include <linux/kernel.h>
21 #include <sys/resource.h>
22 #include <sys/epoll.h>
23 #include <sys/eventfd.h>
24 #include <perf/cpumap.h>
26 #include "../util/stat.h"
27 #include <subcmd/parse-options.h>
32 #define printinfo(fmt, arg...) \
33 do { if (__verbose) printf(fmt, ## arg); } while (0)
35 static unsigned int nthreads = 0;
36 static unsigned int nsecs = 8;
37 static bool done, __verbose, randomize;
40 * epoll related shared variables.
43 /* Maximum number of nesting allowed inside epoll sets */
44 #define EPOLL_MAXNESTS 4
55 static bool noaffinity;
56 static unsigned int nested = 0;
58 /* amount of fds to monitor, per thread */
59 static unsigned int nfds = 64;
61 static pthread_mutex_t thread_lock;
62 static unsigned int threads_starting;
63 static struct stats all_stats[EPOLL_NR_OPS];
64 static pthread_cond_t thread_parent, thread_worker;
69 unsigned long ops[EPOLL_NR_OPS];
73 static const struct option options[] = {
74 OPT_UINTEGER('t', "threads", &nthreads, "Specify amount of threads"),
75 OPT_UINTEGER('r', "runtime", &nsecs, "Specify runtime (in seconds)"),
76 OPT_UINTEGER('f', "nfds", &nfds, "Specify amount of file descriptors to monitor for each thread"),
77 OPT_BOOLEAN( 'n', "noaffinity", &noaffinity, "Disables CPU affinity"),
78 OPT_UINTEGER( 'N', "nested", &nested, "Nesting level epoll hierarchy (default is 0, no nesting)"),
79 OPT_BOOLEAN( 'R', "randomize", &randomize, "Perform random operations on random fds"),
80 OPT_BOOLEAN( 'v', "verbose", &__verbose, "Verbose mode"),
84 static const char * const bench_epoll_ctl_usage[] = {
85 "perf bench epoll ctl <options>",
89 static void toggle_done(int sig __maybe_unused,
90 siginfo_t *info __maybe_unused,
91 void *uc __maybe_unused)
93 /* inform all threads that we're done for the day */
95 gettimeofday(&bench__end, NULL);
96 timersub(&bench__end, &bench__start, &bench__runtime);
99 static void nest_epollfd(void)
102 struct epoll_event ev;
104 if (nested > EPOLL_MAXNESTS)
105 nested = EPOLL_MAXNESTS;
106 printinfo("Nesting level(s): %d\n", nested);
108 epollfdp = calloc(nested, sizeof(int));
110 err(EXIT_FAILURE, "calloc");
112 for (i = 0; i < nested; i++) {
113 epollfdp[i] = epoll_create(1);
115 err(EXIT_FAILURE, "epoll_create");
118 ev.events = EPOLLHUP; /* anything */
119 ev.data.u64 = i; /* any number */
121 for (i = nested - 1; i; i--) {
122 if (epoll_ctl(epollfdp[i - 1], EPOLL_CTL_ADD,
123 epollfdp[i], &ev) < 0)
124 err(EXIT_FAILURE, "epoll_ctl");
127 if (epoll_ctl(epollfd, EPOLL_CTL_ADD, *epollfdp, &ev) < 0)
128 err(EXIT_FAILURE, "epoll_ctl");
131 static inline void do_epoll_op(struct worker *w, int op, int fd)
134 struct epoll_event ev;
141 error = epoll_ctl(epollfd, EPOLL_CTL_ADD, fd, &ev);
144 ev.events = EPOLLOUT;
145 error = epoll_ctl(epollfd, EPOLL_CTL_MOD, fd, &ev);
148 error = epoll_ctl(epollfd, EPOLL_CTL_DEL, fd, NULL);
159 static inline void do_random_epoll_op(struct worker *w)
161 unsigned long rnd1 = random(), rnd2 = random();
164 fd = w->fdmap[rnd1 % nfds];
165 op = rnd2 % EPOLL_NR_OPS;
167 do_epoll_op(w, op, fd);
170 static void *workerfn(void *arg)
173 struct worker *w = (struct worker *) arg;
174 struct timespec ts = { .tv_sec = 0,
177 pthread_mutex_lock(&thread_lock);
179 if (!threads_starting)
180 pthread_cond_signal(&thread_parent);
181 pthread_cond_wait(&thread_worker, &thread_lock);
182 pthread_mutex_unlock(&thread_lock);
188 do_random_epoll_op(w);
190 for (i = 0; i < nfds; i++) {
191 do_epoll_op(w, OP_EPOLL_ADD, w->fdmap[i]);
192 do_epoll_op(w, OP_EPOLL_MOD, w->fdmap[i]);
193 do_epoll_op(w, OP_EPOLL_DEL, w->fdmap[i]);
197 nanosleep(&ts, NULL);
203 static void init_fdmaps(struct worker *w, int pct)
207 struct epoll_event ev;
213 for (i = 0; i < nfds; i+=inc) {
214 ev.data.fd = w->fdmap[i];
217 if (epoll_ctl(epollfd, EPOLL_CTL_ADD, w->fdmap[i], &ev) < 0)
218 err(EXIT_FAILURE, "epoll_ct");
222 static int do_threads(struct worker *worker, struct perf_cpu_map *cpu)
224 pthread_attr_t thread_attr, *attrp = NULL;
232 pthread_attr_init(&thread_attr);
234 nrcpus = perf_cpu_map__nr(cpu);
235 cpuset = CPU_ALLOC(nrcpus);
237 size = CPU_ALLOC_SIZE(nrcpus);
239 for (i = 0; i < nthreads; i++) {
240 struct worker *w = &worker[i];
243 w->fdmap = calloc(nfds, sizeof(int));
247 for (j = 0; j < nfds; j++) {
248 w->fdmap[j] = eventfd(0, EFD_NONBLOCK);
250 err(EXIT_FAILURE, "eventfd");
254 * Lets add 50% of the fdmap to the epoll instance, and
255 * do it before any threads are started; otherwise there is
256 * an initial bias of the call failing (mod and del ops).
262 CPU_ZERO_S(size, cpuset);
263 CPU_SET_S(perf_cpu_map__cpu(cpu, i % perf_cpu_map__nr(cpu)).cpu,
266 ret = pthread_attr_setaffinity_np(&thread_attr, size, cpuset);
269 err(EXIT_FAILURE, "pthread_attr_setaffinity_np");
272 attrp = &thread_attr;
275 ret = pthread_create(&w->thread, attrp, workerfn,
276 (void *)(struct worker *) w);
279 err(EXIT_FAILURE, "pthread_create");
285 pthread_attr_destroy(&thread_attr);
290 static void print_summary(void)
293 unsigned long avg[EPOLL_NR_OPS];
294 double stddev[EPOLL_NR_OPS];
296 for (i = 0; i < EPOLL_NR_OPS; i++) {
297 avg[i] = avg_stats(&all_stats[i]);
298 stddev[i] = stddev_stats(&all_stats[i]);
301 printf("\nAveraged %ld ADD operations (+- %.2f%%)\n",
302 avg[OP_EPOLL_ADD], rel_stddev_stats(stddev[OP_EPOLL_ADD],
304 printf("Averaged %ld MOD operations (+- %.2f%%)\n",
305 avg[OP_EPOLL_MOD], rel_stddev_stats(stddev[OP_EPOLL_MOD],
307 printf("Averaged %ld DEL operations (+- %.2f%%)\n",
308 avg[OP_EPOLL_DEL], rel_stddev_stats(stddev[OP_EPOLL_DEL],
312 int bench_epoll_ctl(int argc, const char **argv)
315 struct sigaction act;
316 struct worker *worker = NULL;
317 struct perf_cpu_map *cpu;
318 struct rlimit rl, prevrl;
321 argc = parse_options(argc, argv, options, bench_epoll_ctl_usage, 0);
323 usage_with_options(bench_epoll_ctl_usage, options);
327 memset(&act, 0, sizeof(act));
328 sigfillset(&act.sa_mask);
329 act.sa_sigaction = toggle_done;
330 sigaction(SIGINT, &act, NULL);
332 cpu = perf_cpu_map__new(NULL);
336 /* a single, main epoll instance */
337 epollfd = epoll_create(1);
339 err(EXIT_FAILURE, "epoll_create");
342 * Deal with nested epolls, if any.
347 /* default to the number of CPUs */
349 nthreads = perf_cpu_map__nr(cpu);
351 worker = calloc(nthreads, sizeof(*worker));
355 if (getrlimit(RLIMIT_NOFILE, &prevrl))
356 err(EXIT_FAILURE, "getrlimit");
357 rl.rlim_cur = rl.rlim_max = nfds * nthreads * 2 + 50;
358 printinfo("Setting RLIMIT_NOFILE rlimit from %" PRIu64 " to: %" PRIu64 "\n",
359 (uint64_t)prevrl.rlim_max, (uint64_t)rl.rlim_max);
360 if (setrlimit(RLIMIT_NOFILE, &rl) < 0)
361 err(EXIT_FAILURE, "setrlimit");
363 printf("Run summary [PID %d]: %d threads doing epoll_ctl ops "
364 "%d file-descriptors for %d secs.\n\n",
365 getpid(), nthreads, nfds, nsecs);
367 for (i = 0; i < EPOLL_NR_OPS; i++)
368 init_stats(&all_stats[i]);
370 pthread_mutex_init(&thread_lock, NULL);
371 pthread_cond_init(&thread_parent, NULL);
372 pthread_cond_init(&thread_worker, NULL);
374 threads_starting = nthreads;
376 gettimeofday(&bench__start, NULL);
378 do_threads(worker, cpu);
380 pthread_mutex_lock(&thread_lock);
381 while (threads_starting)
382 pthread_cond_wait(&thread_parent, &thread_lock);
383 pthread_cond_broadcast(&thread_worker);
384 pthread_mutex_unlock(&thread_lock);
387 toggle_done(0, NULL, NULL);
388 printinfo("main thread: toggling done\n");
390 for (i = 0; i < nthreads; i++) {
391 ret = pthread_join(worker[i].thread, NULL);
393 err(EXIT_FAILURE, "pthread_join");
396 /* cleanup & report results */
397 pthread_cond_destroy(&thread_parent);
398 pthread_cond_destroy(&thread_worker);
399 pthread_mutex_destroy(&thread_lock);
401 for (i = 0; i < nthreads; i++) {
402 unsigned long t[EPOLL_NR_OPS];
404 for (j = 0; j < EPOLL_NR_OPS; j++) {
405 t[j] = worker[i].ops[j];
406 update_stats(&all_stats[j], t[j]);
410 printf("[thread %2d] fdmap: %p [ add: %04ld; mod: %04ld; del: %04lds ops ]\n",
411 worker[i].tid, &worker[i].fdmap[0],
412 t[OP_EPOLL_ADD], t[OP_EPOLL_MOD], t[OP_EPOLL_DEL]);
414 printf("[thread %2d] fdmap: %p ... %p [ add: %04ld ops; mod: %04ld ops; del: %04ld ops ]\n",
415 worker[i].tid, &worker[i].fdmap[0],
416 &worker[i].fdmap[nfds-1],
417 t[OP_EPOLL_ADD], t[OP_EPOLL_MOD], t[OP_EPOLL_DEL]);
425 err(EXIT_FAILURE, "calloc");
427 #endif // HAVE_EVENTFD_SUPPORT