thread_pool.h

Go to the documentation of this file.

// Copyright (C) 2018-2024 Internet Systems Consortium, Inc. ("ISC")
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
#ifndef THREAD_POOL_H
#define THREAD_POOL_H
 
#include <exceptions/exceptions.h>
#include <boost/make_shared.hpp>
#include <boost/shared_ptr.hpp>
 
#include <atomic>
#include <chrono>
#include <cmath>
#include <condition_variable>
#include <list>
#include <mutex>
#include <queue>
#include <thread>
 
#include <signal.h>
 
namespace isc {
namespace util {
 
template <typename WorkItem, typename Container = std::deque<boost::shared_ptr<WorkItem>>>
struct ThreadPool {
    static const double CEXP10;
 
    static const double CEXP100;
 
    static const double CEXP1000;
 
    typedef typename boost::shared_ptr<WorkItem> WorkItemPtr;
 
    ThreadPool() {
    }
 
    ~ThreadPool() {
        reset();
    }
 
    void reset() {
        stopInternal();
        queue_.clear();
    }
 
    void start(uint32_t thread_count) {
        if (!thread_count) {
            isc_throw(InvalidParameter, "thread count is 0");
        }
        if (queue_.enabled()) {
            isc_throw(InvalidOperation, "thread pool already started");
        }
        startInternal(thread_count);
    }
 
    void stop() {
        if (!queue_.enabled()) {
            isc_throw(InvalidOperation, "thread pool already stopped");
        }
        stopInternal();
    }
 
    bool add(const WorkItemPtr& item) {
        return (queue_.pushBack(item));
    }
 
    bool addFront(const WorkItemPtr& item) {
        return (queue_.pushFront(item));
    }
 
    size_t count() {
        return (queue_.count());
    }
 
    void wait() {
        auto id = std::this_thread::get_id();
        if (checkThreadId(id)) {
            isc_throw(MultiThreadingInvalidOperation, "thread pool wait called by worker thread");
        }
        queue_.wait();
    }
 
    bool wait(uint32_t seconds) {
        auto id = std::this_thread::get_id();
        if (checkThreadId(id)) {
            isc_throw(MultiThreadingInvalidOperation, "thread pool wait with timeout called by worker thread");
        }
        return (queue_.wait(seconds));
    }
 
    void pause(bool wait = true) {
        queue_.pause(wait);
    }
 
    void resume() {
        queue_.resume();
    }
 
    bool enabled() {
        return (queue_.enabled());
    }
 
    bool paused() {
        return (queue_.paused());
    }
 
    void setMaxQueueSize(size_t max_queue_size) {
        queue_.setMaxQueueSize(max_queue_size);
    }
 
    size_t getMaxQueueSize() {
        return (queue_.getMaxQueueSize());
    }
 
    size_t size() {
        return (threads_.size());
    }
 
    double getQueueStat(size_t which) {
        return (queue_.getQueueStat(which));
    }
 
private:
    void startInternal(uint32_t thread_count) {
        // Protect us against signals
        sigset_t sset;
        sigset_t osset;
        sigemptyset(&sset);
        sigaddset(&sset, SIGCHLD);
        sigaddset(&sset, SIGINT);
        sigaddset(&sset, SIGHUP);
        sigaddset(&sset, SIGTERM);
        pthread_sigmask(SIG_BLOCK, &sset, &osset);
        queue_.enable(thread_count);
        try {
            for (uint32_t i = 0; i < thread_count; ++i) {
                threads_.push_back(boost::make_shared<std::thread>(&ThreadPool::run, this));
            }
        } catch (...) {
            // Restore signal mask.
            pthread_sigmask(SIG_SETMASK, &osset, 0);
            throw;
        }
        // Restore signal mask.
        pthread_sigmask(SIG_SETMASK, &osset, 0);
    }
 
    void stopInternal() {
        auto id = std::this_thread::get_id();
        if (checkThreadId(id)) {
            isc_throw(MultiThreadingInvalidOperation, "thread pool stop called by worker thread");
        }
        queue_.disable();
        for (auto const& thread : threads_) {
            thread->join();
        }
        threads_.clear();
    }
 
    bool checkThreadId(std::thread::id id) {
        for (auto const& thread : threads_) {
            if (id == thread->get_id()) {
                return (true);
            }
        }
        return (false);
    }
 
    template <typename Item, typename QueueContainer = std::queue<Item>>
    struct ThreadPoolQueue {
        ThreadPoolQueue()
            : enabled_(false), paused_(false), max_queue_size_(0), working_(0),
              unavailable_(0), stat10(0.), stat100(0.), stat1000(0.) {
        }
 
        ~ThreadPoolQueue() {
            disable();
            clear();
        }
 
        void registerThread() {
            std::lock_guard<std::mutex> lock(mutex_);
            ++working_;
            --unavailable_;
        }
 
        void unregisterThread() {
            std::lock_guard<std::mutex> lock(mutex_);
            --working_;
            ++unavailable_;
        }
 
        void setMaxQueueSize(size_t max_queue_size) {
            std::lock_guard<std::mutex> lock(mutex_);
            max_queue_size_ = max_queue_size;
        }
 
        size_t getMaxQueueSize() {
            std::lock_guard<std::mutex> lock(mutex_);
            return (max_queue_size_);
        }
 
