asyncengine 0.0.1.testing1 → 0.0.2.alpha1

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

@@ -20,6 +20,8 @@
  */
 
 BENCHMARK_DECLARE (sizes)
+BENCHMARK_DECLARE (loop_count)
+BENCHMARK_DECLARE (loop_count_timed)
 BENCHMARK_DECLARE (ping_pongs)
 BENCHMARK_DECLARE (tcp_write_batch)
 BENCHMARK_DECLARE (tcp4_pound_100)
@@ -42,8 +44,10 @@ BENCHMARK_DECLARE (udp_packet_storm_100v1000)
 BENCHMARK_DECLARE (udp_packet_storm_1000v1000)
 BENCHMARK_DECLARE (gethostbyname)
 BENCHMARK_DECLARE (getaddrinfo)
+BENCHMARK_DECLARE (fs_stat)
 BENCHMARK_DECLARE (spawn)
 BENCHMARK_DECLARE (thread_create)
+BENCHMARK_DECLARE (million_timers)
 HELPER_DECLARE    (tcp4_blackhole_server)
 HELPER_DECLARE    (tcp_pump_server)
 HELPER_DECLARE    (pipe_pump_server)
@@ -53,6 +57,8 @@ HELPER_DECLARE    (dns_server)
 
 TASK_LIST_START
   BENCHMARK_ENTRY  (sizes)
+  BENCHMARK_ENTRY  (loop_count)
+  BENCHMARK_ENTRY  (loop_count_timed)
 
   BENCHMARK_ENTRY  (ping_pongs)
   BENCHMARK_HELPER (ping_pongs, tcp4_echo_server)
@@ -100,6 +106,9 @@ TASK_LIST_START
 
   BENCHMARK_ENTRY  (getaddrinfo)
 
+  BENCHMARK_ENTRY  (fs_stat)
+
   BENCHMARK_ENTRY  (spawn)
   BENCHMARK_ENTRY  (thread_create)
+  BENCHMARK_ENTRY  (million_timers)
 TASK_LIST_END

data/ext/asyncengine/libuv/{src/unix/prepare.c → test/benchmark-loop-count.c}

@@ -1,4 +1,5 @@
 /* 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
@@ -18,62 +19,70 @@
  * IN THE SOFTWARE.
  */
 
+#include "task.h"
 #include "uv.h"
-#include "internal.h"
 
+#include <stdio.h>
+#include <stdlib.h>
+
+#define NUM_TICKS (2 * 1000 * 1000)
+
+static unsigned long ticks;
+static uv_idle_t idle_handle;
+static uv_timer_t timer_handle;
 
