td_verror() needs errno style error

[fio.git] / io_u.c

diff --git a/io_u.c b/io_u.c
index acc1a7b1dcb9f4ab6ac2c56a1552247c905ab41e..4b0b5a7a11bdb002f72d552c89ee4ce8c4fd6b4e 100644 (file)
--- a/io_u.c
+++ b/io_u.c
@@ -104,7 +104,7 @@ static int __get_next_rand_offset(struct thread_data *td, struct fio_file *f,
 
                dprint(FD_RANDOM, "off rand %llu\n", (unsigned long long) r);
 
-               *b = (lastb - 1) * (r / ((uint64_t) rmax + 1.0));
+               *b = lastb * (r / ((uint64_t) rmax + 1.0));
        } else {
                uint64_t off = 0;
 
@@ -273,7 +273,7 @@ static int get_next_seq_offset(struct thread_data *td, struct fio_file *f,
 {
        assert(ddir_rw(ddir));
 
-       if (f->last_pos >= f->io_size + get_start_offset(td) && td->o.time_based)
+       if (f->last_pos >= f->io_size + get_start_offset(td, f) && td->o.time_based)
                f->last_pos = f->last_pos - f->io_size;
 
        if (f->last_pos < f->real_file_size) {
@@ -415,7 +415,7 @@ static inline int io_u_fits(struct thread_data *td, struct io_u *io_u,
 {
        struct fio_file *f = io_u->file;
 
-       return io_u->offset + buflen <= f->io_size + get_start_offset(td);
+       return io_u->offset + buflen <= f->io_size + get_start_offset(td, f);
 }
 
 static unsigned int __get_next_buflen(struct thread_data *td, struct io_u *io_u,
@@ -426,12 +426,10 @@ static unsigned int __get_next_buflen(struct thread_data *td, struct io_u *io_u,
        unsigned int minbs, maxbs;
        unsigned long r, rand_max;
 
-       assert(ddir_rw(io_u->ddir));
+       assert(ddir_rw(ddir));
 
        if (td->o.bs_is_seq_rand)
                ddir = is_random ? DDIR_WRITE: DDIR_READ;
-       else
-               ddir = io_u->ddir;
 
        minbs = td->o.min_bs[ddir];
        maxbs = td->o.max_bs[ddir];
@@ -680,7 +678,7 @@ static void set_rw_ddir(struct thread_data *td, struct io_u *io_u)
 
 void put_file_log(struct thread_data *td, struct fio_file *f)
 {
-       int ret = put_file(td, f);
+       unsigned int ret = put_file(td, f);
 
        if (ret)
                td_verror(td, ret, "file close");
@@ -1093,7 +1091,10 @@ static struct fio_file *__get_next_file(struct thread_data *td)
        td->file_service_file = f;
        td->file_service_left = td->file_service_nr - 1;
 out:
-       dprint(FD_FILE, "get_next_file: %p [%s]\n", f, f->file_name);
+       if (f)
+               dprint(FD_FILE, "get_next_file: %p [%s]\n", f, f->file_name);
+       else
+               dprint(FD_FILE, "get_next_file: NULL\n");
        return f;
 }
 
@@ -1162,6 +1163,10 @@ static int __lat_target_failed(struct thread_data *td)
                return 1;
 
        td->latency_qd_high = td->latency_qd;
+
+       if (td->latency_qd == td->latency_qd_low)
+               td->latency_qd_low--;
+
        td->latency_qd = (td->latency_qd + td->latency_qd_low) / 2;
 
        dprint(FD_RATE, "Ramped down: %d %d %d\n", td->latency_qd_low, td->latency_qd, td->latency_qd_high);
@@ -1186,6 +1191,8 @@ static int lat_target_failed(struct thread_data *td)
 
 void lat_target_init(struct thread_data *td)
 {
+       td->latency_end_run = 0;
+
        if (td->o.latency_target) {
                dprint(FD_RATE, "Latency target=%llu\n", td->o.latency_target);
                fio_gettime(&td->latency_ts, NULL);
@@ -1197,9 +1204,16 @@ void lat_target_init(struct thread_data *td)
                td->latency_qd = td->o.iodepth;
 }
 
+void lat_target_reset(struct thread_data *td)
+{
+       if (!td->latency_end_run)
+               lat_target_init(td);
+}
+
 static void lat_target_success(struct thread_data *td)
 {
        const unsigned int qd = td->latency_qd;
+       struct thread_options *o = &td->o;
 
        td->latency_qd_low = td->latency_qd;
 
@@ -1208,20 +1222,32 @@ static void lat_target_success(struct thread_data *td)
         * of bisecting from highest possible queue depth. If we have set
         * a limit other than td->o.iodepth, bisect between that.
         */
-       if (td->latency_qd_high != td->o.iodepth)
+       if (td->latency_qd_high != o->iodepth)
                td->latency_qd = (td->latency_qd + td->latency_qd_high) / 2;
        else
                td->latency_qd *= 2;
 
-       if (td->latency_qd > td->o.iodepth)
-               td->latency_qd = td->o.iodepth;
+       if (td->latency_qd > o->iodepth)
+               td->latency_qd = o->iodepth;
 
        dprint(FD_RATE, "Ramped up: %d %d %d\n", td->latency_qd_low, td->latency_qd, td->latency_qd_high);
+
        /*
-        * Same as last one, we are done
+        * Same as last one, we are done. Let it run a latency cycle, so
+        * we get only the results from the targeted depth.
         */
-       if (td->latency_qd == qd)
-               td->done = 1;
+       if (td->latency_qd == qd) {
+               if (td->latency_end_run) {
+                       dprint(FD_RATE, "We are done\n");
+                       td->done = 1;
+               } else {
+                       dprint(FD_RATE, "Quiesce and final run\n");
+                       io_u_quiesce(td);
+                       td->latency_end_run = 1;
+                       reset_all_stats(td);
+                       reset_io_stats(td);
+               }
+       }
 
        lat_new_cycle(td);
 }
@@ -1269,7 +1295,7 @@ int queue_full(struct thread_data *td)
 
 struct io_u *__get_io_u(struct thread_data *td)
 {
-       struct io_u *io_u;
+       struct io_u *io_u = NULL;
 
        td_io_u_lock(td);
 
@@ -1279,9 +1305,9 @@ again:
        else if (!queue_full(td)) {
                io_u = io_u_qpop(&td->io_u_freelist);
 
+               io_u->file = NULL;
                io_u->buflen = 0;
                io_u->resid = 0;
-               io_u->file = NULL;
                io_u->end_io = NULL;
        }
 
@@ -1462,7 +1488,8 @@ struct io_u *get_io_u(struct thread_data *td)
                        if (td->flags & TD_F_REFILL_BUFFERS) {
                                io_u_fill_buffer(td, io_u,
                                        io_u->xfer_buflen, io_u->xfer_buflen);
-                       } else if (td->flags & TD_F_SCRAMBLE_BUFFERS)
+                       } else if ((td->flags & TD_F_SCRAMBLE_BUFFERS) &&
+                                  !(td->flags & TD_F_COMPRESS))
                                do_scramble = 1;
                        if (td->flags & TD_F_VER_NONE) {
                                populate_verify_io_u(td, io_u);
@@ -1521,13 +1548,19 @@ void io_u_log_error(struct thread_data *td, struct io_u *io_u)
                td_verror(td, io_u->error, "io_u error");
 }
 
+static inline int gtod_reduce(struct thread_data *td)
+{
+       return td->o.disable_clat && td->o.disable_lat && td->o.disable_slat
+               && td->o.disable_bw;
+}
+
 static void account_io_completion(struct thread_data *td, struct io_u *io_u,
                                  struct io_completion_data *icd,
                                  const enum fio_ddir idx, unsigned int bytes)
 {
        unsigned long lusec = 0;
 
-       if (!td->o.disable_clat || !td->o.disable_bw)
+       if (!gtod_reduce(td))
                lusec = utime_since(&io_u->issue_time, &icd->time);
 
        if (!td->o.disable_lat) {
@@ -1559,10 +1592,8 @@ static void account_io_completion(struct thread_data *td, struct io_u *io_u,
        if (!td->o.disable_bw)
                add_bw_sample(td, idx, bytes, &icd->time);
 
-       add_iops_sample(td, idx, bytes, &icd->time);
-
-       if (td->o.number_ios && !--td->o.number_ios)
-               td->done = 1;
+       if (!gtod_reduce(td))
+               add_iops_sample(td, idx, bytes, &icd->time);
 }
 
 static long long usec_for_io(struct thread_data *td, enum fio_ddir ddir)
@@ -1680,7 +1711,8 @@ static void init_icd(struct thread_data *td, struct io_completion_data *icd,
                     int nr)
 {
        int ddir;
-       if (!td->o.disable_clat || !td->o.disable_bw)
+
+       if (!gtod_reduce(td))
                fio_gettime(&icd->time, NULL);
 
        icd->nr = nr;