noderb 0.0.4 → 0.0.6

data/ext/noderb_extension/libuv/src/win/threadpool.c

@@ -0,0 +1,73 @@
+/* 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 <assert.h>
+
+#include "uv.h"
+#include "internal.h"
+
+
+static void uv_work_req_init(uv_loop_t* loop, uv_work_t* req,
+    uv_work_cb work_cb, uv_after_work_cb after_work_cb) {
+  uv_req_init(loop, (uv_req_t*) req);
+  req->type = UV_WORK;
+  req->loop = loop;
+  req->work_cb = work_cb;
+  req->after_work_cb = after_work_cb;
+  memset(&req->overlapped, 0, sizeof(req->overlapped));
+}
+
+
+static DWORD WINAPI uv_work_thread_proc(void* parameter) {
+  uv_work_t* req = (uv_work_t*)parameter;
+  uv_loop_t* loop = req->loop;
+
+  assert(req != NULL);
+  assert(req->type == UV_WORK);
+  assert(req->work_cb);
+
+  req->work_cb(req);
+
+  POST_COMPLETION_FOR_REQ(loop, req);
+
+  return 0;
+}
+
+
+int uv_queue_work(uv_loop_t* loop, uv_work_t* req, uv_work_cb work_cb,
+    uv_after_work_cb after_work_cb) {
+  uv_work_req_init(loop, req, work_cb, after_work_cb);
+
+  if (!QueueUserWorkItem(&uv_work_thread_proc, req, WT_EXECUTELONGFUNCTION)) {
+    uv_set_sys_error(loop, GetLastError());
+    return -1;
+  }
+
+  uv_ref(loop);
+  return 0;
+}
+
+
+void uv_process_work_req(uv_loop_t* loop, uv_work_t* req) {
+  assert(req->after_work_cb);
+  req->after_work_cb(req);
+  uv_unref(loop);
+}

data/ext/noderb_extension/libuv/src/win/timer.c

@@ -36,12 +36,12 @@ static uint64_t uv_hrtime_frequency_ = 0;
 static char uv_hrtime_initialized_ = 0;
 
 
-void uv_update_time() {
+void uv_update_time(uv_loop_t* loop) {
   DWORD ticks = GetTickCount();
 
   /* The assumption is made that LARGE_INTEGER.QuadPart has the same type */
-  /* LOOP->time, which happens to be. Is there any way to assert this? */
-  LARGE_INTEGER* time = (LARGE_INTEGER*) &LOOP->time;
+  /* loop->time, which happens to be. Is there any way to assert this? */
+  LARGE_INTEGER* time = (LARGE_INTEGER*) &loop->time;
 
   /* If the timer has wrapped, add 1 to it's high-order dword. */
   /* uv_poll must make sure that the timer can never overflow more than */
@@ -53,11 +53,11 @@ void uv_update_time() {
 }
 
 
