dprint(FD_RANDOM, "free: b=%llu, idx=%u, bit=%u\n", block, idx, bit);
- return (f->file_map[idx] & (1UL << bit)) == 0;
+ return (f->file_map[idx] & (1 << bit)) == 0;
}
/*
unsigned int min_bs = td->o.rw_min_bs;
struct fio_file *f = io_u->file;
unsigned long long block;
- unsigned int blocks;
- unsigned int nr_blocks;
+ unsigned int blocks, nr_blocks;
block = (io_u->offset - f->file_offset) / (unsigned long long) min_bs;
- blocks = 0;
nr_blocks = (io_u->buflen + min_bs - 1) / min_bs;
+ blocks = 0;
- while (blocks < nr_blocks) {
+ while (nr_blocks) {
+ unsigned int this_blocks, mask;
unsigned int idx, bit;
/*
* If we have a mixed random workload, we may
* encounter blocks we already did IO to.
*/
- if ((td->o.ddir_nr == 1) && !random_map_free(f, block))
+ if ((td->o.ddir_nr == 1) && !random_map_free(f, block)) {
+ if (!blocks)
+ blocks = 1;
break;
+ }
idx = RAND_MAP_IDX(f, block);
bit = RAND_MAP_BIT(f, block);
fio_assert(td, idx < f->num_maps);
- f->file_map[idx] |= (1UL << bit);
- block++;
- blocks++;
+ this_blocks = nr_blocks;
+ if (this_blocks + bit > BLOCKS_PER_MAP)
+ this_blocks = BLOCKS_PER_MAP - bit;
+
+ if (this_blocks == BLOCKS_PER_MAP)
+ mask = -1U;
+ else
+ mask = ((1U << this_blocks) - 1) << bit;
+
+ fio_assert(td, !(f->file_map[idx] & mask));
+ f->file_map[idx] |= mask;
+ nr_blocks -= this_blocks;
+ blocks += this_blocks;
+ block += this_blocks;
}
if ((blocks * min_bs) < io_u->buflen)
io_u->buflen = blocks * min_bs;
}
-static inline unsigned long long last_block(struct thread_data *td,
- struct fio_file *f,
- enum fio_ddir ddir)
+static unsigned long long last_block(struct thread_data *td, struct fio_file *f,
+ enum fio_ddir ddir)
{
unsigned long long max_blocks;
unsigned long long max_size;
i = f->last_free_lookup;
*b = (i * BLOCKS_PER_MAP);
while ((*b) * min_bs < f->real_file_size) {
- if (f->file_map[i] != -1UL) {
- *b += fio_ffz(f->file_map[i]);
+ if (f->file_map[i] != (unsigned int) -1) {
+ *b += ffz(f->file_map[i]);
if (*b > last_block(td, f, ddir))
break;
f->last_free_lookup = i;
static unsigned int get_next_buflen(struct thread_data *td, struct io_u *io_u)
{
const int ddir = io_u->ddir;
- unsigned int buflen;
+ unsigned int buflen = buflen; /* silence dumb gcc warning */
long r;
if (td->o.min_bs[ddir] == td->o.max_bs[ddir])
static void set_rwmix_bytes(struct thread_data *td)
{
- unsigned long issues;
unsigned int diff;
/*
* buffered writes may issue a lot quicker than they complete,
* whereas reads do not.
*/
- issues = td->io_issues[td->rwmix_ddir] - td->rwmix_issues;
diff = td->o.rwmix[td->rwmix_ddir ^ 1];
-
- td->rwmix_issues = td->io_issues[td->rwmix_ddir]
- + (issues * ((100 - diff)) / diff);
+ td->rwmix_issues = (td->io_issues[td->rwmix_ddir] * diff) / 100;
}
static inline enum fio_ddir get_rand_ddir(struct thread_data *td)
r = os_random_long(&td->rwmix_state);
v = 1 + (int) (100.0 * (r / (RAND_MAX + 1.0)));
- if (v < td->o.rwmix[DDIR_READ])
+ if (v <= td->o.rwmix[DDIR_READ])
return DDIR_READ;
return DDIR_WRITE;
max_bytes = td->this_io_bytes[ddir];
if (max_bytes >=
(td->o.size * td->o.rwmix[ddir] / 100)) {
- if (!td->rw_end_set[ddir])
+ if (!td->rw_end_set[ddir]) {
td->rw_end_set[ddir] = 1;
+ fio_gettime(&td->rw_end[ddir], NULL);
+ }
ddir ^= 1;
}
put_file_log(td, io_u->file);
io_u->file = NULL;
- list_del(&io_u->list);
- list_add(&io_u->list, &td->io_u_freelist);
+ flist_del(&io_u->list);
+ flist_add(&io_u->list, &td->io_u_freelist);
td->cur_depth--;
}
{
struct io_u *__io_u = *io_u;
+ dprint(FD_IO, "requeue %p\n", __io_u);
+
__io_u->flags |= IO_U_F_FREE;
if ((__io_u->flags & IO_U_F_FLIGHT) && (__io_u->ddir != DDIR_SYNC))
td->io_issues[__io_u->ddir]--;
__io_u->flags &= ~IO_U_F_FLIGHT;
- list_del(&__io_u->list);
- list_add_tail(&__io_u->list, &td->io_u_requeues);
+ flist_del(&__io_u->list);
+ flist_add_tail(&__io_u->list, &td->io_u_requeues);
td->cur_depth--;
*io_u = NULL;
}
{
struct io_u *io_u = NULL;
- if (!list_empty(&td->io_u_requeues))
- io_u = list_entry(td->io_u_requeues.next, struct io_u, list);
+ if (!flist_empty(&td->io_u_requeues))
+ io_u = flist_entry(td->io_u_requeues.next, struct io_u, list);
else if (!queue_full(td)) {
- io_u = list_entry(td->io_u_freelist.next, struct io_u, list);
+ io_u = flist_entry(td->io_u_freelist.next, struct io_u, list);
io_u->buflen = 0;
io_u->resid = 0;
io_u->flags &= ~IO_U_F_FREE;
io_u->error = 0;
- list_del(&io_u->list);
- list_add(&io_u->list, &td->io_u_busylist);
+ flist_del(&io_u->list);
+ flist_add(&io_u->list, &td->io_u_busylist);
td->cur_depth++;
}
if (td->o.verify != VERIFY_NONE)
populate_verify_io_u(td, io_u);
+ else if (td->o.refill_buffers && io_u->ddir == DDIR_WRITE)
+ io_u_fill_buffer(td, io_u, io_u->xfer_buflen);
}
/*
io_u->xfer_buf = io_u->buf;
io_u->xfer_buflen = io_u->buflen;
- if (td->o.refill_buffers && io_u->ddir == DDIR_WRITE)
- io_u_fill_buffer(td, io_u, io_u->xfer_buflen);
out:
if (!td_io_prep(td, io_u)) {
fio_gettime(&io_u->start_time, NULL);
{
struct thread_data *td, *__td;
pid_t pid = getpid();
- struct list_head *entry;
+ struct flist_head *entry;
struct io_u *io_u;
int i;
log_err("fio: io_u timeout: job=%s, pid=%d\n", td->o.name, td->pid);
- list_for_each(entry, &td->io_u_busylist) {
- io_u = list_entry(entry, struct io_u, list);
+ flist_for_each(entry, &td->io_u_busylist) {
+ io_u = flist_entry(entry, struct io_u, list);
io_u_dump(io_u);
}