worker_threads.hpp

Go to the documentation of this file.

/*
 * worker_threads.hpp
 *
 * It contains the definition of classes required for
 * the worker threads.
 *
 */
 
#ifndef WORKER_THREADS_HPP
#define WORKER_THREADS_HPP
 
#include <atomic>
#include <condition_variable>
#include <latch>
#include <list>
#include <mutex>
#include <thread>
#include <vector>
 
// The following classes are defined in this header file:
class CUControllerThreadGroupManager;
class CUControllerWorkerThread;
 
#include "global.h"
#include "units.h"
 
class CUControllerThreadGroupManager {
    private:
        friend class CUControllerWorkerThread;
 
    public:
        CUControllerThreadGroupManager(const std::vector<ControlUnit*>* subsection = NULL);
 
        ~CUControllerThreadGroupManager();
        //static void InitializeThreadGroupManager();
        
        void startAllWorkerThreads();
 
        void stopAllWorkerThreads();
 
        void executeOneStep(unsigned long ts/*, const std::vector<ControlUnit*>* subsection = NULL*/);
        
        bool waitForWorkersToFinish();
 
        ControlUnit* getNextControlUnit();
 
        // static void Vacuum();
 
    private:
        //bool initialized; /* = false */ ///< True, if the manager is already initialized
        std::vector<CUControllerWorkerThread*> worker_threads; 
        std::latch* all_workers_finished_latch;
        // only required if work stealing is used
        std::atomic<unsigned long> work_stealing_next_cuID; 
        std::mutex work_stealing_mtx; 
};
 
class CUControllerWorkerThread {
    public:
        CUControllerWorkerThread(const std::list<ControlUnit*>* connected_units_, CUControllerThreadGroupManager& caller);
        CUControllerWorkerThread(CUControllerThreadGroupManager& caller);
        ~CUControllerWorkerThread();
        void start(); 
        void stop(); 
 
        void executeOneStepForAllConnCUs(unsigned long ts/*, const std::vector<ControlUnit*>* subsection = NULL*/);
        
        bool isIdling() const { return atomic_flag_idling; }
 
        bool errorHappened() const { return error_happened; }
 
    private:
        CUControllerThreadGroupManager& thread_group_manager; 
        bool use_work_stealing; 
        std::vector<ControlUnit*> connected_units; 
        std::thread current_thread;
        std::mutex mtx; 
        std::condition_variable cv; 
        std::atomic<bool> atomic_flag_stop;    
        std::atomic<bool> atomic_flag_exec;    
        std::atomic<bool> atomic_flag_running; 
        std::atomic<bool> atomic_flag_idling;  
        //
        std::atomic<bool> error_happened;      
        //
        std::atomic<unsigned long> atomic_param_ts; 
        //
        void run(); 
};
 
#endif