threadpool.c File Reference

#include "gwion_util.h"

Go to the source code of this file.

Data Structures
struct	task_t
struct	threadpool_t

Functions
static ANN gwtreturn_t	threadpool_thread (void *data)
static ANN bool	alloc (threadpool_t *p, const uint32_t thread_count, const uint32_t queue_size)
static ANN bool	utils (threadpool_t *p)
static ANN bool	start (threadpool_t *p, const uint32_t thread_count)
	ANN2 (1, 2)
bool	threadpool_add (threadpool_t *p, void(*routine)(void *), void *arg)
ANN void	free_threadpool (threadpool_t *p)
threadpool_t *	new_threadpool (const uint32_t thread_count, const uint32_t queue_size)

Function Documentation

alloc()

static ANN bool alloc ( threadpool_t * p, const uint32_t thread_count, const uint32_t queue_size )

static

Definition at line 40 of file threadpool.c.

                               {
  return !(p->threads = malloc(thread_count * sizeof(gwtthread_t))) ||
         !(p->queue = malloc(queue_size * sizeof(task_t)));
}

ANN2()

ANN2	(	1	,
		2	)

Definition at line 66 of file threadpool.c.

                                                                                   {
  if(unlikely(pool->shutdown || pool->active == pool->queue_size))
   return false;
  const uint32_t next = (pool->tail + 1) % pool->queue_size;
  task_t t = { .routine = routine, .arg = arg };
  pool->queue[pool->tail] = t;
  pool->tail = next;
  pool->active++;
  (void)gwt_signal(&pool->cond);
  return true;
}

free_threadpool()

ANN void free_threadpool

(

threadpool_t *

p

)

Definition at line 85 of file threadpool.c.

                                          {
  (void)gwt_lock(&p->lock);
  p->shutdown = true;
  gwt_broadcast(&p->cond);
  (void)gwt_unlock(&p->lock);
  if(p->threads) {
    for(uint32_t i = 0; i < p->started; i++)
      gwt_join(p->threads[i]);
    free(p->threads);
  }
  if(p->queue) free(p->queue);
  if(p->has_lock) gwt_lock_end(&p->lock);
  if(p->has_cond) gwt_cond_end(&p->cond);
  free(p);
}

new_threadpool()

threadpool_t * new_threadpool	(	const uint32_t	thread_count,
		const uint32_t	queue_size )

Definition at line 101 of file threadpool.c.

                                                                                     {
  threadpool_t *p = malloc(sizeof(threadpool_t));
  if(!p) return NULL;
  p->head = p->tail = p->active = 0;
  p->shutdown = p->has_lock = p->has_cond = false;
  p->started = 0;
  p->queue_size = queue_size;
  if(alloc(p, thread_count, queue_size) || !utils(p) ||
     !start(p, thread_count)) {
    free_threadpool(p);
    return NULL;
  }
  return p;
}

start()

static ANN bool start ( threadpool_t * p, const uint32_t thread_count )

static

Definition at line 57 of file threadpool.c.

                                                                    {
  for(uint32_t i = 0; i < thread_count; i++) {
    const int ret = gwt_create(&p->threads[i], threadpool_thread, p);
    if(ret) return false;
    p->started++;
  }
  return true;
}

threadpool_add()

bool threadpool_add	(	threadpool_t *	p,
		void(*	routine )(void *),
		void *	arg )

Definition at line 78 of file threadpool.c.

                                                                         {
  (void)gwt_lock(&p->lock);
  const bool ret = add(p, routine, arg);
  (void)gwt_unlock(&p->lock);
  return ret;
}

threadpool_thread()

static ANN gwtreturn_t threadpool_thread ( void * data )

static

Definition at line 23 of file threadpool.c.

                                                     {
  threadpool_t *p = (threadpool_t *)data;
  while(true) {
    (void)gwt_lock(&p->lock);
    while(!p->active && !p->shutdown)
      (void)gwt_wait(&p->cond, &p->lock);
    if(p->shutdown) break;
    task_t task = p->queue[p->head];
    p->head = (p->head + 1) % p->queue_size;
    p->active--;
    (void)gwt_unlock(&p->lock);
    task.routine(task.arg);
  }
  (void)gwt_unlock(&p->lock);
  THREAD_RETURN(NULL);
}

utils()

static ANN bool utils ( threadpool_t * p )

static

Definition at line 46 of file threadpool.c.

                                       {
#ifdef BUILD_ON_WINDOWS
  p->lock = NULL;
#endif
  if(gwt_lock_ini(&p->lock)) return false;
  p->has_lock = true;
  if(gwt_cond_ini(&p->cond)) return false;
  p->has_cond = true;
  return true;
}