        bool pushBack(const Item& item) {
            bool ret = true;
            if (!item) {
                return (ret);
            }
            {
                std::lock_guard<std::mutex> lock(mutex_);
                if (max_queue_size_ != 0) {
                    while (queue_.size() >= max_queue_size_) {
                        queue_.pop_front();
                        ret = false;
                    }
                }
                queue_.push_back(item);
            }
            // Notify pop function so that it can effectively remove a work item.
            cv_.notify_one();
            return (ret);
        }
 
        bool pushFront(const Item& item) {
            if (!item) {
                return (true);
            }
            {
                std::lock_guard<std::mutex> lock(mutex_);
                if ((max_queue_size_ != 0) &&
                    (queue_.size() >= max_queue_size_)) {
                    return (false);
                }
                queue_.push_front(item);
            }
            // Notify pop function so that it can effectively remove a work item.
            cv_.notify_one();
            return (true);
        }
 
        Item pop() {
            std::unique_lock<std::mutex> lock(mutex_);
            --working_;
            // Signal thread waiting for threads to pause.
            if (paused_ && working_ == 0 && unavailable_ == 0) {
                wait_threads_cv_.notify_all();
            }
            // Signal thread waiting for tasks to finish.
            if (working_ == 0 && queue_.empty()) {
                wait_cv_.notify_all();
            }
            // Wait for push or disable functions.
            cv_.wait(lock, [&]() {return (!enabled_ || (!queue_.empty() && !paused_));});
            ++working_;
            if (!enabled_) {
                return (Item());
            }
            size_t length = queue_.size();
            stat10 = stat10 * CEXP10 + (1 - CEXP10) * length;
            stat100 = stat100 * CEXP100 + (1 - CEXP100) * length;
            stat1000 = stat1000 * CEXP1000 + (1 - CEXP1000) * length;
            Item item = queue_.front();
            queue_.pop_front();
            return (item);
        }
 
        size_t count() {
            std::lock_guard<std::mutex> lock(mutex_);
            return (queue_.size());
        }
 
        void wait() {
            std::unique_lock<std::mutex> lock(mutex_);
            // Wait for any item or for working threads to finish.
            wait_cv_.wait(lock, [&]() {return (working_ == 0 && queue_.empty());});
        }
 
        bool wait(uint32_t seconds) {
            std::unique_lock<std::mutex> lock(mutex_);
            // Wait for any item or for working threads to finish.
            bool ret = wait_cv_.wait_for(lock, std::chrono::seconds(seconds),
                                         [&]() {return (working_ == 0 && queue_.empty());});
            return (ret);
        }
 
        void pause(bool wait) {
            std::unique_lock<std::mutex> lock(mutex_);
            paused_ = true;
            if (wait) {
                // Wait for working threads to finish.
                wait_threads_cv_.wait(lock, [&]() {return (working_ == 0 && unavailable_ == 0);});
            }
        }
 
        void resume() {
            std::unique_lock<std::mutex> lock(mutex_);
            paused_ = false;
            cv_.notify_all();
        }
 
        double getQueueStat(size_t which) {
            std::lock_guard<std::mutex> lock(mutex_);
            switch (which) {
            case 10:
                return (stat10);
            case 100:
                return (stat100);
            case 1000:
                return (stat1000);
            default:
                isc_throw(InvalidParameter, "supported statistic for "
                          << "10/100/1000 only, not " << which);
            }
        }
 
        void clear() {
            std::lock_guard<std::mutex> lock(mutex_);
            queue_ = QueueContainer();
        }
 
        void enable(uint32_t thread_count) {
            std::lock_guard<std::mutex> lock(mutex_);
            enabled_ = true;
            unavailable_ = thread_count;
        }
 
        void disable() {
            {
                std::lock_guard<std::mutex> lock(mutex_);
                paused_ = false;
                enabled_ = false;
            }
            // Notify pop so that it can exit.
            cv_.notify_all();
        }
 
        bool enabled() {
            return (enabled_);
        }
 
        bool paused() {
            return (paused_);
        }
 
    private:
        QueueContainer queue_;
 
        std::mutex mutex_;
 
        std::condition_variable cv_;
 
        std::condition_variable wait_cv_;
 
        std::condition_variable wait_threads_cv_;
 
        std::atomic<bool> enabled_;
 
        std::atomic<bool> paused_;
 
        size_t max_queue_size_;
 
        uint32_t working_;
 
        uint32_t unavailable_;
 
        double stat10;
 
        double stat100;
 
        double stat1000;
    };
 
    void run() {
        queue_.registerThread();
        for (bool work = true; work; work = queue_.enabled()) {
            WorkItemPtr item = queue_.pop();
            if (item) {
                try {
                    (*item)();
                } catch (...) {
                    // catch all exceptions
                }
            }
        }
        queue_.unregisterThread();
    }
 
    std::vector<boost::shared_ptr<std::thread>> threads_;
 
    ThreadPoolQueue<WorkItemPtr, Container> queue_;
};
 
template <typename W, typename C>
const double ThreadPool<W, C>::CEXP10 = std::exp(-.1);
 
template <typename W, typename C>
const double ThreadPool<W, C>::CEXP100 = std::exp(-.01);
 
template <typename W, typename C>
const double ThreadPool<W, C>::CEXP1000 = std::exp(-.001);
 
}  // namespace util
}  // namespace isc
 
#endif  // THREAD_POOL_H