noderb 0.0.4 → 0.0.6

data/ext/noderb_extension/libuv/src/win/winsock.c

@@ -0,0 +1,270 @@
+/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+
+#include <assert.h>
+
+#include "uv.h"
+#include "../uv-common.h"
+#include "internal.h"
+
+
+/* Winsock extension functions (ipv4) */
+LPFN_CONNECTEX pConnectEx;
+LPFN_ACCEPTEX pAcceptEx;
+LPFN_GETACCEPTEXSOCKADDRS pGetAcceptExSockAddrs;
+LPFN_DISCONNECTEX pDisconnectEx;
+LPFN_TRANSMITFILE pTransmitFile;
+
+/* Winsock extension functions (ipv6) */
+LPFN_CONNECTEX pConnectEx6;
+LPFN_ACCEPTEX pAcceptEx6;
+LPFN_GETACCEPTEXSOCKADDRS pGetAcceptExSockAddrs6;
+LPFN_DISCONNECTEX pDisconnectEx6;
+LPFN_TRANSMITFILE  pTransmitFile6;
+
+/* Whether ipv6 is supported */
+int uv_allow_ipv6;
+
+/* Ip address used to bind to any port at any interface */
+struct sockaddr_in uv_addr_ip4_any_;
+struct sockaddr_in6 uv_addr_ip6_any_;
+
+
+/*
+ * Retrieves the pointer to a winsock extension function.
+ */
+static BOOL uv_get_extension_function(SOCKET socket, GUID guid,
+    void **target) {
+  DWORD result, bytes;
+
+  result = WSAIoctl(socket,
+                    SIO_GET_EXTENSION_FUNCTION_POINTER,
+                    &guid,
+                    sizeof(guid),
+                    (void*)target,
+                    sizeof(*target),
+                    &bytes,
+                    NULL,
+                    NULL);
+
+  if (result == SOCKET_ERROR) {
+    *target = NULL;
+    return FALSE;
+  } else {
+    return TRUE;
+  }
+}
+
+
+void uv_winsock_init() {
+  const GUID wsaid_connectex            = WSAID_CONNECTEX;
+  const GUID wsaid_acceptex             = WSAID_ACCEPTEX;
+  const GUID wsaid_getacceptexsockaddrs = WSAID_GETACCEPTEXSOCKADDRS;
+  const GUID wsaid_disconnectex         = WSAID_DISCONNECTEX;
+  const GUID wsaid_transmitfile         = WSAID_TRANSMITFILE;
+
+  WSADATA wsa_data;
+  int errorno;
+  SOCKET dummy;
+  SOCKET dummy6;
+
+  /* Initialize winsock */
+  errorno = WSAStartup(MAKEWORD(2, 2), &wsa_data);
+  if (errorno != 0) {
+    uv_fatal_error(errorno, "WSAStartup");
+  }
+
+  /* Set implicit binding address used by connectEx */
+  uv_addr_ip4_any_ = uv_ip4_addr("0.0.0.0", 0);
+  uv_addr_ip6_any_ = uv_ip6_addr("::", 0);
+
+  /* Retrieve the needed winsock extension function pointers. */
+  dummy = socket(AF_INET, SOCK_STREAM, IPPROTO_IP);
+  if (dummy == INVALID_SOCKET) {
+    uv_fatal_error(WSAGetLastError(), "socket");
+  }
+
+  if (!uv_get_extension_function(dummy,
+                            wsaid_connectex,
+                            (void**)&pConnectEx) ||
+      !uv_get_extension_function(dummy,
+                            wsaid_acceptex,
+                            (void**)&pAcceptEx) ||
+      !uv_get_extension_function(dummy,
+                            wsaid_getacceptexsockaddrs,
+                            (void**)&pGetAcceptExSockAddrs) ||
+      !uv_get_extension_function(dummy,
+                            wsaid_disconnectex,
+                            (void**)&pDisconnectEx) ||
+      !uv_get_extension_function(dummy,
+                            wsaid_transmitfile,
+                            (void**)&pTransmitFile)) {
+    uv_fatal_error(WSAGetLastError(),
+                   "WSAIoctl(SIO_GET_EXTENSION_FUNCTION_POINTER)");
+  }
+
+  if (closesocket(dummy) == SOCKET_ERROR) {
+    uv_fatal_error(WSAGetLastError(), "closesocket");
+  }
+
+  /* optional IPv6 versions of winsock extension functions */
+  dummy6 = socket(AF_INET6, SOCK_STREAM, IPPROTO_IP);
+  if (dummy6 != INVALID_SOCKET) {
+    uv_allow_ipv6 = TRUE;
+
+    if (!uv_get_extension_function(dummy6,
+                              wsaid_connectex,
+                              (void**)&pConnectEx6) ||
+        !uv_get_extension_function(dummy6,
+                              wsaid_acceptex,
+                              (void**)&pAcceptEx6) ||
+        !uv_get_extension_function(dummy6,
+                              wsaid_getacceptexsockaddrs,
+                              (void**)&pGetAcceptExSockAddrs6) ||
+        !uv_get_extension_function(dummy6,
+                              wsaid_disconnectex,
+                              (void**)&pDisconnectEx6) ||
+        !uv_get_extension_function(dummy6,
+                              wsaid_transmitfile,
+                              (void**)&pTransmitFile6)) {
+      uv_allow_ipv6 = FALSE;
+    }
+
+    if (closesocket(dummy6) == SOCKET_ERROR) {
+      uv_fatal_error(WSAGetLastError(), "closesocket");
+    }
+  }
+}
+
+
+int uv_ntstatus_to_winsock_error(NTSTATUS status) {
+  switch (status) {
+    case STATUS_SUCCESS:
+      return ERROR_SUCCESS;
+
+    case STATUS_PENDING:
+      return ERROR_IO_PENDING;
+
+    case STATUS_INVALID_HANDLE:
+    case STATUS_OBJECT_TYPE_MISMATCH:
+      return WSAENOTSOCK;
+
+    case STATUS_INSUFFICIENT_RESOURCES:
+    case STATUS_PAGEFILE_QUOTA:
+    case STATUS_COMMITMENT_LIMIT:
+    case STATUS_WORKING_SET_QUOTA:
+    case STATUS_NO_MEMORY:
+    case STATUS_CONFLICTING_ADDRESSES:
+    case STATUS_QUOTA_EXCEEDED:
+    case STATUS_TOO_MANY_PAGING_FILES:
+    case STATUS_REMOTE_RESOURCES:
+    case STATUS_TOO_MANY_ADDRESSES:
+      return WSAENOBUFS;
+
+    case STATUS_SHARING_VIOLATION:
+    case STATUS_ADDRESS_ALREADY_EXISTS:
+      return WSAEADDRINUSE;
+
+    case STATUS_LINK_TIMEOUT:
+    case STATUS_IO_TIMEOUT:
+    case STATUS_TIMEOUT:
+      return WSAETIMEDOUT;
+
+    case STATUS_GRACEFUL_DISCONNECT:
+      return WSAEDISCON;
+
+    case STATUS_REMOTE_DISCONNECT:
+    case STATUS_CONNECTION_RESET:
+    case STATUS_LINK_FAILED:
+    case STATUS_CONNECTION_DISCONNECTED:
+    case STATUS_PORT_UNREACHABLE:
+      return WSAECONNRESET;
+
+    case STATUS_LOCAL_DISCONNECT:
+    case STATUS_TRANSACTION_ABORTED:
+    case STATUS_CONNECTION_ABORTED:
+      return WSAECONNABORTED;
+
+    case STATUS_BAD_NETWORK_PATH:
+    case STATUS_NETWORK_UNREACHABLE:
+    case STATUS_PROTOCOL_UNREACHABLE:
+      return WSAENETUNREACH;
+
+    case STATUS_HOST_UNREACHABLE:
+      return WSAEHOSTUNREACH;
+
+    case STATUS_CANCELLED:
+    case STATUS_REQUEST_ABORTED:
+      return WSAEINTR;
+
+    case STATUS_BUFFER_OVERFLOW:
+    case STATUS_INVALID_BUFFER_SIZE:
+      return WSAEMSGSIZE;
+
+    case STATUS_BUFFER_TOO_SMALL:
+    case STATUS_ACCESS_VIOLATION:
+      return WSAEFAULT;
+
+    case STATUS_DEVICE_NOT_READY:
+    case STATUS_REQUEST_NOT_ACCEPTED:
+      return WSAEWOULDBLOCK;
+
+    case STATUS_INVALID_NETWORK_RESPONSE:
+    case STATUS_NETWORK_BUSY:
+    case STATUS_NO_SUCH_DEVICE:
+    case STATUS_NO_SUCH_FILE:
+    case STATUS_OBJECT_PATH_NOT_FOUND:
+    case STATUS_OBJECT_NAME_NOT_FOUND:
+    case STATUS_UNEXPECTED_NETWORK_ERROR:
+      return WSAENETDOWN;
+
+    case STATUS_INVALID_CONNECTION:
+      return WSAENOTCONN;
+
+    case STATUS_REMOTE_NOT_LISTENING:
+    case STATUS_CONNECTION_REFUSED:
+      return WSAECONNREFUSED;
+
+    case STATUS_PIPE_DISCONNECTED:
+      return WSAESHUTDOWN;
+
+    case STATUS_INVALID_ADDRESS:
+    case STATUS_INVALID_ADDRESS_COMPONENT:
+      return WSAEADDRNOTAVAIL;
+
+    case STATUS_NOT_SUPPORTED:
+    case STATUS_NOT_IMPLEMENTED:
+      return WSAEOPNOTSUPP;
+
+    case STATUS_ACCESS_DENIED:
+      return WSAEACCES;
+
+    default:
+      if (status & ((FACILITY_NTWIN32 << 16) | ERROR_SEVERITY_ERROR)) {
+        /* It's a windows error that has been previously mapped to an */
+        /* ntstatus code. */
+        return (DWORD) (status & 0xffff);
+      } else {
+        /* The default fallback for unmappable ntstatus codes. */
+        return WSAEINVAL;
+      }
+  }
+}

