/** * Callback routine that is called to destroy this * etch_apr_queue_t when its pool is destroyed. */ static apr_status_t etch_apr_queue_destroy(void *data) { etch_apr_queue_t *queue = data; apr_thread_cond_destroy(queue->not_empty); apr_thread_cond_destroy(queue->not_full); apr_thread_mutex_destroy(queue->one_big_mutex); return APR_SUCCESS; }
/** * Callback routine that is called to destroy this * apr_queue_t when its pool is destroyed. */ static apr_status_t queue_destroy(void *data) { apr_queue_t *queue = data; /* Ignore errors here, we can't do anything about them anyway. */ apr_thread_cond_destroy(queue->not_empty); apr_thread_cond_destroy(queue->not_full); apr_thread_mutex_destroy(queue->one_big_mutex); return APR_SUCCESS; }
/** Shutdown message processing loop */ MRCP_DECLARE(apt_bool_t) mrcp_client_shutdown(mrcp_client_t *client) { apt_task_t *task; if(!client || !client->task) { apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Invalid Client"); return FALSE; } task = apt_consumer_task_base_get(client->task); if(apt_task_terminate(task,TRUE) == FALSE) { apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Failed to Shutdown Client Task"); return FALSE; } client->session_table = NULL; if(client->sync_start_object) { apr_thread_cond_destroy(client->sync_start_object); client->sync_start_object = NULL; } if(client->sync_start_mutex) { apr_thread_mutex_destroy(client->sync_start_mutex); client->sync_start_mutex = NULL; } return TRUE; }
/** Destroy ASR session */ static apt_bool_t asr_session_destroy_ex(asr_session_t *asr_session, apt_bool_t terminate) { if(terminate == TRUE) { apr_thread_mutex_lock(asr_session->mutex); if(mrcp_application_session_terminate(asr_session->mrcp_session) == TRUE) { apr_thread_cond_wait(asr_session->wait_object,asr_session->mutex); /* the response must be checked to be the valid one */ } apr_thread_mutex_unlock(asr_session->mutex); } if(asr_session->audio_in) { fclose(asr_session->audio_in); asr_session->audio_in = NULL; } if(asr_session->mutex) { apr_thread_mutex_destroy(asr_session->mutex); asr_session->mutex = NULL; } if(asr_session->wait_object) { apr_thread_cond_destroy(asr_session->wait_object); asr_session->wait_object = NULL; } if(asr_session->media_buffer) { mpf_frame_buffer_destroy(asr_session->media_buffer); asr_session->media_buffer = NULL; } return mrcp_application_session_destroy(asr_session->mrcp_session); }
static void broadcast_threads(abts_case *tc, void *data) { toolbox_t box; unsigned int i; apr_status_t rv; apr_uint32_t count = 0; apr_thread_cond_t *cond = NULL; apr_thread_mutex_t *mutex = NULL; apr_thread_t *thread[NTHREADS]; rv = apr_thread_cond_create(&cond, p); ABTS_SUCCESS(rv); ABTS_PTR_NOTNULL(tc, cond); rv = apr_thread_mutex_create(&mutex, APR_THREAD_MUTEX_DEFAULT, p); ABTS_SUCCESS(rv); ABTS_PTR_NOTNULL(tc, mutex); rv = apr_thread_mutex_lock(mutex); ABTS_SUCCESS(rv); box.tc = tc; box.data = &count; box.mutex = mutex; box.cond = cond; box.func = lock_and_wait; for (i = 0; i < NTHREADS; i++) { rv = apr_thread_create(&thread[i], NULL, thread_routine, &box, p); ABTS_SUCCESS(rv); } do { rv = apr_thread_mutex_unlock(mutex); ABTS_SUCCESS(rv); apr_sleep(100000); rv = apr_thread_mutex_lock(mutex); ABTS_SUCCESS(rv); } while (apr_atomic_read32(&count) != NTHREADS); rv = apr_thread_cond_broadcast(cond); ABTS_SUCCESS(rv); rv = apr_thread_mutex_unlock(mutex); ABTS_SUCCESS(rv); for (i = 0; i < NTHREADS; i++) { apr_status_t retval; rv = apr_thread_join(&retval, thread[i]); ABTS_SUCCESS(rv); } ABTS_INT_EQUAL(tc, 0, count); rv = apr_thread_cond_destroy(cond); ABTS_SUCCESS(rv); rv = apr_thread_mutex_destroy(mutex); ABTS_SUCCESS(rv); }
static void dynamic_binding(abts_case *tc, void *data) { unsigned int i; apr_status_t rv; toolbox_t box[NTHREADS]; apr_thread_t *thread[NTHREADS]; apr_thread_mutex_t *mutex[NTHREADS]; apr_thread_cond_t *cond = NULL; rv = apr_thread_cond_create(&cond, p); ABTS_SUCCESS(rv); ABTS_PTR_NOTNULL(tc, cond); for (i = 0; i < NTHREADS; i++) { rv = apr_thread_mutex_create(&mutex[i], APR_THREAD_MUTEX_DEFAULT, p); ABTS_SUCCESS(rv); rv = apr_thread_mutex_lock(mutex[i]); ABTS_SUCCESS(rv); box[i].tc = tc; box[i].cond = cond; box[i].mutex = mutex[i]; box[i].func = lock_and_signal; rv = apr_thread_create(&thread[i], NULL, thread_routine, &box[i], p); ABTS_SUCCESS(rv); } /* * The dynamic binding should be preserved because we use only one waiter */ for (i = 0; i < NTHREADS; i++) { rv = apr_thread_cond_wait(cond, mutex[i]); ABTS_SUCCESS(rv); } for (i = 0; i < NTHREADS; i++) { rv = apr_thread_cond_timedwait(cond, mutex[i], 10000); ABTS_INT_EQUAL(tc, 1, APR_STATUS_IS_TIMEUP(rv)); rv = apr_thread_mutex_unlock(mutex[i]); ABTS_SUCCESS(rv); } for (i = 0; i < NTHREADS; i++) { apr_status_t retval; rv = apr_thread_join(&retval, thread[i]); ABTS_SUCCESS(rv); } rv = apr_thread_cond_destroy(cond); ABTS_SUCCESS(rv); for (i = 0; i < NTHREADS; i++) { rv = apr_thread_mutex_destroy(mutex[i]); ABTS_SUCCESS(rv); } }
void rs_simple_destroy(resource_service_fn_t *rs) { rs_simple_priv_t *rss = (rs_simple_priv_t *)rs->priv; apr_status_t value; log_printf(15, "rs_simple_destroy: sl=%p\n", rss->rid_table); tbx_log_flush(); //** Notify the depot check thread apr_thread_mutex_lock(rss->lock); rss->shutdown = 1; apr_thread_cond_broadcast(rss->cond); apr_thread_mutex_unlock(rss->lock); //** Wait for it to shutdown apr_thread_join(&value, rss->check_thread); //** Now we can free up all the space apr_thread_mutex_destroy(rss->lock); apr_thread_cond_destroy(rss->cond); apr_pool_destroy(rss->mpool); //** This also frees the hash tables if (rss->rid_table != NULL) tbx_list_destroy(rss->rid_table); free(rss->random_array); free(rss->fname); free(rss); free(rs); }
static apr_status_t reslist_cleanup(void *data_) { apr_status_t rv; apr_reslist_t *rl = data_; apr_res_t *res; apr_thread_mutex_lock(rl->listlock); while (rl->nidle > 0) { res = pop_resource(rl); rl->ntotal--; rv = destroy_resource(rl, res); if (rv != APR_SUCCESS) { return rv; } free_container(rl, res); } assert(rl->nidle == 0); assert(rl->ntotal == 0); apr_thread_mutex_destroy(rl->listlock); apr_thread_cond_destroy(rl->avail); return APR_SUCCESS; }
void h2_session_destroy(h2_session *session) { AP_DEBUG_ASSERT(session); if (session->mplx) { h2_mplx_release_and_join(session->mplx, session->iowait); session->mplx = NULL; } if (session->streams) { if (h2_stream_set_size(session->streams)) { ap_log_cerror(APLOG_MARK, APLOG_TRACE2, 0, session->c, "h2_session(%ld): destroy, %d streams open", session->id, (int)h2_stream_set_size(session->streams)); } h2_stream_set_destroy(session->streams); session->streams = NULL; } if (session->ngh2) { nghttp2_session_del(session->ngh2); session->ngh2 = NULL; } h2_conn_io_destroy(&session->io); if (session->iowait) { apr_thread_cond_destroy(session->iowait); session->iowait = NULL; } if (session->pool) { apr_pool_destroy(session->pool); } }
void close_server_port(tbx_ns_monitor_t *nm) { apr_status_t dummy; //** Trigger a port shutdown apr_thread_mutex_lock(nm->lock); nm->shutdown_request = 1; log_printf(15, "close_server_port: port=%d Before cond_signal\n", nm->port); tbx_log_flush(); apr_thread_cond_signal(nm->cond); log_printf(15, "close_server_port: port=%d After cond_signal\n", nm->port); tbx_log_flush(); apr_thread_mutex_unlock(nm->lock); log_printf(15, "close_server_port: port=%d After unlock\n", nm->port); tbx_log_flush(); //** Wait until the thread closes apr_thread_join(&dummy, nm->thread); log_printf(15, "close_server_port: port=%d After join\n", nm->port); tbx_log_flush(); //** Free the actual struct free(nm->address); apr_thread_mutex_destroy(nm->lock); apr_thread_cond_destroy(nm->cond); apr_pool_destroy(nm->mpool); nm->port = -1; }
void network_destroy(tbx_network_t *net) { network_close(net); //** Free the main net variables apr_thread_mutex_destroy(net->ns_lock); apr_thread_cond_destroy(net->cond); apr_pool_destroy(net->mpool); free(net); }
static apr_status_t queue_info_cleanup(void *data_) { fd_queue_info_t *qi = data_; int i; apr_thread_cond_destroy(qi->wait_for_idler); apr_thread_mutex_destroy(qi->idlers_mutex); for (i = 0; i < qi->num_recycled; i++) { apr_pool_destroy(qi->recycled_pools[i]); } return APR_SUCCESS; }
static void test_cond(abts_case *tc, void *data) { apr_thread_t *p1, *p2, *p3, *p4, *c1; apr_status_t s0, s1, s2, s3, s4; int count1, count2, count3, count4; int sum; APR_ASSERT_SUCCESS(tc, "create put mutex", apr_thread_mutex_create(&put.mutex, APR_THREAD_MUTEX_DEFAULT, p)); ABTS_PTR_NOTNULL(tc, put.mutex); APR_ASSERT_SUCCESS(tc, "create nready mutex", apr_thread_mutex_create(&nready.mutex, APR_THREAD_MUTEX_DEFAULT, p)); ABTS_PTR_NOTNULL(tc, nready.mutex); APR_ASSERT_SUCCESS(tc, "create condvar", apr_thread_cond_create(&nready.cond, p)); ABTS_PTR_NOTNULL(tc, nready.cond); count1 = count2 = count3 = count4 = 0; put.nput = put.nval = 0; nready.nready = 0; i = 0; x = 0; s0 = apr_thread_create(&p1, NULL, thread_cond_producer, &count1, p); ABTS_INT_EQUAL(tc, APR_SUCCESS, s0); s1 = apr_thread_create(&p2, NULL, thread_cond_producer, &count2, p); ABTS_INT_EQUAL(tc, APR_SUCCESS, s1); s2 = apr_thread_create(&p3, NULL, thread_cond_producer, &count3, p); ABTS_INT_EQUAL(tc, APR_SUCCESS, s2); s3 = apr_thread_create(&p4, NULL, thread_cond_producer, &count4, p); ABTS_INT_EQUAL(tc, APR_SUCCESS, s3); s4 = apr_thread_create(&c1, NULL, thread_cond_consumer, NULL, p); ABTS_INT_EQUAL(tc, APR_SUCCESS, s4); apr_thread_join(&s0, p1); apr_thread_join(&s1, p2); apr_thread_join(&s2, p3); apr_thread_join(&s3, p4); apr_thread_join(&s4, c1); APR_ASSERT_SUCCESS(tc, "destroy condvar", apr_thread_cond_destroy(nready.cond)); sum = count1 + count2 + count3 + count4; /* printf("count1 = %d count2 = %d count3 = %d count4 = %d\n", count1, count2, count3, count4); */ ABTS_INT_EQUAL(tc, MAX_COUNTER, sum); }
/** * Callback routine that is called to destroy this * fd_queue_t when its pool is destroyed. */ static apr_status_t ap_queue_destroy(void *data) { fd_queue_t *queue = data; /* Ignore errors here, we can't do anything about them anyway. * XXX: We should at least try to signal an error here, it is * indicative of a programmer error. -aaron */ apr_thread_cond_destroy(queue->not_empty); apr_thread_mutex_destroy(queue->one_big_mutex); return APR_SUCCESS; }
static apr_status_t thread_pool_cleanup(void *me) { apr_thread_pool_t *_myself = me; _myself->terminated = 1; apr_thread_pool_idle_max_set(_myself, 0); while (_myself->thd_cnt) { apr_sleep(20 * 1000); /* spin lock with 20 ms */ } apr_thread_mutex_destroy(_myself->lock); apr_thread_cond_destroy(_myself->cond); return APR_SUCCESS; }
void gop_control_free(void *arg, int size, void *data) { gop_control_t *shelf = (gop_control_t *)data; int i; for (i=0; i<size; i++) { apr_thread_mutex_destroy(shelf[i].lock); apr_thread_cond_destroy(shelf[i].cond); } free(shelf); return; }
void mq_stream_read_destroy(mq_stream_t *mqs) { log_printf(1, "START msid=%d\n", mqs->msid); if (mqs->mpool == NULL) { //** Nothing to do pack_destroy(mqs->pack); if (mqs->stream_id != NULL) free(mqs->stream_id); free(mqs); return; } //** Change the flag which signals we don't want anything else apr_thread_mutex_lock(mqs->lock); mqs->want_more = MQS_ABORT; //** Consume all the current data and request the pending while ((mqs->gop_processed != NULL) || (mqs->gop_waiting != NULL)) { log_printf(1, "Clearing pending processed=%d waiting=%p msid=%d\n", mqs->gop_processed, mqs->gop_waiting, mqs->msid); if (mqs->gop_processed != NULL) log_printf(1, "processed gid=%d\n", gop_id(mqs->gop_processed)); if (mqs->gop_waiting != NULL) log_printf(1, "waiting gid=%d\n", gop_id(mqs->gop_waiting)); mqs->want_more = MQS_ABORT; apr_thread_mutex_unlock(mqs->lock); mq_stream_read_wait(mqs); apr_thread_mutex_lock(mqs->lock); } if (log_level() >= 15) { char *rhost = mq_address_to_string(mqs->remote_host); log_printf(15, "remote_host as string = %s\n", rhost); if (rhost) free(rhost); } if (mqs->remote_host != NULL) mq_ongoing_host_dec(mqs->ongoing, mqs->remote_host, mqs->host_id, mqs->hid_len); apr_thread_mutex_unlock(mqs->lock); log_printf(2, "msid=%d transfer_packets=%d\n", mqs->msid, mqs->transfer_packets); //** Clean up if (mqs->stream_id != NULL) free(mqs->stream_id); pack_destroy(mqs->pack); apr_thread_mutex_destroy(mqs->lock); apr_thread_cond_destroy(mqs->cond); apr_pool_destroy(mqs->mpool); if (mqs->remote_host != NULL) mq_msg_destroy(mqs->remote_host); free(mqs); return; }
static void lost_signal(abts_case *tc, void *data) { apr_status_t rv; apr_thread_cond_t *cond = NULL; apr_thread_mutex_t *mutex = NULL; rv = apr_thread_mutex_create(&mutex, APR_THREAD_MUTEX_DEFAULT, p); ABTS_SUCCESS(rv); ABTS_PTR_NOTNULL(tc, mutex); rv = apr_thread_cond_create(&cond, p); ABTS_SUCCESS(rv); ABTS_PTR_NOTNULL(tc, cond); rv = apr_thread_cond_signal(cond); ABTS_SUCCESS(rv); rv = apr_thread_mutex_lock(mutex); ABTS_SUCCESS(rv); rv = apr_thread_cond_timedwait(cond, mutex, 10000); ABTS_INT_EQUAL(tc, 1, APR_STATUS_IS_TIMEUP(rv)); rv = apr_thread_mutex_unlock(mutex); ABTS_SUCCESS(rv); rv = apr_thread_cond_broadcast(cond); ABTS_SUCCESS(rv); rv = apr_thread_mutex_lock(mutex); ABTS_SUCCESS(rv); rv = apr_thread_cond_timedwait(cond, mutex, 10000); ABTS_INT_EQUAL(tc, 1, APR_STATUS_IS_TIMEUP(rv)); rv = apr_thread_mutex_unlock(mutex); ABTS_SUCCESS(rv); rv = apr_thread_cond_destroy(cond); ABTS_SUCCESS(rv); rv = apr_thread_mutex_destroy(mutex); ABTS_SUCCESS(rv); }
void gop_dummy_destroy() { apr_status_t tstat; //** Signal a shutdown apr_thread_mutex_lock(gd_lock); gd_shutdown = 1; apr_thread_cond_broadcast(gd_cond); apr_thread_mutex_unlock(gd_lock); //** Wait for the thread to complete apr_thread_join(&tstat, gd_thread); //** Clean up; free_stack(gd_stack, 0); apr_thread_mutex_destroy(gd_lock); apr_thread_cond_destroy(gd_cond); apr_pool_destroy(gd_pool); }
static apr_status_t queue_info_cleanup(void *data_) { fd_queue_info_t *qi = data_; apr_thread_cond_destroy(qi->wait_for_idler); apr_thread_mutex_destroy(qi->idlers_mutex); /* Clean up any pools in the recycled list */ for (;;) { struct recycled_pool *first_pool = qi->recycled_pools; if (first_pool == NULL) { break; } if (apr_atomic_casptr((void*)&(qi->recycled_pools), first_pool->next, first_pool) == first_pool) { apr_pool_destroy(first_pool->pool); } } return APR_SUCCESS; }
/*! \brief Cleanup already allocated data */ static void uni_recog_cleanup(uni_speech_t *uni_speech) { if(uni_speech->speech_base) { uni_speech->speech_base->data = NULL; } if(uni_speech->mutex) { apr_thread_mutex_destroy(uni_speech->mutex); uni_speech->mutex = NULL; } if(uni_speech->wait_object) { apr_thread_cond_destroy(uni_speech->wait_object); uni_speech->wait_object = NULL; } if(uni_speech->media_buffer) { mpf_frame_buffer_destroy(uni_speech->media_buffer); uni_speech->media_buffer = NULL; } mrcp_application_session_destroy(uni_speech->session); }
/* Destroy the audio queue. */ int audio_queue_destroy(audio_queue_t *queue) { if (queue != NULL) { char *name = queue->name; if ((name == NULL) || (strlen(name) == 0)) name = ""; if (queue->buffer != NULL) { audio_buffer_zero(queue->buffer); audio_buffer_destroy(queue->buffer); queue->buffer = NULL; } if (queue->cond != NULL) { if (apr_thread_cond_destroy(queue->cond) != APR_SUCCESS) ast_log(LOG_WARNING, "(%s) Unable to destroy audio queue condition variable\n", name); queue->cond = NULL; } if (queue->mutex != NULL) { if (apr_thread_mutex_destroy(queue->mutex) != APR_SUCCESS) ast_log(LOG_WARNING, "(%s) Unable to destroy audio queue mutex\n", name); queue->mutex = NULL; } queue->name = NULL; queue->read_bytes = 0; queue->waiting = 0; queue->write_bytes = 0; ast_log(LOG_DEBUG, "(%s) Audio queue destroyed\n", name); if (queue->pool != NULL) { apr_pool_destroy(queue->pool); } } return 0; }
void ds_ibp_destroy(data_service_fn_t *dsf) { ds_ibp_priv_t *ds = (ds_ibp_priv_t *)dsf->priv; apr_status_t value; //** Wait for the warmer thread to complete apr_thread_mutex_lock(ds->lock); ds->warm_stop = 1; apr_thread_cond_signal(ds->cond); apr_thread_mutex_unlock(ds->lock); apr_thread_join(&value, ds->thread); //** Wait for it to complete //** Now we can clean up apr_thread_mutex_destroy(ds->lock); apr_thread_cond_destroy(ds->cond); apr_pool_destroy(ds->pool); ibp_destroy_context(ds->ic); free(ds); free(dsf); }
/*! \brief Cleanup already allocated data */ static void uni_recog_cleanup(uni_speech_t *uni_speech) { if(uni_speech->speech_base) { uni_speech->speech_base->data = NULL; } if(uni_speech->mutex) { apr_thread_mutex_destroy(uni_speech->mutex); uni_speech->mutex = NULL; } if(uni_speech->wait_object) { apr_thread_cond_destroy(uni_speech->wait_object); uni_speech->wait_object = NULL; } if(uni_speech->media_buffer) { mpf_frame_buffer_destroy(uni_speech->media_buffer); uni_speech->media_buffer = NULL; } if(mrcp_application_session_destroy(uni_speech->session) != TRUE) { ast_log(LOG_WARNING, "(%s) Failed to destroy application session\n",uni_speech->name); } }
void destroy_hportal(host_portal_t *hp) { log_printf(5, "host=%s conn_list=%d closed=%d\n", hp->host, tbx_stack_count(hp->conn_list),tbx_stack_count(hp->closed_que)); hportal_lock(hp); _reap_hportal(hp, 0); hportal_unlock(hp); tbx_stack_free(hp->conn_list, 1); tbx_stack_free(hp->que, 1); tbx_stack_free(hp->closed_que, 1); tbx_stack_free(hp->direct_list, 1); hp->context->fn->destroy_connect_context(hp->connect_context); apr_thread_mutex_destroy(hp->lock); apr_thread_cond_destroy(hp->cond); apr_pool_destroy(hp->mpool); log_printf(5, "destroy_hportal: Total commands processed: " I64T " (host:%s:%d)\n", hp->cmds_processed, hp->host, hp->port); free(hp); }
static void test_timeoutcond(abts_case *tc, void *data) { apr_status_t s; apr_interval_time_t timeout; apr_time_t begin, end; int i; s = apr_thread_mutex_create(&timeout_mutex, APR_THREAD_MUTEX_DEFAULT, p); ABTS_INT_EQUAL(tc, APR_SUCCESS, s); ABTS_PTR_NOTNULL(tc, timeout_mutex); s = apr_thread_cond_create(&timeout_cond, p); ABTS_INT_EQUAL(tc, APR_SUCCESS, s); ABTS_PTR_NOTNULL(tc, timeout_cond); timeout = apr_time_from_sec(5); for (i = 0; i < MAX_RETRY; i++) { apr_thread_mutex_lock(timeout_mutex); begin = apr_time_now(); s = apr_thread_cond_timedwait(timeout_cond, timeout_mutex, timeout); end = apr_time_now(); apr_thread_mutex_unlock(timeout_mutex); if (s != APR_SUCCESS && !APR_STATUS_IS_TIMEUP(s)) { continue; } ABTS_INT_EQUAL(tc, 1, APR_STATUS_IS_TIMEUP(s)); ABTS_ASSERT(tc, "Timer returned too late", end - begin - timeout < 500000); break; } ABTS_ASSERT(tc, "Too many retries", i < MAX_RETRY); APR_ASSERT_SUCCESS(tc, "Unable to destroy the conditional", apr_thread_cond_destroy(timeout_cond)); }
static apr_status_t thread_pool_construct(apr_thread_pool_t * me, apr_size_t init_threads, apr_size_t max_threads) { apr_status_t rv; int i; me->thd_max = max_threads; me->idle_max = init_threads; me->threshold = init_threads / 2; rv = apr_thread_mutex_create(&me->lock, APR_THREAD_MUTEX_NESTED, me->pool); if (APR_SUCCESS != rv) { return rv; } rv = apr_thread_cond_create(&me->cond, me->pool); if (APR_SUCCESS != rv) { apr_thread_mutex_destroy(me->lock); return rv; } me->tasks = apr_palloc(me->pool, sizeof(*me->tasks)); if (!me->tasks) { goto CATCH_ENOMEM; } APR_RING_INIT(me->tasks, apr_thread_pool_task, link); me->scheduled_tasks = apr_palloc(me->pool, sizeof(*me->scheduled_tasks)); if (!me->scheduled_tasks) { goto CATCH_ENOMEM; } APR_RING_INIT(me->scheduled_tasks, apr_thread_pool_task, link); me->recycled_tasks = apr_palloc(me->pool, sizeof(*me->recycled_tasks)); if (!me->recycled_tasks) { goto CATCH_ENOMEM; } APR_RING_INIT(me->recycled_tasks, apr_thread_pool_task, link); me->busy_thds = apr_palloc(me->pool, sizeof(*me->busy_thds)); if (!me->busy_thds) { goto CATCH_ENOMEM; } APR_RING_INIT(me->busy_thds, apr_thread_list_elt, link); me->idle_thds = apr_palloc(me->pool, sizeof(*me->idle_thds)); if (!me->idle_thds) { goto CATCH_ENOMEM; } APR_RING_INIT(me->idle_thds, apr_thread_list_elt, link); me->recycled_thds = apr_palloc(me->pool, sizeof(*me->recycled_thds)); if (!me->recycled_thds) { goto CATCH_ENOMEM; } APR_RING_INIT(me->recycled_thds, apr_thread_list_elt, link); me->thd_cnt = me->idle_cnt = me->task_cnt = me->scheduled_task_cnt = 0; me->tasks_run = me->tasks_high = me->thd_high = me->thd_timed_out = 0; me->spawning_cnt = 0; me->idle_wait = 0; me->terminated = 0; for (i = 0; i < TASK_PRIORITY_SEGS; i++) { me->task_idx[i] = NULL; } goto FINAL_EXIT; CATCH_ENOMEM: rv = APR_ENOMEM; apr_thread_mutex_destroy(me->lock); apr_thread_cond_destroy(me->cond); FINAL_EXIT: return rv; }
/* * Program entry point. */ int main(int argc, char** argv) { /* * Standard command-line parsing. */ const HASH_T *options = parse_cmdline(argc, argv, arg_opts); if(options == NULL || hash_get(options, "help") != NULL) { show_usage(argc, argv, arg_opts); return EXIT_FAILURE; } const char *url = hash_get(options, "url"); const char *principal = hash_get(options, "principal"); CREDENTIALS_T *credentials = NULL; const char *password = hash_get(options, "credentials"); if(password != NULL) { credentials = credentials_create_password(password); } const char *topic_name = hash_get(options, "topic"); const long seconds = atol(hash_get(options, "seconds")); /* * Setup for condition variable. */ apr_initialize(); apr_pool_create(&pool, NULL); apr_thread_mutex_create(&mutex, APR_THREAD_MUTEX_UNNESTED, pool); apr_thread_cond_create(&cond, pool); /* * Create a session with the Diffusion server. */ SESSION_T *session; DIFFUSION_ERROR_T error = { 0 }; session = session_create(url, principal, credentials, NULL, NULL, &error); if(session == NULL) { fprintf(stderr, "TEST: Failed to create session\n"); fprintf(stderr, "ERR : %s\n", error.message); return EXIT_FAILURE; } /* * Create a topic holding simple string content. */ TOPIC_DETAILS_T *string_topic_details = create_topic_details_single_value(M_DATA_TYPE_STRING); const ADD_TOPIC_PARAMS_T add_topic_params = { .topic_path = topic_name, .details = string_topic_details, .on_topic_added = on_topic_added, .on_topic_add_failed = on_topic_add_failed, .on_discard = on_topic_add_discard, }; apr_thread_mutex_lock(mutex); add_topic(session, add_topic_params); apr_thread_cond_wait(cond, mutex); apr_thread_mutex_unlock(mutex); topic_details_free(string_topic_details); /* * Define the handlers for add_update_source() */ const UPDATE_SOURCE_REGISTRATION_PARAMS_T update_reg_params = { .topic_path = topic_name, .on_init = on_update_source_init, .on_registered = on_update_source_registered, .on_active = on_update_source_active, .on_standby = on_update_source_standby, .on_close = on_update_source_closed }; /* * Register an updater. */ apr_thread_mutex_lock(mutex); CONVERSATION_ID_T *updater_id = register_update_source(session, update_reg_params); apr_thread_cond_wait(cond, mutex); apr_thread_mutex_unlock(mutex); /* * Define default parameters for an update source. */ UPDATE_SOURCE_PARAMS_T update_source_params_base = { .updater_id = updater_id, .topic_path = topic_name, .on_success = on_update_success, .on_failure = on_update_failure }; time_t end_time = time(NULL) + seconds; while(time(NULL) < end_time) { if(active) { /* * Create an update structure containing the current time. */ BUF_T *buf = buf_create(); const time_t time_now = time(NULL); buf_write_string(buf, ctime(&time_now)); CONTENT_T *content = content_create(CONTENT_ENCODING_NONE, buf); UPDATE_T *upd = update_create(UPDATE_ACTION_REFRESH, UPDATE_TYPE_CONTENT, content); UPDATE_SOURCE_PARAMS_T update_source_params = update_source_params_base; update_source_params.update = upd; /* * Update the topic. */ update(session, update_source_params); content_free(content); update_free(upd); buf_free(buf); } sleep(1); } if(active) { UPDATE_SOURCE_DEREGISTRATION_PARAMS_T update_dereg_params = { .updater_id = updater_id, .on_deregistered = on_update_source_deregistered }; apr_thread_mutex_lock(mutex); deregister_update_source(session, update_dereg_params); apr_thread_cond_wait(cond, mutex); apr_thread_mutex_unlock(mutex); } /* * Close session and free resources. */ session_close(session, NULL); session_free(session); conversation_id_free(updater_id); credentials_free(credentials); apr_thread_mutex_destroy(mutex); apr_thread_cond_destroy(cond); apr_pool_destroy(pool); apr_terminate(); return EXIT_SUCCESS; }
SWITCH_DECLARE(switch_status_t) switch_thread_cond_destroy(switch_thread_cond_t *cond) { return apr_thread_cond_destroy(cond); }
LLCondition::~LLCondition() { apr_thread_cond_destroy(mAPRCondp); mAPRCondp = NULL; }