foolio 0.0.3

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

@@ -0,0 +1,171 @@
+/* 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 <iptypes.h>
+#include <mswsock.h>
+#include <ws2tcpip.h>
+#include <windows.h>
+
+#include "winapi.h"
+
+
+/*
+ * MinGW is missing these too
+ */
+#ifndef SO_UPDATE_CONNECT_CONTEXT
+# define SO_UPDATE_CONNECT_CONTEXT 0x7010
+#endif
+
+#ifndef TCP_KEEPALIVE
+# define TCP_KEEPALIVE 3
+#endif
+
+#ifndef IPV6_V6ONLY
+# define IPV6_V6ONLY 27
+#endif
+
+#ifndef IPV6_HOPLIMIT
+# define IPV6_HOPLIMIT 21
+#endif
+
+#ifndef SIO_BASE_HANDLE
+# define SIO_BASE_HANDLE 0x48000022
+#endif
+
+/*
+ * TDI defines that are only in the DDK.
+ * We only need receive flags so far.
+ */
+#ifndef TDI_RECEIVE_NORMAL
+  #define TDI_RECEIVE_BROADCAST           0x00000004
+  #define TDI_RECEIVE_MULTICAST           0x00000008
+  #define TDI_RECEIVE_PARTIAL             0x00000010
+  #define TDI_RECEIVE_NORMAL              0x00000020
+  #define TDI_RECEIVE_EXPEDITED           0x00000040
+  #define TDI_RECEIVE_PEEK                0x00000080
+  #define TDI_RECEIVE_NO_RESPONSE_EXP     0x00000100
+  #define TDI_RECEIVE_COPY_LOOKAHEAD      0x00000200
+  #define TDI_RECEIVE_ENTIRE_MESSAGE      0x00000400
+  #define TDI_RECEIVE_AT_DISPATCH_LEVEL   0x00000800
+  #define TDI_RECEIVE_CONTROL_INFO        0x00001000
+  #define TDI_RECEIVE_FORCE_INDICATION    0x00002000
+  #define TDI_RECEIVE_NO_PUSH             0x00004000
+#endif
+
+/*
+ * The "Auxiliary Function Driver" is the windows kernel-mode driver that does
+ * TCP, UDP etc. Winsock is just a layer that dispatches requests to it.
+ * Having these definitions allows us to bypass winsock and make an AFD kernel
+ * call directly, avoiding a bug in winsock's recvfrom implementation.
+ */
+
+#define AFD_NO_FAST_IO   0x00000001
+#define AFD_OVERLAPPED   0x00000002
+#define AFD_IMMEDIATE    0x00000004
+
+#define AFD_POLL_RECEIVE_BIT            0
+#define AFD_POLL_RECEIVE                (1 << AFD_POLL_RECEIVE_BIT)
+#define AFD_POLL_RECEIVE_EXPEDITED_BIT  1
+#define AFD_POLL_RECEIVE_EXPEDITED      (1 << AFD_POLL_RECEIVE_EXPEDITED_BIT)
+#define AFD_POLL_SEND_BIT               2
+#define AFD_POLL_SEND                   (1 << AFD_POLL_SEND_BIT)
+#define AFD_POLL_DISCONNECT_BIT         3
+#define AFD_POLL_DISCONNECT             (1 << AFD_POLL_DISCONNECT_BIT)
+#define AFD_POLL_ABORT_BIT              4
+#define AFD_POLL_ABORT                  (1 << AFD_POLL_ABORT_BIT)
+#define AFD_POLL_LOCAL_CLOSE_BIT        5
+#define AFD_POLL_LOCAL_CLOSE            (1 << AFD_POLL_LOCAL_CLOSE_BIT)
+#define AFD_POLL_CONNECT_BIT            6
+#define AFD_POLL_CONNECT                (1 << AFD_POLL_CONNECT_BIT)
+#define AFD_POLL_ACCEPT_BIT             7
+#define AFD_POLL_ACCEPT                 (1 << AFD_POLL_ACCEPT_BIT)
+#define AFD_POLL_CONNECT_FAIL_BIT       8
+#define AFD_POLL_CONNECT_FAIL           (1 << AFD_POLL_CONNECT_FAIL_BIT)
+#define AFD_POLL_QOS_BIT                9
+#define AFD_POLL_QOS                    (1 << AFD_POLL_QOS_BIT)
+#define AFD_POLL_GROUP_QOS_BIT          10
+#define AFD_POLL_GROUP_QOS              (1 << AFD_POLL_GROUP_QOS_BIT)
+
+#define AFD_NUM_POLL_EVENTS             11
+#define AFD_POLL_ALL                    ((1 << AFD_NUM_POLL_EVENTS) - 1)
+
+typedef struct _AFD_RECV_DATAGRAM_INFO {
+    LPWSABUF BufferArray;
+    ULONG BufferCount;
+    ULONG AfdFlags;
+    ULONG TdiFlags;
+    struct sockaddr* Address;
+    int* AddressLength;
+} AFD_RECV_DATAGRAM_INFO, *PAFD_RECV_DATAGRAM_INFO;
+
+typedef struct _AFD_RECV_INFO {
+    LPWSABUF BufferArray;
+    ULONG BufferCount;
+    ULONG AfdFlags;
+    ULONG TdiFlags;
+} AFD_RECV_INFO, *PAFD_RECV_INFO;
+
+
+#define _AFD_CONTROL_CODE(operation, method) \
+    ((FSCTL_AFD_BASE) << 12 | (operation << 2) | method)
+
+#define FSCTL_AFD_BASE FILE_DEVICE_NETWORK
+
+#define AFD_RECEIVE            5
+#define AFD_RECEIVE_DATAGRAM   6
+#define AFD_POLL               9
+
+#define IOCTL_AFD_RECEIVE \
+    _AFD_CONTROL_CODE(AFD_RECEIVE, METHOD_NEITHER)
+
+#define IOCTL_AFD_RECEIVE_DATAGRAM \
+    _AFD_CONTROL_CODE(AFD_RECEIVE_DATAGRAM, METHOD_NEITHER)
+
+#define IOCTL_AFD_POLL \
+    _AFD_CONTROL_CODE(AFD_POLL, METHOD_BUFFERED)
+
+#if defined(__MINGW32__) && !defined(__MINGW64_VERSION_MAJOR)
+typedef struct _IP_ADAPTER_UNICAST_ADDRESS_XP {
+  /* FIXME: __C89_NAMELESS was removed */
+  /* __C89_NAMELESS */ union {
+    ULONGLONG Alignment;
+    /* __C89_NAMELESS */ struct {
+      ULONG Length;
+      DWORD Flags;
+    };
+  };
+  struct _IP_ADAPTER_UNICAST_ADDRESS_XP *Next;
+  SOCKET_ADDRESS Address;
+  IP_PREFIX_ORIGIN PrefixOrigin;
+  IP_SUFFIX_ORIGIN SuffixOrigin;
+  IP_DAD_STATE DadState;
+  ULONG ValidLifetime;
+  ULONG PreferredLifetime;
+  ULONG LeaseLifetime;
+} IP_ADAPTER_UNICAST_ADDRESS_XP,*PIP_ADAPTER_UNICAST_ADDRESS_XP;
+
+#endif
+
+#endif /* UV_WIN_WINSOCK_H_ */

