asyncengine 0.0.1.testing1 → 0.0.2.alpha1

data/ext/asyncengine/libuv/src/unix/tty.c

@@ -38,11 +38,11 @@ int uv_tty_init(uv_loop_t* loop, uv_tty_t* tty, int fd, int readable) {
 
   if (readable) {
     uv__nonblock(fd, 1);
-    uv__stream_open((uv_stream_t*)tty, fd, UV_READABLE);
+    uv__stream_open((uv_stream_t*)tty, fd, UV_STREAM_READABLE);
   } else {
     /* Note: writable tty we set to blocking mode. */
-    uv__stream_open((uv_stream_t*)tty, fd, UV_WRITABLE);
-    tty->blocking = 1;
+    uv__stream_open((uv_stream_t*)tty, fd, UV_STREAM_WRITABLE);
+    tty->flags |= UV_STREAM_BLOCKING;
   }
 
   loop->counters.tty_init++;

data/ext/asyncengine/libuv/src/unix/udp.c

@@ -31,63 +31,39 @@
 
 static void uv__udp_run_completed(uv_udp_t* handle);
 static void uv__udp_run_pending(uv_udp_t* handle);
-static void uv__udp_recvmsg(EV_P_ ev_io* w, int revents);
-static void uv__udp_sendmsg(EV_P_ ev_io* w, int revents);
+static void uv__udp_recvmsg(uv_loop_t* loop, uv__io_t* w, int revents);
+static void uv__udp_sendmsg(uv_loop_t* loop, uv__io_t* w, int revents);
 static int uv__udp_maybe_deferred_bind(uv_udp_t* handle, int domain);
 static int uv__udp_send(uv_udp_send_t* req, uv_udp_t* handle, uv_buf_t bufs[],
     int bufcnt, struct sockaddr* addr, socklen_t addrlen, uv_udp_send_cb send_cb);
 
 
 static void uv__udp_start_watcher(uv_udp_t* handle,
-                                  ev_io* w,
-                                  void (*cb)(EV_P_ ev_io*, int),
-                                  int flags) {
-  if (ev_is_active(w)) return;
-  ev_set_cb(w, cb);
-  ev_io_set(w, handle->fd, flags);
-  ev_io_start(handle->loop->ev, w);
-  ev_unref(handle->loop->ev);
+                                  uv__io_t* w,
+                                  uv__io_cb cb,
+                                  int events) {
+  if (uv__io_active(w)) return;
+  uv__io_init(w, cb, handle->fd, events);
+  uv__io_start(handle->loop, w);
+  uv__handle_start(handle);
 }
 
 
-static void uv__udp_stop_watcher(uv_udp_t* handle, ev_io* w) {
-  if (!ev_is_active(w)) return;
-  ev_ref(handle->loop->ev);
-  ev_io_stop(handle->loop->ev, w);
-  ev_io_set(w, -1, 0);
-  ev_set_cb(w, NULL);
-}
-
-
-static void uv__udp_start_read_watcher(uv_udp_t* handle) {
-  uv__udp_start_watcher(handle,
-                        &handle->read_watcher,
-                        uv__udp_recvmsg,
-                        EV_READ);
-}
-
-
-static void uv__udp_start_write_watcher(uv_udp_t* handle) {
-  uv__udp_start_watcher(handle,
-                        &handle->write_watcher,
-                        uv__udp_sendmsg,
-                        EV_WRITE);
-}
-
-
-static void uv__udp_stop_read_watcher(uv_udp_t* handle) {
-  uv__udp_stop_watcher(handle, &handle->read_watcher);
-}
-
+static void uv__udp_stop_watcher(uv_udp_t* handle, uv__io_t* w) {
+  if (!uv__io_active(w)) return;
+  uv__io_stop(handle->loop, w);
 
-static void uv__udp_stop_write_watcher(uv_udp_t* handle) {
-  uv__udp_stop_watcher(handle, &handle->write_watcher);
+  if (!uv__io_active(&handle->read_watcher) &&
+      !uv__io_active(&handle->write_watcher))
+  {
+    uv__handle_stop(handle);
+  }
 }
 
 
 void uv__udp_close(uv_udp_t* handle) {
-  uv__udp_stop_write_watcher(handle);
-  uv__udp_stop_read_watcher(handle);
+  uv__udp_stop_watcher(handle, &handle->write_watcher);
+  uv__udp_stop_watcher(handle, &handle->read_watcher);
   close(handle->fd);
   handle->fd = -1;
 }
@@ -97,8 +73,8 @@ void uv__udp_finish_close(uv_udp_t* handle) {
   uv_udp_send_t* req;
   ngx_queue_t* q;
 
-  assert(!ev_is_active(&handle->write_watcher));
-  assert(!ev_is_active(&handle->read_watcher));
+  assert(!uv__io_active(&handle->write_watcher));
+  assert(!uv__io_active(&handle->read_watcher));
   assert(handle->fd == -1);
 
   uv__udp_run_completed(handle);
@@ -108,6 +84,8 @@ void uv__udp_finish_close(uv_udp_t* handle) {
     ngx_queue_remove(q);
 
     req = ngx_queue_data(q, uv_udp_send_t, queue);
+    uv__req_unregister(handle->loop, req);
+
     if (req->send_cb) {
       /* FIXME proper error code like UV_EABORTED */
       uv__set_artificial_error(handle->loop, UV_EINTR);
@@ -138,7 +116,8 @@ static void uv__udp_run_pending(uv_udp_t* handle) {
 
     memset(&h, 0, sizeof h);
     h.msg_name = &req->addr;
-    h.msg_namelen = req->addrlen;
+    h.msg_namelen = (req->addr.sin6_family == AF_INET6 ?
+      sizeof(struct sockaddr_in6) : sizeof(struct sockaddr_in));
     h.msg_iov = (struct iovec*)req->bufs;
     h.msg_iovlen = req->bufcnt;
 
@@ -185,12 +164,10 @@ static void uv__udp_run_completed(uv_udp_t* handle) {
 
   while (!ngx_queue_empty(&handle->write_completed_queue)) {
     q = ngx_queue_head(&handle->write_completed_queue);
-    assert(q != NULL);
-
     ngx_queue_remove(q);
 
     req = ngx_queue_data(q, uv_udp_send_t, queue);
-    assert(req != NULL);
+    uv__req_unregister(handle->loop, req);
 
     if (req->bufs != req->bufsml)
       free(req->bufs);
@@ -212,30 +189,36 @@ static void uv__udp_run_completed(uv_udp_t* handle) {
 }
 
 
-static void uv__udp_recvmsg(EV_P_ ev_io* w, int revents) {
+static void uv__udp_recvmsg(uv_loop_t* loop, uv__io_t* w, int revents) {
   struct sockaddr_storage peer;
   struct msghdr h;
   uv_udp_t* handle;
   ssize_t nread;
   uv_buf_t buf;
   int flags;
+  int count;
 
   handle = container_of(w, uv_udp_t, read_watcher);
   assert(handle->type == UV_UDP);
-  assert(revents & EV_READ);
+  assert(revents & UV__IO_READ);
 
   assert(handle->recv_cb != NULL);
   assert(handle->alloc_cb != NULL);
 
+  /* Prevent loop starvation when the data comes in as fast as (or faster than)
+   * we can read it. XXX Need to rearm fd if we switch to edge-triggered I/O.
+   */
+  count = 32;
+
+  memset(&h, 0, sizeof(h));
+  h.msg_name = &peer;
+
   do {
-    /* FIXME: hoist alloc_cb out the loop but for now follow uv__read() */
     buf = handle->alloc_cb((uv_handle_t*)handle, 64 * 1024);
     assert(buf.len > 0);
     assert(buf.base != NULL);
 
-    memset(&h, 0, sizeof h);
-    h.msg_name = &peer;
-    h.msg_namelen = sizeof peer;
+    h.msg_namelen = sizeof(peer);
     h.msg_iov = (struct iovec*)&buf;
     h.msg_iovlen = 1;
 
@@ -269,17 +252,18 @@ static void uv__udp_recvmsg(EV_P_ ev_io* w, int revents) {
   }
   /* recv_cb callback may decide to pause or close the handle */
   while (nread != -1
+      && count-- > 0
       && handle->fd != -1
       && handle->recv_cb != NULL);
 }
 
 
-static void uv__udp_sendmsg(EV_P_ ev_io* w, int revents) {
+static void uv__udp_sendmsg(uv_loop_t* loop, uv__io_t* w, int revents) {
   uv_udp_t* handle;
 
   handle = container_of(w, uv_udp_t, write_watcher);
   assert(handle->type == UV_UDP);
-  assert(revents & EV_WRITE);
+  assert(revents & UV__IO_WRITE);
 
   assert(!ngx_queue_empty(&handle->write_queue)
       || !ngx_queue_empty(&handle->write_completed_queue));
@@ -292,11 +276,11 @@ static void uv__udp_sendmsg(EV_P_ ev_io* w, int revents) {
 
   if (!ngx_queue_empty(&handle->write_completed_queue)) {
     /* Schedule completion callbacks. */
-    ev_feed_event(handle->loop->ev, &handle->write_watcher, EV_WRITE);
+    uv__io_feed(handle->loop, &handle->write_watcher, UV__IO_WRITE);
   }
   else if (ngx_queue_empty(&handle->write_queue)) {
     /* Pending queue and completion queue empty, stop watcher. */
-    uv__udp_stop_write_watcher(handle);
+    uv__udp_stop_watcher(handle, &handle->write_watcher);
   }
 }
 
@@ -437,14 +421,13 @@ static int uv__udp_send(uv_udp_send_t* req,
   if (uv__udp_maybe_deferred_bind(handle, addr->sa_family))
     return -1;
 
-  uv__req_init(handle->loop, (uv_req_t*)req);
+  uv__req_init(handle->loop, req, UV_UDP_SEND);
 
+  assert(addrlen <= sizeof(req->addr));
   memcpy(&req->addr, addr, addrlen);
-  req->addrlen = addrlen;
   req->send_cb = send_cb;
   req->handle = handle;
   req->bufcnt = bufcnt;
-  req->type = UV_UDP_SEND;
 
   if (bufcnt <= UV_REQ_BUFSML_SIZE) {
     req->bufs = req->bufsml;
@@ -456,7 +439,11 @@ static int uv__udp_send(uv_udp_send_t* req,
   memcpy(req->bufs, bufs, bufcnt * sizeof(bufs[0]));
 
   ngx_queue_insert_tail(&handle->write_queue, &req->queue);
-  uv__udp_start_write_watcher(handle);
+
+  uv__udp_start_watcher(handle,
+                        &handle->write_watcher,
+                        uv__udp_sendmsg,
+                        UV__IO_WRITE);
 
   return 0;
 }
@@ -646,7 +633,7 @@ int uv_udp_recv_start(uv_udp_t* handle,
     return -1;
   }
 
-  if (ev_is_active(&handle->read_watcher)) {
+  if (uv__io_active(&handle->read_watcher)) {
     uv__set_artificial_error(handle->loop, UV_EALREADY);
     return -1;
   }
@@ -656,14 +643,18 @@ int uv_udp_recv_start(uv_udp_t* handle,
 
   handle->alloc_cb = alloc_cb;
   handle->recv_cb = recv_cb;
-  uv__udp_start_read_watcher(handle);
+
+  uv__udp_start_watcher(handle,
+                        &handle->read_watcher,
+                        uv__udp_recvmsg,
+                        UV__IO_READ);
 
   return 0;
 }
 
 
 int uv_udp_recv_stop(uv_udp_t* handle) {
-  uv__udp_stop_read_watcher(handle);
+  uv__udp_stop_watcher(handle, &handle->read_watcher);
   handle->alloc_cb = NULL;
   handle->recv_cb = NULL;
   return 0;

data/ext/asyncengine/libuv/src/unix/uv-eio.c

@@ -22,52 +22,37 @@
 
 #include "uv.h"
 #include "eio.h"
+#include "internal.h"
 
 #include <assert.h>
 #include <stdio.h>
 
 
-static void uv_eio_do_poll(uv_idle_t* watcher, int status) {
-  assert(watcher == &(watcher->loop->uv_eio_poller));
+static uv_once_t uv__eio_init_once_guard = UV_ONCE_INIT;
 
-  /* printf("uv_eio_poller\n"); */
 
-  if (eio_poll(&watcher->loop->uv_eio_channel) != -1 && uv_is_active((uv_handle_t*) watcher)) {
-    /* printf("uv_eio_poller stop\n"); */
+static void uv_eio_do_poll(uv_idle_t* watcher, int status) {
+  uv_loop_t* loop = watcher->loop;
+  assert(watcher == &loop->uv_eio_poller);
+  if (eio_poll(&loop->uv_eio_channel) != -1)
     uv_idle_stop(watcher);
-    uv_unref(watcher->loop);
-  }
 }
 
 
 /* Called from the main thread. */
 static void uv_eio_want_poll_notifier_cb(uv_async_t* watcher, int status) {
   uv_loop_t* loop = watcher->loop;
-
   assert(watcher == &loop->uv_eio_want_poll_notifier);
-
-  /* printf("want poll notifier\n"); */
-
-  if (eio_poll(&watcher->loop->uv_eio_channel) == -1 && !uv_is_active((uv_handle_t*) &loop->uv_eio_poller)) {
-    /* printf("uv_eio_poller start\n"); */
+  if (eio_poll(&loop->uv_eio_channel) == -1)
     uv_idle_start(&loop->uv_eio_poller, uv_eio_do_poll);
-    uv_ref(loop);
-  }
 }
 
 
 static void uv_eio_done_poll_notifier_cb(uv_async_t* watcher, int revents) {
   uv_loop_t* loop = watcher->loop;
-
   assert(watcher == &loop->uv_eio_done_poll_notifier);
-
-  /* printf("done poll notifier\n"); */
-
-  if (eio_poll(&watcher->loop->uv_eio_channel) != -1 && uv_is_active((uv_handle_t*) &loop->uv_eio_poller)) {
-    /* printf("uv_eio_poller stop\n"); */
+  if (eio_poll(&loop->uv_eio_channel) != -1)
     uv_idle_stop(&loop->uv_eio_poller);
-    uv_unref(loop);
-  }
 }
 
 
@@ -77,13 +62,8 @@ static void uv_eio_done_poll_notifier_cb(uv_async_t* watcher, int revents) {
  */
 static void uv_eio_want_poll(eio_channel *channel) {
   /* Signal the main thread that eio_poll need to be processed. */
-
-  /*
-   * TODO need to select the correct uv_loop_t and async_send to
-   * uv_eio_want_poll_notifier.
-   */
-
-  uv_async_send(&((uv_loop_t *)channel->data)->uv_eio_want_poll_notifier);
+  uv_loop_t* loop = channel->data;
+  uv_async_send(&loop->uv_eio_want_poll_notifier);
 }
 
 
@@ -92,7 +72,8 @@ static void uv_eio_done_poll(eio_channel *channel) {
    * Signal the main thread that we should stop calling eio_poll().
    * from the idle watcher.
    */
-  uv_async_send(&((uv_loop_t *)channel->data)->uv_eio_done_poll_notifier);
+  uv_loop_t* loop = channel->data;
+  uv_async_send(&loop->uv_eio_done_poll_notifier);
 }
 
 
@@ -100,25 +81,27 @@ static void uv__eio_init(void) {
   eio_init(uv_eio_want_poll, uv_eio_done_poll);
 }
 
-static uv_once_t uv__eio_init_once_guard = UV_ONCE_INIT;
-
 
 void uv_eio_init(uv_loop_t* loop) {
-  if (loop->counters.eio_init == 0) {
-    loop->counters.eio_init++;
-
-    uv_idle_init(loop, &loop->uv_eio_poller);
-    uv_idle_start(&loop->uv_eio_poller, uv_eio_do_poll);
-
-    loop->uv_eio_want_poll_notifier.data = loop;
-    uv_async_init(loop, &loop->uv_eio_want_poll_notifier,
-        uv_eio_want_poll_notifier_cb);
-    uv_unref(loop);
-
-    uv_async_init(loop, &loop->uv_eio_done_poll_notifier,
-        uv_eio_done_poll_notifier_cb);
-    uv_unref(loop);
-
-    uv_once(&uv__eio_init_once_guard, uv__eio_init);
-  }
+  if (loop->counters.eio_init) return;
+  loop->counters.eio_init = 1;
+
+  uv_idle_init(loop, &loop->uv_eio_poller);
+  uv_idle_start(&loop->uv_eio_poller, uv_eio_do_poll);
+  loop->uv_eio_poller.flags |= UV__HANDLE_INTERNAL;
+
+  loop->uv_eio_want_poll_notifier.data = loop;
+  uv_async_init(loop,
+                &loop->uv_eio_want_poll_notifier,
+                uv_eio_want_poll_notifier_cb);
+  loop->uv_eio_want_poll_notifier.flags |= UV__HANDLE_INTERNAL;
+  uv__handle_unref(&loop->uv_eio_want_poll_notifier);
+
+  uv_async_init(loop,
+                &loop->uv_eio_done_poll_notifier,
+                uv_eio_done_poll_notifier_cb);
+  loop->uv_eio_done_poll_notifier.flags |= UV__HANDLE_INTERNAL;
+  uv__handle_unref(&loop->uv_eio_done_poll_notifier);
+
+  uv_once(&uv__eio_init_once_guard, uv__eio_init);
 }

data/ext/asyncengine/libuv/src/uv-common.c

@@ -22,6 +22,7 @@
 #include "uv.h"
 #include "uv-common.h"
 
+#include <stdio.h>
 #include <assert.h>
 #include <stddef.h> /* NULL */
 #include <stdlib.h> /* malloc */
@@ -87,7 +88,7 @@ size_t uv_strlcat(char* dst, const char* src, size_t size) {
 }
 
 
-uv_buf_t uv_buf_init(char* base, size_t len) {
+uv_buf_t uv_buf_init(char* base, unsigned int len) {
   uv_buf_t buf;
   buf.base = base;
   buf.len = len;
@@ -199,43 +200,6 @@ int uv_ip6_name(struct sockaddr_in6* src, char* dst, size_t size) {
 }
 
 
-static int cmp_ares_tasks(const uv_ares_task_t* a, const uv_ares_task_t* b) {
-  if (a->sock < b->sock) return -1;
-  if (a->sock > b->sock) return 1;
-  return 0;
-}
-
-
-RB_GENERATE_STATIC(uv__ares_tasks, uv_ares_task_s, node, cmp_ares_tasks)
-
-
-/* add ares handle to list */
-void uv_add_ares_handle(uv_loop_t* loop, uv_ares_task_t* handle) {
-  assert(loop == handle->loop);
-  RB_INSERT(uv__ares_tasks, &loop->uv_ares_handles_, handle);
-}
-
-
-/* find matching ares handle in list */
-uv_ares_task_t* uv_find_ares_handle(uv_loop_t* loop, ares_socket_t sock) {
-  uv_ares_task_t handle;
-  handle.sock = sock;
-  return RB_FIND(uv__ares_tasks, &loop->uv_ares_handles_, &handle);
-}
-
-
-/* remove ares handle in list */
-void uv_remove_ares_handle(uv_ares_task_t* handle) {
-  RB_REMOVE(uv__ares_tasks, &handle->loop->uv_ares_handles_, handle);
-}
-
-
-/* Returns 1 if the uv_ares_handles_ list is empty. 0 otherwise. */
-int uv_ares_handles_empty(uv_loop_t* loop) {
-  return RB_EMPTY(&loop->uv_ares_handles_);
-}
-
-
 int uv_tcp_bind(uv_tcp_t* handle, struct sockaddr_in addr) {
   if (handle->type != UV_TCP || addr.sin_family != AF_INET) {
     uv__set_artificial_error(handle->loop, UV_EFAULT);
@@ -352,3 +316,69 @@ int uv_thread_create(uv_thread_t *tid, void (*entry)(void *arg), void *arg) {
 
   return 0;
 }
+
+
+void uv_walk(uv_loop_t* loop, uv_walk_cb walk_cb, void* arg) {
+  ngx_queue_t* q;
+  uv_handle_t* h;
+
+  ngx_queue_foreach(q, &loop->handle_queue) {
+    h = ngx_queue_data(q, uv_handle_t, handle_queue);
+    if (h->flags & UV__HANDLE_INTERNAL) continue;
+    walk_cb(h, arg);
+  }
+}
+
+
+#ifndef NDEBUG
+static void uv__print_handles(uv_loop_t* loop, int only_active) {
+  const char* type;
+  ngx_queue_t* q;
+  uv_handle_t* h;
+
+  if (loop == NULL)
+    loop = uv_default_loop();
+
+  ngx_queue_foreach(q, &loop->handle_queue) {
+    h = ngx_queue_data(q, uv_handle_t, handle_queue);
+
+    if (only_active && !uv__is_active(h))
+      continue;
+
+    switch (h->type) {
+#define X(uc, lc) case UV_##uc: type = #lc; break;
+      UV_HANDLE_TYPE_MAP(X)
+#undef X
+      default: type = "<unknown>";
+    }
+
+    fprintf(stderr,
+            "[%c%c%c] %-8s %p\n",
+            "R-"[!(h->flags & UV__HANDLE_REF)],
+            "A-"[!(h->flags & UV__HANDLE_ACTIVE)],
+            "I-"[!(h->flags & UV__HANDLE_INTERNAL)],
+            type,
+            (void*)h);
+  }
+}
+
+
+void uv_print_all_handles(uv_loop_t* loop) {
+  uv__print_handles(loop, 0);
+}
+
+
+void uv_print_active_handles(uv_loop_t* loop) {
+  uv__print_handles(loop, 1);
+}
+#endif
+
+
+void uv_ref(uv_handle_t* handle) {
+  uv__handle_ref(handle);
+}
+
+
+void uv_unref(uv_handle_t* handle) {
+  uv__handle_unref(handle);
+}