engines/syslet-rw.c

   1 /*
   2  * read/write() engine that uses syslet to be async
   3  *
   4  */
   5 #include <stdio.h>
   6 #include <stdlib.h>
   7 #include <unistd.h>
   8 #include <errno.h>
   9 #include <assert.h>
  10
  11 #include "../fio.h"
  12 #include "../os.h"
  13
  14 #ifdef FIO_HAVE_SYSLET
  15
  16 struct syslet_data {
  17         struct io_u **events;
  18         unsigned int nr_events;
  19
  20         struct async_head_user ahu;
  21         struct syslet_uatom **ring;
  22 };
  23
  24 /*
  25  * Inspect the ring to see if we have completed events
  26  */
  27 static void fio_syslet_complete(struct thread_data *td)
  28 {
  29         struct syslet_data *sd = td->io_ops->data;
  30
  31         do {
  32                 struct syslet_uatom *atom;
  33                 struct io_u *io_u;
  34                 long ret;
  35
  36                 atom = sd->ring[sd->ahu.user_ring_idx];
  37                 if (!atom)
  38                         break;
  39
  40                 sd->ring[sd->ahu.user_ring_idx] = NULL;
  41                 if (++sd->ahu.user_ring_idx == td->iodepth)
  42                         sd->ahu.user_ring_idx = 0;
  43
  44                 io_u = atom->private;
  45                 ret = *atom->ret_ptr;
  46                 if (ret > 0)
  47                         io_u->resid = io_u->xfer_buflen - ret;
  48                 else if (ret < 0)
  49                         io_u->error = ret;
  50
  51                 sd->events[sd->nr_events++] = io_u;
  52         } while (1);
  53 }
  54
  55 static int fio_syslet_getevents(struct thread_data *td, int min,
  56                                 int fio_unused max,
  57                                 struct timespec fio_unused *t)
  58 {
  59         struct syslet_data *sd = td->io_ops->data;
  60         int get_events;
  61         long ret;
  62
  63         do {
  64                 fio_syslet_complete(td);
  65
  66                 /*
  67                  * do we have enough immediate completions?
  68                  */
  69                 if (sd->nr_events >= (unsigned int) min)
  70                         break;
  71
  72                 /*
  73                  * OK, we need to wait for some events...
  74                  */
  75                 get_events = min - sd->nr_events;
  76                 ret = async_wait(get_events, sd->ahu.user_ring_idx, &sd->ahu);
  77                 if (ret < 0)
  78                         return errno;
  79         } while (1);
  80
  81         ret = sd->nr_events;
  82         sd->nr_events = 0;
  83         return ret;
  84 }
  85
  86 static struct io_u *fio_syslet_event(struct thread_data *td, int event)
  87 {
  88         struct syslet_data *sd = td->io_ops->data;
  89
  90         return sd->events[event];
  91 }
  92
  93 static void init_atom(struct syslet_uatom *atom, int nr, void *arg0,
  94                       void *arg1, void *arg2, void *arg3, void *ret_ptr,
  95                       unsigned long flags, void *priv)
  96 {
  97         atom->flags = flags;
  98         atom->nr = nr;
  99         atom->ret_ptr = ret_ptr;
 100         atom->next = NULL;
 101         atom->arg_ptr[0] = arg0;
 102         atom->arg_ptr[1] = arg1;
 103         atom->arg_ptr[2] = arg2;
 104         atom->arg_ptr[3] = arg3;
 105         atom->arg_ptr[4] = atom->arg_ptr[5] = NULL;
 106         atom->private = priv;
 107 }
 108
 109 /*
 110  * Use seek atom for sync
 111  */
 112 static void fio_syslet_prep_sync(struct io_u *io_u, struct fio_file *f)
 113 {
 114         init_atom(&io_u->req.atom, __NR_fsync, &f->fd, NULL, NULL, NULL,
 115                   &io_u->req.ret, 0, io_u);
 116 }
 117
 118 static void fio_syslet_prep_rw(struct io_u *io_u, struct fio_file *f)
 119 {
 120         int nr;
 121
 122         /*
 123          * prepare rw
 124          */
 125         if (io_u->ddir == DDIR_READ)
 126                 nr = __NR_pread64;
 127         else
 128                 nr = __NR_pwrite64;
 129
 130         init_atom(&io_u->req.atom, nr, &f->fd, &io_u->xfer_buf,
 131                   &io_u->xfer_buflen, &io_u->offset, &io_u->req.ret, 0, io_u);
 132 }
 133
 134 static int fio_syslet_prep(struct thread_data fio_unused *td, struct io_u *io_u)
 135 {
 136         struct fio_file *f = io_u->file;
 137
 138         if (io_u->ddir == DDIR_SYNC)
 139                 fio_syslet_prep_sync(io_u, f);
 140         else
 141                 fio_syslet_prep_rw(io_u, f);
 142
 143         return 0;
 144 }
 145
 146 static void cachemiss_thread_start(void)
 147 {
 148         while (1)
 149                 async_thread();
 150 }
 151
 152 #define THREAD_STACK_SIZE (16384)
 153
 154 static unsigned long thread_stack_alloc()
 155 {
 156         return (unsigned long)malloc(THREAD_STACK_SIZE) + THREAD_STACK_SIZE;
 157 }
 158
 159 static int fio_syslet_queue(struct thread_data *td, struct io_u *io_u)
 160 {
 161         struct syslet_data *sd = td->io_ops->data;
 162         struct syslet_uatom *done;
 163         long ret;
 164
 165         if (!sd->ahu.new_thread_stack)
 166                 sd->ahu.new_thread_stack = thread_stack_alloc();
 167
 168         /*
 169          * On sync completion, the atom is returned. So on NULL return
 170          * it's queued asynchronously.
 171          */
 172         done = async_exec(&io_u->req.atom, &sd->ahu);
 173
 174         if (!done)
 175                 return FIO_Q_QUEUED;
 176
 177         /*
 178          * completed sync
 179          */
 180         ret = io_u->req.ret;
 181         if (ret != (long) io_u->xfer_buflen) {
 182                 if (ret > 0) {
 183                         io_u->resid = io_u->xfer_buflen - ret;
 184                         io_u->error = 0;
 185                         return FIO_Q_COMPLETED;
 186                 } else
 187                         io_u->error = errno;
 188         }
 189
 190         if (sd->nr_events >= td->iodepth)
 191                 printf("ouch! %d\n", sd->nr_events);
 192
 193         if (!io_u->error)
 194                 /* nothing */;
 195         else
 196                 td_verror(td, io_u->error);
 197
 198         return FIO_Q_COMPLETED;
 199 }
 200
 201 static int async_head_init(struct syslet_data *sd, unsigned int depth)
 202 {
 203         unsigned long ring_size;
 204
 205         memset(&sd->ahu, 0, sizeof(struct async_head_user));
 206
 207         ring_size = sizeof(struct syslet_uatom *) * depth;
 208         sd->ring = malloc(ring_size);
 209         memset(sd->ring, 0, ring_size);
 210
 211         sd->ahu.user_ring_idx = 0;
 212         sd->ahu.completion_ring = sd->ring;
 213         sd->ahu.ring_size_bytes = ring_size;
 214         sd->ahu.head_stack = thread_stack_alloc();
 215         sd->ahu.head_eip = (unsigned long)cachemiss_thread_start;
 216         sd->ahu.new_thread_eip = (unsigned long)cachemiss_thread_start;
 217
 218         return 0;
 219 }
 220
 221 static void async_head_exit(struct syslet_data *sd)
 222 {
 223         free(sd->ring);
 224 }
 225
 226 static void fio_syslet_cleanup(struct thread_data *td)
 227 {
 228         struct syslet_data *sd = td->io_ops->data;
 229
 230         if (sd) {
 231                 async_head_exit(sd);
 232                 free(sd->events);
 233                 free(sd);
 234                 td->io_ops->data = NULL;
 235         }
 236 }
 237
 238 static int fio_syslet_init(struct thread_data *td)
 239 {
 240         struct syslet_data *sd;
 241
 242
 243         sd = malloc(sizeof(*sd));
 244         memset(sd, 0, sizeof(*sd));
 245         sd->events = malloc(sizeof(struct io_u *) * td->iodepth);
 246         memset(sd->events, 0, sizeof(struct io_u *) * td->iodepth);
 247
 248         /*
 249          * This will handily fail for kernels where syslet isn't available
 250          */
 251         if (async_head_init(sd, td->iodepth)) {
 252                 free(sd->events);
 253                 free(sd);
 254                 return 1;
 255         }
 256
 257         td->io_ops->data = sd;
 258         return 0;
 259 }
 260
 261 static struct ioengine_ops ioengine = {
 262         .name           = "syslet-rw",
 263         .version        = FIO_IOOPS_VERSION,
 264         .init           = fio_syslet_init,
 265         .prep           = fio_syslet_prep,
 266         .queue          = fio_syslet_queue,
 267         .getevents      = fio_syslet_getevents,
 268         .event          = fio_syslet_event,
 269         .cleanup        = fio_syslet_cleanup,
 270 };
 271
 272 #else /* FIO_HAVE_SYSLET */
 273
 274 /*
 275  * When we have a proper configure system in place, we simply wont build
 276  * and install this io engine. For now install a crippled version that
 277  * just complains and fails to load.
 278  */
 279 static int fio_syslet_init(struct thread_data fio_unused *td)
 280 {
 281         fprintf(stderr, "fio: syslet not available\n");
 282         return 1;
 283 }
 284
 285 static struct ioengine_ops ioengine = {
 286         .name           = "syslet-rw",
 287         .version        = FIO_IOOPS_VERSION,
 288         .init           = fio_syslet_init,
 289 };
 290
 291 #endif /* FIO_HAVE_SYSLET */
 292
 293 static void fio_init fio_syslet_register(void)
 294 {
 295         register_ioengine(&ioengine);
 296 }
 297
 298 static void fio_exit fio_syslet_unregister(void)
 299 {
 300         unregister_ioengine(&ioengine);
 301 }