io_u: don't add slat samples if we are in ramp time

[fio.git] / server.c

diff --git a/server.c b/server.c
index 38626998f279467695fbb27d161ada37f5adbedd..6d5d4ea36ebaf9a774753d6d62c5c50d519c55f7 100644 (file)
--- a/server.c
+++ b/server.c
@@ -578,8 +578,12 @@ static int fio_net_queue_cmd(uint16_t opcode, void *buf, off_t size,
        struct sk_entry *entry;
 
        entry = fio_net_prep_cmd(opcode, buf, size, tagptr, flags);
-       fio_net_queue_entry(entry);
-       return 0;
+       if (entry) {
+               fio_net_queue_entry(entry);
+               return 0;
+       }
+
+       return 1;
 }
 
 static int fio_net_send_simple_stack_cmd(int sk, uint16_t opcode, uint64_t tag)
@@ -908,11 +912,11 @@ static int handle_send_eta_cmd(struct fio_net_cmd *cmd)
                je->files_open          = cpu_to_le32(je->files_open);
 
                for (i = 0; i < DDIR_RWDIR_CNT; i++) {
-                       je->m_rate[i]   = cpu_to_le32(je->m_rate[i]);
-                       je->t_rate[i]   = cpu_to_le32(je->t_rate[i]);
+                       je->m_rate[i]   = cpu_to_le64(je->m_rate[i]);
+                       je->t_rate[i]   = cpu_to_le64(je->t_rate[i]);
                        je->m_iops[i]   = cpu_to_le32(je->m_iops[i]);
                        je->t_iops[i]   = cpu_to_le32(je->t_iops[i]);
-                       je->rate[i]     = cpu_to_le32(je->rate[i]);
+                       je->rate[i]     = cpu_to_le64(je->rate[i]);
                        je->iops[i]     = cpu_to_le32(je->iops[i]);
                }
 
@@ -1440,7 +1444,7 @@ static void convert_gs(struct group_run_stats *dst, struct group_run_stats *src)
                dst->min_run[i]         = cpu_to_le64(src->min_run[i]);
                dst->max_bw[i]          = cpu_to_le64(src->max_bw[i]);
                dst->min_bw[i]          = cpu_to_le64(src->min_bw[i]);
-               dst->io_kb[i]           = cpu_to_le64(src->io_kb[i]);
+               dst->iobytes[i]         = cpu_to_le64(src->iobytes[i]);
                dst->agg[i]             = cpu_to_le64(src->agg[i]);
        }
 
