vl_thread_pool.h

Go to the documentation of this file.

 
#ifndef VL_THREAD_POOL_H
#define VL_THREAD_POOL_H
 
#include "vl_async_queue.h"
#include "vl_atomic.h"
#include "vl_condition.h"
#include "vl_mutex.h"
#include "vl_numtypes.h"
#include "vl_semaphore.h"
#include "vl_thread.h"
 
typedef enum
{
    VL_THREAD_POOL_PRIORITY_HIGH = 0, 
    VL_THREAD_POOL_PRIORITY_MEDIUM = 1, 
    VL_THREAD_POOL_PRIORITY_LOW = 2, 
    VL_THREAD_POOL_PRIORITY_COUNT = 3 
} vl_thread_pool_priority;
 
typedef enum
{
    VL_THREAD_POOL_RUNNING = 0,
    VL_THREAD_POOL_SHUTTING_DOWN = 1,
    VL_THREAD_POOL_SHUT_DOWN = 2
} vl_thread_pool_state;
 
typedef void (*vl_thread_pool_task_proc)(void* user_data);
 
typedef struct
{
    vl_thread_pool_task_proc proc;
    void* user_data;
} vl_thread_pool_task;
 
typedef struct vl_thread_pool_
{
    /* Work queues per priority tier */
    vl_async_queue* workQueues[VL_THREAD_POOL_PRIORITY_COUNT];
 
    /* Semaphore per tier: counts available work at that priority */
    vl_semaphore semaphores[VL_THREAD_POOL_PRIORITY_COUNT];
 
    /* Worker thread management */
    vl_thread* workers;
    vl_uint_t workerCount;
 
    /* State & statistics */
    VL_ATOMIC vl_thread_pool_state state;
    VL_ATOMIC vl_ularge_t tasksCompleted;
 
    /* Idle synchronization: for vlThreadPoolWait() */
    vl_condition all_idle;
    vl_mutex idle_lock;
    VL_ATOMIC vl_uint_t active_workers;
} vl_thread_pool;
 
typedef struct
{
    vl_ularge_t tasks_completed;
    vl_uint32_t tasksPending[VL_THREAD_POOL_PRIORITY_COUNT];
    vl_uint_t worker_count;
} vl_thread_pool_stats;
 
VL_API vl_thread_pool* vlThreadPoolNew(vl_uint_t worker_count);
 
VL_API void vlThreadPoolDelete(vl_thread_pool* pool);
 
VL_API vl_bool_t vlThreadPoolEnqueuePriority(vl_thread_pool* pool, vl_thread_pool_priority priority,
                                             const vl_thread_pool_task* task);
 
VL_API vl_uint_t vlThreadPoolEnqueueBatchPriority(vl_thread_pool* pool, vl_thread_pool_priority priority,
                                                  const vl_thread_pool_task* tasks, vl_uint_t count);
 
static inline vl_bool_t vlThreadPoolEnqueue(vl_thread_pool* pool, const vl_thread_pool_task* task)
{
    return vlThreadPoolEnqueuePriority(pool, VL_THREAD_POOL_PRIORITY_MEDIUM, task);
}
 
static inline vl_uint_t vlThreadPoolEnqueueBatch(vl_thread_pool* pool, const vl_thread_pool_task* tasks,
                                                 vl_uint_t count)
{
    return vlThreadPoolEnqueueBatchPriority(pool, VL_THREAD_POOL_PRIORITY_MEDIUM, tasks, count);
}
 
VL_API vl_bool_t vlThreadPoolWait(vl_thread_pool* pool, vl_uint_t timeout_ms);
 
VL_API void vlThreadPoolShutdown(vl_thread_pool* pool);
 
VL_API void vlThreadPoolGetStats(vl_thread_pool* pool, vl_thread_pool_stats* out_stats);
 
static inline vl_uint32_t vlThreadPoolQueueDepth(vl_thread_pool* pool)
{
    vl_thread_pool_stats stats;
    vlThreadPoolGetStats(pool, &stats);
    return stats.tasksPending[0] + stats.tasksPending[1] + stats.tasksPending[2];
}
 
#endif // VL_THREAD_POOL_H