#include <assert.h>
#include "fio.h"
+#include "hash.h"
/*
* Change this define to play with the timeout handling
* The ->file_map[] contains a map of blocks we have or have not done io
* to yet. Used to make sure we cover the entire range in a fair fashion.
*/
-static int random_map_free(struct thread_data *td, struct fio_file *f,
- const unsigned long long block)
+static int random_map_free(struct fio_file *f, const unsigned long long block)
{
- unsigned int idx = RAND_MAP_IDX(td, f, block);
- unsigned int bit = RAND_MAP_BIT(td, f, block);
+ unsigned int idx = RAND_MAP_IDX(f, block);
+ unsigned int bit = RAND_MAP_BIT(f, block);
dprint(FD_RANDOM, "free: b=%llu, idx=%u, bit=%u\n", block, 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(td, f, block))
+ if ((td->o.ddir_nr == 1) && !random_map_free(f, block))
break;
- idx = RAND_MAP_IDX(td, f, block);
- bit = RAND_MAP_BIT(td, f, block);
+ idx = RAND_MAP_IDX(f, block);
+ bit = RAND_MAP_BIT(f, block);
fio_assert(td, idx < f->num_maps);
enum fio_ddir ddir)
{
unsigned long long max_blocks;
+ unsigned long long max_size;
- max_blocks = f->io_size / (unsigned long long) td->o.min_bs[ddir];
+ /*
+ * Hmm, should we make sure that ->io_size <= ->real_file_size?
+ */
+ max_size = f->io_size;
+ if (max_size > f->real_file_size)
+ max_size = f->real_file_size;
+
+ max_blocks = max_size / (unsigned long long) td->o.min_bs[ddir];
if (!max_blocks)
return 0;
- return max_blocks - 1;
+ return max_blocks;
}
/*
/*
* calculate map offset and check if it's free
*/
- if (random_map_free(td, f, *b))
+ if (random_map_free(f, *b))
return 0;
dprint(FD_RANDOM, "get_next_rand_offset: offset %llu busy\n",
b = (f->last_pos - f->file_offset) / td->o.min_bs[ddir];
}
- io_u->offset = (b * td->o.min_bs[ddir]) + f->file_offset;
+ io_u->offset = b * td->o.min_bs[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);
+ return 1;
+ }
+
+ io_u->offset += f->file_offset;
if (io_u->offset >= f->real_file_size) {
dprint(FD_IO, "get_next_offset: offset %llu >= size %llu\n",
io_u->offset, f->real_file_size);
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 long rbytes;
unsigned int diff;
/*
* buffered writes may issue a lot quicker than they complete,
* whereas reads do not.
*/
- rbytes = td->io_bytes[td->rwmix_ddir] - td->rwmix_bytes;
diff = td->o.rwmix[td->rwmix_ddir ^ 1];
-
- td->rwmix_bytes = td->io_bytes[td->rwmix_ddir]
- + (rbytes * ((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;
static enum fio_ddir get_rw_ddir(struct thread_data *td)
{
if (td_rw(td)) {
- struct timeval now;
- unsigned long elapsed;
- unsigned int cycle;
-
- fio_gettime(&now, NULL);
- elapsed = mtime_since_now(&td->rwmix_switch);
-
- /*
- * if this is the first cycle, make it shorter
- */
- cycle = td->o.rwmixcycle;
- if (!td->rwmix_bytes)
- cycle /= 10;
-
/*
* Check if it's time to seed a new data direction.
*/
- if (elapsed >= cycle ||
- td->io_bytes[td->rwmix_ddir] >= td->rwmix_bytes) {
+ if (td->io_issues[td->rwmix_ddir] >= td->rwmix_issues) {
unsigned long long max_bytes;
enum fio_ddir ddir;
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;
- memcpy(&td->rw_end[ddir], &now,
- sizeof(now));
- }
+
ddir ^= 1;
}
set_rwmix_bytes(td);
td->rwmix_ddir = ddir;
- memcpy(&td->rwmix_switch, &now, sizeof(now));
}
return td->rwmix_ddir;
} else if (td_read(td))
return DDIR_WRITE;
}
+static void put_file_log(struct thread_data *td, struct fio_file *f)
+{
+ int ret = put_file(td, f);
+
+ if (ret)
+ td_verror(td, ret, "file close");
+}
+
void put_io_u(struct thread_data *td, struct io_u *io_u)
{
assert((io_u->flags & IO_U_F_FREE) == 0);
io_u->flags |= IO_U_F_FREE;
- if (io_u->file) {
- int ret = put_file(td, io_u->file);
-
- if (ret)
- td_verror(td, ret, "file close");
- }
+ if (io_u->file)
+ put_file_log(td, io_u->file);
io_u->file = NULL;
list_del(&io_u->list);
{
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]--;
return 0;
}
-void io_u_mark_depth(struct thread_data *td, struct io_u *io_u)
+static void __io_u_mark_map(unsigned int *map, unsigned int nr)
{
int index = 0;
- if (io_u->ddir == DDIR_SYNC)
- return;
+ switch (nr) {
+ default:
+ index = 6;
+ break;
+ case 33 ... 64:
+ index = 5;
+ break;
+ case 17 ... 32:
+ index = 4;
+ break;
+ case 9 ... 16:
+ index = 3;
+ break;
+ case 5 ... 8:
+ index = 2;
+ break;
+ case 1 ... 4:
+ index = 1;
+ case 0:
+ break;
+ }
+
+ map[index]++;
+}
+
+void io_u_mark_submit(struct thread_data *td, unsigned int nr)
+{
+ __io_u_mark_map(td->ts.io_u_submit, nr);
+ td->ts.total_submit++;
+}
+
+void io_u_mark_complete(struct thread_data *td, unsigned int nr)
+{
+ __io_u_mark_map(td->ts.io_u_complete, nr);
+ td->ts.total_complete++;
+}
+
+void io_u_mark_depth(struct thread_data *td, unsigned int nr)
+{
+ int index = 0;
switch (td->cur_depth) {
default:
break;
}
- td->ts.io_u_map[index]++;
- td->ts.total_io_u[io_u->ddir]++;
+ td->ts.io_u_map[index] += nr;
}
static void io_u_mark_lat_usec(struct thread_data *td, unsigned long usec)
if (!fill_io_u(td, io_u))
break;
+ /*
+ * optimization to prevent close/open of the same file. This
+ * way we preserve queueing etc.
+ */
+ if (td->o.nr_files == 1 && td->o.time_based) {
+ put_file_log(td, f);
+ fio_file_reset(f);
+ goto set_file;
+ }
+
/*
* td_io_close() does a put_file() as well, so no need to
* do that here.
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->endpos = io_u->offset + io_u->buflen;
io_u->xfer_buf = io_u->buf;
io_u->xfer_buflen = io_u->buflen;
+
out:
if (!td_io_prep(td, io_u)) {
fio_gettime(&io_u->start_time, NULL);
add_slat_sample(td, io_u->ddir, slat_time);
}
+/*
+ * "randomly" fill the buffer contents
+ */
+void io_u_fill_buffer(struct thread_data *td, struct io_u *io_u,
+ unsigned int max_bs)
+{
+ long *ptr = io_u->buf;
+
+ if (!td->o.zero_buffers) {
+ while ((void *) ptr - io_u->buf < max_bs) {
+ *ptr = rand() * GOLDEN_RATIO_PRIME;
+ ptr++;
+ }
+ } else
+ memset(ptr, 0, max_bs);
+}
+
#ifdef FIO_USE_TIMEOUT
void io_u_set_timeout(struct thread_data *td)
{