-static void uv__prepare(EV_P_ ev_prepare* w, int revents) {
-  uv_prepare_t* prepare = container_of(w, uv_prepare_t, prepare_watcher);
 
-  if (prepare->prepare_cb) {
-    prepare->prepare_cb(prepare, 0);
-  }
+static void idle_cb(uv_idle_t* handle, int status) {
+  if (++ticks == NUM_TICKS)
+    uv_idle_stop(handle);
 }
 
 
-int uv_prepare_init(uv_loop_t* loop, uv_prepare_t* prepare) {
-  uv__handle_init(loop, (uv_handle_t*)prepare, UV_PREPARE);
-  loop->counters.prepare_init++;
+static void idle2_cb(uv_idle_t* handle, int status) {
+  ticks++;
+}
 
-  ev_prepare_init(&prepare->prepare_watcher, uv__prepare);
-  prepare->prepare_cb = NULL;
 
-  return 0;
+static void timer_cb(uv_timer_t* handle, int status) {
+  uv_idle_stop(&idle_handle);
+  uv_timer_stop(&timer_handle);
 }
 
 
-int uv_prepare_start(uv_prepare_t* prepare, uv_prepare_cb cb) {
-  int was_active = ev_is_active(&prepare->prepare_watcher);
+BENCHMARK_IMPL(loop_count) {
+  uv_loop_t* loop = uv_default_loop();
+  uint64_t ns;
+
+  uv_idle_init(loop, &idle_handle);
+  uv_idle_start(&idle_handle, idle_cb);
 
-  prepare->prepare_cb = cb;
+  ns = uv_hrtime();
+  uv_run(loop);
+  ns = uv_hrtime() - ns;
 
-  ev_prepare_start(prepare->loop->ev, &prepare->prepare_watcher);
+  ASSERT(ticks == NUM_TICKS);
 
-  if (!was_active) {
-    ev_unref(prepare->loop->ev);
-  }
+  LOGF("loop_count: %d ticks in %.2fs (%.0f/s)\n",
+       NUM_TICKS,
+       ns / 1e9,
+       NUM_TICKS / (ns / 1e9));
 
   return 0;
 }
 
 
-int uv_prepare_stop(uv_prepare_t* prepare) {
-  int was_active = ev_is_active(&prepare->prepare_watcher);
+BENCHMARK_IMPL(loop_count_timed) {
+  uv_loop_t* loop = uv_default_loop();
 
-  ev_prepare_stop(prepare->loop->ev, &prepare->prepare_watcher);
+  uv_idle_init(loop, &idle_handle);
+  uv_idle_start(&idle_handle, idle2_cb);
 
-  if (was_active) {
-    ev_ref(prepare->loop->ev);
-  }
-  return 0;
-}
+  uv_timer_init(loop, &timer_handle);
+  uv_timer_start(&timer_handle, timer_cb, 5000, 0);
 
+  uv_run(loop);
 
-int uv__prepare_active(const uv_prepare_t* handle) {
-  return ev_is_active(&handle->prepare_watcher);
-}
+  LOGF("loop_count: %lu ticks (%.0f ticks/s)\n", ticks, ticks / 5.0);
 
-
-void uv__prepare_close(uv_prepare_t* handle) {
-  uv_prepare_stop(handle);
+  return 0;
 }

data/ext/asyncengine/libuv/test/benchmark-million-timers.c

@@ -0,0 +1,65 @@
+/* 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 "task.h"
+#include "uv.h"
+
+#define NUM_TIMERS (1000 * 1000)
+
+static int timer_cb_called;
+
+
+static void timer_cb(uv_timer_t* handle, int status) {
+  timer_cb_called++;
+}
+
+
+BENCHMARK_IMPL(million_timers) {
+  uv_timer_t* timers;
+  uv_loop_t* loop;
+  uint64_t before;
+  uint64_t after;
+  int timeout;
+  int i;
+
+  timers = malloc(NUM_TIMERS * sizeof(timers[0]));
+  ASSERT(timers != NULL);
+
+  loop = uv_default_loop();
+  timeout = 0;
+
+  for (i = 0; i < NUM_TIMERS; i++) {
+    if (i % 1000 == 0) timeout++;
+    ASSERT(0 == uv_timer_init(loop, timers + i));
+    ASSERT(0 == uv_timer_start(timers + i, timer_cb, timeout, 0));
+  }
+
+  before = uv_hrtime();
+  ASSERT(0 == uv_run(loop));
+  after = uv_hrtime();
+
+  ASSERT(timer_cb_called == NUM_TIMERS);
+  free(timers);
+
+  LOGF("%.2f seconds\n", (after - before) / 1e9);
+
+  return 0;
+}

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

@@ -26,7 +26,7 @@
 #define MAX_CONNS 1000
 
 #undef NANOSEC
-#define NANOSEC ((uint64_t)10e8)
+#define NANOSEC ((uint64_t) 1e9)
 
 #undef DEBUG
 #define DEBUG 0

data/ext/asyncengine/libuv/test/benchmark-sizes.c

@@ -27,6 +27,7 @@ BENCHMARK_IMPL(sizes) {
   LOGF("uv_shutdown_t: %u bytes\n", (unsigned int) sizeof(uv_shutdown_t));
   LOGF("uv_write_t: %u bytes\n", (unsigned int) sizeof(uv_write_t));
   LOGF("uv_connect_t: %u bytes\n", (unsigned int) sizeof(uv_connect_t));
+  LOGF("uv_udp_send_t: %u bytes\n", (unsigned int) sizeof(uv_udp_send_t));
   LOGF("uv_tcp_t: %u bytes\n", (unsigned int) sizeof(uv_tcp_t));
   LOGF("uv_pipe_t: %u bytes\n", (unsigned int) sizeof(uv_pipe_t));
   LOGF("uv_tty_t: %u bytes\n", (unsigned int) sizeof(uv_tty_t));
@@ -36,5 +37,6 @@ BENCHMARK_IMPL(sizes) {
   LOGF("uv_async_t: %u bytes\n", (unsigned int) sizeof(uv_async_t));
   LOGF("uv_timer_t: %u bytes\n", (unsigned int) sizeof(uv_timer_t));
   LOGF("uv_process_t: %u bytes\n", (unsigned int) sizeof(uv_process_t));
+  LOGF("uv_poll_t: %u bytes\n", (unsigned int) sizeof(uv_poll_t));
   return 0;
 }

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

@@ -101,6 +101,7 @@ void on_read(uv_stream_t* pipe, ssize_t nread, uv_buf_t buf) {
 
 
 static void spawn() {
+  uv_stdio_container_t stdio[2];
   int r;
 
   ASSERT(process_open == 0);
@@ -114,7 +115,12 @@ static void spawn() {
   options.exit_cb = exit_cb;
 
   uv_pipe_init(loop, &out, 0);
-  options.stdout_stream = &out;
+
+  options.stdio = stdio;
+  options.stdio_count = 2;
+  options.stdio[0].flags = UV_IGNORE;
+  options.stdio[1].flags = UV_CREATE_PIPE | UV_WRITABLE_PIPE;
+  options.stdio[1].data.stream = (uv_stream_t*)&out;
 
   r = uv_spawn(loop, &process, options);
   ASSERT(r == 0);

data/ext/asyncengine/libuv/test/benchmark-udp-packet-storm.c

@@ -144,7 +144,7 @@ static int do_packet_storm(int n_senders, int n_receivers) {
   ASSERT(r == 0);
 
   /* Timer should not keep loop alive. */
-  uv_unref(loop);
+  uv_unref((uv_handle_t*)&timeout);
 
   for (i = 0; i < n_receivers; i++) {
     struct sockaddr_in addr;

data/ext/asyncengine/libuv/test/echo-server.c

@@ -298,6 +298,14 @@ static int udp4_echo_start(int port) {
 static int pipe_echo_start(char* pipeName) {
   int r;
 
+#ifndef _WIN32
+  {
+    uv_fs_t req;
+    uv_fs_unlink(uv_default_loop(), &req, pipeName, NULL);
+    uv_fs_req_cleanup(&req);
+  }
+#endif
+
   server = (uv_handle_t*)&pipeServer;
   serverType = PIPE;
 

data/ext/asyncengine/libuv/test/run-tests.c

@@ -22,6 +22,12 @@
 #include <stdio.h>
 #include <string.h>
 
+#ifdef _WIN32
+# include <io.h>
+#else
+# include <unistd.h>
+#endif
+
 #include "uv.h"
 #include "runner.h"
 #include "task.h"
@@ -104,5 +110,29 @@ static int maybe_run_test(int argc, char **argv) {
     while (1) uv_sleep(10000);
   }
 
+  if (strcmp(argv[1], "spawn_helper5") == 0) {
+    const char* out = "fourth stdio!\n\0";
+#ifdef _WIN32
+    DWORD bytes;
+    WriteFile((HANDLE) _get_osfhandle(3), out, strlen(out), &bytes, NULL);
+#else
+    write(3, out, strlen(out));
+    fsync(3);
+#endif
+    return 1;
+  }
+
+  if (strcmp(argv[1], "spawn_helper6") == 0) {
+    int r;
+
+    r = fprintf(stdout, "hello world\n");
+    ASSERT(r > 0);
+
+    r = fprintf(stderr, "hello errworld\n");
+    ASSERT(r > 0);
+
+    return 1;
+  }
+
   return run_test(argv[1], TEST_TIMEOUT, 0);
 }

data/ext/asyncengine/libuv/test/runner-unix.c

@@ -40,6 +40,11 @@
 
 /* Do platform-specific initialization. */
 void platform_init(int argc, char **argv) {
+  /* Running the tests as root is not smart - don't do it. */
+  if (getuid() == 0) {
+    fprintf(stderr, "Running the tests as root is not safe.\n");
+    exit(1);
+  }
   /* Disable stdio output buffering. */
   setvbuf(stdout, NULL, _IONBF, 0);
   setvbuf(stderr, NULL, _IONBF, 0);
@@ -100,13 +105,12 @@ typedef struct {
 static void* dowait(void* data) {
   dowait_args* args = data;
 
-  int i, status, r;
+  int i, r;
   process_info_t* p;
 
   for (i = 0; i < args->n; i++) {
     p = (process_info_t*)(args->vec + i * sizeof(process_info_t));
     if (p->terminated) continue;
-    status = 0;
     r = waitpid(p->pid, &p->status, 0);
     if (r < 0) {
       perror("waitpid");
@@ -285,30 +289,6 @@ void rewind_cursor() {
 }
 
 
-typedef void* (*uv_thread_cb)(void* arg);
-
-
-uintptr_t uv_create_thread(void (*entry)(void* arg), void* arg) {
-  pthread_t t;
-  uv_thread_cb cb = (uv_thread_cb)entry;
-  int r = pthread_create(&t, NULL, cb, arg);
-
-  if (r) {
-    return 0;
-  }
-
-  return (uintptr_t)t;
-}
-
-
-/* Wait for a thread to terminate. Should return 0 if the thread ended, -1 on
- * error.
- */
-int uv_wait_thread(uintptr_t thread_id) {
-  return pthread_join((pthread_t)thread_id, NULL);
-}
-
-
 /* Pause the calling thread for a number of milliseconds. */
 void uv_sleep(int msec) {
   usleep(msec * 1000);

data/ext/asyncengine/libuv/test/runner-win.c

@@ -19,6 +19,7 @@
  * IN THE SOFTWARE.
  */
 
+#include <fcntl.h>
 #include <io.h>
 #include <malloc.h>
 #include <stdio.h>
@@ -44,6 +45,10 @@ void platform_init(int argc, char **argv) {
   SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOGPFAULTERRORBOX |
       SEM_NOOPENFILEERRORBOX);
 
+  _setmode(0, _O_BINARY);
+  _setmode(1, _O_BINARY);
+  _setmode(2, _O_BINARY);
+
   /* Disable stdio output buffering. */
   setvbuf(stdout, NULL, _IONBF, 0);
   setvbuf(stderr, NULL, _IONBF, 0);
@@ -274,69 +279,6 @@ void rewind_cursor() {
 }
 
 
-typedef struct {
-  void (*entry)(void* arg);
-  void* arg;
-} thread_info_t;
-
-
-static unsigned __stdcall create_thread_helper(void* info) {
-  /* Copy thread info locally, then free it */
-  void (*entry)(void* arg) = ((thread_info_t*) info)->entry;
-  void* arg = ((thread_info_t*) info)->arg;
-
-  free(info);
-
-  /* Run the actual thread proc */
-  entry(arg);
-
-  /* Finalize */
-  _endthreadex(0);
-  return 0;
-}
-
-
-/* Create a thread. Returns the thread identifier, or 0 on failure. */
-uintptr_t uv_create_thread(void (*entry)(void* arg), void* arg) {
-  uintptr_t result;
-  thread_info_t* info;
-
-  info = (thread_info_t*) malloc(sizeof *info);
-  if (info == NULL) {
-    return 0;
-  }
-
-  info->entry = entry;
-  info->arg = arg;
-
-  result = _beginthreadex(NULL,
-                          0,
-                          &create_thread_helper,
-                          (void*) info,
-                          0,
-                          NULL);
-
-  if (result == 0) {
-    free(info);
-    return 0;
-  }
-
-  return result;
-}
-
-
-/* Wait for a thread to terminate. Should return 0 if the thread ended, -1 on
- * error.
- */
-int uv_wait_thread(uintptr_t thread_id) {
-  if (WaitForSingleObject((HANDLE)thread_id, INFINITE) != WAIT_OBJECT_0) {
-    return -1;
-  }
-
-  return 0;
-}
-
-
 /* Pause the calling thread for a number of milliseconds. */
 void uv_sleep(int msec) {
   Sleep(msec);