#include <assert.h>
#include "fio.h"
+#include "hash.h"
/*
* Change this define to play with the timeout handling
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;
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;
{
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;
}
+static void __io_u_mark_map(unsigned int *map, unsigned int nr)
+{
+ int index = 0;
+
+ 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;
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)
{