void assoc_init(void) {
cb_cond_initialize(&maintenance_cond);
primary_hashtable = calloc(hashsize(hashpower), sizeof(void *));
if (! primary_hashtable) {
moxi_log_write("Failed to init hashtable.\n");
exit(EXIT_FAILURE);
}
}
/** The "work_collect" abstraction helps to make scatter/gather easier
* when using work queue's. The main caller uses work_collect_init()
* to initialize the work_collect tracking data structure. The
* work_collect structure is then scattered across worker threads
* (such as by using work_send()). The main thread then calls
* work_collect_wait() to wait for N responses. A worker thread
* invokes work_collect_one() when it's finished with its assigned
* work and has one response to contribute. When N responses have
* been counted, work_collect_wait() returns control back to the
* main caller.
*/
int work_collect_init(work_collect *c, int count, void *data) {
cb_assert(c);
memset(c, 0, sizeof(work_collect));
c->count = count;
c->data = data;
cb_mutex_initialize(&c->collect_lock);
cb_cond_initialize(&c->collect_cond);
return 0;
}
/*
* Initializes the thread subsystem, creating various worker threads.
*
* nthreads Number of worker event handler threads to spawn
* main_base Event base for main thread
*/
void thread_init(int nthr, struct event_base *main_base,
void (*dispatcher_callback)(evutil_socket_t, short, void *)) {
int i;
nthreads = nthr + 1;
cqi_freelist = NULL;
cb_mutex_initialize(&conn_lock);
cb_mutex_initialize(&cqi_freelist_lock);
cb_mutex_initialize(&init_lock);
cb_cond_initialize(&init_cond);
threads = calloc(nthreads, sizeof(LIBEVENT_THREAD));
if (! threads) {
settings.extensions.logger->log(EXTENSION_LOG_WARNING, NULL,
"Can't allocate thread descriptors: %s",
strerror(errno));
exit(1);
}
thread_ids = calloc(nthreads, sizeof(cb_thread_t));
if (! thread_ids) {
settings.extensions.logger->log(EXTENSION_LOG_WARNING, NULL,
"Can't allocate thread descriptors: %s",
strerror(errno));
exit(1);
}
setup_dispatcher(main_base, dispatcher_callback);
for (i = 0; i < nthreads; i++) {
if (!create_notification_pipe(&threads[i])) {
exit(1);
}
threads[i].index = i;
setup_thread(&threads[i]);
}
/* Create threads after we've done all the libevent setup. */
for (i = 0; i < nthreads; i++) {
create_worker(worker_libevent, &threads[i], &thread_ids[i]);
threads[i].thread_id = thread_ids[i];
}
/* Wait for all the threads to set themselves up before returning. */
cb_mutex_enter(&init_lock);
while (init_count < nthreads) {
cb_cond_wait(&init_cond, &init_lock);
}
cb_mutex_exit(&init_lock);
}
/*
* Initializes a connection queue.
*/
static void cq_init(CQ *cq) {
cb_mutex_initialize(&cq->lock);
cb_cond_initialize(&cq->cond);
cq->head = NULL;
cq->tail = NULL;
}
