X-Git-Url: https://git.kernel.dk/?p=fio.git;a=blobdiff_plain;f=idletime.c;h=2f59f5104b4152c7b156a1bd255f898eb1ba7c72;hp=244723f051791ab13881398f0eab470f2b1ce62d;hb=04ba61dfa67784d4dfcc22a2b3de7ede28e22e40;hpb=680b5abcb197f52382c8c568c6f1453b410e2b66 diff --git a/idletime.c b/idletime.c index 244723f0..2f59f510 100644 --- a/idletime.c +++ b/idletime.c @@ -1,4 +1,5 @@ #include +#include "fio.h" #include "json.h" #include "idletime.h" @@ -11,7 +12,7 @@ static volatile struct idle_prof_common ipc; static double calibrate_unit(unsigned char *data) { unsigned long t, i, j, k; - struct timeval tps; + struct timespec tps; double tunit = 0.0; for (i = 0; i < CALIBRATE_RUNS; i++) { @@ -43,6 +44,36 @@ static double calibrate_unit(unsigned char *data) return tunit / CALIBRATE_SCALE; } +static void free_cpu_affinity(struct idle_prof_thread *ipt) +{ +#if defined(FIO_HAVE_CPU_AFFINITY) + fio_cpuset_exit(&ipt->cpu_mask); +#endif +} + +static int set_cpu_affinity(struct idle_prof_thread *ipt) +{ +#if defined(FIO_HAVE_CPU_AFFINITY) + if (fio_cpuset_init(&ipt->cpu_mask)) { + log_err("fio: cpuset init failed\n"); + return -1; + } + + fio_cpu_set(&ipt->cpu_mask, ipt->cpu); + + if (fio_setaffinity(gettid(), ipt->cpu_mask)) { + log_err("fio: fio_setaffinity failed\n"); + fio_cpuset_exit(&ipt->cpu_mask); + return -1; + } + + return 0; +#else + log_err("fio: fio_setaffinity not supported\n"); + return -1; +#endif +} + static void *idle_prof_thread_fn(void *data) { int retval; @@ -53,20 +84,12 @@ static void *idle_prof_thread_fn(void *data) pthread_mutex_lock(&ipt->init_lock); /* exit if any other thread failed to start */ - if (ipc.status == IDLE_PROF_STATUS_ABORT) + if (ipc.status == IDLE_PROF_STATUS_ABORT) { + pthread_mutex_unlock(&ipt->init_lock); return NULL; + } -#if defined(FIO_HAVE_CPU_AFFINITY) - os_cpu_mask_t cpu_mask; - memset(&cpu_mask, 0, sizeof(cpu_mask)); - fio_cpu_set(&cpu_mask, ipt->cpu); - - if ((retval=fio_setaffinity(gettid(), cpu_mask)) == -1) - log_err("fio: fio_setaffinity failed\n"); -#else - retval = -1; - log_err("fio: fio_setaffinity not supported\n"); -#endif + retval = set_cpu_affinity(ipt); if (retval == -1) { ipt->state = TD_EXITED; pthread_mutex_unlock(&ipt->init_lock); @@ -86,7 +109,7 @@ static void *idle_prof_thread_fn(void *data) if (retval == -1) { ipt->state = TD_EXITED; pthread_mutex_unlock(&ipt->init_lock); - return NULL; + goto do_exit; } ipt->state = TD_INITIALIZED; @@ -99,12 +122,16 @@ static void *idle_prof_thread_fn(void *data) pthread_mutex_lock(&ipt->start_lock); /* exit if other threads failed to initialize */ - if (ipc.status == IDLE_PROF_STATUS_ABORT) - return NULL; + if (ipc.status == IDLE_PROF_STATUS_ABORT) { + pthread_mutex_unlock(&ipt->start_lock); + goto do_exit; + } /* exit if we are doing calibration only */ - if (ipc.status == IDLE_PROF_STATUS_CALI_STOP) - return NULL; + if (ipc.status == IDLE_PROF_STATUS_CALI_STOP) { + pthread_mutex_unlock(&ipt->start_lock); + goto do_exit; + } fio_gettime(&ipt->tps, NULL); ipt->state = TD_RUNNING; @@ -127,6 +154,8 @@ idle_prof_done: ipt->state = TD_EXITED; pthread_mutex_unlock(&ipt->start_lock); +do_exit: + free_cpu_affinity(ipt); return NULL; } @@ -155,7 +184,6 @@ static void calibration_stats(void) void fio_idle_prof_init(void) { int i, ret; - struct timeval tp; struct timespec ts; pthread_attr_t tattr; struct idle_prof_thread *ipt; @@ -232,7 +260,7 @@ void fio_idle_prof_init(void) if ((ret = pthread_detach(ipt->thread))) { /* log error and let the thread spin */ - log_err("fio: pthread_detatch %s\n", strerror(ret)); + log_err("fio: pthread_detach %s\n", strerror(ret)); } } @@ -254,9 +282,8 @@ void fio_idle_prof_init(void) pthread_mutex_lock(&ipt->init_lock); while ((ipt->state != TD_EXITED) && (ipt->state!=TD_INITIALIZED)) { - fio_gettime(&tp, NULL); - ts.tv_sec = tp.tv_sec + 1; - ts.tv_nsec = tp.tv_usec * 1000; + fio_gettime(&ts, NULL); + ts.tv_sec += 1; pthread_cond_timedwait(&ipt->cond, &ipt->init_lock, &ts); } pthread_mutex_unlock(&ipt->init_lock); @@ -297,7 +324,6 @@ void fio_idle_prof_stop(void) { int i; uint64_t runt; - struct timeval tp; struct timespec ts; struct idle_prof_thread *ipt; @@ -315,9 +341,8 @@ void fio_idle_prof_stop(void) pthread_mutex_lock(&ipt->start_lock); while ((ipt->state != TD_EXITED) && (ipt->state!=TD_NOT_CREATED)) { - fio_gettime(&tp, NULL); - ts.tv_sec = tp.tv_sec + 1; - ts.tv_nsec = tp.tv_usec * 1000; + fio_gettime(&ts, NULL); + ts.tv_sec += 1; /* timed wait in case a signal is not received */ pthread_cond_timedwait(&ipt->cond, &ipt->start_lock, &ts); } @@ -326,7 +351,10 @@ void fio_idle_prof_stop(void) /* calculate idleness */ if (ipc.cali_mean != 0.0) { runt = utime_since(&ipt->tps, &ipt->tpe); - ipt->idleness = ipt->loops * ipc.cali_mean / runt; + if (runt) + ipt->idleness = ipt->loops * ipc.cali_mean / runt; + else + ipt->idleness = 0.0; } else ipt->idleness = 0.0; } @@ -397,7 +425,7 @@ int fio_idle_prof_parse_opt(const char *args) fio_idle_prof_init(); fio_idle_prof_start(); fio_idle_prof_stop(); - show_idle_prof_stats(FIO_OUTPUT_NORMAL, NULL); + show_idle_prof_stats(FIO_OUTPUT_NORMAL, NULL, NULL); return 1; } else if (strcmp("system", args) == 0) { ipc.opt = IDLE_PROF_OPT_SYSTEM; @@ -406,7 +434,7 @@ int fio_idle_prof_parse_opt(const char *args) ipc.opt = IDLE_PROF_OPT_PERCPU; return 0; } else { - log_err("fio: incorrect idle-prof option\n", args); + log_err("fio: incorrect idle-prof option: %s\n", args); return -1; } #else @@ -415,7 +443,8 @@ int fio_idle_prof_parse_opt(const char *args) #endif } -void show_idle_prof_stats(int output, struct json_object *parent) +void show_idle_prof_stats(int output, struct json_object *parent, + struct buf_output *out) { int i, nr_cpus = ipc.nr_cpus; struct json_object *tmp; @@ -423,33 +452,29 @@ void show_idle_prof_stats(int output, struct json_object *parent) if (output == FIO_OUTPUT_NORMAL) { if (ipc.opt > IDLE_PROF_OPT_CALI) - log_info("\nCPU idleness:\n"); + log_buf(out, "\nCPU idleness:\n"); else if (ipc.opt == IDLE_PROF_OPT_CALI) - log_info("CPU idleness:\n"); + log_buf(out, "CPU idleness:\n"); if (ipc.opt >= IDLE_PROF_OPT_SYSTEM) - log_info(" system: %3.2f%%\n", fio_idle_prof_cpu_stat(-1)); + log_buf(out, " system: %3.2f%%\n", fio_idle_prof_cpu_stat(-1)); if (ipc.opt == IDLE_PROF_OPT_PERCPU) { - log_info(" percpu: %3.2f%%", fio_idle_prof_cpu_stat(0)); + log_buf(out, " percpu: %3.2f%%", fio_idle_prof_cpu_stat(0)); for (i = 1; i < nr_cpus; i++) - log_info(", %3.2f%%", fio_idle_prof_cpu_stat(i)); - log_info("\n"); + log_buf(out, ", %3.2f%%", fio_idle_prof_cpu_stat(i)); + log_buf(out, "\n"); } if (ipc.opt >= IDLE_PROF_OPT_CALI) { - log_info(" unit work: mean=%3.2fus,", ipc.cali_mean); - log_info(" stddev=%3.2f\n", ipc.cali_stddev); + log_buf(out, " unit work: mean=%3.2fus,", ipc.cali_mean); + log_buf(out, " stddev=%3.2f\n", ipc.cali_stddev); } - /* dynamic mem allocations can now be freed */ - if (ipc.opt != IDLE_PROF_OPT_NONE) - fio_idle_prof_cleanup(); - return; } - if ((ipc.opt != IDLE_PROF_OPT_NONE) && (output == FIO_OUTPUT_JSON)) { + if ((ipc.opt != IDLE_PROF_OPT_NONE) && (output & FIO_OUTPUT_JSON)) { if (!parent) return; @@ -469,7 +494,5 @@ void show_idle_prof_stats(int output, struct json_object *parent) json_object_add_value_float(tmp, "unit_mean", ipc.cali_mean); json_object_add_value_float(tmp, "unit_stddev", ipc.cali_stddev); - - fio_idle_prof_cleanup(); } }