static void(loop_stop)() { uv_stop(loop); uv_idle_t* idle = s_malloc0(sizeof(*idle)); uv_idle_init(loop, idle); uv_idle_start(idle, loop_stop_cb); }
void rstream_set_file(RStream *rstream, uv_file file) { rstream->file_type = uv_guess_handle(file); if (rstream->free_handle) { // If this is the second time we're calling this function, free the // previously allocated memory if (rstream->fread_idle != NULL) { uv_close((uv_handle_t *)rstream->fread_idle, close_cb); } else { uv_close((uv_handle_t *)rstream->stream, close_cb); } } if (rstream->file_type == UV_FILE) { // Non-blocking file reads are simulated with a idle handle that reads // in chunks of rstream->buffer_size, giving time for other events to // be processed between reads. rstream->fread_idle = xmalloc(sizeof(uv_idle_t)); uv_idle_init(uv_default_loop(), rstream->fread_idle); rstream->fread_idle->data = rstream; } else { // Only pipes are supported for now assert(rstream->file_type == UV_NAMED_PIPE || rstream->file_type == UV_TTY); rstream->stream = xmalloc(sizeof(uv_pipe_t)); uv_pipe_init(uv_default_loop(), (uv_pipe_t *)rstream->stream, 0); uv_pipe_open((uv_pipe_t *)rstream->stream, file); rstream->stream->data = rstream; } rstream->fd = file; rstream->free_handle = true; }
static void idle_1_cb(uv_handle_t* handle, int status) { int r; LOG("IDLE_1_CB\n"); ASSERT(handle != NULL); ASSERT(status == 0); ASSERT(idles_1_active > 0); /* Init idle_2 and make it active */ if (!idle_2_is_active) { r = uv_idle_init(&idle_2_handle, idle_2_close_cb, NULL); ASSERT(r == 0); r = uv_idle_start(&idle_2_handle, idle_2_cb); ASSERT(r == 0); idle_2_is_active = 1; idle_2_cb_started++; } idle_1_cb_called++; if (idle_1_cb_called % 5 == 0) { r = uv_idle_stop((uv_idle_t*)handle); ASSERT(r == 0); idles_1_active--; } }
uv_idle_t idleHandler(uv_loop_t* loop) { uv_idle_t handler; uv_idle_init(loop, &handler); int* p = 0; handler.data = &p; return handler; }
static void next_tick(uv_idle_t* handle, int status) { uv_loop_t* loop = handle->loop; uv_idle_stop(handle); uv_idle_init(loop, &idle_handle); uv_idle_start(&idle_handle, idle_cb); uv_timer_init(loop, &timer_handle); uv_timer_start(&timer_handle, timer_cb, 0, 0); }
rust_uvtmp_thread() { task = rust_scheduler::get_task(); stop_flag = false; loop = uv_loop_new(); uv_idle_init(loop, &idle); idle.data = this; uv_idle_start(&idle, idle_cb); }
void run_UVloop(void *arg) { uv_idle_t idler; uv_idle_init(UV_loop,&idler); //uv_async_init(UV_loop,&Tasks_async,async_handler); uv_idle_start(&idler,SuperNET_idler); uv_run(UV_loop,UV_RUN_DEFAULT); printf("end of uv_run\n"); }
static void enter_loop(MVMThreadContext *tc, MVMCallsite *callsite, MVMRegister *args) { uv_idle_t idle; if (uv_idle_init(tc->loop, &idle) != 0) MVM_panic(1, "Unable to initialize idle worker for event loop"); idle.data = tc; if (uv_idle_start(&idle, idle_handler) != 0) MVM_panic(1, "Unable to start idle worker for event loop"); uv_run(tc->loop, UV_RUN_DEFAULT); MVM_panic(1, "Supposedly unending event loop thread ended"); }
static int luv_new_idle(lua_State* L) { uv_idle_t* handle = (uv_idle_t*)luv_newuserdata(L, sizeof(*handle)); int ret = uv_idle_init(luv_loop(L), handle); if (ret < 0) { lua_pop(L, 1); return luv_error(L, ret); } handle->data = luv_setup_handle(L); return 1; }
/** @internal Schedule deferred continuation. */ static int l_ffi_defer(lua_State *L) { uv_idle_t *check = malloc(sizeof(*check)); if (!check) { return kr_error(ENOMEM); } uv_idle_init(uv_default_loop(), check); check->data = L; return uv_idle_start(check, l_ffi_resume_cb); }
static void HHVM_METHOD(UVIdle, __construct, const Variant &v_loop) { auto* data = Native::data<UVNativeData>(this_); data->resource_handle = (void *) new uv_idle_ext_t(); uv_idle_ext_t *idle_handle = fetchResource(data); idle_handle->start = false; idle_handle->idle_object_data = NULL; if(v_loop.isNull()){ uv_idle_init(uv_default_loop(), idle_handle); return; } Object loop = v_loop.toObject(); checkUVLoopInstance(loop, 1, s_uvidle, StaticString("__construct")); auto* loop_data = Native::data<UVLoopData>(loop.get()); SET_LOOP(this_, loop, s_uvidle); uv_idle_init(loop_data->loop, idle_handle); }
std::shared_ptr<Idle> Idle::Create(Loop& loop) { auto h = std::make_shared<Idle>(private_init{}); int err = uv_idle_init(loop.GetRaw(), h->GetRaw()); if (err < 0) { loop.ReportError(err); return nullptr; } h->Keep(); return h; }
int main() { uv_idle_t idler; uv_idle_init(uv_default_loop(), &idler); uv_idle_start(&idler, wait_for_a_while); printf("Idling...\n"); uv_run(uv_default_loop(), UV_RUN_DEFAULT); return 0; }
// idle-watcher callbacks are low priority, as they are only invoked for each iteration when the event loop has no other pending events int main() { int r; loop = uv_default_loop(); r = uv_idle_init(loop, &idler); if (r) ERROR("initing idler", r); wait_for_next_input(); return uv_run(loop, UV_RUN_DEFAULT); }
DLLEXPORT uv_idle_t *jl_idle_init(uv_loop_t *loop, jl_value_t *julia_struct) { if (!loop) return 0; uv_idle_t *idle = malloc(sizeof(uv_idle_t)); if (uv_idle_init(loop,idle)) { free(idle); return 0; } idle->data = julia_struct; return idle; }
int main(int argc, char **argv) { uv_idle_t idler; uv_idle_init(uv_default_loop(), &idler); uv_idle_start(&idler, waitForAWhile); printf(".. idling..."); uv_run(uv_default_loop(), UV_RUN_DEFAULT); uv_loop_close(uv_default_loop()); return 0; }
int main() { uv_idle_t idler; uv_idle_init(get_loop(), &idler); uv_idle_start(&idler, wait_for_a_while); printf("Now quitting.\n"); uv_run(get_loop(), UV_RUN_DEFAULT); return 0; }
int main(int argc, char **argv) { cg_onscreen_t *onscreen; cg_error_t *error = NULL; struct demo demo; float fovy, aspect, z_near, z_2d, z_far; uv_loop_t *loop = uv_default_loop(); demo.dev = cg_device_new (); if (!demo.dev || error != NULL) c_error("Failed to create Cogl context\n"); onscreen = cg_onscreen_new(demo.dev, WIDTH, HEIGHT); demo.fb = onscreen; demo.width = cg_framebuffer_get_width(demo.fb); demo.height = cg_framebuffer_get_height(demo.fb); cg_onscreen_show(onscreen); cg_framebuffer_set_viewport(demo.fb, 0, 0, demo.width, demo.height); fovy = 45; aspect = (float)demo.width / (float)demo.height; z_near = 0.1; z_2d = 1000; z_far = 2000; cg_framebuffer_perspective(demo.fb, fovy, aspect, z_near, z_far); c_matrix_init_identity(&demo.view); c_matrix_view_2d_in_perspective(&demo.view, fovy, aspect, z_near, z_2d, demo.width, demo.height); cg_framebuffer_set_modelview_matrix(demo.fb, &demo.view); demo.swap_ready = true; cg_onscreen_add_frame_callback(demo.fb, frame_event_cb, &demo, NULL); init_particle_emitters(&demo); demo.timer = c_timer_new(); demo.spin_rate = 0; demo.angle_between_emitters = 2 * M_PI / C_N_ELEMENTS(demo.emitter); uv_idle_init(loop, &demo.idle); demo.idle.data = &demo; uv_idle_start(&demo.idle, paint_cb); cg_uv_set_mainloop(demo.dev, loop); uv_run(loop, UV_RUN_DEFAULT); return 0; }
unsigned int lcbuv_close_socket(lcb_io_opt_t iobase, lcb_sockdata_t *sockbase) { dCOMMON_VARS(iobase, sockbase) uv_idle_t *idle = calloc(1, sizeof(*idle)); assert(sock->lcb_close_called == 0); sock->lcb_close_called = 1; idle->data = sock; uv_idle_init(io->loop, idle); uv_idle_start(idle, socket_closing_cb); (void)io; return 0; }
static void run(void) { uv_idle_t runner; uv_idle_init(uv_default_loop(), &runner); uv_idle_start(&runner, do_run); uv_run(uv_default_loop(), UV_RUN_DEFAULT); uv_loop_close(uv_default_loop()); log_info(LOG, "Client stopped."); automaton->free(automaton); ch->free(ch); cgi_channel->free(cgi_channel); mh->free(mh); zmq_channel->free(zmq_channel); }
int main(int argc, char* argv[]) { uv_idle_t idle; uv_loop_t* loop = uv_default_loop(); uv_idle_init(loop, &idle); uv_idle_start(&idle, idle_routine); fprintf(stdout, "[%lu]Idling begin ...\n", clock()); uv_run(loop, UV_RUN_DEFAULT); fprintf(stdout, "[%lu]Idling finish ...\n", clock()); return 0; }
static unsigned int close_socket(lcb_io_opt_t iobase, lcb_sockdata_t *sockbase) { my_sockdata_t *sock = (my_sockdata_t *)sockbase; my_iops_t *io = (my_iops_t *)iobase; uv_idle_t *idle = calloc(1, sizeof(*idle)); lcb_assert(sock->lcb_close_called == 0); sock->lcb_close_called = 1; idle->data = sock; uv_idle_init(io->loop, idle); uv_idle_start(idle, socket_closing_cb); return 0; }
int main() { uv_idle_t idler; LOG = circus_new_log_file_descriptor(stdlib_memory, LOG_INFO, 1); uv_idle_init(uv_default_loop(), &idler); uv_idle_start(&idler, wait_for_a_while); LOG->set_format(LOG, "[%T] %O:%G\n"); uv_run(uv_default_loop(), UV_RUN_DEFAULT); uv_loop_close(uv_default_loop()); LOG->free(LOG); return 0; }
int main() { /* our reference to the default loop */ uv_loop_t *loop; /* a idler of uv_idle_t struct type */ uv_idle_t idler; /* let uv return the default loop */ loop = uv_default_loop(); /* initialize a idle handle with the default loop and the reference of our idle type */ uv_idle_init(loop, &idler); /* start executing the idle handler and call the wait_for_a_while callback */ uv_idle_start(&idler, wait_for_a_while); printf("Idling ...\n"); /* start runing the loop in default mode */ uv_run(loop, UV_RUN_DEFAULT); }
static void send_error(lcb_io_opt_t iobase, lcb_sockdata_t *sockbase, lcb_io_error_cb callback) { my_sockdata_t *sock = (my_sockdata_t *)sockbase; my_iops_t *io = (my_iops_t *)iobase; my_uvreq_t *uvr; if (!sock) { return; } uvr = alloc_uvreq(sock, (generic_callback_t)callback); if (!uvr) { return; } uv_idle_init(io->loop, &uvr->uvreq.idle); uv_idle_start(&uvr->uvreq.idle, err_idle_cb); incref_sock(sock); }
int sg_etp_session_start(sg_etp_session_t * session, int interval_ms, uv_udp_t * udp) { int ret = ERROR; SG_ASSERT_RET(NULL != session, "session pointer is NULL", ret); session->interval = interval_ms; if (NULL == udp) /* self-contained udp, for client */ { /* init udp */ session->udp = &(session->udp_hdl); ret = uv_udp_init(session->loop, session->udp); SG_ASSERT_RET(ret >= 0, "init udp failed", ERROR); session->udp->data = session; ret = uv_udp_recv_start(session->udp, on_uv_alloc_buffer, on_client_recv_udp); SG_ASSERT_RET(ret >= 0, "start udp recv failed", ERROR); } else { session->udp = udp; } ret = ikcp_nodelay(session->kcp, 1, interval_ms, 2, 0); SG_ASSERT_RET(ret >= 0, "ikcp nodelay failed", ERROR); /* start a timer for kcp update and receiving */ ret = uv_timer_init(session->loop, &(session->timer)); SG_ASSERT_RET(ret >= 0, "init timer failed", ERROR); session->timer.data = session; /* link client pointer to timer */ ret = uv_timer_start(&(session->timer), on_uv_timer_cb, session->interval, session->interval); SG_ASSERT_RET(ret >= 0, "start timer failed", ERROR); uv_idle_init(session->loop, &(session->idle)); session->idle.data = session; SG_CALLBACK(session->on_open, session); return OK; }
void stream_init(Loop *loop, Stream *stream, int fd, uv_stream_t *uvstream, void *data) { stream->uvstream = uvstream; if (fd >= 0) { uv_handle_type type = uv_guess_handle(fd); stream->fd = fd; if (type == UV_FILE) { // Non-blocking file reads are simulated with an idle handle that reads in // chunks of the ring buffer size, giving time for other events to be // processed between reads. uv_idle_init(&loop->uv, &stream->uv.idle); stream->uv.idle.data = stream; } else { assert(type == UV_NAMED_PIPE || type == UV_TTY); uv_pipe_init(&loop->uv, &stream->uv.pipe, 0); uv_pipe_open(&stream->uv.pipe, fd); stream->uvstream = (uv_stream_t *)&stream->uv.pipe; } } if (stream->uvstream) { stream->uvstream->data = stream; } stream->data = data; stream->internal_data = NULL; stream->fpos = 0; stream->curmem = 0; stream->maxmem = 0; stream->pending_reqs = 0; stream->read_cb = NULL; stream->write_cb = NULL; stream->close_cb = NULL; stream->internal_close_cb = NULL; stream->closed = false; stream->buffer = NULL; }
int main() { uv_idle_t idler; uv_loop_t *loop = uv_default_loop(); // 初始化 idle handle uv_idle_init(loop, &idler); // 启用 idle handle 并传入回调 uv_idle_start(&idler, wait_for_a_while); printf("Idling... \n"); // ========================================== // http://docs.libuv.org/en/v1.x/loop.html // ========================================== // int uv_run(uv_loop_t* loop, uv_run_mode mode) // This function runs the event loop. It will act differently depending on the specified mode: // UV_RUN_DEFAULT: Runs the event loop until there are no more active and referenced handles or requests. // Returns non-zero if uv_stop() was called and there are still active handles or requests. Returns zero in all other cases. // // UV_RUN_ONCE: Poll for i/o once. Note that this function blocks if there are no pending callbacks. // Returns zero when done (no active handles or requests left), or non-zero if more callbacks // are expected (meaning you should run the event loop again sometime in the future). // // UV_RUN_NOWAIT: Poll for i/o once but don’t block if there are no pending callbacks. // Returns zero if done (no active handles or requests left), or non-zero if more callbacks // are expected (meaning you should run the event loop again sometime in the future). // 开始轮询,直到该loop中没有活动的引用 // 在此例中,当uv_idle_stop(handle)调用后,所有的活动执行完成 // 此时将会停止loop uv_run(loop, UV_RUN_DEFAULT); // 关闭轮询 // Releases all internal loop resources. uv_loop_close(loop); return 0; }
int uv_tcp_listen(uv_tcp_t* tcp, int backlog, uv_connection_cb cb) { static int single_accept = -1; if (tcp->delayed_error) return uv__set_sys_error(tcp->loop, tcp->delayed_error); if (single_accept == -1) { const char* val = getenv("UV_TCP_SINGLE_ACCEPT"); single_accept = (val == NULL) || (atoi(val) != 0); /* on by default */ } if (!single_accept) goto no_single_accept; tcp->idle_handle = malloc(sizeof(*tcp->idle_handle)); if (tcp->idle_handle == NULL) return uv__set_sys_error(tcp->loop, ENOMEM); if (uv_idle_init(tcp->loop, tcp->idle_handle)) abort(); tcp->flags |= UV_TCP_SINGLE_ACCEPT; no_single_accept: if (maybe_new_socket(tcp, AF_INET, UV_STREAM_READABLE)) return -1; if (listen(tcp->fd, backlog)) return uv__set_sys_error(tcp->loop, errno); tcp->connection_cb = cb; /* Start listening for connections. */ uv__io_set(&tcp->read_watcher, uv__server_io, tcp->fd, UV__IO_READ); uv__io_start(tcp->loop, &tcp->read_watcher); return 0; }
void uv_eio_init(uv_loop_t* loop) { if (loop->flags & UV_LOOP_EIO_INITIALIZED) return; loop->flags |= UV_LOOP_EIO_INITIALIZED; uv_idle_init(loop, &loop->uv_eio_poller); uv_idle_start(&loop->uv_eio_poller, uv_eio_do_poll); loop->uv_eio_poller.flags |= UV__HANDLE_INTERNAL; loop->uv_eio_want_poll_notifier.data = loop; uv_async_init(loop, &loop->uv_eio_want_poll_notifier, uv_eio_want_poll_notifier_cb); loop->uv_eio_want_poll_notifier.flags |= UV__HANDLE_INTERNAL; uv__handle_unref(&loop->uv_eio_want_poll_notifier); uv_async_init(loop, &loop->uv_eio_done_poll_notifier, uv_eio_done_poll_notifier_cb); loop->uv_eio_done_poll_notifier.flags |= UV__HANDLE_INTERNAL; uv__handle_unref(&loop->uv_eio_done_poll_notifier); uv_once(&uv__eio_init_once_guard, uv__eio_init); }