static void *worker_thr_routine(void *data)
{
struct threadpool *pool = (struct threadpool*)data;
struct threadpool_task *task;
while (1) {
task = threadpool_task_get_task(pool);
if (task == NULL) {
if (pool->stop_flag) {
break;
}
else {
DEMO_THREAD_Print("Warning an error has occurred when trying to obtain a worker task.");
DEMO_THREAD_Print("The worker thread has exited.");
break;
}
}
if (task->routine_cb) {
task->routine_cb(task->data);
threadpool_task_init(task);
if (pthread_mutex_lock(&(pool->free_tasks_mutex))) {
perror("pthread_mutex_lock: ");
DEMO_THREAD_Print("The worker thread has exited.");
break;
}
if (threadpool_queue_enqueue(&(pool->free_tasks_queue),task)) {
DEMO_THREAD_Print("Failed to enqueue a task to free tasks queue.");
if (pthread_mutex_unlock(&(pool->free_tasks_mutex))) {
perror("pthread_mutex_unlock: ");
}
DEMO_THREAD_Print("The worker thread has exited.");
break;
}
if (threadpool_queue_getsize(&(pool->free_tasks_queue)) == 1) {
if (pthread_cond_broadcast(&(pool->free_tasks_cond))) {
perror("pthread_cond_broadcast: ");
if (pthread_mutex_unlock(&(pool->free_tasks_mutex))) {
perror("pthread_mutex_unlock: ");
}
break;
}
}
if (pthread_mutex_unlock(&(pool->free_tasks_mutex))) {
perror("pthread_mutex_unlock: ");
DEMO_THREAD_Print("The worker thread has exited.");
break;
}
}
}
return NULL;
}
int threadpool_add_task(struct threadpool *pool, void (*routine)(void*), void *data, int blocking)
{
struct threadpool_task *task;
if (pool == NULL) {
REPORT_ERROR("The threadpool received as argument is NULL.");
return -1;
}
if (pthread_mutex_lock(&(pool->free_tasks_mutex))) {
perror("pthread_mutex_lock: ");
return -1;
}
/* Check if the free task queue is empty. */
while (threadpool_queue_is_empty(&(pool->free_tasks_queue))) {
if (!blocking) {
/* Return immediately if the command is non blocking. */
if (pthread_mutex_unlock(&(pool->free_tasks_mutex))) {
perror("pthread_mutex_unlock: ");
return -1;
}
return -2;
}
/* blocking is set to 1, wait until free_tasks queue has a task to obtain. */
if (pthread_cond_wait(&(pool->free_tasks_cond),&(pool->free_tasks_mutex))) {
perror("pthread_cond_wait: ");
if (pthread_mutex_unlock(&(pool->free_tasks_mutex))) {
perror("pthread_mutex_unlock: ");
}
return -1;
}
}
/* Obtain an empty task. */
if ((task = (struct threadpool_task*)threadpool_queue_dequeue(&(pool->free_tasks_queue))) == NULL) {
REPORT_ERROR("Failed to obtain an empty task from the free tasks queue.");
if (pthread_mutex_unlock(&(pool->free_tasks_mutex))) {
perror("pthread_mutex_unlock: ");
}
return -1;
}
if (pthread_mutex_unlock(&(pool->free_tasks_mutex))) {
perror("pthread_mutex_unlock: ");
return -1;
}
task->data = data;
task->routine_cb = routine;
/* Add the task, to the tasks queue. */
if (pthread_mutex_lock(&(pool->mutex))) {
perror("pthread_mutex_lock: ");
return -1;
}
if (threadpool_queue_enqueue(&(pool->tasks_queue),task)) {
REPORT_ERROR("Failed to add a new task to the tasks queue.");
if (pthread_mutex_unlock(&(pool->mutex))) {
perror("pthread_mutex_unlock: ");
}
return -1;
}
if (threadpool_queue_getsize(&(pool->tasks_queue)) == 1) {
/* Notify all worker threads that there are new jobs. */
if (pthread_cond_broadcast(&(pool->cond))) {
perror("pthread_cond_broadcast: ");
if (pthread_mutex_unlock(&(pool->mutex))) {
perror("pthread_mutex_unlock: ");
}
return -1;
}
}
if (pthread_mutex_unlock(&(pool->mutex))) {
perror("pthread_mutex_unlock: ");
return -1;
}
return 0;
}
struct threadpool* threadpool_init(int num_of_threads)
{
struct threadpool *pool;
int i;
/* Create the thread pool struct. */
if ((pool = malloc(sizeof(struct threadpool))) == NULL) {
perror("malloc: ");
return NULL;
}
pool->stop_flag = 0;
/* Init the mutex and cond vars. */
if (pthread_mutex_init(&(pool->free_tasks_mutex),NULL)) {
perror("pthread_mutex_init: ");
free(pool);
return NULL;
}
if (pthread_mutex_init(&(pool->mutex),NULL)) {
perror("pthread_mutex_init: ");
free(pool);
return NULL;
}
if (pthread_cond_init(&(pool->free_tasks_cond),NULL)) {
perror("pthread_mutex_init: ");
free(pool);
return NULL;
}
if (pthread_cond_init(&(pool->cond),NULL)) {
perror("pthread_mutex_init: ");
free(pool);
return NULL;
}
/* Init the jobs queue. */
threadpool_queue_init(&(pool->tasks_queue));
/* Init the free tasks queue. */
threadpool_queue_init(&(pool->free_tasks_queue));
/* Add all the free tasks to the free tasks queue. */
for (i = 0; i < THREAD_POOL_QUEUE_SIZE; i++) {
threadpool_task_init((pool->tasks) + i);
if (threadpool_queue_enqueue(&(pool->free_tasks_queue),(pool->tasks) + i)) {
REPORT_ERROR("Failed to a task to the free tasks queue during initialization.");
free(pool);
return NULL;
}
}
/* Create the thr_arr. */
if ((pool->thr_arr = malloc(sizeof(pthread_t) * num_of_threads)) == NULL) {
perror("malloc: ");
free(pool);
return NULL;
}
/* Start the worker threads. */
for (pool->num_of_threads = 0; pool->num_of_threads < num_of_threads; (pool->num_of_threads)++) {
if (pthread_create(&(pool->thr_arr[pool->num_of_threads]),NULL,worker_thr_routine,pool)) {
perror("pthread_create:");
threadpool_free(pool,0);
return NULL;
}
}
return pool;
}
/**
* This is the routine the worker threads do during their life.
*
* @param data Contains a pointer to the threadpool structure.
* @return NULL.
*/
static void *worker_thr_routine(void *data)
{
struct threadpool *pool = (struct threadpool*)data;
struct threadpool_task *task;
while (1) {
task = threadpool_task_get_task(pool);
if (task == NULL) {
if (pool->stop_flag) {
/* Worker thr needs to exit (thread pool was shutdown). */
break;
}
else {
/* An error has occurred. */
REPORT_ERROR("Warning an error has occurred when trying to obtain a worker task.");
REPORT_ERROR("The worker thread has exited.");
break;
}
}
/* Execute routine (if any). */
if (task->routine_cb) {
task->routine_cb(task->data);
/* Release the task by returning it to the free_task_queue. */
threadpool_task_init(task);
if (pthread_mutex_lock(&(pool->free_tasks_mutex))) {
perror("pthread_mutex_lock: ");
REPORT_ERROR("The worker thread has exited.");
break;
}
if (threadpool_queue_enqueue(&(pool->free_tasks_queue),task)) {
REPORT_ERROR("Failed to enqueue a task to free tasks queue.");
if (pthread_mutex_unlock(&(pool->free_tasks_mutex))) {
perror("pthread_mutex_unlock: ");
}
REPORT_ERROR("The worker thread has exited.");
break;
}
if (threadpool_queue_getsize(&(pool->free_tasks_queue)) == 1) {
/* Notify all waiting threads that new tasks can added. */
if (pthread_cond_broadcast(&(pool->free_tasks_cond))) {
perror("pthread_cond_broadcast: ");
if (pthread_mutex_unlock(&(pool->free_tasks_mutex))) {
perror("pthread_mutex_unlock: ");
}
break;
}
}
if (pthread_mutex_unlock(&(pool->free_tasks_mutex))) {
perror("pthread_mutex_unlock: ");
REPORT_ERROR("The worker thread has exited.");
break;
}
}
}
return NULL;
}
