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 static int futex_flag = 0;
  30
  31 struct timeval start, end, runtime;
  32 static pthread_mutex_t thread_lock;
  33 static unsigned int threads_starting;
  34 static struct stats throughput_stats;
  35 static pthread_cond_t thread_parent, thread_worker;
  36
  37 struct worker {
  38         int tid;
  39         u_int32_t *futex;
  40         pthread_t thread;
  41         unsigned long ops;
  42 };
  43
  44 static const struct option options[] = {
  45         OPT_UINTEGER('t', "threads", &nthreads, "Specify amount of threads"),
  46         OPT_UINTEGER('r', "runtime", &nsecs,    "Specify runtime (in seconds)"),
  47         OPT_UINTEGER('f', "futexes", &nfutexes, "Specify amount of futexes per threads"),
  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
  53 static const char * const bench_futex_hash_usage[] = {
  54         "perf bench futex hash <options>",
  55         NULL
  56 };
  57
  58 static void *workerfn(void *arg)
  59 {
  60         int ret;
  61         unsigned int i;
  62         struct worker *w = (struct worker *) arg;
  63
  64         pthread_mutex_lock(&thread_lock);
  65         threads_starting--;
  66         if (!threads_starting)
  67                 pthread_cond_signal(&thread_parent);
  68         pthread_cond_wait(&thread_worker, &thread_lock);
  69         pthread_mutex_unlock(&thread_lock);
  70
  71         do {
  72                 for (i = 0; i < nfutexes; i++, w->ops++) {
  73                         /*
  74                          * We want the futex calls to fail in order to stress
  75                          * the hashing of uaddr and not measure other steps,
  76                          * such as internal waitqueue handling, thus enlarging
  77                          * the critical region protected by hb->lock.
  78                          */
  79                         ret = futex_wait(&w->futex[i], 1234, NULL, futex_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         if (!fshared)
 139                 futex_flag = FUTEX_PRIVATE_FLAG;
 140
 141         printf("Run summary [PID %d]: %d threads, each operating on %d [%s] futexes for %d secs.\n\n",
 142                getpid(), nthreads, nfutexes, fshared ? "shared":"private", nsecs);
 143
 144         init_stats(&throughput_stats);
 145         pthread_mutex_init(&thread_lock, NULL);
 146         pthread_cond_init(&thread_parent, NULL);
 147         pthread_cond_init(&thread_worker, NULL);
 148
 149         threads_starting = nthreads;
 150         pthread_attr_init(&thread_attr);
 151         gettimeofday(&start, NULL);
 152         for (i = 0; i < nthreads; i++) {
 153                 worker[i].tid = i;
 154                 worker[i].futex = calloc(nfutexes, sizeof(*worker[i].futex));
 155                 if (!worker[i].futex)
 156                         goto errmem;
 157
 158                 CPU_ZERO(&cpu);
 159                 CPU_SET(i % ncpus, &cpu);
 160
 161                 ret = pthread_attr_setaffinity_np(&thread_attr, sizeof(cpu_set_t), &cpu);
 162                 if (ret)
 163                         err(EXIT_FAILURE, "pthread_attr_setaffinity_np");
 164
 165                 ret = pthread_create(&worker[i].thread, &thread_attr, workerfn,
 166                                      (void *)(struct worker *) &worker[i]);
 167                 if (ret)
 168                         err(EXIT_FAILURE, "pthread_create");
 169
 170         }
 171         pthread_attr_destroy(&thread_attr);
 172
 173         pthread_mutex_lock(&thread_lock);
 174         while (threads_starting)
 175                 pthread_cond_wait(&thread_parent, &thread_lock);
 176         pthread_cond_broadcast(&thread_worker);
 177         pthread_mutex_unlock(&thread_lock);
 178
 179         sleep(nsecs);
 180         toggle_done(0, NULL, NULL);
 181
 182         for (i = 0; i < nthreads; i++) {
 183                 ret = pthread_join(worker[i].thread, NULL);
 184                 if (ret)
 185                         err(EXIT_FAILURE, "pthread_join");
 186         }
 187
 188         /* cleanup & report results */
 189         pthread_cond_destroy(&thread_parent);
 190         pthread_cond_destroy(&thread_worker);
 191         pthread_mutex_destroy(&thread_lock);
 192
 193         for (i = 0; i < nthreads; i++) {
 194                 unsigned long t = worker[i].ops/runtime.tv_sec;
 195                 update_stats(&throughput_stats, t);
 196                 if (!silent) {
 197                         if (nfutexes == 1)
 198                                 printf("[thread %2d] futex: %p [ %ld ops/sec ]\n",
 199                                        worker[i].tid, &worker[i].futex[0], t);
 200                         else
 201                                 printf("[thread %2d] futexes: %p ... %p [ %ld ops/sec ]\n",
 202                                        worker[i].tid, &worker[i].futex[0],
 203                                        &worker[i].futex[nfutexes-1], t);
 204                 }
 205
 206                 free(worker[i].futex);
 207         }
 208
 209         print_summary();
 210
 211         free(worker);
 212         return ret;
 213 errmem:
 214         err(EXIT_FAILURE, "calloc");
 215 }