asyncengine 0.0.1.testing1 → 0.0.2.alpha1

data/ext/asyncengine/libuv/src/win/winapi.c

@@ -22,17 +22,22 @@
 #include <assert.h>
 
 #include "uv.h"
-#include "../uv-common.h"
 #include "internal.h"
 
 
+/* Ntdll function pointers */
 sRtlNtStatusToDosError pRtlNtStatusToDosError;
 sNtDeviceIoControlFile pNtDeviceIoControlFile;
 sNtQueryInformationFile pNtQueryInformationFile;
 sNtSetInformationFile pNtSetInformationFile;
+sNtQuerySystemInformation pNtQuerySystemInformation;
+
+
+/* Kernel32 function pointers */
 sGetQueuedCompletionStatusEx pGetQueuedCompletionStatusEx;
 sSetFileCompletionNotificationModes pSetFileCompletionNotificationModes;
 sCreateSymbolicLinkW pCreateSymbolicLinkW;
+sCancelIoEx pCancelIoEx;
 sInitializeSRWLock pInitializeSRWLock;
 sAcquireSRWLockShared pAcquireSRWLockShared;
 sAcquireSRWLockExclusive pAcquireSRWLockExclusive;
@@ -79,6 +84,13 @@ void uv_winapi_init() {
     uv_fatal_error(GetLastError(), "GetProcAddress");
   }
 
+  pNtQuerySystemInformation = (sNtQuerySystemInformation) GetProcAddress(
+      ntdll_module,
+      "NtQuerySystemInformation");
+  if (pNtQuerySystemInformation == NULL) {
+    uv_fatal_error(GetLastError(), "GetProcAddress");
+  }
+
   kernel32_module = GetModuleHandleA("kernel32.dll");
   if (kernel32_module == NULL) {
     uv_fatal_error(GetLastError(), "GetModuleHandleA");
@@ -94,6 +106,9 @@ void uv_winapi_init() {
   pCreateSymbolicLinkW = (sCreateSymbolicLinkW)
     GetProcAddress(kernel32_module, "CreateSymbolicLinkW");
 
+  pCancelIoEx = (sCancelIoEx)
+    GetProcAddress(kernel32_module, "CancelIoEx");
+
   pInitializeSRWLock = (sInitializeSRWLock)
     GetProcAddress(kernel32_module, "InitializeSRWLock");
 

data/ext/asyncengine/libuv/src/win/winapi.h

@@ -28,11 +28,6 @@
 /*
  * Ntdll headers
  */
-#ifndef _NTDEF_
-  typedef LONG NTSTATUS;
-  typedef NTSTATUS *PNTSTATUS;
-#endif
-
 #ifndef STATUS_SEVERITY_SUCCESS
 # define STATUS_SEVERITY_SUCCESS 0x0
 #endif
@@ -4079,8 +4074,8 @@
         (FACILITY_NTWIN32 << 16) | ERROR_SEVERITY_WARNING)))
 
 /* from ntifs.h */
-/* MinGW already has it */
-#if defined(_MSC_VER) || defined(__MINGW64__)
+/* MinGW already has it, mingw-w64 does not. */
+#if defined(_MSC_VER) || defined(__MINGW64_VERSION_MAJOR)
   typedef struct _REPARSE_DATA_BUFFER {
     ULONG  ReparseTag;
     USHORT ReparseDataLength;
@@ -4141,6 +4136,10 @@ typedef struct _FILE_MODE_INFORMATION {
   ULONG Mode;
 } FILE_MODE_INFORMATION, *PFILE_MODE_INFORMATION;
 
+typedef struct _FILE_END_OF_FILE_INFORMATION {
+  LARGE_INTEGER  EndOfFile;
+} FILE_END_OF_FILE_INFORMATION, *PFILE_END_OF_FILE_INFORMATION;
+
 #define FILE_SYNCHRONOUS_IO_ALERT               0x00000010
 #define FILE_SYNCHRONOUS_IO_NONALERT            0x00000020
 
@@ -4203,6 +4202,19 @@ typedef enum _FILE_INFORMATION_CLASS {
   FileMaximumInformation
 } FILE_INFORMATION_CLASS, *PFILE_INFORMATION_CLASS;
 
+typedef struct _SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION {
+    LARGE_INTEGER IdleTime;
+    LARGE_INTEGER KernelTime;
+    LARGE_INTEGER UserTime;
+    LARGE_INTEGER DpcTime;
+    LARGE_INTEGER InterruptTime;
+    ULONG InterruptCount;
+} SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION, *PSYSTEM_PROCESSOR_PERFORMANCE_INFORMATION;
+
+#ifndef SystemProcessorPerformanceInformation
+# define SystemProcessorPerformanceInformation 8
+#endif
+
 #ifndef DEVICE_TYPE
 # define DEVICE_TYPE DWORD
 #endif
@@ -4319,6 +4331,12 @@ typedef NTSTATUS (NTAPI *sNtSetInformationFile)
                   ULONG Length,
                   FILE_INFORMATION_CLASS FileInformationClass);
 
