struct io_completion_data {
int nr; /* input */
- int account; /* input */
int error; /* output */
unsigned long bytes_done[2]; /* output */
static int get_next_rand_block(struct thread_data *td, struct fio_file *f,
enum fio_ddir ddir, unsigned long long *b)
{
- if (get_next_rand_offset(td, f, ddir, b)) {
- dprint(FD_IO, "%s: rand offset failed, last=%llu, size=%llu\n",
- f->file_name, f->last_pos, f->real_file_size);
- return 1;
+ if (!get_next_rand_offset(td, f, ddir, b))
+ return 0;
+
+ if (td->o.time_based) {
+ fio_file_reset(f);
+ if (!get_next_rand_offset(td, f, ddir, b))
+ return 0;
}
- return 0;
+ dprint(FD_IO, "%s: rand offset failed, last=%llu, size=%llu\n",
+ f->file_name, f->last_pos, f->real_file_size);
+ return 1;
}
-static int get_next_seq_block(struct thread_data *td, struct fio_file *f,
- enum fio_ddir ddir, unsigned long long *b)
+static int get_next_seq_offset(struct thread_data *td, struct fio_file *f,
+ enum fio_ddir ddir, unsigned long long *offset)
{
assert(ddir_rw(ddir));
+ if (f->last_pos >= f->io_size && td->o.time_based)
+ f->last_pos = f->last_pos - f->io_size;
+
if (f->last_pos < f->real_file_size) {
unsigned long long pos;
if (pos)
pos += td->o.ddir_seq_add;
- *b = pos / td->o.min_bs[ddir];
+ *offset = pos;
return 0;
}
}
static int get_next_block(struct thread_data *td, struct io_u *io_u,
- enum fio_ddir ddir, int rw_seq, unsigned long long *b)
+ enum fio_ddir ddir, int rw_seq)
{
struct fio_file *f = io_u->file;
+ unsigned long long b, offset;
int ret;
assert(ddir_rw(ddir));
+ b = offset = -1ULL;
+
if (rw_seq) {
if (td_random(td))
- ret = get_next_rand_block(td, f, ddir, b);
+ ret = get_next_rand_block(td, f, ddir, &b);
else
- ret = get_next_seq_block(td, f, ddir, b);
+ ret = get_next_seq_offset(td, f, ddir, &offset);
} else {
io_u->flags |= IO_U_F_BUSY_OK;
if (td->o.rw_seq == RW_SEQ_SEQ) {
- ret = get_next_seq_block(td, f, ddir, b);
+ ret = get_next_seq_offset(td, f, ddir, &offset);
if (ret)
- ret = get_next_rand_block(td, f, ddir, b);
+ ret = get_next_rand_block(td, f, ddir, &b);
} else if (td->o.rw_seq == RW_SEQ_IDENT) {
if (f->last_start != -1ULL)
- *b = (f->last_start - f->file_offset)
- / td->o.min_bs[ddir];
+ offset = f->last_start - f->file_offset;
else
- *b = 0;
+ offset = 0;
ret = 0;
} else {
log_err("fio: unknown rw_seq=%d\n", td->o.rw_seq);
}
}
+ if (!ret) {
+ if (offset != -1ULL)
+ io_u->offset = offset;
+ else if (b != -1ULL)
+ io_u->offset = b * td->o.ba[ddir];
+ else {
+ log_err("fio: bug in offset generation\n");
+ ret = 1;
+ }
+ }
+
return ret;
}
static int __get_next_offset(struct thread_data *td, struct io_u *io_u)
{
struct fio_file *f = io_u->file;
- unsigned long long b;
enum fio_ddir ddir = io_u->ddir;
int rw_seq_hit = 0;
td->ddir_seq_nr = td->o.ddir_seq_nr;
}
- if (get_next_block(td, io_u, ddir, rw_seq_hit, &b))
+ if (get_next_block(td, io_u, ddir, rw_seq_hit))
return 1;
- io_u->offset = b * td->o.ba[ddir];
if (io_u->offset >= f->io_size) {
dprint(FD_IO, "get_next_offset: offset %llu >= io_size %llu\n",
io_u->offset, f->io_size);
if (minbs == maxbs)
return minbs;
+ /*
+ * If we can't satisfy the min block size from here, then fail
+ */
+ if (!io_u_fits(td, io_u, minbs))
+ return 0;
+
if (td->o.use_os_rand)
rand_max = OS_RAND_MAX;
else
/*
* See if it's time to switch to a new zone
*/
- if (td->zone_bytes >= td->o.zone_size) {
+ if (td->zone_bytes >= td->o.zone_size && td->o.zone_skip) {
td->zone_bytes = 0;
io_u->file->file_offset += td->o.zone_range + td->o.zone_skip;
io_u->file->last_pos = io_u->file->file_offset;
assert(io_u->flags & IO_U_F_FREE);
io_u->flags &= ~(IO_U_F_FREE | IO_U_F_FREE_DEF);
io_u->flags &= ~(IO_U_F_TRIMMED | IO_U_F_BARRIER);
+ io_u->flags &= ~IO_U_F_VER_LIST;
io_u->error = 0;
flist_del(&io_u->list);
if (td->o.verify_backlog && td->io_hist_len) {
int get_verify = 0;
- if (td->verify_batch) {
- td->verify_batch--;
+ if (td->verify_batch)
get_verify = 1;
- } else if (!(td->io_hist_len % td->o.verify_backlog) &&
+ else if (!(td->io_hist_len % td->o.verify_backlog) &&
td->last_ddir != DDIR_READ) {
td->verify_batch = td->o.verify_batch;
if (!td->verify_batch)
get_verify = 1;
}
- if (get_verify && !get_next_verify(td, io_u))
+ if (get_verify && !get_next_verify(td, io_u)) {
+ td->verify_batch--;
return 1;
+ }
}
return 0;
f->last_pos = io_u->offset + io_u->buflen;
if (io_u->ddir == DDIR_WRITE) {
- if (td->o.verify != VERIFY_NONE)
- populate_verify_io_u(td, io_u);
- else if (td->o.refill_buffers)
- io_u_fill_buffer(td, io_u, io_u->xfer_buflen);
- else if (td->o.scramble_buffers)
+ if (td->o.refill_buffers) {
+ io_u_fill_buffer(td, io_u,
+ io_u->xfer_buflen, io_u->xfer_buflen);
+ } else if (td->o.scramble_buffers)
do_scramble = 1;
+ if (td->o.verify != VERIFY_NONE) {
+ populate_verify_io_u(td, io_u);
+ do_scramble = 0;
+ }
} else if (io_u->ddir == DDIR_READ) {
/*
* Reset the buf_filled parameters so next time if the
{
unsigned long uninitialized_var(lusec);
- if (!icd->account)
- return;
-
if (!td->o.disable_clat || !td->o.disable_bw)
lusec = utime_since(&io_u->issue_time, &icd->time);
td->io_blocks[idx]++;
td->this_io_blocks[idx]++;
td->io_bytes[idx] += bytes;
- td->this_io_bytes[idx] += bytes;
+
+ if (!(io_u->flags & IO_U_F_VER_LIST))
+ td->this_io_bytes[idx] += bytes;
if (idx == DDIR_WRITE) {
f = io_u->file;
}
}
- if (ramp_time_over(td) && td->runstate == TD_RUNNING) {
+ if (ramp_time_over(td) && (td->runstate == TD_RUNNING ||
+ td->runstate == TD_VERIFYING)) {
account_io_completion(td, io_u, icd, idx, bytes);
if (__should_check_rate(td, idx)) {
fio_gettime(&icd->time, NULL);
icd->nr = nr;
- icd->account = 1;
icd->error = 0;
icd->bytes_done[0] = icd->bytes_done[1] = 0;
if (!(io_u->flags & IO_U_F_FREE_DEF))
put_io_u(td, io_u);
-
- icd->account = 0;
}
}
* "randomly" fill the buffer contents
*/
void io_u_fill_buffer(struct thread_data *td, struct io_u *io_u,
- unsigned int max_bs)
+ unsigned int min_write, unsigned int max_bs)
{
io_u->buf_filled_len = 0;
- if (!td->o.zero_buffers)
- fill_random_buf(&td->buf_state, io_u->buf, max_bs);
- else
+ if (!td->o.zero_buffers) {
+ unsigned int perc = td->o.compress_percentage;
+
+ if (perc) {
+ unsigned int seg = min_write;
+
+ seg = min(min_write, td->o.compress_chunk);
+ fill_random_buf_percentage(&td->buf_state, io_u->buf,
+ perc, seg, max_bs);
+ } else
+ fill_random_buf(&td->buf_state, io_u->buf, max_bs);
+ } else
memset(io_u->buf, 0, max_bs);
}
projects / fio.git / blobdiff