-int64_t uv_now() {
-  return LOOP->time;
+int64_t uv_now(uv_loop_t* loop) {
+  return loop->time;
 }
 
-
+/* TODO: thread safety */
 uint64_t uv_hrtime(void) {
   LARGE_INTEGER counter;
 
@@ -68,7 +68,7 @@ uint64_t uv_hrtime(void) {
 
     if (!QueryPerformanceFrequency(&counter)) {
       uv_hrtime_frequency_ = 0;
-      uv_set_sys_error(GetLastError());
+      /* uv_set_sys_error(loop, GetLastError()); */
       return 0;
     }
 
@@ -77,12 +77,12 @@ uint64_t uv_hrtime(void) {
 
   /* If the performance frequency is zero, there's no support. */
   if (!uv_hrtime_frequency_) {
-    uv_set_sys_error(ERROR_NOT_SUPPORTED);
+    /* uv_set_sys_error(loop, ERROR_NOT_SUPPORTED); */
     return 0;
   }
 
   if (!QueryPerformanceCounter(&counter)) {
-    uv_set_sys_error(GetLastError());
+    /* uv_set_sys_error(loop, GetLastError()); */
     return 0;
   }
 
@@ -111,23 +111,23 @@ static int uv_timer_compare(uv_timer_t* a, uv_timer_t* b) {
 RB_GENERATE_STATIC(uv_timer_tree_s, uv_timer_s, tree_entry, uv_timer_compare);
 
 
-int uv_timer_init(uv_timer_t* handle) {
-  uv_counters()->handle_init++;
-  uv_counters()->timer_init++;
+int uv_timer_init(uv_loop_t* loop, uv_timer_t* handle) {
+  loop->counters.handle_init++;
+  loop->counters.timer_init++;
 
   handle->type = UV_TIMER;
+  handle->loop = loop;
   handle->flags = 0;
-  handle->error = uv_ok_;
   handle->timer_cb = NULL;
   handle->repeat = 0;
 
-  uv_ref();
+  uv_ref(loop);
 
   return 0;
 }
 
 
-void uv_timer_endgame(uv_timer_t* handle) {
+void uv_timer_endgame(uv_loop_t* loop, uv_timer_t* handle) {
   if (handle->flags & UV_HANDLE_CLOSING) {
     assert(!(handle->flags & UV_HANDLE_CLOSED));
     handle->flags |= UV_HANDLE_CLOSED;
@@ -136,22 +136,25 @@ void uv_timer_endgame(uv_timer_t* handle) {
       handle->close_cb((uv_handle_t*)handle);
     }
 
-    uv_unref();
+    uv_unref(loop);
   }
 }
 
 
-int uv_timer_start(uv_timer_t* handle, uv_timer_cb timer_cb, int64_t timeout, int64_t repeat) {
+int uv_timer_start(uv_timer_t* handle, uv_timer_cb timer_cb, int64_t timeout,
+    int64_t repeat) {
+  uv_loop_t* loop = handle->loop;
+
   if (handle->flags & UV_HANDLE_ACTIVE) {
-    RB_REMOVE(uv_timer_tree_s, &LOOP->timers, handle);
+    RB_REMOVE(uv_timer_tree_s, &loop->timers, handle);
   }
 
   handle->timer_cb = timer_cb;
-  handle->due = LOOP->time + timeout;
+  handle->due = loop->time + timeout;
   handle->repeat = repeat;
   handle->flags |= UV_HANDLE_ACTIVE;
 
-  if (RB_INSERT(uv_timer_tree_s, &LOOP->timers, handle) != NULL) {
+  if (RB_INSERT(uv_timer_tree_s, &loop->timers, handle) != NULL) {
     uv_fatal_error(ERROR_INVALID_DATA, "RB_INSERT");
   }
 
@@ -160,10 +163,12 @@ int uv_timer_start(uv_timer_t* handle, uv_timer_cb timer_cb, int64_t timeout, in
 
 
 int uv_timer_stop(uv_timer_t* handle) {
+  uv_loop_t* loop = handle->loop;
+
   if (!(handle->flags & UV_HANDLE_ACTIVE))
     return 0;
 
-  RB_REMOVE(uv_timer_tree_s, &LOOP->timers, handle);
+  RB_REMOVE(uv_timer_tree_s, &loop->timers, handle);
 
   handle->flags &= ~UV_HANDLE_ACTIVE;
 
@@ -172,21 +177,23 @@ int uv_timer_stop(uv_timer_t* handle) {
 
 
 int uv_timer_again(uv_timer_t* handle) {
+  uv_loop_t* loop = handle->loop;
+
   /* If timer_cb is NULL that means that the timer was never started. */
   if (!handle->timer_cb) {
-    uv_set_sys_error(ERROR_INVALID_DATA);
+    uv_set_sys_error(loop, ERROR_INVALID_DATA);
     return -1;
   }
 
   if (handle->flags & UV_HANDLE_ACTIVE) {
-    RB_REMOVE(uv_timer_tree_s, &LOOP->timers, handle);
+    RB_REMOVE(uv_timer_tree_s, &loop->timers, handle);
     handle->flags &= ~UV_HANDLE_ACTIVE;
   }
 
   if (handle->repeat) {
-    handle->due = LOOP->time + handle->repeat;
+    handle->due = loop->time + handle->repeat;
 
-    if (RB_INSERT(uv_timer_tree_s, &LOOP->timers, handle) != NULL) {
+    if (RB_INSERT(uv_timer_tree_s, &loop->timers, handle) != NULL) {
       uv_fatal_error(ERROR_INVALID_DATA, "RB_INSERT");
     }
 
@@ -209,16 +216,16 @@ int64_t uv_timer_get_repeat(uv_timer_t* handle) {
 }
 
 
-DWORD uv_get_poll_timeout() {
+DWORD uv_get_poll_timeout(uv_loop_t* loop) {
   uv_timer_t* timer;
   int64_t delta;
 
   /* Check if there are any running timers */
-  timer = RB_MIN(uv_timer_tree_s, &LOOP->timers);
+  timer = RB_MIN(uv_timer_tree_s, &loop->timers);
   if (timer) {
-    uv_update_time();
+    uv_update_time(loop);
 
-    delta = timer->due - LOOP->time;
+    delta = timer->due - loop->time;
     if (delta >= UINT_MAX >> 1) {
       /* A timeout value of UINT_MAX means infinite, so that's no good. But */
       /* more importantly, there's always the risk that GetTickCount wraps. */
@@ -241,22 +248,22 @@ DWORD uv_get_poll_timeout() {
 }
 
 
-void uv_process_timers() {
+void uv_process_timers(uv_loop_t* loop) {
   uv_timer_t* timer;
 
   /* Call timer callbacks */
-  for (timer = RB_MIN(uv_timer_tree_s, &LOOP->timers);
-       timer != NULL && timer->due <= LOOP->time;
-       timer = RB_MIN(uv_timer_tree_s, &LOOP->timers)) {
-    RB_REMOVE(uv_timer_tree_s, &LOOP->timers, timer);
+  for (timer = RB_MIN(uv_timer_tree_s, &loop->timers);
+       timer != NULL && timer->due <= loop->time;
+       timer = RB_MIN(uv_timer_tree_s, &loop->timers)) {
+    RB_REMOVE(uv_timer_tree_s, &loop->timers, timer);
 
     if (timer->repeat != 0) {
       /* If it is a repeating timer, reschedule with repeat timeout. */
       timer->due += timer->repeat;
-      if (timer->due < LOOP->time) {
-        timer->due = LOOP->time;
+      if (timer->due < loop->time) {
+        timer->due = loop->time;
       }
-      if (RB_INSERT(uv_timer_tree_s, &LOOP->timers, timer) != NULL) {
+      if (RB_INSERT(uv_timer_tree_s, &loop->timers, timer) != NULL) {
         uv_fatal_error(ERROR_INVALID_DATA, "RB_INSERT");
       }
     } else {