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 "LinkedList.h"
#include "UpnpGlobal.h" /* for UPNP_INLINE, UPNP_EXPORT_SPEC */
#include "UpnpInet.h"
#include "ithread.h"
 
#include <errno.h>
 
#ifdef _WIN32
        #include <time.h>
 
        #ifndef _TIMEZONE_DEFINED
struct timezone
{
        int tz_minuteswest; /* minutes W of Greenwich */
        int tz_dsttime;     /* type of dst correction */
};
        #endif
int gettimeofday(struct timeval *tv, struct timezone *tz);
#else /* _WIN32 */
        #include <sys/param.h>
        #include <sys/time.h> /* for gettimeofday() */
        #if 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 1000
extern int maxJobsTotal;

#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;
        long droppedJobs;
} 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;

void TPSetMaxJobsTotal(int mjt);

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
UPNP_EXPORT_SPEC int ThreadPoolGetStats(
        ThreadPool *tp,
        ThreadPoolStats *stats);
#else
static UPNP_INLINE int ThreadPoolGetStats(
        ThreadPool *tp,
        ThreadPoolStats *stats)
{
}
#endif

#ifdef STATS
UPNP_EXPORT_SPEC void ThreadPoolPrintStats(
        ThreadPoolStats *stats);
#else
static UPNP_INLINE void ThreadPoolPrintStats(
        ThreadPoolStats *stats)
{
}
#endif
 
#ifdef __cplusplus
}
#endif
 
#endif /* THREADPOOL_H */