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