data/ext/libuv/test/benchmark-async-pummel.c

@@ -0,0 +1,97 @@
+/* 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"
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#define NUM_PINGS (1000 * 1000)
+
+static unsigned int callbacks;
+static volatile int done;
+
+
+static void async_cb(uv_async_t* handle, int status) {
+  if (++callbacks == NUM_PINGS)
+    uv_close((uv_handle_t*) handle, NULL);
+}
+
+
+static void pummel(void* arg) {
+  while (!done)
+    uv_async_send((uv_async_t*) arg);
+}
+
+
+static int test_async_pummel(int nthreads) {
+  uv_thread_t* tids;
+  uv_async_t handle;
+  uint64_t time;
+  int i;
+
+  tids = calloc(nthreads, sizeof(tids[0]));
+  ASSERT(tids != NULL);
+
+  ASSERT(0 == uv_async_init(uv_default_loop(), &handle, async_cb));
+
+  for (i = 0; i < nthreads; i++)
+    ASSERT(0 == uv_thread_create(tids + i, pummel, &handle));
+
+  time = uv_hrtime();
+
+  ASSERT(0 == uv_run(uv_default_loop()));
+
+  time = uv_hrtime() - time;
+  done = 1;
+
+  for (i = 0; i < nthreads; i++)
+    ASSERT(0 == uv_thread_join(tids + i));
+
+  printf("%s callbacks in %.2f seconds (%s/sec)\n",
+         fmt(callbacks),
+         time / 1e9,
+         fmt(callbacks / (time / 1e9)));
+
+  free(tids);
+  return 0;
+}
+
+
+BENCHMARK_IMPL(async_pummel_1) {
+  return test_async_pummel(1);
+}
+
+
+BENCHMARK_IMPL(async_pummel_2) {
+  return test_async_pummel(2);
+}
+
+
+BENCHMARK_IMPL(async_pummel_4) {
+  return test_async_pummel(4);
+}
+
+
+BENCHMARK_IMPL(async_pummel_8) {
+  return test_async_pummel(8);
+}

data/ext/libuv/test/benchmark-async.c

@@ -0,0 +1,137 @@
+/* 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"
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#define NUM_PINGS (1000 * 1000)
+
+struct ctx {
+  uv_loop_t* loop;
+  uv_thread_t thread;
+  uv_async_t main_async;    /* wake up main thread */
+  uv_async_t worker_async;  /* wake up worker */
+  unsigned int nthreads;
+  unsigned int main_sent;
+  unsigned int main_seen;
+  unsigned int worker_sent;
+  unsigned int worker_seen;
+};
+
+
+static void worker_async_cb(uv_async_t* handle, int status) {
+  struct ctx* ctx = container_of(handle, struct ctx, worker_async);
+
+  ASSERT(0 == uv_async_send(&ctx->main_async));
+  ctx->worker_sent++;
+  ctx->worker_seen++;
+
+  if (ctx->worker_sent >= NUM_PINGS)
+    uv_close((uv_handle_t*) &ctx->worker_async, NULL);
+}
+
+
+static void main_async_cb(uv_async_t* handle, int status) {
+  struct ctx* ctx = container_of(handle, struct ctx, main_async);
+
+  ASSERT(0 == uv_async_send(&ctx->worker_async));
+  ctx->main_sent++;
+  ctx->main_seen++;
+
+  if (ctx->main_sent >= NUM_PINGS)
+    uv_close((uv_handle_t*) &ctx->main_async, NULL);
+}
+
+
+static void worker(void* arg) {
+  struct ctx* ctx = arg;
+  ASSERT(0 == uv_async_send(&ctx->main_async));
+  ASSERT(0 == uv_run(ctx->loop));
+}
+
+
+static int test_async(int nthreads) {
+  struct ctx* threads;
+  struct ctx* ctx;
+  uint64_t time;
+  int i;
+
+  threads = calloc(nthreads, sizeof(threads[0]));
+  ASSERT(threads != NULL);
+
+  for (i = 0; i < nthreads; i++) {
+    ctx = threads + i;
+    ctx->nthreads = nthreads;
+    ctx->loop = uv_loop_new();
+    ASSERT(ctx->loop != NULL);
+    ASSERT(0 == uv_async_init(ctx->loop, &ctx->worker_async, worker_async_cb));
+    ASSERT(0 == uv_async_init(uv_default_loop(), &ctx->main_async, main_async_cb));
+    ASSERT(0 == uv_thread_create(&ctx->thread, worker, ctx));
+  }
+
+  time = uv_hrtime();
+
+  ASSERT(0 == uv_run(uv_default_loop()));
+
+  for (i = 0; i < nthreads; i++)
+    ASSERT(0 == uv_thread_join(&threads[i].thread));
+
+  time = uv_hrtime() - time;
+
+  for (i = 0; i < nthreads; i++) {
+    ctx = threads + i;
+    ASSERT(ctx->worker_sent == NUM_PINGS);
+    ASSERT(ctx->worker_seen == NUM_PINGS);
+    ASSERT(ctx->main_sent == (unsigned int) NUM_PINGS);
+    ASSERT(ctx->main_seen == (unsigned int) NUM_PINGS);
+  }
+
+  printf("%.2f sec (%s/sec)\n",
+         time / 1e9,
+         fmt(NUM_PINGS / (time / 1e9)));
+
+  free(threads);
+
+  return 0;
+}
+
+
+BENCHMARK_IMPL(async1) {
+  return test_async(1);
+}
+
+
+BENCHMARK_IMPL(async2) {
+  return test_async(2);
+}
+
+
+BENCHMARK_IMPL(async4) {
+  return test_async(4);
+}
+
+
+BENCHMARK_IMPL(async8) {
+  return test_async(8);
+}

