xref: /openbmc/linux/tools/perf/bench/numa.c (revision e2f1cf25)
1 /*
2  * numa.c
3  *
4  * numa: Simulate NUMA-sensitive workload and measure their NUMA performance
5  */
6 
7 #include "../perf.h"
8 #include "../builtin.h"
9 #include "../util/util.h"
10 #include "../util/parse-options.h"
11 #include "../util/cloexec.h"
12 
13 #include "bench.h"
14 
15 #include <errno.h>
16 #include <sched.h>
17 #include <stdio.h>
18 #include <assert.h>
19 #include <malloc.h>
20 #include <signal.h>
21 #include <stdlib.h>
22 #include <string.h>
23 #include <unistd.h>
24 #include <pthread.h>
25 #include <sys/mman.h>
26 #include <sys/time.h>
27 #include <sys/resource.h>
28 #include <sys/wait.h>
29 #include <sys/prctl.h>
30 #include <sys/types.h>
31 
32 #include <numa.h>
33 #include <numaif.h>
34 
35 /*
36  * Regular printout to the terminal, supressed if -q is specified:
37  */
38 #define tprintf(x...) do { if (g && g->p.show_details >= 0) printf(x); } while (0)
39 
40 /*
41  * Debug printf:
42  */
43 #define dprintf(x...) do { if (g && g->p.show_details >= 1) printf(x); } while (0)
44 
45 struct thread_data {
46 	int			curr_cpu;
47 	cpu_set_t		bind_cpumask;
48 	int			bind_node;
49 	u8			*process_data;
50 	int			process_nr;
51 	int			thread_nr;
52 	int			task_nr;
53 	unsigned int		loops_done;
54 	u64			val;
55 	u64			runtime_ns;
56 	u64			system_time_ns;
57 	u64			user_time_ns;
58 	double			speed_gbs;
59 	pthread_mutex_t		*process_lock;
60 };
61 
62 /* Parameters set by options: */
63 
64 struct params {
65 	/* Startup synchronization: */
66 	bool			serialize_startup;
67 
68 	/* Task hierarchy: */
69 	int			nr_proc;
70 	int			nr_threads;
71 
72 	/* Working set sizes: */
73 	const char		*mb_global_str;
74 	const char		*mb_proc_str;
75 	const char		*mb_proc_locked_str;
76 	const char		*mb_thread_str;
77 
78 	double			mb_global;
79 	double			mb_proc;
80 	double			mb_proc_locked;
81 	double			mb_thread;
82 
83 	/* Access patterns to the working set: */
84 	bool			data_reads;
85 	bool			data_writes;
86 	bool			data_backwards;
87 	bool			data_zero_memset;
88 	bool			data_rand_walk;
89 	u32			nr_loops;
90 	u32			nr_secs;
91 	u32			sleep_usecs;
92 
93 	/* Working set initialization: */
94 	bool			init_zero;
95 	bool			init_random;
96 	bool			init_cpu0;
97 
98 	/* Misc options: */
99 	int			show_details;
100 	int			run_all;
101 	int			thp;
102 
103 	long			bytes_global;
104 	long			bytes_process;
105 	long			bytes_process_locked;
106 	long			bytes_thread;
107 
108 	int			nr_tasks;
109 	bool			show_quiet;
110 
111 	bool			show_convergence;
112 	bool			measure_convergence;
113 
114 	int			perturb_secs;
115 	int			nr_cpus;
116 	int			nr_nodes;
117 
118 	/* Affinity options -C and -N: */
119 	char			*cpu_list_str;
120 	char			*node_list_str;
121 };
122 
123 
124 /* Global, read-writable area, accessible to all processes and threads: */
125 
126 struct global_info {
127 	u8			*data;
128 
129 	pthread_mutex_t		startup_mutex;
130 	int			nr_tasks_started;
131 
132 	pthread_mutex_t		startup_done_mutex;
133 
134 	pthread_mutex_t		start_work_mutex;
135 	int			nr_tasks_working;
136 
137 	pthread_mutex_t		stop_work_mutex;
138 	u64			bytes_done;
139 
140 	struct thread_data	*threads;
141 
142 	/* Convergence latency measurement: */
143 	bool			all_converged;
144 	bool			stop_work;
145 
146 	int			print_once;
147 
148 	struct params		p;
149 };
150 
151 static struct global_info	*g = NULL;
152 
153 static int parse_cpus_opt(const struct option *opt, const char *arg, int unset);
154 static int parse_nodes_opt(const struct option *opt, const char *arg, int unset);
155 
156 struct params p0;
157 
158 static const struct option options[] = {
159 	OPT_INTEGER('p', "nr_proc"	, &p0.nr_proc,		"number of processes"),
160 	OPT_INTEGER('t', "nr_threads"	, &p0.nr_threads,	"number of threads per process"),
161 
162 	OPT_STRING('G', "mb_global"	, &p0.mb_global_str,	"MB", "global  memory (MBs)"),
163 	OPT_STRING('P', "mb_proc"	, &p0.mb_proc_str,	"MB", "process memory (MBs)"),
164 	OPT_STRING('L', "mb_proc_locked", &p0.mb_proc_locked_str,"MB", "process serialized/locked memory access (MBs), <= process_memory"),
165 	OPT_STRING('T', "mb_thread"	, &p0.mb_thread_str,	"MB", "thread  memory (MBs)"),
166 
167 	OPT_UINTEGER('l', "nr_loops"	, &p0.nr_loops,		"max number of loops to run"),
168 	OPT_UINTEGER('s', "nr_secs"	, &p0.nr_secs,		"max number of seconds to run"),
169 	OPT_UINTEGER('u', "usleep"	, &p0.sleep_usecs,	"usecs to sleep per loop iteration"),
170 
171 	OPT_BOOLEAN('R', "data_reads"	, &p0.data_reads,	"access the data via writes (can be mixed with -W)"),
172 	OPT_BOOLEAN('W', "data_writes"	, &p0.data_writes,	"access the data via writes (can be mixed with -R)"),
173 	OPT_BOOLEAN('B', "data_backwards", &p0.data_backwards,	"access the data backwards as well"),
174 	OPT_BOOLEAN('Z', "data_zero_memset", &p0.data_zero_memset,"access the data via glibc bzero only"),
175 	OPT_BOOLEAN('r', "data_rand_walk", &p0.data_rand_walk,	"access the data with random (32bit LFSR) walk"),
176 
177 
178 	OPT_BOOLEAN('z', "init_zero"	, &p0.init_zero,	"bzero the initial allocations"),
179 	OPT_BOOLEAN('I', "init_random"	, &p0.init_random,	"randomize the contents of the initial allocations"),
180 	OPT_BOOLEAN('0', "init_cpu0"	, &p0.init_cpu0,	"do the initial allocations on CPU#0"),
181 	OPT_INTEGER('x', "perturb_secs", &p0.perturb_secs,	"perturb thread 0/0 every X secs, to test convergence stability"),
182 
183 	OPT_INCR   ('d', "show_details"	, &p0.show_details,	"Show details"),
184 	OPT_INCR   ('a', "all"		, &p0.run_all,		"Run all tests in the suite"),
185 	OPT_INTEGER('H', "thp"		, &p0.thp,		"MADV_NOHUGEPAGE < 0 < MADV_HUGEPAGE"),
186 	OPT_BOOLEAN('c', "show_convergence", &p0.show_convergence, "show convergence details"),
187 	OPT_BOOLEAN('m', "measure_convergence",	&p0.measure_convergence, "measure convergence latency"),
188 	OPT_BOOLEAN('q', "quiet"	, &p0.show_quiet,	"quiet mode"),
189 	OPT_BOOLEAN('S', "serialize-startup", &p0.serialize_startup,"serialize thread startup"),
190 
191 	/* Special option string parsing callbacks: */
192         OPT_CALLBACK('C', "cpus", NULL, "cpu[,cpu2,...cpuN]",
193 			"bind the first N tasks to these specific cpus (the rest is unbound)",
194 			parse_cpus_opt),
195         OPT_CALLBACK('M', "memnodes", NULL, "node[,node2,...nodeN]",
196 			"bind the first N tasks to these specific memory nodes (the rest is unbound)",
197 			parse_nodes_opt),
198 	OPT_END()
199 };
200 
201 static const char * const bench_numa_usage[] = {
202 	"perf bench numa <options>",
203 	NULL
204 };
205 
206 static const char * const numa_usage[] = {
207 	"perf bench numa mem [<options>]",
208 	NULL
209 };
210 
211 static cpu_set_t bind_to_cpu(int target_cpu)
212 {
213 	cpu_set_t orig_mask, mask;
214 	int ret;
215 
216 	ret = sched_getaffinity(0, sizeof(orig_mask), &orig_mask);
217 	BUG_ON(ret);
218 
219 	CPU_ZERO(&mask);
220 
221 	if (target_cpu == -1) {
222 		int cpu;
223 
224 		for (cpu = 0; cpu < g->p.nr_cpus; cpu++)
225 			CPU_SET(cpu, &mask);
226 	} else {
227 		BUG_ON(target_cpu < 0 || target_cpu >= g->p.nr_cpus);
228 		CPU_SET(target_cpu, &mask);
229 	}
230 
231 	ret = sched_setaffinity(0, sizeof(mask), &mask);
232 	BUG_ON(ret);
233 
234 	return orig_mask;
235 }
236 
237 static cpu_set_t bind_to_node(int target_node)
238 {
239 	int cpus_per_node = g->p.nr_cpus/g->p.nr_nodes;
240 	cpu_set_t orig_mask, mask;
241 	int cpu;
242 	int ret;
243 
244 	BUG_ON(cpus_per_node*g->p.nr_nodes != g->p.nr_cpus);
245 	BUG_ON(!cpus_per_node);
246 
247 	ret = sched_getaffinity(0, sizeof(orig_mask), &orig_mask);
248 	BUG_ON(ret);
249 
250 	CPU_ZERO(&mask);
251 
252 	if (target_node == -1) {
253 		for (cpu = 0; cpu < g->p.nr_cpus; cpu++)
254 			CPU_SET(cpu, &mask);
255 	} else {
256 		int cpu_start = (target_node + 0) * cpus_per_node;
257 		int cpu_stop  = (target_node + 1) * cpus_per_node;
258 
259 		BUG_ON(cpu_stop > g->p.nr_cpus);
260 
261 		for (cpu = cpu_start; cpu < cpu_stop; cpu++)
262 			CPU_SET(cpu, &mask);
263 	}
264 
265 	ret = sched_setaffinity(0, sizeof(mask), &mask);
266 	BUG_ON(ret);
267 
268 	return orig_mask;
269 }
270 
271 static void bind_to_cpumask(cpu_set_t mask)
272 {
273 	int ret;
274 
275 	ret = sched_setaffinity(0, sizeof(mask), &mask);
276 	BUG_ON(ret);
277 }
278 
279 static void mempol_restore(void)
280 {
281 	int ret;
282 
283 	ret = set_mempolicy(MPOL_DEFAULT, NULL, g->p.nr_nodes-1);
284 
285 	BUG_ON(ret);
286 }
287 
288 static void bind_to_memnode(int node)
289 {
290 	unsigned long nodemask;
291 	int ret;
292 
293 	if (node == -1)
294 		return;
295 
296 	BUG_ON(g->p.nr_nodes > (int)sizeof(nodemask));
297 	nodemask = 1L << node;
298 
299 	ret = set_mempolicy(MPOL_BIND, &nodemask, sizeof(nodemask)*8);
300 	dprintf("binding to node %d, mask: %016lx => %d\n", node, nodemask, ret);
301 
302 	BUG_ON(ret);
303 }
304 
305 #define HPSIZE (2*1024*1024)
306 
307 #define set_taskname(fmt...)				\
308 do {							\
309 	char name[20];					\
310 							\
311 	snprintf(name, 20, fmt);			\
312 	prctl(PR_SET_NAME, name);			\
313 } while (0)
314 
315 static u8 *alloc_data(ssize_t bytes0, int map_flags,
316 		      int init_zero, int init_cpu0, int thp, int init_random)
317 {
318 	cpu_set_t orig_mask;
319 	ssize_t bytes;
320 	u8 *buf;
321 	int ret;
322 
323 	if (!bytes0)
324 		return NULL;
325 
326 	/* Allocate and initialize all memory on CPU#0: */
327 	if (init_cpu0) {
328 		orig_mask = bind_to_node(0);
329 		bind_to_memnode(0);
330 	}
331 
332 	bytes = bytes0 + HPSIZE;
333 
334 	buf = (void *)mmap(0, bytes, PROT_READ|PROT_WRITE, MAP_ANON|map_flags, -1, 0);
335 	BUG_ON(buf == (void *)-1);
336 
337 	if (map_flags == MAP_PRIVATE) {
338 		if (thp > 0) {
339 			ret = madvise(buf, bytes, MADV_HUGEPAGE);
340 			if (ret && !g->print_once) {
341 				g->print_once = 1;
342 				printf("WARNING: Could not enable THP - do: 'echo madvise > /sys/kernel/mm/transparent_hugepage/enabled'\n");
343 			}
344 		}
345 		if (thp < 0) {
346 			ret = madvise(buf, bytes, MADV_NOHUGEPAGE);
347 			if (ret && !g->print_once) {
348 				g->print_once = 1;
349 				printf("WARNING: Could not disable THP: run a CONFIG_TRANSPARENT_HUGEPAGE kernel?\n");
350 			}
351 		}
352 	}
353 
354 	if (init_zero) {
355 		bzero(buf, bytes);
356 	} else {
357 		/* Initialize random contents, different in each word: */
358 		if (init_random) {
359 			u64 *wbuf = (void *)buf;
360 			long off = rand();
361 			long i;
362 
363 			for (i = 0; i < bytes/8; i++)
364 				wbuf[i] = i + off;
365 		}
366 	}
367 
368 	/* Align to 2MB boundary: */
369 	buf = (void *)(((unsigned long)buf + HPSIZE-1) & ~(HPSIZE-1));
370 
371 	/* Restore affinity: */
372 	if (init_cpu0) {
373 		bind_to_cpumask(orig_mask);
374 		mempol_restore();
375 	}
376 
377 	return buf;
378 }
379 
380 static void free_data(void *data, ssize_t bytes)
381 {
382 	int ret;
383 
384 	if (!data)
385 		return;
386 
387 	ret = munmap(data, bytes);
388 	BUG_ON(ret);
389 }
390 
391 /*
392  * Create a shared memory buffer that can be shared between processes, zeroed:
393  */
394 static void * zalloc_shared_data(ssize_t bytes)
395 {
396 	return alloc_data(bytes, MAP_SHARED, 1, g->p.init_cpu0,  g->p.thp, g->p.init_random);
397 }
398 
399 /*
400  * Create a shared memory buffer that can be shared between processes:
401  */
402 static void * setup_shared_data(ssize_t bytes)
403 {
404 	return alloc_data(bytes, MAP_SHARED, 0, g->p.init_cpu0,  g->p.thp, g->p.init_random);
405 }
406 
407 /*
408  * Allocate process-local memory - this will either be shared between
409  * threads of this process, or only be accessed by this thread:
410  */
411 static void * setup_private_data(ssize_t bytes)
412 {
413 	return alloc_data(bytes, MAP_PRIVATE, 0, g->p.init_cpu0,  g->p.thp, g->p.init_random);
414 }
415 
416 /*
417  * Return a process-shared (global) mutex:
418  */
419 static void init_global_mutex(pthread_mutex_t *mutex)
420 {
421 	pthread_mutexattr_t attr;
422 
423 	pthread_mutexattr_init(&attr);
424 	pthread_mutexattr_setpshared(&attr, PTHREAD_PROCESS_SHARED);
425 	pthread_mutex_init(mutex, &attr);
426 }
427 
428 static int parse_cpu_list(const char *arg)
429 {
430 	p0.cpu_list_str = strdup(arg);
431 
432 	dprintf("got CPU list: {%s}\n", p0.cpu_list_str);
433 
434 	return 0;
435 }
436 
437 static int parse_setup_cpu_list(void)
438 {
439 	struct thread_data *td;
440 	char *str0, *str;
441 	int t;
442 
443 	if (!g->p.cpu_list_str)
444 		return 0;
445 
446 	dprintf("g->p.nr_tasks: %d\n", g->p.nr_tasks);
447 
448 	str0 = str = strdup(g->p.cpu_list_str);
449 	t = 0;
450 
451 	BUG_ON(!str);
452 
453 	tprintf("# binding tasks to CPUs:\n");
454 	tprintf("#  ");
455 
456 	while (true) {
457 		int bind_cpu, bind_cpu_0, bind_cpu_1;
458 		char *tok, *tok_end, *tok_step, *tok_len, *tok_mul;
459 		int bind_len;
460 		int step;
461 		int mul;
462 
463 		tok = strsep(&str, ",");
464 		if (!tok)
465 			break;
466 
467 		tok_end = strstr(tok, "-");
468 
469 		dprintf("\ntoken: {%s}, end: {%s}\n", tok, tok_end);
470 		if (!tok_end) {
471 			/* Single CPU specified: */
472 			bind_cpu_0 = bind_cpu_1 = atol(tok);
473 		} else {
474 			/* CPU range specified (for example: "5-11"): */
475 			bind_cpu_0 = atol(tok);
476 			bind_cpu_1 = atol(tok_end + 1);
477 		}
478 
479 		step = 1;
480 		tok_step = strstr(tok, "#");
481 		if (tok_step) {
482 			step = atol(tok_step + 1);
483 			BUG_ON(step <= 0 || step >= g->p.nr_cpus);
484 		}
485 
486 		/*
487 		 * Mask length.
488 		 * Eg: "--cpus 8_4-16#4" means: '--cpus 8_4,12_4,16_4',
489 		 * where the _4 means the next 4 CPUs are allowed.
490 		 */
491 		bind_len = 1;
492 		tok_len = strstr(tok, "_");
493 		if (tok_len) {
494 			bind_len = atol(tok_len + 1);
495 			BUG_ON(bind_len <= 0 || bind_len > g->p.nr_cpus);
496 		}
497 
498 		/* Multiplicator shortcut, "0x8" is a shortcut for: "0,0,0,0,0,0,0,0" */
499 		mul = 1;
500 		tok_mul = strstr(tok, "x");
501 		if (tok_mul) {
502 			mul = atol(tok_mul + 1);
503 			BUG_ON(mul <= 0);
504 		}
505 
506 		dprintf("CPUs: %d_%d-%d#%dx%d\n", bind_cpu_0, bind_len, bind_cpu_1, step, mul);
507 
508 		if (bind_cpu_0 >= g->p.nr_cpus || bind_cpu_1 >= g->p.nr_cpus) {
509 			printf("\nTest not applicable, system has only %d CPUs.\n", g->p.nr_cpus);
510 			return -1;
511 		}
512 
513 		BUG_ON(bind_cpu_0 < 0 || bind_cpu_1 < 0);
514 		BUG_ON(bind_cpu_0 > bind_cpu_1);
515 
516 		for (bind_cpu = bind_cpu_0; bind_cpu <= bind_cpu_1; bind_cpu += step) {
517 			int i;
518 
519 			for (i = 0; i < mul; i++) {
520 				int cpu;
521 
522 				if (t >= g->p.nr_tasks) {
523 					printf("\n# NOTE: ignoring bind CPUs starting at CPU#%d\n #", bind_cpu);
524 					goto out;
525 				}
526 				td = g->threads + t;
527 
528 				if (t)
529 					tprintf(",");
530 				if (bind_len > 1) {
531 					tprintf("%2d/%d", bind_cpu, bind_len);
532 				} else {
533 					tprintf("%2d", bind_cpu);
534 				}
535 
536 				CPU_ZERO(&td->bind_cpumask);
537 				for (cpu = bind_cpu; cpu < bind_cpu+bind_len; cpu++) {
538 					BUG_ON(cpu < 0 || cpu >= g->p.nr_cpus);
539 					CPU_SET(cpu, &td->bind_cpumask);
540 				}
541 				t++;
542 			}
543 		}
544 	}
545 out:
546 
547 	tprintf("\n");
548 
549 	if (t < g->p.nr_tasks)
550 		printf("# NOTE: %d tasks bound, %d tasks unbound\n", t, g->p.nr_tasks - t);
551 
552 	free(str0);
553 	return 0;
554 }
555 
556 static int parse_cpus_opt(const struct option *opt __maybe_unused,
557 			  const char *arg, int unset __maybe_unused)
558 {
559 	if (!arg)
560 		return -1;
561 
562 	return parse_cpu_list(arg);
563 }
564 
565 static int parse_node_list(const char *arg)
566 {
567 	p0.node_list_str = strdup(arg);
568 
569 	dprintf("got NODE list: {%s}\n", p0.node_list_str);
570 
571 	return 0;
572 }
573 
574 static int parse_setup_node_list(void)
575 {
576 	struct thread_data *td;
577 	char *str0, *str;
578 	int t;
579 
580 	if (!g->p.node_list_str)
581 		return 0;
582 
583 	dprintf("g->p.nr_tasks: %d\n", g->p.nr_tasks);
584 
585 	str0 = str = strdup(g->p.node_list_str);
586 	t = 0;
587 
588 	BUG_ON(!str);
589 
590 	tprintf("# binding tasks to NODEs:\n");
591 	tprintf("# ");
592 
593 	while (true) {
594 		int bind_node, bind_node_0, bind_node_1;
595 		char *tok, *tok_end, *tok_step, *tok_mul;
596 		int step;
597 		int mul;
598 
599 		tok = strsep(&str, ",");
600 		if (!tok)
601 			break;
602 
603 		tok_end = strstr(tok, "-");
604 
605 		dprintf("\ntoken: {%s}, end: {%s}\n", tok, tok_end);
606 		if (!tok_end) {
607 			/* Single NODE specified: */
608 			bind_node_0 = bind_node_1 = atol(tok);
609 		} else {
610 			/* NODE range specified (for example: "5-11"): */
611 			bind_node_0 = atol(tok);
612 			bind_node_1 = atol(tok_end + 1);
613 		}
614 
615 		step = 1;
616 		tok_step = strstr(tok, "#");
617 		if (tok_step) {
618 			step = atol(tok_step + 1);
619 			BUG_ON(step <= 0 || step >= g->p.nr_nodes);
620 		}
621 
622 		/* Multiplicator shortcut, "0x8" is a shortcut for: "0,0,0,0,0,0,0,0" */
623 		mul = 1;
624 		tok_mul = strstr(tok, "x");
625 		if (tok_mul) {
626 			mul = atol(tok_mul + 1);
627 			BUG_ON(mul <= 0);
628 		}
629 
630 		dprintf("NODEs: %d-%d #%d\n", bind_node_0, bind_node_1, step);
631 
632 		if (bind_node_0 >= g->p.nr_nodes || bind_node_1 >= g->p.nr_nodes) {
633 			printf("\nTest not applicable, system has only %d nodes.\n", g->p.nr_nodes);
634 			return -1;
635 		}
636 
637 		BUG_ON(bind_node_0 < 0 || bind_node_1 < 0);
638 		BUG_ON(bind_node_0 > bind_node_1);
639 
640 		for (bind_node = bind_node_0; bind_node <= bind_node_1; bind_node += step) {
641 			int i;
642 
643 			for (i = 0; i < mul; i++) {
644 				if (t >= g->p.nr_tasks) {
645 					printf("\n# NOTE: ignoring bind NODEs starting at NODE#%d\n", bind_node);
646 					goto out;
647 				}
648 				td = g->threads + t;
649 
650 				if (!t)
651 					tprintf(" %2d", bind_node);
652 				else
653 					tprintf(",%2d", bind_node);
654 
655 				td->bind_node = bind_node;
656 				t++;
657 			}
658 		}
659 	}
660 out:
661 
662 	tprintf("\n");
663 
664 	if (t < g->p.nr_tasks)
665 		printf("# NOTE: %d tasks mem-bound, %d tasks unbound\n", t, g->p.nr_tasks - t);
666 
667 	free(str0);
668 	return 0;
669 }
670 
671 static int parse_nodes_opt(const struct option *opt __maybe_unused,
672 			  const char *arg, int unset __maybe_unused)
673 {
674 	if (!arg)
675 		return -1;
676 
677 	return parse_node_list(arg);
678 
679 	return 0;
680 }
681 
682 #define BIT(x) (1ul << x)
683 
684 static inline uint32_t lfsr_32(uint32_t lfsr)
685 {
686 	const uint32_t taps = BIT(1) | BIT(5) | BIT(6) | BIT(31);
687 	return (lfsr>>1) ^ ((0x0u - (lfsr & 0x1u)) & taps);
688 }
689 
690 /*
691  * Make sure there's real data dependency to RAM (when read
692  * accesses are enabled), so the compiler, the CPU and the
693  * kernel (KSM, zero page, etc.) cannot optimize away RAM
694  * accesses:
695  */
696 static inline u64 access_data(u64 *data __attribute__((unused)), u64 val)
697 {
698 	if (g->p.data_reads)
699 		val += *data;
700 	if (g->p.data_writes)
701 		*data = val + 1;
702 	return val;
703 }
704 
705 /*
706  * The worker process does two types of work, a forwards going
707  * loop and a backwards going loop.
708  *
709  * We do this so that on multiprocessor systems we do not create
710  * a 'train' of processing, with highly synchronized processes,
711  * skewing the whole benchmark.
712  */
713 static u64 do_work(u8 *__data, long bytes, int nr, int nr_max, int loop, u64 val)
714 {
715 	long words = bytes/sizeof(u64);
716 	u64 *data = (void *)__data;
717 	long chunk_0, chunk_1;
718 	u64 *d0, *d, *d1;
719 	long off;
720 	long i;
721 
722 	BUG_ON(!data && words);
723 	BUG_ON(data && !words);
724 
725 	if (!data)
726 		return val;
727 
728 	/* Very simple memset() work variant: */
729 	if (g->p.data_zero_memset && !g->p.data_rand_walk) {
730 		bzero(data, bytes);
731 		return val;
732 	}
733 
734 	/* Spread out by PID/TID nr and by loop nr: */
735 	chunk_0 = words/nr_max;
736 	chunk_1 = words/g->p.nr_loops;
737 	off = nr*chunk_0 + loop*chunk_1;
738 
739 	while (off >= words)
740 		off -= words;
741 
742 	if (g->p.data_rand_walk) {
743 		u32 lfsr = nr + loop + val;
744 		int j;
745 
746 		for (i = 0; i < words/1024; i++) {
747 			long start, end;
748 
749 			lfsr = lfsr_32(lfsr);
750 
751 			start = lfsr % words;
752 			end = min(start + 1024, words-1);
753 
754 			if (g->p.data_zero_memset) {
755 				bzero(data + start, (end-start) * sizeof(u64));
756 			} else {
757 				for (j = start; j < end; j++)
758 					val = access_data(data + j, val);
759 			}
760 		}
761 	} else if (!g->p.data_backwards || (nr + loop) & 1) {
762 
763 		d0 = data + off;
764 		d  = data + off + 1;
765 		d1 = data + words;
766 
767 		/* Process data forwards: */
768 		for (;;) {
769 			if (unlikely(d >= d1))
770 				d = data;
771 			if (unlikely(d == d0))
772 				break;
773 
774 			val = access_data(d, val);
775 
776 			d++;
777 		}
778 	} else {
779 		/* Process data backwards: */
780 
781 		d0 = data + off;
782 		d  = data + off - 1;
783 		d1 = data + words;
784 
785 		/* Process data forwards: */
786 		for (;;) {
787 			if (unlikely(d < data))
788 				d = data + words-1;
789 			if (unlikely(d == d0))
790 				break;
791 
792 			val = access_data(d, val);
793 
794 			d--;
795 		}
796 	}
797 
798 	return val;
799 }
800 
801 static void update_curr_cpu(int task_nr, unsigned long bytes_worked)
802 {
803 	unsigned int cpu;
804 
805 	cpu = sched_getcpu();
806 
807 	g->threads[task_nr].curr_cpu = cpu;
808 	prctl(0, bytes_worked);
809 }
810 
811 #define MAX_NR_NODES	64
812 
813 /*
814  * Count the number of nodes a process's threads
815  * are spread out on.
816  *
817  * A count of 1 means that the process is compressed
818  * to a single node. A count of g->p.nr_nodes means it's
819  * spread out on the whole system.
820  */
821 static int count_process_nodes(int process_nr)
822 {
823 	char node_present[MAX_NR_NODES] = { 0, };
824 	int nodes;
825 	int n, t;
826 
827 	for (t = 0; t < g->p.nr_threads; t++) {
828 		struct thread_data *td;
829 		int task_nr;
830 		int node;
831 
832 		task_nr = process_nr*g->p.nr_threads + t;
833 		td = g->threads + task_nr;
834 
835 		node = numa_node_of_cpu(td->curr_cpu);
836 		if (node < 0) /* curr_cpu was likely still -1 */
837 			return 0;
838 
839 		node_present[node] = 1;
840 	}
841 
842 	nodes = 0;
843 
844 	for (n = 0; n < MAX_NR_NODES; n++)
845 		nodes += node_present[n];
846 
847 	return nodes;
848 }
849 
850 /*
851  * Count the number of distinct process-threads a node contains.
852  *
853  * A count of 1 means that the node contains only a single
854  * process. If all nodes on the system contain at most one
855  * process then we are well-converged.
856  */
857 static int count_node_processes(int node)
858 {
859 	int processes = 0;
860 	int t, p;
861 
862 	for (p = 0; p < g->p.nr_proc; p++) {
863 		for (t = 0; t < g->p.nr_threads; t++) {
864 			struct thread_data *td;
865 			int task_nr;
866 			int n;
867 
868 			task_nr = p*g->p.nr_threads + t;
869 			td = g->threads + task_nr;
870 
871 			n = numa_node_of_cpu(td->curr_cpu);
872 			if (n == node) {
873 				processes++;
874 				break;
875 			}
876 		}
877 	}
878 
879 	return processes;
880 }
881 
882 static void calc_convergence_compression(int *strong)
883 {
884 	unsigned int nodes_min, nodes_max;
885 	int p;
886 
887 	nodes_min = -1;
888 	nodes_max =  0;
889 
890 	for (p = 0; p < g->p.nr_proc; p++) {
891 		unsigned int nodes = count_process_nodes(p);
892 
893 		if (!nodes) {
894 			*strong = 0;
895 			return;
896 		}
897 
898 		nodes_min = min(nodes, nodes_min);
899 		nodes_max = max(nodes, nodes_max);
900 	}
901 
902 	/* Strong convergence: all threads compress on a single node: */
903 	if (nodes_min == 1 && nodes_max == 1) {
904 		*strong = 1;
905 	} else {
906 		*strong = 0;
907 		tprintf(" {%d-%d}", nodes_min, nodes_max);
908 	}
909 }
910 
911 static void calc_convergence(double runtime_ns_max, double *convergence)
912 {
913 	unsigned int loops_done_min, loops_done_max;
914 	int process_groups;
915 	int nodes[MAX_NR_NODES];
916 	int distance;
917 	int nr_min;
918 	int nr_max;
919 	int strong;
920 	int sum;
921 	int nr;
922 	int node;
923 	int cpu;
924 	int t;
925 
926 	if (!g->p.show_convergence && !g->p.measure_convergence)
927 		return;
928 
929 	for (node = 0; node < g->p.nr_nodes; node++)
930 		nodes[node] = 0;
931 
932 	loops_done_min = -1;
933 	loops_done_max = 0;
934 
935 	for (t = 0; t < g->p.nr_tasks; t++) {
936 		struct thread_data *td = g->threads + t;
937 		unsigned int loops_done;
938 
939 		cpu = td->curr_cpu;
940 
941 		/* Not all threads have written it yet: */
942 		if (cpu < 0)
943 			continue;
944 
945 		node = numa_node_of_cpu(cpu);
946 
947 		nodes[node]++;
948 
949 		loops_done = td->loops_done;
950 		loops_done_min = min(loops_done, loops_done_min);
951 		loops_done_max = max(loops_done, loops_done_max);
952 	}
953 
954 	nr_max = 0;
955 	nr_min = g->p.nr_tasks;
956 	sum = 0;
957 
958 	for (node = 0; node < g->p.nr_nodes; node++) {
959 		nr = nodes[node];
960 		nr_min = min(nr, nr_min);
961 		nr_max = max(nr, nr_max);
962 		sum += nr;
963 	}
964 	BUG_ON(nr_min > nr_max);
965 
966 	BUG_ON(sum > g->p.nr_tasks);
967 
968 	if (0 && (sum < g->p.nr_tasks))
969 		return;
970 
971 	/*
972 	 * Count the number of distinct process groups present
973 	 * on nodes - when we are converged this will decrease
974 	 * to g->p.nr_proc:
975 	 */
976 	process_groups = 0;
977 
978 	for (node = 0; node < g->p.nr_nodes; node++) {
979 		int processes = count_node_processes(node);
980 
981 		nr = nodes[node];
982 		tprintf(" %2d/%-2d", nr, processes);
983 
984 		process_groups += processes;
985 	}
986 
987 	distance = nr_max - nr_min;
988 
989 	tprintf(" [%2d/%-2d]", distance, process_groups);
990 
991 	tprintf(" l:%3d-%-3d (%3d)",
992 		loops_done_min, loops_done_max, loops_done_max-loops_done_min);
993 
994 	if (loops_done_min && loops_done_max) {
995 		double skew = 1.0 - (double)loops_done_min/loops_done_max;
996 
997 		tprintf(" [%4.1f%%]", skew * 100.0);
998 	}
999 
1000 	calc_convergence_compression(&strong);
1001 
1002 	if (strong && process_groups == g->p.nr_proc) {
1003 		if (!*convergence) {
1004 			*convergence = runtime_ns_max;
1005 			tprintf(" (%6.1fs converged)\n", *convergence/1e9);
1006 			if (g->p.measure_convergence) {
1007 				g->all_converged = true;
1008 				g->stop_work = true;
1009 			}
1010 		}
1011 	} else {
1012 		if (*convergence) {
1013 			tprintf(" (%6.1fs de-converged)", runtime_ns_max/1e9);
1014 			*convergence = 0;
1015 		}
1016 		tprintf("\n");
1017 	}
1018 }
1019 
1020 static void show_summary(double runtime_ns_max, int l, double *convergence)
1021 {
1022 	tprintf("\r #  %5.1f%%  [%.1f mins]",
1023 		(double)(l+1)/g->p.nr_loops*100.0, runtime_ns_max/1e9 / 60.0);
1024 
1025 	calc_convergence(runtime_ns_max, convergence);
1026 
1027 	if (g->p.show_details >= 0)
1028 		fflush(stdout);
1029 }
1030 
1031 static void *worker_thread(void *__tdata)
1032 {
1033 	struct thread_data *td = __tdata;
1034 	struct timeval start0, start, stop, diff;
1035 	int process_nr = td->process_nr;
1036 	int thread_nr = td->thread_nr;
1037 	unsigned long last_perturbance;
1038 	int task_nr = td->task_nr;
1039 	int details = g->p.show_details;
1040 	int first_task, last_task;
1041 	double convergence = 0;
1042 	u64 val = td->val;
1043 	double runtime_ns_max;
1044 	u8 *global_data;
1045 	u8 *process_data;
1046 	u8 *thread_data;
1047 	u64 bytes_done;
1048 	long work_done;
1049 	u32 l;
1050 	struct rusage rusage;
1051 
1052 	bind_to_cpumask(td->bind_cpumask);
1053 	bind_to_memnode(td->bind_node);
1054 
1055 	set_taskname("thread %d/%d", process_nr, thread_nr);
1056 
1057 	global_data = g->data;
1058 	process_data = td->process_data;
1059 	thread_data = setup_private_data(g->p.bytes_thread);
1060 
1061 	bytes_done = 0;
1062 
1063 	last_task = 0;
1064 	if (process_nr == g->p.nr_proc-1 && thread_nr == g->p.nr_threads-1)
1065 		last_task = 1;
1066 
1067 	first_task = 0;
1068 	if (process_nr == 0 && thread_nr == 0)
1069 		first_task = 1;
1070 
1071 	if (details >= 2) {
1072 		printf("#  thread %2d / %2d global mem: %p, process mem: %p, thread mem: %p\n",
1073 			process_nr, thread_nr, global_data, process_data, thread_data);
1074 	}
1075 
1076 	if (g->p.serialize_startup) {
1077 		pthread_mutex_lock(&g->startup_mutex);
1078 		g->nr_tasks_started++;
1079 		pthread_mutex_unlock(&g->startup_mutex);
1080 
1081 		/* Here we will wait for the main process to start us all at once: */
1082 		pthread_mutex_lock(&g->start_work_mutex);
1083 		g->nr_tasks_working++;
1084 
1085 		/* Last one wake the main process: */
1086 		if (g->nr_tasks_working == g->p.nr_tasks)
1087 			pthread_mutex_unlock(&g->startup_done_mutex);
1088 
1089 		pthread_mutex_unlock(&g->start_work_mutex);
1090 	}
1091 
1092 	gettimeofday(&start0, NULL);
1093 
1094 	start = stop = start0;
1095 	last_perturbance = start.tv_sec;
1096 
1097 	for (l = 0; l < g->p.nr_loops; l++) {
1098 		start = stop;
1099 
1100 		if (g->stop_work)
1101 			break;
1102 
1103 		val += do_work(global_data,  g->p.bytes_global,  process_nr, g->p.nr_proc,	l, val);
1104 		val += do_work(process_data, g->p.bytes_process, thread_nr,  g->p.nr_threads,	l, val);
1105 		val += do_work(thread_data,  g->p.bytes_thread,  0,          1,		l, val);
1106 
1107 		if (g->p.sleep_usecs) {
1108 			pthread_mutex_lock(td->process_lock);
1109 			usleep(g->p.sleep_usecs);
1110 			pthread_mutex_unlock(td->process_lock);
1111 		}
1112 		/*
1113 		 * Amount of work to be done under a process-global lock:
1114 		 */
1115 		if (g->p.bytes_process_locked) {
1116 			pthread_mutex_lock(td->process_lock);
1117 			val += do_work(process_data, g->p.bytes_process_locked, thread_nr,  g->p.nr_threads,	l, val);
1118 			pthread_mutex_unlock(td->process_lock);
1119 		}
1120 
1121 		work_done = g->p.bytes_global + g->p.bytes_process +
1122 			    g->p.bytes_process_locked + g->p.bytes_thread;
1123 
1124 		update_curr_cpu(task_nr, work_done);
1125 		bytes_done += work_done;
1126 
1127 		if (details < 0 && !g->p.perturb_secs && !g->p.measure_convergence && !g->p.nr_secs)
1128 			continue;
1129 
1130 		td->loops_done = l;
1131 
1132 		gettimeofday(&stop, NULL);
1133 
1134 		/* Check whether our max runtime timed out: */
1135 		if (g->p.nr_secs) {
1136 			timersub(&stop, &start0, &diff);
1137 			if ((u32)diff.tv_sec >= g->p.nr_secs) {
1138 				g->stop_work = true;
1139 				break;
1140 			}
1141 		}
1142 
1143 		/* Update the summary at most once per second: */
1144 		if (start.tv_sec == stop.tv_sec)
1145 			continue;
1146 
1147 		/*
1148 		 * Perturb the first task's equilibrium every g->p.perturb_secs seconds,
1149 		 * by migrating to CPU#0:
1150 		 */
1151 		if (first_task && g->p.perturb_secs && (int)(stop.tv_sec - last_perturbance) >= g->p.perturb_secs) {
1152 			cpu_set_t orig_mask;
1153 			int target_cpu;
1154 			int this_cpu;
1155 
1156 			last_perturbance = stop.tv_sec;
1157 
1158 			/*
1159 			 * Depending on where we are running, move into
1160 			 * the other half of the system, to create some
1161 			 * real disturbance:
1162 			 */
1163 			this_cpu = g->threads[task_nr].curr_cpu;
1164 			if (this_cpu < g->p.nr_cpus/2)
1165 				target_cpu = g->p.nr_cpus-1;
1166 			else
1167 				target_cpu = 0;
1168 
1169 			orig_mask = bind_to_cpu(target_cpu);
1170 
1171 			/* Here we are running on the target CPU already */
1172 			if (details >= 1)
1173 				printf(" (injecting perturbalance, moved to CPU#%d)\n", target_cpu);
1174 
1175 			bind_to_cpumask(orig_mask);
1176 		}
1177 
1178 		if (details >= 3) {
1179 			timersub(&stop, &start, &diff);
1180 			runtime_ns_max = diff.tv_sec * 1000000000;
1181 			runtime_ns_max += diff.tv_usec * 1000;
1182 
1183 			if (details >= 0) {
1184 				printf(" #%2d / %2d: %14.2lf nsecs/op [val: %016"PRIx64"]\n",
1185 					process_nr, thread_nr, runtime_ns_max / bytes_done, val);
1186 			}
1187 			fflush(stdout);
1188 		}
1189 		if (!last_task)
1190 			continue;
1191 
1192 		timersub(&stop, &start0, &diff);
1193 		runtime_ns_max = diff.tv_sec * 1000000000ULL;
1194 		runtime_ns_max += diff.tv_usec * 1000ULL;
1195 
1196 		show_summary(runtime_ns_max, l, &convergence);
1197 	}
1198 
1199 	gettimeofday(&stop, NULL);
1200 	timersub(&stop, &start0, &diff);
1201 	td->runtime_ns = diff.tv_sec * 1000000000ULL;
1202 	td->runtime_ns += diff.tv_usec * 1000ULL;
1203 	td->speed_gbs = bytes_done / (td->runtime_ns / 1e9) / 1e9;
1204 
1205 	getrusage(RUSAGE_THREAD, &rusage);
1206 	td->system_time_ns = rusage.ru_stime.tv_sec * 1000000000ULL;
1207 	td->system_time_ns += rusage.ru_stime.tv_usec * 1000ULL;
1208 	td->user_time_ns = rusage.ru_utime.tv_sec * 1000000000ULL;
1209 	td->user_time_ns += rusage.ru_utime.tv_usec * 1000ULL;
1210 
1211 	free_data(thread_data, g->p.bytes_thread);
1212 
1213 	pthread_mutex_lock(&g->stop_work_mutex);
1214 	g->bytes_done += bytes_done;
1215 	pthread_mutex_unlock(&g->stop_work_mutex);
1216 
1217 	return NULL;
1218 }
1219 
1220 /*
1221  * A worker process starts a couple of threads:
1222  */
1223 static void worker_process(int process_nr)
1224 {
1225 	pthread_mutex_t process_lock;
1226 	struct thread_data *td;
1227 	pthread_t *pthreads;
1228 	u8 *process_data;
1229 	int task_nr;
1230 	int ret;
1231 	int t;
1232 
1233 	pthread_mutex_init(&process_lock, NULL);
1234 	set_taskname("process %d", process_nr);
1235 
1236 	/*
1237 	 * Pick up the memory policy and the CPU binding of our first thread,
1238 	 * so that we initialize memory accordingly:
1239 	 */
1240 	task_nr = process_nr*g->p.nr_threads;
1241 	td = g->threads + task_nr;
1242 
1243 	bind_to_memnode(td->bind_node);
1244 	bind_to_cpumask(td->bind_cpumask);
1245 
1246 	pthreads = zalloc(g->p.nr_threads * sizeof(pthread_t));
1247 	process_data = setup_private_data(g->p.bytes_process);
1248 
1249 	if (g->p.show_details >= 3) {
1250 		printf(" # process %2d global mem: %p, process mem: %p\n",
1251 			process_nr, g->data, process_data);
1252 	}
1253 
1254 	for (t = 0; t < g->p.nr_threads; t++) {
1255 		task_nr = process_nr*g->p.nr_threads + t;
1256 		td = g->threads + task_nr;
1257 
1258 		td->process_data = process_data;
1259 		td->process_nr   = process_nr;
1260 		td->thread_nr    = t;
1261 		td->task_nr	 = task_nr;
1262 		td->val          = rand();
1263 		td->curr_cpu	 = -1;
1264 		td->process_lock = &process_lock;
1265 
1266 		ret = pthread_create(pthreads + t, NULL, worker_thread, td);
1267 		BUG_ON(ret);
1268 	}
1269 
1270 	for (t = 0; t < g->p.nr_threads; t++) {
1271                 ret = pthread_join(pthreads[t], NULL);
1272 		BUG_ON(ret);
1273 	}
1274 
1275 	free_data(process_data, g->p.bytes_process);
1276 	free(pthreads);
1277 }
1278 
1279 static void print_summary(void)
1280 {
1281 	if (g->p.show_details < 0)
1282 		return;
1283 
1284 	printf("\n ###\n");
1285 	printf(" # %d %s will execute (on %d nodes, %d CPUs):\n",
1286 		g->p.nr_tasks, g->p.nr_tasks == 1 ? "task" : "tasks", g->p.nr_nodes, g->p.nr_cpus);
1287 	printf(" #      %5dx %5ldMB global  shared mem operations\n",
1288 			g->p.nr_loops, g->p.bytes_global/1024/1024);
1289 	printf(" #      %5dx %5ldMB process shared mem operations\n",
1290 			g->p.nr_loops, g->p.bytes_process/1024/1024);
1291 	printf(" #      %5dx %5ldMB thread  local  mem operations\n",
1292 			g->p.nr_loops, g->p.bytes_thread/1024/1024);
1293 
1294 	printf(" ###\n");
1295 
1296 	printf("\n ###\n"); fflush(stdout);
1297 }
1298 
1299 static void init_thread_data(void)
1300 {
1301 	ssize_t size = sizeof(*g->threads)*g->p.nr_tasks;
1302 	int t;
1303 
1304 	g->threads = zalloc_shared_data(size);
1305 
1306 	for (t = 0; t < g->p.nr_tasks; t++) {
1307 		struct thread_data *td = g->threads + t;
1308 		int cpu;
1309 
1310 		/* Allow all nodes by default: */
1311 		td->bind_node = -1;
1312 
1313 		/* Allow all CPUs by default: */
1314 		CPU_ZERO(&td->bind_cpumask);
1315 		for (cpu = 0; cpu < g->p.nr_cpus; cpu++)
1316 			CPU_SET(cpu, &td->bind_cpumask);
1317 	}
1318 }
1319 
1320 static void deinit_thread_data(void)
1321 {
1322 	ssize_t size = sizeof(*g->threads)*g->p.nr_tasks;
1323 
1324 	free_data(g->threads, size);
1325 }
1326 
1327 static int init(void)
1328 {
1329 	g = (void *)alloc_data(sizeof(*g), MAP_SHARED, 1, 0, 0 /* THP */, 0);
1330 
1331 	/* Copy over options: */
1332 	g->p = p0;
1333 
1334 	g->p.nr_cpus = numa_num_configured_cpus();
1335 
1336 	g->p.nr_nodes = numa_max_node() + 1;
1337 
1338 	/* char array in count_process_nodes(): */
1339 	BUG_ON(g->p.nr_nodes > MAX_NR_NODES || g->p.nr_nodes < 0);
1340 
1341 	if (g->p.show_quiet && !g->p.show_details)
1342 		g->p.show_details = -1;
1343 
1344 	/* Some memory should be specified: */
1345 	if (!g->p.mb_global_str && !g->p.mb_proc_str && !g->p.mb_thread_str)
1346 		return -1;
1347 
1348 	if (g->p.mb_global_str) {
1349 		g->p.mb_global = atof(g->p.mb_global_str);
1350 		BUG_ON(g->p.mb_global < 0);
1351 	}
1352 
1353 	if (g->p.mb_proc_str) {
1354 		g->p.mb_proc = atof(g->p.mb_proc_str);
1355 		BUG_ON(g->p.mb_proc < 0);
1356 	}
1357 
1358 	if (g->p.mb_proc_locked_str) {
1359 		g->p.mb_proc_locked = atof(g->p.mb_proc_locked_str);
1360 		BUG_ON(g->p.mb_proc_locked < 0);
1361 		BUG_ON(g->p.mb_proc_locked > g->p.mb_proc);
1362 	}
1363 
1364 	if (g->p.mb_thread_str) {
1365 		g->p.mb_thread = atof(g->p.mb_thread_str);
1366 		BUG_ON(g->p.mb_thread < 0);
1367 	}
1368 
1369 	BUG_ON(g->p.nr_threads <= 0);
1370 	BUG_ON(g->p.nr_proc <= 0);
1371 
1372 	g->p.nr_tasks = g->p.nr_proc*g->p.nr_threads;
1373 
1374 	g->p.bytes_global		= g->p.mb_global	*1024L*1024L;
1375 	g->p.bytes_process		= g->p.mb_proc		*1024L*1024L;
1376 	g->p.bytes_process_locked	= g->p.mb_proc_locked	*1024L*1024L;
1377 	g->p.bytes_thread		= g->p.mb_thread	*1024L*1024L;
1378 
1379 	g->data = setup_shared_data(g->p.bytes_global);
1380 
1381 	/* Startup serialization: */
1382 	init_global_mutex(&g->start_work_mutex);
1383 	init_global_mutex(&g->startup_mutex);
1384 	init_global_mutex(&g->startup_done_mutex);
1385 	init_global_mutex(&g->stop_work_mutex);
1386 
1387 	init_thread_data();
1388 
1389 	tprintf("#\n");
1390 	if (parse_setup_cpu_list() || parse_setup_node_list())
1391 		return -1;
1392 	tprintf("#\n");
1393 
1394 	print_summary();
1395 
1396 	return 0;
1397 }
1398 
1399 static void deinit(void)
1400 {
1401 	free_data(g->data, g->p.bytes_global);
1402 	g->data = NULL;
1403 
1404 	deinit_thread_data();
1405 
1406 	free_data(g, sizeof(*g));
1407 	g = NULL;
1408 }
1409 
1410 /*
1411  * Print a short or long result, depending on the verbosity setting:
1412  */
1413 static void print_res(const char *name, double val,
1414 		      const char *txt_unit, const char *txt_short, const char *txt_long)
1415 {
1416 	if (!name)
1417 		name = "main,";
1418 
1419 	if (!g->p.show_quiet)
1420 		printf(" %-30s %15.3f, %-15s %s\n", name, val, txt_unit, txt_short);
1421 	else
1422 		printf(" %14.3f %s\n", val, txt_long);
1423 }
1424 
1425 static int __bench_numa(const char *name)
1426 {
1427 	struct timeval start, stop, diff;
1428 	u64 runtime_ns_min, runtime_ns_sum;
1429 	pid_t *pids, pid, wpid;
1430 	double delta_runtime;
1431 	double runtime_avg;
1432 	double runtime_sec_max;
1433 	double runtime_sec_min;
1434 	int wait_stat;
1435 	double bytes;
1436 	int i, t, p;
1437 
1438 	if (init())
1439 		return -1;
1440 
1441 	pids = zalloc(g->p.nr_proc * sizeof(*pids));
1442 	pid = -1;
1443 
1444 	/* All threads try to acquire it, this way we can wait for them to start up: */
1445 	pthread_mutex_lock(&g->start_work_mutex);
1446 
1447 	if (g->p.serialize_startup) {
1448 		tprintf(" #\n");
1449 		tprintf(" # Startup synchronization: ..."); fflush(stdout);
1450 	}
1451 
1452 	gettimeofday(&start, NULL);
1453 
1454 	for (i = 0; i < g->p.nr_proc; i++) {
1455 		pid = fork();
1456 		dprintf(" # process %2d: PID %d\n", i, pid);
1457 
1458 		BUG_ON(pid < 0);
1459 		if (!pid) {
1460 			/* Child process: */
1461 			worker_process(i);
1462 
1463 			exit(0);
1464 		}
1465 		pids[i] = pid;
1466 
1467 	}
1468 	/* Wait for all the threads to start up: */
1469 	while (g->nr_tasks_started != g->p.nr_tasks)
1470 		usleep(1000);
1471 
1472 	BUG_ON(g->nr_tasks_started != g->p.nr_tasks);
1473 
1474 	if (g->p.serialize_startup) {
1475 		double startup_sec;
1476 
1477 		pthread_mutex_lock(&g->startup_done_mutex);
1478 
1479 		/* This will start all threads: */
1480 		pthread_mutex_unlock(&g->start_work_mutex);
1481 
1482 		/* This mutex is locked - the last started thread will wake us: */
1483 		pthread_mutex_lock(&g->startup_done_mutex);
1484 
1485 		gettimeofday(&stop, NULL);
1486 
1487 		timersub(&stop, &start, &diff);
1488 
1489 		startup_sec = diff.tv_sec * 1000000000.0;
1490 		startup_sec += diff.tv_usec * 1000.0;
1491 		startup_sec /= 1e9;
1492 
1493 		tprintf(" threads initialized in %.6f seconds.\n", startup_sec);
1494 		tprintf(" #\n");
1495 
1496 		start = stop;
1497 		pthread_mutex_unlock(&g->startup_done_mutex);
1498 	} else {
1499 		gettimeofday(&start, NULL);
1500 	}
1501 
1502 	/* Parent process: */
1503 
1504 
1505 	for (i = 0; i < g->p.nr_proc; i++) {
1506 		wpid = waitpid(pids[i], &wait_stat, 0);
1507 		BUG_ON(wpid < 0);
1508 		BUG_ON(!WIFEXITED(wait_stat));
1509 
1510 	}
1511 
1512 	runtime_ns_sum = 0;
1513 	runtime_ns_min = -1LL;
1514 
1515 	for (t = 0; t < g->p.nr_tasks; t++) {
1516 		u64 thread_runtime_ns = g->threads[t].runtime_ns;
1517 
1518 		runtime_ns_sum += thread_runtime_ns;
1519 		runtime_ns_min = min(thread_runtime_ns, runtime_ns_min);
1520 	}
1521 
1522 	gettimeofday(&stop, NULL);
1523 	timersub(&stop, &start, &diff);
1524 
1525 	BUG_ON(bench_format != BENCH_FORMAT_DEFAULT);
1526 
1527 	tprintf("\n ###\n");
1528 	tprintf("\n");
1529 
1530 	runtime_sec_max = diff.tv_sec * 1000000000.0;
1531 	runtime_sec_max += diff.tv_usec * 1000.0;
1532 	runtime_sec_max /= 1e9;
1533 
1534 	runtime_sec_min = runtime_ns_min/1e9;
1535 
1536 	bytes = g->bytes_done;
1537 	runtime_avg = (double)runtime_ns_sum / g->p.nr_tasks / 1e9;
1538 
1539 	if (g->p.measure_convergence) {
1540 		print_res(name, runtime_sec_max,
1541 			"secs,", "NUMA-convergence-latency", "secs latency to NUMA-converge");
1542 	}
1543 
1544 	print_res(name, runtime_sec_max,
1545 		"secs,", "runtime-max/thread",	"secs slowest (max) thread-runtime");
1546 
1547 	print_res(name, runtime_sec_min,
1548 		"secs,", "runtime-min/thread",	"secs fastest (min) thread-runtime");
1549 
1550 	print_res(name, runtime_avg,
1551 		"secs,", "runtime-avg/thread",	"secs average thread-runtime");
1552 
1553 	delta_runtime = (runtime_sec_max - runtime_sec_min)/2.0;
1554 	print_res(name, delta_runtime / runtime_sec_max * 100.0,
1555 		"%,", "spread-runtime/thread",	"% difference between max/avg runtime");
1556 
1557 	print_res(name, bytes / g->p.nr_tasks / 1e9,
1558 		"GB,", "data/thread",		"GB data processed, per thread");
1559 
1560 	print_res(name, bytes / 1e9,
1561 		"GB,", "data-total",		"GB data processed, total");
1562 
1563 	print_res(name, runtime_sec_max * 1e9 / (bytes / g->p.nr_tasks),
1564 		"nsecs,", "runtime/byte/thread","nsecs/byte/thread runtime");
1565 
1566 	print_res(name, bytes / g->p.nr_tasks / 1e9 / runtime_sec_max,
1567 		"GB/sec,", "thread-speed",	"GB/sec/thread speed");
1568 
1569 	print_res(name, bytes / runtime_sec_max / 1e9,
1570 		"GB/sec,", "total-speed",	"GB/sec total speed");
1571 
1572 	if (g->p.show_details >= 2) {
1573 		char tname[32];
1574 		struct thread_data *td;
1575 		for (p = 0; p < g->p.nr_proc; p++) {
1576 			for (t = 0; t < g->p.nr_threads; t++) {
1577 				memset(tname, 0, 32);
1578 				td = g->threads + p*g->p.nr_threads + t;
1579 				snprintf(tname, 32, "process%d:thread%d", p, t);
1580 				print_res(tname, td->speed_gbs,
1581 					"GB/sec",	"thread-speed", "GB/sec/thread speed");
1582 				print_res(tname, td->system_time_ns / 1e9,
1583 					"secs",	"thread-system-time", "system CPU time/thread");
1584 				print_res(tname, td->user_time_ns / 1e9,
1585 					"secs",	"thread-user-time", "user CPU time/thread");
1586 			}
1587 		}
1588 	}
1589 
1590 	free(pids);
1591 
1592 	deinit();
1593 
1594 	return 0;
1595 }
1596 
1597 #define MAX_ARGS 50
1598 
1599 static int command_size(const char **argv)
1600 {
1601 	int size = 0;
1602 
1603 	while (*argv) {
1604 		size++;
1605 		argv++;
1606 	}
1607 
1608 	BUG_ON(size >= MAX_ARGS);
1609 
1610 	return size;
1611 }
1612 
1613 static void init_params(struct params *p, const char *name, int argc, const char **argv)
1614 {
1615 	int i;
1616 
1617 	printf("\n # Running %s \"perf bench numa", name);
1618 
1619 	for (i = 0; i < argc; i++)
1620 		printf(" %s", argv[i]);
1621 
1622 	printf("\"\n");
1623 
1624 	memset(p, 0, sizeof(*p));
1625 
1626 	/* Initialize nonzero defaults: */
1627 
1628 	p->serialize_startup		= 1;
1629 	p->data_reads			= true;
1630 	p->data_writes			= true;
1631 	p->data_backwards		= true;
1632 	p->data_rand_walk		= true;
1633 	p->nr_loops			= -1;
1634 	p->init_random			= true;
1635 	p->mb_global_str		= "1";
1636 	p->nr_proc			= 1;
1637 	p->nr_threads			= 1;
1638 	p->nr_secs			= 5;
1639 	p->run_all			= argc == 1;
1640 }
1641 
1642 static int run_bench_numa(const char *name, const char **argv)
1643 {
1644 	int argc = command_size(argv);
1645 
1646 	init_params(&p0, name, argc, argv);
1647 	argc = parse_options(argc, argv, options, bench_numa_usage, 0);
1648 	if (argc)
1649 		goto err;
1650 
1651 	if (__bench_numa(name))
1652 		goto err;
1653 
1654 	return 0;
1655 
1656 err:
1657 	return -1;
1658 }
1659 
1660 #define OPT_BW_RAM		"-s",  "20", "-zZq",    "--thp", " 1", "--no-data_rand_walk"
1661 #define OPT_BW_RAM_NOTHP	OPT_BW_RAM,		"--thp", "-1"
1662 
1663 #define OPT_CONV		"-s", "100", "-zZ0qcm", "--thp", " 1"
1664 #define OPT_CONV_NOTHP		OPT_CONV,		"--thp", "-1"
1665 
1666 #define OPT_BW			"-s",  "20", "-zZ0q",   "--thp", " 1"
1667 #define OPT_BW_NOTHP		OPT_BW,			"--thp", "-1"
1668 
1669 /*
1670  * The built-in test-suite executed by "perf bench numa -a".
1671  *
1672  * (A minimum of 4 nodes and 16 GB of RAM is recommended.)
1673  */
1674 static const char *tests[][MAX_ARGS] = {
1675    /* Basic single-stream NUMA bandwidth measurements: */
1676    { "RAM-bw-local,",	  "mem",  "-p",  "1",  "-t",  "1", "-P", "1024",
1677 			  "-C" ,   "0", "-M",   "0", OPT_BW_RAM },
1678    { "RAM-bw-local-NOTHP,",
1679 			  "mem",  "-p",  "1",  "-t",  "1", "-P", "1024",
1680 			  "-C" ,   "0", "-M",   "0", OPT_BW_RAM_NOTHP },
1681    { "RAM-bw-remote,",	  "mem",  "-p",  "1",  "-t",  "1", "-P", "1024",
1682 			  "-C" ,   "0", "-M",   "1", OPT_BW_RAM },
1683 
1684    /* 2-stream NUMA bandwidth measurements: */
1685    { "RAM-bw-local-2x,",  "mem",  "-p",  "2",  "-t",  "1", "-P", "1024",
1686 			   "-C", "0,2", "-M", "0x2", OPT_BW_RAM },
1687    { "RAM-bw-remote-2x,", "mem",  "-p",  "2",  "-t",  "1", "-P", "1024",
1688 		 	   "-C", "0,2", "-M", "1x2", OPT_BW_RAM },
1689 
1690    /* Cross-stream NUMA bandwidth measurement: */
1691    { "RAM-bw-cross,",     "mem",  "-p",  "2",  "-t",  "1", "-P", "1024",
1692 		 	   "-C", "0,8", "-M", "1,0", OPT_BW_RAM },
1693 
1694    /* Convergence latency measurements: */
1695    { " 1x3-convergence,", "mem",  "-p",  "1", "-t",  "3", "-P",  "512", OPT_CONV },
1696    { " 1x4-convergence,", "mem",  "-p",  "1", "-t",  "4", "-P",  "512", OPT_CONV },
1697    { " 1x6-convergence,", "mem",  "-p",  "1", "-t",  "6", "-P", "1020", OPT_CONV },
1698    { " 2x3-convergence,", "mem",  "-p",  "3", "-t",  "3", "-P", "1020", OPT_CONV },
1699    { " 3x3-convergence,", "mem",  "-p",  "3", "-t",  "3", "-P", "1020", OPT_CONV },
1700    { " 4x4-convergence,", "mem",  "-p",  "4", "-t",  "4", "-P",  "512", OPT_CONV },
1701    { " 4x4-convergence-NOTHP,",
1702 			  "mem",  "-p",  "4", "-t",  "4", "-P",  "512", OPT_CONV_NOTHP },
1703    { " 4x6-convergence,", "mem",  "-p",  "4", "-t",  "6", "-P", "1020", OPT_CONV },
1704    { " 4x8-convergence,", "mem",  "-p",  "4", "-t",  "8", "-P",  "512", OPT_CONV },
1705    { " 8x4-convergence,", "mem",  "-p",  "8", "-t",  "4", "-P",  "512", OPT_CONV },
1706    { " 8x4-convergence-NOTHP,",
1707 			  "mem",  "-p",  "8", "-t",  "4", "-P",  "512", OPT_CONV_NOTHP },
1708    { " 3x1-convergence,", "mem",  "-p",  "3", "-t",  "1", "-P",  "512", OPT_CONV },
1709    { " 4x1-convergence,", "mem",  "-p",  "4", "-t",  "1", "-P",  "512", OPT_CONV },
1710    { " 8x1-convergence,", "mem",  "-p",  "8", "-t",  "1", "-P",  "512", OPT_CONV },
1711    { "16x1-convergence,", "mem",  "-p", "16", "-t",  "1", "-P",  "256", OPT_CONV },
1712    { "32x1-convergence,", "mem",  "-p", "32", "-t",  "1", "-P",  "128", OPT_CONV },
1713 
1714    /* Various NUMA process/thread layout bandwidth measurements: */
1715    { " 2x1-bw-process,",  "mem",  "-p",  "2", "-t",  "1", "-P", "1024", OPT_BW },
1716    { " 3x1-bw-process,",  "mem",  "-p",  "3", "-t",  "1", "-P", "1024", OPT_BW },
1717    { " 4x1-bw-process,",  "mem",  "-p",  "4", "-t",  "1", "-P", "1024", OPT_BW },
1718    { " 8x1-bw-process,",  "mem",  "-p",  "8", "-t",  "1", "-P", " 512", OPT_BW },
1719    { " 8x1-bw-process-NOTHP,",
1720 			  "mem",  "-p",  "8", "-t",  "1", "-P", " 512", OPT_BW_NOTHP },
1721    { "16x1-bw-process,",  "mem",  "-p", "16", "-t",  "1", "-P",  "256", OPT_BW },
1722 
1723    { " 4x1-bw-thread,",	  "mem",  "-p",  "1", "-t",  "4", "-T",  "256", OPT_BW },
1724    { " 8x1-bw-thread,",	  "mem",  "-p",  "1", "-t",  "8", "-T",  "256", OPT_BW },
1725    { "16x1-bw-thread,",   "mem",  "-p",  "1", "-t", "16", "-T",  "128", OPT_BW },
1726    { "32x1-bw-thread,",   "mem",  "-p",  "1", "-t", "32", "-T",   "64", OPT_BW },
1727 
1728    { " 2x3-bw-thread,",	  "mem",  "-p",  "2", "-t",  "3", "-P",  "512", OPT_BW },
1729    { " 4x4-bw-thread,",	  "mem",  "-p",  "4", "-t",  "4", "-P",  "512", OPT_BW },
1730    { " 4x6-bw-thread,",	  "mem",  "-p",  "4", "-t",  "6", "-P",  "512", OPT_BW },
1731    { " 4x8-bw-thread,",	  "mem",  "-p",  "4", "-t",  "8", "-P",  "512", OPT_BW },
1732    { " 4x8-bw-thread-NOTHP,",
1733 			  "mem",  "-p",  "4", "-t",  "8", "-P",  "512", OPT_BW_NOTHP },
1734    { " 3x3-bw-thread,",	  "mem",  "-p",  "3", "-t",  "3", "-P",  "512", OPT_BW },
1735    { " 5x5-bw-thread,",	  "mem",  "-p",  "5", "-t",  "5", "-P",  "512", OPT_BW },
1736 
1737    { "2x16-bw-thread,",   "mem",  "-p",  "2", "-t", "16", "-P",  "512", OPT_BW },
1738    { "1x32-bw-thread,",   "mem",  "-p",  "1", "-t", "32", "-P", "2048", OPT_BW },
1739 
1740    { "numa02-bw,",	  "mem",  "-p",  "1", "-t", "32", "-T",   "32", OPT_BW },
1741    { "numa02-bw-NOTHP,",  "mem",  "-p",  "1", "-t", "32", "-T",   "32", OPT_BW_NOTHP },
1742    { "numa01-bw-thread,", "mem",  "-p",  "2", "-t", "16", "-T",  "192", OPT_BW },
1743    { "numa01-bw-thread-NOTHP,",
1744 			  "mem",  "-p",  "2", "-t", "16", "-T",  "192", OPT_BW_NOTHP },
1745 };
1746 
1747 static int bench_all(void)
1748 {
1749 	int nr = ARRAY_SIZE(tests);
1750 	int ret;
1751 	int i;
1752 
1753 	ret = system("echo ' #'; echo ' # Running test on: '$(uname -a); echo ' #'");
1754 	BUG_ON(ret < 0);
1755 
1756 	for (i = 0; i < nr; i++) {
1757 		run_bench_numa(tests[i][0], tests[i] + 1);
1758 	}
1759 
1760 	printf("\n");
1761 
1762 	return 0;
1763 }
1764 
1765 int bench_numa(int argc, const char **argv, const char *prefix __maybe_unused)
1766 {
1767 	init_params(&p0, "main,", argc, argv);
1768 	argc = parse_options(argc, argv, options, bench_numa_usage, 0);
1769 	if (argc)
1770 		goto err;
1771 
1772 	if (p0.run_all)
1773 		return bench_all();
1774 
1775 	if (__bench_numa(NULL))
1776 		goto err;
1777 
1778 	return 0;
1779 
1780 err:
1781 	usage_with_options(numa_usage, options);
1782 	return -1;
1783 }
1784