X-Git-Url: https://git.kernel.dk/?a=blobdiff_plain;f=engines%2Fsyslet-rw.c;h=a293e7f4715d415622f50b971ac1012a513ec9a2;hb=4d06a3384c0bf34d217fa942d85dc70dfc282da9;hp=0263f05ac0f923227a80af0dc50d5fd17bdf3eda;hpb=e49499f8738562e014867ad693a999646d5e1bfb;p=fio.git diff --git a/engines/syslet-rw.c b/engines/syslet-rw.c index 0263f05a..a293e7f4 100644 --- a/engines/syslet-rw.c +++ b/engines/syslet-rw.c @@ -1,5 +1,8 @@ /* - * read/write() engine that uses syslet to be async + * syslet engine + * + * IO engine that does regular pread(2)/pwrite(2) to transfer data, but + * with syslets to make the execution async. * */ #include @@ -7,20 +10,71 @@ #include #include #include +#include #include "../fio.h" #include "../os.h" #ifdef FIO_HAVE_SYSLET +#ifdef __NR_pread64 +#define __NR_fio_pread __NR_pread64 +#define __NR_fio_pwrite __NR_pwrite64 +#else +#define __NR_fio_pread __NR_pread +#define __NR_fio_pwrite __NR_pwrite +#endif + struct syslet_data { struct io_u **events; unsigned int nr_events; struct async_head_user ahu; struct syslet_uatom **ring; + + struct syslet_uatom *head, *tail; }; +static void fio_syslet_complete_atom(struct thread_data *td, + struct syslet_uatom *atom) +{ + struct syslet_data *sd = td->io_ops->data; + struct syslet_uatom *last; + struct io_u *io_u; + + /* + * complete from the beginning of the sequence up to (and + * including) this atom + */ + last = atom; + io_u = atom->private; + atom = io_u->req.head; + + /* + * now complete in right order + */ + do { + long ret; + + io_u = atom->private; + ret = *atom->ret_ptr; + if (ret >= 0) + io_u->resid = io_u->xfer_buflen - ret; + else if (ret < 0) + io_u->error = ret; + + assert(sd->nr_events < td->o.iodepth); + sd->events[sd->nr_events++] = io_u; + + if (atom == last) + break; + + atom = atom->next; + } while (1); + + assert(!last->next); +} + /* * Inspect the ring to see if we have completed events */ @@ -30,25 +84,16 @@ static void fio_syslet_complete(struct thread_data *td) do { struct syslet_uatom *atom; - struct io_u *io_u; - long ret; atom = sd->ring[sd->ahu.user_ring_idx]; if (!atom) break; sd->ring[sd->ahu.user_ring_idx] = NULL; - if (++sd->ahu.user_ring_idx == td->iodepth) + if (++sd->ahu.user_ring_idx == td->o.iodepth) sd->ahu.user_ring_idx = 0; - io_u = atom->private; - ret = *atom->ret_ptr; - if (ret > 0) - io_u->resid = io_u->xfer_buflen - ret; - else if (ret < 0) - io_u->error = ret; - - sd->events[sd->nr_events++] = io_u; + fio_syslet_complete_atom(td, atom); } while (1); } @@ -57,7 +102,6 @@ static int fio_syslet_getevents(struct thread_data *td, int min, struct timespec fio_unused *t) { struct syslet_data *sd = td->io_ops->data; - int get_events; long ret; do { @@ -72,8 +116,7 @@ static int fio_syslet_getevents(struct thread_data *td, int min, /* * OK, we need to wait for some events... */ - get_events = min - sd->nr_events; - ret = async_wait(get_events, sd->ahu.user_ring_idx, &sd->ahu); + ret = async_wait(1, sd->ahu.user_ring_idx, &sd->ahu); if (ret < 0) return -errno; } while (1); @@ -123,9 +166,9 @@ static void fio_syslet_prep_rw(struct io_u *io_u, struct fio_file *f) * prepare rw */ if (io_u->ddir == DDIR_READ) - nr = __NR_pread64; + nr = __NR_fio_pread; else - nr = __NR_pwrite64; + nr = __NR_fio_pwrite; init_atom(&io_u->req.atom, nr, &f->fd, &io_u->xfer_buf, &io_u->xfer_buflen, &io_u->offset, &io_u->req.ret, 0, io_u); @@ -146,52 +189,74 @@ static int fio_syslet_prep(struct thread_data fio_unused *td, struct io_u *io_u) static void cachemiss_thread_start(void) { while (1) - async_thread(); + async_thread(NULL, NULL); } #define THREAD_STACK_SIZE (16384) static unsigned long thread_stack_alloc() { - return (unsigned long)malloc(THREAD_STACK_SIZE) + THREAD_STACK_SIZE; + return (unsigned long) malloc(THREAD_STACK_SIZE) + THREAD_STACK_SIZE; } -static int fio_syslet_queue(struct thread_data *td, struct io_u *io_u) +static void fio_syslet_queued(struct thread_data *td, struct syslet_data *sd) +{ + struct syslet_uatom *atom; + struct timeval now; + + fio_gettime(&now, NULL); + + atom = sd->head; + while (atom) { + struct io_u *io_u = atom->private; + + memcpy(&io_u->issue_time, &now, sizeof(now)); + io_u_queued(td, io_u); + atom = atom->next; + } +} + +static int fio_syslet_commit(struct thread_data *td) { struct syslet_data *sd = td->io_ops->data; struct syslet_uatom *done; - long ret; + + if (!sd->head) + return 0; + + assert(!sd->tail->next); if (!sd->ahu.new_thread_stack) sd->ahu.new_thread_stack = thread_stack_alloc(); + fio_syslet_queued(td, sd); + /* * On sync completion, the atom is returned. So on NULL return * it's queued asynchronously. */ - done = async_exec(&io_u->req.atom, &sd->ahu); + done = async_exec(sd->head, &sd->ahu); - if (!done) - return FIO_Q_QUEUED; + sd->head = sd->tail = NULL; - /* - * completed sync - */ - ret = io_u->req.ret; - if (ret != (long) io_u->xfer_buflen) { - if (ret > 0) { - io_u->resid = io_u->xfer_buflen - ret; - io_u->error = 0; - return FIO_Q_COMPLETED; - } else - io_u->error = errno; - } + if (done) + fio_syslet_complete_atom(td, done); + + return 0; +} - assert(sd->nr_events < td->iodepth); +static int fio_syslet_queue(struct thread_data *td, struct io_u *io_u) +{ + struct syslet_data *sd = td->io_ops->data; - if (io_u->error) + if (sd->tail) { + sd->tail->next = &io_u->req.atom; + sd->tail = &io_u->req.atom; + } else + sd->head = sd->tail = &io_u->req.atom; - return FIO_Q_COMPLETED; + io_u->req.head = sd->head; + return FIO_Q_QUEUED; } static int async_head_init(struct syslet_data *sd, unsigned int depth) @@ -208,8 +273,8 @@ static int async_head_init(struct syslet_data *sd, unsigned int depth) sd->ahu.completion_ring = sd->ring; sd->ahu.ring_size_bytes = ring_size; sd->ahu.head_stack = thread_stack_alloc(); - sd->ahu.head_eip = (unsigned long)cachemiss_thread_start; - sd->ahu.new_thread_eip = (unsigned long)cachemiss_thread_start; + sd->ahu.head_eip = (unsigned long) cachemiss_thread_start; + sd->ahu.new_thread_eip = (unsigned long) cachemiss_thread_start; return 0; } @@ -238,13 +303,13 @@ static int fio_syslet_init(struct thread_data *td) sd = malloc(sizeof(*sd)); memset(sd, 0, sizeof(*sd)); - sd->events = malloc(sizeof(struct io_u *) * td->iodepth); - memset(sd->events, 0, sizeof(struct io_u *) * td->iodepth); + sd->events = malloc(sizeof(struct io_u *) * td->o.iodepth); + memset(sd->events, 0, sizeof(struct io_u *) * td->o.iodepth); /* * This will handily fail for kernels where syslet isn't available */ - if (async_head_init(sd, td->iodepth)) { + if (async_head_init(sd, td->o.iodepth)) { free(sd->events); free(sd); return 1; @@ -260,9 +325,12 @@ static struct ioengine_ops ioengine = { .init = fio_syslet_init, .prep = fio_syslet_prep, .queue = fio_syslet_queue, + .commit = fio_syslet_commit, .getevents = fio_syslet_getevents, .event = fio_syslet_event, .cleanup = fio_syslet_cleanup, + .open_file = generic_open_file, + .close_file = generic_close_file, }; #else /* FIO_HAVE_SYSLET */