1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * Copyright (C) 2018 Davidlohr Bueso.
4 *
5 * Benchmark the various operations allowed for epoll_ctl(2).
6 * The idea is to concurrently stress a single epoll instance
7 */
8 #ifdef HAVE_EVENTFD_SUPPORT
9 /* For the CLR_() macros */
10 #include <string.h>
11 #include <pthread.h>
12
13 #include <errno.h>
14 #include <inttypes.h>
15 #include <signal.h>
16 #include <stdlib.h>
17 #include <unistd.h>
18 #include <linux/compiler.h>
19 #include <linux/kernel.h>
20 #include <sys/time.h>
21 #include <sys/resource.h>
22 #include <sys/epoll.h>
23 #include <sys/eventfd.h>
24 #include <perf/cpumap.h>
25
26 #include "../util/mutex.h"
27 #include "../util/stat.h"
28 #include <subcmd/parse-options.h>
29 #include "bench.h"
30
31 #include <err.h>
32
33 #define printinfo(fmt, arg...) \
34 do { if (__verbose) printf(fmt, ## arg); } while (0)
35
36 static unsigned int nthreads = 0;
37 static unsigned int nsecs = 8;
38 static bool done, __verbose, randomize;
39
40 /*
41 * epoll related shared variables.
42 */
43
44 /* Maximum number of nesting allowed inside epoll sets */
45 #define EPOLL_MAXNESTS 4
46
47 enum {
48 OP_EPOLL_ADD,
49 OP_EPOLL_MOD,
50 OP_EPOLL_DEL,
51 EPOLL_NR_OPS,
52 };
53
54 static int epollfd;
55 static int *epollfdp;
56 static bool noaffinity;
57 static unsigned int nested = 0;
58
59 /* amount of fds to monitor, per thread */
60 static unsigned int nfds = 64;
61
62 static struct mutex thread_lock;
63 static unsigned int threads_starting;
64 static struct stats all_stats[EPOLL_NR_OPS];
65 static struct cond thread_parent, thread_worker;
66
67 struct worker {
68 int tid;
69 pthread_t thread;
70 unsigned long ops[EPOLL_NR_OPS];
71 int *fdmap;
72 };
73
74 static const struct option options[] = {
75 OPT_UINTEGER('t', "threads", &nthreads, "Specify amount of threads"),
76 OPT_UINTEGER('r', "runtime", &nsecs, "Specify runtime (in seconds)"),
77 OPT_UINTEGER('f', "nfds", &nfds, "Specify amount of file descriptors to monitor for each thread"),
78 OPT_BOOLEAN( 'n', "noaffinity", &noaffinity, "Disables CPU affinity"),
79 OPT_UINTEGER( 'N', "nested", &nested, "Nesting level epoll hierarchy (default is 0, no nesting)"),
80 OPT_BOOLEAN( 'R', "randomize", &randomize, "Perform random operations on random fds"),
81 OPT_BOOLEAN( 'v', "verbose", &__verbose, "Verbose mode"),
82 OPT_END()
83 };
84
85 static const char * const bench_epoll_ctl_usage[] = {
86 "perf bench epoll ctl <options>",
87 NULL
88 };
89
90 static void toggle_done(int sig __maybe_unused,
91 siginfo_t *info __maybe_unused,
92 void *uc __maybe_unused)
93 {
94 /* inform all threads that we're done for the day */
95 done = true;
96 gettimeofday(&bench__end, NULL);
97 timersub(&bench__end, &bench__start, &bench__runtime);
98 }
99
100 static void nest_epollfd(void)
101 {
102 unsigned int i;
103 struct epoll_event ev;
104
105 if (nested > EPOLL_MAXNESTS)
106 nested = EPOLL_MAXNESTS;
107 printinfo("Nesting level(s): %d\n", nested);
108
109 epollfdp = calloc(nested, sizeof(int));
110 if (!epollfdp)
111 err(EXIT_FAILURE, "calloc");
112
113 for (i = 0; i < nested; i++) {
114 epollfdp[i] = epoll_create(1);
115 if (epollfd < 0)
116 err(EXIT_FAILURE, "epoll_create");
117 }
118
119 ev.events = EPOLLHUP; /* anything */
120 ev.data.u64 = i; /* any number */
121
122 for (i = nested - 1; i; i--) {
123 if (epoll_ctl(epollfdp[i - 1], EPOLL_CTL_ADD,
124 epollfdp[i], &ev) < 0)
125 err(EXIT_FAILURE, "epoll_ctl");
126 }
127
128 if (epoll_ctl(epollfd, EPOLL_CTL_ADD, *epollfdp, &ev) < 0)
129 err(EXIT_FAILURE, "epoll_ctl");
130 }
131
132 static inline void do_epoll_op(struct worker *w, int op, int fd)
133 {
134 int error;
135 struct epoll_event ev;
136
137 ev.events = EPOLLIN;
138 ev.data.u64 = fd;
139
140 switch (op) {
141 case OP_EPOLL_ADD:
142 error = epoll_ctl(epollfd, EPOLL_CTL_ADD, fd, &ev);
143 break;
144 case OP_EPOLL_MOD:
145 ev.events = EPOLLOUT;
146 error = epoll_ctl(epollfd, EPOLL_CTL_MOD, fd, &ev);
147 break;
148 case OP_EPOLL_DEL:
149 error = epoll_ctl(epollfd, EPOLL_CTL_DEL, fd, NULL);
150 break;
151 default:
152 error = 1;
153 break;
154 }
155
156 if (!error)
157 w->ops[op]++;
158 }
159
160 static inline void do_random_epoll_op(struct worker *w)
161 {
162 unsigned long rnd1 = random(), rnd2 = random();
163 int op, fd;
164
165 fd = w->fdmap[rnd1 % nfds];
166 op = rnd2 % EPOLL_NR_OPS;
167
168 do_epoll_op(w, op, fd);
169 }
170
171 static void *workerfn(void *arg)
172 {
173 unsigned int i;
174 struct worker *w = (struct worker *) arg;
175 struct timespec ts = { .tv_sec = 0,
176 .tv_nsec = 250 };
177
178 mutex_lock(&thread_lock);
179 threads_starting--;
180 if (!threads_starting)
181 cond_signal(&thread_parent);
182 cond_wait(&thread_worker, &thread_lock);
183 mutex_unlock(&thread_lock);
184
185 /* Let 'em loose */
186 do {
187 /* random */
188 if (randomize) {
189 do_random_epoll_op(w);
190 } else {
191 for (i = 0; i < nfds; i++) {
192 do_epoll_op(w, OP_EPOLL_ADD, w->fdmap[i]);
193 do_epoll_op(w, OP_EPOLL_MOD, w->fdmap[i]);
194 do_epoll_op(w, OP_EPOLL_DEL, w->fdmap[i]);
195 }
196 }
197
198 nanosleep(&ts, NULL);
199 } while (!done);
200
201 return NULL;
202 }
203
204 static void init_fdmaps(struct worker *w, int pct)
205 {
206 unsigned int i;
207 int inc;
208 struct epoll_event ev;
209
210 if (!pct)
211 return;
212
213 inc = 100/pct;
214 for (i = 0; i < nfds; i+=inc) {
215 ev.data.fd = w->fdmap[i];
216 ev.events = EPOLLIN;
217
218 if (epoll_ctl(epollfd, EPOLL_CTL_ADD, w->fdmap[i], &ev) < 0)
219 err(EXIT_FAILURE, "epoll_ct");
220 }
221 }
222
223 static int do_threads(struct worker *worker, struct perf_cpu_map *cpu)
224 {
225 pthread_attr_t thread_attr, *attrp = NULL;
226 cpu_set_t *cpuset;
227 unsigned int i, j;
228 int ret = 0;
229 int nrcpus;
230 size_t size;
231
232 if (!noaffinity)
233 pthread_attr_init(&thread_attr);
234
235 nrcpus = cpu__max_cpu().cpu;
236 cpuset = CPU_ALLOC(nrcpus);
237 BUG_ON(!cpuset);
238 size = CPU_ALLOC_SIZE(nrcpus);
239
240 for (i = 0; i < nthreads; i++) {
241 struct worker *w = &worker[i];
242
243 w->tid = i;
244 w->fdmap = calloc(nfds, sizeof(int));
245 if (!w->fdmap)
246 return 1;
247
248 for (j = 0; j < nfds; j++) {
249 w->fdmap[j] = eventfd(0, EFD_NONBLOCK);
250 if (w->fdmap[j] < 0)
251 err(EXIT_FAILURE, "eventfd");
252 }
253
254 /*
255 * Lets add 50% of the fdmap to the epoll instance, and
256 * do it before any threads are started; otherwise there is
257 * an initial bias of the call failing (mod and del ops).
258 */
259 if (randomize)
260 init_fdmaps(w, 50);
261
262 if (!noaffinity) {
263 CPU_ZERO_S(size, cpuset);
264 CPU_SET_S(perf_cpu_map__cpu(cpu, i % perf_cpu_map__nr(cpu)).cpu,
265 size, cpuset);
266
267 ret = pthread_attr_setaffinity_np(&thread_attr, size, cpuset);
268 if (ret) {
269 CPU_FREE(cpuset);
270 err(EXIT_FAILURE, "pthread_attr_setaffinity_np");
271 }
272
273 attrp = &thread_attr;
274 }
275
276 ret = pthread_create(&w->thread, attrp, workerfn,
277 (void *)(struct worker *) w);
278 if (ret) {
279 CPU_FREE(cpuset);
280 err(EXIT_FAILURE, "pthread_create");
281 }
282 }
283
284 CPU_FREE(cpuset);
285 if (!noaffinity)
286 pthread_attr_destroy(&thread_attr);
287
288 return ret;
289 }
290
291 static void print_summary(void)
292 {
293 int i;
294 unsigned long avg[EPOLL_NR_OPS];
295 double stddev[EPOLL_NR_OPS];
296
297 for (i = 0; i < EPOLL_NR_OPS; i++) {
298 avg[i] = avg_stats(&all_stats[i]);
299 stddev[i] = stddev_stats(&all_stats[i]);
300 }
301
302 printf("\nAveraged %ld ADD operations (+- %.2f%%)\n",
303 avg[OP_EPOLL_ADD], rel_stddev_stats(stddev[OP_EPOLL_ADD],
304 avg[OP_EPOLL_ADD]));
305 printf("Averaged %ld MOD operations (+- %.2f%%)\n",
306 avg[OP_EPOLL_MOD], rel_stddev_stats(stddev[OP_EPOLL_MOD],
307 avg[OP_EPOLL_MOD]));
308 printf("Averaged %ld DEL operations (+- %.2f%%)\n",
309 avg[OP_EPOLL_DEL], rel_stddev_stats(stddev[OP_EPOLL_DEL],
310 avg[OP_EPOLL_DEL]));
311 }
312
313 int bench_epoll_ctl(int argc, const char **argv)
314 {
315 int j, ret = 0;
316 struct sigaction act;
317 struct worker *worker = NULL;
318 struct perf_cpu_map *cpu;
319 struct rlimit rl, prevrl;
320 unsigned int i;
321
322 argc = parse_options(argc, argv, options, bench_epoll_ctl_usage, 0);
323 if (argc) {
324 usage_with_options(bench_epoll_ctl_usage, options);
325 exit(EXIT_FAILURE);
326 }
327
328 memset(&act, 0, sizeof(act));
329 sigfillset(&act.sa_mask);
330 act.sa_sigaction = toggle_done;
331 sigaction(SIGINT, &act, NULL);
332
333 cpu = perf_cpu_map__new_online_cpus();
334 if (!cpu)
335 goto errmem;
336
337 /* a single, main epoll instance */
338 epollfd = epoll_create(1);
339 if (epollfd < 0)
340 err(EXIT_FAILURE, "epoll_create");
341
342 /*
343 * Deal with nested epolls, if any.
344 */
345 if (nested)
346 nest_epollfd();
347
348 /* default to the number of CPUs */
349 if (!nthreads)
350 nthreads = perf_cpu_map__nr(cpu);
351
352 worker = calloc(nthreads, sizeof(*worker));
353 if (!worker)
354 goto errmem;
355
356 if (getrlimit(RLIMIT_NOFILE, &prevrl))
357 err(EXIT_FAILURE, "getrlimit");
358 rl.rlim_cur = rl.rlim_max = nfds * nthreads * 2 + 50;
359 printinfo("Setting RLIMIT_NOFILE rlimit from %" PRIu64 " to: %" PRIu64 "\n",
360 (uint64_t)prevrl.rlim_max, (uint64_t)rl.rlim_max);
361 if (setrlimit(RLIMIT_NOFILE, &rl) < 0)
362 err(EXIT_FAILURE, "setrlimit");
363
364 printf("Run summary [PID %d]: %d threads doing epoll_ctl ops "
365 "%d file-descriptors for %d secs.\n\n",
366 getpid(), nthreads, nfds, nsecs);
367
368 for (i = 0; i < EPOLL_NR_OPS; i++)
369 init_stats(&all_stats[i]);
370
371 mutex_init(&thread_lock);
372 cond_init(&thread_parent);
373 cond_init(&thread_worker);
374
375 threads_starting = nthreads;
376
377 gettimeofday(&bench__start, NULL);
378
379 do_threads(worker, cpu);
380
381 mutex_lock(&thread_lock);
382 while (threads_starting)
383 cond_wait(&thread_parent, &thread_lock);
384 cond_broadcast(&thread_worker);
385 mutex_unlock(&thread_lock);
386
387 sleep(nsecs);
388 toggle_done(0, NULL, NULL);
389 printinfo("main thread: toggling done\n");
390
391 for (i = 0; i < nthreads; i++) {
392 ret = pthread_join(worker[i].thread, NULL);
393 if (ret)
394 err(EXIT_FAILURE, "pthread_join");
395 }
396
397 /* cleanup & report results */
398 cond_destroy(&thread_parent);
399 cond_destroy(&thread_worker);
400 mutex_destroy(&thread_lock);
401
402 for (i = 0; i < nthreads; i++) {
403 unsigned long t[EPOLL_NR_OPS];
404
405 for (j = 0; j < EPOLL_NR_OPS; j++) {
406 t[j] = worker[i].ops[j];
407 update_stats(&all_stats[j], t[j]);
408 }
409
410 if (nfds == 1)
411 printf("[thread %2d] fdmap: %p [ add: %04ld; mod: %04ld; del: %04lds ops ]\n",
412 worker[i].tid, &worker[i].fdmap[0],
413 t[OP_EPOLL_ADD], t[OP_EPOLL_MOD], t[OP_EPOLL_DEL]);
414 else
415 printf("[thread %2d] fdmap: %p ... %p [ add: %04ld ops; mod: %04ld ops; del: %04ld ops ]\n",
416 worker[i].tid, &worker[i].fdmap[0],
417 &worker[i].fdmap[nfds-1],
418 t[OP_EPOLL_ADD], t[OP_EPOLL_MOD], t[OP_EPOLL_DEL]);
419 }
420
421 print_summary();
422
423 close(epollfd);
424 perf_cpu_map__put(cpu);
425 for (i = 0; i < nthreads; i++)
426 free(worker[i].fdmap);
427
428 free(worker);
429 return ret;
430 errmem:
431 err(EXIT_FAILURE, "calloc");
432 }
433 #endif // HAVE_EVENTFD_SUPPORT
434
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.