void nub_thread_join(nub_thread_t* thread) { ASSERT(NULL != thread); thread->disposed = 1; uv_sem_post(&thread->sem_wait_); uv_thread_join(&thread->uvthread); uv_close((uv_handle_t*) thread->async_signal_, nub__free_handle_cb); uv_sem_destroy(&thread->thread_lock_sem_); uv_sem_destroy(&thread->sem_wait_); --thread->nubloop->ref_; thread->nubloop = NULL; }
int uv_barrier_init(uv_barrier_t* barrier, unsigned int count) { int err; barrier->n = count; barrier->count = 0; err = uv_mutex_init(&barrier->mutex); if (err) return -err; err = uv_sem_init(&barrier->turnstile1, 0); if (err) goto error2; err = uv_sem_init(&barrier->turnstile2, 1); if (err) goto error; return 0; error: uv_sem_destroy(&barrier->turnstile1); error2: uv_mutex_destroy(&barrier->mutex); return -err; }
/* kproc exit */ void pexit(char *msg, int t) { Osenv *e; kproc_t* p; Osdep *os; USED(t); /* get our process context and remove ourselves from proc list */ trace(TRACE_DEBUG, "kernel/pexit: process shutdown"); p = (kproc_t*)up; lock(&procs.l); if(p->prev) p->prev->next = p->next; else procs.head = p->next; if(p->next) p->next->prev = p->prev; else procs.tail = p->prev; unlock(&procs.l); if(0) print("pexit: %s: %s\n", p->text, msg); trace(TRACE_DEBUG, "kernel/pexit: releasing resources"); /* release name,fid and env groups */ e = p->env; if(e != nil) { trace(TRACE_DEBUG, "kernel/pexit: closing fgrp"); closefgrp(e->fgrp); trace(TRACE_DEBUG, "kernel/pexit: closing pgrp"); closepgrp(e->pgrp); trace(TRACE_DEBUG, "kernel/pexit: closing egrp"); closeegrp(e->egrp); trace(TRACE_DEBUG, "kernel/pexit: closing signatures"); closesigs(e->sigs); trace(TRACE_DEBUG, "kernel/pexit: freeing user"); free(e->user); } /* release os dependencies */ os = p->os; if(os != nil){ trace(TRACE_DEBUG, "kernel/pexit: deleting semaphore"); uv_sem_destroy(&os->sem); trace(TRACE_DEBUG, "kernel/pexit: freeing os dependencies"); free(os); } /* release the process itself */ trace(TRACE_DEBUG, "kernel/pexit: freeing process"); free(p); }
void uv__stream_close(uv_stream_t* handle) { #if defined(__APPLE__) /* Terminate select loop first */ if (handle->select != NULL) { uv__stream_select_t* s; s = handle->select; uv_sem_post(&s->sem); uv__stream_osx_interrupt_select(handle); uv_thread_join(&s->thread); uv_sem_destroy(&s->sem); uv_mutex_destroy(&s->mutex); close(s->fake_fd); close(s->int_fd); uv_close((uv_handle_t*) &s->async, uv__stream_osx_cb_close); handle->select = NULL; } #endif /* defined(__APPLE__) */ uv_read_stop(handle); uv__io_close(handle->loop, &handle->io_watcher); close(handle->io_watcher.fd); handle->io_watcher.fd = -1; if (handle->accepted_fd >= 0) { close(handle->accepted_fd); handle->accepted_fd = -1; } assert(!uv__io_active(&handle->io_watcher, UV__POLLIN | UV__POLLOUT)); }
void mrb_uv_sem_free(mrb_state *mrb, void *p) { if(!p) { return; } uv_sem_destroy((uv_sem_t*)p); mrb_free(mrb, p); }
static void Semaphore_tp_dealloc(Semaphore *self) { if (self->initialized) { uv_sem_destroy(&self->uv_semaphore); } Py_TYPE(self)->tp_free(self); }
void async_worker_free(async_worker_t *const worker) { if(!worker) return; assert(!worker->work); uv_sem_post(worker->sem); uv_thread_join(worker->thread); uv_sem_destroy(worker->sem); uv_close((uv_handle_t *)&worker->async); free(worker); }
static mrb_value mrb_uv_sem_destroy(mrb_state *mrb, mrb_value self) { uv_sem_t *sem = (uv_sem_t*)mrb_uv_get_ptr(mrb, self, &sem_type); uv_sem_destroy(sem); mrb_free(mrb, DATA_PTR(self)); DATA_PTR(self) = NULL; return self; }
void Thread::start() { if (this->is_started.exchange(true)) { LOG(INFO) << "Thread " << static_cast<void*>(this) << " already started"; return; } uv_sem_init(&this->semaphore, 0); uv_thread_create(&this->thread_id, &Thread::thread_worker, static_cast<void*>(this)); uv_sem_wait(&this->semaphore); uv_sem_destroy(&this->semaphore); }
int uv_barrier_init(uv_barrier_t* barrier, unsigned int count) { barrier->n = count; barrier->count = 0; if (uv_mutex_init(&barrier->mutex)) return -1; if (uv_sem_init(&barrier->turnstile1, 0)) goto error2; if (uv_sem_init(&barrier->turnstile2, 1)) goto error; return 0; error: uv_sem_destroy(&barrier->turnstile1); error2: uv_mutex_destroy(&barrier->mutex); return -1; }
static void init_threads(void) { unsigned int i; const char* val; uv_sem_t sem; nthreads = ARRAY_SIZE(default_threads); val = getenv("UV_THREADPOOL_SIZE"); if (val != NULL) nthreads = atoi(val); if (nthreads == 0) nthreads = 1; if (nthreads > MAX_THREADPOOL_SIZE) nthreads = MAX_THREADPOOL_SIZE; threads = default_threads; if (nthreads > ARRAY_SIZE(default_threads)) { threads = (uv_thread_t*)uv__malloc(nthreads * sizeof(threads[0])); if (threads == NULL) { nthreads = ARRAY_SIZE(default_threads); threads = default_threads; } } if (uv_cond_init(&cond)) abort(); if (uv_mutex_init(&mutex)) abort(); QUEUE_INIT(&wq); if (uv_sem_init(&sem, 0)) abort(); for (i = 0; i < nthreads; i++) if (uv_thread_create(threads + i, worker, &sem)) abort(); for (i = 0; i < nthreads; i++) uv_sem_wait(&sem); uv_sem_destroy(&sem); }
void uv__platform_loop_delete(uv_loop_t* loop) { QUEUE* item; uv__cf_loop_signal_t* s; assert(loop->cf_loop != NULL); uv__cf_loop_signal(loop, NULL, NULL); uv_thread_join(&loop->cf_thread); uv_sem_destroy(&loop->cf_sem); uv_mutex_destroy(&loop->cf_mutex); /* Free any remaining data */ while (!QUEUE_EMPTY(&loop->cf_signals)) { item = QUEUE_HEAD(&loop->cf_signals); s = QUEUE_DATA(item, uv__cf_loop_signal_t, member); QUEUE_REMOVE(item); free(s); } }
void uv__platform_loop_delete(uv_loop_t* loop) { ngx_queue_t* item; uv__cf_loop_signal_t* s; assert(loop->cf_loop != NULL); uv__cf_loop_signal(loop, NULL, NULL); uv_thread_join(&loop->cf_thread); uv_sem_destroy(&loop->cf_sem); uv_mutex_destroy(&loop->cf_mutex); /* Free any remaining data */ while (!ngx_queue_empty(&loop->cf_signals)) { item = ngx_queue_head(&loop->cf_signals); s = ngx_queue_data(item, uv__cf_loop_signal_t, member); ngx_queue_remove(item); free(s); } }
void nub_loop_dispose(nub_loop_t* loop) { ASSERT(0 == uv_loop_alive(&loop->uvloop)); ASSERT(1 == fuq_empty(&loop->blocking_queue_)); ASSERT(0 == loop->ref_); ASSERT(NULL != loop->work_ping_); ASSERT(0 == uv_has_ref((uv_handle_t*) loop->work_ping_)); ASSERT(1 == fuq_empty(&loop->thread_dispose_queue_)); uv_close((uv_handle_t*) loop->work_ping_, nub__free_handle_cb); uv_close((uv_handle_t*) &loop->queue_processor_, NULL); ASSERT(0 == uv_is_active((uv_handle_t*) loop->work_ping_)); fuq_dispose(&loop->thread_dispose_queue_); uv_mutex_destroy(&loop->thread_dispose_lock_); uv_sem_destroy(&loop->loop_lock_sem_); fuq_dispose(&loop->blocking_queue_); uv_mutex_destroy(&loop->queue_processor_lock_); fuq_dispose(&loop->work_queue_); uv_mutex_destroy(&loop->work_lock_); CHECK_EQ(0, uv_run(&loop->uvloop, UV_RUN_NOWAIT)); CHECK_NE(UV_EBUSY, uv_loop_close(&loop->uvloop)); }
int uv__stream_try_select(uv_stream_t* stream, int fd) { /* * kqueue doesn't work with some files from /dev mount on osx. * select(2) in separate thread for those fds */ struct kevent filter[1]; struct kevent events[1]; struct timespec timeout; uv__stream_select_t* s; int fds[2]; int ret; int kq; kq = kqueue(); if (kq == -1) { fprintf(stderr, "(libuv) Failed to create kqueue (%d)\n", errno); return uv__set_sys_error(stream->loop, errno); } EV_SET(&filter[0], fd, EVFILT_READ, EV_ADD | EV_ENABLE, 0, 0, 0); /* Use small timeout, because we only want to capture EINVALs */ timeout.tv_sec = 0; timeout.tv_nsec = 1; ret = kevent(kq, filter, 1, events, 1, &timeout); SAVE_ERRNO(close(kq)); if (ret == -1) return uv__set_sys_error(stream->loop, errno); if ((events[0].flags & EV_ERROR) == 0 || events[0].data != EINVAL) return 0; /* At this point we definitely know that this fd won't work with kqueue */ s = malloc(sizeof(*s)); if (s == NULL) return uv__set_artificial_error(stream->loop, UV_ENOMEM); s->fd = fd; if (uv_async_init(stream->loop, &s->async, uv__stream_osx_select_cb)) { SAVE_ERRNO(free(s)); return uv__set_sys_error(stream->loop, errno); } s->async.flags |= UV__HANDLE_INTERNAL; uv__handle_unref(&s->async); if (uv_sem_init(&s->sem, 0)) goto fatal1; if (uv_mutex_init(&s->mutex)) goto fatal2; /* Create fds for io watcher and to interrupt the select() loop. */ if (socketpair(AF_UNIX, SOCK_STREAM, 0, fds)) goto fatal3; s->fake_fd = fds[0]; s->int_fd = fds[1]; if (uv_thread_create(&s->thread, uv__stream_osx_select, stream)) goto fatal4; s->stream = stream; stream->select = s; return 0; fatal4: close(s->fake_fd); close(s->int_fd); s->fake_fd = -1; s->int_fd = -1; fatal3: uv_mutex_destroy(&s->mutex); fatal2: uv_sem_destroy(&s->sem); fatal1: uv_close((uv_handle_t*) &s->async, uv__stream_osx_cb_close); return uv__set_sys_error(stream->loop, errno); }
void uvm_chime_destroy(uvm_chime_t* c){ uv_sem_destroy(&c->sem); }
void uv_barrier_destroy(uv_barrier_t* barrier) { uv_sem_destroy(&barrier->turnstile2); uv_sem_destroy(&barrier->turnstile1); uv_mutex_destroy(&barrier->mutex); }
Semaphore::~Semaphore() { uv_sem_destroy(&sem); }
static void done_cb(uv_work_t* req, int status) { uv_sem_destroy(pause_sems + (req - pause_reqs)); }