Linux Perf
futex-lock-pi.c
Go to the documentation of this file.
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Copyright (C) 2015 Davidlohr Bueso.
4  */
5 
6 /* For the CLR_() macros */
7 #include <string.h>
8 #include <pthread.h>
9 
10 #include <signal.h>
11 #include "../util/stat.h"
12 #include <subcmd/parse-options.h>
13 #include <linux/compiler.h>
14 #include <linux/kernel.h>
15 #include <errno.h>
16 #include "bench.h"
17 #include "futex.h"
18 #include "cpumap.h"
19 
20 #include <err.h>
21 #include <stdlib.h>
22 #include <sys/time.h>
23 
24 struct worker {
25  int tid;
26  u_int32_t *futex;
27  pthread_t thread;
28  unsigned long ops;
29 };
30 
31 static u_int32_t global_futex = 0;
32 static struct worker *worker;
33 static unsigned int nsecs = 10;
34 static bool silent = false, multi = false;
35 static bool done = false, fshared = false;
36 static unsigned int nthreads = 0;
37 static int futex_flag = 0;
38 struct timeval start, end, runtime;
39 static pthread_mutex_t thread_lock;
40 static unsigned int threads_starting;
41 static struct stats throughput_stats;
42 static pthread_cond_t thread_parent, thread_worker;
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_BOOLEAN( 'M', "multi", &multi, "Use multiple futexes"),
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_lock_pi_usage[] = {
54  "perf bench futex lock-pi <options>",
55  NULL
56 };
57 
58 static void print_summary(void)
59 {
60  unsigned long avg = avg_stats(&throughput_stats);
61  double stddev = stddev_stats(&throughput_stats);
62 
63  printf("%sAveraged %ld operations/sec (+- %.2f%%), total secs = %d\n",
64  !silent ? "\n" : "", avg, rel_stddev_stats(stddev, avg),
65  (int) runtime.tv_sec);
66 }
67 
68 static void toggle_done(int sig __maybe_unused,
69  siginfo_t *info __maybe_unused,
70  void *uc __maybe_unused)
71 {
72  /* inform all threads that we're done for the day */
73  done = true;
74  gettimeofday(&end, NULL);
75  timersub(&end, &start, &runtime);
76 }
77 
78 static void *workerfn(void *arg)
79 {
80  struct worker *w = (struct worker *) arg;
81  unsigned long ops = w->ops;
82 
83  pthread_mutex_lock(&thread_lock);
85  if (!threads_starting)
86  pthread_cond_signal(&thread_parent);
87  pthread_cond_wait(&thread_worker, &thread_lock);
88  pthread_mutex_unlock(&thread_lock);
89 
90  do {
91  int ret;
92  again:
93  ret = futex_lock_pi(w->futex, NULL, futex_flag);
94 
95  if (ret) { /* handle lock acquisition */
96  if (!silent)
97  warn("thread %d: Could not lock pi-lock for %p (%d)",
98  w->tid, w->futex, ret);
99  if (done)
100  break;
101 
102  goto again;
103  }
104 
105  usleep(1);
106  ret = futex_unlock_pi(w->futex, futex_flag);
107  if (ret && !silent)
108  warn("thread %d: Could not unlock pi-lock for %p (%d)",
109  w->tid, w->futex, ret);
110  ops++; /* account for thread's share of work */
111  } while (!done);
112 
113  w->ops = ops;
114  return NULL;
115 }
116 
117 static void create_threads(struct worker *w, pthread_attr_t thread_attr,
118  struct cpu_map *cpu)
119 {
120  cpu_set_t cpuset;
121  unsigned int i;
122 
124 
125  for (i = 0; i < nthreads; i++) {
126  worker[i].tid = i;
127 
128  if (multi) {
129  worker[i].futex = calloc(1, sizeof(u_int32_t));
130  if (!worker[i].futex)
131  err(EXIT_FAILURE, "calloc");
132  } else
133  worker[i].futex = &global_futex;
134 
135  CPU_ZERO(&cpuset);
136  CPU_SET(cpu->map[i % cpu->nr], &cpuset);
137 
138  if (pthread_attr_setaffinity_np(&thread_attr, sizeof(cpu_set_t), &cpuset))
139  err(EXIT_FAILURE, "pthread_attr_setaffinity_np");
140 
141  if (pthread_create(&w[i].thread, &thread_attr, workerfn, &worker[i]))
142  err(EXIT_FAILURE, "pthread_create");
143  }
144 }
145 
146 int bench_futex_lock_pi(int argc, const char **argv)
147 {
148  int ret = 0;
149  unsigned int i;
150  struct sigaction act;
151  pthread_attr_t thread_attr;
152  struct cpu_map *cpu;
153 
154  argc = parse_options(argc, argv, options, bench_futex_lock_pi_usage, 0);
155  if (argc)
156  goto err;
157 
158  cpu = cpu_map__new(NULL);
159  if (!cpu)
160  err(EXIT_FAILURE, "calloc");
161 
162  sigfillset(&act.sa_mask);
163  act.sa_sigaction = toggle_done;
164  sigaction(SIGINT, &act, NULL);
165 
166  if (!nthreads)
167  nthreads = cpu->nr;
168 
169  worker = calloc(nthreads, sizeof(*worker));
170  if (!worker)
171  err(EXIT_FAILURE, "calloc");
172 
173  if (!fshared)
175 
176  printf("Run summary [PID %d]: %d threads doing pi lock/unlock pairing for %d secs.\n\n",
177  getpid(), nthreads, nsecs);
178 
180  pthread_mutex_init(&thread_lock, NULL);
181  pthread_cond_init(&thread_parent, NULL);
182  pthread_cond_init(&thread_worker, NULL);
183 
185  pthread_attr_init(&thread_attr);
186  gettimeofday(&start, NULL);
187 
188  create_threads(worker, thread_attr, cpu);
189  pthread_attr_destroy(&thread_attr);
190 
191  pthread_mutex_lock(&thread_lock);
192  while (threads_starting)
193  pthread_cond_wait(&thread_parent, &thread_lock);
194  pthread_cond_broadcast(&thread_worker);
195  pthread_mutex_unlock(&thread_lock);
196 
197  sleep(nsecs);
198  toggle_done(0, NULL, NULL);
199 
200  for (i = 0; i < nthreads; i++) {
201  ret = pthread_join(worker[i].thread, NULL);
202  if (ret)
203  err(EXIT_FAILURE, "pthread_join");
204  }
205 
206  /* cleanup & report results */
207  pthread_cond_destroy(&thread_parent);
208  pthread_cond_destroy(&thread_worker);
209  pthread_mutex_destroy(&thread_lock);
210 
211  for (i = 0; i < nthreads; i++) {
212  unsigned long t = worker[i].ops/runtime.tv_sec;
213 
215  if (!silent)
216  printf("[thread %3d] futex: %p [ %ld ops/sec ]\n",
217  worker[i].tid, worker[i].futex, t);
218 
219  if (multi)
220  free(worker[i].futex);
221  }
222 
223  print_summary();
224 
225  free(worker);
226  return ret;
227 err:
228  usage_with_options(bench_futex_lock_pi_usage, options);
229  exit(EXIT_FAILURE);
230 }
int nr
Definition: cpumap.h:14
def avg(total, n)
Definition: Util.py:19
double avg_stats(struct stats *stats)
Definition: stat.c:26
static bool fshared
Definition: futex-lock-pi.c:35
Definition: genelf.c:61
static bool silent
Definition: futex-lock-pi.c:34
int int err
Definition: 5sec.c:44
pthread_t thread
Definition: futex-hash.c:47
static struct stats throughput_stats
Definition: futex-lock-pi.c:41
int bench_futex_lock_pi(int argc, const char **argv)
static int futex_flag
Definition: futex-lock-pi.c:37
Definition: cpumap.h:12
static pthread_mutex_t thread_lock
Definition: futex-lock-pi.c:39
double stddev_stats(struct stats *stats)
Definition: stat.c:47
static void init_stats(struct stats *stats)
Definition: stat.h:103
int tid
Definition: futex-hash.c:45
Definition: thread.h:18
static void create_threads(struct worker *w, pthread_attr_t thread_attr, struct cpu_map *cpu)
void update_stats(struct stats *stats, u64 val)
Definition: stat.c:10
static void print_summary(void)
Definition: futex-lock-pi.c:58
static bool done
Definition: futex-lock-pi.c:35
static const char *const bench_futex_lock_pi_usage[]
Definition: futex-lock-pi.c:53
static int pthread_attr_setaffinity_np(pthread_attr_t *attr __maybe_unused, size_t cpusetsize __maybe_unused, cpu_set_t *cpuset __maybe_unused)
Definition: futex.h:93
double rel_stddev_stats(double stddev, double avg)
Definition: stat.c:60
int map[]
Definition: cpumap.h:15
static void * workerfn(void *arg)
Definition: futex-lock-pi.c:78
int FUTEX_PRIVATE_FLAG
Definition: Util.py:13
static pthread_cond_t thread_parent
Definition: futex-lock-pi.c:42
static pthread_cond_t thread_worker
Definition: futex-lock-pi.c:42
u64 start
Definition: hists_common.c:25
static bool multi
Definition: futex-lock-pi.c:34
static int futex_lock_pi(u_int32_t *uaddr, struct timespec *timeout, int opflags)
Definition: futex.h:63
static struct worker * worker
Definition: futex-lock-pi.c:32
Definition: stat.h:10
static unsigned int threads_starting
Definition: futex-lock-pi.c:40
static u_int32_t global_futex
Definition: futex-lock-pi.c:31
void free(void *)
u_int32_t * futex
Definition: futex-hash.c:46
static void toggle_done(int sig __maybe_unused, siginfo_t *info __maybe_unused, void *uc __maybe_unused)
Definition: futex-lock-pi.c:68
static unsigned int nthreads
Definition: futex-lock-pi.c:36
struct cpu_map * cpu_map__new(const char *cpu_list)
Definition: cpumap.c:125
unsigned long ops
Definition: futex-hash.c:48
static unsigned int nsecs
Definition: futex-lock-pi.c:33
struct timeval start end runtime
Definition: futex-lock-pi.c:38
static int futex_unlock_pi(u_int32_t *uaddr, int opflags)
Definition: futex.h:72