[ViewVC] Diff of: cvs/libev/ev

Comparing libev/ev_linuxaio.c (file contents):
Revision 1.1 by root, Thu Jun 20 22:44:59 2019 UTC vs.
Revision 1.9 by root, Sat Jun 22 22:29:38 2019 UTC

  * provisions above, a recipient may use your version of this file under
  * either the BSD or the GPL.
  */
 #include <sys/time.h> /* actually linux/time.h, but we must assume they are compatible */
+#include <poll.h>
 #include <linux/aio_abi.h>
-/* we try to fill 4kn pages exactly.
+/* we try to fill 4kB pages exactly.
  * the ring buffer header is 32 bytes, every io event is 32 bytes.
- * the kernel takes the io event number, doubles it, adds 2, adds the ring buffer
+ * the kernel takes the io event number, doubles it, adds 2, adds the ring buffer.
- * so the calculation below will use "exactly" 8kB for the ring buffer
+ * therefore the calculation below will use "exactly" 4kB for the ring buffer
  */
-#define EV_LINUXAIO_DEPTH (256 / 2 - 2 - 1) /* max. number of io events per batch */
+#define EV_LINUXAIO_DEPTH (128 / 2 - 2 - 1) /* max. number of io events per batch */
 /*****************************************************************************/
 /* syscall wrapdadoop */
 #include <sys/syscall.h> /* no glibc wrappers */
-/* aio_abi.h is not verioned in any way, so we cannot test for its existance */
+/* aio_abi.h is not versioned in any way, so we cannot test for its existance */
 #define IOCB_CMD_POLL 5
 /* taken from linux/fs/aio.c */
 #define AIO_RING_MAGIC                  0xa10a10a1
 #define AIO_RING_INCOMPAT_FEATURES      0
   unsigned header_length;  /* size of aio_ring */
   struct io_event io_events[0];
 };
-static int
+inline_size
+int
 ev_io_setup (unsigned nr_events, aio_context_t *ctx_idp)
 {
   return syscall (SYS_io_setup, nr_events, ctx_idp);
 }
-static int
+inline_size
+int
 ev_io_destroy (aio_context_t ctx_id)
 {
   return syscall (SYS_io_destroy, ctx_id);
 }
-static int
+inline_size
+int
 ev_io_submit (aio_context_t ctx_id, long nr, struct iocb *cbp[])
 {
   return syscall (SYS_io_submit, ctx_id, nr, cbp);
 }
-static int
+inline_size
+int
 ev_io_cancel (aio_context_t ctx_id, struct iocb *cbp, struct io_event *result)
 {
   return syscall (SYS_io_cancel, ctx_id, cbp, result);
 }
-static int
+inline_size
+int
 ev_io_getevents (aio_context_t ctx_id, long min_nr, long nr, struct io_event *events, struct timespec *timeout)
 {
   return syscall (SYS_io_getevents, ctx_id, min_nr, nr, events, timeout);
 }
-typedef void (*ev_io_cb) (long nr, struct io_event *events);
 /*****************************************************************************/
 /* actual backed implementation */
-/* two iocbs for every fd, one for read, one for write */
+/* we use out own wrapper structure in acse we ever want to do something "clever" */
 typedef struct aniocb
 {
   struct iocb io;
   /*int inuse;*/
 } *ANIOCBP;
 inline_size
 void
 linuxaio_array_needsize_iocbp (ANIOCBP *base, int count)
 {
-  /* TODO: quite the overhead to allocate every iocb separately */
+  /* TODO: quite the overhead to allocate every iocb separately, maybe use our own alocator? */
   while (count--)
     {
       *base = (ANIOCBP)ev_malloc (sizeof (**base));
+      /* TODO: full zero initialize required? */
       memset (*base, 0, sizeof (**base));
-      /* would be nice to initialize fd/data as well */
+      /* would be nice to initialize fd/data as well, but array_needsize API doesn't support that */
       (*base)->io.aio_lio_opcode = IOCB_CMD_POLL;
       ++base;
     }
 }
