Makefile: break long line

[fio.git] / backend.c

diff --git a/backend.c b/backend.c
index 9cc8dbc3ce1e029b4729e23e150428e4217b60e4..ce0a0098299294279ea4bf16dfd88b7079d9466e 100644 (file)
--- a/backend.c
+++ b/backend.c
@@ -58,7 +58,7 @@ static char *cgroup_mnt;
 static int exit_value;
 static volatile int fio_abort;
 
-struct io_log *agg_io_log[2];
+struct io_log *agg_io_log[DDIR_RWDIR_CNT];
 
 int groupid = 0;
 unsigned int thread_number = 0;
@@ -208,10 +208,12 @@ static int check_min_rate(struct thread_data *td, struct timeval *now,
 {
        int ret = 0;
 
-       if (bytes_done[0])
-               ret |= __check_min_rate(td, now, 0);
-       if (bytes_done[1])
-               ret |= __check_min_rate(td, now, 1);
+       if (bytes_done[DDIR_READ])
+               ret |= __check_min_rate(td, now, DDIR_READ);
+       if (bytes_done[DDIR_WRITE])
+               ret |= __check_min_rate(td, now, DDIR_WRITE);
+       if (bytes_done[DDIR_TRIM])
+               ret |= __check_min_rate(td, now, DDIR_TRIM);
 
        return ret;
 }
@@ -545,11 +547,13 @@ static int io_bytes_exceeded(struct thread_data *td)
        unsigned long long bytes;
 
        if (td_rw(td))
-               bytes = td->this_io_bytes[0] + td->this_io_bytes[1];
+               bytes = td->this_io_bytes[DDIR_READ] + td->this_io_bytes[DDIR_WRITE];
        else if (td_write(td))
-               bytes = td->this_io_bytes[1];
+               bytes = td->this_io_bytes[DDIR_WRITE];
+       else if (td_read(td))
+               bytes = td->this_io_bytes[DDIR_READ];
        else
-               bytes = td->this_io_bytes[0];
+               bytes = td->this_io_bytes[DDIR_TRIM];
 
        return bytes >= td->o.size;
 }
