Upgrade libuv to f5ff8694

1 files changed, 121 insertions, 37 deletions

diff --git a/deps/uv/test/benchmark-pump.c b/deps/uv/test/benchmark-pump.c
index cd9c7d9967..ad3676d75a 100644
--- a/deps/uv/test/benchmark-pump.c
+++ b/deps/uv/test/benchmark-pump.c
@@ -45,7 +45,9 @@ static uv_buf_t buf_alloc(uv_stream_t*, size_t size);
 static void buf_free(uv_buf_t uv_buf_t);
 
 
-static uv_tcp_t server;
+static uv_tcp_t tcpServer;
+static uv_pipe_t pipeServer;
+static uv_handle_t* server;
 static struct sockaddr_in listen_addr;
 static struct sockaddr_in connect_addr;
 
@@ -68,7 +70,10 @@ static char write_buffer[WRITE_BUFFER_SIZE];
 /* Make this as large as you need. */
 #define MAX_WRITE_HANDLES 1000
 
-static uv_tcp_t write_handles[MAX_WRITE_HANDLES];
+static stream_type type;
+
+static uv_tcp_t tcp_write_handles[MAX_WRITE_HANDLES];
+static uv_pipe_t pipe_write_handles[MAX_WRITE_HANDLES];
 
 static uv_timer_t timer_handle;
 
