1 // SPDX-License-Identifier: GPL-2.0
2 #ifdef HAVE_EVENTFD_SUPPORT
3 /*
4 * Copyright (C) 2018 Davidlohr Bueso.
5 *
6 * This program benchmarks concurrent epoll_wait(2) monitoring multiple
7 * file descriptors under one or two load balancing models. The first,
8 * and default, is the single/combined queueing (which refers to a single
9 * epoll instance for N worker threads):
10 *
11 * |---> [worker A]
12 * |---> [worker B]
13 * [combined queue] .---> [worker C]
14 * |---> [worker D]
15 * |---> [worker E]
16 *
17 * While the second model, enabled via --multiq option, uses multiple
18 * queueing (which refers to one epoll instance per worker). For example,
19 * short lived tcp connections in a high throughput httpd server will
20 * distribute the accept()'ing connections across CPUs. In this case each
21 * worker does a limited amount of processing.
22 *
23 * [queue A] ---> [worker]
24 * [queue B] ---> [worker]
25 * [queue C] ---> [worker]
26 * [queue D] ---> [worker]
27 * [queue E] ---> [worker]
28 *
29 * Naturally, the single queue will enforce more concurrency on the epoll
30 * instance, and can therefore scale poorly compared to multiple queues.
31 * However, this is a benchmark raw data and must be taken with a grain of
32 * salt when choosing how to make use of sys_epoll.
33
34 * Each thread has a number of private, nonblocking file descriptors,
35 * referred to as fdmap. A writer thread will constantly be writing to
36 * the fdmaps of all threads, minimizing each threads's chances of
37 * epoll_wait not finding any ready read events and blocking as this
38 * is not what we want to stress. The size of the fdmap can be adjusted
39 * by the user; enlarging the value will increase the chances of
40 * epoll_wait(2) blocking as the lineal writer thread will take "longer",
41 * at least at a high level.
42 *
43 * Note that because fds are private to each thread, this workload does
44 * not stress scenarios where multiple tasks are awoken per ready IO; ie:
45 * EPOLLEXCLUSIVE semantics.
46 *
47 * The end result/metric is throughput: number of ops/second where an
48 * operation consists of:
49 *
50 * epoll_wait(2) + [others]
51 *
52 * ... where [others] is the cost of re-adding the fd (EPOLLET),
53 * or rearming it (EPOLLONESHOT).
54 *
55 *
56 * The purpose of this is program is that it be useful for measuring
57 * kernel related changes to the sys_epoll, and not comparing different
58 * IO polling methods, for example. Hence everything is very adhoc and
59 * outputs raw microbenchmark numbers. Also this uses eventfd, similar
60 * tools tend to use pipes or sockets, but the result is the same.
61 */
62
63 /* For the CLR_() macros */
64 #include <string.h>
65 #include <pthread.h>
66 #include <unistd.h>
67
68 #include <errno.h>
69 #include <inttypes.h>
70 #include <signal.h>
71 #include <stdlib.h>
72 #include <linux/compiler.h>
73 #include <linux/kernel.h>
74 #include <sys/time.h>
75 #include <sys/resource.h>
76 #include <sys/epoll.h>
77 #include <sys/eventfd.h>
78 #include <sys/types.h>
79 #include <perf/cpumap.h>
80
81 #include "../util/stat.h"
82 #include "../util/mutex.h"
83 #include <subcmd/parse-options.h>
84 #include "bench.h"
85
86 #include <err.h>
87
88 #define printinfo(fmt, arg...) \
89 do { if (__verbose) { printf(fmt, ## arg); fflush(stdout); } } while (0)
90
91 static unsigned int nthreads = 0;
92 static unsigned int nsecs = 8;
93 static bool wdone, done, __verbose, randomize, nonblocking;
94
95 /*
96 * epoll related shared variables.
97 */
98
99 /* Maximum number of nesting allowed inside epoll sets */
100 #define EPOLL_MAXNESTS 4
101
102 static int epollfd;
103 static int *epollfdp;
104 static bool noaffinity;
105 static unsigned int nested = 0;
106 static bool et; /* edge-trigger */
107 static bool oneshot;
108 static bool multiq; /* use an epoll instance per thread */
109
110 /* amount of fds to monitor, per thread */
111 static unsigned int nfds = 64;
112
113 static struct mutex thread_lock;
114 static unsigned int threads_starting;
115 static struct stats throughput_stats;
116 static struct cond thread_parent, thread_worker;
117
118 struct worker {
119 int tid;
120 int epollfd; /* for --multiq */
121 pthread_t thread;
122 unsigned long ops;
123 int *fdmap;
124 };
125
126 static const struct option options[] = {
127 /* general benchmark options */
128 OPT_UINTEGER('t', "threads", &nthreads, "Specify amount of threads"),
129 OPT_UINTEGER('r', "runtime", &nsecs, "Specify runtime (in seconds)"),
130 OPT_UINTEGER('f', "nfds", &nfds, "Specify amount of file descriptors to monitor for each thread"),
131 OPT_BOOLEAN( 'n', "noaffinity", &noaffinity, "Disables CPU affinity"),
132 OPT_BOOLEAN('R', "randomize", &randomize, "Enable random write behaviour (default is lineal)"),
133 OPT_BOOLEAN( 'v', "verbose", &__verbose, "Verbose mode"),
134
135 /* epoll specific options */
136 OPT_BOOLEAN( 'm', "multiq", &multiq, "Use multiple epoll instances (one per thread)"),
137 OPT_BOOLEAN( 'B', "nonblocking", &nonblocking, "Nonblocking epoll_wait(2) behaviour"),
138 OPT_UINTEGER( 'N', "nested", &nested, "Nesting level epoll hierarchy (default is 0, no nesting)"),
139 OPT_BOOLEAN( 'S', "oneshot", &oneshot, "Use EPOLLONESHOT semantics"),
140 OPT_BOOLEAN( 'E', "edge", &et, "Use Edge-triggered interface (default is LT)"),
141
142 OPT_END()
143 };
144
145 static const char * const bench_epoll_wait_usage[] = {
146 "perf bench epoll wait <options>",
147 NULL
148 };
149
150
151 /*
152 * Arrange the N elements of ARRAY in random order.
153 * Only effective if N is much smaller than RAND_MAX;
154 * if this may not be the case, use a better random
155 * number generator. -- Ben Pfaff.
156 */
157 static void shuffle(void *array, size_t n, size_t size)
158 {
159 char *carray = array;
160 void *aux;
161 size_t i;
162
163 if (n <= 1)
164 return;
165
166 aux = calloc(1, size);
167 if (!aux)
168 err(EXIT_FAILURE, "calloc");
169
170 for (i = 1; i < n; ++i) {
171 size_t j = i + rand() / (RAND_MAX / (n - i) + 1);
172 j *= size;
173
174 memcpy(aux, &carray[j], size);
175 memcpy(&carray[j], &carray[i*size], size);
176 memcpy(&carray[i*size], aux, size);
177 }
178
179 free(aux);
180 }
181
182
183 static void *workerfn(void *arg)
184 {
185 int fd, ret, r;
186 struct worker *w = (struct worker *) arg;
187 unsigned long ops = w->ops;
188 struct epoll_event ev;
189 uint64_t val;
190 int to = nonblocking? 0 : -1;
191 int efd = multiq ? w->epollfd : epollfd;
192
193 mutex_lock(&thread_lock);
194 threads_starting--;
195 if (!threads_starting)
196 cond_signal(&thread_parent);
197 cond_wait(&thread_worker, &thread_lock);
198 mutex_unlock(&thread_lock);
199
200 do {
201 /*
202 * Block indefinitely waiting for the IN event.
203 * In order to stress the epoll_wait(2) syscall,
204 * call it event per event, instead of a larger
205 * batch (max)limit.
206 */
207 do {
208 ret = epoll_wait(efd, &ev, 1, to);
209 } while (ret < 0 && errno == EINTR);
210 if (ret < 0)
211 err(EXIT_FAILURE, "epoll_wait");
212
213 fd = ev.data.fd;
214
215 do {
216 r = read(fd, &val, sizeof(val));
217 } while (!done && (r < 0 && errno == EAGAIN));
218
219 if (et) {
220 ev.events = EPOLLIN | EPOLLET;
221 ret = epoll_ctl(efd, EPOLL_CTL_ADD, fd, &ev);
222 }
223
224 if (oneshot) {
225 /* rearm the file descriptor with a new event mask */
226 ev.events |= EPOLLIN | EPOLLONESHOT;
227 ret = epoll_ctl(efd, EPOLL_CTL_MOD, fd, &ev);
228 }
229
230 ops++;
231 } while (!done);
232
233 if (multiq)
234 close(w->epollfd);
235
236 w->ops = ops;
237 return NULL;
238 }
239
240 static void nest_epollfd(struct worker *w)
241 {
242 unsigned int i;
243 struct epoll_event ev;
244 int efd = multiq ? w->epollfd : epollfd;
245
246 if (nested > EPOLL_MAXNESTS)
247 nested = EPOLL_MAXNESTS;
248
249 epollfdp = calloc(nested, sizeof(*epollfdp));
250 if (!epollfdp)
251 err(EXIT_FAILURE, "calloc");
252
253 for (i = 0; i < nested; i++) {
254 epollfdp[i] = epoll_create(1);
255 if (epollfdp[i] < 0)
256 err(EXIT_FAILURE, "epoll_create");
257 }
258
259 ev.events = EPOLLHUP; /* anything */
260 ev.data.u64 = i; /* any number */
261
262 for (i = nested - 1; i; i--) {
263 if (epoll_ctl(epollfdp[i - 1], EPOLL_CTL_ADD,
264 epollfdp[i], &ev) < 0)
265 err(EXIT_FAILURE, "epoll_ctl");
266 }
267
268 if (epoll_ctl(efd, EPOLL_CTL_ADD, *epollfdp, &ev) < 0)
269 err(EXIT_FAILURE, "epoll_ctl");
270 }
271
272 static void toggle_done(int sig __maybe_unused,
273 siginfo_t *info __maybe_unused,
274 void *uc __maybe_unused)
275 {
276 /* inform all threads that we're done for the day */
277 done = true;
278 gettimeofday(&bench__end, NULL);
279 timersub(&bench__end, &bench__start, &bench__runtime);
280 }
281
282 static void print_summary(void)
283 {
284 unsigned long avg = avg_stats(&throughput_stats);
285 double stddev = stddev_stats(&throughput_stats);
286
287 printf("\nAveraged %ld operations/sec (+- %.2f%%), total secs = %d\n",
288 avg, rel_stddev_stats(stddev, avg),
289 (int)bench__runtime.tv_sec);
290 }
291
292 static int do_threads(struct worker *worker, struct perf_cpu_map *cpu)
293 {
294 pthread_attr_t thread_attr, *attrp = NULL;
295 cpu_set_t *cpuset;
296 unsigned int i, j;
297 int ret = 0, events = EPOLLIN;
298 int nrcpus;
299 size_t size;
300
301 if (oneshot)
302 events |= EPOLLONESHOT;
303 if (et)
304 events |= EPOLLET;
305
306 printinfo("starting worker/consumer %sthreads%s\n",
307 noaffinity ? "":"CPU affinity ",
308 nonblocking ? " (nonblocking)":"");
309 if (!noaffinity)
310 pthread_attr_init(&thread_attr);
311
312 nrcpus = cpu__max_cpu().cpu;
313 cpuset = CPU_ALLOC(nrcpus);
314 BUG_ON(!cpuset);
315 size = CPU_ALLOC_SIZE(nrcpus);
316
317 for (i = 0; i < nthreads; i++) {
318 struct worker *w = &worker[i];
319
320 if (multiq) {
321 w->epollfd = epoll_create(1);
322 if (w->epollfd < 0)
323 err(EXIT_FAILURE, "epoll_create");
324
325 if (nested)
326 nest_epollfd(w);
327 }
328
329 w->tid = i;
330 w->fdmap = calloc(nfds, sizeof(int));
331 if (!w->fdmap)
332 return 1;
333
334 for (j = 0; j < nfds; j++) {
335 int efd = multiq ? w->epollfd : epollfd;
336 struct epoll_event ev;
337
338 w->fdmap[j] = eventfd(0, EFD_NONBLOCK);
339 if (w->fdmap[j] < 0)
340 err(EXIT_FAILURE, "eventfd");
341
342 ev.data.fd = w->fdmap[j];
343 ev.events = events;
344
345 ret = epoll_ctl(efd, EPOLL_CTL_ADD,
346 w->fdmap[j], &ev);
347 if (ret < 0)
348 err(EXIT_FAILURE, "epoll_ctl");
349 }
350
351 if (!noaffinity) {
352 CPU_ZERO_S(size, cpuset);
353 CPU_SET_S(perf_cpu_map__cpu(cpu, i % perf_cpu_map__nr(cpu)).cpu,
354 size, cpuset);
355
356 ret = pthread_attr_setaffinity_np(&thread_attr, size, cpuset);
357 if (ret) {
358 CPU_FREE(cpuset);
359 err(EXIT_FAILURE, "pthread_attr_setaffinity_np");
360 }
361
362 attrp = &thread_attr;
363 }
364
365 ret = pthread_create(&w->thread, attrp, workerfn,
366 (void *)(struct worker *) w);
367 if (ret) {
368 CPU_FREE(cpuset);
369 err(EXIT_FAILURE, "pthread_create");
370 }
371 }
372
373 CPU_FREE(cpuset);
374 if (!noaffinity)
375 pthread_attr_destroy(&thread_attr);
376
377 return ret;
378 }
379
380 static void *writerfn(void *p)
381 {
382 struct worker *worker = p;
383 size_t i, j, iter;
384 const uint64_t val = 1;
385 ssize_t sz;
386 struct timespec ts = { .tv_sec = 0,
387 .tv_nsec = 500 };
388
389 printinfo("starting writer-thread: doing %s writes ...\n",
390 randomize? "random":"lineal");
391
392 for (iter = 0; !wdone; iter++) {
393 if (randomize) {
394 shuffle((void *)worker, nthreads, sizeof(*worker));
395 }
396
397 for (i = 0; i < nthreads; i++) {
398 struct worker *w = &worker[i];
399
400 if (randomize) {
401 shuffle((void *)w->fdmap, nfds, sizeof(int));
402 }
403
404 for (j = 0; j < nfds; j++) {
405 do {
406 sz = write(w->fdmap[j], &val, sizeof(val));
407 } while (!wdone && (sz < 0 && errno == EAGAIN));
408 }
409 }
410
411 nanosleep(&ts, NULL);
412 }
413
414 printinfo("exiting writer-thread (total full-loops: %zd)\n", iter);
415 return NULL;
416 }
417
418 static int cmpworker(const void *p1, const void *p2)
419 {
420
421 struct worker *w1 = (struct worker *) p1;
422 struct worker *w2 = (struct worker *) p2;
423 return w1->tid > w2->tid;
424 }
425
426 int bench_epoll_wait(int argc, const char **argv)
427 {
428 int ret = 0;
429 struct sigaction act;
430 unsigned int i;
431 struct worker *worker = NULL;
432 struct perf_cpu_map *cpu;
433 pthread_t wthread;
434 struct rlimit rl, prevrl;
435
436 argc = parse_options(argc, argv, options, bench_epoll_wait_usage, 0);
437 if (argc) {
438 usage_with_options(bench_epoll_wait_usage, options);
439 exit(EXIT_FAILURE);
440 }
441
442 memset(&act, 0, sizeof(act));
443 sigfillset(&act.sa_mask);
444 act.sa_sigaction = toggle_done;
445 sigaction(SIGINT, &act, NULL);
446
447 cpu = perf_cpu_map__new_online_cpus();
448 if (!cpu)
449 goto errmem;
450
451 /* a single, main epoll instance */
452 if (!multiq) {
453 epollfd = epoll_create(1);
454 if (epollfd < 0)
455 err(EXIT_FAILURE, "epoll_create");
456
457 /*
458 * Deal with nested epolls, if any.
459 */
460 if (nested)
461 nest_epollfd(NULL);
462 }
463
464 printinfo("Using %s queue model\n", multiq ? "multi" : "single");
465 printinfo("Nesting level(s): %d\n", nested);
466
467 /* default to the number of CPUs and leave one for the writer pthread */
468 if (!nthreads)
469 nthreads = perf_cpu_map__nr(cpu) - 1;
470
471 worker = calloc(nthreads, sizeof(*worker));
472 if (!worker) {
473 goto errmem;
474 }
475
476 if (getrlimit(RLIMIT_NOFILE, &prevrl))
477 err(EXIT_FAILURE, "getrlimit");
478 rl.rlim_cur = rl.rlim_max = nfds * nthreads * 2 + 50;
479 printinfo("Setting RLIMIT_NOFILE rlimit from %" PRIu64 " to: %" PRIu64 "\n",
480 (uint64_t)prevrl.rlim_max, (uint64_t)rl.rlim_max);
481 if (setrlimit(RLIMIT_NOFILE, &rl) < 0)
482 err(EXIT_FAILURE, "setrlimit");
483
484 printf("Run summary [PID %d]: %d threads monitoring%s on "
485 "%d file-descriptors for %d secs.\n\n",
486 getpid(), nthreads, oneshot ? " (EPOLLONESHOT semantics)": "", nfds, nsecs);
487
488 init_stats(&throughput_stats);
489 mutex_init(&thread_lock);
490 cond_init(&thread_parent);
491 cond_init(&thread_worker);
492
493 threads_starting = nthreads;
494
495 gettimeofday(&bench__start, NULL);
496
497 do_threads(worker, cpu);
498
499 mutex_lock(&thread_lock);
500 while (threads_starting)
501 cond_wait(&thread_parent, &thread_lock);
502 cond_broadcast(&thread_worker);
503 mutex_unlock(&thread_lock);
504
505 /*
506 * At this point the workers should be blocked waiting for read events
507 * to become ready. Launch the writer which will constantly be writing
508 * to each thread's fdmap.
509 */
510 ret = pthread_create(&wthread, NULL, writerfn,
511 (void *)(struct worker *) worker);
512 if (ret)
513 err(EXIT_FAILURE, "pthread_create");
514
515 sleep(nsecs);
516 toggle_done(0, NULL, NULL);
517 printinfo("main thread: toggling done\n");
518
519 sleep(1); /* meh */
520 wdone = true;
521 ret = pthread_join(wthread, NULL);
522 if (ret)
523 err(EXIT_FAILURE, "pthread_join");
524
525 /* cleanup & report results */
526 cond_destroy(&thread_parent);
527 cond_destroy(&thread_worker);
528 mutex_destroy(&thread_lock);
529
530 /* sort the array back before reporting */
531 if (randomize)
532 qsort(worker, nthreads, sizeof(struct worker), cmpworker);
533
534 for (i = 0; i < nthreads; i++) {
535 unsigned long t = bench__runtime.tv_sec > 0 ?
536 worker[i].ops / bench__runtime.tv_sec : 0;
537
538 update_stats(&throughput_stats, t);
539
540 if (nfds == 1)
541 printf("[thread %2d] fdmap: %p [ %04ld ops/sec ]\n",
542 worker[i].tid, &worker[i].fdmap[0], t);
543 else
544 printf("[thread %2d] fdmap: %p ... %p [ %04ld ops/sec ]\n",
545 worker[i].tid, &worker[i].fdmap[0],
546 &worker[i].fdmap[nfds-1], t);
547 }
548
549 print_summary();
550
551 close(epollfd);
552 perf_cpu_map__put(cpu);
553 for (i = 0; i < nthreads; i++)
554 free(worker[i].fdmap);
555
556 free(worker);
557 return ret;
558 errmem:
559 err(EXIT_FAILURE, "calloc");
560 }
561 #endif // HAVE_EVENTFD_SUPPORT
562
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.