data/ext/libuv/test/benchmark-fs-stat.c

@@ -0,0 +1,135 @@
+/* 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"
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#define NUM_SYNC_REQS         (10 * 1e5)
+#define NUM_ASYNC_REQS        (1 * (int) 1e5)
+#define MAX_CONCURRENT_REQS   32
+
+#define sync_stat(req, path)                                                  \
+  do {                                                                        \
+    uv_fs_stat(uv_default_loop(), (req), (path), NULL);                       \
+    uv_fs_req_cleanup((req));                                                 \
+  }                                                                           \
+  while (0)
+
+struct async_req {
+  const char* path;
+  uv_fs_t fs_req;
+  int* count;
+};
+
+
+static void warmup(const char* path) {
+  uv_fs_t reqs[MAX_CONCURRENT_REQS];
+  int i;
+
+  /* warm up the thread pool */
+  for (i = 0; i < ARRAY_SIZE(reqs); i++)
+    uv_fs_stat(uv_default_loop(), reqs + i, path, uv_fs_req_cleanup);
+
+  uv_run(uv_default_loop());
+
+  /* warm up the OS dirent cache */
+  for (i = 0; i < 16; i++)
+    sync_stat(reqs + 0, path);
+}
+
+
+static void sync_bench(const char* path) {
+  uint64_t before;
+  uint64_t after;
+  uv_fs_t req;
+  int i;
+
+  /* do the sync benchmark */
+  before = uv_hrtime();
+
+  for (i = 0; i < NUM_SYNC_REQS; i++)
+    sync_stat(&req, path);
+
+  after = uv_hrtime();
+
+  printf("%s stats (sync): %.2fs (%s/s)\n",
+         fmt(1.0 * NUM_SYNC_REQS),
+         (after - before) / 1e9,
+         fmt((1.0 * NUM_SYNC_REQS) / ((after - before) / 1e9)));
+  fflush(stdout);
+}
+
+
+static void stat_cb(uv_fs_t* fs_req) {
+  struct async_req* req = container_of(fs_req, struct async_req, fs_req);
+  uv_fs_req_cleanup(&req->fs_req);
+  if (*req->count == 0) return;
+  uv_fs_stat(uv_default_loop(), &req->fs_req, req->path, stat_cb);
+  (*req->count)--;
+}
+
+
+static void async_bench(const char* path) {
+  struct async_req reqs[MAX_CONCURRENT_REQS];
+  struct async_req* req;
+  uint64_t before;
+  uint64_t after;
+  int count;
+  int i;
+
+  for (i = 1; i <= MAX_CONCURRENT_REQS; i++) {
+    count = NUM_ASYNC_REQS;
+
+    for (req = reqs; req < reqs + i; req++) {
+      req->path = path;
+      req->count = &count;
+      uv_fs_stat(uv_default_loop(), &req->fs_req, req->path, stat_cb);
+    }
+
+    before = uv_hrtime();
+    uv_run(uv_default_loop());
+    after = uv_hrtime();
+
+    printf("%s stats (%d concurrent): %.2fs (%s/s)\n",
+           fmt(1.0 * NUM_ASYNC_REQS),
+           i,
+           (after - before) / 1e9,
+           fmt((1.0 * NUM_ASYNC_REQS) / ((after - before) / 1e9)));
+    fflush(stdout);
+  }
+}
+
+
+/* This benchmark aims to measure the overhead of doing I/O syscalls from
+ * the thread pool. The stat() syscall was chosen because its results are
+ * easy for the operating system to cache, taking the actual I/O overhead
+ * out of the equation.
+ */
+BENCHMARK_IMPL(fs_stat) {
+  const char path[] = ".";
+  warmup(path);
+  sync_bench(path);
+  async_bench(path);
+  return 0;
+}