multi_threading_mgr.h

Go to the documentation of this file.

// Copyright (C) 2019-2022 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 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_;

    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