X-Git-Url: https://git.kernel.dk/?p=fio.git;a=blobdiff_plain;f=io_u.c;h=53e57b4ffe4a6bcc51907c54ac25ca2531c73d1a;hp=b8f090bd536a5b3d2077e191684b18f062425c7b;hb=9ff9de69348f3def14e9a5dde7401d5e760e3c7c;hpb=e7e6cfb4f22b19de03aa5a0b031d4844dd8b1ebe diff --git a/io_u.c b/io_u.c index b8f090bd..53e57b4f 100644 --- a/io_u.c +++ b/io_u.c @@ -3,13 +3,18 @@ #include #include #include +#include #include "fio.h" #include "os.h" +/* + * Change this define to play with the timeout handling + */ +#undef FIO_USE_TIMEOUT + struct io_completion_data { int nr; /* input */ - endio_handler *handler; /* input */ int error; /* output */ unsigned long bytes_done[2]; /* output */ @@ -100,7 +105,7 @@ static int get_next_offset(struct thread_data *td, struct fio_file *f, unsigned long long b, rb; long r; - if (!td->sequential) { + if (td_random(td)) { unsigned long long max_blocks = f->file_size / td->min_bs[ddir]; int loops = 5; @@ -193,6 +198,9 @@ static enum fio_ddir get_rw_ddir(struct thread_data *td) 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; + io_u->file = NULL; list_del(&io_u->list); list_add(&io_u->list, &td->io_u_freelist); @@ -244,7 +252,7 @@ static int fill_io_u(struct thread_data *td, struct fio_file *f, /* * mark entry before potentially trimming io_u */ - if (!td->read_iolog && !td->sequential && !td->norandommap) + if (!td->read_iolog && td_random(td) && !td->norandommap) mark_random_map(td, f, io_u); /* @@ -289,23 +297,23 @@ static void io_u_mark_latency(struct thread_data *td, unsigned long msec) switch (msec) { default: index++; - case 1024 ... 2047: + case 1000 ... 1999: index++; - case 512 ... 1023: + case 750 ... 999: index++; - case 256 ... 511: + case 500 ... 749: index++; - case 128 ... 255: + case 250 ... 499: index++; - case 64 ... 127: + case 100 ... 249: index++; - case 32 ... 63: + case 50 ... 99: index++; - case 16 ... 31: + case 20 ... 49: index++; - case 8 ... 15: + case 10 ... 19: index++; - case 4 ... 7: + case 4 ... 9: index++; case 2 ... 3: index++; @@ -316,7 +324,27 @@ static void io_u_mark_latency(struct thread_data *td, unsigned long msec) td->io_u_lat[index]++; } -static struct fio_file *get_next_file(struct thread_data *td) +/* + * Get next file to service by choosing one at random + */ +static struct fio_file *get_next_file_rand(struct thread_data *td) +{ + long r = os_random_long(&td->next_file_state); + unsigned int fileno; + struct fio_file *f; + + do { + fileno = (unsigned int) ((double) (td->nr_files - 1) * r / (RAND_MAX + 1.0)); + f = &td->files[fileno]; + if (f->fd != -1) + return f; + } while (1); +} + +/* + * Get next file to service by doing round robin between all available ones + */ +static struct fio_file *get_next_file_rr(struct thread_data *td) { unsigned int old_next_file = td->next_file; struct fio_file *f; @@ -349,9 +377,13 @@ struct io_u *__get_io_u(struct thread_data *td) io_u->buflen = 0; io_u->resid = 0; io_u->file = NULL; + io_u->end_io = NULL; } if (io_u) { + assert(io_u->flags & IO_U_F_FREE); + 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); @@ -381,7 +413,11 @@ struct io_u *get_io_u(struct thread_data *td) if (io_u->file) goto out; - f = get_next_file(td); + if (td->file_service_type == FIO_FSERVICE_RR) + f = get_next_file_rr(td); + else + f = get_next_file_rand(td); + if (!f) { put_io_u(td, io_u); return NULL; @@ -441,6 +477,9 @@ static void io_completed(struct thread_data *td, struct io_u *io_u, { unsigned long msec; + assert(io_u->flags & IO_U_F_FLIGHT); + io_u->flags &= ~IO_U_F_FLIGHT; + if (io_u->ddir == DDIR_SYNC) { td->last_was_sync = 1; return; @@ -471,8 +510,8 @@ static void io_completed(struct thread_data *td, struct io_u *io_u, icd->bytes_done[idx] += bytes; - if (icd->handler) { - ret = icd->handler(io_u); + if (io_u->end_io) { + ret = io_u->end_io(io_u); if (ret && !icd->error) icd->error = ret; } @@ -480,12 +519,10 @@ static void io_completed(struct thread_data *td, struct io_u *io_u, icd->error = io_u->error; } -static void init_icd(struct io_completion_data *icd, endio_handler *handler, - int nr) +static void init_icd(struct io_completion_data *icd, int nr) { fio_gettime(&icd->time, NULL); - icd->handler = handler; icd->nr = nr; icd->error = 0; @@ -509,12 +546,11 @@ static void ios_completed(struct thread_data *td, /* * Complete a single io_u for the sync engines. */ -long io_u_sync_complete(struct thread_data *td, struct io_u *io_u, - endio_handler *handler) +long io_u_sync_complete(struct thread_data *td, struct io_u *io_u) { struct io_completion_data icd; - init_icd(&icd, handler, 1); + init_icd(&icd, 1); io_completed(td, io_u, &icd); put_io_u(td, io_u); @@ -527,9 +563,7 @@ long io_u_sync_complete(struct thread_data *td, struct io_u *io_u, /* * Called to complete min_events number of io for the async engines. */ -long io_u_queued_complete(struct thread_data *td, int min_events, - endio_handler *handler) - +long io_u_queued_complete(struct thread_data *td, int min_events) { struct io_completion_data icd; struct timespec *tvp = NULL; @@ -538,7 +572,7 @@ long io_u_queued_complete(struct thread_data *td, int min_events, if (min_events > 0) { ret = td_io_commit(td); if (ret < 0) { - td_verror(td, -ret); + td_verror(td, -ret, "td_io_commit"); return ret; } } else { @@ -549,12 +583,12 @@ long io_u_queued_complete(struct thread_data *td, int min_events, ret = td_io_getevents(td, min_events, td->cur_depth, tvp); if (ret < 0) { - td_verror(td, -ret); + td_verror(td, -ret, "td_io_getevents"); return ret; } else if (!ret) return ret; - init_icd(&icd, handler, ret); + init_icd(&icd, ret); ios_completed(td, &icd); if (!icd.error) return icd.bytes_done[0] + icd.bytes_done[1]; @@ -572,3 +606,83 @@ void io_u_queued(struct thread_data *td, struct io_u *io_u) slat_time = mtime_since(&io_u->start_time, &io_u->issue_time); add_slat_sample(td, io_u->ddir, slat_time); } + +#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 list_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->name, td->pid); + + list_for_each(entry, &td->io_u_busylist) { + io_u = list_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 +}