1 // SPDX-License-Identifier: GPL-2.0
5 * numa: Simulate NUMA-sensitive workload and measure their NUMA performance
9 /* For the CLR_() macros */
13 #include "../builtin.h"
14 #include "../util/util.h"
15 #include <subcmd/parse-options.h>
16 #include "../util/cloexec.h"
31 #include <sys/resource.h>
33 #include <sys/prctl.h>
34 #include <sys/types.h>
35 #include <linux/kernel.h>
36 #include <linux/time64.h>
42 * Regular printout to the terminal, supressed if -q is specified:
44 #define tprintf(x...) do { if (g && g->p.show_details >= 0) printf(x); } while (0)
50 #define dprintf(x...) do { if (g && g->p.show_details >= 1) printf(x); } while (0)
54 cpu_set_t bind_cpumask
;
60 unsigned int loops_done
;
66 pthread_mutex_t
*process_lock
;
69 /* Parameters set by options: */
72 /* Startup synchronization: */
73 bool serialize_startup
;
79 /* Working set sizes: */
80 const char *mb_global_str
;
81 const char *mb_proc_str
;
82 const char *mb_proc_locked_str
;
83 const char *mb_thread_str
;
87 double mb_proc_locked
;
90 /* Access patterns to the working set: */
94 bool data_zero_memset
;
100 /* Working set initialization: */
112 long bytes_process_locked
;
118 bool show_convergence
;
119 bool measure_convergence
;
125 /* Affinity options -C and -N: */
131 /* Global, read-writable area, accessible to all processes and threads: */
136 pthread_mutex_t startup_mutex
;
137 int nr_tasks_started
;
139 pthread_mutex_t startup_done_mutex
;
141 pthread_mutex_t start_work_mutex
;
142 int nr_tasks_working
;
144 pthread_mutex_t stop_work_mutex
;
147 struct thread_data
*threads
;
149 /* Convergence latency measurement: */
158 static struct global_info
*g
= NULL
;
160 static int parse_cpus_opt(const struct option
*opt
, const char *arg
, int unset
);
161 static int parse_nodes_opt(const struct option
*opt
, const char *arg
, int unset
);
165 static const struct option options
[] = {
166 OPT_INTEGER('p', "nr_proc" , &p0
.nr_proc
, "number of processes"),
167 OPT_INTEGER('t', "nr_threads" , &p0
.nr_threads
, "number of threads per process"),
169 OPT_STRING('G', "mb_global" , &p0
.mb_global_str
, "MB", "global memory (MBs)"),
170 OPT_STRING('P', "mb_proc" , &p0
.mb_proc_str
, "MB", "process memory (MBs)"),
171 OPT_STRING('L', "mb_proc_locked", &p0
.mb_proc_locked_str
,"MB", "process serialized/locked memory access (MBs), <= process_memory"),
172 OPT_STRING('T', "mb_thread" , &p0
.mb_thread_str
, "MB", "thread memory (MBs)"),
174 OPT_UINTEGER('l', "nr_loops" , &p0
.nr_loops
, "max number of loops to run (default: unlimited)"),
175 OPT_UINTEGER('s', "nr_secs" , &p0
.nr_secs
, "max number of seconds to run (default: 5 secs)"),
176 OPT_UINTEGER('u', "usleep" , &p0
.sleep_usecs
, "usecs to sleep per loop iteration"),
178 OPT_BOOLEAN('R', "data_reads" , &p0
.data_reads
, "access the data via writes (can be mixed with -W)"),
179 OPT_BOOLEAN('W', "data_writes" , &p0
.data_writes
, "access the data via writes (can be mixed with -R)"),
180 OPT_BOOLEAN('B', "data_backwards", &p0
.data_backwards
, "access the data backwards as well"),
181 OPT_BOOLEAN('Z', "data_zero_memset", &p0
.data_zero_memset
,"access the data via glibc bzero only"),
182 OPT_BOOLEAN('r', "data_rand_walk", &p0
.data_rand_walk
, "access the data with random (32bit LFSR) walk"),
185 OPT_BOOLEAN('z', "init_zero" , &p0
.init_zero
, "bzero the initial allocations"),
186 OPT_BOOLEAN('I', "init_random" , &p0
.init_random
, "randomize the contents of the initial allocations"),
187 OPT_BOOLEAN('0', "init_cpu0" , &p0
.init_cpu0
, "do the initial allocations on CPU#0"),
188 OPT_INTEGER('x', "perturb_secs", &p0
.perturb_secs
, "perturb thread 0/0 every X secs, to test convergence stability"),
190 OPT_INCR ('d', "show_details" , &p0
.show_details
, "Show details"),
191 OPT_INCR ('a', "all" , &p0
.run_all
, "Run all tests in the suite"),
192 OPT_INTEGER('H', "thp" , &p0
.thp
, "MADV_NOHUGEPAGE < 0 < MADV_HUGEPAGE"),
193 OPT_BOOLEAN('c', "show_convergence", &p0
.show_convergence
, "show convergence details, "
194 "convergence is reached when each process (all its threads) is running on a single NUMA node."),
195 OPT_BOOLEAN('m', "measure_convergence", &p0
.measure_convergence
, "measure convergence latency"),
196 OPT_BOOLEAN('q', "quiet" , &p0
.show_quiet
, "quiet mode"),
197 OPT_BOOLEAN('S', "serialize-startup", &p0
.serialize_startup
,"serialize thread startup"),
199 /* Special option string parsing callbacks: */
200 OPT_CALLBACK('C', "cpus", NULL
, "cpu[,cpu2,...cpuN]",
201 "bind the first N tasks to these specific cpus (the rest is unbound)",
203 OPT_CALLBACK('M', "memnodes", NULL
, "node[,node2,...nodeN]",
204 "bind the first N tasks to these specific memory nodes (the rest is unbound)",
209 static const char * const bench_numa_usage
[] = {
210 "perf bench numa <options>",
214 static const char * const numa_usage
[] = {
215 "perf bench numa mem [<options>]",
219 static cpu_set_t
bind_to_cpu(int target_cpu
)
221 cpu_set_t orig_mask
, mask
;
224 ret
= sched_getaffinity(0, sizeof(orig_mask
), &orig_mask
);
229 if (target_cpu
== -1) {
232 for (cpu
= 0; cpu
< g
->p
.nr_cpus
; cpu
++)
235 BUG_ON(target_cpu
< 0 || target_cpu
>= g
->p
.nr_cpus
);
236 CPU_SET(target_cpu
, &mask
);
239 ret
= sched_setaffinity(0, sizeof(mask
), &mask
);
245 static cpu_set_t
bind_to_node(int target_node
)
247 int cpus_per_node
= g
->p
.nr_cpus
/g
->p
.nr_nodes
;
248 cpu_set_t orig_mask
, mask
;
252 BUG_ON(cpus_per_node
*g
->p
.nr_nodes
!= g
->p
.nr_cpus
);
253 BUG_ON(!cpus_per_node
);
255 ret
= sched_getaffinity(0, sizeof(orig_mask
), &orig_mask
);
260 if (target_node
== -1) {
261 for (cpu
= 0; cpu
< g
->p
.nr_cpus
; cpu
++)
264 int cpu_start
= (target_node
+ 0) * cpus_per_node
;
265 int cpu_stop
= (target_node
+ 1) * cpus_per_node
;
267 BUG_ON(cpu_stop
> g
->p
.nr_cpus
);
269 for (cpu
= cpu_start
; cpu
< cpu_stop
; cpu
++)
273 ret
= sched_setaffinity(0, sizeof(mask
), &mask
);
279 static void bind_to_cpumask(cpu_set_t mask
)
283 ret
= sched_setaffinity(0, sizeof(mask
), &mask
);
287 static void mempol_restore(void)
291 ret
= set_mempolicy(MPOL_DEFAULT
, NULL
, g
->p
.nr_nodes
-1);
296 static void bind_to_memnode(int node
)
298 unsigned long nodemask
;
304 BUG_ON(g
->p
.nr_nodes
> (int)sizeof(nodemask
)*8);
305 nodemask
= 1L << node
;
307 ret
= set_mempolicy(MPOL_BIND
, &nodemask
, sizeof(nodemask
)*8);
308 dprintf("binding to node %d, mask: %016lx => %d\n", node
, nodemask
, ret
);
313 #define HPSIZE (2*1024*1024)
315 #define set_taskname(fmt...) \
319 snprintf(name, 20, fmt); \
320 prctl(PR_SET_NAME, name); \
323 static u8
*alloc_data(ssize_t bytes0
, int map_flags
,
324 int init_zero
, int init_cpu0
, int thp
, int init_random
)
334 /* Allocate and initialize all memory on CPU#0: */
336 orig_mask
= bind_to_node(0);
340 bytes
= bytes0
+ HPSIZE
;
342 buf
= (void *)mmap(0, bytes
, PROT_READ
|PROT_WRITE
, MAP_ANON
|map_flags
, -1, 0);
343 BUG_ON(buf
== (void *)-1);
345 if (map_flags
== MAP_PRIVATE
) {
347 ret
= madvise(buf
, bytes
, MADV_HUGEPAGE
);
348 if (ret
&& !g
->print_once
) {
350 printf("WARNING: Could not enable THP - do: 'echo madvise > /sys/kernel/mm/transparent_hugepage/enabled'\n");
354 ret
= madvise(buf
, bytes
, MADV_NOHUGEPAGE
);
355 if (ret
&& !g
->print_once
) {
357 printf("WARNING: Could not disable THP: run a CONFIG_TRANSPARENT_HUGEPAGE kernel?\n");
365 /* Initialize random contents, different in each word: */
367 u64
*wbuf
= (void *)buf
;
371 for (i
= 0; i
< bytes
/8; i
++)
376 /* Align to 2MB boundary: */
377 buf
= (void *)(((unsigned long)buf
+ HPSIZE
-1) & ~(HPSIZE
-1));
379 /* Restore affinity: */
381 bind_to_cpumask(orig_mask
);
388 static void free_data(void *data
, ssize_t bytes
)
395 ret
= munmap(data
, bytes
);
400 * Create a shared memory buffer that can be shared between processes, zeroed:
402 static void * zalloc_shared_data(ssize_t bytes
)
404 return alloc_data(bytes
, MAP_SHARED
, 1, g
->p
.init_cpu0
, g
->p
.thp
, g
->p
.init_random
);
408 * Create a shared memory buffer that can be shared between processes:
410 static void * setup_shared_data(ssize_t bytes
)
412 return alloc_data(bytes
, MAP_SHARED
, 0, g
->p
.init_cpu0
, g
->p
.thp
, g
->p
.init_random
);
416 * Allocate process-local memory - this will either be shared between
417 * threads of this process, or only be accessed by this thread:
419 static void * setup_private_data(ssize_t bytes
)
421 return alloc_data(bytes
, MAP_PRIVATE
, 0, g
->p
.init_cpu0
, g
->p
.thp
, g
->p
.init_random
);
425 * Return a process-shared (global) mutex:
427 static void init_global_mutex(pthread_mutex_t
*mutex
)
429 pthread_mutexattr_t attr
;
431 pthread_mutexattr_init(&attr
);
432 pthread_mutexattr_setpshared(&attr
, PTHREAD_PROCESS_SHARED
);
433 pthread_mutex_init(mutex
, &attr
);
436 static int parse_cpu_list(const char *arg
)
438 p0
.cpu_list_str
= strdup(arg
);
440 dprintf("got CPU list: {%s}\n", p0
.cpu_list_str
);
445 static int parse_setup_cpu_list(void)
447 struct thread_data
*td
;
451 if (!g
->p
.cpu_list_str
)
454 dprintf("g->p.nr_tasks: %d\n", g
->p
.nr_tasks
);
456 str0
= str
= strdup(g
->p
.cpu_list_str
);
461 tprintf("# binding tasks to CPUs:\n");
465 int bind_cpu
, bind_cpu_0
, bind_cpu_1
;
466 char *tok
, *tok_end
, *tok_step
, *tok_len
, *tok_mul
;
471 tok
= strsep(&str
, ",");
475 tok_end
= strstr(tok
, "-");
477 dprintf("\ntoken: {%s}, end: {%s}\n", tok
, tok_end
);
479 /* Single CPU specified: */
480 bind_cpu_0
= bind_cpu_1
= atol(tok
);
482 /* CPU range specified (for example: "5-11"): */
483 bind_cpu_0
= atol(tok
);
484 bind_cpu_1
= atol(tok_end
+ 1);
488 tok_step
= strstr(tok
, "#");
490 step
= atol(tok_step
+ 1);
491 BUG_ON(step
<= 0 || step
>= g
->p
.nr_cpus
);
496 * Eg: "--cpus 8_4-16#4" means: '--cpus 8_4,12_4,16_4',
497 * where the _4 means the next 4 CPUs are allowed.
500 tok_len
= strstr(tok
, "_");
502 bind_len
= atol(tok_len
+ 1);
503 BUG_ON(bind_len
<= 0 || bind_len
> g
->p
.nr_cpus
);
506 /* Multiplicator shortcut, "0x8" is a shortcut for: "0,0,0,0,0,0,0,0" */
508 tok_mul
= strstr(tok
, "x");
510 mul
= atol(tok_mul
+ 1);
514 dprintf("CPUs: %d_%d-%d#%dx%d\n", bind_cpu_0
, bind_len
, bind_cpu_1
, step
, mul
);
516 if (bind_cpu_0
>= g
->p
.nr_cpus
|| bind_cpu_1
>= g
->p
.nr_cpus
) {
517 printf("\nTest not applicable, system has only %d CPUs.\n", g
->p
.nr_cpus
);
521 BUG_ON(bind_cpu_0
< 0 || bind_cpu_1
< 0);
522 BUG_ON(bind_cpu_0
> bind_cpu_1
);
524 for (bind_cpu
= bind_cpu_0
; bind_cpu
<= bind_cpu_1
; bind_cpu
+= step
) {
527 for (i
= 0; i
< mul
; i
++) {
530 if (t
>= g
->p
.nr_tasks
) {
531 printf("\n# NOTE: ignoring bind CPUs starting at CPU#%d\n #", bind_cpu
);
539 tprintf("%2d/%d", bind_cpu
, bind_len
);
541 tprintf("%2d", bind_cpu
);
544 CPU_ZERO(&td
->bind_cpumask
);
545 for (cpu
= bind_cpu
; cpu
< bind_cpu
+bind_len
; cpu
++) {
546 BUG_ON(cpu
< 0 || cpu
>= g
->p
.nr_cpus
);
547 CPU_SET(cpu
, &td
->bind_cpumask
);
557 if (t
< g
->p
.nr_tasks
)
558 printf("# NOTE: %d tasks bound, %d tasks unbound\n", t
, g
->p
.nr_tasks
- t
);
564 static int parse_cpus_opt(const struct option
*opt __maybe_unused
,
565 const char *arg
, int unset __maybe_unused
)
570 return parse_cpu_list(arg
);
573 static int parse_node_list(const char *arg
)
575 p0
.node_list_str
= strdup(arg
);
577 dprintf("got NODE list: {%s}\n", p0
.node_list_str
);
582 static int parse_setup_node_list(void)
584 struct thread_data
*td
;
588 if (!g
->p
.node_list_str
)
591 dprintf("g->p.nr_tasks: %d\n", g
->p
.nr_tasks
);
593 str0
= str
= strdup(g
->p
.node_list_str
);
598 tprintf("# binding tasks to NODEs:\n");
602 int bind_node
, bind_node_0
, bind_node_1
;
603 char *tok
, *tok_end
, *tok_step
, *tok_mul
;
607 tok
= strsep(&str
, ",");
611 tok_end
= strstr(tok
, "-");
613 dprintf("\ntoken: {%s}, end: {%s}\n", tok
, tok_end
);
615 /* Single NODE specified: */
616 bind_node_0
= bind_node_1
= atol(tok
);
618 /* NODE range specified (for example: "5-11"): */
619 bind_node_0
= atol(tok
);
620 bind_node_1
= atol(tok_end
+ 1);
624 tok_step
= strstr(tok
, "#");
626 step
= atol(tok_step
+ 1);
627 BUG_ON(step
<= 0 || step
>= g
->p
.nr_nodes
);
630 /* Multiplicator shortcut, "0x8" is a shortcut for: "0,0,0,0,0,0,0,0" */
632 tok_mul
= strstr(tok
, "x");
634 mul
= atol(tok_mul
+ 1);
638 dprintf("NODEs: %d-%d #%d\n", bind_node_0
, bind_node_1
, step
);
640 if (bind_node_0
>= g
->p
.nr_nodes
|| bind_node_1
>= g
->p
.nr_nodes
) {
641 printf("\nTest not applicable, system has only %d nodes.\n", g
->p
.nr_nodes
);
645 BUG_ON(bind_node_0
< 0 || bind_node_1
< 0);
646 BUG_ON(bind_node_0
> bind_node_1
);
648 for (bind_node
= bind_node_0
; bind_node
<= bind_node_1
; bind_node
+= step
) {
651 for (i
= 0; i
< mul
; i
++) {
652 if (t
>= g
->p
.nr_tasks
) {
653 printf("\n# NOTE: ignoring bind NODEs starting at NODE#%d\n", bind_node
);
659 tprintf(" %2d", bind_node
);
661 tprintf(",%2d", bind_node
);
663 td
->bind_node
= bind_node
;
672 if (t
< g
->p
.nr_tasks
)
673 printf("# NOTE: %d tasks mem-bound, %d tasks unbound\n", t
, g
->p
.nr_tasks
- t
);
679 static int parse_nodes_opt(const struct option
*opt __maybe_unused
,
680 const char *arg
, int unset __maybe_unused
)
685 return parse_node_list(arg
);
690 #define BIT(x) (1ul << x)
692 static inline uint32_t lfsr_32(uint32_t lfsr
)
694 const uint32_t taps
= BIT(1) | BIT(5) | BIT(6) | BIT(31);
695 return (lfsr
>>1) ^ ((0x0u
- (lfsr
& 0x1u
)) & taps
);
699 * Make sure there's real data dependency to RAM (when read
700 * accesses are enabled), so the compiler, the CPU and the
701 * kernel (KSM, zero page, etc.) cannot optimize away RAM
704 static inline u64
access_data(u64
*data
, u64 val
)
708 if (g
->p
.data_writes
)
714 * The worker process does two types of work, a forwards going
715 * loop and a backwards going loop.
717 * We do this so that on multiprocessor systems we do not create
718 * a 'train' of processing, with highly synchronized processes,
719 * skewing the whole benchmark.
721 static u64
do_work(u8
*__data
, long bytes
, int nr
, int nr_max
, int loop
, u64 val
)
723 long words
= bytes
/sizeof(u64
);
724 u64
*data
= (void *)__data
;
725 long chunk_0
, chunk_1
;
730 BUG_ON(!data
&& words
);
731 BUG_ON(data
&& !words
);
736 /* Very simple memset() work variant: */
737 if (g
->p
.data_zero_memset
&& !g
->p
.data_rand_walk
) {
742 /* Spread out by PID/TID nr and by loop nr: */
743 chunk_0
= words
/nr_max
;
744 chunk_1
= words
/g
->p
.nr_loops
;
745 off
= nr
*chunk_0
+ loop
*chunk_1
;
750 if (g
->p
.data_rand_walk
) {
751 u32 lfsr
= nr
+ loop
+ val
;
754 for (i
= 0; i
< words
/1024; i
++) {
757 lfsr
= lfsr_32(lfsr
);
759 start
= lfsr
% words
;
760 end
= min(start
+ 1024, words
-1);
762 if (g
->p
.data_zero_memset
) {
763 bzero(data
+ start
, (end
-start
) * sizeof(u64
));
765 for (j
= start
; j
< end
; j
++)
766 val
= access_data(data
+ j
, val
);
769 } else if (!g
->p
.data_backwards
|| (nr
+ loop
) & 1) {
775 /* Process data forwards: */
777 if (unlikely(d
>= d1
))
779 if (unlikely(d
== d0
))
782 val
= access_data(d
, val
);
787 /* Process data backwards: */
793 /* Process data forwards: */
795 if (unlikely(d
< data
))
797 if (unlikely(d
== d0
))
800 val
= access_data(d
, val
);
809 static void update_curr_cpu(int task_nr
, unsigned long bytes_worked
)
813 cpu
= sched_getcpu();
815 g
->threads
[task_nr
].curr_cpu
= cpu
;
816 prctl(0, bytes_worked
);
819 #define MAX_NR_NODES 64
822 * Count the number of nodes a process's threads
825 * A count of 1 means that the process is compressed
826 * to a single node. A count of g->p.nr_nodes means it's
827 * spread out on the whole system.
829 static int count_process_nodes(int process_nr
)
831 char node_present
[MAX_NR_NODES
] = { 0, };
835 for (t
= 0; t
< g
->p
.nr_threads
; t
++) {
836 struct thread_data
*td
;
840 task_nr
= process_nr
*g
->p
.nr_threads
+ t
;
841 td
= g
->threads
+ task_nr
;
843 node
= numa_node_of_cpu(td
->curr_cpu
);
844 if (node
< 0) /* curr_cpu was likely still -1 */
847 node_present
[node
] = 1;
852 for (n
= 0; n
< MAX_NR_NODES
; n
++)
853 nodes
+= node_present
[n
];
859 * Count the number of distinct process-threads a node contains.
861 * A count of 1 means that the node contains only a single
862 * process. If all nodes on the system contain at most one
863 * process then we are well-converged.
865 static int count_node_processes(int node
)
870 for (p
= 0; p
< g
->p
.nr_proc
; p
++) {
871 for (t
= 0; t
< g
->p
.nr_threads
; t
++) {
872 struct thread_data
*td
;
876 task_nr
= p
*g
->p
.nr_threads
+ t
;
877 td
= g
->threads
+ task_nr
;
879 n
= numa_node_of_cpu(td
->curr_cpu
);
890 static void calc_convergence_compression(int *strong
)
892 unsigned int nodes_min
, nodes_max
;
898 for (p
= 0; p
< g
->p
.nr_proc
; p
++) {
899 unsigned int nodes
= count_process_nodes(p
);
906 nodes_min
= min(nodes
, nodes_min
);
907 nodes_max
= max(nodes
, nodes_max
);
910 /* Strong convergence: all threads compress on a single node: */
911 if (nodes_min
== 1 && nodes_max
== 1) {
915 tprintf(" {%d-%d}", nodes_min
, nodes_max
);
919 static void calc_convergence(double runtime_ns_max
, double *convergence
)
921 unsigned int loops_done_min
, loops_done_max
;
923 int nodes
[MAX_NR_NODES
];
934 if (!g
->p
.show_convergence
&& !g
->p
.measure_convergence
)
937 for (node
= 0; node
< g
->p
.nr_nodes
; node
++)
943 for (t
= 0; t
< g
->p
.nr_tasks
; t
++) {
944 struct thread_data
*td
= g
->threads
+ t
;
945 unsigned int loops_done
;
949 /* Not all threads have written it yet: */
953 node
= numa_node_of_cpu(cpu
);
957 loops_done
= td
->loops_done
;
958 loops_done_min
= min(loops_done
, loops_done_min
);
959 loops_done_max
= max(loops_done
, loops_done_max
);
963 nr_min
= g
->p
.nr_tasks
;
966 for (node
= 0; node
< g
->p
.nr_nodes
; node
++) {
968 nr_min
= min(nr
, nr_min
);
969 nr_max
= max(nr
, nr_max
);
972 BUG_ON(nr_min
> nr_max
);
974 BUG_ON(sum
> g
->p
.nr_tasks
);
976 if (0 && (sum
< g
->p
.nr_tasks
))
980 * Count the number of distinct process groups present
981 * on nodes - when we are converged this will decrease
986 for (node
= 0; node
< g
->p
.nr_nodes
; node
++) {
987 int processes
= count_node_processes(node
);
990 tprintf(" %2d/%-2d", nr
, processes
);
992 process_groups
+= processes
;
995 distance
= nr_max
- nr_min
;
997 tprintf(" [%2d/%-2d]", distance
, process_groups
);
999 tprintf(" l:%3d-%-3d (%3d)",
1000 loops_done_min
, loops_done_max
, loops_done_max
-loops_done_min
);
1002 if (loops_done_min
&& loops_done_max
) {
1003 double skew
= 1.0 - (double)loops_done_min
/loops_done_max
;
1005 tprintf(" [%4.1f%%]", skew
* 100.0);
1008 calc_convergence_compression(&strong
);
1010 if (strong
&& process_groups
== g
->p
.nr_proc
) {
1011 if (!*convergence
) {
1012 *convergence
= runtime_ns_max
;
1013 tprintf(" (%6.1fs converged)\n", *convergence
/ NSEC_PER_SEC
);
1014 if (g
->p
.measure_convergence
) {
1015 g
->all_converged
= true;
1016 g
->stop_work
= true;
1021 tprintf(" (%6.1fs de-converged)", runtime_ns_max
/ NSEC_PER_SEC
);
1028 static void show_summary(double runtime_ns_max
, int l
, double *convergence
)
1030 tprintf("\r # %5.1f%% [%.1f mins]",
1031 (double)(l
+1)/g
->p
.nr_loops
*100.0, runtime_ns_max
/ NSEC_PER_SEC
/ 60.0);
1033 calc_convergence(runtime_ns_max
, convergence
);
1035 if (g
->p
.show_details
>= 0)
1039 static void *worker_thread(void *__tdata
)
1041 struct thread_data
*td
= __tdata
;
1042 struct timeval start0
, start
, stop
, diff
;
1043 int process_nr
= td
->process_nr
;
1044 int thread_nr
= td
->thread_nr
;
1045 unsigned long last_perturbance
;
1046 int task_nr
= td
->task_nr
;
1047 int details
= g
->p
.show_details
;
1048 int first_task
, last_task
;
1049 double convergence
= 0;
1051 double runtime_ns_max
;
1058 struct rusage rusage
;
1060 bind_to_cpumask(td
->bind_cpumask
);
1061 bind_to_memnode(td
->bind_node
);
1063 set_taskname("thread %d/%d", process_nr
, thread_nr
);
1065 global_data
= g
->data
;
1066 process_data
= td
->process_data
;
1067 thread_data
= setup_private_data(g
->p
.bytes_thread
);
1072 if (process_nr
== g
->p
.nr_proc
-1 && thread_nr
== g
->p
.nr_threads
-1)
1076 if (process_nr
== 0 && thread_nr
== 0)
1080 printf("# thread %2d / %2d global mem: %p, process mem: %p, thread mem: %p\n",
1081 process_nr
, thread_nr
, global_data
, process_data
, thread_data
);
1084 if (g
->p
.serialize_startup
) {
1085 pthread_mutex_lock(&g
->startup_mutex
);
1086 g
->nr_tasks_started
++;
1087 pthread_mutex_unlock(&g
->startup_mutex
);
1089 /* Here we will wait for the main process to start us all at once: */
1090 pthread_mutex_lock(&g
->start_work_mutex
);
1091 g
->nr_tasks_working
++;
1093 /* Last one wake the main process: */
1094 if (g
->nr_tasks_working
== g
->p
.nr_tasks
)
1095 pthread_mutex_unlock(&g
->startup_done_mutex
);
1097 pthread_mutex_unlock(&g
->start_work_mutex
);
1100 gettimeofday(&start0
, NULL
);
1102 start
= stop
= start0
;
1103 last_perturbance
= start
.tv_sec
;
1105 for (l
= 0; l
< g
->p
.nr_loops
; l
++) {
1111 val
+= do_work(global_data
, g
->p
.bytes_global
, process_nr
, g
->p
.nr_proc
, l
, val
);
1112 val
+= do_work(process_data
, g
->p
.bytes_process
, thread_nr
, g
->p
.nr_threads
, l
, val
);
1113 val
+= do_work(thread_data
, g
->p
.bytes_thread
, 0, 1, l
, val
);
1115 if (g
->p
.sleep_usecs
) {
1116 pthread_mutex_lock(td
->process_lock
);
1117 usleep(g
->p
.sleep_usecs
);
1118 pthread_mutex_unlock(td
->process_lock
);
1121 * Amount of work to be done under a process-global lock:
1123 if (g
->p
.bytes_process_locked
) {
1124 pthread_mutex_lock(td
->process_lock
);
1125 val
+= do_work(process_data
, g
->p
.bytes_process_locked
, thread_nr
, g
->p
.nr_threads
, l
, val
);
1126 pthread_mutex_unlock(td
->process_lock
);
1129 work_done
= g
->p
.bytes_global
+ g
->p
.bytes_process
+
1130 g
->p
.bytes_process_locked
+ g
->p
.bytes_thread
;
1132 update_curr_cpu(task_nr
, work_done
);
1133 bytes_done
+= work_done
;
1135 if (details
< 0 && !g
->p
.perturb_secs
&& !g
->p
.measure_convergence
&& !g
->p
.nr_secs
)
1140 gettimeofday(&stop
, NULL
);
1142 /* Check whether our max runtime timed out: */
1144 timersub(&stop
, &start0
, &diff
);
1145 if ((u32
)diff
.tv_sec
>= g
->p
.nr_secs
) {
1146 g
->stop_work
= true;
1151 /* Update the summary at most once per second: */
1152 if (start
.tv_sec
== stop
.tv_sec
)
1156 * Perturb the first task's equilibrium every g->p.perturb_secs seconds,
1157 * by migrating to CPU#0:
1159 if (first_task
&& g
->p
.perturb_secs
&& (int)(stop
.tv_sec
- last_perturbance
) >= g
->p
.perturb_secs
) {
1160 cpu_set_t orig_mask
;
1164 last_perturbance
= stop
.tv_sec
;
1167 * Depending on where we are running, move into
1168 * the other half of the system, to create some
1171 this_cpu
= g
->threads
[task_nr
].curr_cpu
;
1172 if (this_cpu
< g
->p
.nr_cpus
/2)
1173 target_cpu
= g
->p
.nr_cpus
-1;
1177 orig_mask
= bind_to_cpu(target_cpu
);
1179 /* Here we are running on the target CPU already */
1181 printf(" (injecting perturbalance, moved to CPU#%d)\n", target_cpu
);
1183 bind_to_cpumask(orig_mask
);
1187 timersub(&stop
, &start
, &diff
);
1188 runtime_ns_max
= diff
.tv_sec
* NSEC_PER_SEC
;
1189 runtime_ns_max
+= diff
.tv_usec
* NSEC_PER_USEC
;
1192 printf(" #%2d / %2d: %14.2lf nsecs/op [val: %016"PRIx64
"]\n",
1193 process_nr
, thread_nr
, runtime_ns_max
/ bytes_done
, val
);
1200 timersub(&stop
, &start0
, &diff
);
1201 runtime_ns_max
= diff
.tv_sec
* NSEC_PER_SEC
;
1202 runtime_ns_max
+= diff
.tv_usec
* NSEC_PER_USEC
;
1204 show_summary(runtime_ns_max
, l
, &convergence
);
1207 gettimeofday(&stop
, NULL
);
1208 timersub(&stop
, &start0
, &diff
);
1209 td
->runtime_ns
= diff
.tv_sec
* NSEC_PER_SEC
;
1210 td
->runtime_ns
+= diff
.tv_usec
* NSEC_PER_USEC
;
1211 td
->speed_gbs
= bytes_done
/ (td
->runtime_ns
/ NSEC_PER_SEC
) / 1e9
;
1213 getrusage(RUSAGE_THREAD
, &rusage
);
1214 td
->system_time_ns
= rusage
.ru_stime
.tv_sec
* NSEC_PER_SEC
;
1215 td
->system_time_ns
+= rusage
.ru_stime
.tv_usec
* NSEC_PER_USEC
;
1216 td
->user_time_ns
= rusage
.ru_utime
.tv_sec
* NSEC_PER_SEC
;
1217 td
->user_time_ns
+= rusage
.ru_utime
.tv_usec
* NSEC_PER_USEC
;
1219 free_data(thread_data
, g
->p
.bytes_thread
);
1221 pthread_mutex_lock(&g
->stop_work_mutex
);
1222 g
->bytes_done
+= bytes_done
;
1223 pthread_mutex_unlock(&g
->stop_work_mutex
);
1229 * A worker process starts a couple of threads:
1231 static void worker_process(int process_nr
)
1233 pthread_mutex_t process_lock
;
1234 struct thread_data
*td
;
1235 pthread_t
*pthreads
;
1241 pthread_mutex_init(&process_lock
, NULL
);
1242 set_taskname("process %d", process_nr
);
1245 * Pick up the memory policy and the CPU binding of our first thread,
1246 * so that we initialize memory accordingly:
1248 task_nr
= process_nr
*g
->p
.nr_threads
;
1249 td
= g
->threads
+ task_nr
;
1251 bind_to_memnode(td
->bind_node
);
1252 bind_to_cpumask(td
->bind_cpumask
);
1254 pthreads
= zalloc(g
->p
.nr_threads
* sizeof(pthread_t
));
1255 process_data
= setup_private_data(g
->p
.bytes_process
);
1257 if (g
->p
.show_details
>= 3) {
1258 printf(" # process %2d global mem: %p, process mem: %p\n",
1259 process_nr
, g
->data
, process_data
);
1262 for (t
= 0; t
< g
->p
.nr_threads
; t
++) {
1263 task_nr
= process_nr
*g
->p
.nr_threads
+ t
;
1264 td
= g
->threads
+ task_nr
;
1266 td
->process_data
= process_data
;
1267 td
->process_nr
= process_nr
;
1269 td
->task_nr
= task_nr
;
1272 td
->process_lock
= &process_lock
;
1274 ret
= pthread_create(pthreads
+ t
, NULL
, worker_thread
, td
);
1278 for (t
= 0; t
< g
->p
.nr_threads
; t
++) {
1279 ret
= pthread_join(pthreads
[t
], NULL
);
1283 free_data(process_data
, g
->p
.bytes_process
);
1287 static void print_summary(void)
1289 if (g
->p
.show_details
< 0)
1293 printf(" # %d %s will execute (on %d nodes, %d CPUs):\n",
1294 g
->p
.nr_tasks
, g
->p
.nr_tasks
== 1 ? "task" : "tasks", g
->p
.nr_nodes
, g
->p
.nr_cpus
);
1295 printf(" # %5dx %5ldMB global shared mem operations\n",
1296 g
->p
.nr_loops
, g
->p
.bytes_global
/1024/1024);
1297 printf(" # %5dx %5ldMB process shared mem operations\n",
1298 g
->p
.nr_loops
, g
->p
.bytes_process
/1024/1024);
1299 printf(" # %5dx %5ldMB thread local mem operations\n",
1300 g
->p
.nr_loops
, g
->p
.bytes_thread
/1024/1024);
1304 printf("\n ###\n"); fflush(stdout
);
1307 static void init_thread_data(void)
1309 ssize_t size
= sizeof(*g
->threads
)*g
->p
.nr_tasks
;
1312 g
->threads
= zalloc_shared_data(size
);
1314 for (t
= 0; t
< g
->p
.nr_tasks
; t
++) {
1315 struct thread_data
*td
= g
->threads
+ t
;
1318 /* Allow all nodes by default: */
1321 /* Allow all CPUs by default: */
1322 CPU_ZERO(&td
->bind_cpumask
);
1323 for (cpu
= 0; cpu
< g
->p
.nr_cpus
; cpu
++)
1324 CPU_SET(cpu
, &td
->bind_cpumask
);
1328 static void deinit_thread_data(void)
1330 ssize_t size
= sizeof(*g
->threads
)*g
->p
.nr_tasks
;
1332 free_data(g
->threads
, size
);
1335 static int init(void)
1337 g
= (void *)alloc_data(sizeof(*g
), MAP_SHARED
, 1, 0, 0 /* THP */, 0);
1339 /* Copy over options: */
1342 g
->p
.nr_cpus
= numa_num_configured_cpus();
1344 g
->p
.nr_nodes
= numa_max_node() + 1;
1346 /* char array in count_process_nodes(): */
1347 BUG_ON(g
->p
.nr_nodes
> MAX_NR_NODES
|| g
->p
.nr_nodes
< 0);
1349 if (g
->p
.show_quiet
&& !g
->p
.show_details
)
1350 g
->p
.show_details
= -1;
1352 /* Some memory should be specified: */
1353 if (!g
->p
.mb_global_str
&& !g
->p
.mb_proc_str
&& !g
->p
.mb_thread_str
)
1356 if (g
->p
.mb_global_str
) {
1357 g
->p
.mb_global
= atof(g
->p
.mb_global_str
);
1358 BUG_ON(g
->p
.mb_global
< 0);
1361 if (g
->p
.mb_proc_str
) {
1362 g
->p
.mb_proc
= atof(g
->p
.mb_proc_str
);
1363 BUG_ON(g
->p
.mb_proc
< 0);
1366 if (g
->p
.mb_proc_locked_str
) {
1367 g
->p
.mb_proc_locked
= atof(g
->p
.mb_proc_locked_str
);
1368 BUG_ON(g
->p
.mb_proc_locked
< 0);
1369 BUG_ON(g
->p
.mb_proc_locked
> g
->p
.mb_proc
);
1372 if (g
->p
.mb_thread_str
) {
1373 g
->p
.mb_thread
= atof(g
->p
.mb_thread_str
);
1374 BUG_ON(g
->p
.mb_thread
< 0);
1377 BUG_ON(g
->p
.nr_threads
<= 0);
1378 BUG_ON(g
->p
.nr_proc
<= 0);
1380 g
->p
.nr_tasks
= g
->p
.nr_proc
*g
->p
.nr_threads
;
1382 g
->p
.bytes_global
= g
->p
.mb_global
*1024L*1024L;
1383 g
->p
.bytes_process
= g
->p
.mb_proc
*1024L*1024L;
1384 g
->p
.bytes_process_locked
= g
->p
.mb_proc_locked
*1024L*1024L;
1385 g
->p
.bytes_thread
= g
->p
.mb_thread
*1024L*1024L;
1387 g
->data
= setup_shared_data(g
->p
.bytes_global
);
1389 /* Startup serialization: */
1390 init_global_mutex(&g
->start_work_mutex
);
1391 init_global_mutex(&g
->startup_mutex
);
1392 init_global_mutex(&g
->startup_done_mutex
);
1393 init_global_mutex(&g
->stop_work_mutex
);
1398 if (parse_setup_cpu_list() || parse_setup_node_list())
1407 static void deinit(void)
1409 free_data(g
->data
, g
->p
.bytes_global
);
1412 deinit_thread_data();
1414 free_data(g
, sizeof(*g
));
1419 * Print a short or long result, depending on the verbosity setting:
1421 static void print_res(const char *name
, double val
,
1422 const char *txt_unit
, const char *txt_short
, const char *txt_long
)
1427 if (!g
->p
.show_quiet
)
1428 printf(" %-30s %15.3f, %-15s %s\n", name
, val
, txt_unit
, txt_short
);
1430 printf(" %14.3f %s\n", val
, txt_long
);
1433 static int __bench_numa(const char *name
)
1435 struct timeval start
, stop
, diff
;
1436 u64 runtime_ns_min
, runtime_ns_sum
;
1437 pid_t
*pids
, pid
, wpid
;
1438 double delta_runtime
;
1440 double runtime_sec_max
;
1441 double runtime_sec_min
;
1449 pids
= zalloc(g
->p
.nr_proc
* sizeof(*pids
));
1452 /* All threads try to acquire it, this way we can wait for them to start up: */
1453 pthread_mutex_lock(&g
->start_work_mutex
);
1455 if (g
->p
.serialize_startup
) {
1457 tprintf(" # Startup synchronization: ..."); fflush(stdout
);
1460 gettimeofday(&start
, NULL
);
1462 for (i
= 0; i
< g
->p
.nr_proc
; i
++) {
1464 dprintf(" # process %2d: PID %d\n", i
, pid
);
1468 /* Child process: */
1476 /* Wait for all the threads to start up: */
1477 while (g
->nr_tasks_started
!= g
->p
.nr_tasks
)
1478 usleep(USEC_PER_MSEC
);
1480 BUG_ON(g
->nr_tasks_started
!= g
->p
.nr_tasks
);
1482 if (g
->p
.serialize_startup
) {
1485 pthread_mutex_lock(&g
->startup_done_mutex
);
1487 /* This will start all threads: */
1488 pthread_mutex_unlock(&g
->start_work_mutex
);
1490 /* This mutex is locked - the last started thread will wake us: */
1491 pthread_mutex_lock(&g
->startup_done_mutex
);
1493 gettimeofday(&stop
, NULL
);
1495 timersub(&stop
, &start
, &diff
);
1497 startup_sec
= diff
.tv_sec
* NSEC_PER_SEC
;
1498 startup_sec
+= diff
.tv_usec
* NSEC_PER_USEC
;
1499 startup_sec
/= NSEC_PER_SEC
;
1501 tprintf(" threads initialized in %.6f seconds.\n", startup_sec
);
1505 pthread_mutex_unlock(&g
->startup_done_mutex
);
1507 gettimeofday(&start
, NULL
);
1510 /* Parent process: */
1513 for (i
= 0; i
< g
->p
.nr_proc
; i
++) {
1514 wpid
= waitpid(pids
[i
], &wait_stat
, 0);
1516 BUG_ON(!WIFEXITED(wait_stat
));
1521 runtime_ns_min
= -1LL;
1523 for (t
= 0; t
< g
->p
.nr_tasks
; t
++) {
1524 u64 thread_runtime_ns
= g
->threads
[t
].runtime_ns
;
1526 runtime_ns_sum
+= thread_runtime_ns
;
1527 runtime_ns_min
= min(thread_runtime_ns
, runtime_ns_min
);
1530 gettimeofday(&stop
, NULL
);
1531 timersub(&stop
, &start
, &diff
);
1533 BUG_ON(bench_format
!= BENCH_FORMAT_DEFAULT
);
1535 tprintf("\n ###\n");
1538 runtime_sec_max
= diff
.tv_sec
* NSEC_PER_SEC
;
1539 runtime_sec_max
+= diff
.tv_usec
* NSEC_PER_USEC
;
1540 runtime_sec_max
/= NSEC_PER_SEC
;
1542 runtime_sec_min
= runtime_ns_min
/ NSEC_PER_SEC
;
1544 bytes
= g
->bytes_done
;
1545 runtime_avg
= (double)runtime_ns_sum
/ g
->p
.nr_tasks
/ NSEC_PER_SEC
;
1547 if (g
->p
.measure_convergence
) {
1548 print_res(name
, runtime_sec_max
,
1549 "secs,", "NUMA-convergence-latency", "secs latency to NUMA-converge");
1552 print_res(name
, runtime_sec_max
,
1553 "secs,", "runtime-max/thread", "secs slowest (max) thread-runtime");
1555 print_res(name
, runtime_sec_min
,
1556 "secs,", "runtime-min/thread", "secs fastest (min) thread-runtime");
1558 print_res(name
, runtime_avg
,
1559 "secs,", "runtime-avg/thread", "secs average thread-runtime");
1561 delta_runtime
= (runtime_sec_max
- runtime_sec_min
)/2.0;
1562 print_res(name
, delta_runtime
/ runtime_sec_max
* 100.0,
1563 "%,", "spread-runtime/thread", "% difference between max/avg runtime");
1565 print_res(name
, bytes
/ g
->p
.nr_tasks
/ 1e9
,
1566 "GB,", "data/thread", "GB data processed, per thread");
1568 print_res(name
, bytes
/ 1e9
,
1569 "GB,", "data-total", "GB data processed, total");
1571 print_res(name
, runtime_sec_max
* NSEC_PER_SEC
/ (bytes
/ g
->p
.nr_tasks
),
1572 "nsecs,", "runtime/byte/thread","nsecs/byte/thread runtime");
1574 print_res(name
, bytes
/ g
->p
.nr_tasks
/ 1e9
/ runtime_sec_max
,
1575 "GB/sec,", "thread-speed", "GB/sec/thread speed");
1577 print_res(name
, bytes
/ runtime_sec_max
/ 1e9
,
1578 "GB/sec,", "total-speed", "GB/sec total speed");
1580 if (g
->p
.show_details
>= 2) {
1581 char tname
[14 + 2 * 10 + 1];
1582 struct thread_data
*td
;
1583 for (p
= 0; p
< g
->p
.nr_proc
; p
++) {
1584 for (t
= 0; t
< g
->p
.nr_threads
; t
++) {
1585 memset(tname
, 0, sizeof(tname
));
1586 td
= g
->threads
+ p
*g
->p
.nr_threads
+ t
;
1587 snprintf(tname
, sizeof(tname
), "process%d:thread%d", p
, t
);
1588 print_res(tname
, td
->speed_gbs
,
1589 "GB/sec", "thread-speed", "GB/sec/thread speed");
1590 print_res(tname
, td
->system_time_ns
/ NSEC_PER_SEC
,
1591 "secs", "thread-system-time", "system CPU time/thread");
1592 print_res(tname
, td
->user_time_ns
/ NSEC_PER_SEC
,
1593 "secs", "thread-user-time", "user CPU time/thread");
1607 static int command_size(const char **argv
)
1616 BUG_ON(size
>= MAX_ARGS
);
1621 static void init_params(struct params
*p
, const char *name
, int argc
, const char **argv
)
1625 printf("\n # Running %s \"perf bench numa", name
);
1627 for (i
= 0; i
< argc
; i
++)
1628 printf(" %s", argv
[i
]);
1632 memset(p
, 0, sizeof(*p
));
1634 /* Initialize nonzero defaults: */
1636 p
->serialize_startup
= 1;
1637 p
->data_reads
= true;
1638 p
->data_writes
= true;
1639 p
->data_backwards
= true;
1640 p
->data_rand_walk
= true;
1642 p
->init_random
= true;
1643 p
->mb_global_str
= "1";
1647 p
->run_all
= argc
== 1;
1650 static int run_bench_numa(const char *name
, const char **argv
)
1652 int argc
= command_size(argv
);
1654 init_params(&p0
, name
, argc
, argv
);
1655 argc
= parse_options(argc
, argv
, options
, bench_numa_usage
, 0);
1659 if (__bench_numa(name
))
1668 #define OPT_BW_RAM "-s", "20", "-zZq", "--thp", " 1", "--no-data_rand_walk"
1669 #define OPT_BW_RAM_NOTHP OPT_BW_RAM, "--thp", "-1"
1671 #define OPT_CONV "-s", "100", "-zZ0qcm", "--thp", " 1"
1672 #define OPT_CONV_NOTHP OPT_CONV, "--thp", "-1"
1674 #define OPT_BW "-s", "20", "-zZ0q", "--thp", " 1"
1675 #define OPT_BW_NOTHP OPT_BW, "--thp", "-1"
1678 * The built-in test-suite executed by "perf bench numa -a".
1680 * (A minimum of 4 nodes and 16 GB of RAM is recommended.)
1682 static const char *tests
[][MAX_ARGS
] = {
1683 /* Basic single-stream NUMA bandwidth measurements: */
1684 { "RAM-bw-local,", "mem", "-p", "1", "-t", "1", "-P", "1024",
1685 "-C" , "0", "-M", "0", OPT_BW_RAM
},
1686 { "RAM-bw-local-NOTHP,",
1687 "mem", "-p", "1", "-t", "1", "-P", "1024",
1688 "-C" , "0", "-M", "0", OPT_BW_RAM_NOTHP
},
1689 { "RAM-bw-remote,", "mem", "-p", "1", "-t", "1", "-P", "1024",
1690 "-C" , "0", "-M", "1", OPT_BW_RAM
},
1692 /* 2-stream NUMA bandwidth measurements: */
1693 { "RAM-bw-local-2x,", "mem", "-p", "2", "-t", "1", "-P", "1024",
1694 "-C", "0,2", "-M", "0x2", OPT_BW_RAM
},
1695 { "RAM-bw-remote-2x,", "mem", "-p", "2", "-t", "1", "-P", "1024",
1696 "-C", "0,2", "-M", "1x2", OPT_BW_RAM
},
1698 /* Cross-stream NUMA bandwidth measurement: */
1699 { "RAM-bw-cross,", "mem", "-p", "2", "-t", "1", "-P", "1024",
1700 "-C", "0,8", "-M", "1,0", OPT_BW_RAM
},
1702 /* Convergence latency measurements: */
1703 { " 1x3-convergence,", "mem", "-p", "1", "-t", "3", "-P", "512", OPT_CONV
},
1704 { " 1x4-convergence,", "mem", "-p", "1", "-t", "4", "-P", "512", OPT_CONV
},
1705 { " 1x6-convergence,", "mem", "-p", "1", "-t", "6", "-P", "1020", OPT_CONV
},
1706 { " 2x3-convergence,", "mem", "-p", "3", "-t", "3", "-P", "1020", OPT_CONV
},
1707 { " 3x3-convergence,", "mem", "-p", "3", "-t", "3", "-P", "1020", OPT_CONV
},
1708 { " 4x4-convergence,", "mem", "-p", "4", "-t", "4", "-P", "512", OPT_CONV
},
1709 { " 4x4-convergence-NOTHP,",
1710 "mem", "-p", "4", "-t", "4", "-P", "512", OPT_CONV_NOTHP
},
1711 { " 4x6-convergence,", "mem", "-p", "4", "-t", "6", "-P", "1020", OPT_CONV
},
1712 { " 4x8-convergence,", "mem", "-p", "4", "-t", "8", "-P", "512", OPT_CONV
},
1713 { " 8x4-convergence,", "mem", "-p", "8", "-t", "4", "-P", "512", OPT_CONV
},
1714 { " 8x4-convergence-NOTHP,",
1715 "mem", "-p", "8", "-t", "4", "-P", "512", OPT_CONV_NOTHP
},
1716 { " 3x1-convergence,", "mem", "-p", "3", "-t", "1", "-P", "512", OPT_CONV
},
1717 { " 4x1-convergence,", "mem", "-p", "4", "-t", "1", "-P", "512", OPT_CONV
},
1718 { " 8x1-convergence,", "mem", "-p", "8", "-t", "1", "-P", "512", OPT_CONV
},
1719 { "16x1-convergence,", "mem", "-p", "16", "-t", "1", "-P", "256", OPT_CONV
},
1720 { "32x1-convergence,", "mem", "-p", "32", "-t", "1", "-P", "128", OPT_CONV
},
1722 /* Various NUMA process/thread layout bandwidth measurements: */
1723 { " 2x1-bw-process,", "mem", "-p", "2", "-t", "1", "-P", "1024", OPT_BW
},
1724 { " 3x1-bw-process,", "mem", "-p", "3", "-t", "1", "-P", "1024", OPT_BW
},
1725 { " 4x1-bw-process,", "mem", "-p", "4", "-t", "1", "-P", "1024", OPT_BW
},
1726 { " 8x1-bw-process,", "mem", "-p", "8", "-t", "1", "-P", " 512", OPT_BW
},
1727 { " 8x1-bw-process-NOTHP,",
1728 "mem", "-p", "8", "-t", "1", "-P", " 512", OPT_BW_NOTHP
},
1729 { "16x1-bw-process,", "mem", "-p", "16", "-t", "1", "-P", "256", OPT_BW
},
1731 { " 4x1-bw-thread,", "mem", "-p", "1", "-t", "4", "-T", "256", OPT_BW
},
1732 { " 8x1-bw-thread,", "mem", "-p", "1", "-t", "8", "-T", "256", OPT_BW
},
1733 { "16x1-bw-thread,", "mem", "-p", "1", "-t", "16", "-T", "128", OPT_BW
},
1734 { "32x1-bw-thread,", "mem", "-p", "1", "-t", "32", "-T", "64", OPT_BW
},
1736 { " 2x3-bw-thread,", "mem", "-p", "2", "-t", "3", "-P", "512", OPT_BW
},
1737 { " 4x4-bw-thread,", "mem", "-p", "4", "-t", "4", "-P", "512", OPT_BW
},
1738 { " 4x6-bw-thread,", "mem", "-p", "4", "-t", "6", "-P", "512", OPT_BW
},
1739 { " 4x8-bw-thread,", "mem", "-p", "4", "-t", "8", "-P", "512", OPT_BW
},
1740 { " 4x8-bw-thread-NOTHP,",
1741 "mem", "-p", "4", "-t", "8", "-P", "512", OPT_BW_NOTHP
},
1742 { " 3x3-bw-thread,", "mem", "-p", "3", "-t", "3", "-P", "512", OPT_BW
},
1743 { " 5x5-bw-thread,", "mem", "-p", "5", "-t", "5", "-P", "512", OPT_BW
},
1745 { "2x16-bw-thread,", "mem", "-p", "2", "-t", "16", "-P", "512", OPT_BW
},
1746 { "1x32-bw-thread,", "mem", "-p", "1", "-t", "32", "-P", "2048", OPT_BW
},
1748 { "numa02-bw,", "mem", "-p", "1", "-t", "32", "-T", "32", OPT_BW
},
1749 { "numa02-bw-NOTHP,", "mem", "-p", "1", "-t", "32", "-T", "32", OPT_BW_NOTHP
},
1750 { "numa01-bw-thread,", "mem", "-p", "2", "-t", "16", "-T", "192", OPT_BW
},
1751 { "numa01-bw-thread-NOTHP,",
1752 "mem", "-p", "2", "-t", "16", "-T", "192", OPT_BW_NOTHP
},
1755 static int bench_all(void)
1757 int nr
= ARRAY_SIZE(tests
);
1761 ret
= system("echo ' #'; echo ' # Running test on: '$(uname -a); echo ' #'");
1764 for (i
= 0; i
< nr
; i
++) {
1765 run_bench_numa(tests
[i
][0], tests
[i
] + 1);
1773 int bench_numa(int argc
, const char **argv
)
1775 init_params(&p0
, "main,", argc
, argv
);
1776 argc
= parse_options(argc
, argv
, options
, bench_numa_usage
, 0);
1783 if (__bench_numa(NULL
))
1789 usage_with_options(numa_usage
, options
);