X-Git-Url: https://git.kernel.dk/?p=fio.git;a=blobdiff_plain;f=engines%2Fsyslet-rw.c;h=dcfcb79f4b16b62c4c0c5038b9548a72ee3cfaf6;hp=0263f05ac0f923227a80af0dc50d5fd17bdf3eda;hb=6a117e0ce9fca919c0477048a9b844d1a84bb005;hpb=e49499f8738562e014867ad693a999646d5e1bfb diff --git a/engines/syslet-rw.c b/engines/syslet-rw.c index 0263f05a..dcfcb79f 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,70 @@ #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 +83,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 +101,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 +115,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 +165,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 +188,81 @@ 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); - - if (!done) - return FIO_Q_QUEUED; + done = async_exec(sd->head, &sd->ahu); - /* - * 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 == (void *) -1) { + log_err("fio: syslets don't appear to work\n"); + return -1; } - assert(sd->nr_events < td->iodepth); + sd->head = sd->tail = NULL; - if (io_u->error) + if (done) + fio_syslet_complete_atom(td, done); - return FIO_Q_COMPLETED; + return 0; +} + +static int fio_syslet_queue(struct thread_data *td, struct io_u *io_u) +{ + struct syslet_data *sd = td->io_ops->data; + + fio_ro_check(td, io_u); + + 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; + + io_u->req.head = sd->head; + return FIO_Q_QUEUED; } static int async_head_init(struct syslet_data *sd, unsigned int depth) @@ -208,8 +279,9 @@ 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; + sd->ahu.new_thread_stack = thread_stack_alloc(); return 0; } @@ -219,6 +291,19 @@ static void async_head_exit(struct syslet_data *sd) free(sd->ring); } +static int check_syslet_support(struct syslet_data *sd) +{ + struct syslet_uatom atom; + void *ret; + + init_atom(&atom, __NR_getpid, NULL, NULL, NULL, NULL, NULL, 0, NULL); + ret = async_exec(sd->head, &sd->ahu); + if (ret == (void *) -1) + return 1; + + return 0; +} + static void fio_syslet_cleanup(struct thread_data *td) { struct syslet_data *sd = td->io_ops->data; @@ -235,16 +320,22 @@ static int fio_syslet_init(struct thread_data *td) { struct syslet_data *sd; - 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; + } + + if (check_syslet_support(sd)) { + log_err("fio: syslets do not appear to work\n"); free(sd->events); free(sd); return 1; @@ -260,9 +351,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 */