io_size vs. time_based discrepancy

[fio.git] / backend.c

diff --git a/backend.c b/backend.c
index 9307667054b4c16eb6e760e4a0f5197599c745fd..224736f4c963dcef68db671b39b83ec9ed763758 100644 (file)
--- a/backend.c
+++ b/backend.c
@@ -35,6 +35,7 @@
 #include <sys/wait.h>
 #include <sys/ipc.h>
 #include <sys/mman.h>
+#include <math.h>
 
 #include "fio.h"
 #ifndef FIO_NO_HAVE_SHM_H
@@ -100,7 +101,7 @@ static void sig_int(int sig)
        }
 }
 
-static void sig_show_status(int sig)
+void sig_show_status(int sig)
 {
        show_running_run_stats();
 }
@@ -179,7 +180,7 @@ static int __check_min_rate(struct thread_data *td, struct timeval *now,
                if (spent < td->o.ratecycle)
                        return 0;
 
-               if (td->o.rate[ddir]) {
+               if (td->o.rate[ddir] || td->o.ratemin[ddir]) {
                        /*
                         * check bandwidth specified rate
                         */
@@ -220,6 +221,7 @@ static int __check_min_rate(struct thread_data *td, struct timeval *now,
                                        log_err("%s: min iops rate %u not met,"
                                                " got %lu\n", td->o.name,
                                                        rate_iops_min, rate);
+                                       return 1;
                                }
                        }
                }
@@ -445,8 +447,8 @@ static int wait_for_completions(struct thread_data *td, struct timeval *time)
        /*
         * if the queue is full, we MUST reap at least 1 event
         */
-       min_evts = min(td->o.iodepth_batch_complete, td->cur_depth);
-    if ((full && !min_evts) || !td->o.iodepth_batch_complete)
+       min_evts = min(td->o.iodepth_batch_complete_min, td->cur_depth);
+       if ((full && !min_evts) || !td->o.iodepth_batch_complete_min)
                min_evts = 1;
 
        if (time && (__should_check_rate(td, DDIR_READ) ||
@@ -539,7 +541,7 @@ sync_done:
                        *ret = ret2;
                break;
        default:
-               assert(ret < 0);
+               assert(*ret < 0);
                td_verror(td, -(*ret), "td_io_queue");
                break;
        }
@@ -550,6 +552,12 @@ sync_done:
        return 0;
 }
 
+static inline int io_in_polling(struct thread_data *td)
+{
+       return !td->o.iodepth_batch_complete_min &&
+                  !td->o.iodepth_batch_complete_max;
+}
+
 /*
  * The main verify engine. Runs over the writes we previously submitted,
  * reads the blocks back in, and checks the crc/md5 of the data.
@@ -683,7 +691,7 @@ static void do_verify(struct thread_data *td, uint64_t verify_bytes)
                 */
 reap:
                full = queue_full(td) || (ret == FIO_Q_BUSY && td->cur_depth);
-               if (full || !td->o.iodepth_batch_complete)
+               if (full || io_in_polling(td))
                        ret = wait_for_completions(td, NULL);
 
                if (ret < 0)
@@ -768,17 +776,30 @@ static int io_complete_bytes_exceeded(struct thread_data *td)
  */
 static long long usec_for_io(struct thread_data *td, enum fio_ddir ddir)
 {
-       uint64_t secs, remainder, bps, bytes;
+       uint64_t secs, remainder, bps, bytes, iops;
 
        assert(!(td->flags & TD_F_CHILD));
        bytes = td->rate_io_issue_bytes[ddir];
        bps = td->rate_bps[ddir];
-       if (bps) {
+
+       if (td->o.rate_process == RATE_PROCESS_POISSON) {
+               uint64_t val;
+               iops = bps / td->o.bs[ddir];
+               val = (int64_t) (1000000 / iops) *
+                               -logf(__rand_0_1(&td->poisson_state));
+               if (val) {
+                       dprint(FD_RATE, "poisson rate iops=%llu\n",
+                                       (unsigned long long) 1000000 / val);
+               }
+               td->last_usec += val;
+               return td->last_usec;
+       } else if (bps) {
                secs = bytes / bps;
                remainder = bytes % bps;
                return remainder * 1000000 / bps + secs * 1000000;
-       } else
-               return 0;
+       }
+
+       return 0;
 }
 
 /*
@@ -847,7 +868,7 @@ static uint64_t do_io(struct thread_data *td)
                if (flow_threshold_exceeded(td))
                        continue;
 
-               if (bytes_issued >= total_bytes)
+               if (!td->o.time_based && bytes_issued >= total_bytes)
                        break;
 
                io_u = get_io_u(td);
@@ -931,7 +952,7 @@ static uint64_t do_io(struct thread_data *td)
 reap:
                        full = queue_full(td) ||
                                (ret == FIO_Q_BUSY && td->cur_depth);
-                       if (full || !td->o.iodepth_batch_complete)
+                       if (full || io_in_polling(td))
                                ret = wait_for_completions(td, &comp_time);
                }
                if (ret < 0)
@@ -1552,27 +1573,28 @@ static void *thread_main(void *data)
 
        fio_gettime(&td->epoch, NULL);
        fio_getrusage(&td->ru_start);
+       memcpy(&td->bw_sample_time, &td->epoch, sizeof(td->epoch));
+       memcpy(&td->iops_sample_time, &td->epoch, sizeof(td->epoch));
+
+       if (o->ratemin[DDIR_READ] || o->ratemin[DDIR_WRITE] ||
+                       o->ratemin[DDIR_TRIM]) {
+               memcpy(&td->lastrate[DDIR_READ], &td->bw_sample_time,
+                                       sizeof(td->bw_sample_time));
+               memcpy(&td->lastrate[DDIR_WRITE], &td->bw_sample_time,
+                                       sizeof(td->bw_sample_time));
+               memcpy(&td->lastrate[DDIR_TRIM], &td->bw_sample_time,
+                                       sizeof(td->bw_sample_time));
+       }
+
        clear_state = 0;
        while (keep_running(td)) {
                uint64_t verify_bytes;
 
                fio_gettime(&td->start, NULL);
-               memcpy(&td->bw_sample_time, &td->start, sizeof(td->start));
-               memcpy(&td->iops_sample_time, &td->start, sizeof(td->start));
                memcpy(&td->tv_cache, &td->start, sizeof(td->start));
 
-               if (o->ratemin[DDIR_READ] || o->ratemin[DDIR_WRITE] ||
-                               o->ratemin[DDIR_TRIM]) {
-                       memcpy(&td->lastrate[DDIR_READ], &td->bw_sample_time,
-                                               sizeof(td->bw_sample_time));
-                       memcpy(&td->lastrate[DDIR_WRITE], &td->bw_sample_time,
-                                               sizeof(td->bw_sample_time));
-                       memcpy(&td->lastrate[DDIR_TRIM], &td->bw_sample_time,
-                                               sizeof(td->bw_sample_time));
-               }
-
                if (clear_state)
-                       clear_io_state(td);
+                       clear_io_state(td, 0);
 
                prune_io_piece_log(td);
 
@@ -1610,7 +1632,7 @@ static void *thread_main(void *data)
                    (td->io_ops->flags & FIO_UNIDIR))
                        continue;
 
-               clear_io_state(td);
+               clear_io_state(td, 0);
 
                fio_gettime(&td->start, NULL);
 
@@ -1637,16 +1659,8 @@ static void *thread_main(void *data)
        td->ts.io_bytes[DDIR_TRIM] = td->io_bytes[DDIR_TRIM];
 
        if (td->o.verify_state_save && !(td->flags & TD_F_VSTATE_SAVED) &&
-           (td->o.verify != VERIFY_NONE && td_write(td))) {
-               struct all_io_list *state;
-               size_t sz;
-
-               state = get_all_io_list(td->thread_number, &sz);
-               if (state) {
-                       __verify_save_state(state, "local");
-                       free(state);
-               }
-       }
+           (td->o.verify != VERIFY_NONE && td_write(td)))
+               verify_save_state(td->thread_number);
 
        fio_unpin_memory(td);
 
@@ -1896,7 +1910,7 @@ void check_trigger_file(void)
                if (nr_clients)
                        fio_clients_send_trigger(trigger_remote_cmd);
                else {
-                       verify_save_state();
+                       verify_save_state(IO_LIST_ALL);
                        fio_terminate_threads(TERMINATE_ALL);
                        exec_trigger(trigger_cmd);
                }
@@ -1978,7 +1992,7 @@ static void run_threads(void)
                        nr_process++;
        }
 
-       if (output_format == FIO_OUTPUT_NORMAL) {
+       if (output_format & FIO_OUTPUT_NORMAL) {
                log_info("Starting ");
                if (nr_thread)
                        log_info("%d thread%s", nr_thread,