fio: fix aio trim completion latencies

[fio.git] / idletime.c

diff --git a/idletime.c b/idletime.c
index db272fe4331e5783b7c755c846e9b4a3f58d9c3d..2f59f5104b4152c7b156a1bd255f898eb1ba7c72 100644 (file)
--- a/idletime.c
+++ b/idletime.c
@@ -1,4 +1,5 @@
 #include <math.h>
+#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++) {
@@ -183,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;
@@ -260,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));
                }
        }
 
@@ -282,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);
@@ -325,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;
 
@@ -343,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);
                }
@@ -400,7 +397,7 @@ static double fio_idle_prof_cpu_stat(int cpu)
        return p * 100.0;
 }
 
-static void fio_idle_prof_cleanup(void)
+void fio_idle_prof_cleanup(void)
 {
        if (ipc.ipts) {
                free(ipc.ipts);
@@ -428,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;
@@ -446,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;
@@ -454,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;
 
@@ -500,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();
        }
 }