@@ -1458,6 +1462,8 @@ void fio_server_send_ts(struct thread_stat *ts, struct group_run_stats *rs)
 {
        struct cmd_ts_pdu p;
        int i, j;
+       void *ss_buf;
+       uint64_t *ss_iops, *ss_bw;
 
        dprint(FD_NET, "server sending end stats\n");
 
@@ -1537,13 +1543,41 @@ void fio_server_send_ts(struct thread_stat *ts, struct group_run_stats *rs)
        p.ts.latency_window     = cpu_to_le64(ts->latency_window);
        p.ts.latency_percentile.u.i = cpu_to_le64(fio_double_to_uint64(ts->latency_percentile.u.f));
 
-       p.ts.nr_block_infos     = le64_to_cpu(ts->nr_block_infos);
+       p.ts.nr_block_infos     = cpu_to_le64(ts->nr_block_infos);
        for (i = 0; i < p.ts.nr_block_infos; i++)
-               p.ts.block_infos[i] = le32_to_cpu(ts->block_infos[i]);
+               p.ts.block_infos[i] = cpu_to_le32(ts->block_infos[i]);
+
+       p.ts.ss_dur             = cpu_to_le64(ts->ss_dur);
+       p.ts.ss_state           = cpu_to_le32(ts->ss_state);
+       p.ts.ss_head            = cpu_to_le32(ts->ss_head);
+       p.ts.ss_limit.u.i       = cpu_to_le64(fio_double_to_uint64(ts->ss_limit.u.f));
+       p.ts.ss_slope.u.i       = cpu_to_le64(fio_double_to_uint64(ts->ss_slope.u.f));
+       p.ts.ss_deviation.u.i   = cpu_to_le64(fio_double_to_uint64(ts->ss_deviation.u.f));
+       p.ts.ss_criterion.u.i   = cpu_to_le64(fio_double_to_uint64(ts->ss_criterion.u.f));
 
        convert_gs(&p.rs, rs);
 
-       fio_net_queue_cmd(FIO_NET_CMD_TS, &p, sizeof(p), NULL, SK_F_COPY);
+       dprint(FD_NET, "ts->ss_state = %d\n", ts->ss_state);
+       if (ts->ss_state & __FIO_SS_DATA) {
+               dprint(FD_NET, "server sending steadystate ring buffers\n");
+
+               ss_buf = malloc(sizeof(p) + 2*ts->ss_dur*sizeof(uint64_t));
+
+               memcpy(ss_buf, &p, sizeof(p));
+
+               ss_iops = (uint64_t *) ((struct cmd_ts_pdu *)ss_buf + 1);
+               ss_bw = ss_iops + (int) ts->ss_dur;
+               for (i = 0; i < ts->ss_dur; i++) {
+                       ss_iops[i] = cpu_to_le64(ts->ss_iops_data[i]);
+                       ss_bw[i] = cpu_to_le64(ts->ss_bw_data[i]);
+               }
+
+               fio_net_queue_cmd(FIO_NET_CMD_TS, ss_buf, sizeof(p) + 2*ts->ss_dur*sizeof(uint64_t), NULL, SK_F_COPY);
+
+               free(ss_buf);
+       }
+       else
+               fio_net_queue_cmd(FIO_NET_CMD_TS, &p, sizeof(p), NULL, SK_F_COPY);
 }
 
 void fio_server_send_gs(struct group_run_stats *rs)
@@ -1726,7 +1760,7 @@ static int __fio_append_iolog_gz_hist(struct sk_entry *first, struct io_log *log
                /* Do the subtraction on server side so that client doesn't have to
                 * reconstruct our linked list from packets.
                 */
-               cur_plat_entry  = s->plat_entry;
+               cur_plat_entry  = s->data.plat_entry;
                prev_plat_entry = flist_first_entry(&cur_plat_entry->list, struct io_u_plat_entry, list);
                cur_plat  = cur_plat_entry->io_u_plat;
                prev_plat = prev_plat_entry->io_u_plat;
@@ -1930,7 +1964,7 @@ int fio_send_iolog(struct thread_data *td, struct io_log *log, const char *name)
                        struct io_sample *s = get_sample(log, cur_log, i);
 
                        s->time         = cpu_to_le64(s->time);
-                       s->val          = cpu_to_le64(s->val);
+                       s->data.val     = cpu_to_le64(s->data.val);
                        s->__ddir       = cpu_to_le32(s->__ddir);
                        s->bs           = cpu_to_le32(s->bs);
 
@@ -1999,10 +2033,8 @@ int fio_server_get_verify_state(const char *name, int threadnumber,
        dprint(FD_NET, "server: request verify state\n");
 
        rep = smalloc(sizeof(*rep));
-       if (!rep) {
-               log_err("fio: smalloc pool too small\n");
+       if (!rep)
                return ENOMEM;
-       }
 
        __fio_mutex_init(&rep->lock, FIO_MUTEX_LOCKED);
        rep->data = NULL;
@@ -2506,7 +2538,7 @@ int fio_start_server(char *pidfile)
 
        pid = fork();
        if (pid < 0) {
-               log_err("fio: failed server fork: %s", strerror(errno));
+               log_err("fio: failed server fork: %s\n", strerror(errno));
                free(pidfile);
                return -1;
        } else if (pid) {