* 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);
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 void set_rwmix_bytes(struct thread_data *td)
{
- unsigned long long rbytes;
+ unsigned long issues;
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;
+ issues = td->io_issues[td->rwmix_ddir] - td->rwmix_issues;
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]
+ + (issues * ((100 - diff)) / diff);
}
static inline enum fio_ddir get_rand_ddir(struct thread_data *td)
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);
return 0;
}
-void io_u_mark_depth(struct thread_data *td, struct io_u *io_u)
+void io_u_mark_depth(struct thread_data *td, unsigned int nr)
{
int index = 0;
- if (io_u->ddir == DDIR_SYNC)
- return;
-
switch (td->cur_depth) {
default:
index = 6;
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.
projects / fio.git / blobdiff