if (!uv_is_active((uv_handle_t*) &gc_timer)) {

uv_timer_start(&node::gc_timer, node::CheckStatus, 5., 5.);

}

if (uv_is_active((uv_handle_t*) &gc_timer)) {

uv_timer_stop(&gc_timer);

}

assert((uv_idle_t*) watcher == &gc_idle);

//fprintf(stderr, "idle\n");

if (V8::IdleNotification()) {

uv_idle_stop(&gc_idle);

StopGCTimer();

}

assert((uv_check_t*) watcher == &gc_check);

tick_times[tick_time_head] = uv_now();

tick_time_head = (tick_time_head + 1) % RPM_SAMPLES;

StartGCTimer();

for (int i = 0; i < (int)(GC_WAIT_TIME/FAST_TICK); i++) {

double d = TICK_TIME(i+1) - TICK_TIME(i+2);

//printf("d = %f\n", d);

// If in the last 5 ticks the difference between

// ticks was less than 0.7 seconds, then continue.

if (d < FAST_TICK) {

//printf("---\n");

return;

}

}

// Otherwise start the gc!

//fprintf(stderr, "start idle 2\n");

uv_idle_start(&node::gc_idle, node::Idle);

// Avoid entering a V8 scope.

if (!need_tick_cb) return;

need_tick_cb = false;

if (uv_is_active((uv_handle_t*) &tick_spinner)) {

uv_idle_stop(&tick_spinner);

uv_unref();

}

HandleScope scope;

if (tick_callback_sym.IsEmpty()) {

// Lazily set the symbol

tick_callback_sym =

Persistent<String>::New(String::NewSymbol("_tickCallback"));

}

Local<Value> cb_v = process->Get(tick_callback_sym);

if (!cb_v->IsFunction()) return;

Local<Function> cb = Local<Function>::Cast(cb_v);

TryCatch try_catch;

cb->Call(process, 0, NULL);

if (try_catch.HasCaught()) {

FatalException(try_catch);

}

assert((uv_idle_t*) handle == &tick_spinner);

assert(status == 0);

Tick();

HandleScope scope;

need_tick_cb = true;

// TODO: this tick_spinner shouldn't be necessary. An ev_prepare should be

// sufficent, the problem is only in the case of the very last "tick" -

// there is nothing left to do in the event loop and libev will exit. The

// ev_prepare callback isn't called before exiting. Thus we start this

// tick_spinner to keep the event loop alive long enough to handle it.

if (!uv_is_active((uv_handle_t*) &tick_spinner)) {

uv_idle_start(&tick_spinner, Spin);

uv_ref();

}

return Undefined();

assert((uv_prepare_t*) handle == &prepare_tick_watcher);

assert(status == 0);

Tick();

assert((uv_check_t*) handle == &check_tick_watcher);

assert(status == 0);

Tick();

assert((uv_idle_t*) watcher == &eio_poller);

//printf("eio_poller\n");

if (eio_poll() != -1 && uv_is_active((uv_handle_t*) &eio_poller)) {

//printf("eio_poller stop\n");

uv_idle_stop(&eio_poller);

uv_unref();

}

assert((uv_async_t*) watcher == &eio_want_poll_notifier);

//printf("want poll notifier\n");

if (eio_poll() == -1 && !uv_is_active((uv_handle_t*) &eio_poller)) {

//printf("eio_poller start\n");

uv_idle_start(&eio_poller, node::DoPoll);

uv_ref();

}

assert((uv_async_t*) watcher == &eio_done_poll_notifier);

//printf("done poll notifier\n");

if (eio_poll() != -1 && uv_is_active((uv_handle_t*) &eio_poller)) {

//printf("eio_poller stop\n");

uv_idle_stop(&eio_poller);

uv_unref();

}

// Signal the main thread that we should stop calling eio_poll().

// from the idle watcher.

uv_async_send(&eio_done_poll_notifier);