// // The destructor! // ~SpellDictionary(){ if (spellClass){ delete spellClass; spellClass = NULL; } uv_rwlock_destroy(&rwlock); };
static mrb_value mrb_uv_rwlock_destroy(mrb_state *mrb, mrb_value self) { uv_rwlock_destroy((uv_rwlock_t*)mrb_uv_get_ptr(mrb, self, &mrb_uv_rwlock_type)); DATA_PTR(self) = NULL; return self; }
static void mrb_uv_rwlock_free(mrb_state *mrb, void *p) { if (p) { uv_rwlock_destroy((uv_rwlock_t*)p); mrb_free(mrb, p); } }
static void RWLock_tp_dealloc(RWLock *self) { if (self->initialized) { uv_rwlock_destroy(&self->uv_rwlock); } Py_TYPE(self)->tp_free(self); }
void php_cassandra_log_cleanup() { cass_log_cleanup(); uv_rwlock_destroy(&log_lock); if (log_location) { free(log_location); log_location = NULL; } }
int main() { uv_thread_t threads[3]; int thread_nums[] = {1, 2, 1}; uv_barrier_init(&blocker, 4); shared_num = 0; uv_rwlock_init(&numlock); uv_thread_create(&threads[0], reader, &thread_nums[0]); uv_thread_create(&threads[1], reader, &thread_nums[1]); uv_thread_create(&threads[2], writer, &thread_nums[2]); uv_barrier_wait(&blocker); uv_barrier_destroy(&blocker); uv_rwlock_destroy(&numlock); return 0; }
// same as ./10-locks, but using try* functions when obtaining read and write locks // int main() { int r; const int count = 4; fprintf(stderr, "barrier: init\n"); uv_barrier_init(&blocker, count); shared_num = 0; // https://github.com/thlorenz/libuv-dox/blob/master/methods.md#rwlock fprintf(stderr, "rwlock: init\n"); r = uv_rwlock_init(&numlock); if (r) ERROR("rwlock_init", r); uv_thread_t threads[3]; int thread_nums[] = { 1, 2, 1 }; r = uv_thread_create(&threads[0], reader_entry, &thread_nums[0]); if (r) ERROR("thread_create", r); r = uv_thread_create(&threads[1], reader_entry, &thread_nums[1]); if (r) ERROR("thread_create", r); r = uv_thread_create(&threads[2], writer_entry, &thread_nums[2]); if (r) ERROR("thread_create", r); // https://github.com/thlorenz/libuv-dox/blob/master/methods.md#barrier fprintf(stderr, "barrier: wait\n"); uv_barrier_wait(&blocker); fprintf(stderr, "barrier: destroy\n"); uv_barrier_destroy(&blocker); fprintf(stderr, "rwlock: destroy\n"); uv_rwlock_destroy(&numlock); if (r) ERROR("rwlock_destroy", r); return 0; }
void uv__loop_close(uv_loop_t* loop) { uv__signal_loop_cleanup(loop); uv__platform_loop_delete(loop); uv__async_stop(loop); if (loop->emfile_fd != -1) { uv__close(loop->emfile_fd); loop->emfile_fd = -1; } if (loop->backend_fd != -1) { uv__close(loop->backend_fd); loop->backend_fd = -1; } uv_mutex_lock(&loop->wq_mutex); assert(QUEUE_EMPTY(&loop->wq) && "thread pool work queue not empty!"); assert(!uv__has_active_reqs(loop)); uv_mutex_unlock(&loop->wq_mutex); uv_mutex_destroy(&loop->wq_mutex); /* * Note that all thread pool stuff is finished at this point and * it is safe to just destroy rw lock */ uv_rwlock_destroy(&loop->cloexec_lock); #if 0 assert(QUEUE_EMPTY(&loop->pending_queue)); assert(QUEUE_EMPTY(&loop->watcher_queue)); assert(loop->nfds == 0); #endif uv__free(loop->watchers); loop->watchers = NULL; loop->nwatchers = 0; }
int uv_loop_init(uv_loop_t* loop) { void* saved_data; int err; saved_data = loop->data; memset(loop, 0, sizeof(*loop)); loop->data = saved_data; heap_init((struct heap*) &loop->timer_heap); QUEUE_INIT(&loop->wq); 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->active_handles = 0; loop->active_reqs.count = 0; 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); loop->async_io_watcher.fd = -1; loop->async_wfd = -1; 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_global_once_init(); err = uv_signal_init(loop, &loop->child_watcher); if (err) goto fail_signal_init; uv__handle_unref(&loop->child_watcher); loop->child_watcher.flags |= UV__HANDLE_INTERNAL; QUEUE_INIT(&loop->process_handles); err = uv_rwlock_init(&loop->cloexec_lock); if (err) goto fail_rwlock_init; err = uv_mutex_init(&loop->wq_mutex); if (err) goto fail_mutex_init; err = uv_async_init(loop, &loop->wq_async, uv__work_done); if (err) goto fail_async_init; uv__handle_unref(&loop->wq_async); loop->wq_async.flags |= UV__HANDLE_INTERNAL; return 0; fail_async_init: uv_mutex_destroy(&loop->wq_mutex); fail_mutex_init: uv_rwlock_destroy(&loop->cloexec_lock); fail_rwlock_init: uv__signal_loop_cleanup(loop); fail_signal_init: uv__platform_loop_delete(loop); return err; }
~SessionContainer() { uv_rwlock_destroy(&sessions_lock); }
inline ~rwlock() { uv_rwlock_destroy(&mtx); }