cp_pooled_thread_client_interface * cp_pooled_thread_client_interface_create (cp_pooled_thread_scheduler *owner, void *client, int min_threads, int max_threads, cp_pooled_thread_report_load report_load, cp_pooled_thread_shrink shrink, cp_thread_action action, void *action_prm, cp_thread_stop_fn stop_fn, void *stop_prm) { cp_pooled_thread_client_interface *ci = calloc(1, sizeof(cp_pooled_thread_client_interface)); if (client == NULL) cp_fatal(CP_MEMORY_ALLOCATION_FAILURE, "can\'t allocate thread pool client interface"); ci->owner = owner; ci->client = client; ci->min = min_threads; ci->max = max_threads; ci->report_load = report_load; ci->shrink = shrink; ci->action = action; ci->action_prm = action_prm; ci->stop_fn = stop_fn; ci->stop_prm = stop_prm; cp_pooled_thread_scheduler_register_client(owner, ci); return ci; }
static int init_file_service(char *mimetypes_filename, char *doc_path) { int rc = 0; if ((rc = checkdir(doc_path))) { cp_fatal(rc, "can\'t open document root at [%s]", doc_path); exit(rc); } if ((rc = load_mime_types(mimetypes_filename))) { cp_fatal(rc, "can\'t load mime types from [%s], sorry", mimetypes_filename); exit(rc); } document_root = doc_path; return rc; }
cp_pooled_thread_scheduler *cp_pooled_thread_scheduler_create(cp_thread_pool *pool) { cp_pooled_thread_scheduler *scheduler = calloc(1, sizeof(cp_pooled_thread_scheduler)); if (scheduler == NULL) cp_fatal(CP_MEMORY_ALLOCATION_FAILURE, "can\'t allocate thread manager"); scheduler->pool = pool; scheduler->client_list = cp_vector_create(20); #ifdef CP_HAS_SRANDOM srandom(time(NULL)); #else srand(time(NULL)); #endif return scheduler; }
cp_thread_pool *cp_thread_pool_create(int min_size, int max_size) { int rc; cp_thread_pool *pool = calloc(1, sizeof(cp_thread_pool)); if (pool == NULL) cp_fatal(CP_MEMORY_ALLOCATION_FAILURE, "can\'t allocate thread pool structure"); pool->min_size = min_size; pool->max_size = max_size; pool->running = 1; pool->free_pool = cp_list_create(); if (pool->free_pool == NULL) cp_fatal(CP_MEMORY_ALLOCATION_FAILURE, "can\'t allocate thread pool list"); pool->in_use = cp_hashlist_create(10, cp_hash_long, cp_hash_compare_long); if (pool->in_use == NULL) cp_fatal(CP_MEMORY_ALLOCATION_FAILURE, "can\'t allocate thread pool running list"); pool->pool_lock = (cp_mutex *) malloc(sizeof(cp_mutex)); if (pool->pool_lock == NULL) { cp_error(CP_MEMORY_ALLOCATION_FAILURE, "can\'t create mutex"); goto THREAD_POOL_CREATE_CANCEL; } if ((rc = cp_mutex_init(pool->pool_lock, NULL))) { cp_error(rc, "can\'t create mutex"); goto THREAD_POOL_CREATE_CANCEL; } pool->pool_cond = (cp_cond *) malloc(sizeof(cp_cond)); if (pool->pool_cond == NULL) { cp_error(rc, "can\'t create condition variable"); cp_mutex_destroy(pool->pool_lock); free(pool->pool_lock); goto THREAD_POOL_CREATE_CANCEL; } if ((rc = cp_cond_init(pool->pool_cond, NULL))) { cp_error(rc, "can\'t create condition variable"); free(pool->pool_cond); cp_mutex_destroy(pool->pool_lock); free(pool->pool_lock); goto THREAD_POOL_CREATE_CANCEL; } for ( ; pool->size < pool->min_size; pool->size++) { cp_pooled_thread *pt = cp_pooled_thread_create(pool); if (pt == NULL) cp_fatal(CP_THREAD_CREATION_FAILURE, "can\'t create thread pool (created %d threads, minimum pool size is %d", pool->size, pool->min_size); cp_list_append(pool->free_pool, pt); } return pool; THREAD_POOL_CREATE_CANCEL: cp_list_destroy_custom(pool->free_pool, (cp_destructor_fn) cp_pooled_thread_destroy); cp_hashlist_destroy_custom(pool->in_use, NULL, (cp_destructor_fn) cp_pooled_thread_destroy); free(pool); return NULL; }