Add thread support
This commit is contained in:
219
src/thread.c
Normal file
219
src/thread.c
Normal file
@@ -0,0 +1,219 @@
|
||||
#include <bh/internal/thread.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
bh_task_t *bh_task_new(void (*func)(void *),
|
||||
void *data,
|
||||
int flags)
|
||||
{
|
||||
bh_task_t *result;
|
||||
|
||||
result = malloc(sizeof(bh_task_t));
|
||||
if (result)
|
||||
bh_task_init(result, func, data, flags);
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
void bh_task_free(bh_task_t *task)
|
||||
{
|
||||
bh_task_destroy(task);
|
||||
free(task);
|
||||
}
|
||||
|
||||
void bh_task_init(bh_task_t *task,
|
||||
void (*func)(void *),
|
||||
void *data,
|
||||
int flags)
|
||||
{
|
||||
task->func = func;
|
||||
task->data = data;
|
||||
task->flags = flags;
|
||||
}
|
||||
|
||||
void bh_task_destroy(bh_task_t *task)
|
||||
{
|
||||
(void)task;
|
||||
}
|
||||
|
||||
void bh_task_reuse(bh_task_t *task,
|
||||
void (*func)(void *),
|
||||
void *data)
|
||||
{
|
||||
if (task->flags & BH_THREAD_DONE)
|
||||
bh_task_init(task, func, data, task->flags & ~(BH_THREAD_DONE));
|
||||
}
|
||||
|
||||
int bh_task_done(bh_task_t *task)
|
||||
{
|
||||
return (task->flags & BH_THREAD_DONE) != 0;
|
||||
}
|
||||
|
||||
bh_mutex_t *bh_mutex_new(void)
|
||||
{
|
||||
bh_mutex_t *result;
|
||||
|
||||
result = malloc(sizeof(*result));
|
||||
if (result && bh_mutex_init(result))
|
||||
{
|
||||
free(result);
|
||||
result = NULL;
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
void bh_mutex_free(bh_mutex_t *mutex)
|
||||
{
|
||||
bh_mutex_destroy(mutex);
|
||||
free(mutex);
|
||||
}
|
||||
|
||||
bh_cond_t *bh_cond_new(void)
|
||||
{
|
||||
bh_cond_t *result;
|
||||
|
||||
result = malloc(sizeof(*result));
|
||||
if (result && bh_cond_init(result))
|
||||
{
|
||||
free(result);
|
||||
result = NULL;
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
void bh_cond_free(bh_cond_t *cond)
|
||||
{
|
||||
bh_cond_destroy(cond);
|
||||
free(cond);
|
||||
}
|
||||
|
||||
int bh_thread_pool_add(bh_thread_pool_t *pool,
|
||||
bh_task_t *task)
|
||||
{
|
||||
void *iter;
|
||||
bh_task_t *item;
|
||||
|
||||
/* Queue task for execution */
|
||||
bh_mutex_lock(&pool->lock);
|
||||
if (bh_queue_insert(&pool->tasks, task))
|
||||
{
|
||||
bh_mutex_unlock(&pool->lock);
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* Signal new job */
|
||||
bh_mutex_unlock(&pool->lock);
|
||||
bh_cond_signal(&pool->new_task);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int bh_thread_pool_wait(bh_thread_pool_t *pool)
|
||||
{
|
||||
/* Lock and check if there is jobs in the queue */
|
||||
bh_mutex_lock(&pool->lock);
|
||||
while (!bh_queue_empty(&pool->tasks))
|
||||
{
|
||||
bh_task_t *task;
|
||||
|
||||
/* Fetch task from the queue */
|
||||
task = bh_queue_front(&pool->tasks);
|
||||
bh_queue_remove(&pool->tasks);
|
||||
|
||||
/* Unlock and do the task */
|
||||
bh_mutex_unlock(&pool->lock);
|
||||
|
||||
task->func(task->data);
|
||||
task->flags |= BH_THREAD_DONE;
|
||||
if (task->flags & BH_THREAD_CLEANUP)
|
||||
bh_task_free(task);
|
||||
|
||||
/* Lock and check for the next task */
|
||||
bh_mutex_lock(&pool->lock);
|
||||
}
|
||||
|
||||
/* Check until there is no active threads */
|
||||
while (pool->active)
|
||||
bh_cond_wait(&pool->done_task, &pool->lock);
|
||||
|
||||
/* Unlock */
|
||||
bh_mutex_unlock(&pool->lock);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
void bh_thread_pool_destroy(bh_thread_pool_t *pool)
|
||||
{
|
||||
size_t i;
|
||||
|
||||
/* Broadcast shutdown */
|
||||
pool->shutdown = 1;
|
||||
bh_cond_broadcast(&pool->new_task);
|
||||
|
||||
/* Join and delete every thread */
|
||||
for (i = 0; i < pool->size; i++)
|
||||
bh_thread_join(pool->threads + i);
|
||||
|
||||
/* Destroy any tasks with cleanup flag */
|
||||
while (!bh_queue_empty(&pool->tasks))
|
||||
{
|
||||
bh_task_t *task;
|
||||
|
||||
task = bh_queue_front(&pool->tasks);
|
||||
bh_queue_remove(&pool->tasks);
|
||||
|
||||
if (task->flags & BH_THREAD_CLEANUP)
|
||||
bh_task_free(task);
|
||||
}
|
||||
|
||||
/* Destroy thread array, queue, lock and condition variables */
|
||||
free(pool->threads);
|
||||
bh_queue_destroy(&pool->tasks);
|
||||
bh_cond_destroy(&pool->new_task);
|
||||
bh_cond_destroy(&pool->done_task);
|
||||
bh_mutex_destroy(&pool->lock);
|
||||
}
|
||||
|
||||
void bh_thread_pool_free(bh_thread_pool_t *pool)
|
||||
{
|
||||
bh_thread_pool_destroy(pool);
|
||||
free(pool);
|
||||
}
|
||||
|
||||
void bh_thread_pool_worker(void *arg)
|
||||
{
|
||||
bh_thread_pool_t *pool;
|
||||
|
||||
pool = (bh_thread_pool_t *)arg;
|
||||
while (1)
|
||||
{
|
||||
bh_task_t *task;
|
||||
|
||||
bh_mutex_lock(&pool->lock);
|
||||
while (!pool->shutdown && bh_queue_empty(&pool->tasks))
|
||||
bh_cond_wait(&pool->new_task, &pool->lock);
|
||||
|
||||
if (pool->shutdown)
|
||||
{
|
||||
bh_mutex_unlock(&pool->lock);
|
||||
break;
|
||||
}
|
||||
|
||||
task = bh_queue_front(&pool->tasks);
|
||||
bh_queue_remove(&pool->tasks);
|
||||
pool->active++;
|
||||
bh_mutex_unlock(&pool->lock);
|
||||
|
||||
task->func(task->data);
|
||||
task->flags |= BH_THREAD_DONE;
|
||||
if (task->flags & BH_THREAD_CLEANUP)
|
||||
bh_task_free(task);
|
||||
|
||||
bh_mutex_lock(&pool->lock);
|
||||
pool->active--;
|
||||
|
||||
bh_mutex_unlock(&pool->lock);
|
||||
bh_cond_broadcast(&pool->done_task);
|
||||
}
|
||||
}
|
||||
182
src/thread_posix.c
Normal file
182
src/thread_posix.c
Normal file
@@ -0,0 +1,182 @@
|
||||
#include <bh/internal/thread.h>
|
||||
#include <string.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
static void *bh_thread_run(void *arg)
|
||||
{
|
||||
bh_task_t *task;
|
||||
|
||||
task = (bh_task_t *)arg;
|
||||
|
||||
task->func(task->data);
|
||||
task->flags |= BH_THREAD_DONE;
|
||||
|
||||
if (task->flags & BH_THREAD_CLEANUP)
|
||||
bh_task_free(task);
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
int bh_thread_init(bh_thread_t *thread,
|
||||
bh_task_t *task)
|
||||
{
|
||||
return pthread_create(&thread->handle, NULL, bh_thread_run, task);
|
||||
}
|
||||
|
||||
int bh_thread_join(bh_thread_t *thread)
|
||||
{
|
||||
return pthread_join(thread->handle, NULL);
|
||||
}
|
||||
|
||||
int bh_thread_detach(bh_thread_t *thread)
|
||||
{
|
||||
return pthread_detach(thread->handle);
|
||||
}
|
||||
|
||||
int bh_mutex_init(bh_mutex_t *mutex)
|
||||
{
|
||||
return pthread_mutex_init(&mutex->handle, NULL);
|
||||
}
|
||||
|
||||
void bh_mutex_destroy(bh_mutex_t *mutex)
|
||||
{
|
||||
pthread_mutex_destroy(&mutex->handle);
|
||||
}
|
||||
|
||||
int bh_mutex_lock(bh_mutex_t *mutex)
|
||||
{
|
||||
return pthread_mutex_lock(&mutex->handle);
|
||||
}
|
||||
|
||||
int bh_mutex_try_lock(bh_mutex_t *mutex)
|
||||
{
|
||||
return pthread_mutex_trylock(&mutex->handle);
|
||||
}
|
||||
|
||||
int bh_mutex_unlock(bh_mutex_t *mutex)
|
||||
{
|
||||
return pthread_mutex_unlock(&mutex->handle);
|
||||
}
|
||||
|
||||
int bh_cond_init(bh_cond_t *cond)
|
||||
{
|
||||
return pthread_cond_init(&cond->handle, NULL);
|
||||
}
|
||||
|
||||
void bh_cond_destroy(bh_cond_t *cond)
|
||||
{
|
||||
pthread_cond_destroy(&cond->handle);
|
||||
}
|
||||
|
||||
int bh_cond_wait(bh_cond_t *cond,
|
||||
bh_mutex_t *mutex)
|
||||
{
|
||||
return pthread_cond_wait(&cond->handle, &mutex->handle);
|
||||
}
|
||||
|
||||
int bh_cond_wait_for(bh_cond_t *cond,
|
||||
bh_mutex_t *mutex,
|
||||
unsigned long timeout)
|
||||
{
|
||||
struct timespec ts;
|
||||
|
||||
ts.tv_sec = timeout / 1000;
|
||||
ts.tv_nsec = (timeout - ts.tv_sec * 1000) * 1000000;
|
||||
|
||||
return pthread_cond_timedwait(&cond->handle, &mutex->handle, &ts);
|
||||
}
|
||||
|
||||
int bh_cond_signal(bh_cond_t *cond)
|
||||
{
|
||||
return pthread_cond_signal(&cond->handle);
|
||||
}
|
||||
|
||||
int bh_cond_broadcast(bh_cond_t *cond)
|
||||
{
|
||||
return pthread_cond_broadcast(&cond->handle);
|
||||
}
|
||||
|
||||
int bh_thread_pool_init(bh_thread_pool_t *pool,
|
||||
size_t size)
|
||||
{
|
||||
size_t i;
|
||||
static bh_task_t pool_task;
|
||||
static int pool_task_init = 0;
|
||||
|
||||
/* Initialize static thread pool task */
|
||||
if (!pool_task_init)
|
||||
{
|
||||
bh_task_init(&pool_task, bh_thread_pool_worker, pool, 0);
|
||||
pool_task_init = 1;
|
||||
}
|
||||
|
||||
/* Zero out pool structure */
|
||||
memset(pool, 0, sizeof(*pool));
|
||||
|
||||
/* Initialize mutex and condition variables */
|
||||
if (bh_mutex_init(&pool->lock))
|
||||
goto lock_fail;
|
||||
|
||||
if (bh_cond_init(&pool->new_task))
|
||||
goto task_fail;
|
||||
|
||||
if (bh_cond_init(&pool->done_task))
|
||||
goto done_fail;
|
||||
|
||||
/* Allocate array of threads */
|
||||
pool->threads = malloc(size * sizeof(bh_thread_t));
|
||||
pool->size = size;
|
||||
|
||||
if (!pool->threads)
|
||||
goto thread_fail;
|
||||
|
||||
/* Initialize queue */
|
||||
bh_queue_init(&pool->tasks);
|
||||
if (bh_queue_reserve(&pool->tasks, 64))
|
||||
goto queue_fail;
|
||||
|
||||
/* Initialize threads */
|
||||
for (i = 0; i < size; i++)
|
||||
{
|
||||
if (bh_thread_init(&pool->threads[i], &pool_task))
|
||||
{
|
||||
pool->shutdown = 1;
|
||||
bh_cond_broadcast(&pool->new_task);
|
||||
for(; i; i--)
|
||||
bh_thread_join(&pool->threads[i - 1]);
|
||||
|
||||
bh_queue_destroy(&pool->tasks);
|
||||
goto queue_fail;
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
|
||||
queue_fail:
|
||||
free(pool->threads);
|
||||
|
||||
thread_fail:
|
||||
bh_cond_destroy(&pool->done_task);
|
||||
|
||||
done_fail:
|
||||
bh_cond_destroy(&pool->new_task);
|
||||
|
||||
task_fail:
|
||||
bh_mutex_destroy(&pool->lock);
|
||||
|
||||
lock_fail:
|
||||
return -1;
|
||||
}
|
||||
|
||||
bh_thread_pool_t *bh_thread_pool_new(size_t size)
|
||||
{
|
||||
bh_thread_pool_t *result;
|
||||
result = malloc(sizeof(*result));
|
||||
if (result && bh_thread_pool_init(result, size))
|
||||
{
|
||||
free(result);
|
||||
result = NULL;
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
Reference in New Issue
Block a user