tools/perf/bench/epoll-wait.c - linux/kernel/git/gregkh/usb - Git at Google

 // SPDX-License-Identifier: GPL-2.0
 #ifdef HAVE_EVENTFD
 /*
  * Copyright (C) 2018 Davidlohr Bueso.
  *
  * This program benchmarks concurrent epoll_wait(2) monitoring multiple
  * file descriptors under one or two load balancing models. The first,
  * and default, is the single/combined queueing (which refers to a single
  * epoll instance for N worker threads):
  *
  *                          |---> [worker A]
  *                          |---> [worker B]
  *        [combined queue]  .---> [worker C]
  *                          |---> [worker D]
  *                          |---> [worker E]
  *
  * While the second model, enabled via --multiq option, uses multiple
  * queueing (which refers to one epoll instance per worker). For example,
  * short lived tcp connections in a high throughput httpd server will
  * ditribute the accept()'ing  connections across CPUs. In this case each
  * worker does a limited  amount of processing.
  *
  *             [queue A]  ---> [worker]
  *             [queue B]  ---> [worker]
  *             [queue C]  ---> [worker]
  *             [queue D]  ---> [worker]
  *             [queue E]  ---> [worker]
  *
  * Naturally, the single queue will enforce more concurrency on the epoll
  * instance, and can therefore scale poorly compared to multiple queues.
  * However, this is a benchmark raw data and must be taken with a grain of
  * salt when choosing how to make use of sys_epoll.

  * Each thread has a number of private, nonblocking file descriptors,
  * referred to as fdmap. A writer thread will constantly be writing to
  * the fdmaps of all threads, minimizing each threads's chances of
  * epoll_wait not finding any ready read events and blocking as this
  * is not what we want to stress. The size of the fdmap can be adjusted
  * by the user; enlarging the value will increase the chances of
  * epoll_wait(2) blocking as the lineal writer thread will take "longer",
  * at least at a high level.
  *
  * Note that because fds are private to each thread, this workload does
  * not stress scenarios where multiple tasks are awoken per ready IO; ie:
  * EPOLLEXCLUSIVE semantics.
  *
  * The end result/metric is throughput: number of ops/second where an
  * operation consists of:
  *
  *   epoll_wait(2) + [others]
  *
  *        ... where [others] is the cost of re-adding the fd (EPOLLET),
  *            or rearming it (EPOLLONESHOT).
  *
  *
  * The purpose of this is program is that it be useful for measuring
  * kernel related changes to the sys_epoll, and not comparing different
  * IO polling methods, for example. Hence everything is very adhoc and
  * outputs raw microbenchmark numbers. Also this uses eventfd, similar
  * tools tend to use pipes or sockets, but the result is the same.
  */

 /* For the CLR_() macros */
 #include <string.h>
 #include <pthread.h>
 #include <unistd.h>

 #include <errno.h>
 #include <inttypes.h>
 #include <signal.h>
 #include <stdlib.h>
 #include <linux/compiler.h>
 #include <linux/kernel.h>
 #include <sys/time.h>
 #include <sys/resource.h>
 #include <sys/epoll.h>
 #include <sys/eventfd.h>
 #include <sys/types.h>
 #include <internal/cpumap.h>
 #include <perf/cpumap.h>

 #include "../util/stat.h"
 #include <subcmd/parse-options.h>
 #include "bench.h"

 #include <err.h>

 #define printinfo(fmt, arg...) \
 	do { if (__verbose) { printf(fmt, ## arg); fflush(stdout); } } while (0)

 static unsigned int nthreads = 0;
 static unsigned int nsecs    = 8;
 static bool wdone, done, __verbose, randomize, nonblocking;

 /*
  * epoll related shared variables.
  */

 /* Maximum number of nesting allowed inside epoll sets */
 #define EPOLL_MAXNESTS 4

 static int epollfd;
 static int *epollfdp;
 static bool noaffinity;
 static unsigned int nested = 0;
 static bool et; /* edge-trigger */
 static bool oneshot;
 static bool multiq; /* use an epoll instance per thread */

 /* amount of fds to monitor, per thread */
 static unsigned int nfds = 64;

 static pthread_mutex_t thread_lock;
 static unsigned int threads_starting;
 static struct stats throughput_stats;
 static pthread_cond_t thread_parent, thread_worker;

 struct worker {
 	int tid;
 	int epollfd; /* for --multiq */
 	pthread_t thread;
 	unsigned long ops;
 	int *fdmap;
 };

 static const struct option options[] = {
 	/* general benchmark options */
 	OPT_UINTEGER('t', "threads", &nthreads, "Specify amount of threads"),
 	OPT_UINTEGER('r', "runtime", &nsecs, "Specify runtime (in seconds)"),
 	OPT_UINTEGER('f', "nfds",    &nfds,  "Specify amount of file descriptors to monitor for each thread"),
 	OPT_BOOLEAN( 'n', "noaffinity",  &noaffinity,   "Disables CPU affinity"),
 	OPT_BOOLEAN('R', "randomize", &randomize,   "Enable random write behaviour (default is lineal)"),
 	OPT_BOOLEAN( 'v', "verbose", &__verbose, "Verbose mode"),

 	/* epoll specific options */
 	OPT_BOOLEAN( 'm', "multiq",  &multiq,   "Use multiple epoll instances (one per thread)"),
 	OPT_BOOLEAN( 'B', "nonblocking", &nonblocking, "Nonblocking epoll_wait(2) behaviour"),
 	OPT_UINTEGER( 'N', "nested",  &nested,   "Nesting level epoll hierarchy (default is 0, no nesting)"),
 	OPT_BOOLEAN( 'S', "oneshot",  &oneshot,   "Use EPOLLONESHOT semantics"),
 	OPT_BOOLEAN( 'E', "edge",  &et,   "Use Edge-triggered interface (default is LT)"),

 	OPT_END()
 };

 static const char * const bench_epoll_wait_usage[] = {
 	"perf bench epoll wait <options>",
 	NULL
 };


 /*
  * Arrange the N elements of ARRAY in random order.
  * Only effective if N is much smaller than RAND_MAX;
  * if this may not be the case, use a better random
  * number generator. -- Ben Pfaff.
  */
 static void shuffle(void *array, size_t n, size_t size)
 {
 	char *carray = array;
 	void *aux;
 	size_t i;

 	if (n <= 1)
 		return;

 	aux = calloc(1, size);
 	if (!aux)
 		err(EXIT_FAILURE, "calloc");

 	for (i = 1; i < n; ++i) {
 		size_t j =   i + rand() / (RAND_MAX / (n - i) + 1);
 		j *= size;

 		memcpy(aux, &carray[j], size);
 		memcpy(&carray[j], &carray[i*size], size);
 		memcpy(&carray[i*size], aux, size);
 	}

 	free(aux);
 }


 static void *workerfn(void *arg)
 {
 	int fd, ret, r;
 	struct worker *w = (struct worker *) arg;
 	unsigned long ops = w->ops;
 	struct epoll_event ev;
 	uint64_t val;
 	int to = nonblocking? 0 : -1;
 	int efd = multiq ? w->epollfd : epollfd;

 	pthread_mutex_lock(&thread_lock);
 	threads_starting--;
 	if (!threads_starting)
 		pthread_cond_signal(&thread_parent);
 	pthread_cond_wait(&thread_worker, &thread_lock);
 	pthread_mutex_unlock(&thread_lock);

 	do {
 		/*
 		 * Block undefinitely waiting for the IN event.
 		 * In order to stress the epoll_wait(2) syscall,
 		 * call it event per event, instead of a larger
 		 * batch (max)limit.
 		 */
 		do {
 			ret = epoll_wait(efd, &ev, 1, to);
 		} while (ret < 0 && errno == EINTR);
 		if (ret < 0)
 			err(EXIT_FAILURE, "epoll_wait");

 		fd = ev.data.fd;

 		do {
 			r = read(fd, &val, sizeof(val));
 		} while (!done && (r < 0 && errno == EAGAIN));

 		if (et) {
 			ev.events = EPOLLIN | EPOLLET;
 			ret = epoll_ctl(efd, EPOLL_CTL_ADD, fd, &ev);
 		}

 		if (oneshot) {
 			/* rearm the file descriptor with a new event mask */
 			ev.events |= EPOLLIN | EPOLLONESHOT;
 			ret = epoll_ctl(efd, EPOLL_CTL_MOD, fd, &ev);
 		}

 		ops++;
 	}  while (!done);

 	if (multiq)
 		close(w->epollfd);

 	w->ops = ops;
 	return NULL;
 }

 static void nest_epollfd(struct worker *w)
 {
 	unsigned int i;
 	struct epoll_event ev;
 	int efd = multiq ? w->epollfd : epollfd;

 	if (nested > EPOLL_MAXNESTS)
 		nested = EPOLL_MAXNESTS;

 	epollfdp = calloc(nested, sizeof(*epollfdp));
 	if (!epollfdp)
 		err(EXIT_FAILURE, "calloc");

 	for (i = 0; i < nested; i++) {
 		epollfdp[i] = epoll_create(1);
 		if (epollfdp[i] < 0)
 			err(EXIT_FAILURE, "epoll_create");
 	}

 	ev.events = EPOLLHUP; /* anything */
 	ev.data.u64 = i; /* any number */

 	for (i = nested - 1; i; i--) {
 		if (epoll_ctl(epollfdp[i - 1], EPOLL_CTL_ADD,
 			      epollfdp[i], &ev) < 0)
 			err(EXIT_FAILURE, "epoll_ctl");
 	}

 	if (epoll_ctl(efd, EPOLL_CTL_ADD, *epollfdp, &ev) < 0)
 		err(EXIT_FAILURE, "epoll_ctl");
 }

 static void toggle_done(int sig __maybe_unused,
 			siginfo_t *info __maybe_unused,
 			void *uc __maybe_unused)
 {
 	/* inform all threads that we're done for the day */
 	done = true;
 	gettimeofday(&bench__end, NULL);
 	timersub(&bench__end, &bench__start, &bench__runtime);
 }

 static void print_summary(void)
 {
 	unsigned long avg = avg_stats(&throughput_stats);
 	double stddev = stddev_stats(&throughput_stats);

 	printf("\nAveraged %ld operations/sec (+- %.2f%%), total secs = %d\n",
 	       avg, rel_stddev_stats(stddev, avg),
 	       (int)bench__runtime.tv_sec);
 }

 static int do_threads(struct worker *worker, struct perf_cpu_map *cpu)
 {
 	pthread_attr_t thread_attr, *attrp = NULL;
 	cpu_set_t cpuset;
 	unsigned int i, j;
 	int ret = 0, events = EPOLLIN;

 	if (oneshot)
 		events |= EPOLLONESHOT;
 	if (et)
 		events |= EPOLLET;

 	printinfo("starting worker/consumer %sthreads%s\n",
 		  noaffinity ?  "":"CPU affinity ",
 		  nonblocking ? " (nonblocking)":"");
 	if (!noaffinity)
 		pthread_attr_init(&thread_attr);

 	for (i = 0; i < nthreads; i++) {
 		struct worker *w = &worker[i];

 		if (multiq) {
 			w->epollfd = epoll_create(1);
 			if (w->epollfd < 0)
 				err(EXIT_FAILURE, "epoll_create");

 			if (nested)
 				nest_epollfd(w);
 		}

 		w->tid = i;
 		w->fdmap = calloc(nfds, sizeof(int));
 		if (!w->fdmap)
 			return 1;

 		for (j = 0; j < nfds; j++) {
 			int efd = multiq ? w->epollfd : epollfd;
 			struct epoll_event ev;

 			w->fdmap[j] = eventfd(0, EFD_NONBLOCK);
 			if (w->fdmap[j] < 0)
 				err(EXIT_FAILURE, "eventfd");

 			ev.data.fd = w->fdmap[j];
 			ev.events = events;

 			ret = epoll_ctl(efd, EPOLL_CTL_ADD,
 					w->fdmap[j], &ev);
 			if (ret < 0)
 				err(EXIT_FAILURE, "epoll_ctl");
 		}

 		if (!noaffinity) {
 			CPU_ZERO(&cpuset);
 			CPU_SET(cpu->map[i % cpu->nr], &cpuset);

 			ret = pthread_attr_setaffinity_np(&thread_attr, sizeof(cpu_set_t), &cpuset);
 			if (ret)
 				err(EXIT_FAILURE, "pthread_attr_setaffinity_np");

 			attrp = &thread_attr;
 		}

 		ret = pthread_create(&w->thread, attrp, workerfn,
 				     (void *)(struct worker *) w);
 		if (ret)
 			err(EXIT_FAILURE, "pthread_create");
 	}

 	if (!noaffinity)
 		pthread_attr_destroy(&thread_attr);

 	return ret;
 }

 static void *writerfn(void *p)
 {
 	struct worker *worker = p;
 	size_t i, j, iter;
 	const uint64_t val = 1;
 	ssize_t sz;
 	struct timespec ts = { .tv_sec = 0,
 			       .tv_nsec = 500 };

 	printinfo("starting writer-thread: doing %s writes ...\n",
 		  randomize? "random":"lineal");

 	for (iter = 0; !wdone; iter++) {
 		if (randomize) {
 			shuffle((void *)worker, nthreads, sizeof(*worker));
 		}

 		for (i = 0; i < nthreads; i++) {
 			struct worker *w = &worker[i];

 			if (randomize) {
 				shuffle((void *)w->fdmap, nfds, sizeof(int));
 			}

 			for (j = 0; j < nfds; j++) {
 				do {
 					sz = write(w->fdmap[j], &val, sizeof(val));
 				} while (!wdone && (sz < 0 && errno == EAGAIN));
 			}
 		}

 		nanosleep(&ts, NULL);
 	}

 	printinfo("exiting writer-thread (total full-loops: %zd)\n", iter);
 	return NULL;
 }

 static int cmpworker(const void *p1, const void *p2)
 {

 	struct worker *w1 = (struct worker *) p1;
 	struct worker *w2 = (struct worker *) p2;
 	return w1->tid > w2->tid;
 }

 int bench_epoll_wait(int argc, const char **argv)
 {
 	int ret = 0;
 	struct sigaction act;
 	unsigned int i;
 	struct worker *worker = NULL;
 	struct perf_cpu_map *cpu;
 	pthread_t wthread;
 	struct rlimit rl, prevrl;

 	argc = parse_options(argc, argv, options, bench_epoll_wait_usage, 0);
 	if (argc) {
 		usage_with_options(bench_epoll_wait_usage, options);
 		exit(EXIT_FAILURE);
 	}

 	memset(&act, 0, sizeof(act));
 	sigfillset(&act.sa_mask);
 	act.sa_sigaction = toggle_done;
 	sigaction(SIGINT, &act, NULL);

 	cpu = perf_cpu_map__new(NULL);
 	if (!cpu)
 		goto errmem;

 	/* a single, main epoll instance */
 	if (!multiq) {
 		epollfd = epoll_create(1);
 		if (epollfd < 0)
 			err(EXIT_FAILURE, "epoll_create");

 		/*
 		 * Deal with nested epolls, if any.
 		 */
 		if (nested)
 			nest_epollfd(NULL);
 	}

 	printinfo("Using %s queue model\n", multiq ? "multi" : "single");
 	printinfo("Nesting level(s): %d\n", nested);

 	/* default to the number of CPUs and leave one for the writer pthread */
 	if (!nthreads)
 		nthreads = cpu->nr - 1;

 	worker = calloc(nthreads, sizeof(*worker));
 	if (!worker) {
 		goto errmem;
 	}

 	if (getrlimit(RLIMIT_NOFILE, &prevrl))
 		err(EXIT_FAILURE, "getrlimit");
 	rl.rlim_cur = rl.rlim_max = nfds * nthreads * 2 + 50;
 	printinfo("Setting RLIMIT_NOFILE rlimit from %" PRIu64 " to: %" PRIu64 "\n",
 		  (uint64_t)prevrl.rlim_max, (uint64_t)rl.rlim_max);
 	if (setrlimit(RLIMIT_NOFILE, &rl) < 0)
 		err(EXIT_FAILURE, "setrlimit");

 	printf("Run summary [PID %d]: %d threads monitoring%s on "
 	       "%d file-descriptors for %d secs.\n\n",
 	       getpid(), nthreads, oneshot ? " (EPOLLONESHOT semantics)": "", nfds, nsecs);

 	init_stats(&throughput_stats);
 	pthread_mutex_init(&thread_lock, NULL);
 	pthread_cond_init(&thread_parent, NULL);
 	pthread_cond_init(&thread_worker, NULL);

 	threads_starting = nthreads;

 	gettimeofday(&bench__start, NULL);

 	do_threads(worker, cpu);

 	pthread_mutex_lock(&thread_lock);
 	while (threads_starting)
 		pthread_cond_wait(&thread_parent, &thread_lock);
 	pthread_cond_broadcast(&thread_worker);
 	pthread_mutex_unlock(&thread_lock);

 	/*
 	 * At this point the workers should be blocked waiting for read events
 	 * to become ready. Launch the writer which will constantly be writing
 	 * to each thread's fdmap.
 	 */
 	ret = pthread_create(&wthread, NULL, writerfn,
 			     (void *)(struct worker *) worker);
 	if (ret)
 		err(EXIT_FAILURE, "pthread_create");

 	sleep(nsecs);
 	toggle_done(0, NULL, NULL);
 	printinfo("main thread: toggling done\n");

 	sleep(1); /* meh */
 	wdone = true;
 	ret = pthread_join(wthread, NULL);
 	if (ret)
 		err(EXIT_FAILURE, "pthread_join");

 	/* cleanup & report results */
 	pthread_cond_destroy(&thread_parent);
 	pthread_cond_destroy(&thread_worker);
 	pthread_mutex_destroy(&thread_lock);

 	/* sort the array back before reporting */
 	if (randomize)
 		qsort(worker, nthreads, sizeof(struct worker), cmpworker);

 	for (i = 0; i < nthreads; i++) {
 		unsigned long t = worker[i].ops / bench__runtime.tv_sec;

 		update_stats(&throughput_stats, t);

 		if (nfds == 1)
 			printf("[thread %2d] fdmap: %p [ %04ld ops/sec ]\n",
 			       worker[i].tid, &worker[i].fdmap[0], t);
 		else
 			printf("[thread %2d] fdmap: %p ... %p [ %04ld ops/sec ]\n",
 			       worker[i].tid, &worker[i].fdmap[0],
 			       &worker[i].fdmap[nfds-1], t);
 	}

 	print_summary();

 	close(epollfd);
 	return ret;
 errmem:
 	err(EXIT_FAILURE, "calloc");
 }
 #endif // HAVE_EVENTFD
	// SPDX-License-Identifier: GPL-2.0
	#ifdef HAVE_EVENTFD
	/*
	* Copyright (C) 2018 Davidlohr Bueso.
	*
	* This program benchmarks concurrent epoll_wait(2) monitoring multiple
	* file descriptors under one or two load balancing models. The first,
	* and default, is the single/combined queueing (which refers to a single
	* epoll instance for N worker threads):
	*
	* \|---> [worker A]
	* \|---> [worker B]
	* [combined queue] .---> [worker C]
	* \|---> [worker D]
	* \|---> [worker E]
	*
	* While the second model, enabled via --multiq option, uses multiple
	* queueing (which refers to one epoll instance per worker). For example,
	* short lived tcp connections in a high throughput httpd server will
	* ditribute the accept()'ing connections across CPUs. In this case each
	* worker does a limited amount of processing.
	*
	* [queue A] ---> [worker]
	* [queue B] ---> [worker]
	* [queue C] ---> [worker]
	* [queue D] ---> [worker]
	* [queue E] ---> [worker]
	*
	* Naturally, the single queue will enforce more concurrency on the epoll
	* instance, and can therefore scale poorly compared to multiple queues.
	* However, this is a benchmark raw data and must be taken with a grain of
	* salt when choosing how to make use of sys_epoll.

	* Each thread has a number of private, nonblocking file descriptors,
	* referred to as fdmap. A writer thread will constantly be writing to
	* the fdmaps of all threads, minimizing each threads's chances of
	* epoll_wait not finding any ready read events and blocking as this
	* is not what we want to stress. The size of the fdmap can be adjusted
	* by the user; enlarging the value will increase the chances of
	* epoll_wait(2) blocking as the lineal writer thread will take "longer",
	* at least at a high level.
	*
	* Note that because fds are private to each thread, this workload does
	* not stress scenarios where multiple tasks are awoken per ready IO; ie:
	* EPOLLEXCLUSIVE semantics.
	*
	* The end result/metric is throughput: number of ops/second where an
	* operation consists of:
	*
	* epoll_wait(2) + [others]
	*
	* ... where [others] is the cost of re-adding the fd (EPOLLET),
	* or rearming it (EPOLLONESHOT).
	*
	*
	* The purpose of this is program is that it be useful for measuring
	* kernel related changes to the sys_epoll, and not comparing different
	* IO polling methods, for example. Hence everything is very adhoc and
	* outputs raw microbenchmark numbers. Also this uses eventfd, similar
	* tools tend to use pipes or sockets, but the result is the same.
	*/

	/* For the CLR_() macros */
	#include <string.h>
	#include <pthread.h>
	#include <unistd.h>

	#include <errno.h>
	#include <inttypes.h>
	#include <signal.h>
	#include <stdlib.h>
	#include <linux/compiler.h>
	#include <linux/kernel.h>
	#include <sys/time.h>
	#include <sys/resource.h>
	#include <sys/epoll.h>
	#include <sys/eventfd.h>
	#include <sys/types.h>
	#include <internal/cpumap.h>
	#include <perf/cpumap.h>

	#include "../util/stat.h"
	#include <subcmd/parse-options.h>
	#include "bench.h"

	#include <err.h>

	#define printinfo(fmt, arg...) \
	do { if (__verbose) { printf(fmt, ## arg); fflush(stdout); } } while (0)

	static unsigned int nthreads = 0;
	static unsigned int nsecs = 8;
	static bool wdone, done, __verbose, randomize, nonblocking;

	/*
	* epoll related shared variables.
	*/

	/* Maximum number of nesting allowed inside epoll sets */
	#define EPOLL_MAXNESTS 4

	static int epollfd;
	static int *epollfdp;
	static bool noaffinity;
	static unsigned int nested = 0;
	static bool et; /* edge-trigger */
	static bool oneshot;
	static bool multiq; /* use an epoll instance per thread */

	/* amount of fds to monitor, per thread */
	static unsigned int nfds = 64;

	static pthread_mutex_t thread_lock;
	static unsigned int threads_starting;
	static struct stats throughput_stats;
	static pthread_cond_t thread_parent, thread_worker;

	struct worker {
	int tid;
	int epollfd; /* for --multiq */
	pthread_t thread;
	unsigned long ops;
	int *fdmap;
	};

	static const struct option options[] = {
	/* general benchmark options */
	OPT_UINTEGER('t', "threads", &nthreads, "Specify amount of threads"),
	OPT_UINTEGER('r', "runtime", &nsecs, "Specify runtime (in seconds)"),
	OPT_UINTEGER('f', "nfds", &nfds, "Specify amount of file descriptors to monitor for each thread"),
	OPT_BOOLEAN( 'n', "noaffinity", &noaffinity, "Disables CPU affinity"),
	OPT_BOOLEAN('R', "randomize", &randomize, "Enable random write behaviour (default is lineal)"),
	OPT_BOOLEAN( 'v', "verbose", &__verbose, "Verbose mode"),

	/* epoll specific options */
	OPT_BOOLEAN( 'm', "multiq", &multiq, "Use multiple epoll instances (one per thread)"),
	OPT_BOOLEAN( 'B', "nonblocking", &nonblocking, "Nonblocking epoll_wait(2) behaviour"),
	OPT_UINTEGER( 'N', "nested", &nested, "Nesting level epoll hierarchy (default is 0, no nesting)"),
	OPT_BOOLEAN( 'S', "oneshot", &oneshot, "Use EPOLLONESHOT semantics"),
	OPT_BOOLEAN( 'E', "edge", &et, "Use Edge-triggered interface (default is LT)"),

	OPT_END()
	};

	static const char * const bench_epoll_wait_usage[] = {
	"perf bench epoll wait <options>",
	NULL
	};


	/*
	* Arrange the N elements of ARRAY in random order.
	* Only effective if N is much smaller than RAND_MAX;
	* if this may not be the case, use a better random
	* number generator. -- Ben Pfaff.
	*/
	static void shuffle(void *array, size_t n, size_t size)
	{
	char *carray = array;
	void *aux;
	size_t i;

	if (n <= 1)
	return;

	aux = calloc(1, size);
	if (!aux)
	err(EXIT_FAILURE, "calloc");

	for (i = 1; i < n; ++i) {
	size_t j = i + rand() / (RAND_MAX / (n - i) + 1);
	j *= size;

	memcpy(aux, &carray[j], size);
	memcpy(&carray[j], &carray[i*size], size);
	memcpy(&carray[i*size], aux, size);
	}

	free(aux);
	}


	static void workerfn(void arg)
	{
	int fd, ret, r;
	struct worker w = (struct worker ) arg;
	unsigned long ops = w->ops;
	struct epoll_event ev;
	uint64_t val;
	int to = nonblocking? 0 : -1;
	int efd = multiq ? w->epollfd : epollfd;

	pthread_mutex_lock(&thread_lock);
	threads_starting--;
	if (!threads_starting)
	pthread_cond_signal(&thread_parent);
	pthread_cond_wait(&thread_worker, &thread_lock);
	pthread_mutex_unlock(&thread_lock);

	do {
	/*
	* Block undefinitely waiting for the IN event.
	* In order to stress the epoll_wait(2) syscall,
	* call it event per event, instead of a larger
	* batch (max)limit.
	*/
	do {
	ret = epoll_wait(efd, &ev, 1, to);
	} while (ret < 0 && errno == EINTR);
	if (ret < 0)
	err(EXIT_FAILURE, "epoll_wait");

	fd = ev.data.fd;

	do {
	r = read(fd, &val, sizeof(val));
	} while (!done && (r < 0 && errno == EAGAIN));

	if (et) {
	ev.events = EPOLLIN \| EPOLLET;
	ret = epoll_ctl(efd, EPOLL_CTL_ADD, fd, &ev);
	}

	if (oneshot) {
	/* rearm the file descriptor with a new event mask */
	ev.events \|= EPOLLIN \| EPOLLONESHOT;
	ret = epoll_ctl(efd, EPOLL_CTL_MOD, fd, &ev);
	}

	ops++;
	} while (!done);

	if (multiq)
	close(w->epollfd);

	w->ops = ops;
	return NULL;
	}

	static void nest_epollfd(struct worker *w)
	{
	unsigned int i;
	struct epoll_event ev;
	int efd = multiq ? w->epollfd : epollfd;

	if (nested > EPOLL_MAXNESTS)
	nested = EPOLL_MAXNESTS;

	epollfdp = calloc(nested, sizeof(*epollfdp));
	if (!epollfdp)
	err(EXIT_FAILURE, "calloc");

	for (i = 0; i < nested; i++) {
	epollfdp[i] = epoll_create(1);
	if (epollfdp[i] < 0)
	err(EXIT_FAILURE, "epoll_create");
	}

	ev.events = EPOLLHUP; /* anything */
	ev.data.u64 = i; /* any number */

	for (i = nested - 1; i; i--) {
	if (epoll_ctl(epollfdp[i - 1], EPOLL_CTL_ADD,
	epollfdp[i], &ev) < 0)
	err(EXIT_FAILURE, "epoll_ctl");
	}

	if (epoll_ctl(efd, EPOLL_CTL_ADD, *epollfdp, &ev) < 0)
	err(EXIT_FAILURE, "epoll_ctl");
	}

	static void toggle_done(int sig __maybe_unused,
	siginfo_t *info __maybe_unused,
	void *uc __maybe_unused)
	{
	/* inform all threads that we're done for the day */
	done = true;
	gettimeofday(&bench__end, NULL);
	timersub(&bench__end, &bench__start, &bench__runtime);
	}

	static void print_summary(void)
	{
	unsigned long avg = avg_stats(&throughput_stats);
	double stddev = stddev_stats(&throughput_stats);

	printf("\nAveraged %ld operations/sec (+- %.2f%%), total secs = %d\n",
	avg, rel_stddev_stats(stddev, avg),
	(int)bench__runtime.tv_sec);
	}

	static int do_threads(struct worker worker, struct perf_cpu_map cpu)
	{
	pthread_attr_t thread_attr, *attrp = NULL;
	cpu_set_t cpuset;
	unsigned int i, j;
	int ret = 0, events = EPOLLIN;

	if (oneshot)
	events \|= EPOLLONESHOT;
	if (et)
	events \|= EPOLLET;

	printinfo("starting worker/consumer %sthreads%s\n",
	noaffinity ? "":"CPU affinity ",
	nonblocking ? " (nonblocking)":"");
	if (!noaffinity)
	pthread_attr_init(&thread_attr);

	for (i = 0; i < nthreads; i++) {
	struct worker *w = &worker[i];

	if (multiq) {
	w->epollfd = epoll_create(1);
	if (w->epollfd < 0)
	err(EXIT_FAILURE, "epoll_create");

	if (nested)
	nest_epollfd(w);
	}

	w->tid = i;
	w->fdmap = calloc(nfds, sizeof(int));
	if (!w->fdmap)
	return 1;

	for (j = 0; j < nfds; j++) {
	int efd = multiq ? w->epollfd : epollfd;
	struct epoll_event ev;

	w->fdmap[j] = eventfd(0, EFD_NONBLOCK);
	if (w->fdmap[j] < 0)
	err(EXIT_FAILURE, "eventfd");

	ev.data.fd = w->fdmap[j];
	ev.events = events;

	ret = epoll_ctl(efd, EPOLL_CTL_ADD,
	w->fdmap[j], &ev);
	if (ret < 0)
	err(EXIT_FAILURE, "epoll_ctl");
	}

	if (!noaffinity) {
	CPU_ZERO(&cpuset);
	CPU_SET(cpu->map[i % cpu->nr], &cpuset);

	ret = pthread_attr_setaffinity_np(&thread_attr, sizeof(cpu_set_t), &cpuset);
	if (ret)
	err(EXIT_FAILURE, "pthread_attr_setaffinity_np");

	attrp = &thread_attr;
	}

	ret = pthread_create(&w->thread, attrp, workerfn,
	(void )(struct worker ) w);
	if (ret)
	err(EXIT_FAILURE, "pthread_create");
	}

	if (!noaffinity)
	pthread_attr_destroy(&thread_attr);

	return ret;
	}

	static void writerfn(void p)
	{
	struct worker *worker = p;
	size_t i, j, iter;
	const uint64_t val = 1;
	ssize_t sz;
	struct timespec ts = { .tv_sec = 0,
	.tv_nsec = 500 };

	printinfo("starting writer-thread: doing %s writes ...\n",
	randomize? "random":"lineal");

	for (iter = 0; !wdone; iter++) {
	if (randomize) {
	shuffle((void )worker, nthreads, sizeof(worker));
	}

	for (i = 0; i < nthreads; i++) {
	struct worker *w = &worker[i];

	if (randomize) {
	shuffle((void *)w->fdmap, nfds, sizeof(int));
	}

	for (j = 0; j < nfds; j++) {
	do {
	sz = write(w->fdmap[j], &val, sizeof(val));
	} while (!wdone && (sz < 0 && errno == EAGAIN));
	}
	}

	nanosleep(&ts, NULL);
	}

	printinfo("exiting writer-thread (total full-loops: %zd)\n", iter);
	return NULL;
	}

	static int cmpworker(const void p1, const void p2)
	{

	struct worker w1 = (struct worker ) p1;
	struct worker w2 = (struct worker ) p2;
	return w1->tid > w2->tid;
	}

	int bench_epoll_wait(int argc, const char **argv)
	{
	int ret = 0;
	struct sigaction act;
	unsigned int i;
	struct worker *worker = NULL;
	struct perf_cpu_map *cpu;
	pthread_t wthread;
	struct rlimit rl, prevrl;

	argc = parse_options(argc, argv, options, bench_epoll_wait_usage, 0);
	if (argc) {
	usage_with_options(bench_epoll_wait_usage, options);
	exit(EXIT_FAILURE);
	}

	memset(&act, 0, sizeof(act));
	sigfillset(&act.sa_mask);
	act.sa_sigaction = toggle_done;
	sigaction(SIGINT, &act, NULL);

	cpu = perf_cpu_map__new(NULL);
	if (!cpu)
	goto errmem;

	/* a single, main epoll instance */
	if (!multiq) {
	epollfd = epoll_create(1);
	if (epollfd < 0)
	err(EXIT_FAILURE, "epoll_create");

	/*
	* Deal with nested epolls, if any.
	*/
	if (nested)
	nest_epollfd(NULL);
	}

	printinfo("Using %s queue model\n", multiq ? "multi" : "single");
	printinfo("Nesting level(s): %d\n", nested);

	/* default to the number of CPUs and leave one for the writer pthread */
	if (!nthreads)
	nthreads = cpu->nr - 1;

	worker = calloc(nthreads, sizeof(*worker));
	if (!worker) {
	goto errmem;
	}

	if (getrlimit(RLIMIT_NOFILE, &prevrl))
	err(EXIT_FAILURE, "getrlimit");
	rl.rlim_cur = rl.rlim_max = nfds * nthreads * 2 + 50;
	printinfo("Setting RLIMIT_NOFILE rlimit from %" PRIu64 " to: %" PRIu64 "\n",
	(uint64_t)prevrl.rlim_max, (uint64_t)rl.rlim_max);
	if (setrlimit(RLIMIT_NOFILE, &rl) < 0)
	err(EXIT_FAILURE, "setrlimit");

	printf("Run summary [PID %d]: %d threads monitoring%s on "
	"%d file-descriptors for %d secs.\n\n",
	getpid(), nthreads, oneshot ? " (EPOLLONESHOT semantics)": "", nfds, nsecs);

	init_stats(&throughput_stats);
	pthread_mutex_init(&thread_lock, NULL);
	pthread_cond_init(&thread_parent, NULL);
	pthread_cond_init(&thread_worker, NULL);

	threads_starting = nthreads;

	gettimeofday(&bench__start, NULL);

	do_threads(worker, cpu);

	pthread_mutex_lock(&thread_lock);
	while (threads_starting)
	pthread_cond_wait(&thread_parent, &thread_lock);
	pthread_cond_broadcast(&thread_worker);
	pthread_mutex_unlock(&thread_lock);

	/*
	* At this point the workers should be blocked waiting for read events
	* to become ready. Launch the writer which will constantly be writing
	* to each thread's fdmap.
	*/
	ret = pthread_create(&wthread, NULL, writerfn,
	(void )(struct worker ) worker);
	if (ret)
	err(EXIT_FAILURE, "pthread_create");

	sleep(nsecs);
	toggle_done(0, NULL, NULL);
	printinfo("main thread: toggling done\n");

	sleep(1); /* meh */
	wdone = true;
	ret = pthread_join(wthread, NULL);
	if (ret)
	err(EXIT_FAILURE, "pthread_join");

	/* cleanup & report results */
	pthread_cond_destroy(&thread_parent);
	pthread_cond_destroy(&thread_worker);
	pthread_mutex_destroy(&thread_lock);

	/* sort the array back before reporting */
	if (randomize)
	qsort(worker, nthreads, sizeof(struct worker), cmpworker);

	for (i = 0; i < nthreads; i++) {
	unsigned long t = worker[i].ops / bench__runtime.tv_sec;

	update_stats(&throughput_stats, t);

	if (nfds == 1)
	printf("[thread %2d] fdmap: %p [ %04ld ops/sec ]\n",
	worker[i].tid, &worker[i].fdmap[0], t);
	else
	printf("[thread %2d] fdmap: %p ... %p [ %04ld ops/sec ]\n",
	worker[i].tid, &worker[i].fdmap[0],
	&worker[i].fdmap[nfds-1], t);
	}

	print_summary();

	close(epollfd);
	return ret;
	errmem:
	err(EXIT_FAILURE, "calloc");
	}
	#endif // HAVE_EVENTFD