data/ext/noderb_extension/libuv/src/win/winsock.h

@@ -0,0 +1,134 @@
+/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+
+#ifndef UV_WIN_WINSOCK_H_
+#define UV_WIN_WINSOCK_H_
+
+#include <winsock2.h>
+#include <mswsock.h>
+#include <ws2tcpip.h>
+#include <windows.h>
+
+
+/*
+ * Guids and typedefs for winsock extension functions
+ * Mingw32 doesn't have these :-(
+ */
+#ifndef WSAID_ACCEPTEX
+# define WSAID_ACCEPTEX                                        \
+         {0xb5367df1, 0xcbac, 0x11cf,                          \
+         {0x95, 0xca, 0x00, 0x80, 0x5f, 0x48, 0xa1, 0x92}}
+
+# define WSAID_CONNECTEX                                       \
+         {0x25a207b9, 0xddf3, 0x4660,                          \
+         {0x8e, 0xe9, 0x76, 0xe5, 0x8c, 0x74, 0x06, 0x3e}}
+
+# define WSAID_GETACCEPTEXSOCKADDRS                            \
+         {0xb5367df2, 0xcbac, 0x11cf,                          \
+         {0x95, 0xca, 0x00, 0x80, 0x5f, 0x48, 0xa1, 0x92}}
+
+# define WSAID_DISCONNECTEX                                    \
+         {0x7fda2e11, 0x8630, 0x436f,                          \
+         {0xa0, 0x31, 0xf5, 0x36, 0xa6, 0xee, 0xc1, 0x57}}
+
+# define WSAID_TRANSMITFILE                                    \
+         {0xb5367df0, 0xcbac, 0x11cf,                          \
+         {0x95, 0xca, 0x00, 0x80, 0x5f, 0x48, 0xa1, 0x92}}
+
+  typedef BOOL PASCAL (*LPFN_ACCEPTEX)
+                      (SOCKET sListenSocket,
+                       SOCKET sAcceptSocket,
+                       PVOID lpOutputBuffer,
+                       DWORD dwReceiveDataLength,
+                       DWORD dwLocalAddressLength,
+                       DWORD dwRemoteAddressLength,
+                       LPDWORD lpdwBytesReceived,
+                       LPOVERLAPPED lpOverlapped);
+
+  typedef BOOL PASCAL (*LPFN_CONNECTEX)
+                      (SOCKET s,
+                       const struct sockaddr* name,
+                       int namelen,
+                       PVOID lpSendBuffer,
+                       DWORD dwSendDataLength,
+                       LPDWORD lpdwBytesSent,
+                       LPOVERLAPPED lpOverlapped);
+
+  typedef void PASCAL (*LPFN_GETACCEPTEXSOCKADDRS)
+                      (PVOID lpOutputBuffer,
+                       DWORD dwReceiveDataLength,
+                       DWORD dwLocalAddressLength,
+                       DWORD dwRemoteAddressLength,
+                       LPSOCKADDR* LocalSockaddr,
+                       LPINT LocalSockaddrLength,
+                       LPSOCKADDR* RemoteSockaddr,
+                       LPINT RemoteSockaddrLength);
+
+  typedef BOOL PASCAL (*LPFN_DISCONNECTEX)
+                      (SOCKET hSocket,
+                       LPOVERLAPPED lpOverlapped,
+                       DWORD dwFlags,
+                       DWORD reserved);
+
+  typedef BOOL PASCAL (*LPFN_TRANSMITFILE)
+                      (SOCKET hSocket,
+                       HANDLE hFile,
+                       DWORD nNumberOfBytesToWrite,
+                       DWORD nNumberOfBytesPerSend,
+                       LPOVERLAPPED lpOverlapped,
+                       LPTRANSMIT_FILE_BUFFERS lpTransmitBuffers,
+                       DWORD dwFlags);
+#endif
+
+/*
+ * MinGW is missing these too
+ */
+#ifndef SO_UPDATE_CONNECT_CONTEXT
+# define SO_UPDATE_CONNECT_CONTEXT 0x7010
+#endif
+
+#ifndef IPV6_V6ONLY
+  #define IPV6_V6ONLY 27
+#endif
+
+
+/* Winsock extension functions (ipv4) */
+extern LPFN_CONNECTEX pConnectEx;
+extern LPFN_ACCEPTEX pAcceptEx;
+extern LPFN_GETACCEPTEXSOCKADDRS pGetAcceptExSockAddrs;
+extern LPFN_DISCONNECTEX pDisconnectEx;
+extern LPFN_TRANSMITFILE pTransmitFile;
+
+/* Winsock extension functions (ipv6) */
+extern LPFN_CONNECTEX pConnectEx6;
+extern LPFN_ACCEPTEX pAcceptEx6;
+extern LPFN_GETACCEPTEXSOCKADDRS pGetAcceptExSockAddrs6;
+extern LPFN_DISCONNECTEX pDisconnectEx6;
+extern LPFN_TRANSMITFILE  pTransmitFile6;
+
+/* Whether ipv6 is supported */
+extern int uv_allow_ipv6;
+
+/* Ip address used to bind to any port at any interface */
+extern struct sockaddr_in uv_addr_ip4_any_;
+extern struct sockaddr_in6 uv_addr_ip6_any_;
+
+#endif /* UV_WIN_WINSOCK_H_ */

