UserControlledScheduler.h

Go to the documentation of this file.

 
#pragma once
#include <DeterministicConcurrency>
#include <cstddef>
#include <array>
#include <tuple>
#include <type_traits>
#include <chrono>
#include <thread>
 
namespace DeterministicConcurrency{
 
    template<size_t N>
    class UserControlledScheduler{
 
        struct emplace_t {};
 
        public:
 
        template <typename... Tuples>
        UserControlledScheduler(Tuples&&... tuples)
            : UserControlledScheduler{std::index_sequence_for<Tuples...>{},
                                static_cast<Tuples&&>(tuples)...} {}
 
        template<thread_status_t S, typename... Args>
        void waitUntilAllThreadStatus(Args&&... threadIndexes){
            for(size_t numThreads = 0; numThreads != sizeof...(threadIndexes);){
                std::this_thread::sleep_for(std::chrono::milliseconds(1));
                numThreads = 0;
                ([&]{
                    if (getThreadStatus(threadIndexes) == S)
                        numThreads++;
                }(),...);
            }
            return;
        }
 
        template<typename BasicLockable>
        static void waitUntilLocked(BasicLockable* lockable){
            while (lockable->try_lock()){
                lockable->unlock();
                std::this_thread::sleep_for(std::chrono::milliseconds(1));
            }
        }
 
        template<thread_status_t S, typename... Args>
        size_t waitUntilOneThreadStatus(Args&&... threadIndexes){
            size_t threadIndex = -1;
            for (;threadIndex == -1;){
                std::this_thread::sleep_for(std::chrono::milliseconds(1));
                ([&]{
                    if (getThreadStatus(threadIndexes) == S)
                        threadIndex = threadIndexes;
                }(),...);
            }
            return threadIndex;
        }
 
        template<typename... Args>
        void switchContextTo(Args&&... threadIndexes){
            ([&]{
                proceed(threadIndexes);
                wait(threadIndexes);
            }(),...);
        }
 
        void switchContextAll(){
            switchContextAll(std::make_index_sequence<N>());
        }
 
        template<typename... Args>
        void joinOn(Args&&... threadIndexes){
            static_assert(sizeof...(threadIndexes) <= N, "Too many args");
            (_threads[threadIndexes].join(), ...);
        }
 
        void joinAll(){
            for (auto& _thread : _threads)
                _thread.join();
        }
 
        template<typename... Args>
        void proceed(Args&&... threadIndexes){
            static_assert(sizeof...(threadIndexes) <= N, "Too many args");
            (_threads[threadIndexes].tick(), ...);
        }
 
        template<typename... Args>
        void wait(Args&&... threadIndexes){
            static_assert(sizeof...(threadIndexes) <= N, "Too many args");
            (_threads[threadIndexes].wait_for_tock(), ...);
        }
 
        thread_status_t getThreadStatus(size_t threadIndex){
            return _contexts[threadIndex].thread_status_v;
        }
 
        private:
 
        template <typename... Tuples>
        UserControlledScheduler(emplace_t, Tuples&&... tuples)
            : _threads{std::make_from_tuple<DeterministicThread>(tuples)...} {}
 
        template <typename... Tuples, std::size_t... Is>
        UserControlledScheduler(std::index_sequence<Is...>, Tuples&&... tuples)
            : UserControlledScheduler{
                emplace_t{}, std::tuple_cat(std::tuple{&std::get<Is>(_contexts)},
                                            static_cast<Tuples&&>(tuples))...} {}
 
 
        template <std::size_t... Is>
        void switchContextAll(std::index_sequence<Is...>){
            ([&]{
                proceed(Is);
                wait(Is);
            }(),...);
        }
 
        std::array<thread_context, N> _contexts;
        std::array<DeterministicThread, N> _threads;
    };
 
    template<typename... Tuples>
    auto make_UserControlledScheduler(Tuples&&... tuples) {
        return UserControlledScheduler<sizeof...(Tuples)>(static_cast<Tuples&&>(tuples)...);
    }
    
}