#include "fio.h"
#include "hash.h"
-/*
- * Change this define to play with the timeout handling
- */
-#undef FIO_USE_TIMEOUT
-
struct io_completion_data {
int nr; /* input */
if (td_random(td) && (td->o.ddir_nr && !--td->ddir_nr)) {
td->ddir_nr = td->o.ddir_nr;
- if (get_next_rand_offset(td, f, ddir, &b))
+ if (get_next_rand_offset(td, f, ddir, &b)) {
+ dprint(FD_IO, "%s: getting rand offset failed\n",
+ f->file_name);
return 1;
+ }
} else {
if (f->last_pos >= f->real_file_size) {
if (!td_random(td) ||
- get_next_rand_offset(td, f, ddir, &b))
+ get_next_rand_offset(td, f, ddir, &b)) {
+ dprint(FD_IO, "%s: pos %llu > size %llu\n",
+ f->file_name, f->last_pos,
+ f->real_file_size);
return 1;
+ }
} else
b = (f->last_pos - f->file_offset) / td->o.min_bs[ddir];
}
do {
long r = os_random_long(&td->next_file_state);
+ int opened = 0;
fno = (unsigned int) ((double) td->o.nr_files
* (r / (OS_RAND_MAX + 1.0)));
if (f->flags & FIO_FILE_DONE)
continue;
+ if (!(f->flags & FIO_FILE_OPEN)) {
+ int err;
+
+ err = td_io_open_file(td, f);
+ if (err)
+ continue;
+ opened = 1;
+ }
+
if ((!goodf || (f->flags & goodf)) && !(f->flags & badf)) {
dprint(FD_FILE, "get_next_file_rand: %p\n", f);
return f;
}
+ if (opened)
+ td_io_close_file(td, f);
} while (1);
}
struct fio_file *f;
do {
+ int opened = 0;
+
f = td->files[td->next_file];
td->next_file++;
if (td->next_file >= td->o.nr_files)
td->next_file = 0;
+ dprint(FD_FILE, "trying file %s %x\n", f->file_name, f->flags);
if (f->flags & FIO_FILE_DONE) {
f = NULL;
continue;
}
+ if (!(f->flags & FIO_FILE_OPEN)) {
+ int err;
+
+ err = td_io_open_file(td, f);
+ if (err)
+ continue;
+ opened = 1;
+ }
+
if ((!goodf || (f->flags & goodf)) && !(f->flags & badf))
break;
+ if (opened)
+ td_io_close_file(td, f);
+
f = NULL;
} while (td->next_file != old_next_file);
}
f = td->file_service_file;
- if (f && (f->flags & FIO_FILE_OPEN) && td->file_service_left--)
- goto out;
+ if (f && (f->flags & FIO_FILE_OPEN) && !(f->flags & FIO_FILE_CLOSING)) {
+ if (td->o.file_service_type == FIO_FSERVICE_SEQ)
+ goto out;
+ if (td->file_service_left--)
+ goto out;
+ }
- if (td->o.file_service_type == FIO_FSERVICE_RR)
+ if (td->o.file_service_type == FIO_FSERVICE_RR ||
+ td->o.file_service_type == FIO_FSERVICE_SEQ)
f = get_next_file_rr(td, FIO_FILE_OPEN, FIO_FILE_CLOSING);
else
f = get_next_file_rand(td, FIO_FILE_OPEN, FIO_FILE_CLOSING);
td->file_service_file = f;
td->file_service_left = td->file_service_nr - 1;
out:
- dprint(FD_FILE, "get_next_file: %p\n", f);
+ dprint(FD_FILE, "get_next_file: %p [%s]\n", f, f->file_name);
return f;
}
td_io_close_file(td, f);
f->flags |= FIO_FILE_DONE;
td->nr_done_files++;
+ dprint(FD_FILE, "%s: is done (%d of %d)\n", f->file_name, td->nr_done_files, td->o.nr_files);
/*
* probably not the right place to do this, but see
out:
if (!td_io_prep(td, io_u)) {
- fio_gettime(&io_u->start_time, NULL);
+ if (!td->o.disable_slat)
+ fio_gettime(&io_u->start_time, NULL);
return io_u;
}
err_put:
static void io_completed(struct thread_data *td, struct io_u *io_u,
struct io_completion_data *icd)
{
- unsigned long usec;
+ /*
+ * Older gcc's are too dumb to realize that usec is always used
+ * initialized, silence that warning.
+ */
+ unsigned long uninitialized_var(usec);
dprint_io_u(io_u, "io complete");
if (!io_u->error) {
unsigned int bytes = io_u->buflen - io_u->resid;
const enum fio_ddir idx = io_u->ddir;
- int ret, ramp_done;
+ int ret;
- ramp_done = ramp_time_over(td);
+ td->io_blocks[idx]++;
+ td->io_bytes[idx] += bytes;
+ td->this_io_bytes[idx] += bytes;
- if (ramp_done) {
- td->io_blocks[idx]++;
- td->io_bytes[idx] += bytes;
- td->this_io_bytes[idx] += bytes;
+ if (ramp_time_over(td)) {
+ if (!td->o.disable_clat || !td->o.disable_bw)
+ usec = utime_since(&io_u->issue_time,
+ &icd->time);
- usec = utime_since(&io_u->issue_time, &icd->time);
-
- add_clat_sample(td, idx, usec);
- add_bw_sample(td, idx, &icd->time);
- io_u_mark_latency(td, usec);
+ if (!td->o.disable_clat) {
+ add_clat_sample(td, idx, usec);
+ io_u_mark_latency(td, usec);
+ }
+ if (!td->o.disable_bw)
+ add_bw_sample(td, idx, &icd->time);
}
if (td_write(td) && idx == DDIR_WRITE &&
td->o.verify != VERIFY_NONE)
log_io_piece(td, io_u);
- if (ramp_done)
- icd->bytes_done[idx] += bytes;
+ icd->bytes_done[idx] += bytes;
if (io_u->end_io) {
ret = io_u->end_io(td, io_u);
}
}
-static void init_icd(struct io_completion_data *icd, int nr)
+static void init_icd(struct thread_data *td, struct io_completion_data *icd,
+ int nr)
{
- fio_gettime(&icd->time, NULL);
+ if (!td->o.disable_clat || !td->o.disable_bw)
+ fio_gettime(&icd->time, NULL);
icd->nr = nr;
{
struct io_completion_data icd;
- init_icd(&icd, 1);
+ init_icd(td, &icd, 1);
io_completed(td, io_u, &icd);
put_io_u(td, io_u);
} else if (!ret)
return ret;
- init_icd(&icd, ret);
+ init_icd(td, &icd, ret);
ios_completed(td, &icd);
if (!icd.error)
return icd.bytes_done[0] + icd.bytes_done[1];
*/
void io_u_queued(struct thread_data *td, struct io_u *io_u)
{
- unsigned long slat_time;
+ if (!td->o.disable_slat) {
+ unsigned long slat_time;
- slat_time = utime_since(&io_u->start_time, &io_u->issue_time);
- add_slat_sample(td, io_u->ddir, slat_time);
+ slat_time = utime_since(&io_u->start_time, &io_u->issue_time);
+ add_slat_sample(td, io_u->ddir, slat_time);
+ }
}
/*
} else
memset(ptr, 0, max_bs);
}
-
-#ifdef FIO_USE_TIMEOUT
-void io_u_set_timeout(struct thread_data *td)
-{
- assert(td->cur_depth);
-
- td->timer.it_interval.tv_sec = 0;
- td->timer.it_interval.tv_usec = 0;
- td->timer.it_value.tv_sec = IO_U_TIMEOUT + IO_U_TIMEOUT_INC;
- td->timer.it_value.tv_usec = 0;
- setitimer(ITIMER_REAL, &td->timer, NULL);
- fio_gettime(&td->timeout_end, NULL);
-}
-
-static void io_u_dump(struct io_u *io_u)
-{
- unsigned long t_start = mtime_since_now(&io_u->start_time);
- unsigned long t_issue = mtime_since_now(&io_u->issue_time);
-
- log_err("io_u=%p, t_start=%lu, t_issue=%lu\n", io_u, t_start, t_issue);
- log_err(" buf=%p/%p, len=%lu/%lu, offset=%llu\n", io_u->buf,
- io_u->xfer_buf, io_u->buflen,
- io_u->xfer_buflen,
- io_u->offset);
- log_err(" ddir=%d, fname=%s\n", io_u->ddir, io_u->file->file_name);
-}
-#else
-void io_u_set_timeout(struct thread_data fio_unused *td)
-{
-}
-#endif
-
-#ifdef FIO_USE_TIMEOUT
-static void io_u_timeout_handler(int fio_unused sig)
-{
- struct thread_data *td, *__td;
- pid_t pid = getpid();
- struct flist_head *entry;
- struct io_u *io_u;
- int i;
-
- log_err("fio: io_u timeout\n");
-
- /*
- * TLS would be nice...
- */
- td = NULL;
- for_each_td(__td, i) {
- if (__td->pid == pid) {
- td = __td;
- break;
- }
- }
-
- if (!td) {
- log_err("fio: io_u timeout, can't find job\n");
- exit(1);
- }
-
- if (!td->cur_depth) {
- log_err("fio: timeout without pending work?\n");
- return;
- }
-
- log_err("fio: io_u timeout: job=%s, pid=%d\n", td->o.name, td->pid);
-
- flist_for_each(entry, &td->io_u_busylist) {
- io_u = flist_entry(entry, struct io_u, list);
-
- io_u_dump(io_u);
- }
-
- td_verror(td, ETIMEDOUT, "io_u timeout");
- exit(1);
-}
-#endif
-
-void io_u_init_timeout(void)
-{
-#ifdef FIO_USE_TIMEOUT
- signal(SIGALRM, io_u_timeout_handler);
-#endif
-}
projects / fio.git / blobdiff