@@ -572,7 +576,7 @@ static void do_io(struct thread_data *td)
                (!flist_empty(&td->trim_list)) || !io_bytes_exceeded(td) ||
                td->o.time_based) {
                struct timeval comp_time;
-               unsigned long bytes_done[2] = { 0, 0 };
+               unsigned long bytes_done[DDIR_RWDIR_CNT] = { 0, 0, 0 };
                int min_evts = 0;
                struct io_u *io_u;
                int ret2, full;
@@ -649,8 +653,9 @@ static void do_io(struct thread_data *td)
                                requeue_io_u(td, &io_u);
                        } else {
 sync_done:
-                               if (__should_check_rate(td, 0) ||
-                                   __should_check_rate(td, 1))
+                               if (__should_check_rate(td, DDIR_READ) ||
+                                   __should_check_rate(td, DDIR_WRITE) ||
+                                   __should_check_rate(td, DDIR_TRIM))
                                        fio_gettime(&comp_time, NULL);
 
                                ret = io_u_sync_complete(td, io_u, bytes_done);
@@ -697,8 +702,9 @@ sync_done:
                        if (full && !min_evts)
                                min_evts = 1;
 
-                       if (__should_check_rate(td, 0) ||
-                           __should_check_rate(td, 1))
+                       if (__should_check_rate(td, DDIR_READ) ||
+                           __should_check_rate(td, DDIR_WRITE) ||
+                           __should_check_rate(td, DDIR_TRIM))
                                fio_gettime(&comp_time, NULL);
 
                        do {
@@ -711,7 +717,7 @@ sync_done:
 
                if (ret < 0)
                        break;
-               if (!(bytes_done[0] + bytes_done[1]))
+               if (!ddir_rw_sum(bytes_done))
                        continue;
 
                if (!in_ramp_time(td) && should_check_rate(td, bytes_done)) {
@@ -726,7 +732,7 @@ sync_done:
                if (td->o.thinktime) {
                        unsigned long long b;
 
-                       b = td->io_blocks[0] + td->io_blocks[1];
+                       b = ddir_rw_sum(td->io_blocks);
                        if (!(b % td->o.thinktime_blocks)) {
                                int left;
 
@@ -772,7 +778,7 @@ sync_done:
        /*
         * stop job if we failed doing any IO
         */
-       if ((td->this_io_bytes[0] + td->this_io_bytes[1]) == 0)
+       if (!ddir_rw_sum(td->this_io_bytes))
                td->done = 1;
 }
 
@@ -800,6 +806,7 @@ static int init_io_u(struct thread_data *td)
 
        max_units = td->o.iodepth;
        max_bs = max(td->o.max_bs[DDIR_READ], td->o.max_bs[DDIR_WRITE]);
+       max_bs = max(td->o.max_bs[DDIR_TRIM], max_bs);
        min_write = td->o.min_bs[DDIR_WRITE];
        td->orig_buffer_size = (unsigned long long) max_bs
                                        * (unsigned long long) max_units;
@@ -926,8 +933,6 @@ static int switch_ioscheduler(struct thread_data *td)
 
 static int keep_running(struct thread_data *td)
 {
-       unsigned long long io_done;
-
        if (td->done)
                return 0;
        if (td->o.time_based)
@@ -937,9 +942,7 @@ static int keep_running(struct thread_data *td)
                return 1;
        }
 
-       io_done = td->io_bytes[DDIR_READ] + td->io_bytes[DDIR_WRITE]
-                       + td->io_skip_bytes;
-       if (io_done < td->o.size)
+       if (ddir_rw_sum(td->io_bytes) < td->o.size)
                return 1;
 
        return 0;
@@ -1097,10 +1100,13 @@ static void *thread_main(void *data)
                memcpy(&td->iops_sample_time, &td->start, sizeof(td->start));
                memcpy(&td->tv_cache, &td->start, sizeof(td->start));
 
-               if (td->o.ratemin[0] || td->o.ratemin[1]) {
-                       memcpy(&td->lastrate[0], &td->bw_sample_time,
+               if (td->o.ratemin[DDIR_READ] || td->o.ratemin[DDIR_WRITE] ||
+                               td->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[1], &td->bw_sample_time,
+                       memcpy(&td->lastrate[DDIR_TRIM], &td->bw_sample_time,
                                                sizeof(td->bw_sample_time));
                }
 
@@ -1121,6 +1127,10 @@ static void *thread_main(void *data)
                        elapsed = utime_since_now(&td->start);
                        td->ts.runtime[DDIR_WRITE] += elapsed;
                }
+               if (td_trim(td) && td->io_bytes[DDIR_TRIM]) {
+                       elapsed = utime_since_now(&td->start);
+                       td->ts.runtime[DDIR_TRIM] += elapsed;
+               }
 
                if (td->error || td->terminate)
                        break;
@@ -1143,11 +1153,13 @@ static void *thread_main(void *data)
        }
 
        update_rusage_stat(td);
-       td->ts.runtime[0] = (td->ts.runtime[0] + 999) / 1000;
-       td->ts.runtime[1] = (td->ts.runtime[1] + 999) / 1000;
+       td->ts.runtime[DDIR_READ] = (td->ts.runtime[DDIR_READ] + 999) / 1000;
+       td->ts.runtime[DDIR_WRITE] = (td->ts.runtime[DDIR_WRITE] + 999) / 1000;
+       td->ts.runtime[DDIR_TRIM] = (td->ts.runtime[DDIR_TRIM] + 999) / 1000;
        td->ts.total_run_time = mtime_since_now(&td->epoch);
-       td->ts.io_bytes[0] = td->io_bytes[0];
-       td->ts.io_bytes[1] = td->io_bytes[1];
+       td->ts.io_bytes[DDIR_READ] = td->io_bytes[DDIR_READ];
+       td->ts.io_bytes[DDIR_WRITE] = td->io_bytes[DDIR_WRITE];
+       td->ts.io_bytes[DDIR_TRIM] = td->io_bytes[DDIR_TRIM];
 
        fio_mutex_down(writeout_mutex);
        if (td->bw_log) {
@@ -1337,8 +1349,8 @@ static void reap_threads(unsigned int *nr_running, unsigned int *t_rate,
                continue;
 reaped:
                (*nr_running)--;
-               (*m_rate) -= (td->o.ratemin[0] + td->o.ratemin[1]);
-               (*t_rate) -= (td->o.rate[0] + td->o.rate[1]);
+               (*m_rate) -= ddir_rw_sum(td->o.ratemin);
+               (*t_rate) -= ddir_rw_sum(td->o.rate);
                if (!td->pid)
                        pending--;
 
@@ -1369,7 +1381,7 @@ static void run_threads(void)
 
        set_sig_handlers();
 
-       if (!terse_output) {
+       if (output_format == FIO_OUTPUT_NORMAL) {
                log_info("Starting ");
                if (nr_thread)
                        log_info("%d thread%s", nr_thread,
@@ -1560,8 +1572,8 @@ static void run_threads(void)
                                td_set_runstate(td, TD_RUNNING);
                        nr_running++;
                        nr_started--;
-                       m_rate += td->o.ratemin[0] + td->o.ratemin[1];
-                       t_rate += td->o.rate[0] + td->o.rate[1];
+                       m_rate += ddir_rw_sum(td->o.ratemin);
+                       t_rate += ddir_rw_sum(td->o.rate);
                        todo--;
                        fio_mutex_up(td->mutex);
                }
@@ -1620,7 +1632,7 @@ static int create_disk_util_thread(void)
 
        setup_disk_util();
 
-       disk_thread_mutex = fio_mutex_init(0);
+       disk_thread_mutex = fio_mutex_init(FIO_MUTEX_LOCKED);
 
        ret = pthread_create(&disk_util_thread, NULL, disk_thread_main, NULL);
        if (ret) {
@@ -1659,12 +1671,13 @@ int fio_backend(void)
        if (write_bw_log) {
                setup_log(&agg_io_log[DDIR_READ], 0);
                setup_log(&agg_io_log[DDIR_WRITE], 0);
+               setup_log(&agg_io_log[DDIR_TRIM], 0);
        }
 
-       startup_mutex = fio_mutex_init(0);
+       startup_mutex = fio_mutex_init(FIO_MUTEX_LOCKED);
        if (startup_mutex == NULL)
                return 1;
-       writeout_mutex = fio_mutex_init(1);
+       writeout_mutex = fio_mutex_init(FIO_MUTEX_UNLOCKED);
        if (writeout_mutex == NULL)
                return 1;
 
@@ -1682,6 +1695,8 @@ int fio_backend(void)
                        __finish_log(agg_io_log[DDIR_READ], "agg-read_bw.log");
                        __finish_log(agg_io_log[DDIR_WRITE],
                                        "agg-write_bw.log");
+                       __finish_log(agg_io_log[DDIR_TRIM],
+                                       "agg-write_bw.log");
                }
        }