ControlThread.h

 
#ifndef STAMINA_BUILDER_THREADS_CONTROLTHREAD_H
#define STAMINA_BUILDER_THREADS_CONTROLTHREAD_H
 
#include "BaseThread.h"
 
#include "storm/storage/BitVectorHashMap.h"
 
#include <deque>
 
namespace stamina {
    namespace builder {
        namespace threads {
            // The thread index of no exploration thread
            const uint8_t NO_THREAD = 0;
 
            // Forward-declare the exploration thread
            template <typename StateType, typename RewardModelType, typename ValueType>
            class ExplorationThread;
 
            template <typename StateType, typename RewardModelType, typename ValueType>
            class ControlThread : public BaseThread<StateType, RewardModelType, ValueType> {
            public:
                struct StateAndThreadIndex {
                    StateAndThreadIndex(StateType state, uint8_t thread) : state(state), thread(thread) {
                        // Intentionally left empty
                    }
                    StateType state; // State Index
                    uint8_t thread; // Thread index
                    // Cast to StateType
                    operator StateType() const {
                        return state;
                    }
                };
                class LockableDeque {
                public:
                    int size();
                    void emplace_back(StateType from, StateType to, double rate);
                    bool empty();
                    void lockThread();
                    void unlockThread();
                private:
                    std::deque<typename StaminaModelBuilder<ValueType, RewardModelType, StateType>::TransitionInfo> queue;
                    std::shared_mutex lock;
                };
 
                typedef typename ExplorationThread<StateType, RewardModelType, ValueType>::StateAndProbability StateAndProbability;
                ControlThread(
                    StaminaModelBuilder<ValueType, RewardModelType, StateType> * parent
                    , uint8_t numberExplorationThreads
//                  , storm::storage::sparse::StateStorage<uint8_t>& stateThreadMap // State storage owned by parents
                );
                std::pair<uint8_t, StateType> requestOwnership(CompressedState & state, uint8_t threadIndex, StateType requestedId = 0);
                uint8_t whoOwns(CompressedState & state);
                StateType whatIsIndex(CompressedState & state);
                void requestInsertTransition(
                    uint8_t thread
                    , StateType from
                    , StateType to
                    , double rate
                );
                void requestCrossExplorationFromThread(
                    StateAndProbability stateAndProbability
                    , double threadIndex
                );
                virtual void mainLoop() override;
                storm::storage::sparse::StateStorage<StateAndThreadIndex>& getStateStorage();
                void terminate();
            private:
                std::vector<LockableDeque> transitionQueues;
                std::shared_mutex ownershipMutex;
                const uint8_t numberExplorationThreads;
                storm::storage::sparse::StateStorage<uint8_t>& stateThreadMap;
                const std::vector<ExplorationThread<StateType, RewardModelType, ValueType>> explorationThreads;
            };
 
        } // namespace threads
    } // namespace builder
} // namespace stamina
 
#endif // STAMINA_BUILDER_THREADS_CONTROLTHREAD_H