自学教程：C++ uv_async_init函数代码示例

        ThriftClient::ThriftClient()        {            _contextQueue = gcnew ContextQueue();            _transportPool = gcnew Queue<FrameTransport^>();            _loop = uv_loop_new();            _notifier = new uv_async_t();            _notifier->data = _contextQueue->ToPointer();            uv_async_init(_loop, _notifier, NotifyCompleted);            _stop = new uv_async_t();            uv_async_init(_loop, _stop, StopCompleted);        }

static svc_baton* svc_create_baton(uv_loop_t* loop, const char* name, int main_ref, int cb_ref) {  svc_baton* baton = LocalAlloc(LPTR, sizeof(svc_baton));  baton->lua_main_ref = main_ref;  baton->block.lua_cb_ref = cb_ref;  baton->name = _strdup(name);  uv_async_init(loop, &baton->svc_async_handle, svcmain_cb);  uv_async_init(loop, &baton->block.async_handle, svchandler_cb);  baton->svc_async_handle.data = baton;  baton->block.async_handle.data = baton;  baton->svc_end_event = CreateEvent(NULL, TRUE, FALSE, NULL);  baton->block.block_end_event = CreateEvent(NULL, TRUE, FALSE, NULL);  baton->next = NULL;  return baton;}

void eventpool_init(enum eventpool_threads_t t) {	/*	 * Make sure we execute in the main thread	 */	const uv_thread_t pth_cur_id = uv_thread_self();	assert(uv_thread_equal(&pth_main_id, &pth_cur_id));	if(eventpoolinit == 1) {		return;	}	eventpoolinit = 1;	threads = t;	if((async_req = MALLOC(sizeof(uv_async_t))) == NULL) {		OUT_OF_MEMORY /*LCOV_EXCL_LINE*/	}	uv_async_init(uv_default_loop(), async_req, eventpool_execute);	if(lockinit == 0) {		lockinit = 1;		// pthread_mutexattr_init(&listeners_attr);		// pthread_mutexattr_settype(&listeners_attr, PTHREAD_MUTEX_RECURSIVE);		// pthread_mutex_init(&listeners_lock, &listeners_attr);		uv_mutex_init(&listeners_lock);	}}

	// shutdown shuts down the Node's event loop and cleans up resources.	void	shutdown()	{		uv_async_init(m_uv_loop.get(), &m_async, [](uv_async_t* handle) {			auto self = (Node*)(handle->data);			auto timer = self->m_timer.get();			uv_timer_stop(timer);			uv_close((uv_handle_t*)timer, [](uv_handle_t* handle) {				auto self = (Node*)(handle->data);				auto tcp = self->m_tcp.get();				auto loop = self->m_uv_loop.get();				self->m_peer_registry = nullptr;				uv_close((uv_handle_t*)tcp, [](uv_handle_t* handle) {					auto self = (Node*)(handle->data);					auto loop = self->m_uv_loop.get();					uv_walk(loop, [](uv_handle_t* handle, void* arg) {						if (uv_is_closing(handle) == 0) {							uv_close(handle, [](uv_handle_t* h){});						}					}, nullptr);				});			});		});		m_async.data = this;		uv_async_send(&m_async);	}

static voidtcp_bind(uv_loop_t *loop, struct server_context *server) {    int rc;    uv_tcp_init(loop, &server->tcp);    rc = uv_tcp_open(&server->tcp, server->tcp_fd);    if (rc) {        logger_stderr("tcp open error: %s", uv_strerror(rc));    }    uv_async_init(loop, &server->async_handle, consumer_close);    rc = uv_tcp_bind(&server->tcp, server->local_addr, 0);    if (rc || errno) {        logger_stderr("bind error: %s", rc ? uv_strerror(rc) : strerror(errno));        exit(1);    }    rc = uv_listen((uv_stream_t*)&server->tcp, SOMAXCONN, server->accept_cb);    if (rc) {        logger_stderr("listen error: %s", rc ? uv_strerror(rc) : strerror(errno));        exit(1);    }}

int nub_thread_create(nub_loop_t* loop, nub_thread_t* thread) {  uv_async_t* async_handle;  int er;  async_handle = (uv_async_t*) malloc(sizeof(*async_handle));  CHECK_NE(NULL, async_handle);  er = uv_async_init(&loop->uvloop, async_handle, nub__work_signal_cb);  ASSERT(0 == er);  async_handle->data = thread;  thread->async_signal_ = async_handle;  ASSERT(uv_loop_alive(&loop->uvloop));  er = uv_sem_init(&thread->thread_lock_sem_, 0);  ASSERT(0 == er);  er = uv_sem_init(&thread->sem_wait_, 1);  ASSERT(0 == er);  fuq_init(&thread->incoming_);  thread->disposed = 0;  thread->nubloop = loop;  thread->disposed_cb_ = NULL;  thread->work.thread = thread;  thread->work.work_type = NUB_LOOP_QUEUE_NONE;  ++loop->ref_;  return uv_thread_create(&thread->uvthread, nub__thread_entry_cb, thread);}

int iotjs_tizen_bridge_native(const char* fn_name, unsigned fn_name_size,                              const char* message, unsigned message_size,                              user_callback_t cb) {  iotjs_environment_t* env = iotjs_environment_get();  if (env->state != kRunningMain && env->state != kRunningLoop) {    return IOTJS_ERROR_RESULT_FAILED;  }  iotjs_call_jfunc_t* handle = IOTJS_ALLOC(iotjs_call_jfunc_t);  if (handle == NULL) {    return IOTJS_ERROR_OUT_OF_MEMORY;  }  handle->async.data = (void*)handle;  handle->fn_name = create_string_buffer(fn_name, fn_name_size);  handle->message = create_string_buffer(message, message_size);  handle->module = create_string_buffer(IOTJS_MAGIC_STRING_TIZEN,                                        sizeof(IOTJS_MAGIC_STRING_TIZEN));  handle->cb = cb;  uv_loop_t* loop = iotjs_environment_loop(env);  uv_async_init(loop, &handle->async, bridge_native_async_handler);  uv_async_send(&handle->async);  return IOTJS_ERROR_NONE;}

static intAsync_tp_init(Async *self, PyObject *args, PyObject *kwargs){    int r;    Loop *loop;    PyObject *callback, *tmp;    UNUSED_ARG(kwargs);    RAISE_IF_HANDLE_INITIALIZED(self, -1);    if (!PyArg_ParseTuple(args, "O!O:__init__", &LoopType, &loop, &callback)) {        return -1;    }    if (!PyCallable_Check(callback)) {        PyErr_SetString(PyExc_TypeError, "a callable is required");        return -1;    }    r = uv_async_init(loop->uv_loop, (uv_async_t *)UV_HANDLE(self), on_async_callback);    if (r != 0) {        RAISE_UV_EXCEPTION(loop->uv_loop, PyExc_AsyncError);        return -1;    }    tmp = self->callback;    Py_INCREF(callback);    self->callback = callback;    Py_XDECREF(tmp);    initialize_handle(HANDLE(self), loop);    return 0;}

    ClientWrap::ClientWrap( int compileGuarded )      : m_mutex("Node.js ClientWrap")    {      std::vector<std::string> pluginPaths;      Plug::AppendUserPaths( pluginPaths );      Plug::AppendGlobalPaths( pluginPaths );      CG::CompileOptions compileOptions;      if ( compileGuarded > -1 )        compileOptions.setGuarded( compileGuarded );      else        compileOptions.setGuarded( false );      RC::Handle<IO::Manager> ioManager = IOManager::Create( &ClientWrap::ScheduleAsyncUserCallback, this );      RC::Handle<DG::Context> dgContext = DG::Context::Create( ioManager, pluginPaths, compileOptions, true );#if defined(FABRIC_MODULE_OPENCL)      OCL::registerTypes( dgContext->getRTManager() );#endif      Plug::Manager::Instance()->loadBuiltInPlugins( pluginPaths, dgContext->getCGManager(), DG::Context::GetCallbackStruct() );            m_client = Client::Create( dgContext, this );      m_mainThreadTLS = true;      uv_async_init( uv_default_loop(), &m_uvAsync, &ClientWrap::AsyncCallback );      m_uvAsync.data = this;            //// uv_timer_init adds a loop reference. (That is, it calls uv_ref.) This      //// is not the behavior we want in Node. Timers should not increase the      //// ref count of the loop except when active.      //uv_unref( uv_default_loop() );    }

static int luv_queue_channel_new(lua_State* L){	const char* name = luv_queue_lua_arg_string(L, 1, NULL, queue_usage_new);	int limit = luv_queue_lua_arg_integer(L, 2, 1, 0, queue_usage_new);	luv_queue_t* queue = luv_queue_create(name, limit);	if (lua_gettop(L) >= 3) {		lua_pushvalue(L, 3);		queue->async_cb = luaL_ref(L, LUA_REGISTRYINDEX);		uv_async_init(luv_loop(L), &queue->async, luv_queue_async_callback);		queue->async.data = queue;	} else {		queue->async_cb = LUA_REFNIL;		queue->async.data = NULL;	}	queue->L = L;	if (!luv_queues_add(queue)) {		luv_queue_destroy(queue);		lua_pushnil(L);		lua_pushstring(L, "chan name duplicated");		return 2;	}	luv_queue_channel_push_queue(L, queue);	return 1;}

void connection_consumer_start(void *arg){    int rc;    struct server_ctx *ctx;    uv_loop_t* loop;        ctx = arg;    loop = uv_loop_new();    listener_event_loops[ctx->index] = *loop;        http_request_cache_configure_listener(loop, &listener_async_handles[ctx->index]);    uv_barrier_wait(listeners_created_barrier);        rc = uv_async_init(loop, &ctx->async_handle, connection_consumer_close);    uv_unref((uv_handle_t*) &ctx->async_handle);        /* Wait until the main thread is ready. */    uv_sem_wait(&ctx->semaphore);    get_listen_handle(loop, (uv_stream_t*) &ctx->server_handle);    uv_sem_post(&ctx->semaphore);        rc = uv_listen((uv_stream_t*)&ctx->server_handle, 128, connection_consumer_new_connection);    rc = uv_run(loop, UV_RUN_DEFAULT);        uv_loop_delete(loop);}

lcb_luv_socket_t lcb_luv_socket_new(struct lcb_io_opt_st *iops){    /* Find the next 'file descriptor' */    lcb_socket_t idx;    lcb_luv_socket_t newsock;    idx = find_free_idx(IOPS_COOKIE(iops));    if (idx == -1) {        iops->v.v0.error = ENFILE;        return NULL;    }    newsock = calloc(1, sizeof(struct lcb_luv_socket_st));    newsock->idx = idx;    newsock->parent = IOPS_COOKIE(iops);    uv_async_init(newsock->parent->loop, &newsock->async, async_cb);    newsock->async_state = 0;    newsock->async.data = newsock;    newsock->u_req.req.data = newsock;    newsock->refcount = 1;    uv_tcp_init(IOPS_COOKIE(iops)->loop, &newsock->tcp);    IOPS_COOKIE(iops)->socktable[idx] = newsock;    iops->v.v0.error = 0;    log_socket_debug("%p: Created new socket %p(%d)", iops, newsock, idx);    return newsock;}

static int luv_new_work(lua_State* L) {  size_t len;  const char* buff;  luv_work_ctx_t* ctx;  buff = luv_thread_dumped(L, 1, &len);  luaL_checktype(L, 2, LUA_TFUNCTION);  if(!lua_isnoneornil(L, 3))    luaL_checktype(L, 3, LUA_TFUNCTION);  ctx = lua_newuserdata(L, sizeof(*ctx));  memset(ctx, 0, sizeof(*ctx));  ctx->len = len;  ctx->code = malloc(ctx->len);  memcpy(ctx->code, buff, len);  lua_pushvalue(L, 2);  ctx->after_work_cb = luaL_ref(L, LUA_REGISTRYINDEX);  if (lua_gettop(L) == 4) {    lua_pushvalue(L, 3);    ctx->async_cb = luaL_ref(L, LUA_REGISTRYINDEX);    uv_async_init(luv_loop(L), &ctx->async, async_cb);  } else    ctx->async_cb = LUA_REFNIL;  ctx->L = L;  luaL_getmetatable(L, "luv_work_ctx");  lua_setmetatable(L, -2);  return 1;}

 AsyncQueue(uv_loop_t *loop, std::function<void(T &)> fn) :       callback(fn) {     async.data = this;     uv_async_init(loop, &async, [](UV_ASYNC_PARAMS(handle)) {         auto q = reinterpret_cast<AsyncQueue *>(handle->data);         q->process();     }); }

int main() {    uv_thread_t tid;    loop = create_loop();    async_handle = malloc(sizeof(uv_async_t));    uv_async_init(loop, async_handle, async_callback);    uv_thread_create(&tid, thread_main, NULL);    uv_async_send(async_handle);    uv_thread_join(&tid);}

void V8SynchronizationContext::Initialize() {	// This executes on V8 thread    V8SynchronizationContext::uv_edge_async = new uv_edge_async_t;    uv_async_init(uv_default_loop(), &V8SynchronizationContext::uv_edge_async->uv_async, continueOnV8Thread);    V8SynchronizationContext::Unref(V8SynchronizationContext::uv_edge_async);    V8SynchronizationContext::funcWaitHandle = gcnew AutoResetEvent(true);}

 ThreadPool::ThreadPool() {     loop_ = (uv_loop_t*)malloc(sizeof *loop_);     UV_CHECK(uv_loop_init(loop_));     UV_CHECK(uv_async_init(loop_, &async_, thread_pool_async_cb));     async_.data = (void*)(this);     thread_.reset(new thread([=] () {                 UV_CHECK(uv_run(loop_, UV_RUN_DEFAULT));                 })); }

void extract_options(Local<Object> options, void* cptr, sass_context_wrapper* ctx_w, bool is_file, bool is_sync) {  NanScope();  struct Sass_Context* ctx;  NanAssignPersistent(ctx_w->result, options->Get(NanNew("result"))->ToObject());  if (is_file) {    ctx_w->fctx = (struct Sass_File_Context*) cptr;    ctx = sass_file_context_get_context(ctx_w->fctx);  }  else {    ctx_w->dctx = (struct Sass_Data_Context*) cptr;    ctx = sass_data_context_get_context(ctx_w->dctx);  }  struct Sass_Options* sass_options = sass_context_get_options(ctx);  ctx_w->importer_callback = NULL;  ctx_w->is_sync = is_sync;  if (!is_sync) {    ctx_w->request.data = ctx_w;    // async (callback) style    Local<Function> success_callback = Local<Function>::Cast(options->Get(NanNew("success")));    Local<Function> error_callback = Local<Function>::Cast(options->Get(NanNew("error")));    ctx_w->success_callback = new NanCallback(success_callback);    ctx_w->error_callback = new NanCallback(error_callback);  }  Local<Function> importer_callback = Local<Function>::Cast(options->Get(NanNew("importer")));  if (importer_callback->IsFunction()) {    ctx_w->importer_callback = new NanCallback(importer_callback);    uv_async_init(uv_default_loop(), &ctx_w->async, (uv_async_cb)dispatched_async_uv_callback);    sass_option_set_importer(sass_options, sass_make_importer(sass_importer, ctx_w));  }  if(!is_file) {    sass_option_set_input_path(sass_options, create_string(options->Get(NanNew("file"))));  }  sass_option_set_output_path(sass_options, create_string(options->Get(NanNew("outFile"))));  sass_option_set_image_path(sass_options, create_string(options->Get(NanNew("imagePath"))));  sass_option_set_output_style(sass_options, (Sass_Output_Style)options->Get(NanNew("style"))->Int32Value());  sass_option_set_is_indented_syntax_src(sass_options, options->Get(NanNew("indentedSyntax"))->BooleanValue());  sass_option_set_source_comments(sass_options, options->Get(NanNew("comments"))->BooleanValue());  sass_option_set_omit_source_map_url(sass_options, options->Get(NanNew("omitSourceMapUrl"))->BooleanValue());  sass_option_set_source_map_embed(sass_options, options->Get(NanNew("sourceMapEmbed"))->BooleanValue());  sass_option_set_source_map_contents(sass_options, options->Get(NanNew("sourceMapContents"))->BooleanValue());  sass_option_set_source_map_file(sass_options, create_string(options->Get(NanNew("sourceMap"))));  sass_option_set_include_path(sass_options, create_string(options->Get(NanNew("paths"))));  sass_option_set_precision(sass_options, options->Get(NanNew("precision"))->Int32Value());}

voidas_event_register_external_loop(as_event_loop* event_loop){	// This method is only called when user sets an external event loop.	event_loop->wakeup = cf_malloc(sizeof(uv_async_t));	as_queue_init(&event_loop->queue, sizeof(as_uv_command), AS_EVENT_QUEUE_INITIAL_CAPACITY);		// Assume uv_async_init is called on the same thread as the event loop.	uv_async_init(event_loop->loop, event_loop->wakeup, as_uv_wakeup);}

Error TLSConnectionPrivate::Connect(const std::string &ipaddr, int port, TLSConnectionOptions *opts) {	int err;	loop_ = uv_loop_new();	struct sockaddr_in addr = uv_ip4_addr(ipaddr.c_str(), port);	err = uv_tcp_init(loop_, &tcpsock_);	if (err != UV_OK) {		return UVUtils::ErrorFromLastUVError(loop_);	}	if (opts != nullptr) {		uv_tcp_nodelay(&tcpsock_, opts->tcp_no_delay ? 1 : 0);	}	tcpconn_.data = static_cast<void *>(this);	tcpsock_.data = static_cast<void *>(this);	err = uv_tcp_connect(&tcpconn_, &tcpsock_, addr, TLSConnectionPrivate::OnConnect);	if (err != UV_OK) {		return UVUtils::ErrorFromLastUVError(loop_);	}	uv_mutex_init(&wqlock_);	uv_async_init(loop_, &wqasync_, TLSConnectionPrivate::OnDrainWriteQueue);	wqasync_.data = this;	uv_async_init(loop_, &dcasync_, TLSConnectionPrivate::OnDisconnectRequest);	dcasync_.data = this;	state_ = TLS_CONNECTION_STATE_PRE_CONNECT;	err = uv_thread_create(&thread_, TLSConnectionPrivate::TLSConnectionThread, this);	if (err  == -1) {		return Error::ErrorFromDescription(			std::string("TLSConnection"),			0L,			std::string("unable to create connection thread")		);	}	return Error::NoError();}

static void worker_thread(void* arg) {    ls_worker_t* w = (ls_worker_t*)arg;    w->worker_loop = uv_loop_new();    uv_async_init(w->worker_loop, &(w->worker_async), worker_async_callback);    w->worker_started = 1;    uv_run(w->worker_loop, UV_RUN_DEFAULT);    LOG("  worker_thread[%p] terminate/n", w);}

static int uv__loop_init(uv_loop_t* loop, int default_loop) {  unsigned int i;  int err;  uv__signal_global_once_init();  memset(loop, 0, sizeof(*loop));  RB_INIT(&loop->timer_handles);  QUEUE_INIT(&loop->wq);  QUEUE_INIT(&loop->active_reqs);  QUEUE_INIT(&loop->idle_handles);  QUEUE_INIT(&loop->async_handles);  QUEUE_INIT(&loop->check_handles);  QUEUE_INIT(&loop->prepare_handles);  QUEUE_INIT(&loop->handle_queue);  loop->nfds = 0;  loop->watchers = NULL;  loop->nwatchers = 0;  QUEUE_INIT(&loop->pending_queue);  QUEUE_INIT(&loop->watcher_queue);  loop->closing_handles = NULL;  loop->time = uv__hrtime() / 1000000;  uv__async_init(&loop->async_watcher);  loop->signal_pipefd[0] = -1;  loop->signal_pipefd[1] = -1;  loop->backend_fd = -1;  loop->emfile_fd = -1;  loop->timer_counter = 0;  loop->stop_flag = 0;  err = uv__platform_loop_init(loop, default_loop);  if (err)    return err;  uv_signal_init(loop, &loop->child_watcher);  uv__handle_unref(&loop->child_watcher);  loop->child_watcher.flags |= UV__HANDLE_INTERNAL;  for (i = 0; i < ARRAY_SIZE(loop->process_handles); i++)    QUEUE_INIT(loop->process_handles + i);  if (uv_mutex_init(&loop->wq_mutex))    abort();  if (uv_async_init(loop, &loop->wq_async, uv__work_done))    abort();  uv__handle_unref(&loop->wq_async);  loop->wq_async.flags |= UV__HANDLE_INTERNAL;  return 0;}

int uv_loop_init(uv_loop_t* loop) {  int err;  uv__signal_global_once_init();  memset(loop, 0, sizeof(*loop));  heap_init((struct heap*) &loop->timer_heap);  QUEUE_INIT(&loop->wq);  QUEUE_INIT(&loop->active_reqs);  QUEUE_INIT(&loop->idle_handles);  QUEUE_INIT(&loop->async_handles);  QUEUE_INIT(&loop->check_handles);  QUEUE_INIT(&loop->prepare_handles);  QUEUE_INIT(&loop->handle_queue);  loop->nfds = 0;  loop->watchers = NULL;  loop->nwatchers = 0;  QUEUE_INIT(&loop->pending_queue);  QUEUE_INIT(&loop->watcher_queue);  loop->closing_handles = NULL;  uv__update_time(loop);  uv__async_init(&loop->async_watcher);  loop->signal_pipefd[0] = -1;  loop->signal_pipefd[1] = -1;  loop->backend_fd = -1;  loop->emfile_fd = -1;  loop->timer_counter = 0;  loop->stop_flag = 0;  err = uv__platform_loop_init(loop);  if (err)    return err;  uv_signal_init(loop, &loop->child_watcher);  uv__handle_unref(&loop->child_watcher);  loop->child_watcher.flags |= UV__HANDLE_INTERNAL;  QUEUE_INIT(&loop->process_handles);  if (uv_rwlock_init(&loop->cloexec_lock))    abort();  if (uv_mutex_init(&loop->wq_mutex))    abort();  if (uv_async_init(loop, &loop->wq_async, uv__work_done))    abort();  uv__handle_unref(&loop->wq_async);  loop->wq_async.flags |= UV__HANDLE_INTERNAL;  return 0;}

static void uv_finit(void){	//uv_unref((uv_handle_t*)&g_timer);	uv_timer_stop(&g_timer);	uv_stop(&g_loop);	uv_async_init(&g_loop, &g_async, NULL);	uv_async_send(&g_async);	uv_thread_join(&g_loop_thread);	if (g_sys) delete g_sys;	//if (g_remote) delete g_remote;}

EventServer::EventServer() : thread_id_(std::this_thread::get_id()){  CHECK_EQ(0, uv_loop_init(&uv_loop_));    async_handle_ = new AsyncHandle;    async_handle_->es = this;    async_handle_->uv_handle.data = async_handle_;    CHECK_EQ(0, uv_async_init(&uv_loop_, &async_handle_->uv_handle,                              &EventServer::uv_async_cb));}

int uv_loop_init(uv_loop_t* loop) {  /* Initialize libuv itself first */  uv__once_init();  /* Create an I/O completion port */  loop->iocp = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, 1);  if (loop->iocp == NULL)    return uv_translate_sys_error(GetLastError());  /* To prevent uninitialized memory access, loop->time must be initialized   * to zero before calling uv_update_time for the first time.   */  loop->time = 0;  uv_update_time(loop);  QUEUE_INIT(&loop->wq);  QUEUE_INIT(&loop->handle_queue);  QUEUE_INIT(&loop->active_reqs);  loop->active_handles = 0;  loop->pending_reqs_tail = NULL;  loop->endgame_handles = NULL;  RB_INIT(&loop->timers);  loop->check_handles = NULL;  loop->prepare_handles = NULL;  loop->idle_handles = NULL;  loop->next_prepare_handle = NULL;  loop->next_check_handle = NULL;  loop->next_idle_handle = NULL;  memset(&loop->poll_peer_sockets, 0, sizeof loop->poll_peer_sockets);  loop->active_tcp_streams = 0;  loop->active_udp_streams = 0;  loop->timer_counter = 0;  loop->stop_flag = 0;  if (uv_mutex_init(&loop->wq_mutex))    abort();  if (uv_async_init(loop, &loop->wq_async, uv__work_done))    abort();  uv__handle_unref(&loop->wq_async);  loop->wq_async.flags |= UV__HANDLE_INTERNAL;  return 0;}

extern "C" void*rust_uv_bind_op_cb(uv_loop_t* loop, extern_async_op_cb cb) {    uv_async_t* async = (uv_async_t*)current_kernel_malloc(            sizeof(uv_async_t),            "uv_async_t");    uv_async_init(loop, async, foreign_extern_async_op_cb);    async->data = (void*)cb;    // decrement the ref count, so that our async bind    // doesn't count towards keeping the loop alive    //uv_unref(loop);    return async;}

int uv__loop_init(uv_loop_t* loop, int default_loop) {  unsigned int i;  int flags;  uv__signal_global_once_init();#if HAVE_KQUEUE  flags = EVBACKEND_KQUEUE;#else  flags = EVFLAG_AUTO;#endif  memset(loop, 0, sizeof(*loop));  RB_INIT(&loop->timer_handles);  ngx_queue_init(&loop->wq);  ngx_queue_init(&loop->active_reqs);  ngx_queue_init(&loop->idle_handles);  ngx_queue_init(&loop->async_handles);  ngx_queue_init(&loop->check_handles);  ngx_queue_init(&loop->prepare_handles);  ngx_queue_init(&loop->handle_queue);  loop->closing_handles = NULL;  loop->time = uv_hrtime() / 1000000;  loop->async_pipefd[0] = -1;  loop->async_pipefd[1] = -1;  loop->async_sweep_needed = 0;  loop->signal_pipefd[0] = -1;  loop->signal_pipefd[1] = -1;  loop->emfile_fd = -1;  loop->ev = (default_loop ? ev_default_loop : ev_loop_new)(flags);  ev_set_userdata(loop->ev, loop);  uv_signal_init(loop, &loop->child_watcher);  uv__handle_unref(&loop->child_watcher);  loop->child_watcher.flags |= UV__HANDLE_INTERNAL;  for (i = 0; i < ARRAY_SIZE(loop->process_handles); i++)    ngx_queue_init(loop->process_handles + i);  if (uv_mutex_init(&loop->wq_mutex))    abort();  if (uv_async_init(loop, &loop->wq_async, uv__work_done))    abort();  uv__handle_unref(&loop->wq_async);  loop->wq_async.flags |= UV__HANDLE_INTERNAL;  if (uv__platform_loop_init(loop, default_loop))    return -1;  return 0;}

extern "C" void*rust_uv_hilvl_async_init(uv_loop_t* loop, extern_simple_cb cb,        uint8_t* buf) {    uv_async_t* async = (uv_async_t*)current_kernel_malloc(            sizeof(uv_async_t),            "uv_async_t");    uv_async_init(loop, async, foreign_async_cb);    handle_data* data = new_handle_data_from(buf, cb);    async->data = data;    return async;}

/** libuv constructors */DLLEXPORT uv_async_t *jl_make_async(uv_loop_t *loop,jl_value_t *julia_struct){    if (!loop)        return 0;    uv_async_t *async = malloc(sizeof(uv_async_t));    if (uv_async_init(loop,async,(uv_async_cb)&jl_asynccb)) {        free(async);        return 0;    }    async->data=julia_struct;    return async;}