X-Git-Url: https://git.kernel.dk/?p=fio.git;a=blobdiff_plain;f=fio.c;h=9510dee42971cf244a0cf1bdbec8548765c50d8c;hp=44c8b3800fcc595afea8bca99c264a8fba202964;hb=8756e4d421722eaeb089067aeaaf317d05d53a57;hpb=5289b84775b17eaf2a05481033761f100d5a01e2 diff --git a/fio.c b/fio.c index 44c8b380..9510dee4 100644 --- a/fio.c +++ b/fio.c @@ -69,7 +69,7 @@ enum { TD_REAPED, }; -#define should_fsync(td) (td_write(td) && (!(td)->odirect || (td)->override_sync)) +#define should_fsync(td) ((td_write(td) || td_rw(td)) && (!(td)->odirect || (td)->override_sync)) static sem_t startup_sem; @@ -216,55 +216,6 @@ static void mark_random_map(struct thread_data *td, struct io_u *io_u) io_u->buflen = blocks * td->min_bs; } -static int get_next_offset(struct thread_data *td, unsigned long long *offset) -{ - unsigned long long b, rb; - long r; - - if (!td->sequential) { - unsigned long max_blocks = td->io_size / td->min_bs; - int loops = 50; - - do { - lrand48_r(&td->random_state, &r); - b = ((max_blocks - 1) * r / (RAND_MAX+1.0)); - rb = b + (td->file_offset / td->min_bs); - loops--; - } while (!random_map_free(td, rb) && loops); - - if (!loops) { - if (get_next_free_block(td, &b)) - return 1; - } - } else - b = td->last_bytes / td->min_bs; - - *offset = (b * td->min_bs) + td->file_offset; - if (*offset > td->file_size) - return 1; - - return 0; -} - -static unsigned int get_next_buflen(struct thread_data *td) -{ - unsigned int buflen; - long r; - - if (td->min_bs == td->max_bs) - buflen = td->min_bs; - else { - lrand48_r(&td->bsrange_state, &r); - buflen = (1 + (double) (td->max_bs - 1) * r / (RAND_MAX + 1.0)); - buflen = (buflen + td->min_bs - 1) & ~(td->min_bs - 1); - } - - if (buflen > td->io_size - td->this_io_bytes[td->ddir]) - buflen = td->io_size - td->this_io_bytes[td->ddir]; - - return buflen; -} - static inline void add_stat_sample(struct io_stat *is, unsigned long val) { if (val > is->max_val) @@ -327,6 +278,55 @@ static void add_bw_sample(struct thread_data *td, int ddir) td->stat_io_bytes[ddir] = td->this_io_bytes[ddir]; } +static int get_next_offset(struct thread_data *td, unsigned long long *offset) +{ + unsigned long long b, rb; + long r; + + if (!td->sequential) { + unsigned long max_blocks = td->io_size / td->min_bs; + int loops = 50; + + do { + lrand48_r(&td->random_state, &r); + b = ((max_blocks - 1) * r / (RAND_MAX+1.0)); + rb = b + (td->file_offset / td->min_bs); + loops--; + } while (!random_map_free(td, rb) && loops); + + if (!loops) { + if (get_next_free_block(td, &b)) + return 1; + } + } else + b = td->last_pos / td->min_bs; + + *offset = (b * td->min_bs) + td->file_offset; + if (*offset > td->real_file_size) + return 1; + + return 0; +} + +static unsigned int get_next_buflen(struct thread_data *td) +{ + unsigned int buflen; + long r; + + if (td->min_bs == td->max_bs) + buflen = td->min_bs; + else { + lrand48_r(&td->bsrange_state, &r); + buflen = (1 + (double) (td->max_bs - 1) * r / (RAND_MAX + 1.0)); + buflen = (buflen + td->min_bs - 1) & ~(td->min_bs - 1); + } + + if (buflen > td->io_size - td->this_io_bytes[td->ddir]) + buflen = td->io_size - td->this_io_bytes[td->ddir]; + + return buflen; +} + /* * busy looping version for the last few usec */ @@ -541,6 +541,49 @@ static void fill_md5(struct verify_header *hdr, void *p, unsigned int len) memcpy(hdr->md5_digest, md5_ctx.hash, sizeof(md5_ctx.hash)); } +unsigned int hweight32(unsigned int w) +{ + unsigned int res = w - ((w >> 1) & 0x55555555); + + res = (res & 0x33333333) + ((res >> 2) & 0x33333333); + res = (res + (res >> 4)) & 0x0F0F0F0F; + res = res + (res >> 8); + + return (res + (res >> 16)) & 0x000000FF; +} + +unsigned long hweight64(unsigned long long w) +{ +#if __WORDSIZE == 32 + return hweight32((unsigned int)(w >> 32)) + hweight32((unsigned int)w); +#elif __WORDSIZE == 64 + unsigned long long v = w - ((w >> 1) & 0x5555555555555555ul); + + v = (v & 0x3333333333333333ul) + ((v >> 2) & 0x3333333333333333ul); + v = (v + (v >> 4)) & 0x0F0F0F0F0F0F0F0Ful; + v = v + (v >> 8); + v = v + (v >> 16); + + return (v + (v >> 32)) & 0x00000000000000FFul; +#else +#error __WORDSIZE not defined +#endif +} + +static int get_rw_ddir(struct thread_data *td) +{ + /* + * perhaps cheasy, but use the hamming weight of the position + * as a randomizer for data direction. + */ + if (td_rw(td)) + return hweight64(td->last_pos) & 1; + else if (td_read(td)) + return DDIR_READ; + else + return DDIR_WRITE; +} + /* * fill body of io_u->buf with random data and add a header with the * (eg) sha1sum of that data. @@ -566,16 +609,59 @@ static void populate_io_u(struct thread_data *td, struct io_u *io_u) memcpy(io_u->buf, &hdr, sizeof(hdr)); } -static void put_io_u(struct thread_data *td, struct io_u *io_u) +static int td_io_prep(struct thread_data *td, struct io_u *io_u) +{ + if (td->io_prep && td->io_prep(td, io_u)) + return 1; + + return 0; +} + +void put_io_u(struct thread_data *td, struct io_u *io_u) { list_del(&io_u->list); list_add(&io_u->list, &td->io_u_freelist); td->cur_depth--; } +static int fill_io_u(struct thread_data *td, struct io_u *io_u) +{ + /* + * If using an iolog, grab next piece if any available. + */ + if (td->iolog) { + struct io_piece *ipo; + + if (list_empty(&td->io_log_list)) + return 1; + + ipo = list_entry(td->io_log_list.next, struct io_piece, list); + list_del(&ipo->list); + io_u->offset = ipo->offset; + io_u->buflen = ipo->len; + io_u->ddir = ipo->ddir; + free(ipo); + return 0; + } + + /* + * No log, let the seq/rand engine retrieve the next position. + */ + if (!get_next_offset(td, &io_u->offset)) { + io_u->buflen = get_next_buflen(td); + + if (io_u->buflen) { + io_u->ddir = get_rw_ddir(td); + return 0; + } + } + + return 1; +} + #define queue_full(td) (list_empty(&(td)->io_u_freelist)) -static struct io_u *__get_io_u(struct thread_data *td) +struct io_u *__get_io_u(struct thread_data *td) { struct io_u *io_u; @@ -591,19 +677,6 @@ static struct io_u *__get_io_u(struct thread_data *td) return io_u; } -static int td_io_prep(struct thread_data *td, struct io_u *io_u, int read) -{ - if (read) - io_u->ddir = DDIR_READ; - else - io_u->ddir = DDIR_WRITE; - - if (td->io_prep && td->io_prep(td, io_u)) - return 1; - - return 0; -} - static struct io_u *get_io_u(struct thread_data *td) { struct io_u *io_u; @@ -612,34 +685,33 @@ static struct io_u *get_io_u(struct thread_data *td) if (!io_u) return NULL; - if (get_next_offset(td, &io_u->offset)) { - put_io_u(td, io_u); - return NULL; + if (td->zone_bytes >= td->zone_size) { + td->zone_bytes = 0; + td->last_pos += td->zone_skip; } - io_u->buflen = get_next_buflen(td); - if (!io_u->buflen) { + if (fill_io_u(td, io_u)) { put_io_u(td, io_u); return NULL; } - if (io_u->buflen + io_u->offset > td->file_size) - io_u->buflen = td->file_size - io_u->offset; + if (io_u->buflen + io_u->offset > td->real_file_size) + io_u->buflen = td->real_file_size - io_u->offset; if (!io_u->buflen) { put_io_u(td, io_u); return NULL; } - if (!td->sequential) + if (!td->iolog && !td->sequential) mark_random_map(td, io_u); - td->last_bytes += io_u->buflen; + td->last_pos += io_u->buflen; if (td->verify != VERIFY_NONE) populate_io_u(td, io_u); - if (td_io_prep(td, io_u, td_read(td))) { + if (td_io_prep(td, io_u)) { put_io_u(td, io_u); return NULL; } @@ -654,8 +726,7 @@ static inline void td_set_runstate(struct thread_data *td, int runstate) td->runstate = runstate; } -static int get_next_verify(struct thread_data *td, - unsigned long long *offset, unsigned int *len) +static int get_next_verify(struct thread_data *td, struct io_u *io_u) { struct io_piece *ipo; @@ -665,8 +736,9 @@ static int get_next_verify(struct thread_data *td, ipo = list_entry(td->io_hist_list.next, struct io_piece, list); list_del(&ipo->list); - *offset = ipo->offset; - *len = ipo->len; + io_u->offset = ipo->offset; + io_u->buflen = ipo->len; + io_u->ddir = DDIR_READ; free(ipo); return 0; } @@ -719,6 +791,68 @@ static void log_io_piece(struct thread_data *td, struct io_u *io_u) list_add(&ipo->list, entry); } +static int init_iolog(struct thread_data *td) +{ + unsigned long long offset; + unsigned int bytes; + char *str, *p; + FILE *f; + int rw, i, reads, writes; + + if (!td->iolog) + return 0; + + f = fopen(td->iolog_file, "r"); + if (!f) { + perror("fopen iolog"); + return 1; + } + + str = malloc(4096); + reads = writes = i = 0; + while ((p = fgets(str, 4096, f)) != NULL) { + struct io_piece *ipo; + + if (sscanf(p, "%d,%llu,%u", &rw, &offset, &bytes) != 3) { + fprintf(stderr, "bad iolog: %s\n", p); + continue; + } + if (rw == DDIR_READ) + reads++; + else if (rw == DDIR_WRITE) + writes++; + else { + fprintf(stderr, "bad ddir: %d\n", rw); + continue; + } + + ipo = malloc(sizeof(*ipo)); + INIT_LIST_HEAD(&ipo->list); + ipo->offset = offset; + ipo->len = bytes; + if (bytes > td->max_bs) + td->max_bs = bytes; + ipo->ddir = rw; + list_add_tail(&ipo->list, &td->io_log_list); + i++; + } + + free(str); + fclose(f); + + if (!i) + return 1; + + if (reads && !writes) + td->ddir = DDIR_READ; + else if (!reads && writes) + td->ddir = DDIR_READ; + else + td->iomix = 1; + + return 0; +} + static int sync_td(struct thread_data *td) { if (td->io_sync) @@ -751,21 +885,23 @@ static void io_completed(struct thread_data *td, struct io_u *io_u, gettimeofday(&e, NULL); if (!io_u->error) { - int idx = io_u->ddir; + unsigned int bytes = io_u->buflen - io_u->resid; + const int idx = io_u->ddir; td->io_blocks[idx]++; - td->io_bytes[idx] += (io_u->buflen - io_u->resid); - td->this_io_bytes[idx] += (io_u->buflen - io_u->resid); + td->io_bytes[idx] += bytes; + td->zone_bytes += bytes; + td->this_io_bytes[idx] += bytes; msec = mtime_since(&io_u->issue_time, &e); - add_clat_sample(td, io_u->ddir, msec); - add_bw_sample(td, io_u->ddir); + add_clat_sample(td, idx, msec); + add_bw_sample(td, idx); - if (td_write(td) && io_u->ddir == DDIR_WRITE) + if ((td_rw(td) || td_write(td)) && idx == DDIR_WRITE) log_io_piece(td, io_u); - icd->bytes_done[idx] += (io_u->buflen - io_u->resid); + icd->bytes_done[idx] += bytes; } else icd->error = io_u->error; } @@ -860,12 +996,12 @@ static void do_verify(struct thread_data *td) if (!io_u) break; - if (get_next_verify(td, &io_u->offset, &io_u->buflen)) { + if (get_next_verify(td, io_u)) { put_io_u(td, io_u); break; } - if (td_io_prep(td, io_u, 1)) { + if (td_io_prep(td, io_u)) { put_io_u(td, io_u); break; } @@ -1000,7 +1136,7 @@ static void do_io(struct thread_data *td) if (td->cur_depth) cleanup_pending_aio(td); - if (should_fsync(td)) + if (should_fsync(td) && td->fsync_blocks) sync_td(td); } @@ -1022,6 +1158,8 @@ static int init_io(struct thread_data *td) return fio_posixaio_init(td); else if (td->io_engine == FIO_SGIO) return fio_sgio_init(td); + else if (td->io_engine == FIO_SPLICEIO) + return fio_spliceio_init(td); else { fprintf(stderr, "bad io_engine %d\n", td->io_engine); return 1; @@ -1095,10 +1233,6 @@ static int init_io_u(struct thread_data *td) } } - INIT_LIST_HEAD(&td->io_u_freelist); - INIT_LIST_HEAD(&td->io_u_busylist); - INIT_LIST_HEAD(&td->io_hist_list); - p = ALIGN(td->orig_buffer); for (i = 0; i < max_units; i++) { io_u = malloc(sizeof(*io_u)); @@ -1106,6 +1240,7 @@ static int init_io_u(struct thread_data *td) INIT_LIST_HEAD(&io_u->list); io_u->buf = p + td->max_bs * i; + io_u->index = i; list_add(&io_u->list, &td->io_u_freelist); } @@ -1196,15 +1331,18 @@ static int file_size(struct thread_data *td) return 1; } - if (!td->file_size) - td->file_size = st.st_size; + td->real_file_size = st.st_size; + if (!td->file_size || td->file_size > td->real_file_size) + td->file_size = td->real_file_size; + + td->file_size -= td->file_offset; return 0; } static int bdev_size(struct thread_data *td) { - size_t bytes; + unsigned long long bytes; int r; r = blockdev_size(td->fd, &bytes); @@ -1213,39 +1351,47 @@ static int bdev_size(struct thread_data *td) return 1; } + td->real_file_size = bytes; + /* * no extend possibilities, so limit size to device size if too large */ - if (!td->file_size || td->file_size > bytes) - td->file_size = bytes; + if (!td->file_size || td->file_size > td->real_file_size) + td->file_size = td->real_file_size; + td->file_size -= td->file_offset; return 0; } static int get_file_size(struct thread_data *td) { - int ret; + int ret = 0; if (td->filetype == FIO_TYPE_FILE) ret = file_size(td); - else + else if (td->filetype == FIO_TYPE_BD) ret = bdev_size(td); + else + td->real_file_size = -1; if (ret) return ret; - if (td->file_offset > td->file_size) { - fprintf(stderr, "Client%d: offset larger than length (%Lu > %Lu)\n", td->thread_number, td->file_offset, td->file_size); + if (td->file_offset > td->real_file_size) { + fprintf(stderr, "Client%d: offset extends end (%Lu > %Lu)\n", td->thread_number, td->file_offset, td->real_file_size); return 1; } - td->io_size = td->file_size - td->file_offset; + td->io_size = td->file_size; if (td->io_size == 0) { fprintf(stderr, "Client%d: no io blocks\n", td->thread_number); td_verror(td, EINVAL); return 1; } + if (!td->zone_size) + td->zone_size = td->io_size; + td->total_io_size = td->io_size * td->loops; return 0; } @@ -1254,14 +1400,15 @@ static int setup_file_mmap(struct thread_data *td) { int flags; - if (td_read(td)) - flags = PROT_READ; - else { + if (td_rw(td)) + flags = PROT_READ | PROT_WRITE; + else if (td_write(td)) { flags = PROT_WRITE; if (td->verify != VERIFY_NONE) flags |= PROT_READ; - } + } else + flags = PROT_READ; td->mmap = mmap(NULL, td->file_size, flags, MAP_SHARED, td->fd, td->file_offset); if (td->mmap == MAP_FAILED) { @@ -1333,7 +1480,7 @@ static int setup_file(struct thread_data *td) if (create_file(td, td->file_size, 0)) return 1; } else if (td->filetype == FIO_TYPE_FILE) { - if (st.st_size < td->file_size) { + if (st.st_size < (off_t) td->file_size) { if (create_file(td, td->file_size - st.st_size, 1)) return 1; } @@ -1342,9 +1489,7 @@ static int setup_file(struct thread_data *td) if (td->odirect) flags |= O_DIRECT; - if (td_read(td)) - td->fd = open(td->file_name, flags | O_RDONLY); - else { + if (td_write(td) || td_rw(td)) { if (td->filetype == FIO_TYPE_FILE) { if (!td->overwrite) flags |= O_TRUNC; @@ -1357,6 +1502,13 @@ static int setup_file(struct thread_data *td) flags |= O_RDWR; td->fd = open(td->file_name, flags, 0600); + } else { + if (td->filetype == FIO_TYPE_CHAR) + flags |= O_RDWR; + else + flags |= O_RDONLY; + + td->fd = open(td->file_name, flags); } if (td->fd == -1) { @@ -1585,17 +1737,23 @@ static void init_disk_util(struct thread_data *td) return; /* - * if this is inside a partition dir, jump back to parent + * for md/dm, there's no queue dir. we already have the right place */ - sprintf(tmp, "%s/queue", foo); + sprintf(tmp, "%s/stat", foo); if (stat(tmp, &st)) { - p = dirname(foo); - sprintf(tmp, "%s/queue", p); + /* + * if this is inside a partition dir, jump back to parent + */ + sprintf(tmp, "%s/queue", foo); if (stat(tmp, &st)) { - fprintf(stderr, "unknown sysfs layout\n"); - return; + p = dirname(foo); + sprintf(tmp, "%s/queue", p); + if (stat(tmp, &st)) { + fprintf(stderr, "unknown sysfs layout\n"); + return; + } + sprintf(foo, "%s", p); } - sprintf(foo, "%s", p); } disk_util_add(dev, foo); @@ -1613,9 +1771,10 @@ static void clear_io_state(struct thread_data *td) if (td->io_engine == FIO_SYNCIO) lseek(td->fd, SEEK_SET, 0); - td->last_bytes = 0; + td->last_pos = 0; td->stat_io_bytes[0] = td->stat_io_bytes[1] = 0; td->this_io_bytes[0] = td->this_io_bytes[1] = 0; + td->zone_bytes = 0; if (td->file_map) memset(td->file_map, 0, td->num_maps * sizeof(long)); @@ -1646,6 +1805,11 @@ static void *thread_main(void *data) td->pid = getpid(); + INIT_LIST_HEAD(&td->io_u_freelist); + INIT_LIST_HEAD(&td->io_u_busylist); + INIT_LIST_HEAD(&td->io_hist_list); + INIT_LIST_HEAD(&td->io_log_list); + if (init_io_u(td)) goto err; @@ -1657,6 +1821,9 @@ static void *thread_main(void *data) if (init_io(td)) goto err; + if (init_iolog(td)) + goto err; + if (td->ioprio) { if (ioprio_set(IOPRIO_WHO_PROCESS, 0, td->ioprio) == -1) { td_verror(td, errno); @@ -1689,6 +1856,9 @@ static void *thread_main(void *data) do_io(td); td->runtime[td->ddir] += mtime_since_now(&td->start); + if (td_rw(td) && td->io_bytes[td->ddir ^ 1]) + td->runtime[td->ddir ^ 1] = td->runtime[td->ddir]; + update_rusage_stat(td); if (td->error || td->terminate) @@ -1786,7 +1956,7 @@ static void show_ddir_status(struct thread_data *td, struct group_run_stats *rs, return; bw = td->io_bytes[ddir] / td->runtime[ddir]; - printf(" %s: io=%6luMiB, bw=%6luKiB/s, runt=%6lumsec\n", ddir_str[ddir], td->io_bytes[ddir] >> 20, bw, td->runtime[ddir]); + printf(" %s: io=%6lluMiB, bw=%6luKiB/s, runt=%6lumsec\n", ddir_str[ddir], td->io_bytes[ddir] >> 20, bw, td->runtime[ddir]); if (calc_lat(&td->slat_stat[ddir], &min, &max, &mean, &dev)) printf(" slat (msec): min=%5lu, max=%5lu, avg=%5.02f, dev=%5.02f\n", min, max, mean, dev); @@ -1813,7 +1983,8 @@ static void show_thread_status(struct thread_data *td, printf("Client%d (groupid=%d): err=%2d:\n", td->thread_number, td->groupid, td->error); show_ddir_status(td, rs, td->ddir); - show_ddir_status(td, rs, td->ddir ^ 1); + if (td->io_bytes[td->ddir ^ 1]) + show_ddir_status(td, rs, td->ddir ^ 1); if (td->runtime[0] + td->runtime[1]) { double runt = td->runtime[0] + td->runtime[1]; @@ -1843,7 +2014,12 @@ static void check_str_update(struct thread_data *td) c = 'E'; break; case TD_RUNNING: - if (td_read(td)) { + if (td_rw(td)) { + if (td->sequential) + c = 'M'; + else + c = 'm'; + } else if (td_read(td)) { if (td->sequential) c = 'R'; else @@ -1900,14 +2076,80 @@ static void eta_to_str(char *str, int eta_sec) str += sprintf(str, "%02ds", s); } +static int thread_eta(struct thread_data *td, unsigned long elapsed) +{ + unsigned long long bytes_total, bytes_done; + unsigned int eta_sec = 0; + + bytes_total = td->total_io_size; + + /* + * if writing, bytes_total will be twice the size. If mixing, + * assume a 50/50 split and thus bytes_total will be 50% larger. + */ + if (td->verify) { + if (td_rw(td)) + bytes_total = bytes_total * 3 / 2; + else + bytes_total <<= 1; + } + if (td->zone_size && td->zone_skip) + bytes_total /= (td->zone_skip / td->zone_size); + + if (td->runstate == TD_RUNNING || td->runstate == TD_VERIFYING) { + double perc; + + bytes_done = td->io_bytes[DDIR_READ] + td->io_bytes[DDIR_WRITE]; + perc = (double) bytes_done / (double) bytes_total; + if (perc > 1.0) + perc = 1.0; + + eta_sec = (elapsed * (1.0 / perc)) - elapsed; + + if (td->timeout && eta_sec > (td->timeout - elapsed)) + eta_sec = td->timeout - elapsed; + } else if (td->runstate == TD_NOT_CREATED || td->runstate == TD_CREATED) { + int t_eta = 0, r_eta = 0; + + /* + * We can only guess - assume it'll run the full timeout + * if given, otherwise assume it'll run at the specified rate. + */ + if (td->timeout) + t_eta = td->timeout + td->start_delay - elapsed; + if (td->rate) { + r_eta = (bytes_total / 1024) / td->rate; + r_eta += td->start_delay - elapsed; + } + + if (r_eta && t_eta) + eta_sec = min(r_eta, t_eta); + else if (r_eta) + eta_sec = r_eta; + else if (t_eta) + eta_sec = t_eta; + else + eta_sec = INT_MAX; + } else { + /* + * thread is already done + */ + eta_sec = 0; + } + + return eta_sec; +} + static void print_thread_status(void) { - unsigned long long bytes_done, bytes_total; - int i, nr_running, t_rate, m_rate, eta_sec; + unsigned long elapsed = time_since_now(&genesis); + int i, nr_running, t_rate, m_rate, *eta_secs, eta_sec; char eta_str[32]; - double perc; + double perc = 0.0; + + eta_secs = malloc(thread_number * sizeof(int)); + memset(eta_secs, 0, thread_number * sizeof(int)); - bytes_done = bytes_total = 0; nr_running = t_rate = m_rate = 0; for (i = 0; i < thread_number; i++) { struct thread_data *td = &threads[i]; @@ -1918,42 +2160,44 @@ static void print_thread_status(void) m_rate += td->ratemin; } - bytes_total += td->total_io_size; - if (td->verify) - bytes_total += td->total_io_size; - - bytes_done += td->io_bytes[DDIR_READ] +td->io_bytes[DDIR_WRITE]; + if (elapsed >= 3) + eta_secs[i] = thread_eta(td, elapsed); + else + eta_secs[i] = INT_MAX; check_str_update(td); } - perc = 0; - eta_sec = 0; - if (bytes_total && bytes_done) { - unsigned long runtime; - - perc = (double) bytes_done / (double) bytes_total; - if (perc > 1.0) - perc = 1.0; + if (exitall_on_terminate) + eta_sec = INT_MAX; + else + eta_sec = 0; - runtime = time_since_now(&genesis); - if (runtime >= 5) { - memset(eta_str, 0, sizeof(eta_str)); - eta_sec = (runtime * (1.0 / perc)) - runtime; - eta_to_str(eta_str, eta_sec); + for (i = 0; i < thread_number; i++) { + if (exitall_on_terminate) { + if (eta_secs[i] < eta_sec) + eta_sec = eta_secs[i]; + } else { + if (eta_secs[i] > eta_sec) + eta_sec = eta_secs[i]; } + } - perc *= 100.0; + if (eta_sec != INT_MAX && elapsed) { + perc = (double) elapsed / (double) (elapsed + eta_sec); + eta_to_str(eta_str, eta_sec); } printf("Threads now running (%d)", nr_running); if (m_rate || t_rate) printf(", commitrate %d/%dKiB/sec", t_rate, m_rate); - printf(": [%s] [%3.2f%% done]", run_str, perc); - if (eta_sec) - printf(" [eta %s]", eta_str); + if (eta_sec != INT_MAX) { + perc *= 100.0; + printf(": [%s] [%3.2f%% done] [eta %s]", run_str, perc,eta_str); + } printf("\r"); fflush(stdout); + free(eta_secs); } static void reap_threads(int *nr_running, int *t_rate, int *m_rate) @@ -2110,9 +2354,9 @@ static void show_group_stats(struct group_run_stats *rs, int id) printf("\nRun status group %d (all jobs):\n", id); if (rs->max_run[DDIR_READ]) - printf(" READ: io=%luMiB, aggrb=%lu, minb=%lu, maxb=%lu, mint=%lumsec, maxt=%lumsec\n", rs->io_mb[0], rs->agg[0], rs->min_bw[0], rs->max_bw[0], rs->min_run[0], rs->max_run[0]); + printf(" READ: io=%lluMiB, aggrb=%llu, minb=%llu, maxb=%llu, mint=%llumsec, maxt=%llumsec\n", rs->io_mb[0], rs->agg[0], rs->min_bw[0], rs->max_bw[0], rs->min_run[0], rs->max_run[0]); if (rs->max_run[DDIR_WRITE]) - printf(" WRITE: io=%luMiB, aggrb=%lu, minb=%lu, maxb=%lu, mint=%lumsec, maxt=%lumsec\n", rs->io_mb[1], rs->agg[1], rs->min_bw[1], rs->max_bw[1], rs->min_run[1], rs->max_run[1]); + printf(" WRITE: io=%lluMiB, aggrb=%llu, minb=%llu, maxb=%llu, mint=%llumsec, maxt=%llumsec\n", rs->io_mb[1], rs->agg[1], rs->min_bw[1], rs->max_bw[1], rs->min_run[1], rs->max_run[1]); } static void show_disk_util(void)