@@ -81,6 +86,7 @@ static double gbit(int64_t bytes, int64_t passed_ms) {
 
 static void show_stats(uv_timer_t* handle, int status) {
   int64_t diff;
+  int i;
 
 #if PRINT_STATS
   LOGF("connections: %d, write: %.1f gbit/s\n",
@@ -94,9 +100,13 @@ static void show_stats(uv_timer_t* handle, int status) {
     uv_update_time();
     diff = uv_now() - start_time;
 
-    LOGF("pump%d_client: %.1f gbit/s\n", write_sockets,
+    LOGF("%s_pump%d_client: %.1f gbit/s\n", type == TCP ? "tcp" : "pipe", write_sockets,
         gbit(nsent_total, diff));
 
+    for (i = 0; i < write_sockets; i++) {
+      uv_close(type == TCP ? (uv_handle_t*)&tcp_write_handles[i] : (uv_handle_t*)&pipe_write_handles[i], NULL);
+    }
+
     exit(0);
   }
 
@@ -112,7 +122,7 @@ static void read_show_stats() {
   uv_update_time();
   diff = uv_now() - start_time;
 
-  LOGF("pump%d_server: %.1f gbit/s\n", max_read_sockets,
+  LOGF("%s_pump%d_server: %.1f gbit/s\n", type == TCP ? "tcp" : "pipe", max_read_sockets,
       gbit(nrecv_total, diff));
 }
 
@@ -133,7 +143,7 @@ void read_sockets_close_cb(uv_handle_t* handle) {
    */
   if (uv_now() - start_time > 1000 && read_sockets == 0) {
     read_show_stats();
-    uv_close((uv_handle_t*)&server, NULL);
+    uv_close(server, NULL);
   }
 }
 
@@ -154,7 +164,7 @@ static void start_stats_collection() {
 }
 
 
-static void read_cb(uv_stream_t* tcp, ssize_t bytes, uv_buf_t buf) {
+static void read_cb(uv_stream_t* stream, ssize_t bytes, uv_buf_t buf) {
   if (nrecv_total == 0) {
     ASSERT(start_time == 0);
     uv_update_time();
@@ -162,7 +172,7 @@ static void read_cb(uv_stream_t* tcp, ssize_t bytes, uv_buf_t buf) {
   }
 
   if (bytes < 0) {
-    uv_close((uv_handle_t*)tcp, read_sockets_close_cb);
+    uv_close((uv_handle_t*)stream, read_sockets_close_cb);
     return;
   }
 
@@ -187,7 +197,7 @@ static void write_cb(uv_req_t *req, int status) {
 }
 
 
-static void do_write(uv_stream_t* tcp) {
+static void do_write(uv_stream_t* stream) {
   uv_req_t* req;
   uv_buf_t buf;
   int r;
@@ -195,9 +205,9 @@ static void do_write(uv_stream_t* tcp) {
   buf.base = (char*) &write_buffer;
   buf.len = sizeof write_buffer;
 
-  while (tcp->write_queue_size == 0) {
+  while (stream->write_queue_size == 0) {
     req = req_alloc();
-    uv_req_init(req, (uv_handle_t*)tcp, write_cb);
+    uv_req_init(req, (uv_handle_t*)stream, write_cb);
 
     r = uv_write(req, &buf, 1);
     ASSERT(r == 0);
@@ -221,7 +231,7 @@ static void connect_cb(uv_req_t* req, int status) {
 
     /* Yay! start writing */
     for (i = 0; i < write_sockets; i++) {
-      do_write((uv_stream_t*)&write_handles[i]);
+      do_write(type == TCP ? (uv_stream_t*)&tcp_write_handles[i] : (uv_stream_t*)&pipe_write_handles[i]);
     }
   }
 }
@@ -230,38 +240,62 @@ static void connect_cb(uv_req_t* req, int status) {
 static void maybe_connect_some() {
   uv_req_t* req;
   uv_tcp_t* tcp;
+  uv_pipe_t* pipe;
   int r;
 
   while (max_connect_socket < TARGET_CONNECTIONS &&
          max_connect_socket < write_sockets + MAX_SIMULTANEOUS_CONNECTS) {
-    tcp = &write_handles[max_connect_socket++];
-
-    r = uv_tcp_init(tcp);
-    ASSERT(r == 0);
-
-    req = req_alloc();
-    uv_req_init(req, (uv_handle_t*)tcp, connect_cb);
-    r = uv_tcp_connect(req, connect_addr);
-    ASSERT(r == 0);
+    if (type == TCP) {
+      tcp = &tcp_write_handles[max_connect_socket++];
+
+      r = uv_tcp_init(tcp);
+      ASSERT(r == 0);
+
+      req = req_alloc();
+      uv_req_init(req, (uv_handle_t*)tcp, connect_cb);
+      r = uv_tcp_connect(req, connect_addr);
+      ASSERT(r == 0);
+    } else {
+      pipe = &pipe_write_handles[max_connect_socket++];
+
+      r = uv_pipe_init(pipe);
+      ASSERT(r == 0);
+
+      req = req_alloc();
+      uv_req_init(req, (uv_handle_t*)pipe, connect_cb);
+      r = uv_pipe_connect(req, TEST_PIPENAME);
+      ASSERT(r == 0);
+
+#ifdef _WIN32
+      /* HACK: This is temporary to give the pipes server enough time to create new handles.
+       * This will go away once uv_pipe_connect can deal with UV_EBUSY.
+       */
+      Sleep(1);
+#endif
+    }
   }
 }
 
 
 static void connection_cb(uv_handle_t* s, int status) {
-  uv_tcp_t* tcp;
+  uv_stream_t* stream;
   int r;
 
-  ASSERT(&server == (uv_tcp_t*)s);
+  ASSERT(server == s);
   ASSERT(status == 0);
 
-  tcp = malloc(sizeof(uv_tcp_t));
-
-  uv_tcp_init(tcp);
+  if (type == TCP) {
+    stream = (uv_stream_t*)malloc(sizeof(uv_tcp_t));
+    uv_tcp_init((uv_tcp_t*)stream);
+  } else {
+    stream = (uv_stream_t*)malloc(sizeof(uv_pipe_t));
+    uv_pipe_init((uv_pipe_t*)stream);
+  }
 
-  r = uv_accept(s, (uv_stream_t*)tcp);
+  r = uv_accept(s, stream);
   ASSERT(r == 0);
 
-  r = uv_read_start((uv_stream_t*)tcp, buf_alloc, read_cb);
+  r = uv_read_start(stream, buf_alloc, read_cb);
   ASSERT(r == 0);
 
   read_sockets++;
@@ -317,7 +351,7 @@ typedef struct buf_list_s {
 static buf_list_t* buf_freelist = NULL;
 
 
-static uv_buf_t buf_alloc(uv_stream_t* tcp, size_t size) {
+static uv_buf_t buf_alloc(uv_stream_t* stream, size_t size) {
   buf_list_t* buf;
 
   buf = buf_freelist;
@@ -342,18 +376,41 @@ static void buf_free(uv_buf_t uv_buf_t) {
 }
 
 
-HELPER_IMPL(pump_server) {
+HELPER_IMPL(tcp_pump_server) {
   int r;
 
+  type = TCP;
   uv_init();
   listen_addr = uv_ip4_addr("0.0.0.0", TEST_PORT);
 
   /* Server */
-  r = uv_tcp_init(&server);
+  server = (uv_handle_t*)&tcpServer;
+  r = uv_tcp_init(&tcpServer);
+  ASSERT(r == 0);
+  r = uv_tcp_bind(&tcpServer, listen_addr);
+  ASSERT(r == 0);
+  r = uv_tcp_listen(&tcpServer, MAX_WRITE_HANDLES, connection_cb);
+  ASSERT(r == 0);
+
+  uv_run();
+
+  return 0;
+}
+
+
+HELPER_IMPL(pipe_pump_server) {
+  int r;
+  type = PIPE;
+
+  uv_init();
+
+  /* Server */
+  server = (uv_handle_t*)&pipeServer;
+  r = uv_pipe_init(&pipeServer);
   ASSERT(r == 0);
-  r = uv_tcp_bind(&server, listen_addr);
+  r = uv_pipe_bind(&pipeServer, TEST_PIPENAME);
   ASSERT(r == 0);
-  r = uv_tcp_listen(&server, MAX_WRITE_HANDLES, connection_cb);
+  r = uv_pipe_listen(&pipeServer, connection_cb);
   ASSERT(r == 0);
 
   uv_run();
@@ -362,9 +419,10 @@ HELPER_IMPL(pump_server) {
 }
 
 
-void pump(int n) {
+void tcp_pump(int n) {
   ASSERT(n <= MAX_WRITE_HANDLES);
   TARGET_CONNECTIONS = n;
+  type = TCP;
 
   uv_init();
 
@@ -377,13 +435,39 @@ void pump(int n) {
 }
 
 
-BENCHMARK_IMPL(pump100_client) {
-  pump(100);
+void pipe_pump(int n) {
+  ASSERT(n <= MAX_WRITE_HANDLES);
+  TARGET_CONNECTIONS = n;
+  type = PIPE;
+
+  uv_init();
+
+  /* Start making connections */
+  maybe_connect_some();
+
+  uv_run();
+}
+
+
+BENCHMARK_IMPL(tcp_pump100_client) {
+  tcp_pump(100);
+  return 0;
+}
+
+
+BENCHMARK_IMPL(tcp_pump1_client) {
+  tcp_pump(1);
+  return 0;
+}
+
+
+BENCHMARK_IMPL(pipe_pump100_client) {
+  pipe_pump(100);
   return 0;
 }
 
 
-BENCHMARK_IMPL(pump1_client) {
-  pump(1);
+BENCHMARK_IMPL(pipe_pump1_client) {
+  pipe_pump(1);
   return 0;
 }