From 9cec08e49022c57efca252a74c778e18c11b80d3 Mon Sep 17 00:00:00 2001 From: Bert Belder Date: Tue, 24 May 2011 01:42:22 +0200 Subject: [PATCH] Batch of ev -> uv changes --- src/node.cc | 135 +++++++++++++++++++--------------------- src/node.h | 2 +- src/node_constants.cc | 5 +- src/node_file.cc | 4 +- src/node_script.h | 2 +- src/node_stdio_win32.cc | 43 +++++++------ 6 files changed, 91 insertions(+), 100 deletions(-) diff --git a/src/node.cc b/src/node.cc index 62765c2065..8e627703cd 100644 --- a/src/node.cc +++ b/src/node.cc @@ -27,6 +27,7 @@ #include #include +#include #include #include #include @@ -119,9 +120,9 @@ static uv_handle_t tick_spinner; static bool need_tick_cb; static Persistent tick_callback_sym; -static ev_async eio_want_poll_notifier; -static ev_async eio_done_poll_notifier; -static ev_idle eio_poller; +static uv_handle_t eio_want_poll_notifier; +static uv_handle_t eio_done_poll_notifier; +static uv_handle_t eio_poller; // Buffer for getpwnam_r(), getgrpam_r() and other misc callers; keep this // scoped at file-level rather than method-level to avoid excess stack usage. @@ -134,9 +135,9 @@ static char getbuf[PATH_MAX + 1]; // // A rather convoluted algorithm has been devised to determine when Node is // idle. You'll have to figure it out for yourself. -static ev_check gc_check; -static ev_idle gc_idle; -static ev_timer gc_timer; +static uv_handle_t gc_check; +static uv_handle_t gc_idle; +static uv_handle_t gc_timer; bool need_gc; @@ -144,42 +145,40 @@ bool need_gc; #define GC_WAIT_TIME 5. #define RPM_SAMPLES 100 #define TICK_TIME(n) tick_times[(tick_time_head - (n)) % RPM_SAMPLES] -static ev_tstamp tick_times[RPM_SAMPLES]; +static int64_t tick_times[RPM_SAMPLES]; static int tick_time_head; +static void CheckStatus(uv_handle_t* watcher, int status); + static void StartGCTimer () { - if (!ev_is_active(&gc_timer)) { - ev_timer_start(EV_DEFAULT_UC_ &gc_timer); - ev_unref(EV_DEFAULT_UC); + if (!uv_is_active(&gc_timer)) { + uv_timer_start(&node::gc_timer, node::CheckStatus, 5., 5.); } } static void StopGCTimer () { - if (ev_is_active(&gc_timer)) { - ev_ref(EV_DEFAULT_UC); - ev_timer_stop(EV_DEFAULT_UC_ &gc_timer); + if (uv_is_active(&gc_timer)) { + uv_timer_stop(&gc_timer); } } -static void Idle(EV_P_ ev_idle *watcher, int revents) { +static void Idle(uv_handle_t* watcher, int status) { assert(watcher == &gc_idle); - assert(revents == EV_IDLE); //fprintf(stderr, "idle\n"); if (V8::IdleNotification()) { - ev_idle_stop(EV_A_ watcher); + uv_idle_stop(watcher); StopGCTimer(); } } // Called directly after every call to select() (or epoll, or whatever) -static void Check(EV_P_ ev_check *watcher, int revents) { +static void Check(uv_handle_t* watcher, int status) { assert(watcher == &gc_check); - assert(revents == EV_CHECK); - tick_times[tick_time_head] = ev_now(EV_DEFAULT_UC); + tick_times[tick_time_head] = uv_now(); tick_time_head = (tick_time_head + 1) % RPM_SAMPLES; StartGCTimer(); @@ -198,7 +197,7 @@ static void Check(EV_P_ ev_check *watcher, int revents) { // Otherwise start the gc! //fprintf(stderr, "start idle 2\n"); - ev_idle_start(EV_A_ &gc_idle); + uv_idle_start(&node::gc_idle, node::Idle); } @@ -270,42 +269,42 @@ static void CheckTick(uv_handle_t* handle, int status) { } -static void DoPoll(EV_P_ ev_idle *watcher, int revents) { +static void DoPoll(uv_handle_t* watcher, int status) { assert(watcher == &eio_poller); - assert(revents == EV_IDLE); //printf("eio_poller\n"); - if (eio_poll() != -1) { + if (eio_poll() != -1 && uv_is_active(&eio_poller)) { //printf("eio_poller stop\n"); - ev_idle_stop(EV_DEFAULT_UC_ watcher); + uv_idle_stop(watcher); + uv_unref(); } } // Called from the main thread. -static void WantPollNotifier(EV_P_ ev_async *watcher, int revents) { +static void WantPollNotifier(uv_handle_t* watcher, int status) { assert(watcher == &eio_want_poll_notifier); - assert(revents == EV_ASYNC); //printf("want poll notifier\n"); - if (eio_poll() == -1) { + if (eio_poll() == -1 && !uv_is_active(&eio_poller)) { //printf("eio_poller start\n"); - ev_idle_start(EV_DEFAULT_UC_ &eio_poller); + uv_idle_start(&eio_poller, node::DoPoll); + uv_ref(); } } -static void DonePollNotifier(EV_P_ ev_async *watcher, int revents) { +static void DonePollNotifier(uv_handle_t* watcher, int revents) { assert(watcher == &eio_done_poll_notifier); - assert(revents == EV_ASYNC); //printf("done poll notifier\n"); - if (eio_poll() != -1) { + if (eio_poll() != -1 && uv_is_active(&eio_poller)) { //printf("eio_poller stop\n"); - ev_idle_stop(EV_DEFAULT_UC_ &eio_poller); + uv_idle_stop(&eio_poller); + uv_unref(); } } @@ -314,14 +313,14 @@ static void DonePollNotifier(EV_P_ ev_async *watcher, int revents) { // request (that is, one of the node.fs.* functions) has completed. static void EIOWantPoll(void) { // Signal the main thread that eio_poll need to be processed. - ev_async_send(EV_DEFAULT_UC_ &eio_want_poll_notifier); + uv_async_send(&eio_want_poll_notifier); } static void EIODonePoll(void) { // Signal the main thread that we should stop calling eio_poll(). // from the idle watcher. - ev_async_send(EV_DEFAULT_UC_ &eio_done_poll_notifier); + uv_async_send(&eio_done_poll_notifier); } @@ -1508,28 +1507,27 @@ v8::Handle Exit(const v8::Arguments& args) { } -static void CheckStatus(EV_P_ ev_timer *watcher, int revents) { +static void CheckStatus(uv_handle_t* watcher, int status) { assert(watcher == &gc_timer); - assert(revents == EV_TIMEOUT); // check memory - if (!ev_is_active(&gc_idle)) { + if (!uv_is_active(&gc_idle)) { HeapStatistics stats; V8::GetHeapStatistics(&stats); if (stats.total_heap_size() > 1024 * 1024 * 128) { // larger than 128 megs, just start the idle watcher - ev_idle_start(EV_A_ &gc_idle); + uv_idle_start(&node::gc_idle, node::Idle); return; } } - double d = ev_now(EV_DEFAULT_UC) - TICK_TIME(3); + double d = uv_now() - TICK_TIME(3); //printfb("timer d = %f\n", d); if (d >= GC_WAIT_TIME - 1.) { //fprintf(stderr, "start idle\n"); - ev_idle_start(EV_A_ &gc_idle); + uv_idle_start(&node::gc_idle, node::Idle); } } @@ -1784,12 +1782,11 @@ void FatalException(TryCatch &try_catch) { } -static ev_async debug_watcher; +static uv_handle_t debug_watcher; -static void DebugMessageCallback(EV_P_ ev_async *watcher, int revents) { +static void DebugMessageCallback(uv_handle_t* watcher, int status) { HandleScope scope; assert(watcher == &debug_watcher); - assert(revents == EV_ASYNC); Debug::ProcessDebugMessages(); } @@ -1799,7 +1796,7 @@ static void DebugMessageDispatch(void) { // Send a signal to our main thread saying that it should enter V8 to // handle the message. - ev_async_send(EV_DEFAULT_UC_ &debug_watcher); + uv_async_send(&debug_watcher); } static void DebugBreakMessageHandler(const Debug::Message& message) { @@ -1989,8 +1986,8 @@ Handle SetupProcessObject(int argc, char *argv[]) { versions->Set(String::NewSymbol("node"), String::New(NODE_VERSION+1)); versions->Set(String::NewSymbol("v8"), String::New(V8::GetVersion())); versions->Set(String::NewSymbol("ares"), String::New(ARES_VERSION_STR)); - snprintf(buf, 20, "%d.%d", ev_version_major(), ev_version_minor()); - versions->Set(String::NewSymbol("ev"), String::New(buf)); + snprintf(buf, 20, "%d.%d", UV_VERSION_MAJOR, UV_VERSION_MINOR); + versions->Set(String::NewSymbol("uv"), String::New(buf)); #ifdef HAVE_OPENSSL // Stupid code to slice out the version string. int c, l = strlen(OPENSSL_VERSION_TEXT); @@ -2365,28 +2362,26 @@ char** Init(int argc, char *argv[]) { uv_idle_init(&node::tick_spinner, NULL, NULL); uv_unref(); - ev_check_init(&node::gc_check, node::Check); - ev_check_start(EV_DEFAULT_UC_ &node::gc_check); - ev_unref(EV_DEFAULT_UC); + uv_check_init(&node::gc_check, NULL, NULL); + uv_check_start(&node::gc_check, node::Check); + uv_unref(); - ev_idle_init(&node::gc_idle, node::Idle); - ev_timer_init(&node::gc_timer, node::CheckStatus, 5., 5.); + uv_idle_init(&node::gc_idle, NULL, NULL); + uv_unref(); + uv_timer_init(&node::gc_timer, NULL, NULL); + uv_unref(); // Setup the EIO thread pool. It requires 3, yes 3, watchers. { - ev_idle_init(&node::eio_poller, node::DoPoll); - // TODO Probably don't need to start this each time. - // Avoids failing on test/simple/test-eio-race3.js though - ev_idle_start(EV_DEFAULT_UC_ &eio_poller); + uv_idle_init(&node::eio_poller, NULL, NULL); + uv_idle_start(&eio_poller, node::DoPoll); - ev_async_init(&node::eio_want_poll_notifier, node::WantPollNotifier); - ev_async_start(EV_DEFAULT_UC_ &node::eio_want_poll_notifier); - ev_unref(EV_DEFAULT_UC); + uv_async_init(&node::eio_want_poll_notifier, node::WantPollNotifier, NULL, NULL); + uv_unref(); - ev_async_init(&node::eio_done_poll_notifier, node::DonePollNotifier); - ev_async_start(EV_DEFAULT_UC_ &node::eio_done_poll_notifier); - ev_unref(EV_DEFAULT_UC); + uv_async_init(&node::eio_done_poll_notifier, node::DonePollNotifier, NULL, NULL); + uv_unref(); eio_init(node::EIOWantPoll, node::EIODonePoll); // Don't handle more than 10 reqs on each eio_poll(). This is to avoid @@ -2397,20 +2392,16 @@ char** Init(int argc, char *argv[]) { V8::SetFatalErrorHandler(node::OnFatalError); - // Initialize the async watcher for receiving messages from the debug - // thread and marshal it into the main thread. DebugMessageCallback() - // is called from the main thread to execute a random bit of javascript - // - which will give V8 control so it can handle whatever new message - // had been received on the debug thread. - ev_async_init(&node::debug_watcher, node::DebugMessageCallback); - ev_set_priority(&node::debug_watcher, EV_MAXPRI); // Set the callback DebugMessageDispatch which is called from the debug // thread. Debug::SetDebugMessageDispatchHandler(node::DebugMessageDispatch); - // Start the async watcher. - ev_async_start(EV_DEFAULT_UC_ &node::debug_watcher); + // Initialize the async watcher. DebugMessageCallback() is called from the + // main thread to execute a random bit of javascript - which will give V8 + // control so it can handle whatever new message had been received on the + // debug thread. + uv_async_init(&node::debug_watcher, node::DebugMessageCallback, NULL, NULL); // unref it so that we exit the event loop despite it being active. - ev_unref(EV_DEFAULT_UC); + uv_unref(); // If the --debug flag was specified then initialize the debug thread. @@ -2470,7 +2461,7 @@ int Start(int argc, char *argv[]) { // All our arguments are loaded. We've evaluated all of the scripts. We // might even have created TCP servers. Now we enter the main eventloop. If // there are no watchers on the loop (except for the ones that were - // ev_unref'd) then this function exits. As long as there are active + // uv_unref'd) then this function exits. As long as there are active // watchers, it blocks. uv_run(); diff --git a/src/node.h b/src/node.h index 74ca77fcd6..e444f00044 100644 --- a/src/node.h +++ b/src/node.h @@ -22,7 +22,7 @@ #ifndef SRC_NODE_H_ #define SRC_NODE_H_ -#include +#include #include #include #include /* struct stat */ diff --git a/src/node_constants.cc b/src/node_constants.cc index 1d14fcc60b..bdc2c3f333 100644 --- a/src/node_constants.cc +++ b/src/node_constants.cc @@ -21,7 +21,7 @@ #include -#include +#include #include #include @@ -44,9 +44,6 @@ namespace node { using namespace v8; void DefineConstants(Handle target) { - NODE_DEFINE_CONSTANT(target, EV_MINPRI); - NODE_DEFINE_CONSTANT(target, EV_MAXPRI); - // file access modes NODE_DEFINE_CONSTANT(target, O_RDONLY); NODE_DEFINE_CONSTANT(target, O_WRONLY); diff --git a/src/node_file.cc b/src/node_file.cc index 5103691bb7..39e49178d2 100644 --- a/src/node_file.cc +++ b/src/node_file.cc @@ -88,7 +88,7 @@ static int After(eio_req *req) { Persistent *callback = cb_unwrap(req->data); - ev_unref(EV_DEFAULT_UC); + uv_unref(); // there is always at least one argument. "error" int argc = 1; @@ -213,7 +213,7 @@ static int After(eio_req *req) { eio_req *req = eio_##func(__VA_ARGS__, EIO_PRI_DEFAULT, After, \ cb_persist(callback)); \ assert(req); \ - ev_ref(EV_DEFAULT_UC); \ + uv_ref(); \ return Undefined(); static Handle Close(const Arguments& args) { diff --git a/src/node_script.h b/src/node_script.h index 78ebc8e463..5074abf2d3 100644 --- a/src/node_script.h +++ b/src/node_script.h @@ -25,7 +25,7 @@ #include #include #include -#include +#include namespace node { diff --git a/src/node_stdio_win32.cc b/src/node_stdio_win32.cc index 76661de1a1..94de715cfc 100644 --- a/src/node_stdio_win32.cc +++ b/src/node_stdio_win32.cc @@ -415,18 +415,19 @@ static Handle ClearLine(const Arguments& args) { /* TTY watcher data */ -bool tty_watcher_initialized = false; HANDLE tty_handle; HANDLE tty_wait_handle; void *tty_error_callback; void *tty_keypress_callback; void *tty_resize_callback; -static ev_async tty_avail_notifier; +static bool tty_watcher_initialized = false; +static bool tty_watcher_active = false; +static uv_handle_t tty_avail_notifier; static void CALLBACK tty_want_poll(void *context, BOOLEAN didTimeout) { assert(!didTimeout); - ev_async_send(EV_DEFAULT_UC_ &tty_avail_notifier); + uv_async_send(&tty_avail_notifier); } @@ -437,12 +438,13 @@ static void tty_watcher_arm() { // but apparently this does not apply to wait threads. Sigh. HANDLE old_wait_handle = tty_wait_handle; - tty_wait_handle = NULL; + tty_wait_handle = NULL; + + assert(tty_watcher_active); - if (ev_is_active(&tty_avail_notifier)) { - if (!RegisterWaitForSingleObject(&tty_wait_handle, tty_handle, tty_want_poll, NULL, - INFINITE, WT_EXECUTEINWAITTHREAD | WT_EXECUTEONLYONCE)) - ThrowException(ErrnoException(GetLastError(), "RegisterWaitForSingleObject")); + if (!RegisterWaitForSingleObject(&tty_wait_handle, tty_handle, tty_want_poll, NULL, + INFINITE, WT_EXECUTEINWAITTHREAD | WT_EXECUTEONLYONCE)) { + ThrowException(ErrnoException(GetLastError(), "RegisterWaitForSingleObject")); } if (old_wait_handle != NULL) { @@ -463,18 +465,19 @@ static void tty_watcher_disarm() { } -static void tty_watcher_start() { - if (!ev_is_active(&tty_avail_notifier)) { - ev_async_start(EV_DEFAULT_UC_ &tty_avail_notifier); +static void tty_watcher_start() { + assert(tty_watcher_initialized); + if (!tty_watcher_active) { + tty_watcher_active = true; tty_watcher_arm(); } } static void tty_watcher_stop() { - if (ev_is_active(&tty_avail_notifier)) { + if (tty_watcher_active) { + tty_watcher_active = false; tty_watcher_disarm(); - ev_async_stop(EV_DEFAULT_UC_ &tty_avail_notifier); } } @@ -488,9 +491,9 @@ static inline void tty_emit_error(Handle err) { } -static void tty_poll(EV_P_ ev_async *watcher, int revents) { - assert(watcher == &tty_avail_notifier); - assert(revents == EV_ASYNC); +static void tty_poll(uv_handle_t* handle, int status) { + assert(handle == &tty_avail_notifier); + assert(status == 0); HandleScope scope; TryCatch try_catch; @@ -509,8 +512,8 @@ static void tty_poll(EV_P_ ev_async *watcher, int revents) { numev = 0; } - for (i = numev; i > 0 && - ev_is_active(EV_DEFAULT_UC_ &tty_avail_notifier); i--) { + for (i = numev; i > 0 && + tty_watcher_active; i--) { if (!ReadConsoleInputW(tty_handle, &input, 1, &read)) { tty_emit_error(ErrnoException(GetLastError(), "ReadConsoleInputW")); break; @@ -561,7 +564,7 @@ static void tty_poll(EV_P_ ev_async *watcher, int revents) { j = k.wRepeatCount; do { (*callback)->Call(global, 2, argv); - } while (--j > 0 && ev_is_active(EV_DEFAULT_UC_ &tty_avail_notifier)); + } while (--j > 0 && tty_watcher_active); break; case WINDOW_BUFFER_SIZE_EVENT: @@ -606,7 +609,7 @@ static Handle InitTTYWatcher(const Arguments& args) { ? cb_persist(args[3]) : NULL; - ev_async_init(EV_DEFAULT_UC_ &tty_avail_notifier, tty_poll); + uv_async_init(&tty_avail_notifier, tty_poll, NULL, NULL); tty_watcher_initialized = true; tty_wait_handle = NULL;