+ecb_cold
 static void
 linuxaio_free_iocbp (EV_P)
 {
   while (linuxaio_iocbpmax--)
     ev_free (linuxaio_iocbps [linuxaio_iocbpmax]);
-  linuxaio_iocbpmax = 0;
+  linuxaio_iocbpmax = 0; /* next resize will completely reallocate the array, at some overhead */
 }
 static void
 linuxaio_modify (EV_P_ int fd, int oev, int nev)
 {
-  /* TODO: full zero initialize required? */
   array_needsize (ANIOCBP, linuxaio_iocbps, linuxaio_iocbpmax, fd + 1, linuxaio_array_needsize_iocbp);
   struct aniocb *iocb = linuxaio_iocbps [fd];
   if (iocb->io.aio_buf)
-    ev_io_cancel (linuxaio_ctx, &iocb->io, (void *)0);
+    ev_io_cancel (linuxaio_ctx, &iocb->io, (struct io_event *)0); /* always returns an error relevant kernels */
   if (nev)
     {
       iocb->io.aio_data       = fd;
       iocb->io.aio_fildes     = fd;
   while (nr)
     {
       int fd  = ev->data;
       int res = ev->res;
-      assert (("libev: iocb fd must be in-bounds", fd >= 0 && fd < anfdxmax));
+      assert (("libev: iocb fd must be in-bounds", fd >= 0 && fd < anfdmax));
       /* linux aio is oneshot: rearm fd */
       linuxaio_iocbps [fd]->io.aio_buf = 0;
       anfds [fd].events = 0;
       fd_change (EV_A_ fd, 0);
 static int
 linuxaio_get_events_from_ring (EV_P)
 {
   struct aio_ring *ring = (struct aio_ring *)linuxaio_ctx;
-  ECB_MEMORY_FENCE_ACQUIRE;
   unsigned head = ring->head;
   unsigned tail = *(volatile unsigned *)&ring->tail;
-  if (ring->magic != AIO_RING_MAGIC
+  if (head == tail)
-      || ring->incompat_features != AIO_RING_INCOMPAT_FEATURES
-      || ring->header_length != sizeof (struct aio_ring) /* TODO: or use it to find io_event[0]? */
-      || head == tail)
     return 0;
+  /* bail out if the ring buffer doesn't match the expected layout */
+  if (ecb_expect_false (ring->magic != AIO_RING_MAGIC)
+                        || ring->incompat_features != AIO_RING_INCOMPAT_FEATURES
+                        || ring->header_length != sizeof (struct aio_ring)) /* TODO: or use it to find io_event[0]? */
+    return 0;
+  ECB_MEMORY_FENCE_ACQUIRE;
   /* parse all available events, but only once, to avoid starvation */
   if (tail > head) /* normal case around */
     linuxaio_parse_events (EV_A_ ring->io_events + head, tail - head);
-  else
-    {
-      /* wrapped around */
+  else /* wrapped around */
+    {
       linuxaio_parse_events (EV_A_ ring->io_events + head, ring->nr - head);
       linuxaio_parse_events (EV_A_ ring->io_events, tail);
     }
   ring->head = tail;
   if (linuxaio_get_events_from_ring (EV_A))
     return;
   /* no events, so wait for at least one, then poll ring buffer again */
-  /* this degraded to one event per loop iteration */
+  /* this degrades to one event per loop iteration */
   /* if the ring buffer changes layout, but so be it */
   ts.tv_sec  = (long)timeout;
   ts.tv_nsec = (long)((timeout - ts.tv_sec) * 1e9);
   res = ev_io_getevents (linuxaio_ctx, 1, 1, &ioev, &ts);
   if (res < 0)
-    ev_syserr ("(libev) io_getevents");
+    ev_syserr ("(libev) linuxaio io_getevents");
   else if (res)
     {
       /* at least one event received, handle it and any remaining ones in the ring buffer */
       linuxaio_parse_events (EV_A_ &ioev, 1);
       linuxaio_get_events_from_ring (EV_A);
   /* which allows us to pinpoint the errornous iocb */
   for (submitted = 0; submitted < linuxaio_submitcnt; )
     {
       int res = ev_io_submit (linuxaio_ctx, linuxaio_submitcnt - submitted, linuxaio_submits + submitted);
-      if (res < 0)
+      if (ecb_expect_false (res < 0))
         if (errno == EAGAIN)
           {
             /* This happens when the ring buffer is full, at least. I assume this means
              * that the event was queued synchronously during io_submit, and thus
              * the buffer overflowd.
              * In this case, we just try next loop iteration.
+             * This should not result in a few fds taking priority, as the interface
+             * is one-shot, and we submit iocb's in a round-robin fashion.
              */
-            memcpy (linuxaio_submits, linuxaio_submits + submitted, (linuxaio_submitcnt - submitted) * sizeof (*linuxaio_submits));
+            memmove (linuxaio_submits, linuxaio_submits + submitted, (linuxaio_submitcnt - submitted) * sizeof (*linuxaio_submits));
             linuxaio_submitcnt -= submitted;
             timeout = 0;
             break;
           }
         else
-          /* TODO: we get EAGAIN when the ring buffer is full for some reason */
-          /* TODO: should we always just try next time? */
-          ev_syserr ("(libev) io_submit");
+          ev_syserr ("(libev) linuxaio io_submit");
       submitted += res;
     }
   linuxaio_submitcnt = 0;
 inline_size
 int
 linuxaio_init (EV_P_ int flags)
 {
   /* would be great to have a nice test for IOCB_CMD_POLL instead */
+  /* also: test some semi-common fd types, such as files and ttys in recommended_backends */
   if (ev_linux_version () < 0x041200) /* 4.18 introduced IOCB_CMD_POLL */
     return 0;
+  linuxaio_ctx = 0;
   if (ev_io_setup (EV_LINUXAIO_DEPTH, &linuxaio_ctx) < 0)
     return 0;
   backend_modify  = linuxaio_modify;
   backend_poll    = linuxaio_poll;
 inline_size
 void
 linuxaio_fork (EV_P)
 {
-  abort ();//D
+  /* this frees all iocbs, which is very heavy-handed */
-}
+  linuxaio_destroy (EV_A);
+  linuxaio_submitcnt = 0; /* all pointers were invalidated */
+  linuxaio_ctx = 0;
+  while (ev_io_setup (EV_LINUXAIO_DEPTH, &linuxaio_ctx) < 0)
+    ev_syserr ("(libev) linuxaio io_setup");
+  fd_rearm_all (EV_A);
+}

Diff Legend

-–
+Removed lines
-+
+Added lines
-<
+Changed lines
->
+Changed lines

Comparing libev/ev_linuxaio.c (file contents): Revision 1.1 by root, Thu Jun 20 22:44:59 2019 UTC vs. Revision 1.9 by root, Sat Jun 22 22:29:38 2019 UTC

Diff Legend

Comparing libev/ev_linuxaio.c (file contents):
Revision 1.1 by root, Thu Jun 20 22:44:59 2019 UTC vs.
Revision 1.9 by root, Sat Jun 22 22:29:38 2019 UTC