data/ext/noderb_extension/libuv/test/benchmark-ares.c

@@ -26,6 +26,8 @@
 #include <stdio.h>
 #include <string.h> /* strlen */
 
+static uv_loop_t* loop;
+
 ares_channel channel;
 struct ares_options options;
 int optmask;
@@ -67,7 +69,7 @@ static void prep_tcploopback()
   options.tcp_port = htons(TEST_PORT_2);
   options.flags = ARES_FLAG_USEVC;
 
-  rc = uv_ares_init_options(&channel, &options, optmask);
+  rc = uv_ares_init_options(loop, &channel, &options, optmask);
 
   ASSERT(rc == ARES_SUCCESS);
 }
@@ -85,11 +87,13 @@ BENCHMARK_IMPL(gethostbyname) {
   }
 
   uv_init();
+  loop = uv_default_loop();
+
   ares_callbacks = 0;
   ares_errors = 0;
 
-  uv_update_time();
-  start_time = uv_now();
+  uv_update_time(loop);
+  start_time = uv_now(loop);
 
   prep_tcploopback();
 
@@ -101,11 +105,11 @@ BENCHMARK_IMPL(gethostbyname) {
                       &argument);
   }
 
-  uv_run();
+  uv_run(loop);
 
-  uv_ares_destroy(channel);
+  uv_ares_destroy(loop, channel);
 
