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