+typedef NTSTATUS (NTAPI *sNtQuerySystemInformation)
+                 (UINT SystemInformationClass,
+                  PVOID SystemInformation,
+                  ULONG SystemInformationLength,
+                  PULONG ReturnLength);
+
 
 /*
  * Kernel32 headers
@@ -4335,7 +4353,7 @@ typedef NTSTATUS (NTAPI *sNtSetInformationFile)
 # define SYMBOLIC_LINK_FLAG_DIRECTORY 0x1
 #endif
 
-#ifdef __MINGW32__
+#if defined(__MINGW32__) && !defined(__MINGW64_VERSION_MAJOR)
   typedef struct _OVERLAPPED_ENTRY {
       ULONG_PTR lpCompletionKey;
       LPOVERLAPPED lpOverlapped;
@@ -4374,6 +4392,10 @@ typedef BOOLEAN (WINAPI* sCreateSymbolicLinkW)
                  LPCWSTR lpTargetFileName,
                  DWORD dwFlags);
 
+typedef BOOL (WINAPI* sCancelIoEx)
+             (HANDLE hFile,
+              LPOVERLAPPED lpOverlapped);
+
 typedef VOID (WINAPI* sInitializeSRWLock)
              (PSRWLOCK SRWLock);
 
@@ -4397,17 +4419,19 @@ typedef VOID (WINAPI* sReleaseSRWLockExclusive)
 
 
 
-/* Ntapi function pointers */
+/* Ntdll function pointers */
 extern sRtlNtStatusToDosError pRtlNtStatusToDosError;
 extern sNtDeviceIoControlFile pNtDeviceIoControlFile;
 extern sNtQueryInformationFile pNtQueryInformationFile;
 extern sNtSetInformationFile pNtSetInformationFile;
+extern sNtQuerySystemInformation pNtQuerySystemInformation;
 
 
 /* Kernel32 function pointers */
 extern sGetQueuedCompletionStatusEx pGetQueuedCompletionStatusEx;
 extern sSetFileCompletionNotificationModes pSetFileCompletionNotificationModes;
 extern sCreateSymbolicLinkW pCreateSymbolicLinkW;
+extern sCancelIoEx pCancelIoEx;
 extern sInitializeSRWLock pInitializeSRWLock;
 extern sAcquireSRWLockShared pAcquireSRWLockShared;
 extern sAcquireSRWLockExclusive pAcquireSRWLockExclusive;

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

@@ -22,9 +22,9 @@
 #include <assert.h>
 
 #include "uv.h"
-#include "../uv-common.h"
 #include "internal.h"
 
+
 /* Whether ipv6 is supported */
 int uv_allow_ipv6;
 
@@ -468,3 +468,90 @@ int WSAAPI uv_wsarecvfrom_workaround(SOCKET socket, WSABUF* buffers,
     return SOCKET_ERROR;
   }
 }
+
+
+int WSAAPI uv_msafd_poll(SOCKET socket, AFD_POLL_INFO* info,
+    OVERLAPPED* overlapped) {
+  IO_STATUS_BLOCK iosb;
+  IO_STATUS_BLOCK* iosb_ptr;
+  HANDLE event = NULL;
+  void* apc_context;
+  NTSTATUS status;
+  DWORD error;
+
+  if (overlapped != NULL) {
+    /* Overlapped operation. */
+    iosb_ptr = (IO_STATUS_BLOCK*) &overlapped->Internal;
+    event = overlapped->hEvent;
+
+    /* Do not report iocp completion if hEvent is tagged. */
+    if ((uintptr_t) event & 1) {
+      event = (HANDLE)((uintptr_t) event & ~(uintptr_t) 1);
+      apc_context = NULL;
+    } else {
+      apc_context = overlapped;
+    }
+
+  } else {
+    /* Blocking operation. */
+    iosb_ptr = &iosb;
+    event = CreateEvent(NULL, FALSE, FALSE, NULL);
+    if (event == NULL) {
+      return SOCKET_ERROR;
+    }
+    apc_context = NULL;
+  }
+
+  iosb_ptr->Status = STATUS_PENDING;
+  status = pNtDeviceIoControlFile((HANDLE) socket,
+                                  event,
+                                  NULL,
+                                  apc_context,
+                                  iosb_ptr,
+                                  IOCTL_AFD_POLL,
+                                  info,
+                                  sizeof *info,
+                                  info,
+                                  sizeof *info);
+
+  if (overlapped == NULL) {
+    /* If this is a blocking operation, wait for the event to become */
+    /* signaled, and then grab the real status from the io status block. */
+    if (status == STATUS_PENDING) {
+      DWORD r = WaitForSingleObject(event, INFINITE);
+
+      if (r == WAIT_FAILED) {
+        DWORD saved_error = GetLastError();
+        CloseHandle(event);
+        WSASetLastError(saved_error);
+        return SOCKET_ERROR;
+      }
+
+      status = iosb.Status;
+    }
+
+    CloseHandle(event);
+  }
+
+  switch (status) {
+    case STATUS_SUCCESS:
+      error = ERROR_SUCCESS;
+      break;
+
+    case STATUS_PENDING:
+      error = WSA_IO_PENDING;
+      break;
+
+    default:
+      error = uv_ntstatus_to_winsock_error(status);
+      break;
+  }
+
+  WSASetLastError(error);
+
+  if (error == ERROR_SUCCESS) {
+    return 0;
+  } else {
+    return SOCKET_ERROR;
+  }
+}

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

