1/*
  2 * Copyright (C) 2013  Davidlohr Bueso <davidlohr@hp.com>
  3 *
  4 * futex-wake: Block a bunch of threads on a futex and wake'em up, N at a time.
  5 *
  6 * This program is particularly useful to measure the latency of nthread wakeups
  7 * in non-error situations:  all waiters are queued and all wake calls wakeup
  8 * one or more tasks, and thus the waitqueue is never empty.
  9 */
 10
 11/* For the CLR_() macros */
 12#include <pthread.h>
 13
 14#include <signal.h>
 15#include "../util/stat.h"
 16#include <subcmd/parse-options.h>
 17#include <linux/compiler.h>
 18#include <linux/kernel.h>
 19#include <linux/time64.h>
 20#include <errno.h>
 21#include "bench.h"
 22#include "futex.h"
 23
 24#include <err.h>
 25#include <stdlib.h>
 26#include <sys/time.h>
 27
 28/* all threads will block on the same futex */
 29static u_int32_t futex1 = 0;
 30
 31/*
 32 * How many wakeups to do at a time.
 33 * Default to 1 in order to make the kernel work more.
 34 */
 35static unsigned int nwakes = 1;
 36
 37pthread_t *worker;
 38static bool done = false, silent = false, fshared = false;
 39static pthread_mutex_t thread_lock;
 40static pthread_cond_t thread_parent, thread_worker;
 41static struct stats waketime_stats, wakeup_stats;
 42static unsigned int ncpus, threads_starting, nthreads = 0;
 43static int futex_flag = 0;
 44
 45static const struct option options[] = {
 46	OPT_UINTEGER('t', "threads", &nthreads, "Specify amount of threads"),
 47	OPT_UINTEGER('w', "nwakes",  &nwakes,   "Specify amount of threads to wake at once"),
 48	OPT_BOOLEAN( 's', "silent",  &silent,   "Silent mode: do not display data/details"),
 49	OPT_BOOLEAN( 'S', "shared",  &fshared,  "Use shared futexes instead of private ones"),
 50	OPT_END()
 51};
 52
 53static const char * const bench_futex_wake_usage[] = {
 54	"perf bench futex wake <options>",
 55	NULL
 56};
 57
 58static void *workerfn(void *arg __maybe_unused)
 59{
 60	pthread_mutex_lock(&thread_lock);
 61	threads_starting--;
 62	if (!threads_starting)
 63		pthread_cond_signal(&thread_parent);
 64	pthread_cond_wait(&thread_worker, &thread_lock);
 65	pthread_mutex_unlock(&thread_lock);
 66
 67	while (1) {
 68		if (futex_wait(&futex1, 0, NULL, futex_flag) != EINTR)
 69			break;
 70	}
 71
 72	pthread_exit(NULL);
 73	return NULL;
 74}
 75
 76static void print_summary(void)
 77{
 78	double waketime_avg = avg_stats(&waketime_stats);
 79	double waketime_stddev = stddev_stats(&waketime_stats);
 80	unsigned int wakeup_avg = avg_stats(&wakeup_stats);
 81
 82	printf("Wokeup %d of %d threads in %.4f ms (+-%.2f%%)\n",
 83	       wakeup_avg,
 84	       nthreads,
 85	       waketime_avg / USEC_PER_MSEC,
 86	       rel_stddev_stats(waketime_stddev, waketime_avg));
 87}
 88
 89static void block_threads(pthread_t *w,
 90			  pthread_attr_t thread_attr)
 91{
 92	cpu_set_t cpu;
 93	unsigned int i;
 94
 95	threads_starting = nthreads;
 96
 97	/* create and block all threads */
 98	for (i = 0; i < nthreads; i++) {
 99		CPU_ZERO(&cpu);
100		CPU_SET(i % ncpus, &cpu);
101
102		if (pthread_attr_setaffinity_np(&thread_attr, sizeof(cpu_set_t), &cpu))
103			err(EXIT_FAILURE, "pthread_attr_setaffinity_np");
104
105		if (pthread_create(&w[i], &thread_attr, workerfn, NULL))
106			err(EXIT_FAILURE, "pthread_create");
107	}
108}
109
110static void toggle_done(int sig __maybe_unused,
111			siginfo_t *info __maybe_unused,
112			void *uc __maybe_unused)
113{
114	done = true;
115}
116
117int bench_futex_wake(int argc, const char **argv,
118		     const char *prefix __maybe_unused)
119{
120	int ret = 0;
121	unsigned int i, j;
122	struct sigaction act;
123	pthread_attr_t thread_attr;
124
125	argc = parse_options(argc, argv, options, bench_futex_wake_usage, 0);
126	if (argc) {
127		usage_with_options(bench_futex_wake_usage, options);
128		exit(EXIT_FAILURE);
129	}
130
131	ncpus = sysconf(_SC_NPROCESSORS_ONLN);
132	nwakes = futexbench_sanitize_numeric(nwakes);
133
134	sigfillset(&act.sa_mask);
135	act.sa_sigaction = toggle_done;
136	sigaction(SIGINT, &act, NULL);
137
138	if (!nthreads)
139		nthreads = ncpus;
140	else
141		nthreads = futexbench_sanitize_numeric(nthreads);
142
143	worker = calloc(nthreads, sizeof(*worker));
144	if (!worker)
145		err(EXIT_FAILURE, "calloc");
146
147	if (!fshared)
148		futex_flag = FUTEX_PRIVATE_FLAG;
149
150	printf("Run summary [PID %d]: blocking on %d threads (at [%s] futex %p), "
151	       "waking up %d at a time.\n\n",
152	       getpid(), nthreads, fshared ? "shared":"private",  &futex1, nwakes);
153
154	init_stats(&wakeup_stats);
155	init_stats(&waketime_stats);
156	pthread_attr_init(&thread_attr);
157	pthread_mutex_init(&thread_lock, NULL);
158	pthread_cond_init(&thread_parent, NULL);
159	pthread_cond_init(&thread_worker, NULL);
160
161	for (j = 0; j < bench_repeat && !done; j++) {
162		unsigned int nwoken = 0;
163		struct timeval start, end, runtime;
164
165		/* create, launch & block all threads */
166		block_threads(worker, thread_attr);
167
168		/* make sure all threads are already blocked */
169		pthread_mutex_lock(&thread_lock);
170		while (threads_starting)
171			pthread_cond_wait(&thread_parent, &thread_lock);
172		pthread_cond_broadcast(&thread_worker);
173		pthread_mutex_unlock(&thread_lock);
174
175		usleep(100000);
176
177		/* Ok, all threads are patiently blocked, start waking folks up */
178		gettimeofday(&start, NULL);
179		while (nwoken != nthreads)
180			nwoken += futex_wake(&futex1, nwakes, futex_flag);
181		gettimeofday(&end, NULL);
182		timersub(&end, &start, &runtime);
183
184		update_stats(&wakeup_stats, nwoken);
185		update_stats(&waketime_stats, runtime.tv_usec);
186
187		if (!silent) {
188			printf("[Run %d]: Wokeup %d of %d threads in %.4f ms\n",
189			       j + 1, nwoken, nthreads, runtime.tv_usec / (double)USEC_PER_MSEC);
190		}
191
192		for (i = 0; i < nthreads; i++) {
193			ret = pthread_join(worker[i], NULL);
194			if (ret)
195				err(EXIT_FAILURE, "pthread_join");
196		}
197
198	}
199
200	/* cleanup & report results */
201	pthread_cond_destroy(&thread_parent);
202	pthread_cond_destroy(&thread_worker);
203	pthread_mutex_destroy(&thread_lock);
204	pthread_attr_destroy(&thread_attr);
205
206	print_summary();
207
208	free(worker);
209	return ret;
210}