X-Git-Url: https://git.kernel.dk/?p=fio.git;a=blobdiff_plain;f=idletime.c;h=fc1df8e9d009a49059558c6ca576a6e553f304c7;hp=244723f051791ab13881398f0eab470f2b1ce62d;hb=7aeb498947d6f2d6c96b571520f12b80365fa8a1;hpb=680b5abcb197f52382c8c568c6f1453b410e2b66 diff --git a/idletime.c b/idletime.c index 244723f0..fc1df8e9 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,9 +184,9 @@ static void calibration_stats(void) void fio_idle_prof_init(void) { int i, ret; - struct timeval tp; struct timespec ts; pthread_attr_t tattr; + pthread_condattr_t cattr; struct idle_prof_thread *ipt; ipc.nr_cpus = cpus_online(); @@ -166,6 +195,13 @@ void fio_idle_prof_init(void) if (ipc.opt == IDLE_PROF_OPT_NONE) return; + ret = pthread_condattr_init(&cattr); + assert(ret == 0); +#ifdef CONFIG_PTHREAD_CONDATTR_SETCLOCK + ret = pthread_condattr_setclock(&cattr, CLOCK_MONOTONIC); + assert(ret == 0); +#endif + if ((ret = pthread_attr_init(&tattr))) { log_err("fio: pthread_attr_init %s\n", strerror(ret)); return; @@ -211,7 +247,7 @@ void fio_idle_prof_init(void) break; } - if ((ret = pthread_cond_init(&ipt->cond, NULL))) { + if ((ret = pthread_cond_init(&ipt->cond, &cattr))) { ipc.status = IDLE_PROF_STATUS_ABORT; log_err("fio: pthread_cond_init %s\n", strerror(ret)); break; @@ -232,7 +268,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 +290,12 @@ 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; +#ifdef CONFIG_PTHREAD_CONDATTR_SETCLOCK + clock_gettime(CLOCK_MONOTONIC, &ts); +#else + clock_gettime(CLOCK_REALTIME, &ts); +#endif + ts.tv_sec += 1; pthread_cond_timedwait(&ipt->cond, &ipt->init_lock, &ts); } pthread_mutex_unlock(&ipt->init_lock); @@ -297,7 +336,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 +353,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 +363,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 +437,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 +446,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 +455,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 +464,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 +506,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(); } }