engines/guasi.c

   1 /*
   2  * guasi engine
   3  *
   4  * IO engine using the GUASI library.
   5  *
   6  * This is currently disabled. To enable it, execute:
   7  *
   8  * $ export EXTFLAGS="-DFIO_HAVE_GUASI"
   9  * $ export EXTLIBS="-lguasi"
  10  *
  11  * before running make. You'll need the GUASI lib as well:
  12  *
  13  * http://www.xmailserver.org/guasi-lib.html
  14  *
  15  */
  16 #include <stdio.h>
  17 #include <stdlib.h>
  18 #include <unistd.h>
  19 #include <errno.h>
  20 #include <assert.h>
  21
  22 #include "../fio.h"
  23
  24 #ifdef FIO_HAVE_GUASI
  25
  26 #define GFIO_MIN_THREADS 32
  27 #ifndef GFIO_MAX_THREADS
  28 #define GFIO_MAX_THREADS 2000
  29 #endif
  30
  31 #include <guasi.h>
  32 #include <guasi_syscalls.h>
  33
  34 #ifdef GFIO_DEBUG
  35 #define GDBG_PRINT(a) printf a
  36 #else
  37 #define GDBG_PRINT(a) (void) 0
  38 #endif
  39
  40 struct guasi_data {
  41         guasi_t hctx;
  42         int max_reqs;
  43         guasi_req_t *reqs;
  44         struct io_u **io_us;
  45         int queued_nr;
  46         int reqs_nr;
  47 };
  48
  49 static int fio_guasi_prep(struct thread_data fio_unused *td, struct io_u *io_u)
  50 {
  51
  52         GDBG_PRINT(("fio_guasi_prep(%p)\n", io_u));
  53         io_u->greq = NULL;
  54
  55         return 0;
  56 }
  57
  58 static struct io_u *fio_guasi_event(struct thread_data *td, int event)
  59 {
  60         struct guasi_data *ld = td->io_ops->data;
  61         struct io_u *io_u;
  62         struct guasi_reqinfo rinf;
  63
  64         GDBG_PRINT(("fio_guasi_event(%d)\n", event));
  65         if (guasi_req_info(ld->reqs[event], &rinf) < 0) {
  66                 log_err("guasi_req_info(%d) FAILED!\n", event);
  67                 return NULL;
  68         }
  69         io_u = rinf.asid;
  70         io_u->error = EINPROGRESS;
  71         GDBG_PRINT(("fio_guasi_event(%d) -> %p\n", event, io_u));
  72         if (rinf.status == GUASI_STATUS_COMPLETE) {
  73                 io_u->error = rinf.result;
  74                 if (io_u->ddir == DDIR_READ ||
  75                     io_u->ddir == DDIR_WRITE) {
  76                         io_u->error = 0;
  77                         if (rinf.result != (long) io_u->xfer_buflen) {
  78                                 if (rinf.result >= 0)
  79                                         io_u->resid = io_u->xfer_buflen - rinf.result;
  80                                 else
  81                                         io_u->error = rinf.error;
  82                         }
  83                 }
  84         }
  85
  86         return io_u;
  87 }
  88
  89 static int fio_guasi_getevents(struct thread_data *td, unsigned int min,
  90                                unsigned int max, struct timespec *t)
  91 {
  92         struct guasi_data *ld = td->io_ops->data;
  93         int n, r;
  94         long timeo = -1;
  95
  96         GDBG_PRINT(("fio_guasi_getevents(%d, %d)\n", min, max));
  97         if (min > ld->max_reqs)
  98                 min = ld->max_reqs;
  99         if (max > ld->max_reqs)
 100                 max = ld->max_reqs;
 101         if (t)
 102                 timeo = t->tv_sec * 1000L + t->tv_nsec / 1000000L;
 103         for (n = 0; n < ld->reqs_nr; n++)
 104                 guasi_req_free(ld->reqs[n]);
 105         n = 0;
 106         do {
 107                 r = guasi_fetch(ld->hctx, ld->reqs + n, min - n,
 108                                 max - n, timeo);
 109                 if (r < 0) {
 110                         log_err("guasi_fetch() FAILED! (%d)\n", r);
 111                         break;
 112                 }
 113                 n += r;
 114                 if (n >= min)
 115                         break;
 116         } while (1);
 117         ld->reqs_nr = n;
 118         GDBG_PRINT(("fio_guasi_getevents() -> %d\n", n));
 119
 120         return n;
 121 }
 122
 123 static int fio_guasi_queue(struct thread_data *td, struct io_u *io_u)
 124 {
 125         struct guasi_data *ld = td->io_ops->data;
 126
 127         fio_ro_check(td, io_u);
 128
 129         GDBG_PRINT(("fio_guasi_queue(%p)\n", io_u));
 130         if (ld->queued_nr == (int) td->o.iodepth)
 131                 return FIO_Q_BUSY;
 132
 133         ld->io_us[ld->queued_nr] = io_u;
 134         ld->queued_nr++;
 135         return FIO_Q_QUEUED;
 136 }
 137
 138 static void fio_guasi_queued(struct thread_data *td, struct io_u **io_us, int nr)
 139 {
 140         int i;
 141         struct io_u *io_u;
 142         struct timeval now;
 143
 144         if (!fio_fill_issue_time(td))
 145                 return;
 146
 147         io_u_mark_submit(td, nr);
 148         fio_gettime(&now, NULL);
 149         for (i = 0; i < nr; i++) {
 150                 io_u = io_us[i];
 151                 memcpy(&io_u->issue_time, &now, sizeof(now));
 152                 io_u_queued(td, io_u);
 153         }
 154 }
 155
 156 static int fio_guasi_commit(struct thread_data *td)
 157 {
 158         struct guasi_data *ld = td->io_ops->data;
 159         int i;
 160         struct io_u *io_u;
 161         struct fio_file *f;
 162
 163         GDBG_PRINT(("fio_guasi_commit(%d)\n", ld->queued_nr));
 164         for (i = 0; i < ld->queued_nr; i++) {
 165                 io_u = ld->io_us[i];
 166                 GDBG_PRINT(("fio_guasi_commit(%d) --> %p\n", i, io_u));
 167                 f = io_u->file;
 168                 io_u->greq = NULL;
 169                 if (io_u->ddir == DDIR_READ)
 170                         io_u->greq = guasi__pread(ld->hctx, ld, io_u, 0,
 171                                                   f->fd, io_u->xfer_buf, io_u->xfer_buflen,
 172                                                   io_u->offset);
 173                 else if (io_u->ddir == DDIR_WRITE)
 174                         io_u->greq = guasi__pwrite(ld->hctx, ld, io_u, 0,
 175                                                    f->fd, io_u->xfer_buf, io_u->xfer_buflen,
 176                                                    io_u->offset);
 177                 else if (io_u->ddir == DDIR_SYNC)
 178                         io_u->greq = guasi__fsync(ld->hctx, ld, io_u, 0, f->fd);
 179                 else {
 180                         log_err("fio_guasi_commit() FAILED: unknow request %d\n",
 181                                 io_u->ddir);
 182                 }
 183                 if (io_u->greq == NULL) {
 184                         log_err("fio_guasi_commit() FAILED: submit failed (%s)\n",
 185                                 strerror(errno));
 186                         return -1;
 187                 }
 188         }
 189         fio_guasi_queued(td, ld->io_us, i);
 190         ld->queued_nr = 0;
 191         GDBG_PRINT(("fio_guasi_commit() -> %d\n", i));
 192
 193         return 0;
 194 }
 195
 196 static int fio_guasi_cancel(struct thread_data fio_unused *td,
 197                             struct io_u *io_u)
 198 {
 199         GDBG_PRINT(("fio_guasi_cancel(%p) req=%p\n", io_u, io_u->greq));
 200         if (io_u->greq != NULL)
 201                 guasi_req_cancel(io_u->greq);
 202
 203         return 0;
 204 }
 205
 206 static void fio_guasi_cleanup(struct thread_data *td)
 207 {
 208         struct guasi_data *ld = td->io_ops->data;
 209         int n;
 210
 211         GDBG_PRINT(("fio_guasi_cleanup(%p)\n", ld));
 212         if (ld) {
 213                 for (n = 0; n < ld->reqs_nr; n++)
 214                         guasi_req_free(ld->reqs[n]);
 215                 guasi_free(ld->hctx);
 216                 free(ld->reqs);
 217                 free(ld->io_us);
 218                 free(ld);
 219         }
 220         GDBG_PRINT(("fio_guasi_cleanup(%p) DONE\n", ld));
 221 }
 222
 223 static int fio_guasi_init(struct thread_data *td)
 224 {
 225         int maxthr;
 226         struct guasi_data *ld = malloc(sizeof(*ld));
 227
 228         GDBG_PRINT(("fio_guasi_init(): depth=%d\n", td->o.iodepth));
 229         memset(ld, 0, sizeof(*ld));
 230         maxthr = td->o.iodepth > GFIO_MIN_THREADS ? td->o.iodepth: GFIO_MIN_THREADS;
 231         if (maxthr > GFIO_MAX_THREADS)
 232                 maxthr = GFIO_MAX_THREADS;
 233         if ((ld->hctx = guasi_create(GFIO_MIN_THREADS, maxthr, 1)) == NULL) {
 234                 td_verror(td, errno, "guasi_create");
 235                 free(ld);
 236                 return 1;
 237         }
 238         ld->max_reqs = td->o.iodepth;
 239         ld->reqs = malloc(ld->max_reqs * sizeof(guasi_req_t));
 240         ld->io_us = malloc(ld->max_reqs * sizeof(struct io_u *));
 241         memset(ld->io_us, 0, ld->max_reqs * sizeof(struct io_u *));
 242         ld->queued_nr = 0;
 243         ld->reqs_nr = 0;
 244
 245         td->io_ops->data = ld;
 246         GDBG_PRINT(("fio_guasi_init(): depth=%d -> %p\n", td->o.iodepth, ld));
 247
 248         return 0;
 249 }
 250
 251 static struct ioengine_ops ioengine = {
 252         .name           = "guasi",
 253         .version        = FIO_IOOPS_VERSION,
 254         .init           = fio_guasi_init,
 255         .prep           = fio_guasi_prep,
 256         .queue          = fio_guasi_queue,
 257         .commit         = fio_guasi_commit,
 258         .cancel         = fio_guasi_cancel,
 259         .getevents      = fio_guasi_getevents,
 260         .event          = fio_guasi_event,
 261         .cleanup        = fio_guasi_cleanup,
 262         .open_file      = generic_open_file,
 263         .close_file     = generic_close_file,
 264         .get_file_size  = generic_get_file_size,
 265 };
 266
 267 #else /* FIO_HAVE_GUASI */
 268
 269 /*
 270  * When we have a proper configure system in place, we simply wont build
 271  * and install this io engine. For now install a crippled version that
 272  * just complains and fails to load.
 273  */
 274 static int fio_guasi_init(struct thread_data fio_unused *td)
 275 {
 276         fprintf(stderr, "fio: guasi not available\n");
 277         return 1;
 278 }
 279
 280 static struct ioengine_ops ioengine = {
 281         .name           = "guasi",
 282         .version        = FIO_IOOPS_VERSION,
 283         .init           = fio_guasi_init,
 284 };
 285
 286 #endif
 287
 288 static void fio_init fio_guasi_register(void)
 289 {
 290         register_ioengine(&ioengine);
 291 }
 292
 293 static void fio_exit fio_guasi_unregister(void)
 294 {
 295         unregister_ioengine(&ioengine);
 296 }
 297