backend: cleanup overlap submission logic
[fio.git] / idletime.c
index 9e69607..90bc1d9 100644 (file)
@@ -11,7 +11,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 +43,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 +83,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 +108,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 +121,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 +153,8 @@ idle_prof_done:
        ipt->state = TD_EXITED;
        pthread_mutex_unlock(&ipt->start_lock);
 
+do_exit:
+       free_cpu_affinity(ipt);
        return NULL;
 }
 
@@ -165,7 +183,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;
@@ -242,7 +259,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 +281,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);
@@ -307,7 +323,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 +340,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 +350,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;
        }
@@ -379,7 +396,7 @@ static double fio_idle_prof_cpu_stat(int cpu)
        return p * 100.0;
 }
 
-void fio_idle_prof_cleanup(void)
+static void fio_idle_prof_cleanup(void)
 {
        if (ipc.ipts) {
                free(ipc.ipts);
@@ -407,7 +424,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 +442,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,23 +451,23 @@ 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 */
@@ -459,7 +477,7 @@ void show_idle_prof_stats(int output, struct json_object *parent)
                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;