tools/perf/bench/futex-hash.c

   1 /*
   2  * Copyright (C) 2013  Davidlohr Bueso <davidlohr@hp.com>
   3  *
   4  * futex-hash: Stress the hell out of the Linux kernel futex uaddr hashing.
   5  *
   6  * This program is particularly useful for measuring the kernel's futex hash
   7  * table/function implementation. In order for it to make sense, use with as
   8  * many threads and futexes as possible.
   9  */
  10
  11 #include "../perf.h"
  12 #include "../util/util.h"
  13 #include "../util/stat.h"
  14 #include "../util/parse-options.h"
  15 #include "../util/header.h"
  16 #include "bench.h"
  17 #include "futex.h"
  18
  19 #include <err.h>
  20 #include <stdlib.h>
  21 #include <sys/time.h>
  22 #include <pthread.h>
  23
  24 static unsigned int nthreads = 0;
  25 static unsigned int nsecs    = 10;
  26 /* amount of futexes per thread */
  27 static unsigned int nfutexes = 1024;
  28 static bool fshared = false, done = false, silent = false;
  29
  30 struct timeval start, end, runtime;
  31 static pthread_mutex_t thread_lock;
  32 static unsigned int threads_starting;
  33 static struct stats throughput_stats;
  34 static pthread_cond_t thread_parent, thread_worker;
  35
  36 struct worker {
  37         int tid;
  38         u_int32_t *futex;
  39         pthread_t thread;
  40         unsigned long ops;
  41 };
  42
  43 static const struct option options[] = {
  44         OPT_UINTEGER('t', "threads", &nthreads, "Specify amount of threads"),
  45         OPT_UINTEGER('r', "runtime", &nsecs,    "Specify runtime (in seconds)"),
  46         OPT_UINTEGER('f', "futexes", &nfutexes, "Specify amount of futexes per threads"),
  47         OPT_BOOLEAN( 's', "silent",  &silent,   "Silent mode: do not display data/details"),
  48         OPT_BOOLEAN( 'S', "shared",  &fshared,  "Use shared futexes instead of private ones"),
  49         OPT_END()
  50 };
  51
  52 static const char * const bench_futex_hash_usage[] = {
  53         "perf bench futex hash <options>",
  54         NULL
  55 };
  56
  57 static void *workerfn(void *arg)
  58 {
  59         int ret;
  60         unsigned int i;
  61         struct worker *w = (struct worker *) arg;
  62
  63         pthread_mutex_lock(&thread_lock);
  64         threads_starting--;
  65         if (!threads_starting)
  66                 pthread_cond_signal(&thread_parent);
  67         pthread_cond_wait(&thread_worker, &thread_lock);
  68         pthread_mutex_unlock(&thread_lock);
  69
  70         do {
  71                 for (i = 0; i < nfutexes; i++, w->ops++) {
  72                         /*
  73                          * We want the futex calls to fail in order to stress
  74                          * the hashing of uaddr and not measure other steps,
  75                          * such as internal waitqueue handling, thus enlarging
  76                          * the critical region protected by hb->lock.
  77                          */
  78                         ret = futex_wait(&w->futex[i], 1234, NULL,
  79                                          fshared ? 0 : FUTEX_PRIVATE_FLAG);
  80                         if (!silent &&
  81                             (!ret || errno != EAGAIN || errno != EWOULDBLOCK))
  82                                 warn("Non-expected futex return call");
  83                 }
  84         }  while (!done);
  85
  86         return NULL;
  87 }
  88
  89 static void toggle_done(int sig __maybe_unused,
  90                         siginfo_t *info __maybe_unused,
  91                         void *uc __maybe_unused)
  92 {
  93         /* inform all threads that we're done for the day */
  94         done = true;
  95         gettimeofday(&end, NULL);
  96         timersub(&end, &start, &runtime);
  97 }
  98
  99 static void print_summary(void)
 100 {
 101         unsigned long avg = avg_stats(&throughput_stats);
 102         double stddev = stddev_stats(&throughput_stats);
 103
 104         printf("%sAveraged %ld operations/sec (+- %.2f%%), total secs = %d\n",
 105                !silent ? "\n" : "", avg, rel_stddev_stats(stddev, avg),
 106                (int) runtime.tv_sec);
 107 }
 108
 109 int bench_futex_hash(int argc, const char **argv,
 110                      const char *prefix __maybe_unused)
 111 {
 112         int ret = 0;
 113         cpu_set_t cpu;
 114         struct sigaction act;
 115         unsigned int i, ncpus;
 116         pthread_attr_t thread_attr;
 117         struct worker *worker = NULL;
 118
 119         argc = parse_options(argc, argv, options, bench_futex_hash_usage, 0);
 120         if (argc) {
 121                 usage_with_options(bench_futex_hash_usage, options);
 122                 exit(EXIT_FAILURE);
 123         }
 124
 125         ncpus = sysconf(_SC_NPROCESSORS_ONLN);
 126
 127         sigfillset(&act.sa_mask);
 128         act.sa_sigaction = toggle_done;
 129         sigaction(SIGINT, &act, NULL);
 130
 131         if (!nthreads) /* default to the number of CPUs */
 132                 nthreads = ncpus;
 133
 134         worker = calloc(nthreads, sizeof(*worker));
 135         if (!worker)
 136                 goto errmem;
 137
 138         printf("Run summary [PID %d]: %d threads, each operating on %d [%s] futexes for %d secs.\n\n",
 139                getpid(), nthreads, nfutexes, fshared ? "shared":"private", nsecs);
 140
 141         init_stats(&throughput_stats);
 142         pthread_mutex_init(&thread_lock, NULL);
 143         pthread_cond_init(&thread_parent, NULL);
 144         pthread_cond_init(&thread_worker, NULL);
 145
 146         threads_starting = nthreads;
 147         pthread_attr_init(&thread_attr);
 148         gettimeofday(&start, NULL);
 149         for (i = 0; i < nthreads; i++) {
 150                 worker[i].tid = i;
 151                 worker[i].futex = calloc(nfutexes, sizeof(*worker[i].futex));
 152                 if (!worker[i].futex)
 153                         goto errmem;
 154
 155                 CPU_ZERO(&cpu);
 156                 CPU_SET(i % ncpus, &cpu);
 157
 158                 ret = pthread_attr_setaffinity_np(&thread_attr, sizeof(cpu_set_t), &cpu);
 159                 if (ret)
 160                         err(EXIT_FAILURE, "pthread_attr_setaffinity_np");
 161
 162                 ret = pthread_create(&worker[i].thread, &thread_attr, workerfn,
 163                                      (void *)(struct worker *) &worker[i]);
 164                 if (ret)
 165                         err(EXIT_FAILURE, "pthread_create");
 166
 167         }
 168         pthread_attr_destroy(&thread_attr);
 169
 170         pthread_mutex_lock(&thread_lock);
 171         while (threads_starting)
 172                 pthread_cond_wait(&thread_parent, &thread_lock);
 173         pthread_cond_broadcast(&thread_worker);
 174         pthread_mutex_unlock(&thread_lock);
 175
 176         sleep(nsecs);
 177         toggle_done(0, NULL, NULL);
 178
 179         for (i = 0; i < nthreads; i++) {
 180                 ret = pthread_join(worker[i].thread, NULL);
 181                 if (ret)
 182                         err(EXIT_FAILURE, "pthread_join");
 183         }
 184
 185         /* cleanup & report results */
 186         pthread_cond_destroy(&thread_parent);
 187         pthread_cond_destroy(&thread_worker);
 188         pthread_mutex_destroy(&thread_lock);
 189
 190         for (i = 0; i < nthreads; i++) {
 191                 unsigned long t = worker[i].ops/runtime.tv_sec;
 192                 update_stats(&throughput_stats, t);
 193                 if (!silent) {
 194                         if (nfutexes == 1)
 195                                 printf("[thread %2d] futex: %p [ %ld ops/sec ]\n",
 196                                        worker[i].tid, &worker[i].futex[0], t);
 197                         else
 198                                 printf("[thread %2d] futexes: %p ... %p [ %ld ops/sec ]\n",
 199                                        worker[i].tid, &worker[i].futex[0],
 200                                        &worker[i].futex[nfutexes-1], t);
 201                 }
 202
 203                 free(worker[i].futex);
 204         }
 205
 206         print_summary();
 207
 208         free(worker);
 209         return ret;
 210 errmem:
 211         err(EXIT_FAILURE, "calloc");
 212 }