1 // SPDX-License-Identifier: GPL-2.0
2 /* Copyright (c) 2020 Facebook */
3 #define _GNU_SOURCE
4 #include <argp.h>
5 #include <linux/compiler.h>
6 #include <sys/time.h>
7 #include <sched.h>
8 #include <fcntl.h>
9 #include <pthread.h>
10 #include <sys/sysinfo.h>
11 #include <signal.h>
12 #include "bench.h"
13 #include "testing_helpers.h"
14 
15 struct env env = {
16 	.warmup_sec = 1,
17 	.duration_sec = 5,
18 	.affinity = false,
19 	.quiet = false,
20 	.consumer_cnt = 0,
21 	.producer_cnt = 1,
22 };
23 
24 static int libbpf_print_fn(enum libbpf_print_level level,
25 		    const char *format, va_list args)
26 {
27 	if (level == LIBBPF_DEBUG && !env.verbose)
28 		return 0;
29 	return vfprintf(stderr, format, args);
30 }
31 
32 void setup_libbpf(void)
33 {
34 	libbpf_set_strict_mode(LIBBPF_STRICT_ALL);
35 	libbpf_set_print(libbpf_print_fn);
36 }
37 
38 void false_hits_report_progress(int iter, struct bench_res *res, long delta_ns)
39 {
40 	long total = res->false_hits  + res->hits + res->drops;
41 
42 	printf("Iter %3d (%7.3lfus): ",
43 	       iter, (delta_ns - 1000000000) / 1000.0);
44 
45 	printf("%ld false hits of %ld total operations. Percentage = %2.2f %%\n",
46 	       res->false_hits, total, ((float)res->false_hits / total) * 100);
47 }
48 
49 void false_hits_report_final(struct bench_res res[], int res_cnt)
50 {
51 	long total_hits = 0, total_drops = 0, total_false_hits = 0, total_ops = 0;
52 	int i;
53 
54 	for (i = 0; i < res_cnt; i++) {
55 		total_hits += res[i].hits;
56 		total_false_hits += res[i].false_hits;
57 		total_drops += res[i].drops;
58 	}
59 	total_ops = total_hits + total_false_hits + total_drops;
60 
61 	printf("Summary: %ld false hits of %ld total operations. ",
62 	       total_false_hits, total_ops);
63 	printf("Percentage =  %2.2f %%\n",
64 	       ((float)total_false_hits / total_ops) * 100);
65 }
66 
67 void hits_drops_report_progress(int iter, struct bench_res *res, long delta_ns)
68 {
69 	double hits_per_sec, drops_per_sec;
70 	double hits_per_prod;
71 
72 	hits_per_sec = res->hits / 1000000.0 / (delta_ns / 1000000000.0);
73 	hits_per_prod = hits_per_sec / env.producer_cnt;
74 	drops_per_sec = res->drops / 1000000.0 / (delta_ns / 1000000000.0);
75 
76 	printf("Iter %3d (%7.3lfus): ",
77 	       iter, (delta_ns - 1000000000) / 1000.0);
78 
79 	printf("hits %8.3lfM/s (%7.3lfM/prod), drops %8.3lfM/s, total operations %8.3lfM/s\n",
80 	       hits_per_sec, hits_per_prod, drops_per_sec, hits_per_sec + drops_per_sec);
81 }
82 
83 void
84 grace_period_latency_basic_stats(struct bench_res res[], int res_cnt, struct basic_stats *gp_stat)
85 {
86 	int i;
87 
88 	memset(gp_stat, 0, sizeof(struct basic_stats));
89 
90 	for (i = 0; i < res_cnt; i++)
91 		gp_stat->mean += res[i].gp_ns / 1000.0 / (double)res[i].gp_ct / (0.0 + res_cnt);
92 
93 #define IT_MEAN_DIFF (res[i].gp_ns / 1000.0 / (double)res[i].gp_ct - gp_stat->mean)
94 	if (res_cnt > 1) {
95 		for (i = 0; i < res_cnt; i++)
96 			gp_stat->stddev += (IT_MEAN_DIFF * IT_MEAN_DIFF) / (res_cnt - 1.0);
97 	}
98 	gp_stat->stddev = sqrt(gp_stat->stddev);
99 #undef IT_MEAN_DIFF
100 }
101 
102 void
103 grace_period_ticks_basic_stats(struct bench_res res[], int res_cnt, struct basic_stats *gp_stat)
104 {
105 	int i;
106 
107 	memset(gp_stat, 0, sizeof(struct basic_stats));
108 	for (i = 0; i < res_cnt; i++)
109 		gp_stat->mean += res[i].stime / (double)res[i].gp_ct / (0.0 + res_cnt);
110 
111 #define IT_MEAN_DIFF (res[i].stime / (double)res[i].gp_ct - gp_stat->mean)
112 	if (res_cnt > 1) {
113 		for (i = 0; i < res_cnt; i++)
114 			gp_stat->stddev += (IT_MEAN_DIFF * IT_MEAN_DIFF) / (res_cnt - 1.0);
115 	}
116 	gp_stat->stddev = sqrt(gp_stat->stddev);
117 #undef IT_MEAN_DIFF
118 }
119 
120 void hits_drops_report_final(struct bench_res res[], int res_cnt)
121 {
122 	int i;
123 	double hits_mean = 0.0, drops_mean = 0.0, total_ops_mean = 0.0;
124 	double hits_stddev = 0.0, drops_stddev = 0.0, total_ops_stddev = 0.0;
125 	double total_ops;
126 
127 	for (i = 0; i < res_cnt; i++) {
128 		hits_mean += res[i].hits / 1000000.0 / (0.0 + res_cnt);
129 		drops_mean += res[i].drops / 1000000.0 / (0.0 + res_cnt);
130 	}
131 	total_ops_mean = hits_mean + drops_mean;
132 
133 	if (res_cnt > 1)  {
134 		for (i = 0; i < res_cnt; i++) {
135 			hits_stddev += (hits_mean - res[i].hits / 1000000.0) *
136 				       (hits_mean - res[i].hits / 1000000.0) /
137 				       (res_cnt - 1.0);
138 			drops_stddev += (drops_mean - res[i].drops / 1000000.0) *
139 					(drops_mean - res[i].drops / 1000000.0) /
140 					(res_cnt - 1.0);
141 			total_ops = res[i].hits + res[i].drops;
142 			total_ops_stddev += (total_ops_mean - total_ops / 1000000.0) *
143 					(total_ops_mean - total_ops / 1000000.0) /
144 					(res_cnt - 1.0);
145 		}
146 		hits_stddev = sqrt(hits_stddev);
147 		drops_stddev = sqrt(drops_stddev);
148 		total_ops_stddev = sqrt(total_ops_stddev);
149 	}
150 	printf("Summary: hits %8.3lf \u00B1 %5.3lfM/s (%7.3lfM/prod), ",
151 	       hits_mean, hits_stddev, hits_mean / env.producer_cnt);
152 	printf("drops %8.3lf \u00B1 %5.3lfM/s, ",
153 	       drops_mean, drops_stddev);
154 	printf("total operations %8.3lf \u00B1 %5.3lfM/s\n",
155 	       total_ops_mean, total_ops_stddev);
156 }
157 
158 void ops_report_progress(int iter, struct bench_res *res, long delta_ns)
159 {
160 	double hits_per_sec, hits_per_prod;
161 
162 	hits_per_sec = res->hits / 1000000.0 / (delta_ns / 1000000000.0);
163 	hits_per_prod = hits_per_sec / env.producer_cnt;
164 
165 	printf("Iter %3d (%7.3lfus): ", iter, (delta_ns - 1000000000) / 1000.0);
166 
167 	printf("hits %8.3lfM/s (%7.3lfM/prod)\n", hits_per_sec, hits_per_prod);
168 }
169 
170 void ops_report_final(struct bench_res res[], int res_cnt)
171 {
172 	double hits_mean = 0.0, hits_stddev = 0.0;
173 	int i;
174 
175 	for (i = 0; i < res_cnt; i++)
176 		hits_mean += res[i].hits / 1000000.0 / (0.0 + res_cnt);
177 
178 	if (res_cnt > 1)  {
179 		for (i = 0; i < res_cnt; i++)
180 			hits_stddev += (hits_mean - res[i].hits / 1000000.0) *
181 				       (hits_mean - res[i].hits / 1000000.0) /
182 				       (res_cnt - 1.0);
183 
184 		hits_stddev = sqrt(hits_stddev);
185 	}
186 	printf("Summary: throughput %8.3lf \u00B1 %5.3lf M ops/s (%7.3lfM ops/prod), ",
187 	       hits_mean, hits_stddev, hits_mean / env.producer_cnt);
188 	printf("latency %8.3lf ns/op\n", 1000.0 / hits_mean * env.producer_cnt);
189 }
190 
191 void local_storage_report_progress(int iter, struct bench_res *res,
192 				   long delta_ns)
193 {
194 	double important_hits_per_sec, hits_per_sec;
195 	double delta_sec = delta_ns / 1000000000.0;
196 
197 	hits_per_sec = res->hits / 1000000.0 / delta_sec;
198 	important_hits_per_sec = res->important_hits / 1000000.0 / delta_sec;
199 
200 	printf("Iter %3d (%7.3lfus): ", iter, (delta_ns - 1000000000) / 1000.0);
201 
202 	printf("hits %8.3lfM/s ", hits_per_sec);
203 	printf("important_hits %8.3lfM/s\n", important_hits_per_sec);
204 }
205 
206 void local_storage_report_final(struct bench_res res[], int res_cnt)
207 {
208 	double important_hits_mean = 0.0, important_hits_stddev = 0.0;
209 	double hits_mean = 0.0, hits_stddev = 0.0;
210 	int i;
211 
212 	for (i = 0; i < res_cnt; i++) {
213 		hits_mean += res[i].hits / 1000000.0 / (0.0 + res_cnt);
214 		important_hits_mean += res[i].important_hits / 1000000.0 / (0.0 + res_cnt);
215 	}
216 
217 	if (res_cnt > 1)  {
218 		for (i = 0; i < res_cnt; i++) {
219 			hits_stddev += (hits_mean - res[i].hits / 1000000.0) *
220 				       (hits_mean - res[i].hits / 1000000.0) /
221 				       (res_cnt - 1.0);
222 			important_hits_stddev +=
223 				       (important_hits_mean - res[i].important_hits / 1000000.0) *
224 				       (important_hits_mean - res[i].important_hits / 1000000.0) /
225 				       (res_cnt - 1.0);
226 		}
227 
228 		hits_stddev = sqrt(hits_stddev);
229 		important_hits_stddev = sqrt(important_hits_stddev);
230 	}
231 	printf("Summary: hits throughput %8.3lf \u00B1 %5.3lf M ops/s, ",
232 	       hits_mean, hits_stddev);
233 	printf("hits latency %8.3lf ns/op, ", 1000.0 / hits_mean);
234 	printf("important_hits throughput %8.3lf \u00B1 %5.3lf M ops/s\n",
235 	       important_hits_mean, important_hits_stddev);
236 }
237 
238 const char *argp_program_version = "benchmark";
239 const char *argp_program_bug_address = "<bpf@vger.kernel.org>";
240 const char argp_program_doc[] =
241 "benchmark    Generic benchmarking framework.\n"
242 "\n"
243 "This tool runs benchmarks.\n"
244 "\n"
245 "USAGE: benchmark <bench-name>\n"
246 "\n"
247 "EXAMPLES:\n"
248 "    # run 'count-local' benchmark with 1 producer and 1 consumer\n"
249 "    benchmark count-local\n"
250 "    # run 'count-local' with 16 producer and 8 consumer thread, pinned to CPUs\n"
251 "    benchmark -p16 -c8 -a count-local\n";
252 
253 enum {
254 	ARG_PROD_AFFINITY_SET = 1000,
255 	ARG_CONS_AFFINITY_SET = 1001,
256 };
257 
258 static const struct argp_option opts[] = {
259 	{ "list", 'l', NULL, 0, "List available benchmarks"},
260 	{ "duration", 'd', "SEC", 0, "Duration of benchmark, seconds"},
261 	{ "warmup", 'w', "SEC", 0, "Warm-up period, seconds"},
262 	{ "producers", 'p', "NUM", 0, "Number of producer threads"},
263 	{ "consumers", 'c', "NUM", 0, "Number of consumer threads"},
264 	{ "verbose", 'v', NULL, 0, "Verbose debug output"},
265 	{ "affinity", 'a', NULL, 0, "Set consumer/producer thread affinity"},
266 	{ "quiet", 'q', NULL, 0, "Be more quiet"},
267 	{ "prod-affinity", ARG_PROD_AFFINITY_SET, "CPUSET", 0,
268 	  "Set of CPUs for producer threads; implies --affinity"},
269 	{ "cons-affinity", ARG_CONS_AFFINITY_SET, "CPUSET", 0,
270 	  "Set of CPUs for consumer threads; implies --affinity"},
271 	{},
272 };
273 
274 extern struct argp bench_ringbufs_argp;
275 extern struct argp bench_bloom_map_argp;
276 extern struct argp bench_bpf_loop_argp;
277 extern struct argp bench_local_storage_argp;
278 extern struct argp bench_local_storage_rcu_tasks_trace_argp;
279 extern struct argp bench_strncmp_argp;
280 extern struct argp bench_hashmap_lookup_argp;
281 extern struct argp bench_local_storage_create_argp;
282 extern struct argp bench_htab_mem_argp;
283 
284 static const struct argp_child bench_parsers[] = {
285 	{ &bench_ringbufs_argp, 0, "Ring buffers benchmark", 0 },
286 	{ &bench_bloom_map_argp, 0, "Bloom filter map benchmark", 0 },
287 	{ &bench_bpf_loop_argp, 0, "bpf_loop helper benchmark", 0 },
288 	{ &bench_local_storage_argp, 0, "local_storage benchmark", 0 },
289 	{ &bench_strncmp_argp, 0, "bpf_strncmp helper benchmark", 0 },
290 	{ &bench_local_storage_rcu_tasks_trace_argp, 0,
291 		"local_storage RCU Tasks Trace slowdown benchmark", 0 },
292 	{ &bench_hashmap_lookup_argp, 0, "Hashmap lookup benchmark", 0 },
293 	{ &bench_local_storage_create_argp, 0, "local-storage-create benchmark", 0 },
294 	{ &bench_htab_mem_argp, 0, "hash map memory benchmark", 0 },
295 	{},
296 };
297 
298 /* Make pos_args global, so that we can run argp_parse twice, if necessary */
299 static int pos_args;
300 
301 static error_t parse_arg(int key, char *arg, struct argp_state *state)
302 {
303 	switch (key) {
304 	case 'v':
305 		env.verbose = true;
306 		break;
307 	case 'l':
308 		env.list = true;
309 		break;
310 	case 'd':
311 		env.duration_sec = strtol(arg, NULL, 10);
312 		if (env.duration_sec <= 0) {
313 			fprintf(stderr, "Invalid duration: %s\n", arg);
314 			argp_usage(state);
315 		}
316 		break;
317 	case 'w':
318 		env.warmup_sec = strtol(arg, NULL, 10);
319 		if (env.warmup_sec <= 0) {
320 			fprintf(stderr, "Invalid warm-up duration: %s\n", arg);
321 			argp_usage(state);
322 		}
323 		break;
324 	case 'p':
325 		env.producer_cnt = strtol(arg, NULL, 10);
326 		if (env.producer_cnt <= 0) {
327 			fprintf(stderr, "Invalid producer count: %s\n", arg);
328 			argp_usage(state);
329 		}
330 		break;
331 	case 'c':
332 		env.consumer_cnt = strtol(arg, NULL, 10);
333 		if (env.consumer_cnt <= 0) {
334 			fprintf(stderr, "Invalid consumer count: %s\n", arg);
335 			argp_usage(state);
336 		}
337 		break;
338 	case 'a':
339 		env.affinity = true;
340 		break;
341 	case 'q':
342 		env.quiet = true;
343 		break;
344 	case ARG_PROD_AFFINITY_SET:
345 		env.affinity = true;
346 		if (parse_num_list(arg, &env.prod_cpus.cpus,
347 				   &env.prod_cpus.cpus_len)) {
348 			fprintf(stderr, "Invalid format of CPU set for producers.");
349 			argp_usage(state);
350 		}
351 		break;
352 	case ARG_CONS_AFFINITY_SET:
353 		env.affinity = true;
354 		if (parse_num_list(arg, &env.cons_cpus.cpus,
355 				   &env.cons_cpus.cpus_len)) {
356 			fprintf(stderr, "Invalid format of CPU set for consumers.");
357 			argp_usage(state);
358 		}
359 		break;
360 	case ARGP_KEY_ARG:
361 		if (pos_args++) {
362 			fprintf(stderr,
363 				"Unrecognized positional argument: %s\n", arg);
364 			argp_usage(state);
365 		}
366 		env.bench_name = strdup(arg);
367 		break;
368 	default:
369 		return ARGP_ERR_UNKNOWN;
370 	}
371 	return 0;
372 }
373 
374 static void parse_cmdline_args_init(int argc, char **argv)
375 {
376 	static const struct argp argp = {
377 		.options = opts,
378 		.parser = parse_arg,
379 		.doc = argp_program_doc,
380 		.children = bench_parsers,
381 	};
382 	if (argp_parse(&argp, argc, argv, 0, NULL, NULL))
383 		exit(1);
384 }
385 
386 static void parse_cmdline_args_final(int argc, char **argv)
387 {
388 	struct argp_child bench_parsers[2] = {};
389 	const struct argp argp = {
390 		.options = opts,
391 		.parser = parse_arg,
392 		.doc = argp_program_doc,
393 		.children = bench_parsers,
394 	};
395 
396 	/* Parse arguments the second time with the correct set of parsers */
397 	if (bench->argp) {
398 		bench_parsers[0].argp = bench->argp;
399 		bench_parsers[0].header = bench->name;
400 		pos_args = 0;
401 		if (argp_parse(&argp, argc, argv, 0, NULL, NULL))
402 			exit(1);
403 	}
404 }
405 
406 static void collect_measurements(long delta_ns);
407 
408 static __u64 last_time_ns;
409 static void sigalarm_handler(int signo)
410 {
411 	long new_time_ns = get_time_ns();
412 	long delta_ns = new_time_ns - last_time_ns;
413 
414 	collect_measurements(delta_ns);
415 
416 	last_time_ns = new_time_ns;
417 }
418 
419 /* set up periodic 1-second timer */
420 static void setup_timer()
421 {
422 	static struct sigaction sigalarm_action = {
423 		.sa_handler = sigalarm_handler,
424 	};
425 	struct itimerval timer_settings = {};
426 	int err;
427 
428 	last_time_ns = get_time_ns();
429 	err = sigaction(SIGALRM, &sigalarm_action, NULL);
430 	if (err < 0) {
431 		fprintf(stderr, "failed to install SIGALRM handler: %d\n", -errno);
432 		exit(1);
433 	}
434 	timer_settings.it_interval.tv_sec = 1;
435 	timer_settings.it_value.tv_sec = 1;
436 	err = setitimer(ITIMER_REAL, &timer_settings, NULL);
437 	if (err < 0) {
438 		fprintf(stderr, "failed to arm interval timer: %d\n", -errno);
439 		exit(1);
440 	}
441 }
442 
443 static void set_thread_affinity(pthread_t thread, int cpu)
444 {
445 	cpu_set_t cpuset;
446 	int err;
447 
448 	CPU_ZERO(&cpuset);
449 	CPU_SET(cpu, &cpuset);
450 	err = pthread_setaffinity_np(thread, sizeof(cpuset), &cpuset);
451 	if (err) {
452 		fprintf(stderr, "setting affinity to CPU #%d failed: %d\n",
453 			cpu, -err);
454 		exit(1);
455 	}
456 }
457 
458 static int next_cpu(struct cpu_set *cpu_set)
459 {
460 	if (cpu_set->cpus) {
461 		int i;
462 
463 		/* find next available CPU */
464 		for (i = cpu_set->next_cpu; i < cpu_set->cpus_len; i++) {
465 			if (cpu_set->cpus[i]) {
466 				cpu_set->next_cpu = i + 1;
467 				return i;
468 			}
469 		}
470 		fprintf(stderr, "Not enough CPUs specified, need CPU #%d or higher.\n", i);
471 		exit(1);
472 	}
473 
474 	return cpu_set->next_cpu++ % env.nr_cpus;
475 }
476 
477 static struct bench_state {
478 	int res_cnt;
479 	struct bench_res *results;
480 	pthread_t *consumers;
481 	pthread_t *producers;
482 } state;
483 
484 const struct bench *bench = NULL;
485 
486 extern const struct bench bench_count_global;
487 extern const struct bench bench_count_local;
488 extern const struct bench bench_rename_base;
489 extern const struct bench bench_rename_kprobe;
490 extern const struct bench bench_rename_kretprobe;
491 extern const struct bench bench_rename_rawtp;
492 extern const struct bench bench_rename_fentry;
493 extern const struct bench bench_rename_fexit;
494 extern const struct bench bench_trig_base;
495 extern const struct bench bench_trig_tp;
496 extern const struct bench bench_trig_rawtp;
497 extern const struct bench bench_trig_kprobe;
498 extern const struct bench bench_trig_fentry;
499 extern const struct bench bench_trig_fentry_sleep;
500 extern const struct bench bench_trig_fmodret;
501 extern const struct bench bench_trig_uprobe_base;
502 extern const struct bench bench_trig_uprobe_with_nop;
503 extern const struct bench bench_trig_uretprobe_with_nop;
504 extern const struct bench bench_trig_uprobe_without_nop;
505 extern const struct bench bench_trig_uretprobe_without_nop;
506 extern const struct bench bench_rb_libbpf;
507 extern const struct bench bench_rb_custom;
508 extern const struct bench bench_pb_libbpf;
509 extern const struct bench bench_pb_custom;
510 extern const struct bench bench_bloom_lookup;
511 extern const struct bench bench_bloom_update;
512 extern const struct bench bench_bloom_false_positive;
513 extern const struct bench bench_hashmap_without_bloom;
514 extern const struct bench bench_hashmap_with_bloom;
515 extern const struct bench bench_bpf_loop;
516 extern const struct bench bench_strncmp_no_helper;
517 extern const struct bench bench_strncmp_helper;
518 extern const struct bench bench_bpf_hashmap_full_update;
519 extern const struct bench bench_local_storage_cache_seq_get;
520 extern const struct bench bench_local_storage_cache_interleaved_get;
521 extern const struct bench bench_local_storage_cache_hashmap_control;
522 extern const struct bench bench_local_storage_tasks_trace;
523 extern const struct bench bench_bpf_hashmap_lookup;
524 extern const struct bench bench_local_storage_create;
525 extern const struct bench bench_htab_mem;
526 
527 static const struct bench *benchs[] = {
528 	&bench_count_global,
529 	&bench_count_local,
530 	&bench_rename_base,
531 	&bench_rename_kprobe,
532 	&bench_rename_kretprobe,
533 	&bench_rename_rawtp,
534 	&bench_rename_fentry,
535 	&bench_rename_fexit,
536 	&bench_trig_base,
537 	&bench_trig_tp,
538 	&bench_trig_rawtp,
539 	&bench_trig_kprobe,
540 	&bench_trig_fentry,
541 	&bench_trig_fentry_sleep,
542 	&bench_trig_fmodret,
543 	&bench_trig_uprobe_base,
544 	&bench_trig_uprobe_with_nop,
545 	&bench_trig_uretprobe_with_nop,
546 	&bench_trig_uprobe_without_nop,
547 	&bench_trig_uretprobe_without_nop,
548 	&bench_rb_libbpf,
549 	&bench_rb_custom,
550 	&bench_pb_libbpf,
551 	&bench_pb_custom,
552 	&bench_bloom_lookup,
553 	&bench_bloom_update,
554 	&bench_bloom_false_positive,
555 	&bench_hashmap_without_bloom,
556 	&bench_hashmap_with_bloom,
557 	&bench_bpf_loop,
558 	&bench_strncmp_no_helper,
559 	&bench_strncmp_helper,
560 	&bench_bpf_hashmap_full_update,
561 	&bench_local_storage_cache_seq_get,
562 	&bench_local_storage_cache_interleaved_get,
563 	&bench_local_storage_cache_hashmap_control,
564 	&bench_local_storage_tasks_trace,
565 	&bench_bpf_hashmap_lookup,
566 	&bench_local_storage_create,
567 	&bench_htab_mem,
568 };
569 
570 static void find_benchmark(void)
571 {
572 	int i;
573 
574 	if (!env.bench_name) {
575 		fprintf(stderr, "benchmark name is not specified\n");
576 		exit(1);
577 	}
578 	for (i = 0; i < ARRAY_SIZE(benchs); i++) {
579 		if (strcmp(benchs[i]->name, env.bench_name) == 0) {
580 			bench = benchs[i];
581 			break;
582 		}
583 	}
584 	if (!bench) {
585 		fprintf(stderr, "benchmark '%s' not found\n", env.bench_name);
586 		exit(1);
587 	}
588 }
589 
590 static void setup_benchmark(void)
591 {
592 	int i, err;
593 
594 	if (!env.quiet)
595 		printf("Setting up benchmark '%s'...\n", bench->name);
596 
597 	state.producers = calloc(env.producer_cnt, sizeof(*state.producers));
598 	state.consumers = calloc(env.consumer_cnt, sizeof(*state.consumers));
599 	state.results = calloc(env.duration_sec + env.warmup_sec + 2,
600 			       sizeof(*state.results));
601 	if (!state.producers || !state.consumers || !state.results)
602 		exit(1);
603 
604 	if (bench->validate)
605 		bench->validate();
606 	if (bench->setup)
607 		bench->setup();
608 
609 	for (i = 0; i < env.consumer_cnt; i++) {
610 		err = pthread_create(&state.consumers[i], NULL,
611 				     bench->consumer_thread, (void *)(long)i);
612 		if (err) {
613 			fprintf(stderr, "failed to create consumer thread #%d: %d\n",
614 				i, -err);
615 			exit(1);
616 		}
617 		if (env.affinity)
618 			set_thread_affinity(state.consumers[i],
619 					    next_cpu(&env.cons_cpus));
620 	}
621 
622 	/* unless explicit producer CPU list is specified, continue after
623 	 * last consumer CPU
624 	 */
625 	if (!env.prod_cpus.cpus)
626 		env.prod_cpus.next_cpu = env.cons_cpus.next_cpu;
627 
628 	for (i = 0; i < env.producer_cnt; i++) {
629 		err = pthread_create(&state.producers[i], NULL,
630 				     bench->producer_thread, (void *)(long)i);
631 		if (err) {
632 			fprintf(stderr, "failed to create producer thread #%d: %d\n",
633 				i, -err);
634 			exit(1);
635 		}
636 		if (env.affinity)
637 			set_thread_affinity(state.producers[i],
638 					    next_cpu(&env.prod_cpus));
639 	}
640 
641 	if (!env.quiet)
642 		printf("Benchmark '%s' started.\n", bench->name);
643 }
644 
645 static pthread_mutex_t bench_done_mtx = PTHREAD_MUTEX_INITIALIZER;
646 static pthread_cond_t bench_done = PTHREAD_COND_INITIALIZER;
647 
648 static void collect_measurements(long delta_ns) {
649 	int iter = state.res_cnt++;
650 	struct bench_res *res = &state.results[iter];
651 
652 	bench->measure(res);
653 
654 	if (bench->report_progress)
655 		bench->report_progress(iter, res, delta_ns);
656 
657 	if (iter == env.duration_sec + env.warmup_sec) {
658 		pthread_mutex_lock(&bench_done_mtx);
659 		pthread_cond_signal(&bench_done);
660 		pthread_mutex_unlock(&bench_done_mtx);
661 	}
662 }
663 
664 int main(int argc, char **argv)
665 {
666 	env.nr_cpus = get_nprocs();
667 	parse_cmdline_args_init(argc, argv);
668 
669 	if (env.list) {
670 		int i;
671 
672 		printf("Available benchmarks:\n");
673 		for (i = 0; i < ARRAY_SIZE(benchs); i++) {
674 			printf("- %s\n", benchs[i]->name);
675 		}
676 		return 0;
677 	}
678 
679 	find_benchmark();
680 	parse_cmdline_args_final(argc, argv);
681 
682 	setup_benchmark();
683 
684 	setup_timer();
685 
686 	pthread_mutex_lock(&bench_done_mtx);
687 	pthread_cond_wait(&bench_done, &bench_done_mtx);
688 	pthread_mutex_unlock(&bench_done_mtx);
689 
690 	if (bench->report_final)
691 		/* skip first sample */
692 		bench->report_final(state.results + env.warmup_sec,
693 				    state.res_cnt - env.warmup_sec);
694 
695 	return 0;
696 }
697