blktrace: only probe and set depth if option isn't set

[fio.git] / backend.c

diff --git a/backend.c b/backend.c
index 7ec8d2a3d7b438a954e0bf0c7db04f21416ff072..25479b49c9c9f1a82b7d39bec3cb11d5a816327b 100644 (file)
--- a/backend.c
+++ b/backend.c
@@ -565,6 +565,8 @@ static void do_verify(struct thread_data *td, uint64_t verify_bytes)
                        io_u->end_io = verify_io_u;
 
                ddir = io_u->ddir;
+               if (!td->o.disable_slat)
+                       fio_gettime(&io_u->start_time, NULL);
 
                ret = td_io_queue(td, io_u);
                switch (ret) {
@@ -656,10 +658,10 @@ static unsigned int exceeds_number_ios(struct thread_data *td)
        if (!td->o.number_ios)
                return 0;
 
-       number_ios = ddir_rw_sum(td->this_io_blocks);
+       number_ios = ddir_rw_sum(td->io_blocks);
        number_ios += td->io_u_queued + td->io_u_in_flight;
 
-       return number_ios >= td->o.number_ios;
+       return number_ios >= (td->o.number_ios * td->loops);
 }
 
 static int io_issue_bytes_exceeded(struct thread_data *td)
@@ -680,6 +682,7 @@ static int io_issue_bytes_exceeded(struct thread_data *td)
        else
                limit = td->o.size;
 
+       limit *= td->loops;
        return bytes >= limit || exceeds_number_ios(td);
 }
 
@@ -701,6 +704,7 @@ static int io_complete_bytes_exceeded(struct thread_data *td)
        else
                limit = td->o.size;
 
+       limit *= td->loops;
        return bytes >= limit || exceeds_number_ios(td);
 }
 
@@ -724,16 +728,27 @@ static uint64_t do_io(struct thread_data *td)
 
        lat_target_init(td);
 
+       total_bytes = td->o.size;
+       /*
+       * Allow random overwrite workloads to write up to io_limit
+       * before starting verification phase as 'size' doesn't apply.
+       */
+       if (td_write(td) && td_random(td) && td->o.norandommap)
+               total_bytes = max(total_bytes, (uint64_t) td->o.io_limit);
        /*
         * If verify_backlog is enabled, we'll run the verify in this
         * handler as well. For that case, we may need up to twice the
         * amount of bytes.
         */
-       total_bytes = td->o.size;
        if (td->o.verify != VERIFY_NONE &&
           (td_write(td) && td->o.verify_backlog))
                total_bytes += td->o.size;
 
+       /* In trimwrite mode, each byte is trimmed and then written, so
+        * allow total_bytes to be twice as big */
+       if (td_trimwrite(td))
+               total_bytes += td->total_io_size;
+
        while ((td->o.read_iolog_file && !flist_empty(&td->io_log_list)) ||
                (!flist_empty(&td->trim_list)) || !io_issue_bytes_exceeded(td) ||
                td->o.time_based) {
@@ -1516,6 +1531,15 @@ static void *thread_main(void *data)
 
                clear_state = 1;
 
+               /*
+                * Make sure we've successfully updated the rusage stats
+                * before waiting on the stat mutex. Otherwise we could have
+                * the stat thread holding stat mutex and waiting for
+                * the rusage_sem, which would never get upped because
+                * this thread is waiting for the stat mutex.
+                */
+               check_update_rusage(td);
+
                fio_mutex_down(stat_mutex);
                if (td_read(td) && td->io_bytes[DDIR_READ]) {
                        elapsed = mtime_since_now(&td->start);
@@ -1546,6 +1570,11 @@ static void *thread_main(void *data)
 
                do_verify(td, verify_bytes);
 
+               /*
+                * See comment further up for why this is done here.
+                */
+               check_update_rusage(td);
+
                fio_mutex_down(stat_mutex);
                td->ts.runtime[DDIR_READ] += mtime_since_now(&td->start);
                fio_gettime(&td->start, NULL);