noderb 0.0.4 → 0.0.6

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

@@ -28,47 +28,59 @@
 #undef NANOSEC
 #define NANOSEC ((uint64_t)10e8)
 
+#define DEBUG 0
+
+struct conn_rec_s;
+
+typedef void (*setup_fn)(int num, void* arg);
+typedef void (*make_connect_fn)(struct conn_rec_s* conn);
+typedef int (*connect_fn)(int num, make_connect_fn make_connect, void* arg);
+
 /* Base class for tcp_conn_rec and pipe_conn_rec.
  * The ordering of fields matters!
  */
-typedef struct {
+typedef struct conn_rec_s {
+  int i;
   uv_connect_t conn_req;
   uv_write_t write_req;
+  make_connect_fn make_connect;
   uv_stream_t stream;
 } conn_rec;
 
 typedef struct {
+  int i;
   uv_connect_t conn_req;
   uv_write_t write_req;
+  make_connect_fn make_connect;
   uv_tcp_t stream;
 } tcp_conn_rec;
 
 typedef struct {
+  int i;
   uv_connect_t conn_req;
   uv_write_t write_req;
+  make_connect_fn make_connect;
   uv_pipe_t stream;
 } pipe_conn_rec;
 
 static char buffer[] = "QS";
 
+static uv_loop_t* loop;
+
 static tcp_conn_rec tcp_conns[MAX_CONNS];
 static pipe_conn_rec pipe_conns[MAX_CONNS];
 
-static uint64_t start_time;
-static uint64_t end_time;
+static uint64_t start; /* in ms  */
 static int closed_streams;
 static int conns_failed;
 
-typedef void *(*setup_fn)(int num, void* arg);
-typedef int (*connect_fn)(int num, void* handles, void* arg);
-
-static uv_buf_t alloc_cb(uv_stream_t* stream, size_t suggested_size);
+static uv_buf_t alloc_cb(uv_handle_t* handle, size_t suggested_size);
 static void connect_cb(uv_connect_t* conn_req, int status);
 static void read_cb(uv_stream_t* stream, ssize_t nread, uv_buf_t buf);
 static void close_cb(uv_handle_t* handle);
 
 
-static uv_buf_t alloc_cb(uv_stream_t* stream, size_t suggested_size) {
+static uv_buf_t alloc_cb(uv_handle_t* handle, size_t suggested_size) {
   static char slab[65536];
   uv_buf_t buf;
   buf.base = slab;
@@ -77,12 +89,25 @@ static uv_buf_t alloc_cb(uv_stream_t* stream, size_t suggested_size) {
 }
 
 
+static void after_write(uv_write_t* req, int status) {
+  if (status != 0) {
+    fprintf(stderr, "write error %s\n", uv_err_name(uv_last_error(loop)));
+    uv_close((uv_handle_t*)req->handle, close_cb);
+    conns_failed++;
+    return;
+  }
+}
+
+
 static void connect_cb(uv_connect_t* req, int status) {
   conn_rec* conn;
   uv_buf_t buf;
   int r;
 
   if (status != 0) {
+#if DEBUG
+    fprintf(stderr, "connect error %s\n", uv_err_name(uv_last_error()));
+#endif
     uv_close((uv_handle_t*)req->handle, close_cb);
     conns_failed++;
     return;
@@ -91,89 +116,150 @@ static void connect_cb(uv_connect_t* req, int status) {
   ASSERT(req != NULL);
   ASSERT(status == 0);
 
-  conn = req->data;
+  conn = (conn_rec*)req->data;
   ASSERT(conn != NULL);
 
+#if DEBUG
+  printf("connect_cb %d\n", conn->i);
+#endif
+
   r = uv_read_start(&conn->stream, alloc_cb, read_cb);
   ASSERT(r == 0);
 
   buf.base = buffer;
   buf.len = sizeof(buffer) - 1;
 
-  r = uv_write(&conn->write_req, &conn->stream, &buf, 1, NULL);
+  r = uv_write(&conn->write_req, &conn->stream, &buf, 1, after_write);
   ASSERT(r == 0);
 }
 
 
 static void read_cb(uv_stream_t* stream, ssize_t nread, uv_buf_t buf) {
+  conn_rec* p = (conn_rec*)stream->data;
+  uv_err_t err = uv_last_error(loop);
+
   ASSERT(stream != NULL);
-  ASSERT(nread == -1 && uv_last_error().code == UV_EOF);
+
+#if DEBUG
+  printf("read_cb %d\n", p->i);
+#endif
+
   uv_close((uv_handle_t*)stream, close_cb);
+
+  if (nread == -1) {
+    if (err.code == UV_EOF) {
+      ;
+    } else if (err.code == UV_ECONNRESET) {
+      conns_failed++;
+    } else {
+      fprintf(stderr, "read error %s\n", uv_err_name(uv_last_error(loop)));
+      ASSERT(0);
+    }
+  }
 }
 
 
 static void close_cb(uv_handle_t* handle) {
+  conn_rec* p = (conn_rec*)handle->data;
+
   ASSERT(handle != NULL);
   closed_streams++;
+
+#if DEBUG
+  printf("close_cb %d\n", p->i);
+#endif
+
+  if (uv_now(loop) - start < 10000) {
+    p->make_connect(p);
+  }
 }
 
 
-static void* tcp_do_setup(int num, void* arg) {
-  tcp_conn_rec* pe;
-  tcp_conn_rec* p;
-  int r;
+static void tcp_do_setup(int num, void* arg) {
+  int i;
 
-  for (p = tcp_conns, pe = p + num; p < pe; p++) {
-    r = uv_tcp_init(&p->stream);
-    ASSERT(r == 0);
+  for (i = 0; i < num; i++) {
+    tcp_conns[i].i = i;
   }
-
-  return tcp_conns;
 }
 
 
-static void* pipe_do_setup(int num, void* arg) {
-  pipe_conn_rec* pe;
-  pipe_conn_rec* p;
-  int r;
+static void pipe_do_setup(int num, void* arg) {
+  int i;
 
-  for (p = pipe_conns, pe = p + num; p < pe; p++) {
-    r = uv_pipe_init(&p->stream);
-    ASSERT(r == 0);
+  for (i = 0; i < num; i++) {
+    pipe_conns[i].i = i;
   }
-
-  return pipe_conns;
 }
 
 
-static int tcp_do_connect(int num, void* conns, void* arg) {
+static void tcp_make_connect(conn_rec* p) {
   struct sockaddr_in addr;
-  tcp_conn_rec* pe;
-  tcp_conn_rec* p;
   int r;
 
+  r = uv_tcp_init(loop, (uv_tcp_t*)&p->stream);
+  ASSERT(r == 0);
+
   addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
-  for (p = tcp_conns, pe = p + num; p < pe; p++) {
-    r = uv_tcp_connect(&p->conn_req, &p->stream, addr, connect_cb);
-    ASSERT(r == 0);
 
-    p->conn_req.data = p;
+  r = uv_tcp_connect(&((tcp_conn_rec*)p)->conn_req, (uv_tcp_t*)&p->stream, addr, connect_cb);
+  if (r) {
+    fprintf(stderr, "uv_tcp_connect error %s\n",
+        uv_err_name(uv_last_error(loop)));
+    ASSERT(0);
   }
 
-  return 0;
+#if DEBUG
+  printf("make connect %d\n", p->i);
+#endif
+
+  p->conn_req.data = p;
+  p->write_req.data = p;
+  p->stream.data = p;
 }
 
 
-static int pipe_do_connect(int num, void* conns, void* arg) {
-  pipe_conn_rec* pe;
-  pipe_conn_rec* p;
+static void pipe_make_connect(conn_rec* p) {
   int r;
 
-  for (p = pipe_conns, pe = p + num; p < pe; p++) {
-    r = uv_pipe_connect(&p->conn_req, &p->stream, TEST_PIPENAME, connect_cb);
-    ASSERT(r == 0);
+  r = uv_pipe_init(loop, (uv_pipe_t*)&p->stream);
+  ASSERT(r == 0);
 
-    p->conn_req.data = p;
+  r = uv_pipe_connect(&((pipe_conn_rec*)p)->conn_req, (uv_pipe_t*)&p->stream, TEST_PIPENAME, connect_cb);
+  if (r) {
+    fprintf(stderr, "uv_tcp_connect error %s\n",
+        uv_err_name(uv_last_error(loop)));
+    ASSERT(0);
+  }
+
+#if DEBUG
+  printf("make connect %d\n", p->i);
+#endif
+
+  p->conn_req.data = p;
+  p->write_req.data = p;
+  p->stream.data = p;
+}
+
+
+static int tcp_do_connect(int num, make_connect_fn make_connect, void* arg) {
+  int i;
+
+  for (i = 0; i < num; i++) {
+    tcp_make_connect((conn_rec*)&tcp_conns[i]);
+    tcp_conns[i].make_connect = make_connect;
+  }
+
+  return 0;
+}
+
+
+static int pipe_do_connect(int num, make_connect_fn make_connect, void* arg) {
+  int i;
+
+  for (i = 0; i < num; i++) {
+    pipe_make_connect((conn_rec*)&pipe_conns[i]);
+    pipe_conns[i].make_connect = make_connect;
   }
 
   return 0;
@@ -184,27 +270,30 @@ static int pound_it(int concurrency,
                     const char* type,
                     setup_fn do_setup,
                     connect_fn do_connect,
+                    make_connect_fn make_connect,
                     void* arg) {
   double secs;
-  void* state;
   int r;
+  uint64_t start_time; /* in ns */
+  uint64_t end_time;
 
   uv_init();
+  loop = uv_default_loop();
+
+  uv_update_time(loop);
+  start = uv_now(loop);
 
   /* Run benchmark for at least five seconds. */
   start_time = uv_hrtime();
-  do {
-    state = do_setup(concurrency, arg);
-    ASSERT(state != NULL);
 
-    r = do_connect(concurrency, state, arg);
-    ASSERT(!r);
+  do_setup(concurrency, arg);
 
-    uv_run();
+  r = do_connect(concurrency, make_connect, arg);
+  ASSERT(!r);
 
-    end_time = uv_hrtime();
-  }
-  while ((end_time - start_time) < 5 * NANOSEC);
+  uv_run(loop);
+
+  end_time = uv_hrtime();
 
   /* Number of fractional seconds it took to run the benchmark. */
   secs = (double)(end_time - start_time) / NANOSEC;
@@ -220,20 +309,20 @@ static int pound_it(int concurrency,
 
 
 BENCHMARK_IMPL(tcp4_pound_100) {
-  return pound_it(100, "tcp", tcp_do_setup, tcp_do_connect, NULL);
+  return pound_it(100, "tcp", tcp_do_setup, tcp_do_connect, tcp_make_connect, NULL);
 }
 
 
 BENCHMARK_IMPL(tcp4_pound_1000) {
-  return pound_it(1000, "tcp", tcp_do_setup, tcp_do_connect, NULL);
+  return pound_it(1000, "tcp", tcp_do_setup, tcp_do_connect, tcp_make_connect, NULL);
 }
 
 
 BENCHMARK_IMPL(pipe_pound_100) {
-  return pound_it(100, "pipe", pipe_do_setup, pipe_do_connect, NULL);
+  return pound_it(100, "pipe", pipe_do_setup, pipe_do_connect, pipe_make_connect, NULL);
 }
 
 
 BENCHMARK_IMPL(pipe_pound_1000) {
-  return pound_it(1000, "pipe", pipe_do_setup, pipe_do_connect, NULL);
+  return pound_it(1000, "pipe", pipe_do_setup, pipe_do_connect, pipe_make_connect, NULL);
 }

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

@@ -41,9 +41,10 @@ static void maybe_connect_some();
 static uv_req_t* req_alloc();
 static void req_free(uv_req_t* uv_req);
 
-static uv_buf_t buf_alloc(uv_stream_t*, size_t size);
+static uv_buf_t buf_alloc(uv_handle_t*, size_t size);
 static void buf_free(uv_buf_t uv_buf_t);
 
+static uv_loop_t* loop;
 
 static uv_tcp_t tcpServer;
 static uv_pipe_t pipeServer;
@@ -97,8 +98,8 @@ static void show_stats(uv_timer_t* handle, int status) {
   /* Exit if the show is over */
   if (!--stats_left) {
 
-    uv_update_time();
-    diff = uv_now() - start_time;
+    uv_update_time(loop);
+    diff = uv_now(loop) - start_time;
 
     LOGF("%s_pump%d_client: %.1f gbit/s\n", type == TCP ? "tcp" : "pipe", write_sockets,
         gbit(nsent_total, diff));
@@ -119,8 +120,8 @@ static void show_stats(uv_timer_t* handle, int status) {
 static void read_show_stats() {
   int64_t diff;
 
-  uv_update_time();
-  diff = uv_now() - start_time;
+  uv_update_time(loop);
+  diff = uv_now(loop) - start_time;
 
   LOGF("%s_pump%d_server: %.1f gbit/s\n", type == TCP ? "tcp" : "pipe", max_read_sockets,
       gbit(nrecv_total, diff));
@@ -141,7 +142,7 @@ void read_sockets_close_cb(uv_handle_t* handle) {
   /* If it's past the first second and everyone has closed their connection
    * Then print stats.
    */
-  if (uv_now() - start_time > 1000 && read_sockets == 0) {
+  if (uv_now(loop) - start_time > 1000 && read_sockets == 0) {
     read_show_stats();
     uv_close((uv_handle_t*)server, NULL);
   }
@@ -153,21 +154,21 @@ static void start_stats_collection() {
 
   /* Show-stats timer */
   stats_left = STATS_COUNT;
-  r = uv_timer_init(&timer_handle);
+  r = uv_timer_init(loop, &timer_handle);
   ASSERT(r == 0);
   r = uv_timer_start(&timer_handle, show_stats, STATS_INTERVAL, STATS_INTERVAL);
   ASSERT(r == 0);
 
-  uv_update_time();
-  start_time = uv_now();
+  uv_update_time(loop);
+  start_time = uv_now(loop);
 }
 
 
 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();
-    start_time = uv_now();
+    uv_update_time(loop);
+    start_time = uv_now(loop);
   }
 
   if (bytes < 0) {
@@ -213,7 +214,7 @@ static void do_write(uv_stream_t* stream) {
 static void connect_cb(uv_connect_t* req, int status) {
   int i;
 
-  if (status) LOG(uv_strerror(uv_last_error()));
+  if (status) LOG(uv_strerror(uv_last_error(loop)));
   ASSERT(status == 0);
 
   write_sockets++;
@@ -243,7 +244,7 @@ static void maybe_connect_some() {
     if (type == TCP) {
       tcp = &tcp_write_handles[max_connect_socket++];
 
-      r = uv_tcp_init(tcp);
+      r = uv_tcp_init(loop, tcp);
       ASSERT(r == 0);
 
       req = (uv_connect_t*) req_alloc();
@@ -252,7 +253,7 @@ static void maybe_connect_some() {
     } else {
       pipe = &pipe_write_handles[max_connect_socket++];
 
-      r = uv_pipe_init(pipe);
+      r = uv_pipe_init(loop, pipe);
       ASSERT(r == 0);
 
       req = (uv_connect_t*) req_alloc();
@@ -272,10 +273,10 @@ static void connection_cb(uv_stream_t* s, int status) {
 
   if (type == TCP) {
     stream = (uv_stream_t*)malloc(sizeof(uv_tcp_t));
-    uv_tcp_init((uv_tcp_t*)stream);
+    uv_tcp_init(loop, (uv_tcp_t*)stream);
   } else {
     stream = (uv_stream_t*)malloc(sizeof(uv_pipe_t));
-    uv_pipe_init((uv_pipe_t*)stream);
+    uv_pipe_init(loop, (uv_pipe_t*)stream);
   }
 
   r = uv_accept(s, stream);
@@ -337,7 +338,7 @@ typedef struct buf_list_s {
 static buf_list_t* buf_freelist = NULL;
 
 
-static uv_buf_t buf_alloc(uv_stream_t* stream, size_t size) {
+static uv_buf_t buf_alloc(uv_handle_t* handle, size_t size) {
   buf_list_t* buf;
 
   buf = buf_freelist;
@@ -367,18 +368,20 @@ HELPER_IMPL(tcp_pump_server) {
 
   type = TCP;
   uv_init();
+  loop = uv_default_loop();
+
   listen_addr = uv_ip4_addr("0.0.0.0", TEST_PORT);
 
   /* Server */
   server = (uv_stream_t*)&tcpServer;
-  r = uv_tcp_init(&tcpServer);
+  r = uv_tcp_init(loop, &tcpServer);
   ASSERT(r == 0);
   r = uv_tcp_bind(&tcpServer, listen_addr);
   ASSERT(r == 0);
   r = uv_listen((uv_stream_t*)&tcpServer, MAX_WRITE_HANDLES, connection_cb);
   ASSERT(r == 0);
 
-  uv_run();
+  uv_run(loop);
 
   return 0;
 }
@@ -389,17 +392,18 @@ HELPER_IMPL(pipe_pump_server) {
   type = PIPE;
 
   uv_init();
+  loop = uv_default_loop();
 
   /* Server */
   server = (uv_stream_t*)&pipeServer;
-  r = uv_pipe_init(&pipeServer);
+  r = uv_pipe_init(loop, &pipeServer);
   ASSERT(r == 0);
   r = uv_pipe_bind(&pipeServer, TEST_PIPENAME);
   ASSERT(r == 0);
   r = uv_listen((uv_stream_t*)&pipeServer, MAX_WRITE_HANDLES, connection_cb);
   ASSERT(r == 0);
 
-  uv_run();
+  uv_run(loop);
 
   return 0;
 }
@@ -411,13 +415,14 @@ void tcp_pump(int n) {
   type = TCP;
 
   uv_init();
+  loop = uv_default_loop();
 
   connect_addr = uv_ip4_addr("127.0.0.1", TEST_PORT);
 
   /* Start making connections */
   maybe_connect_some();
 
-  uv_run();
+  uv_run(loop);
 }
 
 
@@ -427,11 +432,12 @@ void pipe_pump(int n) {
   type = PIPE;
 
   uv_init();
+  loop = uv_default_loop();
 
   /* Start making connections */
   maybe_connect_some();
 
-  uv_run();
+  uv_run(loop);
 }
 
 

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

@@ -24,6 +24,8 @@
 #include "task.h"
 #include "uv.h"
 
+static uv_loop_t* loop;
+
 static int N = 1000;
 static int done;
 
@@ -69,7 +71,7 @@ static void exit_cb(uv_process_t* process, int exit_status, int term_signal) {
 }
 
 
-uv_buf_t on_alloc(uv_stream_t* tcp, size_t suggested_size) {
+uv_buf_t on_alloc(uv_handle_t* handle, size_t suggested_size) {
   uv_buf_t buf;
   buf.base = output + output_used;
   buf.len = OUTPUT_SIZE - output_used;
@@ -85,7 +87,7 @@ void pipe_close_cb(uv_handle_t* pipe) {
 
 
 void on_read(uv_stream_t* pipe, ssize_t nread, uv_buf_t buf) {
-  uv_err_t err = uv_last_error();
+  uv_err_t err = uv_last_error(loop);
 
   if (nread > 0) {
     ASSERT(pipe_open == 1);
@@ -111,10 +113,10 @@ static void spawn() {
   options.args = args;
   options.exit_cb = exit_cb;
 
-  uv_pipe_init(&out);
+  uv_pipe_init(loop, &out);
   options.stdout_stream = &out;
 
-  r = uv_spawn(&process, options);
+  r = uv_spawn(loop, &process, options);
   ASSERT(r == 0);
 
   process_open = 1;
@@ -127,25 +129,26 @@ static void spawn() {
 
 
 BENCHMARK_IMPL(spawn) {
-  int r; 
+  int r;
   static int64_t start_time, end_time;
 
   uv_init();
+  loop = uv_default_loop();
 
   r = uv_exepath(exepath, &exepath_size);
   ASSERT(r == 0);
   exepath[exepath_size] = '\0';
 
-  uv_update_time();
-  start_time = uv_now();
+  uv_update_time(loop);
+  start_time = uv_now(loop);
 
   spawn();
 
-  r = uv_run();
+  r = uv_run(loop);
   ASSERT(r == 0);
 
-  uv_update_time();
-  end_time = uv_now();
+  uv_update_time(loop);
+  end_time = uv_now(loop);
 
   LOGF("spawn: %.0f spawns/s\n",
        (double) N / (double) (end_time - start_time) * 1000.0);