X-Git-Url: https://git.kernel.dk/?a=blobdiff_plain;f=idletime.c;h=fc1df8e9d009a49059558c6ca576a6e553f304c7;hb=e1ce5b385c65803b170e512a1b5256bbe99f98f0;hp=9e6960702ca0face97c1602534bf79616f2afbaf;hpb=59358c8ef39efea4a2ab141d85b2deebf5cf34fd;p=fio.git diff --git a/idletime.c b/idletime.c index 9e696070..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,16 +44,26 @@ 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) - os_cpu_mask_t cpu_mask; + if (fio_cpuset_init(&ipt->cpu_mask)) { + log_err("fio: cpuset init failed\n"); + return -1; + } - memset(&cpu_mask, 0, sizeof(cpu_mask)); - fio_cpu_set(&cpu_mask, ipt->cpu); + fio_cpu_set(&ipt->cpu_mask, ipt->cpu); - if (fio_setaffinity(gettid(), cpu_mask)) { + if (fio_setaffinity(gettid(), ipt->cpu_mask)) { log_err("fio: fio_setaffinity failed\n"); + fio_cpuset_exit(&ipt->cpu_mask); return -1; } @@ -73,8 +84,10 @@ 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; + } retval = set_cpu_affinity(ipt); if (retval == -1) { @@ -96,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; @@ -109,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; @@ -137,6 +154,8 @@ idle_prof_done: ipt->state = TD_EXITED; pthread_mutex_unlock(&ipt->start_lock); +do_exit: + free_cpu_affinity(ipt); return NULL; } @@ -165,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(); @@ -176,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; @@ -221,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; @@ -242,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)); } } @@ -264,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); @@ -307,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; @@ -325,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); } @@ -336,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; } @@ -407,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; @@ -425,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; @@ -433,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; @@ -479,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(); } }