ThreadPool.hpp

Go to the documentation of this file.

#ifndef COMPA_THREADPOOL_HPP
#define COMPA_THREADPOOL_HPP
/*******************************************************************************
 *
 * Copyright (c) 2000-2003 Intel Corporation
 * All rights reserved.
 * Copyright (c) 2012 France Telecom All rights reserved.
 * Copyright (C) 2021+ GPL 3 and higher by Ingo Höft, <Ingo@Hoeft-online.de>
 * Redistribution only with this Copyright remark. Last modified: 2025-04-30
 *
 * 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.
 *
 ******************************************************************************/
// Last compare with ./Pupnp source file on 2024-10-26, ver 1.14.20
#include "LinkedList.hpp"
#include <UPnPsdk/port_sock.hpp>
 
#if defined(_WIN32) || defined(DOXYGEN_RUN)
#if !defined(_TIMEZONE_DEFINED) || defined(DOXYGEN_RUN)
struct timezone {
    int tz_minuteswest;
    int tz_dsttime;
};
int gettimeofday(struct timeval* tv, struct timezone* tz);
#endif
#else                 // _WIN32
#include <sys/time.h> /* for gettimeofday() */
#endif                // _WIN32
 
#define INVALID_JOB_ID (-2 & 1 << 29)
 
typedef void (*free_routine)(void* arg);
 
enum Duration { SHORT_TERM, PERSISTENT };
 
enum ThreadPriority { LOW_PRIORITY, MED_PRIORITY, HIGH_PRIORITY };
 
constexpr ThreadPriority DEFAULT_PRIORITY{MED_PRIORITY};
 
constexpr int DEFAULT_MIN_THREADS{1};
 
constexpr int DEFAULT_MAX_THREADS{10};
 
constexpr int DEFAULT_STACK_SIZE{0u};
 
constexpr int DEFAULT_JOBS_PER_THREAD{10};
 
constexpr int DEFAULT_STARVATION_TIME{500};
 
constexpr int DEFAULT_IDLE_TIME{10 * 1000};
 
constexpr free_routine DEFAULT_FREE_ROUTINE{nullptr};
 
constexpr int DEFAULT_MAX_JOBS_TOTAL{100};
extern int maxJobsTotal;
 
#define STATS 1
 
#ifdef _DEBUG
#define DEBUG 1
#endif
 
typedef int PolicyType;
 
#define DEFAULT_POLICY SCHED_OTHER
 
struct ThreadPoolAttr {
    int minThreads;
    int maxThreads;
    size_t stackSize;
    int maxIdleTime;
    int jobsPerThread;
    int maxJobsTotal;
    int starvationTime;
    PolicyType schedPolicy;
};
 
struct ThreadPoolJob {
    UPnPsdk::start_routine func;
    void* arg;
    free_routine free_func;
    struct timeval requestTime;
    ThreadPriority priority;
    int jobId;
};
 
struct ThreadPoolStats {
    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;
};
 
struct ThreadPool {
    pthread_mutex_t mutex;
    pthread_cond_t condition;
    pthread_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;
};
 
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,
    UPnPsdk::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 totalMaxJobs);
 
#if defined(STATS) || defined(DOXYGEN_RUN)
int ThreadPoolGetStats(
    ThreadPool* tp,
    ThreadPoolStats* stats);
#else
static inline int ThreadPoolGetStats(
    ThreadPool* tp,
    ThreadPoolStats* stats) {}
#endif
 
#if defined(STATS) || defined(DOXYGEN_RUN)
void ThreadPoolPrintStats(
    ThreadPoolStats* stats);
#else
static inline void ThreadPoolPrintStats(
    ThreadPoolStats* stats) {}
#endif
 
#endif /* COMPA_THREADPOOL_HPP */