-  end_time = uv_now();
+  end_time = uv_now(loop);
 
   if (ares_errors > 0) {
     printf("There were %d failures\n", ares_errors);

data/ext/noderb_extension/libuv/test/benchmark-getaddrinfo.c

@@ -32,6 +32,8 @@
 
 const char* name = "localhost";
 
+static uv_loop_t* loop;
+
 static uv_getaddrinfo_t handles[CONCURRENT_CALLS];
 
 static int calls_initiated = 0;
@@ -58,7 +60,7 @@ static void getaddrinfo_initiate(uv_getaddrinfo_t* handle) {
 
   calls_initiated++;
 
-  r = uv_getaddrinfo(handle, &getaddrinfo_cb, name, NULL, NULL);
+  r = uv_getaddrinfo(loop, handle, &getaddrinfo_cb, name, NULL, NULL);
   ASSERT(r == 0);
 }
 
@@ -66,19 +68,20 @@ static void getaddrinfo_initiate(uv_getaddrinfo_t* handle) {
 BENCHMARK_IMPL(getaddrinfo) {
   int i;
 
-  uv_init();
+  uv_init(loop);
+  loop = uv_default_loop();
 
-  uv_update_time();
-  start_time = uv_now();
+  uv_update_time(loop);
+  start_time = uv_now(loop);
 
   for (i = 0; i < CONCURRENT_CALLS; i++) {
     getaddrinfo_initiate(&handles[i]);
   }
 
-  uv_run();
+  uv_run(loop);
 
-  uv_update_time();
-  end_time = uv_now();
+  uv_update_time(loop);
+  end_time = uv_now(loop);
 
   ASSERT(calls_initiated == TOTAL_CALLS);
   ASSERT(calls_completed == TOTAL_CALLS);

data/ext/noderb_extension/libuv/test/benchmark-list.h

@@ -29,6 +29,16 @@ BENCHMARK_DECLARE (tcp_pump100_client)
 BENCHMARK_DECLARE (tcp_pump1_client)
 BENCHMARK_DECLARE (pipe_pump100_client)
 BENCHMARK_DECLARE (pipe_pump1_client)
+BENCHMARK_DECLARE (udp_packet_storm_1v1)
+BENCHMARK_DECLARE (udp_packet_storm_1v10)
+BENCHMARK_DECLARE (udp_packet_storm_1v100)
+BENCHMARK_DECLARE (udp_packet_storm_1v1000)
+BENCHMARK_DECLARE (udp_packet_storm_10v10)
+BENCHMARK_DECLARE (udp_packet_storm_10v100)
+BENCHMARK_DECLARE (udp_packet_storm_10v1000)
+BENCHMARK_DECLARE (udp_packet_storm_100v100)
+BENCHMARK_DECLARE (udp_packet_storm_100v1000)
+BENCHMARK_DECLARE (udp_packet_storm_1000v1000)
 BENCHMARK_DECLARE (gethostbyname)
 BENCHMARK_DECLARE (getaddrinfo)
 BENCHMARK_DECLARE (spawn)
@@ -68,6 +78,17 @@ TASK_LIST_START
   BENCHMARK_ENTRY  (pipe_pound_1000)
   BENCHMARK_HELPER (pipe_pound_1000, pipe_echo_server)
 
+  BENCHMARK_ENTRY  (udp_packet_storm_1v1)
+  BENCHMARK_ENTRY  (udp_packet_storm_1v10)
+  BENCHMARK_ENTRY  (udp_packet_storm_1v100)
+  BENCHMARK_ENTRY  (udp_packet_storm_1v1000)
+  BENCHMARK_ENTRY  (udp_packet_storm_10v10)
+  BENCHMARK_ENTRY  (udp_packet_storm_10v100)
+  BENCHMARK_ENTRY  (udp_packet_storm_10v1000)
+  BENCHMARK_ENTRY  (udp_packet_storm_100v100)
+  BENCHMARK_ENTRY  (udp_packet_storm_100v1000)
+  BENCHMARK_ENTRY  (udp_packet_storm_1000v1000)
+
   BENCHMARK_ENTRY  (gethostbyname)
   BENCHMARK_HELPER (gethostbyname, dns_server)
 

data/ext/noderb_extension/libuv/test/benchmark-ping-pongs.c

@@ -46,13 +46,15 @@ typedef struct buf_s {
 
 static char PING[] = "PING\n";
 
+static uv_loop_t* loop;
+
 static buf_t* buf_freelist = NULL;
 static int pinger_shutdown_cb_called;
 static int completed_pingers = 0;
 static int64_t start_time;
 
 
-static uv_buf_t buf_alloc(uv_stream_t* tcp, size_t size) {
+static uv_buf_t buf_alloc(uv_handle_t* tcp, size_t size) {
   buf_t* ab;
 
   ab = buf_freelist;
@@ -124,13 +126,13 @@ static void pinger_shutdown_cb(uv_shutdown_t* req, int status) {
 
 
 static void pinger_read_cb(uv_stream_t* tcp, ssize_t nread, uv_buf_t buf) {
-  unsigned int i;
+  ssize_t i;
   pinger_t* pinger;
 
   pinger = (pinger_t*)tcp->data;
 
   if (nread < 0) {
-    ASSERT(uv_last_error().code == UV_EOF);
+    ASSERT(uv_last_error(loop).code == UV_EOF);
 
     if (buf.base) {
       buf_free(buf);
@@ -148,7 +150,7 @@ static void pinger_read_cb(uv_stream_t* tcp, ssize_t nread, uv_buf_t buf) {
     pinger->state = (pinger->state + 1) % (sizeof(PING) - 1);
     if (pinger->state == 0) {
       pinger->pongs++;
-      if (uv_now() - start_time > TIME) {
+      if (uv_now(loop) - start_time > TIME) {
         uv_shutdown(&pinger->shutdown_req, (uv_stream_t*) tcp, pinger_shutdown_cb);
         break;
       } else {
@@ -185,7 +187,7 @@ static void pinger_new() {
   pinger->pongs = 0;
 
   /* Try to connec to the server and do NUM_PINGS ping-pongs. */
-  r = uv_tcp_init(&pinger->tcp);
+  r = uv_tcp_init(loop, &pinger->tcp);
   ASSERT(!r);
 
   pinger->tcp.data = pinger;
@@ -199,10 +201,12 @@ static void pinger_new() {
 
 BENCHMARK_IMPL(ping_pongs) {
   uv_init();
-  start_time = uv_now();
+  loop = uv_default_loop();
+
+  start_time = uv_now(loop);
 
   pinger_new();
-  uv_run();
+  uv_run(loop);
 
   ASSERT(completed_pingers == 1);