Minki/linux
1
0
Fork 1
mirror of https://github.com/torvalds/linux.git synced 2024-12-18 00:53:40 +00:00
Code Issues Packages Projects Releases Wiki Activity

perf bench numa: Use NSEC_PER_U?SEC

Browse Source 
Following kernel practices, using linux/time64.h

Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Jiri Olsa <jolsa@kernel.org>
Cc: Namhyung Kim <namhyung@kernel.org>
Cc: Steven Rostedt <rostedt@goodmis.org>
Cc: Wang Nan <wangnan0@huawei.com>
Link: http://lkml.kernel.org/n/tip-7vnv15263y50qku76p4w5xk6@git.kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
This commit is contained in:
Arnaldo Carvalho de Melo 2016-08-08 11:55:38 -03:00
parent bd48c63eb0
commit a8ad8329b9
1 changed files with 27 additions and 26 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

53
tools/perf/bench/numa.c
View File

@ -30,6 +30,7 @@
#include <sys/wait.h> #include <sys/wait.h>
#include <sys/prctl.h> #include <sys/prctl.h>
#include <sys/types.h> #include <sys/types.h>
#include <linux/time64.h>
#include <numa.h> #include <numa.h>
#include <numaif.h> #include <numaif.h>
@ -1004,7 +1005,7 @@ static void calc_convergence(double runtime_ns_max, double *convergence)
if (strong && process_groups == g->p.nr_proc) { if (strong && process_groups == g->p.nr_proc) {
if (!*convergence) { if (!*convergence) {
*convergence = runtime_ns_max; *convergence = runtime_ns_max;
tprintf(" (%6.1fs converged)\n", *convergence/1e9); tprintf(" (%6.1fs converged)\n", *convergence / NSEC_PER_SEC);
if (g->p.measure_convergence) { if (g->p.measure_convergence) {
g->all_converged = true; g->all_converged = true;
g->stop_work = true; g->stop_work = true;
@ -1012,7 +1013,7 @@ static void calc_convergence(double runtime_ns_max, double *convergence)
} }
} else { } else {
if (*convergence) { if (*convergence) {
tprintf(" (%6.1fs de-converged)", runtime_ns_max/1e9); tprintf(" (%6.1fs de-converged)", runtime_ns_max / NSEC_PER_SEC);
*convergence = 0; *convergence = 0;
} }
tprintf("\n"); tprintf("\n");
@ -1022,7 +1023,7 @@ static void calc_convergence(double runtime_ns_max, double *convergence)
static void show_summary(double runtime_ns_max, int l, double *convergence) static void show_summary(double runtime_ns_max, int l, double *convergence)
{ {
tprintf("\r # %5.1f%% [%.1f mins]", tprintf("\r # %5.1f%% [%.1f mins]",
(double)(l+1)/g->p.nr_loops*100.0, runtime_ns_max/1e9 / 60.0); (double)(l+1)/g->p.nr_loops*100.0, runtime_ns_max / NSEC_PER_SEC / 60.0);
calc_convergence(runtime_ns_max, convergence); calc_convergence(runtime_ns_max, convergence);
@ -1179,8 +1180,8 @@ static void *worker_thread(void *__tdata)
if (details >= 3) { if (details >= 3) {
timersub(&stop, &start, &diff); timersub(&stop, &start, &diff);
runtime_ns_max = diff.tv_sec * 1000000000; runtime_ns_max = diff.tv_sec * NSEC_PER_SEC;
runtime_ns_max += diff.tv_usec * 1000; runtime_ns_max += diff.tv_usec * NSEC_PER_USEC;
if (details >= 0) { if (details >= 0) {
printf(" #%2d / %2d: %14.2lf nsecs/op [val: %016"PRIx64"]\n", printf(" #%2d / %2d: %14.2lf nsecs/op [val: %016"PRIx64"]\n",
@ -1192,23 +1193,23 @@ static void *worker_thread(void *__tdata)
continue; continue;
timersub(&stop, &start0, &diff); timersub(&stop, &start0, &diff);
runtime_ns_max = diff.tv_sec * 1000000000ULL; runtime_ns_max = diff.tv_sec * NSEC_PER_SEC;
runtime_ns_max += diff.tv_usec * 1000ULL; runtime_ns_max += diff.tv_usec * NSEC_PER_USEC;
show_summary(runtime_ns_max, l, &convergence); show_summary(runtime_ns_max, l, &convergence);
} }
gettimeofday(&stop, NULL); gettimeofday(&stop, NULL);
timersub(&stop, &start0, &diff); timersub(&stop, &start0, &diff);
td->runtime_ns = diff.tv_sec * 1000000000ULL; td->runtime_ns = diff.tv_sec * NSEC_PER_SEC;
td->runtime_ns += diff.tv_usec * 1000ULL; td->runtime_ns += diff.tv_usec * NSEC_PER_USEC;
td->speed_gbs = bytes_done / (td->runtime_ns / 1e9) / 1e9; td->speed_gbs = bytes_done / (td->runtime_ns / NSEC_PER_SEC) / 1e9;
getrusage(RUSAGE_THREAD, &rusage); getrusage(RUSAGE_THREAD, &rusage);
td->system_time_ns = rusage.ru_stime.tv_sec * 1000000000ULL; td->system_time_ns = rusage.ru_stime.tv_sec * NSEC_PER_SEC;
td->system_time_ns += rusage.ru_stime.tv_usec * 1000ULL; td->system_time_ns += rusage.ru_stime.tv_usec * NSEC_PER_USEC;
td->user_time_ns = rusage.ru_utime.tv_sec * 1000000000ULL; td->user_time_ns = rusage.ru_utime.tv_sec * NSEC_PER_SEC;
td->user_time_ns += rusage.ru_utime.tv_usec * 1000ULL; td->user_time_ns += rusage.ru_utime.tv_usec * NSEC_PER_USEC;
free_data(thread_data, g->p.bytes_thread); free_data(thread_data, g->p.bytes_thread);
@ -1469,7 +1470,7 @@ static int __bench_numa(const char *name)
} }
/* Wait for all the threads to start up: */ /* Wait for all the threads to start up: */
while (g->nr_tasks_started != g->p.nr_tasks) while (g->nr_tasks_started != g->p.nr_tasks)
usleep(1000); usleep(USEC_PER_MSEC);
BUG_ON(g->nr_tasks_started != g->p.nr_tasks); BUG_ON(g->nr_tasks_started != g->p.nr_tasks);
@ -1488,9 +1489,9 @@ static int __bench_numa(const char *name)
timersub(&stop, &start, &diff); timersub(&stop, &start, &diff);
startup_sec = diff.tv_sec * 1000000000.0; startup_sec = diff.tv_sec * NSEC_PER_SEC;
startup_sec += diff.tv_usec * 1000.0; startup_sec += diff.tv_usec * NSEC_PER_USEC;
startup_sec /= 1e9; startup_sec /= NSEC_PER_SEC;
tprintf(" threads initialized in %.6f seconds.\n", startup_sec); tprintf(" threads initialized in %.6f seconds.\n", startup_sec);
tprintf(" #\n"); tprintf(" #\n");
@ -1529,14 +1530,14 @@ static int __bench_numa(const char *name)
tprintf("\n ###\n"); tprintf("\n ###\n");
tprintf("\n"); tprintf("\n");
runtime_sec_max = diff.tv_sec * 1000000000.0; runtime_sec_max = diff.tv_sec * NSEC_PER_SEC;
runtime_sec_max += diff.tv_usec * 1000.0; runtime_sec_max += diff.tv_usec * NSEC_PER_USEC;
runtime_sec_max /= 1e9; runtime_sec_max /= NSEC_PER_SEC;
runtime_sec_min = runtime_ns_min/1e9; runtime_sec_min = runtime_ns_min / NSEC_PER_SEC;
bytes = g->bytes_done; bytes = g->bytes_done;
runtime_avg = (double)runtime_ns_sum / g->p.nr_tasks / 1e9; runtime_avg = (double)runtime_ns_sum / g->p.nr_tasks / NSEC_PER_SEC;
if (g->p.measure_convergence) { if (g->p.measure_convergence) {
print_res(name, runtime_sec_max, print_res(name, runtime_sec_max,
@ -1562,7 +1563,7 @@ static int __bench_numa(const char *name)
print_res(name, bytes / 1e9, print_res(name, bytes / 1e9,
"GB,", "data-total", "GB data processed, total"); "GB,", "data-total", "GB data processed, total");
print_res(name, runtime_sec_max * 1e9 / (bytes / g->p.nr_tasks), print_res(name, runtime_sec_max * NSEC_PER_SEC / (bytes / g->p.nr_tasks),
"nsecs,", "runtime/byte/thread","nsecs/byte/thread runtime"); "nsecs,", "runtime/byte/thread","nsecs/byte/thread runtime");
print_res(name, bytes / g->p.nr_tasks / 1e9 / runtime_sec_max, print_res(name, bytes / g->p.nr_tasks / 1e9 / runtime_sec_max,
@ -1581,9 +1582,9 @@ static int __bench_numa(const char *name)
snprintf(tname, 32, "process%d:thread%d", p, t); snprintf(tname, 32, "process%d:thread%d", p, t);
print_res(tname, td->speed_gbs, print_res(tname, td->speed_gbs,
"GB/sec", "thread-speed", "GB/sec/thread speed"); "GB/sec", "thread-speed", "GB/sec/thread speed");
print_res(tname, td->system_time_ns / 1e9, print_res(tname, td->system_time_ns / NSEC_PER_SEC,
"secs", "thread-system-time", "system CPU time/thread"); "secs", "thread-system-time", "system CPU time/thread");
print_res(tname, td->user_time_ns / 1e9, print_res(tname, td->user_time_ns / NSEC_PER_SEC,
"secs", "thread-user-time", "user CPU time/thread"); "secs", "thread-user-time", "user CPU time/thread");
} }
} }