DeterministicThread.h

Go to the documentation of this file.

 
#pragma once
#include <DeterministicConcurrency>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <tuple>
 
namespace DeterministicConcurrency{
    enum class thread_status_t{
        RUNNING,
        WAITING,
        NOT_STARTED,
        FINISHED,
        WAITING_EXTERNAL
    };
 
    class DeterministicThread;
 
    class thread_context {
    public:
        thread_context() noexcept : control_mutex(), tick_tock(), thread_status_v(thread_status_t::NOT_STARTED) {}
 
        void switchContext(){
            tock();             
            wait_for_tick();    
        }
 
        template<typename BasicLockable, typename... Args>
        void lock(BasicLockable* lockable, Args&&... args){
 
            {
            std::lock_guard<std::mutex> lock(control_mutex);
            thread_status_v = DeterministicConcurrency::thread_status_t::WAITING_EXTERNAL;
            }
 
            lockable->lock(std::forward<Args>(args)...);
            
            {
            std::lock_guard<std::mutex> lock(control_mutex);
            thread_status_v = DeterministicConcurrency::thread_status_t::RUNNING;
            }
 
        }
 
        template<typename BasicLockable, typename... Args>
        void lock_shared(BasicLockable* lockable, Args&&... args){
 
            {
            std::lock_guard<std::mutex> lock(control_mutex);
            thread_status_v = DeterministicConcurrency::thread_status_t::WAITING_EXTERNAL;
            }
 
            lockable->lock_shared(std::forward<Args>(args)...);
            
            {
            std::lock_guard<std::mutex> lock(control_mutex);
            thread_status_v = DeterministicConcurrency::thread_status_t::RUNNING;
            }
 
        }
 
        private:
 
        friend class DeterministicThread;
 
        template<size_t N>
        friend class UserControlledScheduler;
 
        void start(){
            std::unique_lock<std::mutex> lock(control_mutex);
            while (thread_status_v == thread_status_t::NOT_STARTED)
                tick_tock.wait(lock);
        }
 
        void finish(){
            {
                std::unique_lock<std::mutex> lock(control_mutex);
                thread_status_v = thread_status_t::FINISHED;
            }
            tick_tock.notify_one();
        }
        
        void tock() {
            {
                std::unique_lock<std::mutex> lock(control_mutex);
                thread_status_v = thread_status_t::WAITING;
            }
            tick_tock.notify_one();
        }
 
        void wait_for_tick(){
            std::unique_lock<std::mutex> lock(control_mutex);
            while (thread_status_v == thread_status_t::WAITING)
                tick_tock.wait(lock);
        }
 
        std::condition_variable tick_tock;
        volatile thread_status_t thread_status_v;
        std::mutex control_mutex;
    };
 
    class DeterministicThread {
    public:
        template <typename Func, typename... Args>
        explicit DeterministicThread(thread_context* t ,Func&& func, Args&&... args)
            : _thread([function = std::forward<Func>(func), t, tuple = std::make_tuple(std::forward<Args>(args)...)]() mutable {
                t->start();
                std::apply(function, std::tuple_cat(std::make_tuple(t), tuple));
                t->finish();
            })
            , _this_thread(t) {}
 
        void join() {
            _thread.join();
        }
 
        void tick() {
            {
                std::unique_lock<std::mutex> lock(_this_thread->control_mutex);
                if (_this_thread->thread_status_v == thread_status_t::FINISHED)return;
                _this_thread->thread_status_v = thread_status_t::RUNNING;
            }
            _this_thread->tick_tock.notify_one();
        }
 
        void wait_for_tock(){
            std::unique_lock<std::mutex> lock(_this_thread->control_mutex);
            while (_this_thread->thread_status_v == thread_status_t::RUNNING)
                _this_thread->tick_tock.wait(lock);
        }
 
    private:
        thread_context* _this_thread;
        std::thread _thread;
    };
}