result_t net_base::backend(std::string &retVal) { switch (ev_backend(s_loop)) { case EVBACKEND_SELECT: retVal = "Select"; break; case EVBACKEND_POLL: retVal = "Poll"; break; case EVBACKEND_EPOLL: retVal = "EPoll"; break; case EVBACKEND_KQUEUE: retVal = "KQueue"; break; case EVBACKEND_DEVPOLL: retVal = "DevPoll"; break; case EVBACKEND_PORT: retVal = "Port"; break; } return 0; }
/** get the event system in use */ static void get_event_sys(const char** n, const char** s, const char** m) { #ifdef USE_WINSOCK *n = "event"; *s = "winsock"; *m = "WSAWaitForMultipleEvents"; #elif defined(USE_MINI_EVENT) *n = "mini-event"; *s = "internal"; *m = "select"; #else struct event_base* b; *s = event_get_version(); # ifdef HAVE_EVENT_BASE_GET_METHOD *n = "libevent"; b = event_base_new(); *m = event_base_get_method(b); # elif defined(HAVE_EV_LOOP) || defined(HAVE_EV_DEFAULT_LOOP) *n = "libev"; b = (struct event_base*)ev_default_loop(EVFLAG_AUTO); *m = ev_backend2str(ev_backend((struct ev_loop*)b)); # else *n = "unknown"; *m = "not obtainable"; b = NULL; # endif # ifdef HAVE_EVENT_BASE_FREE event_base_free(b); # endif #endif }
LWS_VISIBLE int lws_initloop( struct lws_context *context, struct ev_loop *loop) { int status = 0; int backend; const char * backend_name; struct ev_io *w_accept = &context->w_accept.watcher; struct ev_signal *w_sigint = &context->w_sigint.watcher; if (!loop) loop = ev_default_loop(0); context->io_loop = loop; /* * Initialize the accept w_accept with the listening socket * and register a callback for read operations: */ ev_io_init(w_accept, lws_accept_cb, context->lserv_fd, EV_READ); ev_io_start(context->io_loop,w_accept); /* Register the signal watcher unless the user has indicated otherwise: */ if( context->use_ev_sigint ) { ev_signal_init(w_sigint, context->lws_ev_sigint_cb, SIGINT); ev_signal_start(context->io_loop,w_sigint); }; backend = ev_backend(loop); switch (backend) { case EVBACKEND_SELECT: backend_name = "select"; break; case EVBACKEND_POLL: backend_name = "poll"; break; case EVBACKEND_EPOLL: backend_name = "epoll"; break; case EVBACKEND_KQUEUE: backend_name = "kqueue"; break; case EVBACKEND_DEVPOLL: backend_name = "/dev/poll"; break; case EVBACKEND_PORT: backend_name = "Solaris 10 \"port\""; break; default: backend_name = "Unknown libev backend"; break; }; lwsl_notice(" libev backend: %s\n", backend_name); return status; }
const char* li_event_loop_backend_string(liEventLoop *loop) { switch (ev_backend(loop->loop)) { case EVBACKEND_SELECT: return "select"; case EVBACKEND_POLL: return "poll"; case EVBACKEND_EPOLL: return "epoll"; case EVBACKEND_KQUEUE: return "kqueue"; case EVBACKEND_DEVPOLL: return "devpoll"; case EVBACKEND_PORT: return "port"; default: return "unknown"; } }
/** * Returns one of the EventLoop::BACKEND_* flags indicating the event backend in use. * * @return int * @return false if object is not initialized */ PHP_METHOD(EventLoop, getBackend) { event_loop_object *obj = (event_loop_object *)zend_object_store_get_object(getThis() TSRMLS_CC); assert(obj->loop); if(obj->loop) { RETURN_LONG(ev_backend(obj->loop)); } RETURN_BOOL(0); }
/* Procedure exposed in Python will generate and start the event loop */ static PyObject *py_run_loop(PyObject *self, PyObject *args) { char *backend=""; int i; ev_io accept_watcher; ev_signal signal_watcher, signal_watcher2, signal_watcher3; struct TimerObj *timer; loop = ev_default_loop (0); switch (ev_backend(loop)) { case 1: backend="select"; break; case 2: backend="poll"; break; case 4: backend="epoll"; break; case 8: backend="kqueue"; break; } printf("Using %s as event backend\n", backend); ev_io_init(&accept_watcher,accept_cb,sockfd,EV_READ); ev_io_start(loop,&accept_watcher); ev_signal_init(&signal_watcher, sigint_cb, SIGINT); ev_signal_start(loop, &signal_watcher); ev_signal_init(&signal_watcher2, sigpipe_cb, SIGPIPE); ev_signal_start(loop, &signal_watcher2); ev_signal_init(&signal_watcher3, sigterm_cb, SIGTERM); ev_signal_start(loop, &signal_watcher3); idle_watcher = malloc(sizeof(ev_idle)); ev_idle_init(idle_watcher, idle_cb); if (list_timers_i>=0) { for (i=0; i<list_timers_i; i++) { timer=list_timers[i]; ev_timer_init(&timer->timerwatcher, timer_cb, timer->delay, timer->delay); ev_timer_start(loop, &timer->timerwatcher); } } ev_loop (loop, 0); return Py_None; }
void ub_get_event_sys(struct ub_event_base* base, const char** n, const char** s, const char** m) { #ifdef USE_WINSOCK (void)base; *n = "event"; *s = "winsock"; *m = "WSAWaitForMultipleEvents"; #elif defined(USE_MINI_EVENT) (void)base; *n = "mini-event"; *s = "internal"; *m = "select"; #else struct event_base* b = AS_EVENT_BASE(base); *s = event_get_version(); # if defined(HAVE_EV_LOOP) || defined(HAVE_EV_DEFAULT_LOOP) *n = "libev"; if (!b) b = (struct event_base*)ev_default_loop(EVFLAG_AUTO); # ifdef EVBACKEND_SELECT *m = ub_ev_backend2str(ev_backend((struct ev_loop*)b)); # else *m = "not obtainable"; # endif # elif defined(HAVE_EVENT_BASE_GET_METHOD) *n = "libevent"; if (!b) b = event_base_new(); *m = event_base_get_method(b); # else *n = "unknown"; *m = "not obtainable"; (void)b; # endif # ifdef HAVE_EVENT_BASE_FREE if (b && b != AS_EVENT_BASE(base)) event_base_free(b); # endif #endif }
static VALUE NIO_Selector_backend(VALUE self) { struct NIO_Selector *selector; Data_Get_Struct(self, struct NIO_Selector, selector); if(selector->closed) { rb_raise(rb_eIOError, "selector is closed"); } switch (ev_backend(selector->ev_loop)) { case EVBACKEND_EPOLL: return ID2SYM(rb_intern("epoll")); case EVBACKEND_POLL: return ID2SYM(rb_intern("poll")); case EVBACKEND_KQUEUE: return ID2SYM(rb_intern("kqueue")); case EVBACKEND_SELECT: return ID2SYM(rb_intern("select")); case EVBACKEND_PORT: return ID2SYM(rb_intern("port")); } return ID2SYM(rb_intern("unknown")); }
static PyObject * Loop_backend_get(Loop *self, void *closure) { return PyInt_FromUnsignedLong(ev_backend(self->loop)); }