ThreadPool.h

Go to the documentation of this file.

/*******************************************************************************
 *
 * Copyright (c) 2000-2003 Intel Corporation 
 * All rights reserved. 
 * Copyright (c) 2012 France Telecom All rights reserved. 
 *
 * Redistribution and use in source and binary forms, with or without 
 * modification, are permitted provided that the following conditions are met: 
 *
 * * Redistributions of source code must retain the above copyright notice, 
 * this list of conditions and the following disclaimer. 
 * * Redistributions in binary form must reproduce the above copyright notice, 
 * this list of conditions and the following disclaimer in the documentation 
 * and/or other materials provided with the distribution. 
 * * Neither name of Intel Corporation nor the names of its contributors 
 * may be used to endorse or promote products derived from this software 
 * without specific prior written permission.
 * 
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL INTEL OR 
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY 
 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 ******************************************************************************/
 
#ifndef THREADPOOL_H
#define THREADPOOL_H
 
#include "FreeList.h"
#include "ithread.h"
#include "LinkedList.h"
#include "UpnpInet.h"
#include "UpnpGlobal.h" /* for UPNP_INLINE, EXPORT_SPEC */
 
#include <errno.h>
 
#ifdef _WIN32
        #include <time.h>
        struct timezone
        {
                int  tz_minuteswest; /* minutes W of Greenwich */
                int  tz_dsttime;     /* type of dst correction */
        };
        int gettimeofday(struct timeval *tv, struct timezone *tz);
#else /* _WIN32 */
        #include <sys/param.h>
        #include <sys/time.h> /* for gettimeofday() */
        #if defined(__OSX__) || defined(__APPLE__) || defined(__NetBSD__)
                #include <sys/resource.h>       /* for setpriority() */
        #endif
#endif
 
#ifdef __cplusplus
extern "C" {
#endif
 
#define JOBFREELISTSIZE 100
 
#define INFINITE_THREADS -1
 
#define EMAXTHREADS (-8 & 1<<29)
 
#define INVALID_POLICY (-9 & 1<<29)
 
#define INVALID_JOB_ID (-2 & 1<<29)
 
typedef enum duration {
        SHORT_TERM,
        PERSISTENT
} Duration;
 
typedef enum priority {
        LOW_PRIORITY,
        MED_PRIORITY,
        HIGH_PRIORITY
} ThreadPriority;
 
#define DEFAULT_PRIORITY MED_PRIORITY
 
#define DEFAULT_MIN_THREADS 1
 
#define DEFAULT_MAX_THREADS 10
 
#define DEFAULT_STACK_SIZE 0u
 
#define DEFAULT_JOBS_PER_THREAD 10
 
#define DEFAULT_STARVATION_TIME 500
 
#define DEFAULT_IDLE_TIME 10 * 1000
 
#define DEFAULT_FREE_ROUTINE NULL
 
#define DEFAULT_MAX_JOBS_TOTAL 100
 
#define STATS 1
 
#ifdef _DEBUG
        #define DEBUG 1
#endif
 
typedef int PolicyType;
 
#define DEFAULT_POLICY SCHED_OTHER
 
typedef void (*free_routine)(void *arg);
 
 
typedef struct THREADPOOLATTR
{
        int minThreads;
        int maxThreads;
        size_t stackSize;
        int maxIdleTime;
        int jobsPerThread;
        int maxJobsTotal;
        int starvationTime;
        PolicyType schedPolicy;
} ThreadPoolAttr;
 
typedef struct THREADPOOLJOB
{
        start_routine func;
        void *arg;
        free_routine free_func;
        struct timeval requestTime;
        ThreadPriority priority;
        int jobId;
} ThreadPoolJob;
 
typedef struct TPOOLSTATS
{
        double totalTimeHQ;
        int totalJobsHQ;
        double avgWaitHQ;
        double totalTimeMQ;
        int totalJobsMQ;
        double avgWaitMQ;
        double totalTimeLQ;
        int totalJobsLQ;
        double avgWaitLQ;
        double totalWorkTime;
        double totalIdleTime;
        int workerThreads;
        int idleThreads;
        int persistentThreads;
        int totalThreads;
        int maxThreads;
        int currentJobsHQ;
        int currentJobsLQ;
        int currentJobsMQ;
} ThreadPoolStats;
 
typedef struct THREADPOOL
{
        ithread_mutex_t mutex;
        ithread_cond_t condition;
        ithread_cond_t start_and_shutdown;
        int lastJobId;
        int shutdown;
        int totalThreads;
        int pendingWorkerThreadStart;
        int busyThreads;
        int persistentThreads;
        FreeList jobFreeList;
        LinkedList lowJobQ;
        LinkedList medJobQ;
        LinkedList highJobQ;
        ThreadPoolJob *persistentJob;
        ThreadPoolAttr attr;
        ThreadPoolStats stats;
} ThreadPool;
 
int ThreadPoolInit(
        ThreadPool *tp,
        ThreadPoolAttr *attr);
 
int ThreadPoolAddPersistent(
        ThreadPool*tp,
        ThreadPoolJob *job,
        int *jobId);
 
int ThreadPoolGetAttr(
        ThreadPool *tp,
        ThreadPoolAttr *out);
 
int ThreadPoolSetAttr(
        ThreadPool *tp,
        ThreadPoolAttr *attr);
 
int ThreadPoolAdd(
        ThreadPool*tp,
        ThreadPoolJob *job,
        int *jobId);
 
int ThreadPoolRemove(
        ThreadPool *tp,
        int jobId,
        ThreadPoolJob *out);
 
int ThreadPoolShutdown(
        ThreadPool *tp);
 
int TPJobInit(
        ThreadPoolJob *job,
        start_routine func,
        void *arg);
 
int TPJobSetPriority(
        ThreadPoolJob *job,
        ThreadPriority priority);
 
int TPJobSetFreeFunction(
        ThreadPoolJob *job,
        free_routine func);
 
int TPAttrInit(
        ThreadPoolAttr *attr);
 
int TPAttrSetMaxThreads(
        ThreadPoolAttr *attr,
        int maxThreads);
 
int TPAttrSetMinThreads(
        ThreadPoolAttr *attr,
        int minThreads);
 
int TPAttrSetStackSize(
        ThreadPoolAttr *attr,
        size_t stackSize);
 
int TPAttrSetIdleTime(
        ThreadPoolAttr *attr,
        int idleTime);
 
int TPAttrSetJobsPerThread(
        ThreadPoolAttr *attr,
        int jobsPerThread);
 
int TPAttrSetStarvationTime(
        ThreadPoolAttr *attr,
        int starvationTime);
 
int TPAttrSetSchedPolicy(
        ThreadPoolAttr *attr,
        PolicyType schedPolicy);
 
int TPAttrSetMaxJobsTotal(
        ThreadPoolAttr *attr,
        int maxJobsTotal);
 
#ifdef STATS
        EXPORT_SPEC int ThreadPoolGetStats(
                ThreadPool *tp,
                ThreadPoolStats *stats);
#else
        static UPNP_INLINE int ThreadPoolGetStats(
                ThreadPool *tp,
                ThreadPoolStats *stats) {}
#endif
 
#ifdef STATS
        EXPORT_SPEC void ThreadPoolPrintStats(
                ThreadPoolStats *stats);
#else
        static UPNP_INLINE void ThreadPoolPrintStats(
                ThreadPoolStats *stats) {}
#endif
 
#ifdef __cplusplus
}
#endif
 
#endif /* THREADPOOL_H */