multi_threading_mgr.h

Go to the documentation of this file.

// Copyright (C) 2019-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 MULTI_THREADING_MGR_H
#define MULTI_THREADING_MGR_H
 
#include <util/thread_pool.h>
#include <functional>
#include <list>
 
#include <boost/noncopyable.hpp>
 
#include <stdint.h>
 
namespace isc {
namespace util {
 
 
struct CSCallbackSet {
    typedef std::function<void()> Callback;
 
    CSCallbackSet(const std::string& name, const Callback& check_cb,
                  const Callback& entry_cb, const Callback& exit_cb)
        : name_(name), check_cb_(check_cb), entry_cb_(entry_cb),
          exit_cb_(exit_cb) {}
 
    std::string name_;
 
    Callback check_cb_;
 
    Callback entry_cb_;
 
    Callback exit_cb_;
};
 
class CSCallbackSetList {
public:
    CSCallbackSetList() {}
 
    void addCallbackSet(const std::string& name,
                        const CSCallbackSet::Callback& check_cb,
                        const CSCallbackSet::Callback& entry_cb,
                        const CSCallbackSet::Callback& exit_cb);
 
    void removeCallbackSet(const std::string& name);
 
    void removeAll();
 
    const std::list<CSCallbackSet>& getCallbackSets();
 
private:
    std::list<CSCallbackSet> cb_sets_;
};
 
class MultiThreadingMgr : public boost::noncopyable {
public:
    static MultiThreadingMgr& instance();
 
    bool getMode() const;
 
    void setMode(bool enabled);
 
    void setTestMode(const bool test_mode) {
        test_mode_ = test_mode;
    }
 
    bool isTestMode() const {
        return (test_mode_);
    }
 
    void enterCriticalSection();
 
    void exitCriticalSection();
 
    bool isInCriticalSection();
 
    ThreadPool<std::function<void()>>& getThreadPool();
 
    uint32_t getThreadPoolSize() const;
 
    void setThreadPoolSize(uint32_t size);
 
    uint32_t getPacketQueueSize();
 
    void setPacketQueueSize(uint32_t size);
 
    static uint32_t detectThreadCount();
 
    void apply(bool enabled, uint32_t thread_count, uint32_t queue_size);
 
    void addCriticalSectionCallbacks(const std::string& name,
                                     const CSCallbackSet::Callback& check_cb,
                                     const CSCallbackSet::Callback& entry_cb,
                                     const CSCallbackSet::Callback& exit_cb);
 
    void removeCriticalSectionCallbacks(const std::string& name);
 
    void removeAllCriticalSectionCallbacks();
 
protected:
 
    MultiThreadingMgr();
 
    virtual ~MultiThreadingMgr();
 
private:
 
    void checkCallbacksPermissions();
 
    void callEntryCallbacks();
 
    void callExitCallbacks();
 
    bool enabled_;
 
    bool test_mode_;
 
    uint32_t critical_section_count_;
 
    uint32_t thread_pool_size_;
 
    ThreadPool<std::function<void()>> thread_pool_;
 
    CSCallbackSetList cs_callbacks_;
};
 
struct MultiThreadingLock {
    MultiThreadingLock(std::mutex& mutex);
 
private:
    std::unique_lock<std::mutex> lock_;
};
 
 
class MultiThreadingCriticalSection : public boost::noncopyable {
public:
 
    MultiThreadingCriticalSection();
 
    virtual ~MultiThreadingCriticalSection();
};
 
}  // namespace util
}  // namespace isc
 
#endif // MULTI_THREADING_MGR_H