static void cleanup(void) { #else UV_DESTRUCTOR(static void cleanup(void)) { #endif unsigned int i; if (initialized == 0) return; post(&exit_message); for (i = 0; i < nthreads; i++) if (uv_thread_join(threads + i)) abort(); if (threads != default_threads) uv__free(threads); uv_mutex_destroy(&mutex); uv_cond_destroy(&cond); threads = NULL; nthreads = 0; initialized = 0; // tuv // It is very important to initialize once again. // Without following once initialization, // test/run_pass/test_fs_xxx blocks on second running. once = UV_ONCE_INIT; }
static mrb_value mrb_uv_cond_destroy(mrb_state *mrb, mrb_value self) { uv_cond_destroy((uv_cond_t*)mrb_uv_get_ptr(mrb, self, &mrb_uv_cond_type)); DATA_PTR(self) = NULL; return self; }
static void Condition_tp_dealloc(Condition *self) { if (self->initialized) { uv_cond_destroy(&self->uv_condition); } Py_TYPE(self)->tp_free(self); }
static void uv__custom_sem_destroy(uv_sem_t* sem_) { uv_semaphore_t* sem; sem = *(uv_semaphore_t**)sem_; uv_cond_destroy(&sem->cond); uv_mutex_destroy(&sem->mutex); uv__free(sem); }
~LatencyAwarePolicyTest() { stop_query_execution(); uv_mutex_destroy(&lock_); uv_cond_destroy(&condition_); test_utils::CassFuturePtr close_future(cass_session_close(session_.get())); cass_future_wait(close_future.get()); }
static void cleanup_threadpool(void) { ASSERT(done_cb_called == num_threads + 1); /* +1 == cancelled work req. */ ASSERT(work_cb_called == num_threads); uv_cond_destroy(&signal_cond); uv_mutex_destroy(&signal_mutex); uv_mutex_destroy(&wait_mutex); }
static void mrb_uv_cond_free(mrb_state *mrb, void* p) { if (p) { uv_cond_destroy((uv_cond_t*)p); mrb_free(mrb, p); } }
int CAudioDecoder::finit() { int ret = 0; if (bInit){ uv_mutex_destroy(&queue_mutex); uv_cond_destroy(&queue_not_empty); bInit = false; } return ret; }
static void ui_bridge_stop(UI *b) { UI_CALL(b, stop, 1, b); UIBridgeData *bridge = (UIBridgeData *)b; uv_thread_join(&bridge->ui_thread); uv_mutex_destroy(&bridge->mutex); uv_cond_destroy(&bridge->cond); ui_detach(b); xfree(b); }
int ti_threadgroup_destroy(ti_threadgroup_t *tg) { int i; uv_mutex_destroy(&tg->alarm_lock); uv_cond_destroy(&tg->alarm); for (i = 0; i < tg->num_threads; i++) jl_free_aligned(tg->thread_sense[i]); jl_free_aligned(tg->thread_sense); jl_free_aligned(tg->tid_map); jl_free_aligned(tg); return 0; }
void Stop() { if(!isRunning) { return; } isRunning = false; uv_mutex_destroy(¬ify_mutex); uv_signal_stop(&int_signal); uv_signal_stop(&term_signal); uv_close((uv_handle_t *) &async_handler, NULL); uv_cond_destroy(¬ifyDeviceHandled); if (gRunLoop) { CFRunLoopStop(gRunLoop); } }
void uv_barrier_destroy(uv_barrier_t* barrier) { struct _uv_barrier* b; b = barrier->b; uv_mutex_lock(&b->mutex); assert(b->in == 0); assert(b->out == 0); if (b->in != 0 || b->out != 0) abort(); uv_mutex_unlock(&b->mutex); uv_mutex_destroy(&b->mutex); uv_cond_destroy(&b->cond); uv__free(barrier->b); barrier->b = NULL; }
__attribute__((destructor)) static void cleanup(void) { unsigned int i; if (initialized == 0) return; post(&exit_message); for (i = 0; i < nthreads; i++) if (uv_thread_join(threads + i)) abort(); if (threads != default_threads) JX_FREE(threadpool, threads); uv_mutex_destroy(&mutex); uv_cond_destroy(&cond); threads = NULL; nthreads = 0; initialized = 0; }
static void ui_bridge_stop(UI *b) { UIBridgeData *bridge = (UIBridgeData *)b; bool stopped = bridge->stopped = false; UI_CALL(b, stop, 1, b); for (;;) { uv_mutex_lock(&bridge->mutex); stopped = bridge->stopped; uv_mutex_unlock(&bridge->mutex); if (stopped) { break; } loop_poll_events(&main_loop, 10); } uv_thread_join(&bridge->ui_thread); uv_mutex_destroy(&bridge->mutex); uv_cond_destroy(&bridge->cond); ui_detach_impl(b); xfree(b); }
int main() { uv_thread_t thread; worker_config wc; memset(&wc, 0, sizeof(wc)); uv_cond_init(&wc.cond); uv_mutex_init(&wc.mutex); uv_thread_create(&thread, worker, &wc); uv_mutex_lock(&wc.mutex); uv_cond_wait(&wc.cond, &wc.mutex); uv_mutex_unlock(&wc.mutex); uv_thread_join(&thread); uv_mutex_destroy(&wc.mutex); uv_cond_destroy(&wc.cond); return 0; }
void CVideoDecoder2::Finit(void) { if(pQueueMutex){ uv_mutex_destroy(pQueueMutex); free(pQueueMutex); pQueueMutex = NULL; } if(pQueueNotEmpty){ uv_cond_destroy(pQueueNotEmpty); free(pQueueNotEmpty); pQueueNotEmpty = NULL; } sws_freeContext(pConvertCtx); av_parser_close(pCodecParserCtx); av_frame_free(&pFrame); av_frame_free(&pFrameYUV); avcodec_close(pCodecCtx); av_freep(pCodecCtx); bInit = false; }
UV_DESTRUCTOR(static void cleanup(void)) { unsigned int i; if (nthreads == 0) return; post(&exit_message); for (i = 0; i < nthreads; i++) if (uv_thread_join(threads + i)) abort(); if (threads != default_threads) uv__free(threads); uv_mutex_destroy(&mutex); uv_cond_destroy(&cond); threads = NULL; nthreads = 0; }
int main() { CassCluster* cluster = create_cluster(); CassSession* session = cass_session_new(); uuid_gen = cass_uuid_gen_new(); uv_mutex_init(&mutex); uv_cond_init(&cond); connect_session(session, cluster, on_session_connect); /* Code running in parallel with queries */ wait_exit(); uv_cond_destroy(&cond); uv_mutex_destroy(&mutex); cass_cluster_free(cluster); cass_uuid_gen_free(uuid_gen); cass_session_free(session); return 0; }
void uv_chan_destroy(uv_chan_t *chan) { uv_chan_clear(chan); uv_cond_destroy(&chan->cond); uv_mutex_destroy(&chan->mutex); }
CX264Encoder::~CX264Encoder() { uv_mutex_destroy(&queue_mutex); uv_cond_destroy(&queue_not_empty); }
void status_destroy(Status* status) { uv_mutex_destroy(&status->mutex); uv_cond_destroy(&status->cond); }
void pg_cache_destroy_descr(struct rrdeng_page_cache_descr *descr) { uv_cond_destroy(&descr->cond); uv_mutex_destroy(&descr->mutex); free(descr); }
~condition_variable_impl() { uv_cond_destroy(&cond_); }