@@ -43,11 +43,15 @@
 #endif
 
 #ifndef IPV6_V6ONLY
-  #define IPV6_V6ONLY 27
+# define IPV6_V6ONLY 27
 #endif
 
 #ifndef IPV6_HOPLIMIT
-  #define IPV6_HOPLIMIT 21
+# define IPV6_HOPLIMIT 21
+#endif
+
+#ifndef SIO_BASE_HANDLE
+# define SIO_BASE_HANDLE 0x48000022
 #endif
 
 /*
@@ -81,6 +85,32 @@
 #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;
@@ -105,6 +135,7 @@ typedef struct _AFD_RECV_INFO {
 
 #define AFD_RECEIVE            5
 #define AFD_RECEIVE_DATAGRAM   6
+#define AFD_POLL               9
 
 #define IOCTL_AFD_RECEIVE \
     _AFD_CONTROL_CODE(AFD_RECEIVE, METHOD_NEITHER)
@@ -112,8 +143,10 @@ typedef struct _AFD_RECV_INFO {
 #define IOCTL_AFD_RECEIVE_DATAGRAM \
     _AFD_CONTROL_CODE(AFD_RECEIVE_DATAGRAM, METHOD_NEITHER)
 
-#if defined(__MINGW32__) && !defined(__MINGW64__)
+#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 {

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

@@ -41,16 +41,16 @@ static int argument;
 static int64_t start_time;
 static int64_t end_time;
 
-/* callback method. may issue another call */
-static void aresbynamecallback( void *arg,
-                          int status,
-                          int timeouts,
-                          struct hostent *hostent) {
-    ares_callbacks++;
-    if (status != 0) {
-      ares_errors++;
-    }
 
+/* callback method. */
+static void aresbynamecallback(void *arg,
+                               int status,
+                               int timeouts,
+                               struct hostent *hostent) {
+  ares_callbacks++;
+  if (status != 0) {
+    ares_errors++;
+  }
 }
 
 
@@ -89,30 +89,29 @@ BENCHMARK_IMPL(gethostbyname) {
   ares_callbacks = 0;
   ares_errors = 0;
 
-  uv_update_time(loop);
-  start_time = uv_now(loop);
+  start_time = uv_hrtime();
 
   prep_tcploopback();
 
   for (ares_start = 0; ares_start < NUM_CALLS_TO_START; ares_start++) {
     ares_gethostbyname(channel,
-                      "echos.srv",
-                      AF_INET,
-                      &aresbynamecallback,
-                      &argument);
+                       "echos.srv",
+                       AF_INET,
+                       &aresbynamecallback,
+                       &argument);
   }
 
   uv_run(loop);
 
   uv_ares_destroy(loop, channel);
 
-  end_time = uv_now(loop);
+  end_time = uv_hrtime();
 
   if (ares_errors > 0) {
     printf("There were %d failures\n", ares_errors);
   }
   LOGF("ares_gethostbyname: %.0f req/s\n",
-      1000.0 * ares_callbacks / (double)(end_time - start_time));
+       1e9 * ares_callbacks / (double)(end_time - start_time));
 
   return 0;
 }

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

@@ -0,0 +1,164 @@
+/* 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 * 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 const char* fmt(double d) {
+  uint64_t v;
+  char* p;
+
+  p = (char *) calloc(1, 32) + 31; /* leaks memory */
+  v = d;
+
+#if 0 /* works but we don't care about fractional precision */
+  if (d - v >= 0.01) {
+    *--p = '0' + (uint64_t) (d * 100) % 10;
+    *--p = '0' + (uint64_t) (d * 10) % 10;
+    *--p = '.';
+  }
+#endif
+
+  if (v == 0)
+    *--p = '0';
+
+  while (v) {
+    if (v) *--p = '0' + (v % 10), v /= 10;
+    if (v) *--p = '0' + (v % 10), v /= 10;
+    if (v) *--p = '0' + (v % 10), v /= 10;
+    if (v) *--p = ',';
+  }
+
+  return p;
+}
+
+
+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;
+}