multi_threading_mgr.h

Go to the documentation of this file.

// Copyright (C) 2019-2021 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 CSCallbackPair {
    typedef std::function<void()> Callback;

    CSCallbackPair(const std::string& name, const Callback& entry_cb,
                   const Callback& exit_cb)
        : name_(name), entry_cb_(entry_cb), exit_cb_(exit_cb) {}

    std::string name_;

    Callback entry_cb_;

    Callback exit_cb_;
};

class CSCallbackPairList {
public:
    CSCallbackPairList() {}

    void addCallbackPair(const std::string& name,
                         const CSCallbackPair::Callback& entry_cb,
                         const CSCallbackPair::Callback& exit_cb);

    void removeCallbackPair(const std::string& name);

    void removeAll();

    const std::list<CSCallbackPair>& getCallbackPairs();

private:
    std::list<CSCallbackPair> cb_pairs_;
};

class MultiThreadingMgr : public boost::noncopyable {
public:

    static MultiThreadingMgr& instance();

    bool getMode() const;

    void setMode(bool enabled);

    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 CSCallbackPair::Callback& entry_cb,
                                     const CSCallbackPair::Callback& exit_cb);

    void removeCriticalSectionCallbacks(const std::string& name);

    void removeAllCriticalSectionCallbacks();

protected:

    MultiThreadingMgr();

    virtual ~MultiThreadingMgr();

private:

    void stopProcessing();

    void startProcessing();

    bool enabled_;

    uint32_t critical_section_count_;

    uint32_t thread_pool_size_;

    ThreadPool<std::function<void()>> thread_pool_;

    CSCallbackPairList cs_callbacks_;
};


class MultiThreadingCriticalSection : public boost::noncopyable {
public:

    MultiThreadingCriticalSection();

    virtual ~MultiThreadingCriticalSection();
};

}  // namespace util
}  // namespace isc

#endif // MULTI_THREADING_MGR_H